@prktsol/prkt 1.0.0

package/dist/scripts/runGaslessWalletDemo.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const env_1 = require("../config/env");
+const gaslessDemo_1 = require("../kora/gaslessDemo");
+const TokenWallet_1 = require("../spl/TokenWallet");
+const managedAgentWallet_1 = require("./managedAgentWallet");
+const shared_1 = require("./shared");
+const mode_1 = require("./mode");
+const DEFAULT_AGENT_NAME = "gasless-wallet-demo";
+async function main() {
+    const rpcUrl = (0, env_1.getRpcUrl)();
+    const usdcMintAddress = (0, env_1.getUsdcMintAddress)();
+    (0, env_1.assertMintMatchesRpcCluster)({
+        mintAddress: usdcMintAddress,
+        mintName: "USDC_MINT",
+        rpcUrl
+    });
+    const connection = new web3_js_1.Connection(rpcUrl, "confirmed");
+    const managed = (0, managedAgentWallet_1.resolveManagedAgentWallet)({
+        agentName: (0, managedAgentWallet_1.getManagedAgentName)({ defaultAgentName: DEFAULT_AGENT_NAME, env: process.env }),
+        ownerId: (0, managedAgentWallet_1.getManagedOwnerId)(process.env)
+    });
+    const walletManager = managed.walletManager;
+    const koraSigner = (0, shared_1.createKoraSigner)();
+    const usdcMint = new web3_js_1.PublicKey(usdcMintAddress);
+    const usdcAccount = TokenWallet_1.TokenWallet.findAssociatedTokenAddress(walletManager.publicKey, usdcMint);
+    const solLamports = await connection.getBalance(walletManager.publicKey, "confirmed");
+    const usdcAccountInfo = await connection.getAccountInfo(usdcAccount, "confirmed");
+    let usdcBalance = 0;
+    if (usdcAccountInfo) {
+        const tokenBalance = await connection.getTokenAccountBalance(usdcAccount, "confirmed");
+        usdcBalance = (0, gaslessDemo_1.parseUiAmount)(tokenBalance.value);
+    }
+    console.log("PRKT gasless wallet demo");
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    console.log(`USDC ATA: ${usdcAccount.toBase58()}`);
+    console.log(`Starting SOL balance (lamports): ${solLamports}`);
+    console.log(`Starting USDC balance: ${usdcBalance.toFixed(6)}`);
+    (0, gaslessDemo_1.assertGaslessDemoReadiness)({
+        solLamports,
+        usdcBalance
+    });
+    if ((0, env_1.isKoraMockMode)()) {
+        console.log("KORA_MOCK_MODE=true. The script will show the same fee-abstraction flow, but the signature is simulated.");
+    }
+    const result = await koraSigner.submitGaslessMemo(walletManager, "PRKT gasless agent check (USDC-backed fee abstraction)");
+    (0, mode_1.printDemoMode)(result.mock ? "SIMULATED" : "LIVE", "Gasless memo transport");
+    const endingSolLamports = await connection.getBalance(walletManager.publicKey, "confirmed");
+    console.log("Gasless execution complete.");
+    console.log(`Signature: ${result.signature}`);
+    console.log(`Mode: ${result.mock ? "mock" : "live"}`);
+    console.log(`Ending SOL balance (lamports): ${endingSolLamports}`);
+    console.log("Kora relayed the transaction while the wallet started at 0 SOL. For this demo, the relayer is expected to be configured to settle fees against the wallet's USDC liquidity.");
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Gasless wallet demo failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runKaminoDevnet.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const agentPolicies_1 = require("../config/agentPolicies");
+const env_1 = require("../config/env");
+const BalanceService_1 = require("../core/balances/BalanceService");
+const DevnetFundingService_1 = require("../core/funding/DevnetFundingService");
+const RpcClient_1 = require("../core/rpc/RpcClient");
+const TokenService_1 = require("../core/tokens/TokenService");
+const TransactionService_1 = require("../core/transactions/TransactionService");
+const kaminoLiveConfig_1 = require("../defi/kamino/kaminoLiveConfig");
+const protocols_1 = require("../defi/protocols");
+const liveExecutors_1 = require("../defi/universal/liveExecutors");
+const policy_1 = require("../policy");
+const managedAgentWallet_1 = require("./managedAgentWallet");
+const mode_1 = require("./mode");
+const DEFAULT_AGENT_NAME = "kamino-live-devnet";
+async function main() {
+    const action = parseAction(process.argv[2]);
+    (0, mode_1.printDemoMode)("LIVE", `Kamino ${action} transaction on configured cluster`);
+    const rpcClient = new RpcClient_1.RpcClient((0, env_1.getRpcUrl)(), "confirmed");
+    const transactionService = new TransactionService_1.TransactionService(rpcClient);
+    const tokenService = new TokenService_1.TokenService(rpcClient);
+    const balanceService = new BalanceService_1.BalanceService(rpcClient, tokenService);
+    const fundingService = new DevnetFundingService_1.DevnetFundingService(rpcClient, transactionService);
+    const config = (0, kaminoLiveConfig_1.loadKaminoLiveConfig)();
+    const managed = (0, managedAgentWallet_1.resolveManagedAgentWallet)({
+        agentName: (0, managedAgentWallet_1.getManagedAgentName)({
+            defaultAgentName: DEFAULT_AGENT_NAME,
+            env: process.env
+        }),
+        ownerId: (0, managedAgentWallet_1.getManagedOwnerId)(process.env)
+    });
+    const walletManager = managed.walletManager;
+    await (0, managedAgentWallet_1.ensureManagedAgentWalletFunding)({
+        balanceService,
+        fundingService,
+        minimumSol: action === "deposit"
+            ? Number(config.actions.depositAmountRaw) / web3_js_1.LAMPORTS_PER_SOL + 0.05
+            : 0.05,
+        publicKey: walletManager.publicKey
+    });
+    const prepared = await (0, liveExecutors_1.prepareLiveKamino)({
+        intent: {
+            action,
+            amountLamports: 0,
+            marketId: protocols_1.PROTOCOL_PRESETS.kamino.defaultMarketId,
+            memo: `LIVE:KAMINO:${action}`,
+            protocol: "kamino",
+            slippageBps: 40
+        },
+        logger: (message) => console.log(`[kamino-live] ${message}`),
+        walletManager
+    });
+    if (!prepared) {
+        throw new Error("Kamino live execution was not prepared. Check ENABLE_LIVE_KAMINO and config.");
+    }
+    const policyEngine = new policy_1.PolicyEngine((0, agentPolicies_1.createDefaultPolicyConfig)({
+        allowOpaqueProgramIds: prepared.policyConfigPatch?.rules?.allowOpaqueProgramIds,
+        agentId: managed.agent.name,
+        allowedCloseAccountDestinations: prepared.policyConfigPatch?.rules?.allowedCloseAccountDestinations,
+        approvalMode: "sandbox",
+        extraAllowedProgramIds: prepared.policyConfigPatch?.rules?.allowedProgramIds ?? [config.programId]
+    }));
+    const sandboxExecutor = new policy_1.SandboxExecutor(policyEngine, transactionService, "sandbox");
+    console.log("PRKT Kamino live demo");
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    console.log(`Market: ${config.marketAddress}`);
+    console.log(`Program: ${config.programId}`);
+    console.log(`Action: ${action}`);
+    console.log(`Amount (raw): ${action === "deposit" ? config.actions.depositAmountRaw : config.actions.borrowAmountRaw}`);
+    const execution = await sandboxExecutor.executePreparedTransaction({
+        confirmationStrategy: prepared.confirmationStrategy,
+        inspectionContext: prepared.inspectionContext,
+        transaction: prepared.transaction
+    });
+    if (!execution.signature) {
+        const simulationLogs = execution.simulationLogs?.join(" | ");
+        throw new Error(`Guarded Kamino execution blocked: ${summarizeKaminoFailure(execution.inspection.reasons.join("; "), simulationLogs) ||
+            "unknown reason"}${simulationLogs ? ` | simulation logs: ${simulationLogs}` : ""}`);
+    }
+    if (prepared.verifyExecution) {
+        await prepared.verifyExecution(execution.signature);
+    }
+    console.log(`Transaction signature: ${execution.signature}`);
+}
+function parseAction(rawValue) {
+    if (!rawValue || rawValue === "deposit") {
+        return "deposit";
+    }
+    if (rawValue === "borrow") {
+        return "borrow";
+    }
+    throw new Error(`Unsupported action '${rawValue}'. Use 'deposit' or 'borrow'.`);
+}
+function summarizeKaminoFailure(reason, simulationLogs) {
+    if (simulationLogs?.includes("ReserveStale")) {
+        return "reserve refresh is currently broken on the selected devnet market";
+    }
+    if (simulationLogs?.includes("InvalidOracleConfig")) {
+        return "the selected devnet market has invalid oracle configuration";
+    }
+    return reason;
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Kamino live demo failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runLpStrategy.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DeFiCoordinator_1 = require("../defi/DeFiCoordinator");
+const managedAgentWallet_1 = require("./managedAgentWallet");
+const shared_1 = require("./shared");
+const mode_1 = require("./mode");
+const DEFAULT_AGENT_NAME = "lp-strategy";
+async function main() {
+    (0, mode_1.printDemoMode)("SIMULATED", "Protocol intent only (memo execution), not live Raydium LP instructions");
+    const managed = (0, managedAgentWallet_1.resolveManagedAgentWallet)({
+        agentName: (0, managedAgentWallet_1.getManagedAgentName)({ defaultAgentName: DEFAULT_AGENT_NAME, env: process.env }),
+        ownerId: (0, managedAgentWallet_1.getManagedOwnerId)(process.env)
+    });
+    const coordinator = new DeFiCoordinator_1.DeFiCoordinator(managed.walletManager, (0, shared_1.createKoraSigner)(), (0, shared_1.createRuntimeLogger)("lp"));
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    const result = await coordinator.runLiquidityStrategy({
+        liquidityInRange: true
+    });
+    console.log("LP strategy complete.");
+    if (!result) {
+        console.log("No liquidity action executed.");
+        return;
+    }
+    console.log(`Protocol: ${result.protocol}`);
+    console.log(`Action: ${result.action}`);
+    console.log(`Signature: ${result.signature}`);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`LP strategy failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runMarinadeDevnet.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const agentPolicies_1 = require("../config/agentPolicies");
+const env_1 = require("../config/env");
+const BalanceService_1 = require("../core/balances/BalanceService");
+const DevnetFundingService_1 = require("../core/funding/DevnetFundingService");
+const RpcClient_1 = require("../core/rpc/RpcClient");
+const TokenService_1 = require("../core/tokens/TokenService");
+const TransactionService_1 = require("../core/transactions/TransactionService");
+const protocols_1 = require("../defi/protocols");
+const liveExecutors_1 = require("../defi/universal/liveExecutors");
+const policy_1 = require("../policy");
+const managedAgentWallet_1 = require("./managedAgentWallet");
+const mode_1 = require("./mode");
+const DEFAULT_AGENT_NAME = "marinade-live-devnet";
+async function main() {
+    const amountLamports = parseAmountLamports(process.argv[2]);
+    (0, mode_1.printDemoMode)("LIVE", `Marinade staking transaction on configured cluster (${amountLamports} lamports)`);
+    const rpcUrl = (0, env_1.getRpcUrl)();
+    const cluster = (0, env_1.detectClusterFromRpcUrl)(rpcUrl);
+    if (cluster !== "devnet") {
+        throw new Error(`Marinade live demo requires devnet. Current RPC cluster is ${cluster} (${rpcUrl}).`);
+    }
+    const rpcClient = new RpcClient_1.RpcClient(rpcUrl, "confirmed");
+    const tokenService = new TokenService_1.TokenService(rpcClient);
+    const balanceService = new BalanceService_1.BalanceService(rpcClient, tokenService);
+    const transactionService = new TransactionService_1.TransactionService(rpcClient);
+    const fundingService = new DevnetFundingService_1.DevnetFundingService(rpcClient, transactionService);
+    const managed = (0, managedAgentWallet_1.resolveManagedAgentWallet)({
+        agentName: (0, managedAgentWallet_1.getManagedAgentName)({
+            defaultAgentName: DEFAULT_AGENT_NAME,
+            env: process.env
+        }),
+        ownerId: (0, managedAgentWallet_1.getManagedOwnerId)(process.env)
+    });
+    const walletManager = managed.walletManager;
+    await (0, managedAgentWallet_1.ensureManagedAgentWalletFunding)({
+        balanceService,
+        fundingService,
+        minimumSol: amountLamports / web3_js_1.LAMPORTS_PER_SOL + 0.05,
+        publicKey: walletManager.publicKey
+    });
+    const prepared = await (0, liveExecutors_1.prepareLiveMarinade)({
+        intent: {
+            action: "stake",
+            amountLamports,
+            marketId: protocols_1.PROTOCOL_PRESETS.marinade.defaultMarketId,
+            memo: `LIVE:MARINADE:stake:${amountLamports}`,
+            protocol: "marinade",
+            slippageBps: 25
+        },
+        logger: (message) => console.log(`[marinade-live] ${message}`),
+        walletManager
+    });
+    if (!prepared) {
+        throw new Error("Marinade live execution was not prepared. Check ENABLE_LIVE_MARINADE and your RPC cluster.");
+    }
+    const policyEngine = new policy_1.PolicyEngine((0, agentPolicies_1.createDefaultPolicyConfig)({
+        agentId: managed.agent.name,
+        allowOpaqueProgramIds: prepared.policyConfigPatch?.rules?.allowOpaqueProgramIds,
+        approvalMode: "sandbox",
+        extraAllowedProgramIds: prepared.policyConfigPatch?.rules?.allowedProgramIds
+    }));
+    const sandboxExecutor = new policy_1.SandboxExecutor(policyEngine, transactionService, "sandbox");
+    console.log("PRKT Marinade live demo");
+    console.log(`RPC: ${rpcUrl}`);
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    console.log(`Amount (lamports): ${amountLamports}`);
+    const execution = await sandboxExecutor.executePreparedTransaction({
+        confirmationStrategy: prepared.confirmationStrategy,
+        inspectionContext: prepared.inspectionContext,
+        transaction: prepared.transaction
+    });
+    if (!execution.signature) {
+        throw new Error(`Guarded Marinade execution blocked: ${execution.inspection.reasons.join("; ") || "unknown reason"}`);
+    }
+    if (prepared.verifyExecution) {
+        await prepared.verifyExecution(execution.signature);
+    }
+    console.log(`Transaction signature: ${execution.signature}`);
+}
+function parseAmountLamports(rawValue) {
+    if (!rawValue) {
+        return Math.round(0.15 * web3_js_1.LAMPORTS_PER_SOL);
+    }
+    const sol = Number(rawValue);
+    if (!Number.isFinite(sol) || sol <= 0) {
+        throw new Error(`Invalid SOL amount '${rawValue}'. Provide a positive decimal SOL amount.`);
+    }
+    return Math.round(sol * web3_js_1.LAMPORTS_PER_SOL);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Marinade live demo failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runOrcaLpDevnet.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_sdk_1 = require("@orca-so/common-sdk");
+const whirlpools_sdk_1 = require("@orca-so/whirlpools-sdk");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const agentPolicies_1 = require("../config/agentPolicies");
+const env_1 = require("../config/env");
+const BalanceService_1 = require("../core/balances/BalanceService");
+const DevnetFundingService_1 = require("../core/funding/DevnetFundingService");
+const RpcClient_1 = require("../core/rpc/RpcClient");
+const TokenService_1 = require("../core/tokens/TokenService");
+const TransactionService_1 = require("../core/transactions/TransactionService");
+const policy_1 = require("../policy");
+const managedAgentWallet_1 = require("./managedAgentWallet");
+const mode_1 = require("./mode");
+const DEFAULT_AGENT_NAME = "orca-live-devnet";
+const DEFAULT_LP_SOL = 0.05;
+const MINIMUM_SOL_BALANCE = 0.25;
+const ORCA_DEVNET_PROGRAM_ID = new web3_js_1.PublicKey("whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc");
+const ORCA_DEVNET_CONFIG = new web3_js_1.PublicKey("FcrweFY1G9HJAHG5inkGB6pKg1HZ6x9UC2WioAfWrGkR");
+const ORCA_DEVNET_CONFIG_EXTENSION = new web3_js_1.PublicKey("475EJ7JqnRpVLoFVzp2ruEYvWWMCf6Z8KMWRujtXXNSU");
+const ORCA_DEVNET_USDC_MINT = new web3_js_1.PublicKey("BRjpCHtyQLNCo8gqRUr8jtdAj5AjPYQaoqbvcZiHok1k");
+const ORCA_DEVNET_TICK_SPACING = 64;
+async function main() {
+    const depositAmountSol = parseAmountSol(process.argv[2]);
+    (0, mode_1.printDemoMode)("LIVE", `Orca Whirlpool LP demo on devnet (${depositAmountSol.toFixed(4)} SOL one-sided deposit)`);
+    const rpcUrl = (0, env_1.getRpcUrl)();
+    const cluster = (0, env_1.detectClusterFromRpcUrl)(rpcUrl);
+    if (cluster !== "devnet") {
+        throw new Error(`Orca LP demo requires devnet. Current RPC cluster is ${cluster} (${rpcUrl}).`);
+    }
+    const rpcClient = new RpcClient_1.RpcClient(rpcUrl, "confirmed");
+    const tokenService = new TokenService_1.TokenService(rpcClient);
+    const balanceService = new BalanceService_1.BalanceService(rpcClient, tokenService);
+    const transactionService = new TransactionService_1.TransactionService(rpcClient);
+    const fundingService = new DevnetFundingService_1.DevnetFundingService(rpcClient, transactionService);
+    const managed = (0, managedAgentWallet_1.resolveManagedAgentWallet)({
+        agentName: (0, managedAgentWallet_1.getManagedAgentName)({
+            defaultAgentName: DEFAULT_AGENT_NAME,
+            env: process.env
+        }),
+        ownerId: (0, managedAgentWallet_1.getManagedOwnerId)(process.env)
+    });
+    const walletManager = managed.walletManager;
+    console.log("PRKT Orca devnet LP demo");
+    console.log(`RPC: ${rpcUrl}`);
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    console.log(`Orca program: ${ORCA_DEVNET_PROGRAM_ID.toBase58()}`);
+    console.log(`Orca config: ${ORCA_DEVNET_CONFIG.toBase58()}`);
+    console.log(`Orca config extension: ${ORCA_DEVNET_CONFIG_EXTENSION.toBase58()}`);
+    await (0, managedAgentWallet_1.ensureManagedAgentWalletFunding)({
+        balanceService,
+        fundingService,
+        minimumSol: MINIMUM_SOL_BALANCE,
+        publicKey: walletManager.publicKey
+    });
+    const orcaWallet = new common_sdk_1.ReadOnlyWallet(walletManager.publicKey);
+    const whirlpoolContext = whirlpools_sdk_1.WhirlpoolContext.from(rpcClient.connection, orcaWallet);
+    const whirlpoolClient = (0, whirlpools_sdk_1.buildWhirlpoolClient)(whirlpoolContext);
+    const whirlpool = await loadSupportedDevnetPool(whirlpoolClient);
+    const poolData = whirlpool.getData();
+    const poolAddress = whirlpool.getAddress();
+    const tokenA = whirlpool.getTokenAInfo();
+    const tokenB = whirlpool.getTokenBInfo();
+    if (whirlpools_sdk_1.TickUtil.isFullRangeOnly(poolData.tickSpacing)) {
+        throw new Error(`Configured Orca pool ${poolAddress.toBase58()} is full-range only (tick spacing ${poolData.tickSpacing}).`);
+    }
+    const { sideDescription, tickLowerIndex, tickUpperIndex } = deriveOneSidedPositionRange({
+        currentTickIndex: poolData.tickCurrentIndex,
+        nativeIsTokenA: tokenA.mint.equals(spl_token_1.NATIVE_MINT),
+        tickSpacing: poolData.tickSpacing
+    });
+    const tokenExtensionContext = await whirlpools_sdk_1.TokenExtensionUtil.buildTokenExtensionContextForPool(whirlpoolClient.getFetcher(), tokenA.mint, tokenB.mint);
+    const quote = (0, whirlpools_sdk_1.increaseLiquidityQuoteByInputTokenUsingPriceDeviation)(spl_token_1.NATIVE_MINT, new decimal_js_1.default(depositAmountSol.toString()), tickLowerIndex, tickUpperIndex, common_sdk_1.Percentage.fromFraction(1, 100), whirlpool, tokenExtensionContext);
+    if (quote.liquidityAmount.isZero()) {
+        throw new Error(`Orca quote returned zero liquidity for pool ${poolAddress.toBase58()}. Try a different amount or RPC.`);
+    }
+    const policyEngine = new policy_1.PolicyEngine((0, agentPolicies_1.createDefaultPolicyConfig)({
+        agentId: managed.agent.name,
+        allowOpaqueProgramIds: [ORCA_DEVNET_PROGRAM_ID.toBase58()],
+        allowedCloseAccountDestinations: [walletManager.publicKey.toBase58()],
+        approvalMode: "sandbox",
+        extraAllowedProgramIds: [ORCA_DEVNET_PROGRAM_ID.toBase58()]
+    }));
+    const sandboxExecutor = new policy_1.SandboxExecutor(policyEngine, transactionService, "sandbox");
+    console.log(`Pool: ${poolAddress.toBase58()}`);
+    console.log(`Pool tick spacing: ${poolData.tickSpacing}`);
+    console.log(`Pool token A: ${tokenA.mint.toBase58()}`);
+    console.log(`Pool token B: ${tokenB.mint.toBase58()}`);
+    console.log(`Current tick: ${poolData.tickCurrentIndex}`);
+    console.log(`Range: [${tickLowerIndex}, ${tickUpperIndex}] (${sideDescription})`);
+    console.log(`Estimated token max A: ${quote.tokenMaxA.toString()}`);
+    console.log(`Estimated token max B: ${quote.tokenMaxB.toString()}`);
+    const initTickArrays = await whirlpool.initTickArrayForTicks([tickLowerIndex, tickUpperIndex], walletManager.publicKey);
+    if (initTickArrays && !initTickArrays.isEmpty()) {
+        const tickArraySignature = await executeBuilder({
+            builder: initTickArrays,
+            label: "initialize Orca tick arrays",
+            sandboxExecutor,
+            walletManager
+        });
+        console.log(`Tick array init signature: ${tickArraySignature}`);
+    }
+    const { positionMint, tx } = await whirlpool.openPosition(tickLowerIndex, tickUpperIndex, quote, walletManager.publicKey, walletManager.publicKey);
+    const lpSignature = await executeBuilder({
+        builder: tx,
+        label: "open Orca position",
+        sandboxExecutor,
+        walletManager
+    });
+    const positionTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(positionMint, walletManager.publicKey);
+    const positionTokenBalance = await readPositionTokenBalance(positionTokenAccount, rpcClient);
+    if (positionTokenBalance !== 1n) {
+        throw new Error(`Orca position verification failed: expected 1 position token, got ${positionTokenBalance.toString()}.`);
+    }
+    const solAfter = await balanceService.getSolBalance(walletManager.publicKey);
+    console.log(`Position mint: ${positionMint.toBase58()}`);
+    console.log(`Position token account: ${positionTokenAccount.toBase58()}`);
+    console.log(`Transaction signature: ${lpSignature}`);
+    console.log(`SOL after execution: ${solAfter.toFixed(4)}`);
+}
+async function loadSupportedDevnetPool(whirlpoolClient) {
+    const candidates = [
+        whirlpools_sdk_1.PDAUtil.getWhirlpool(ORCA_DEVNET_PROGRAM_ID, ORCA_DEVNET_CONFIG, spl_token_1.NATIVE_MINT, ORCA_DEVNET_USDC_MINT, ORCA_DEVNET_TICK_SPACING).publicKey,
+        whirlpools_sdk_1.PDAUtil.getWhirlpool(ORCA_DEVNET_PROGRAM_ID, ORCA_DEVNET_CONFIG, ORCA_DEVNET_USDC_MINT, spl_token_1.NATIVE_MINT, ORCA_DEVNET_TICK_SPACING).publicKey
+    ];
+    for (const address of candidates) {
+        try {
+            return await whirlpoolClient.getPool(address);
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error(`Could not load the public Orca devnet SOL/devUSDC concentrated pool (tick spacing ${ORCA_DEVNET_TICK_SPACING}).`);
+}
+function deriveOneSidedPositionRange(input) {
+    const [minTick, maxTick] = whirlpools_sdk_1.TickUtil.getFullRangeTickIndex(input.tickSpacing);
+    const currentTickIndex = whirlpools_sdk_1.TickUtil.getInitializableTickIndex(input.currentTickIndex, input.tickSpacing);
+    const width = input.tickSpacing * 128;
+    const gap = input.tickSpacing * 64;
+    if (input.nativeIsTokenA) {
+        const tickLowerIndex = Math.min(Math.max(currentTickIndex + gap, minTick), maxTick - width);
+        return {
+            sideDescription: "one-sided SOL above current price",
+            tickLowerIndex,
+            tickUpperIndex: tickLowerIndex + width
+        };
+    }
+    const tickUpperIndex = Math.max(Math.min(currentTickIndex - gap, maxTick), minTick + width);
+    return {
+        sideDescription: "one-sided SOL below current price",
+        tickLowerIndex: tickUpperIndex - width,
+        tickUpperIndex
+    };
+}
+async function executeBuilder(input) {
+    const payload = await input.builder.build({
+        maxSupportedTransactionVersion: 0
+    });
+    if (!(payload.transaction instanceof web3_js_1.VersionedTransaction)) {
+        throw new Error(`${input.label} did not build a versioned transaction.`);
+    }
+    if (payload.signers.length > 0) {
+        payload.transaction.sign(payload.signers);
+    }
+    const signedTransaction = await input.walletManager.signTransaction(payload.transaction);
+    const execution = await input.sandboxExecutor.executePreparedTransaction({
+        confirmationStrategy: {
+            blockhash: payload.recentBlockhash.blockhash,
+            lastValidBlockHeight: payload.recentBlockhash.lastValidBlockHeight,
+            signature: ""
+        },
+        transaction: signedTransaction
+    });
+    if (!execution.signature) {
+        throw new Error(`${input.label} was blocked: ${execution.inspection.reasons.join("; ") || "unknown reason"}`);
+    }
+    return execution.signature;
+}
+async function readPositionTokenBalance(tokenAccount, rpcClient) {
+    const accountInfo = await rpcClient.getAccountInfo(tokenAccount, "confirmed");
+    if (!accountInfo) {
+        return 0n;
+    }
+    const balance = await rpcClient.getTokenAccountBalance(tokenAccount, "confirmed");
+    return BigInt(balance.value.amount);
+}
+function parseAmountSol(rawValue) {
+    if (!rawValue) {
+        return DEFAULT_LP_SOL;
+    }
+    const parsed = Number(rawValue);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`Invalid SOL amount '${rawValue}'. Provide a positive decimal SOL amount.`);
+    }
+    return parsed;
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Orca LP devnet demo failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runRaydiumLpDevnet.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const agentPolicies_1 = require("../config/agentPolicies");
+const env_1 = require("../config/env");
+const RpcClient_1 = require("../core/rpc/RpcClient");
+const PostTransactionVerifier_1 = require("../core/transactions/PostTransactionVerifier");
+const TransactionService_1 = require("../core/transactions/TransactionService");
+const TokenService_1 = require("../core/tokens/TokenService");
+const RaydiumAdapter_1 = require("../defi/adapters/RaydiumAdapter");
+const raydiumDevnetConfig_1 = require("../defi/lp/raydiumDevnetConfig");
+const policy_1 = require("../policy");
+const WalletManager_1 = require("../wallet/WalletManager");
+const mode_1 = require("./mode");
+async function main() {
+    (0, mode_1.printDemoMode)("LIVE", "Real Raydium add-liquidity transaction on configured cluster");
+    const walletManager = WalletManager_1.WalletManager.loadOrGenerate();
+    const connection = new web3_js_1.Connection((0, env_1.getRpcUrl)(), "confirmed");
+    const rpcClient = new RpcClient_1.RpcClient((0, env_1.getRpcUrl)(), "confirmed");
+    const tokenService = new TokenService_1.TokenService(rpcClient);
+    const verifier = new PostTransactionVerifier_1.PostTransactionVerifier(rpcClient, tokenService);
+    const transactionService = new TransactionService_1.TransactionService(rpcClient);
+    const config = (0, raydiumDevnetConfig_1.loadRaydiumLpDevnetConfig)();
+    const adapter = new RaydiumAdapter_1.RaydiumAdapter();
+    const requiredAccounts = [
+        config.poolConfig.poolId,
+        config.poolConfig.authority,
+        config.poolConfig.baseVault,
+        config.poolConfig.quoteVault,
+        config.poolConfig.openOrders,
+        config.poolConfig.targetOrders,
+        config.poolConfig.marketId,
+        config.poolConfig.marketEventQueue,
+        config.poolConfig.lpMint,
+        config.userTokenAccounts.baseTokenAccount,
+        config.userTokenAccounts.quoteTokenAccount,
+        config.userTokenAccounts.lpTokenAccount
+    ];
+    const accountInfos = await connection.getMultipleAccountsInfo(requiredAccounts.map((key) => new web3_js_1.PublicKey(key)), "confirmed");
+    const missingAccounts = requiredAccounts.filter((_, index) => accountInfos[index] === null);
+    if (missingAccounts.length > 0) {
+        throw new Error(`The following configured accounts do not exist on the selected cluster: ${missingAccounts.join(", ")}`);
+    }
+    const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+    const lpBalanceSnapshot = await verifier.snapshotSplTokenAccount({
+        label: "Raydium LP token balance",
+        mint: new web3_js_1.PublicKey(config.poolConfig.lpMint),
+        tokenAccount: new web3_js_1.PublicKey(config.userTokenAccounts.lpTokenAccount)
+    });
+    const transaction = await adapter.buildAddLiquidityTransactionDraft({
+        baseAmountIn: config.amounts.baseAmountIn,
+        otherAmountMin: config.amounts.otherAmountMin,
+        owner: walletManager,
+        poolConfig: config.poolConfig,
+        quoteAmountIn: config.amounts.quoteAmountIn,
+        recentBlockhash: latestBlockhash.blockhash,
+        userTokenAccounts: config.userTokenAccounts
+    });
+    const policyEngine = new policy_1.PolicyEngine((0, agentPolicies_1.createDefaultPolicyConfig)({
+        allowOpaqueProgramIds: [config.poolConfig.programId],
+        agentId: "raydium-live-devnet-script",
+        approvalMode: "sandbox",
+        extraAllowedProgramIds: [config.poolConfig.programId]
+    }));
+    const sandboxExecutor = new policy_1.SandboxExecutor(policyEngine, transactionService, "sandbox");
+    console.log("PRKT Raydium devnet LP demo");
+    console.log(`Wallet: ${walletManager.publicKey.toBase58()}`);
+    console.log(`Pool: ${config.poolConfig.poolId}`);
+    console.log(`Base amount in: ${config.amounts.baseAmountIn}`);
+    console.log(`Quote amount in: ${config.amounts.quoteAmountIn}`);
+    const execution = await sandboxExecutor.executePreparedTransaction({
+        confirmationStrategy: {
+            blockhash: latestBlockhash.blockhash,
+            lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+            signature: ""
+        },
+        transaction
+    });
+    if (!execution.signature) {
+        throw new Error(`Guarded Raydium execution blocked: ${execution.inspection.reasons.join("; ") || "unknown reason"}`);
+    }
+    const [verification] = await verifier.assertBalanceChanges([
+        {
+            minIncreaseRaw: 1n,
+            snapshot: lpBalanceSnapshot
+        }
+    ]);
+    console.log(`Transaction signature: ${execution.signature}`);
+    console.log(`Verification: ${verification.label} ${verification.beforeUi} -> ${verification.afterUi} (${verification.deltaUi})`);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Raydium LP devnet demo failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runReleaseReadiness.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const releaseReadiness_1 = require("./releaseReadiness");
+function main() {
+    console.log("PRKT release readiness check");
+    const checks = (0, releaseReadiness_1.runReadinessChecks)();
+    let failures = 0;
+    for (const check of checks) {
+        const marker = check.ok ? "PASS" : "FAIL";
+        console.log(`[${marker}] ${check.title} -> ${check.detail}`);
+        if (!check.ok) {
+            failures += 1;
+        }
+    }
+    if (failures > 0) {
+        console.error(`Release readiness failed with ${failures} failing check(s).`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log("Release readiness passed.");
+}
+main();

package/dist/scripts/runStakeStrategy.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const DeFiCoordinator_1 = require("../defi/DeFiCoordinator");
+const managedAgentWallet_1 = require("./managedAgentWallet");
+const shared_1 = require("./shared");
+const mode_1 = require("./mode");
+const DEFAULT_AGENT_NAME = "stake-strategy";
+async function main() {
+    (0, mode_1.printDemoMode)("SIMULATED", "Protocol intent only (memo execution), not live Marinade instructions");
+    const managed = (0, managedAgentWallet_1.resolveManagedAgentWallet)({
+        agentName: (0, managedAgentWallet_1.getManagedAgentName)({ defaultAgentName: DEFAULT_AGENT_NAME, env: process.env }),
+        ownerId: (0, managedAgentWallet_1.getManagedOwnerId)(process.env)
+    });
+    const coordinator = new DeFiCoordinator_1.DeFiCoordinator(managed.walletManager, (0, shared_1.createKoraSigner)(), (0, shared_1.createRuntimeLogger)("stake"));
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    const result = await coordinator.runStakingStrategy({
+        idleSolLamports: Math.round(0.8 * web3_js_1.LAMPORTS_PER_SOL)
+    });
+    console.log("Staking strategy complete.");
+    if (!result) {
+        console.log("No staking action executed.");
+        return;
+    }
+    console.log(`Protocol: ${result.protocol}`);
+    console.log(`Action: ${result.action}`);
+    console.log(`Signature: ${result.signature}`);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Staking strategy failed: ${message}`);
+    process.exitCode = 1;
+});