@prktsol/prkt 1.0.0

package/dist/scripts/runStressTest.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AgentManager_1 = require("../agent/AgentManager");
+const MockPriceFeed_1 = require("../agent/MockPriceFeed");
+const runtimeFactory_1 = require("./runtimeFactory");
+const shared_1 = require("./shared");
+const mode_1 = require("./mode");
+async function main() {
+    (0, mode_1.printDemoMode)("SIMULATED", "Concurrent harness with per-agent rate limits and circuit breaker");
+    const events = await AgentManager_1.AgentManager.runManagedTradeSimulation({
+        amountSol: 0.01,
+        koraSigner: (0, shared_1.createKoraSigner)(),
+        liveSwapConfig: (0, runtimeFactory_1.createLiveSwapConfig)(),
+        logger: (0, shared_1.createRuntimeLogger)("stress"),
+        rounds: 5,
+        safetyControls: {
+            cooldownMs: 15_000,
+            maxActionsPerWindow: 2,
+            maxConsecutiveFailures: 2,
+            windowMs: 20_000
+        },
+        priceFeed: new MockPriceFeed_1.MockPriceFeed({
+            buyThresholdUsd: 100,
+            solPriceUsd: 92,
+            usdcPriceUsd: 1
+        })
+    });
+    console.log("Managed stress run complete.");
+    for (const event of events) {
+        if (event.status === "executed") {
+            console.log(`${event.agentId}#${event.iteration}: ${event.result.action} ${event.result.execution?.signature ?? "NOOP"}`);
+            continue;
+        }
+        console.log(`${event.agentId}#${event.iteration}: ${event.status} (${event.reason})`);
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Stress test failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runTradeLoop.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PolicyGuard_1 = require("../policy/PolicyGuard");
+const MockPriceFeed_1 = require("../agent/MockPriceFeed");
+const AgentRuntime_1 = require("../agent/AgentRuntime");
+const policyFactory_1 = require("../agent/policyFactory");
+const managedAgentWallet_1 = require("./managedAgentWallet");
+const runtimeFactory_1 = require("./runtimeFactory");
+const shared_1 = require("./shared");
+const mode_1 = require("./mode");
+const DEFAULT_AGENT_NAME = "trade-loop";
+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 policy = (0, policyFactory_1.createDefaultAgentPolicy)();
+    const policyGuard = new PolicyGuard_1.PolicyGuard(policy);
+    const priceFeed = new MockPriceFeed_1.MockPriceFeed({
+        buyThresholdUsd: 100,
+        solPriceUsd: 95,
+        usdcPriceUsd: 1
+    });
+    const result = await (0, AgentRuntime_1.simulateMarketAction)({
+        amountSol: 0.01,
+        koraSigner: (0, shared_1.createKoraSigner)(),
+        liveSwapConfig: (0, runtimeFactory_1.createLiveSwapConfig)(),
+        logger: (0, shared_1.createRuntimeLogger)("trade"),
+        policyGuard,
+        priceFeed,
+        walletManager
+    });
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    const mode = result.liveSwap && !result.execution?.mock ? "LIVE" : "SIMULATED";
+    const detail = mode === "LIVE"
+        ? "Jupiter route built and submitted"
+        : "Memo intent and/or mock transport";
+    (0, mode_1.printDemoMode)(mode, detail);
+    console.log(`Trade action: ${result.action}`);
+    if (result.execution) {
+        console.log(`Trade signature: ${result.execution.signature}`);
+    }
+    if (result.liveSwap) {
+        console.log(`Trade route: ${result.liveSwap.routeType}`);
+        console.log(`Quote out amount: ${result.liveSwap.quoteOutAmount}`);
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Trade loop failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runUniversalDeFiDemo.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const universal_1 = require("../defi/universal");
+const managedAgentWallet_1 = require("./managedAgentWallet");
+const shared_1 = require("./shared");
+const mode_1 = require("./mode");
+const DEFAULT_AGENT_NAME = "universal-defi-demo";
+async function main() {
+    (0, mode_1.printDemoMode)("SIMULATED", "Universal DeFi compatibility mode (trade/lp/lending/borrowing/yield/staking routed by adapter registry)");
+    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 orchestrator = new universal_1.UniversalDeFiOrchestrator({
+        koraSigner: (0, shared_1.createKoraSigner)(),
+        liveFirst: false,
+        logger: (0, shared_1.createRuntimeLogger)("universal-defi"),
+        walletManager: managed.walletManager
+    });
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    const requests = [
+        {
+            capability: "trade",
+            snapshot: {
+                buyThresholdUsd: 100,
+                solPriceUsd: 95
+            }
+        },
+        {
+            capability: "staking",
+            snapshot: {
+                idleSolLamports: Math.round(1.0 * web3_js_1.LAMPORTS_PER_SOL)
+            }
+        },
+        {
+            capability: "lp",
+            snapshot: {
+                liquidityInRange: true
+            }
+        },
+        {
+            capability: "lending",
+            snapshot: {
+                healthFactor: 2.0,
+                idleUsdcAtomic: 5_000_000
+            }
+        },
+        {
+            capability: "borrowing",
+            protocol: "kamino",
+            snapshot: {
+                borrowDemandUsdcAtomic: 3_000_000,
+                collateralSolLamports: Math.round(1.2 * web3_js_1.LAMPORTS_PER_SOL),
+                healthFactor: 2.3
+            }
+        },
+        {
+            capability: "yield",
+            protocol: "kamino",
+            snapshot: {
+                healthFactor: 2.1,
+                idleUsdcAtomic: 4_000_000
+            }
+        }
+    ];
+    const results = await orchestrator.executeBatch(requests);
+    console.log("Universal DeFi run complete.");
+    for (const entry of results) {
+        if (!entry.result) {
+            console.log(`${entry.capability}/${entry.protocol}: HOLD`);
+            continue;
+        }
+        console.log(`${entry.capability}/${entry.protocol}: ${entry.result.action} ${entry.result.signature}`);
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Universal DeFi demo failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runYieldStrategy.js

@@ -0,0 +1,33 @@
+"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 = "yield-strategy";
+async function main() {
+    (0, mode_1.printDemoMode)("SIMULATED", "Protocol intent only (memo execution), not live 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)("yield"));
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    const result = await coordinator.runLendingStrategy({
+        healthFactor: 2.1,
+        idleUsdcAtomic: 5_000_000
+    });
+    console.log("Yield strategy complete.");
+    if (!result) {
+        console.log("No lending 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(`Yield strategy failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runtimeFactory.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLiveSwapConfig = createLiveSwapConfig;
+const env_1 = require("../config/env");
+const JupiterSwapClient_1 = require("../dex/JupiterSwapClient");
+const SwapExecutor_1 = require("../dex/SwapExecutor");
+function createLiveSwapConfig() {
+    const enabled = (0, env_1.isLiveSwapPathEnabled)();
+    const outputMint = (0, env_1.getUsdcMintAddress)();
+    (0, env_1.assertMintMatchesRpcCluster)({
+        mintAddress: outputMint,
+        mintName: "USDC_MINT",
+        rpcUrl: (0, env_1.getRpcUrl)()
+    });
+    if (!enabled) {
+        return {
+            enabled,
+            outputMint,
+            swapExecutor: null
+        };
+    }
+    return {
+        enabled,
+        outputMint,
+        swapExecutor: new SwapExecutor_1.SwapExecutor(new JupiterSwapClient_1.JupiterSwapClient((0, env_1.getJupiterApiBaseUrl)()))
+    };
+}

package/dist/scripts/shared.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuntimeLogger = createRuntimeLogger;
+exports.createKoraSigner = createKoraSigner;
+const env_1 = require("../config/env");
+const KoraRpcClient_1 = require("../kora/KoraRpcClient");
+const KoraSigner_1 = require("../kora/KoraSigner");
+function createRuntimeLogger(prefix) {
+    return (message) => {
+        console.log(`[${prefix}] ${message}`);
+    };
+}
+function createKoraSigner() {
+    const koraRpcUrl = (0, env_1.getKoraRpcUrl)();
+    const mockMode = (0, env_1.isKoraMockMode)();
+    console.log(`[runtime] Solana RPC: ${(0, env_1.getRpcUrl)()}`);
+    console.log(`[runtime] Kora RPC: ${koraRpcUrl}`);
+    console.log(`[runtime] Kora mock mode: ${mockMode}`);
+    console.log(`[runtime] Live swap path: ${(0, env_1.isLiveSwapPathEnabled)()}`);
+    console.log(`[runtime] Jupiter API: ${(0, env_1.getJupiterApiBaseUrl)()}`);
+    return new KoraSigner_1.KoraSigner(new KoraRpcClient_1.KoraRpcClient(koraRpcUrl), {
+        mockMode
+    });
+}

package/dist/scripts/simulateAttack.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PolicyGuard_1 = require("../policy/PolicyGuard");
+const errors_1 = require("../policy/errors");
+const policyFactory_1 = require("../agent/policyFactory");
+const attack_1 = require("../simulation/attack");
+const managedAgentWallet_1 = require("./managedAgentWallet");
+const DEFAULT_AGENT_NAME = "simulate-attack";
+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 policy = (0, policyFactory_1.createDefaultAgentPolicy)({
+        whitelistedTransferDestinations: []
+    });
+    const policyGuard = new PolicyGuard_1.PolicyGuard(policy);
+    try {
+        (0, attack_1.simulateAttack)(policyGuard, walletManager);
+        console.error("Security failure: attack unexpectedly succeeded.");
+        process.exitCode = 1;
+    }
+    catch (error) {
+        if (error instanceof errors_1.SecurityViolationError) {
+            console.log("SecurityViolation detected. Attack blocked successfully.");
+            console.log(error.message);
+            return;
+        }
+        throw error;
+    }
+}
+try {
+    main();
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Attack simulation failed: ${message}`);
+    process.exitCode = 1;
+}

package/dist/scripts/simulateSwarm.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const policyFactory_1 = require("../agent/policyFactory");
+const PolicyGuard_1 = require("../policy/PolicyGuard");
+const errors_1 = require("../policy/errors");
+const programs_1 = require("../solana/programs");
+const WalletManager_1 = require("../wallet/WalletManager");
+const shared_1 = require("./shared");
+const mode_1 = require("./mode");
+function log(agentId, message) {
+    console.log(`[swarm][${agentId}] ${message}`);
+}
+function createTransferProbe(walletManager, destination, lamports) {
+    const message = new web3_js_1.TransactionMessage({
+        payerKey: walletManager.publicKey,
+        recentBlockhash: programs_1.MOCK_BLOCKHASH,
+        instructions: [
+            web3_js_1.SystemProgram.transfer({
+                fromPubkey: walletManager.publicKey,
+                toPubkey: new web3_js_1.PublicKey(destination),
+                lamports
+            })
+        ]
+    }).compileToV0Message();
+    const transaction = new web3_js_1.VersionedTransaction(message);
+    transaction.sign([walletManager.payer]);
+    return transaction;
+}
+async function runRole(role, koraSigner) {
+    const walletManager = WalletManager_1.WalletManager.generate();
+    const policyGuard = new PolicyGuard_1.PolicyGuard(role.policy);
+    log(role.id, `Role: ${role.description}`);
+    log(role.id, `Wallet: ${walletManager.publicKey.toBase58()}`);
+    log(role.id, `Policy max spend: ${role.policy.maxSpend.lamports} lamports`);
+    log(role.id, `Policy transfer whitelist: ${role.policy.whitelistedTransferDestinations.length} destination(s)`);
+    log(role.id, "Policy check starting.");
+    if (role.runBlockedProbe) {
+        try {
+            const blockedProbe = createTransferProbe(walletManager, web3_js_1.Keypair.generate().publicKey.toBase58(), 100_000);
+            policyGuard.validate(blockedProbe);
+            log(role.id, "Strict whitelist probe unexpectedly passed.");
+        }
+        catch (error) {
+            if (error instanceof errors_1.SecurityViolationError) {
+                log(role.id, `Strict whitelist probe blocked as expected: ${error.message}`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    const transaction = await koraSigner.buildMemoTransaction(walletManager, role.memo);
+    policyGuard.validate(transaction);
+    log(role.id, "Policy check passed. Executing gasless action.");
+    const execution = await koraSigner.signAndSendGasless(transaction, role.memo);
+    log(role.id, `Execution complete (${execution.mock ? "mock" : "live"}): ${execution.signature}`);
+}
+async function main() {
+    (0, mode_1.printDemoMode)("SIMULATED", "Multi-agent memo execution and policy probes");
+    console.log("PRKT swarm simulation");
+    console.log("Spawning 3 distinct agent wallets and executing in parallel.");
+    const koraSigner = (0, shared_1.createKoraSigner)();
+    const liquidationVault = web3_js_1.Keypair.generate().publicKey.toBase58();
+    const roles = [
+        {
+            description: "High-frequency operator (low spend limit)",
+            id: "agent-1",
+            memo: "HFT heartbeat: rebalance window open",
+            policy: (0, policyFactory_1.createDefaultAgentPolicy)({
+                maxSpend: {
+                    lamports: 50_000
+                }
+            })
+        },
+        {
+            description: "Long-term staker (high spend limit)",
+            id: "agent-2",
+            memo: "Staker review: epoch position healthy",
+            policy: (0, policyFactory_1.createDefaultAgentPolicy)({
+                maxSpend: {
+                    lamports: 10_000_000
+                }
+            })
+        },
+        {
+            description: "Liquidator (strict whitelist)",
+            id: "agent-3",
+            memo: "Liquidator check: liquidation opportunity queued",
+            policy: (0, policyFactory_1.createDefaultAgentPolicy)({
+                maxSpend: {
+                    lamports: 250_000
+                },
+                whitelistedTransferDestinations: [liquidationVault]
+            }),
+            runBlockedProbe: true
+        }
+    ];
+    await Promise.all(roles.map(async (role) => runRole(role, koraSigner)));
+    console.log("Swarm simulation complete.");
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Swarm simulation failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/simulation/attack.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompromisedDrainTransaction = createCompromisedDrainTransaction;
+exports.simulateAttack = simulateAttack;
+const web3_js_1 = require("@solana/web3.js");
+const programs_1 = require("../solana/programs");
+function createCompromisedDrainTransaction(walletManager) {
+    const attackerDestination = web3_js_1.Keypair.generate().publicKey;
+    const instruction = web3_js_1.SystemProgram.transfer({
+        fromPubkey: walletManager.publicKey,
+        toPubkey: attackerDestination,
+        lamports: 1_000_000
+    });
+    const message = new web3_js_1.TransactionMessage({
+        payerKey: walletManager.publicKey,
+        recentBlockhash: programs_1.MOCK_BLOCKHASH,
+        instructions: [instruction]
+    }).compileToV0Message();
+    const transaction = new web3_js_1.VersionedTransaction(message);
+    transaction.sign([walletManager.payer]);
+    return {
+        recipient: attackerDestination.toBase58(),
+        transaction
+    };
+}
+function simulateAttack(policyGuard, walletManager) {
+    const { recipient, transaction } = createCompromisedDrainTransaction(walletManager);
+    policyGuard.validate(transaction);
+    return recipient;
+}

package/dist/solana/programs.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOKEN_PROGRAM_ID = exports.NATIVE_MINT = exports.MOCK_BLOCKHASH = exports.MEMO_PROGRAM_ID = exports.ASSOCIATED_TOKEN_PROGRAM_ID = void 0;
+const web3_js_1 = require("@solana/web3.js");
+exports.ASSOCIATED_TOKEN_PROGRAM_ID = new web3_js_1.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+exports.MEMO_PROGRAM_ID = new web3_js_1.PublicKey("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr");
+exports.MOCK_BLOCKHASH = "11111111111111111111111111111111";
+exports.NATIVE_MINT = new web3_js_1.PublicKey("So11111111111111111111111111111111111111112");
+exports.TOKEN_PROGRAM_ID = new web3_js_1.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");

package/dist/spl/TokenWallet.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenWallet = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const programs_1 = require("../solana/programs");
+class TokenWallet {
+    static findAssociatedTokenAddress(owner, mint) {
+        const [associatedTokenAddress] = web3_js_1.PublicKey.findProgramAddressSync([owner.toBuffer(), programs_1.TOKEN_PROGRAM_ID.toBuffer(), mint.toBuffer()], programs_1.ASSOCIATED_TOKEN_PROGRAM_ID);
+        return associatedTokenAddress;
+    }
+    static async buildWrapSolTransaction(input) {
+        if (!Number.isInteger(input.amountLamports) || input.amountLamports <= 0) {
+            throw new Error("Wrap SOL amount must be a positive integer lamport value.");
+        }
+        const associatedTokenAddress = TokenWallet.findAssociatedTokenAddress(input.walletManager.publicKey, programs_1.NATIVE_MINT);
+        const instructions = [];
+        if (input.createAssociatedTokenAccount) {
+            instructions.push(TokenWallet.createAssociatedTokenAccountInstruction({
+                mint: programs_1.NATIVE_MINT,
+                owner: input.walletManager.publicKey,
+                payer: input.walletManager.publicKey
+            }));
+        }
+        instructions.push(web3_js_1.SystemProgram.transfer({
+            fromPubkey: input.walletManager.publicKey,
+            toPubkey: associatedTokenAddress,
+            lamports: input.amountLamports
+        }), TokenWallet.createSyncNativeInstruction(associatedTokenAddress));
+        const message = new web3_js_1.TransactionMessage({
+            payerKey: input.walletManager.publicKey,
+            recentBlockhash: input.recentBlockhash,
+            instructions
+        }).compileToV0Message();
+        const transaction = new web3_js_1.VersionedTransaction(message);
+        const signedTransaction = await input.walletManager.signTransaction(transaction);
+        return {
+            associatedTokenAddress,
+            createdAssociatedTokenAccount: input.createAssociatedTokenAccount,
+            transaction: signedTransaction
+        };
+    }
+    static createAssociatedTokenAccountInstruction(input) {
+        const associatedTokenAddress = TokenWallet.findAssociatedTokenAddress(input.owner, input.mint);
+        return new web3_js_1.TransactionInstruction({
+            programId: programs_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            keys: [
+                { pubkey: input.payer, isSigner: true, isWritable: true },
+                { pubkey: associatedTokenAddress, isSigner: false, isWritable: true },
+                { pubkey: input.owner, isSigner: false, isWritable: false },
+                { pubkey: input.mint, isSigner: false, isWritable: false },
+                { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
+                { pubkey: programs_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }
+            ],
+            data: Buffer.alloc(0)
+        });
+    }
+    static createSyncNativeInstruction(associatedTokenAddress) {
+        return new web3_js_1.TransactionInstruction({
+            programId: programs_1.TOKEN_PROGRAM_ID,
+            keys: [{ pubkey: associatedTokenAddress, isSigner: false, isWritable: true }],
+            data: Buffer.from([17])
+        });
+    }
+}
+exports.TokenWallet = TokenWallet;

package/dist/types/policy.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wallet/WalletManager.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletManager = void 0;
+var WalletManager_1 = require("../core/wallet/WalletManager");
+Object.defineProperty(exports, "WalletManager", { enumerable: true, get: function () { return WalletManager_1.WalletManager; } });

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@prktsol/prkt",
+  "version": "1.0.0",
+  "description": "Policy-enforced autonomous agent wallet scaffold for Solana.",
+  "main": "dist/index.js",
+  "bin": {
+    "prkt": "dist/cli/index.js"
+  },
+  "files": [
+    "dist/**/*",
+    ".env.example",
+    ".env.devnet.all-protocols.example",
+    ".env.devnet.autonomous.example",
+    ".env.devnet.jupiter.example",
+    ".env.devnet.kamino.example",
+    ".env.devnet.marinade.example",
+    ".env.devnet.orca.example",
+    ".env.devnet.raydium.example",
+    "ARCHITECTURE.md",
+    "CLI.md",
+    "CLI_QUICKSTART.md",
+    "COMPATIBILITY.md",
+    "DEVNET_PROTOCOL_ADDRESSES.md",
+    "README.md"
+  ],
+  "type": "commonjs",
+  "scripts": {
+    "build": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
+    "cli": "ts-node src/cli/index.ts",
+    "dashboard:demo": "node src/scripts/runDashboard.mjs",
+    "dev": "ts-node src/index.ts",
+    "demo:autonomous-agent-wallet:devnet": "ts-node src/scripts/runAutonomousAgentWalletDevnet.ts",
+    "demo:autonomous-portfolio:devnet": "ts-node src/scripts/runAutonomousPortfolioDevnet.ts",
+    "defi:all": "ts-node src/scripts/runDeFiSuite.ts",
+    "defi:universal": "ts-node src/scripts/runUniversalDeFiDemo.ts",
+    "agent:defi:universal": "ts-node src/scripts/runAgentUniversalDeFi.ts",
+    "defi:all:sim": "ts-node src/scripts/runDeFiSuite.ts",
+    "defi:lp": "ts-node src/scripts/runLpStrategy.ts",
+    "defi:lp:sim": "ts-node src/scripts/runLpStrategy.ts",
+    "defi:lp:devnet": "ts-node src/scripts/runRaydiumLpDevnet.ts",
+    "defi:orca:devnet": "ts-node src/scripts/runOrcaLpDevnet.ts",
+    "defi:kamino:devnet": "ts-node src/scripts/runKaminoDevnet.ts",
+    "defi:borrow": "ts-node src/scripts/runBorrowStrategy.ts",
+    "defi:borrow:sim": "ts-node src/scripts/runBorrowStrategy.ts",
+    "defi:stake": "ts-node src/scripts/runStakeStrategy.ts",
+    "defi:stake:sim": "ts-node src/scripts/runStakeStrategy.ts",
+    "defi:stake:devnet": "ts-node src/scripts/runMarinadeDevnet.ts",
+    "defi:yield": "ts-node src/scripts/runYieldStrategy.ts",
+    "defi:yield:sim": "ts-node src/scripts/runYieldStrategy.ts",
+    "wallet:gasless": "ts-node src/scripts/runGaslessWalletDemo.ts",
+    "kora:memo": "ts-node src/scripts/runGaslessMemo.ts",
+    "trade:simulate": "ts-node src/scripts/runTradeLoop.ts",
+    "simulate-attack": "ts-node src/scripts/simulateAttack.ts",
+    "simulate:swarm": "ts-node src/scripts/simulateSwarm.ts",
+    "stress:agents": "ts-node src/scripts/runStressTest.ts",
+    "release:check": "ts-node src/scripts/runReleaseReadiness.ts",
+    "demo:rehearsal": "ts-node src/scripts/runDemoRehearsal.ts",
+    "test": "jest --runInBand",
+    "test:coverage": "jest --runInBand --coverage",
+    "test:watch": "jest --watch",
+    "wallet:devnet": "ts-node src/scripts/runDevnetWalletDemo.ts",
+    "demo:multi-agent:devnet": "ts-node src/demo/scripts/runMultiAgentDevnetDemo.ts",
+    "wallet:status": "ts-node src/index.ts"
+  },
+  "keywords": [
+    "solana",
+    "agent",
+    "wallet",
+    "typescript"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.32.1",
+    "@kamino-finance/klend-sdk": "^7.3.20",
+    "@marinade.finance/marinade-ts-sdk": "^5.0.18",
+    "@orca-so/common-sdk": "^0.7.0",
+    "@orca-so/whirlpools-sdk": "^0.20.0",
+    "@raydium-io/raydium-sdk-v2": "^0.1.95-alpha",
+    "@solana/spl-token": "^0.4.14",
+    "@solana/web3.js": "^1.98.4",
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0",
+    "decimal.js": "^10.6.0",
+    "dotenv": "^16.6.1",
+    "solana-agent-kit": "^1.4.9"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.6.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}