@prktsol/prkt 1.0.0

package/dist/scripts/runAutonomousPortfolioDevnet.js

@@ -0,0 +1,390 @@
+"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 MockPriceFeed_1 = require("../agent/MockPriceFeed");
+const AgentRuntime_1 = require("../agent/AgentRuntime");
+const policyFactory_1 = require("../agent/policyFactory");
+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 DeFiExecutor_1 = require("../defi/DeFiExecutor");
+const kaminoLiveConfig_1 = require("../defi/kamino/kaminoLiveConfig");
+const protocols_1 = require("../defi/protocols");
+const liveExecutors_1 = require("../defi/universal/liveExecutors");
+const PolicyGuard_1 = require("../policy/PolicyGuard");
+const policy_1 = require("../policy");
+const shared_1 = require("./shared");
+const managedAgentWallet_1 = require("./managedAgentWallet");
+const mode_1 = require("./mode");
+const DEFAULT_AGENT_NAME = "autonomous-portfolio-devnet";
+const REQUIRED_FUNDING_SOL = 1.0;
+const DEFAULT_SWAP_SOL = 0.01;
+const DEFAULT_ORCA_LP_SOL = 0.05;
+const ORCA_DEVNET_PROGRAM_ID = new web3_js_1.PublicKey("whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc");
+const ORCA_DEVNET_CONFIG = new web3_js_1.PublicKey("FcrweFY1G9HJAHG5inkGB6pKg1HZ6x9UC2WioAfWrGkR");
+const ORCA_DEVNET_USDC_MINT = new web3_js_1.PublicKey("BRjpCHtyQLNCo8gqRUr8jtdAj5AjPYQaoqbvcZiHok1k");
+const ORCA_DEVNET_TICK_SPACING = 64;
+async function main() {
+    (0, mode_1.printDemoMode)("LIVE", "Autonomous portfolio wallet: provision or load the assigned agent wallet, fund on devnet, swap via Jupiter, open Orca LP, then attempt Kamino deposit/borrow live with simulated fallback on devnet");
+    const rpcUrl = (0, env_1.getRpcUrl)();
+    const cluster = (0, env_1.detectClusterFromRpcUrl)(rpcUrl);
+    if (cluster !== "devnet") {
+        throw new Error(`Autonomous portfolio 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 autonomous portfolio demo");
+    console.log(`RPC: ${rpcUrl}`);
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    await (0, managedAgentWallet_1.ensureManagedAgentWalletFunding)({
+        balanceService,
+        fundingService,
+        minimumSol: REQUIRED_FUNDING_SOL,
+        publicKey: walletManager.publicKey
+    });
+    const signatures = [];
+    const swapResult = await executeAutonomousSwapIntent({
+        amountSol: DEFAULT_SWAP_SOL,
+        walletManager
+    });
+    signatures.push({
+        label: swapResult.mode === "LIVE"
+            ? "Jupiter swap"
+            : "Jupiter swap intent (simulated on devnet)",
+        signature: swapResult.signature
+    });
+    const orcaResult = await executeAutonomousOrcaLp({
+        balanceService,
+        depositAmountSol: DEFAULT_ORCA_LP_SOL,
+        rpcClient,
+        tokenService,
+        transactionService,
+        walletManager
+    });
+    if (orcaResult.tickArrayInitSignature) {
+        signatures.push({
+            label: "Orca tick arrays",
+            signature: orcaResult.tickArrayInitSignature
+        });
+    }
+    signatures.push({
+        label: "Orca LP position",
+        signature: orcaResult.signature
+    });
+    const kaminoDepositResult = await executeKaminoActionWithFallback({
+        action: "deposit",
+        transactionService,
+        walletManager
+    });
+    signatures.push({
+        label: kaminoDepositResult.label,
+        signature: kaminoDepositResult.signature
+    });
+    const kaminoBorrowResult = await executeKaminoActionWithFallback({
+        action: "borrow",
+        transactionService,
+        walletManager
+    });
+    signatures.push({
+        label: kaminoBorrowResult.label,
+        signature: kaminoBorrowResult.signature
+    });
+    const usdcMint = new web3_js_1.PublicKey((0, env_1.getUsdcMintAddress)());
+    const solAfter = await balanceService.getSolBalance(walletManager.publicKey);
+    const usdcAfter = await balanceService.getSplTokenBalance({
+        mint: usdcMint,
+        owner: walletManager.publicKey
+    });
+    console.log("");
+    console.log("Autonomous portfolio run");
+    for (const entry of signatures) {
+        console.log(`${entry.label}: ${entry.signature}`);
+    }
+    console.log(`Orca position mint: ${orcaResult.positionMint}`);
+    console.log(`SOL after: ${solAfter.toFixed(4)}`);
+    console.log(`USDC after: ${usdcAfter.toFixed(6)}`);
+}
+async function executeAutonomousSwapIntent(input) {
+    const result = await (0, AgentRuntime_1.simulateMarketAction)({
+        amountSol: input.amountSol,
+        koraSigner: (0, shared_1.createKoraSigner)(),
+        liveSwapConfig: {
+            enabled: false,
+            outputMint: (0, env_1.getUsdcMintAddress)(),
+            swapExecutor: null
+        },
+        logger: (message) => console.log(`[autonomous-jupiter] ${message}`),
+        policyGuard: new PolicyGuard_1.PolicyGuard((0, policyFactory_1.createDefaultAgentPolicy)()),
+        priceFeed: new MockPriceFeed_1.MockPriceFeed({
+            buyThresholdUsd: 100,
+            solPriceUsd: 95,
+            usdcPriceUsd: 1
+        }),
+        walletManager: input.walletManager
+    });
+    if (!result.execution) {
+        throw new Error("Autonomous Jupiter swap intent did not produce an execution result.");
+    }
+    return {
+        mode: result.liveSwap && !result.execution.mock ? "LIVE" : "SIMULATED",
+        signature: result.execution.signature
+    };
+}
+async function executeLiveKaminoAction(input) {
+    const config = (0, kaminoLiveConfig_1.loadKaminoLiveConfig)();
+    const prepared = await (0, liveExecutors_1.prepareLiveKamino)({
+        intent: {
+            action: input.action,
+            amountLamports: 0,
+            marketId: protocols_1.PROTOCOL_PRESETS.kamino.defaultMarketId,
+            memo: `LIVE:KAMINO:${input.action}`,
+            protocol: "kamino",
+            slippageBps: 40
+        },
+        logger: (message) => console.log(`[autonomous-kamino] ${message}`),
+        walletManager: input.walletManager
+    });
+    if (!prepared) {
+        throw new Error(`Kamino ${input.action} was not prepared. Check ENABLE_LIVE_KAMINO and ${config.marketAddress}.`);
+    }
+    return executePreparedLive({
+        agentId: `autonomous-portfolio-kamino-${input.action}`,
+        prepared,
+        transactionService: input.transactionService
+    });
+}
+async function executeKaminoActionWithFallback(input) {
+    try {
+        const signature = await executeLiveKaminoAction(input);
+        return {
+            label: `Kamino ${input.action}`,
+            signature
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "unknown Kamino live error";
+        console.log(`[autonomous-kamino] live ${input.action} failed on devnet (${summarizeKaminoLiveFailure(message)}); falling back to simulated intent`);
+        const signature = await executeSimulatedKaminoAction(input);
+        return {
+            label: `Kamino ${input.action} intent (simulated fallback)`,
+            signature
+        };
+    }
+}
+async function executeSimulatedKaminoAction(input) {
+    const executor = new DeFiExecutor_1.DeFiExecutor((0, policyFactory_1.createDefaultAgentPolicy)({
+        maxSpend: {
+            lamports: 1_000_000_000
+        }
+    }));
+    const result = await executor.executeIntent({
+        intent: {
+            action: input.action,
+            amountLamports: 0,
+            expectedHealthFactor: input.action === "borrow" ? 2.2 : 2.0,
+            marketId: protocols_1.PROTOCOL_PRESETS.kamino.defaultMarketId,
+            memo: `DEFI_INTENT:KAMINO:${input.action}:DEVNET_FALLBACK`,
+            protocol: "kamino",
+            slippageBps: 40
+        },
+        koraSigner: (0, shared_1.createKoraSigner)(),
+        walletManager: input.walletManager
+    });
+    return result.signature;
+}
+function summarizeKaminoLiveFailure(message) {
+    if (message.includes("ReserveStale")) {
+        return "reserve refresh is currently broken on the selected devnet market";
+    }
+    if (message.includes("InvalidOracleConfig")) {
+        return "the selected devnet market has invalid oracle configuration";
+    }
+    if (message.includes("simulation failed")) {
+        return "transaction simulation failed";
+    }
+    return message.length > 140 ? `${message.slice(0, 137)}...` : message;
+}
+async function executePreparedLive(input) {
+    const policyEngine = new policy_1.PolicyEngine((0, agentPolicies_1.createDefaultPolicyConfig)({
+        agentId: input.agentId,
+        allowOpaqueProgramIds: input.prepared.policyConfigPatch?.rules?.allowOpaqueProgramIds,
+        allowedCloseAccountDestinations: input.prepared.policyConfigPatch?.rules?.allowedCloseAccountDestinations,
+        approvalMode: "sandbox",
+        extraAllowedProgramIds: input.prepared.policyConfigPatch?.rules?.allowedProgramIds
+    }));
+    const sandboxExecutor = new policy_1.SandboxExecutor(policyEngine, input.transactionService, "sandbox");
+    const execution = await sandboxExecutor.executePreparedTransaction({
+        confirmationStrategy: input.prepared.confirmationStrategy,
+        inspectionContext: input.prepared.inspectionContext,
+        transaction: input.prepared.transaction
+    });
+    if (!execution.signature) {
+        const simulationLogs = execution.simulationLogs?.join(" | ");
+        throw new Error(`Guarded ${input.prepared.protocol} execution blocked: ${execution.inspection.reasons.join("; ") || "unknown reason"}${simulationLogs ? ` | simulation logs: ${simulationLogs}` : ""}`);
+    }
+    if (input.prepared.verifyExecution) {
+        await input.prepared.verifyExecution(execution.signature);
+    }
+    return execution.signature;
+}
+async function executeAutonomousOrcaLp(input) {
+    const orcaWallet = new common_sdk_1.ReadOnlyWallet(input.walletManager.publicKey);
+    const whirlpoolContext = whirlpools_sdk_1.WhirlpoolContext.from(input.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(input.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: "autonomous-portfolio-orca",
+        allowOpaqueProgramIds: [ORCA_DEVNET_PROGRAM_ID.toBase58()],
+        allowedCloseAccountDestinations: [input.walletManager.publicKey.toBase58()],
+        approvalMode: "sandbox",
+        extraAllowedProgramIds: [ORCA_DEVNET_PROGRAM_ID.toBase58()]
+    }));
+    const sandboxExecutor = new policy_1.SandboxExecutor(policyEngine, input.transactionService, "sandbox");
+    const solBefore = await input.balanceService.getSolBalance(input.walletManager.publicKey);
+    console.log(`Orca pool: ${poolAddress.toBase58()}`);
+    console.log(`Orca range: [${tickLowerIndex}, ${tickUpperIndex}] (${sideDescription})`);
+    console.log(`Orca estimated token max A: ${quote.tokenMaxA.toString()}`);
+    console.log(`Orca estimated token max B: ${quote.tokenMaxB.toString()}`);
+    let tickArrayInitSignature;
+    const initTickArrays = await whirlpool.initTickArrayForTicks([tickLowerIndex, tickUpperIndex], input.walletManager.publicKey);
+    if (initTickArrays && !initTickArrays.isEmpty()) {
+        tickArrayInitSignature = await executeBuilder({
+            builder: initTickArrays,
+            label: "initialize Orca tick arrays",
+            sandboxExecutor,
+            walletManager: input.walletManager
+        });
+    }
+    const { positionMint, tx } = await whirlpool.openPosition(tickLowerIndex, tickUpperIndex, quote, input.walletManager.publicKey, input.walletManager.publicKey);
+    const positionTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(positionMint, input.walletManager.publicKey);
+    const signature = await executeBuilder({
+        builder: tx,
+        label: "open Orca position",
+        sandboxExecutor,
+        walletManager: input.walletManager
+    });
+    const positionTokenBalance = await readPositionTokenBalance(positionTokenAccount, input.rpcClient);
+    if (positionTokenBalance !== 1n) {
+        throw new Error(`Orca position verification failed: expected 1 position token, got ${positionTokenBalance.toString()}.`);
+    }
+    const solAfter = await input.balanceService.getSolBalance(input.walletManager.publicKey);
+    console.log(`Orca verified ${signature}: position token balance ${positionTokenBalance.toString()}`);
+    console.log(`Orca SOL before: ${solBefore.toFixed(4)}`);
+    console.log(`Orca SOL after: ${solAfter.toFixed(4)}`);
+    return {
+        positionMint: positionMint.toBase58(),
+        signature,
+        tickArrayInitSignature
+    };
+}
+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);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Autonomous portfolio demo failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runBorrowStrategy.js

@@ -0,0 +1,35 @@
+"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 = "borrow-strategy";
+async function main() {
+    (0, mode_1.printDemoMode)("SIMULATED", "Protocol intent only (memo execution), not live Kamino borrow 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)("borrow"));
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    const result = await coordinator.runBorrowingStrategy({
+        borrowDemandUsdcAtomic: 3_000_000,
+        collateralSolLamports: Math.round(1.2 * web3_js_1.LAMPORTS_PER_SOL),
+        healthFactor: 2.3
+    });
+    console.log("Borrow strategy complete.");
+    if (!result) {
+        console.log("No borrowing 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(`Borrow strategy failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runDeFiSuite.js

@@ -0,0 +1,41 @@
+"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 = "defi-suite";
+async function main() {
+    (0, mode_1.printDemoMode)("SIMULATED", "Protocol intents only (memo execution), not live Marinade/Raydium/Kamino 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)("defi"));
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    const results = await coordinator.runFullSuite({
+        buyThresholdUsd: 100,
+        healthFactor: 2.2,
+        idleSolLamports: Math.round(1.0 * web3_js_1.LAMPORTS_PER_SOL),
+        idleUsdcAtomic: 5_000_000,
+        liquidityInRange: true,
+        solPriceUsd: 95
+    });
+    console.log("DeFi suite complete.");
+    if (results.length === 0) {
+        console.log("No DeFi actions executed.");
+        return;
+    }
+    for (const result of results) {
+        console.log(`${result.protocol}: ${result.action} ${result.signature}`);
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`DeFi suite failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runDemoRehearsal.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const env_1 = require("../config/env");
+const env_2 = require("../config/env");
+function runCommand(command, args) {
+    const result = (0, child_process_1.spawnSync)([command, ...args].join(" "), {
+        shell: true,
+        stdio: "inherit"
+    });
+    return {
+        detail: `${command} ${args.join(" ")}`,
+        ok: result.status === 0,
+        title: `Command ${command}`
+    };
+}
+function runPreflightChecks() {
+    const checks = [];
+    const rpcUrl = (0, env_1.getRpcUrl)();
+    const cluster = (0, env_1.detectClusterFromRpcUrl)(rpcUrl);
+    const usdcMint = (0, env_1.getUsdcMintAddress)();
+    const secretKey = (0, env_2.getOptionalSecretKey)();
+    const remoteSigner = (0, env_1.getRemoteSignerConfig)();
+    checks.push({
+        detail: rpcUrl,
+        ok: cluster === "devnet",
+        title: "RPC cluster is devnet"
+    });
+    try {
+        (0, env_1.assertMintMatchesRpcCluster)({
+            mintAddress: usdcMint,
+            mintName: "USDC_MINT",
+            rpcUrl
+        });
+        checks.push({
+            detail: usdcMint,
+            ok: true,
+            title: "USDC mint matches RPC cluster"
+        });
+    }
+    catch (error) {
+        checks.push({
+            detail: error instanceof Error ? error.message : "mint and cluster mismatch",
+            ok: false,
+            title: "USDC mint matches RPC cluster"
+        });
+    }
+    checks.push({
+        detail: remoteSigner
+            ? `remote signer ${remoteSigner.publicKey.toBase58()}`
+            : secretKey
+                ? "local demo key present"
+                : "missing signer config",
+        ok: Boolean(remoteSigner) || Boolean(secretKey),
+        title: "signer configuration is present"
+    });
+    checks.push({
+        detail: "raydium_lp.devnet.json",
+        ok: (0, fs_1.existsSync)("raydium_lp.devnet.json"),
+        title: "Raydium devnet LP config exists"
+    });
+    checks.push(runCommand("npm", ["run", "release:check"]));
+    return checks;
+}
+function writeSessionArtifact(checks) {
+    const artifactDir = path_1.default.join(process.cwd(), "artifacts");
+    if (!(0, fs_1.existsSync)(artifactDir)) {
+        (0, fs_1.mkdirSync)(artifactDir, { recursive: true });
+    }
+    const artifactPath = path_1.default.join(artifactDir, "demo-session.json");
+    const payload = {
+        cluster: (0, env_1.detectClusterFromRpcUrl)((0, env_1.getRpcUrl)()),
+        generatedAtIso8601: new Date().toISOString(),
+        recommendedLiveRunOrder: [
+            "npm run wallet:devnet",
+            "npm run defi:lp:devnet",
+            "npm run simulate-attack",
+            "npm run stress:agents"
+        ],
+        checks
+    };
+    (0, fs_1.writeFileSync)(artifactPath, JSON.stringify(payload, null, 2), "utf8");
+    return artifactPath;
+}
+function main() {
+    console.log("PRKT demo rehearsal");
+    const checks = runPreflightChecks();
+    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;
+        }
+    }
+    const artifactPath = writeSessionArtifact(checks);
+    console.log(`Session artifact: ${artifactPath}`);
+    if (failures > 0) {
+        console.error(`Demo rehearsal preflight failed with ${failures} failing check(s).`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log("Demo rehearsal preflight passed.");
+    console.log("Next: run the recommended live order and record signatures in artifacts/bounty-evidence.md.");
+}
+main();

package/dist/scripts/runDevnetWalletDemo.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const DecisionEngine_1 = require("../agent/DecisionEngine");
+const env_1 = require("../config/env");
+const programs_1 = require("../solana/programs");
+const TokenWallet_1 = require("../spl/TokenWallet");
+const WalletManager_1 = require("../wallet/WalletManager");
+const mode_1 = require("./mode");
+const devnetWalletPreflight_1 = require("./devnetWalletPreflight");
+async function main() {
+    (0, mode_1.printDemoMode)("LIVE", "Direct Solana transaction path (wrap SOL into wSOL)");
+    const rpcUrl = (0, env_1.getRpcUrl)();
+    const connection = new web3_js_1.Connection(rpcUrl, "confirmed");
+    const walletManager = WalletManager_1.WalletManager.loadConfigured();
+    const associatedTokenAddress = TokenWallet_1.TokenWallet.findAssociatedTokenAddress(walletManager.publicKey, programs_1.NATIVE_MINT);
+    console.log("PRKT devnet wallet demo");
+    console.log(`RPC: ${rpcUrl}`);
+    console.log(`Wallet: ${walletManager.publicKey.toBase58()}`);
+    const startingSolBalance = (await connection.getBalance(walletManager.publicKey, "confirmed")) / 1_000_000_000;
+    let startingWsolBalance = 0;
+    const existingWsolAccount = await connection.getAccountInfo(associatedTokenAddress, "confirmed");
+    if (existingWsolAccount) {
+        const tokenBalance = await connection.getTokenAccountBalance(associatedTokenAddress, "confirmed");
+        startingWsolBalance = tokenBalance.value.uiAmount ?? 0;
+    }
+    (0, devnetWalletPreflight_1.assertDeterministicWrapPreflight)({
+        startingSolBalance,
+        startingWsolBalance
+    });
+    const agent = new DecisionEngine_1.DecisionEngine(connection, walletManager);
+    const result = await agent.think();
+    console.log(`Associated token account: ${associatedTokenAddress.toBase58()}`);
+    console.log(`Decision: ${result.action}`);
+    if (result.action !== "wrap") {
+        throw new Error("Execution failed: DecisionEngine returned HOLD during a deterministic wrap run. Check preflight balances and retry.");
+    }
+    const endingWsolBalance = result.wsolBalance;
+    if (endingWsolBalance <= startingWsolBalance) {
+        throw new Error(`Post-check failed: wSOL did not increase (${startingWsolBalance.toFixed(4)} -> ${endingWsolBalance.toFixed(4)}).`);
+    }
+    console.log(`Created ATA this run: ${result.createdAssociatedTokenAccount ? "yes" : "no"}`);
+    console.log(`Wrapped amount: ${result.wrapAmount.toFixed(2)} SOL`);
+    console.log(`Transaction signature: ${result.signature}`);
+    console.log(`wSOL before: ${startingWsolBalance.toFixed(4)}`);
+    console.log(`wSOL after: ${endingWsolBalance.toFixed(4)}`);
+    console.log("Post-check passed: wSOL balance increased.");
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Devnet wallet demo failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runGaslessMemo.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const managedAgentWallet_1 = require("./managedAgentWallet");
+const shared_1 = require("./shared");
+const DEFAULT_AGENT_NAME = "gasless-memo";
+async function main() {
+    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 result = await koraSigner.submitGaslessMemo(walletManager, "PRKT gasless memo verification");
+    console.log("Gasless memo verification complete.");
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    console.log(`Signature: ${result.signature}`);
+    console.log(`Mode: ${result.mock ? "mock" : "live"}`);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Gasless memo failed: ${message}`);
+    process.exitCode = 1;
+});