@prktsol/prkt 1.0.0

package/dist/scripts/releaseReadiness.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommandCheck = runCommandCheck;
+exports.evaluateProductionTodo = evaluateProductionTodo;
+exports.findOpenBlockingTodoItems = findOpenBlockingTodoItems;
+exports.runReadinessChecks = runReadinessChecks;
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const BLOCKING_TODO_SECTION_PREFIXES = [
+    "## P0 Blockers",
+    "## P1 Security Hardening",
+    "## P1 End-to-End Live Paths",
+    "## P0 Test and Release Gates",
+    "## Mainnet Deployment Gate"
+];
+function runCommandCheck(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 evaluateProductionTodo(todoPath = "PRODUCTION_READINESS_TODO.md") {
+    if (!(0, fs_1.existsSync)(todoPath)) {
+        return {
+            detail: todoPath,
+            ok: false,
+            title: "Production TODO present"
+        };
+    }
+    const blockingItems = findOpenBlockingTodoItems((0, fs_1.readFileSync)(todoPath, "utf8"));
+    if (blockingItems.length === 0) {
+        return {
+            detail: "No open P0/P1/mainnet deployment blockers",
+            ok: true,
+            title: "Production blockers cleared"
+        };
+    }
+    return {
+        detail: blockingItems.join(" | "),
+        ok: false,
+        title: "Production blockers cleared"
+    };
+}
+function findOpenBlockingTodoItems(markdown) {
+    const openItems = [];
+    let currentSection = "";
+    for (const rawLine of markdown.split(/\r?\n/u)) {
+        const line = rawLine.trim();
+        if (line.startsWith("## ")) {
+            currentSection = line;
+            continue;
+        }
+        if (!BLOCKING_TODO_SECTION_PREFIXES.some((section) => currentSection.startsWith(section))) {
+            continue;
+        }
+        const match = line.match(/^- \[ \] (.+)$/u);
+        if (!match) {
+            continue;
+        }
+        openItems.push(`${currentSection.replace(/^## /u, "")}: ${match[1]}`);
+    }
+    return openItems;
+}
+function runReadinessChecks() {
+    const npmCommand = "npm";
+    const checks = [];
+    checks.push({
+        detail: ".env.example",
+        ok: (0, fs_1.existsSync)(".env.example"),
+        title: "Env template present"
+    });
+    checks.push({
+        detail: "SKILLS.md",
+        ok: (0, fs_1.existsSync)("SKILLS.md"),
+        title: "Agent skills file present"
+    });
+    checks.push({
+        detail: "README.md",
+        ok: (0, fs_1.existsSync)("README.md"),
+        title: "README present"
+    });
+    checks.push(evaluateProductionTodo());
+    checks.push(runCommandCheck(npmCommand, ["run", "build"]));
+    checks.push(runCommandCheck("node", ["dist/cli/index.js", "--help"]));
+    checks.push(runCommandCheck(npmCommand, ["run", "test:coverage"]));
+    checks.push(runCommandCheck(npmCommand, ["pack", "--dry-run", "--cache", ".npm-cache"]));
+    return checks;
+}

package/dist/scripts/runAgentUniversalDeFi.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const AgentRunner_1 = require("../agent/runner/AgentRunner");
+const UniversalDeFiStrategy_1 = require("../agent/strategies/UniversalDeFiStrategy");
+const agentPolicies_1 = require("../config/agentPolicies");
+const env_1 = require("../config/env");
+const BalanceService_1 = require("../core/balances/BalanceService");
+const RpcClient_1 = require("../core/rpc/RpcClient");
+const TokenService_1 = require("../core/tokens/TokenService");
+const TransactionService_1 = require("../core/transactions/TransactionService");
+const universal_1 = require("../defi/universal");
+const managedAgentWallet_1 = require("./managedAgentWallet");
+const mode_1 = require("./mode");
+const shared_1 = require("./shared");
+const DEFAULT_AGENT_NAME = "agent-universal-defi";
+async function main() {
+    (0, mode_1.printDemoMode)("SIMULATED", "AgentRunner universal DeFi flow (agent emits trade/lp/lending/borrowing/yield/staking intents)");
+    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 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 balanceService = new BalanceService_1.BalanceService(rpcClient, tokenService);
+    const koraSigner = (0, shared_1.createKoraSigner)();
+    const universalDeFi = new universal_1.UniversalDeFiOrchestrator({
+        koraSigner,
+        liveFirst: false,
+        logger: (message) => console.log(`[universal-defi] ${message}`),
+        walletManager
+    });
+    const runner = new AgentRunner_1.AgentRunner();
+    const agentId = managed.agent.name;
+    (0, managedAgentWallet_1.logManagedAgentWallet)(managed);
+    runner.registerAgent({
+        context: {
+            id: agentId,
+            walletManager,
+            walletPublicKey: walletManager.publicKey,
+            rpcClient,
+            transactionService,
+            tokenService,
+            balanceService,
+            policyConfig: (0, agentPolicies_1.createDefaultPolicyConfig)({
+                agentId
+            }),
+            logger: (message) => console.log(`[${agentId}] ${message}`),
+            universalDeFiExecutor: universalDeFi
+        },
+        strategy: new UniversalDeFiStrategy_1.UniversalDeFiStrategy([
+            {
+                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: "raydium",
+                snapshot: {
+                    rewardsClaimableAtomic: 750_000
+                }
+            }
+        ])
+    });
+    const result = await runner.runOnceParallel();
+    console.log("Agent universal DeFi run complete.");
+    for (const agent of result) {
+        for (const outcome of agent.outcomes) {
+            const intentType = outcome.intent.type;
+            const suffix = outcome.signature ? `signature=${outcome.signature}` : "HOLD";
+            console.log(`${agent.agentId} ${intentType} -> ${suffix}`);
+        }
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Agent universal DeFi run failed: ${message}`);
+    process.exitCode = 1;
+});

package/dist/scripts/runAutonomousAgentWalletDevnet.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const marinade_ts_sdk_1 = require("@marinade.finance/marinade-ts-sdk");
+const web3_js_1 = require("@solana/web3.js");
+const AgentRunner_1 = require("../agent/runner/AgentRunner");
+const UniversalDeFiStrategy_1 = require("../agent/strategies/UniversalDeFiStrategy");
+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 universal_1 = require("../defi/universal");
+const managedAgentWallet_1 = require("./managedAgentWallet");
+const mode_1 = require("./mode");
+const shared_1 = require("./shared");
+const DEFAULT_AGENT_NAME = "agent-autonomous-wallet";
+const REQUIRED_FUNDING_SOL = 0.5;
+const DEFAULT_STAKE_SOL = 0.15;
+async function main() {
+    (0, mode_1.printDemoMode)("LIVE", "Autonomous agent wallet: provision or load the assigned agent wallet, fund on devnet, execute live Marinade stake, and verify owner stop control");
+    const rpcUrl = (0, env_1.getRpcUrl)();
+    const cluster = (0, env_1.detectClusterFromRpcUrl)(rpcUrl);
+    if (cluster !== "devnet") {
+        throw new Error(`Autonomous agent wallet 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;
+    const logger = (0, shared_1.createRuntimeLogger)("autonomous-agent");
+    const agentId = managed.agent.name;
+    console.log("PRKT autonomous agent wallet 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 marinade = new marinade_ts_sdk_1.Marinade(new marinade_ts_sdk_1.MarinadeConfig({
+        connection: rpcClient.connection,
+        publicKey: walletManager.publicKey
+    }));
+    const marinadeState = await marinade.getMarinadeState();
+    const msolMint = marinadeState.mSolMintAddress;
+    const solBefore = await balanceService.getSolBalance(walletManager.publicKey);
+    const msolBefore = await balanceService.getSplTokenBalance({
+        mint: msolMint,
+        owner: walletManager.publicKey
+    });
+    const koraSigner = (0, shared_1.createKoraSigner)();
+    const universalDeFi = new universal_1.UniversalDeFiOrchestrator({
+        koraSigner,
+        liveFirst: true,
+        logger,
+        walletManager
+    });
+    const runner = new AgentRunner_1.AgentRunner();
+    runner.registerAgent({
+        context: {
+            id: agentId,
+            walletManager,
+            walletPublicKey: walletManager.publicKey,
+            rpcClient,
+            transactionService,
+            tokenService,
+            balanceService,
+            policyConfig: (0, agentPolicies_1.createDefaultPolicyConfig)({
+                agentId,
+                maxSolPerTxLamports: Math.round(0.3 * web3_js_1.LAMPORTS_PER_SOL),
+                maxTransactionsPerDay: 10,
+                maxTransactionsPerSession: 3
+            }),
+            logger,
+            universalDeFiExecutor: universalDeFi
+        },
+        strategy: new UniversalDeFiStrategy_1.UniversalDeFiStrategy([
+            {
+                capability: "staking",
+                protocol: "marinade",
+                snapshot: {
+                    idleSolLamports: Math.round(solBefore * web3_js_1.LAMPORTS_PER_SOL)
+                }
+            }
+        ]),
+        approvalMode: "sandbox"
+    });
+    const [runResult] = await runner.runOnceParallel();
+    if (!runResult) {
+        throw new Error("Autonomous agent run did not produce a result.");
+    }
+    const [stakeOutcome] = runResult.outcomes;
+    if (!stakeOutcome) {
+        throw new Error("Autonomous agent produced no staking outcome.");
+    }
+    if (!stakeOutcome.allowed || !stakeOutcome.signature) {
+        throw new Error(`Autonomous stake was blocked: ${stakeOutcome.reasons.join("; ") || "unknown reason"}`);
+    }
+    const solAfter = await balanceService.getSolBalance(walletManager.publicKey);
+    const msolAfter = await balanceService.getSplTokenBalance({
+        mint: msolMint,
+        owner: walletManager.publicKey
+    });
+    if (msolAfter <= msolBefore) {
+        throw new Error(`Autonomous stake verification failed: mSOL did not increase (${msolBefore.toFixed(6)} -> ${msolAfter.toFixed(6)}).`);
+    }
+    console.log("");
+    console.log("Autonomous run");
+    console.log(`Agent: ${agentId}`);
+    console.log(`Intent: stake ${DEFAULT_STAKE_SOL.toFixed(2)} SOL via Marinade`);
+    console.log(`Signature: ${stakeOutcome.signature}`);
+    console.log(`SOL before: ${solBefore.toFixed(4)}`);
+    console.log(`SOL after: ${solAfter.toFixed(4)}`);
+    console.log(`mSOL before: ${msolBefore.toFixed(6)}`);
+    console.log(`mSOL after: ${msolAfter.toFixed(6)}`);
+    const originalEmergencyLock = process.env.POLICY_EMERGENCY_LOCK;
+    process.env.POLICY_EMERGENCY_LOCK = "true";
+    try {
+        const [lockedRun] = await runner.runOnceParallel();
+        const [lockedOutcome] = lockedRun?.outcomes ?? [];
+        if (!lockedOutcome || lockedOutcome.allowed) {
+            throw new Error("Emergency lock supervision check failed: agent execution was not blocked.");
+        }
+        console.log("");
+        console.log("Owner supervision");
+        console.log("Emergency lock engaged via POLICY_EMERGENCY_LOCK=true");
+        console.log(`Blocked reasons: ${lockedOutcome.reasons.join("; ")}`);
+    }
+    finally {
+        if (originalEmergencyLock === undefined) {
+            delete process.env.POLICY_EMERGENCY_LOCK;
+        }
+        else {
+            process.env.POLICY_EMERGENCY_LOCK = originalEmergencyLock;
+        }
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Autonomous agent wallet demo failed: ${message}`);
+    process.exitCode = 1;
+});