@prktsol/prkt 1.0.0 → 1.0.1

package/dist/agent/strategies/UniversalDeFiStrategy.d.ts

@@ -0,0 +1,22 @@
+import type { AgentIntent } from "../intents/types";
+import type { AgentContext, Strategy } from "../types/AgentContext";
+export declare class UniversalDeFiStrategy implements Strategy {
+    private readonly requests;
+    readonly name = "universal-defi";
+    constructor(requests: Array<{
+        capability: "trade" | "lp" | "lending" | "borrowing" | "yield" | "staking";
+        protocol?: "jupiter" | "raydium" | "kamino" | "marinade";
+        snapshot: {
+            borrowDemandUsdcAtomic?: number;
+            buyThresholdUsd?: number;
+            collateralSolLamports?: number;
+            healthFactor?: number;
+            idleSolLamports?: number;
+            idleUsdcAtomic?: number;
+            liquidityInRange?: boolean;
+            rewardsClaimableAtomic?: number;
+            solPriceUsd?: number;
+        };
+    }>);
+    nextIntents(_context: AgentContext): Promise<AgentIntent[]>;
+}

package/dist/agent/types/AgentContext.d.ts

@@ -0,0 +1,28 @@
+import type { PublicKey } from "@solana/web3.js";
+import type { BalanceService } from "../../core/balances/BalanceService";
+import type { RpcClient } from "../../core/rpc/RpcClient";
+import type { TokenService } from "../../core/tokens/TokenService";
+import type { TransactionService } from "../../core/transactions/TransactionService";
+import type { WalletManager } from "../../core/wallet/WalletManager";
+import type { PolicyConfig } from "../../policy";
+import type { AgentIntent } from "../intents/types";
+import type { UniversalDeFiRequest, UniversalExecutionOptions, UniversalExecutionResult } from "../../defi/universal";
+export type AgentLogger = (message: string) => void;
+export type AgentContext = {
+    id: string;
+    walletManager: WalletManager;
+    walletPublicKey: PublicKey;
+    rpcClient: RpcClient;
+    transactionService: TransactionService;
+    tokenService: TokenService;
+    balanceService: BalanceService;
+    policyConfig: PolicyConfig;
+    logger: AgentLogger;
+    universalDeFiExecutor?: {
+        execute(request: UniversalDeFiRequest, options?: UniversalExecutionOptions): Promise<UniversalExecutionResult>;
+    };
+};
+export type Strategy = {
+    name: string;
+    nextIntents(context: AgentContext): Promise<AgentIntent[]>;
+};

package/dist/anchoring/SessionAnchor.d.ts

@@ -0,0 +1,42 @@
+import { AuditEntry } from "../compression/types";
+import { WalletManager } from "../core/wallet/WalletManager";
+export type SessionStartResult = {
+    compressedAnchorAddress?: string;
+    compressedAnchorSignature?: string;
+    sessionId: string;
+    slot: number;
+    startSignature: string;
+};
+export type SessionCloseResult = {
+    closeSignature: string;
+    compressedAnchorAddress?: string;
+    compressedAnchorSignature?: string;
+    commitment: string;
+    entryCount: number;
+    explorerUrl: string;
+    ledgerSlot: number;
+    sessionId: string;
+    slot: number;
+};
+export type SessionVerifyResult = {
+    closeSignature?: string;
+    commitment?: string;
+    entries: AuditEntry[];
+    entryCount: number;
+    explorerUrl?: string;
+    reason?: string;
+    slot?: number;
+    valid: boolean;
+};
+export declare class SessionAnchor {
+    private readonly rpcEndpoint;
+    private readonly walletManager?;
+    private static readonly sessionRegistry;
+    constructor(rpcEndpoint: string, walletManager?: WalletManager | undefined);
+    startSession(agentId: string): Promise<SessionStartResult>;
+    closeSession(sessionId: string, auditLog: AuditEntry[]): Promise<SessionCloseResult>;
+    verifySession(sessionId: string, commitment?: string): Promise<SessionVerifyResult>;
+    private buildExplorerUrl;
+    private getPayer;
+    private getStore;
+}

package/dist/anchoring/SessionAnchor.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionAnchor = void 0;
+const crypto_1 = require("crypto");
+const PRKTError_1 = require("../errors/PRKTError");
+const WalletManager_1 = require("../core/wallet/WalletManager");
+const memoLedger_1 = require("../solana/memoLedger");
+const CompressedDataAccount_1 = require("../zkCompression/CompressedDataAccount");
+const SESSION_START_DISCRIMINATOR = "PRKTSS01";
+const SESSION_CLOSE_DISCRIMINATOR = "PRKTSC01";
+class SessionAnchor {
+    rpcEndpoint;
+    walletManager;
+    static sessionRegistry = new Map();
+    constructor(rpcEndpoint, walletManager) {
+        this.rpcEndpoint = rpcEndpoint;
+        this.walletManager = walletManager;
+    }
+    async startSession(agentId) {
+        try {
+            const sessionId = (0, crypto_1.randomUUID)();
+            const payload = {
+                agentId,
+                event: "SESSION_START",
+                prkt: 1,
+                sessionId,
+                ts: Date.now()
+            };
+            const anchored = await this.getStore().writeAccount({
+                discriminator: SESSION_START_DISCRIMINATOR,
+                namespace: "prkt-session-start",
+                parts: [sessionId],
+                payer: this.getPayer(),
+                payload
+            });
+            SessionAnchor.sessionRegistry.set(sessionId, {
+                startCompressedAddress: anchored.address,
+                startSignature: anchored.signature
+            });
+            return {
+                compressedAnchorAddress: anchored.address,
+                compressedAnchorSignature: anchored.signature,
+                sessionId,
+                slot: anchored.slot ?? 0,
+                startSignature: anchored.signature
+            };
+        }
+        catch (error) {
+            throw new PRKTError_1.AnchorError(`Failed to start session: ${error}`);
+        }
+    }
+    async closeSession(sessionId, auditLog) {
+        try {
+            const serialized = JSON.stringify(auditLog);
+            const hash = (0, crypto_1.createHash)("sha256").update(serialized).digest("hex");
+            const payload = {
+                entryCount: auditLog.length,
+                event: "SESSION_CLOSE",
+                logHash: hash,
+                prkt: 1,
+                sessionId,
+                ts: Date.now()
+            };
+            const anchored = await this.getStore().writeAccount({
+                discriminator: SESSION_CLOSE_DISCRIMINATOR,
+                namespace: "prkt-session-close",
+                parts: [sessionId],
+                payer: this.getPayer(),
+                payload
+            });
+            SessionAnchor.sessionRegistry.set(sessionId, {
+                ...SessionAnchor.sessionRegistry.get(sessionId),
+                closeCompressedAddress: anchored.address,
+                closeSignature: anchored.signature,
+                commitment: hash,
+                entryCount: auditLog.length
+            });
+            return {
+                closeSignature: anchored.signature,
+                compressedAnchorAddress: anchored.address,
+                compressedAnchorSignature: anchored.signature,
+                commitment: hash,
+                entryCount: auditLog.length,
+                explorerUrl: this.buildExplorerUrl(anchored.signature),
+                ledgerSlot: anchored.slot ?? 0,
+                sessionId,
+                slot: anchored.slot ?? 0
+            };
+        }
+        catch (error) {
+            throw new PRKTError_1.AnchorError(`Failed to close session: ${error}`);
+        }
+    }
+    async verifySession(sessionId, commitment) {
+        try {
+            const record = await this.getStore().readAccount({
+                discriminator: SESSION_CLOSE_DISCRIMINATOR,
+                namespace: "prkt-session-close",
+                parts: [sessionId]
+            });
+            if (!record.exists || !record.payload) {
+                return {
+                    entries: [],
+                    entryCount: 0,
+                    reason: record.reason ?? "SESSION_NOT_FOUND",
+                    valid: false
+                };
+            }
+            const payload = record.payload;
+            if (payload.event !== "SESSION_CLOSE" || payload.sessionId !== sessionId) {
+                return {
+                    closeSignature: record.signature,
+                    entries: [],
+                    entryCount: 0,
+                    reason: "SESSION_RECORD_INVALID",
+                    valid: false
+                };
+            }
+            if (commitment && payload.logHash !== commitment) {
+                return {
+                    closeSignature: record.signature,
+                    commitment: payload.logHash,
+                    entries: [],
+                    entryCount: payload.entryCount,
+                    explorerUrl: record.explorerUrl,
+                    reason: "HASH_MISMATCH",
+                    slot: record.slot,
+                    valid: false
+                };
+            }
+            return {
+                closeSignature: record.signature,
+                commitment: payload.logHash,
+                entries: [],
+                entryCount: payload.entryCount,
+                explorerUrl: record.explorerUrl,
+                slot: record.slot,
+                valid: true
+            };
+        }
+        catch (error) {
+            throw new PRKTError_1.AnchorError(`Failed to verify session: ${error}`);
+        }
+    }
+    buildExplorerUrl(signature) {
+        return (0, memoLedger_1.buildExplorerTxUrl)(signature, this.rpcEndpoint);
+    }
+    getPayer() {
+        const wallet = this.walletManager ?? WalletManager_1.WalletManager.loadOrGenerate();
+        try {
+            return wallet.payer;
+        }
+        catch (error) {
+            throw new PRKTError_1.AnchorError(`Compressed session storage requires a local signer: ${error}`);
+        }
+    }
+    getStore() {
+        return new CompressedDataAccount_1.CompressedDataAccount(this.rpcEndpoint);
+    }
+}
+exports.SessionAnchor = SessionAnchor;

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -1,5 +1,38 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = require("fs");
 const spl_token_1 = require("@solana/spl-token");
@@ -22,14 +55,84 @@ const DevnetFundingService_1 = require("../core/funding/DevnetFundingService");
 const multiAgentDevnetScenario_1 = require("../demo/scenarios/multiAgentDevnetScenario");
 const policy_1 = require("../policy");
 const completion_1 = require("./utils/completion");
+const CLI_BANNER = String.raw `██████╗ ██████╗ ██╗  ██╗████████╗
+██╔══██╗██╔══██╗██║ ██╔╝╚══██╔══╝
+██████╔╝██████╔╝█████╔╝    ██║
+██╔═══╝ ██╔══██╗██╔═██╗    ██║
+██║     ██║  ██║██║  ██╗   ██║
+╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝
+
+Policy-Enforced Autonomous Agent Runtime
+Solana Infrastructure Layer`;
 const program = new commander_1.Command();
 const walletRegistry = new walletRegistry_1.WalletRegistry();
 const agentRegistry = new agentRegistry_1.AgentRegistryStore(walletRegistry);
 const activityStore = new activityStore_1.ActivityStore();
 const CUSTODY_MODEL = "local-per-user";
 const POLICY_EXECUTION_MODEL = "user-owned agent wallets with policy-guarded execution";
+function shouldPrintStartupBanner(argv) {
+    if (argv.includes("--json")) {
+        return false;
+    }
+    return !argv.includes("completion");
+}
+function inspectSignerConfiguration() {
+    try {
+        const remoteSigner = (0, env_1.getRemoteSignerConfig)();
+        if (remoteSigner) {
+            return {
+                detail: `remote signer ${remoteSigner.publicKey.toBase58()}`,
+                status: "ok"
+            };
+        }
+        const treasurySecretKey = (0, env_1.getOptionalDevnetTreasurySecretKey)();
+        if (treasurySecretKey) {
+            return {
+                detail: "devnet treasury key present",
+                status: "ok"
+            };
+        }
+        const localSecretKey = (0, env_1.getOptionalSecretKey)();
+        if (localSecretKey) {
+            return {
+                detail: "local demo key present",
+                status: "ok"
+            };
+        }
+        return {
+            detail: "missing signer configuration",
+            status: "warn"
+        };
+    }
+    catch (error) {
+        return {
+            detail: error instanceof Error ? error.message : "invalid signer configuration",
+            status: "fail"
+        };
+    }
+}
 function outputOptions(command) {
-    const options = command.optsWithGlobals();
+    if (command &&
+        typeof command === "object" &&
+        "optsWithGlobals" in command &&
+        typeof command.optsWithGlobals === "function") {
+        const options = command.optsWithGlobals();
+        return {
+            json: Boolean(options.json)
+        };
+    }
+    if (command &&
+        typeof command === "object" &&
+        "opts" in command &&
+        typeof command.opts === "function") {
+        const options = command.opts();
+        return {
+            json: Boolean(options.json)
+        };
+    }
+    const options = command && typeof command === "object" && "json" in command
+        ? command
+        : {};
     return {
         json: Boolean(options.json)
     };
@@ -162,6 +265,51 @@ program
     activity("config", { action: "init" });
     (0, output_1.printResult)(outputOptions(command), payload, "PRKT initialized");
 });
+program
+    .command("verify-session <sessionId>")
+    .option("--commitment <hash>", "on-chain commitment hash")
+    .description("verify an agent session log against the compressed session anchor on Solana devnet")
+    .action(async (sessionId, options) => {
+    const { SessionAnchor } = await Promise.resolve().then(() => __importStar(require("../anchoring/SessionAnchor")));
+    const { defaultPRKTConfig } = await Promise.resolve().then(() => __importStar(require("../config/PRKTConfig")));
+    const anchor = new SessionAnchor(defaultPRKTConfig.zkCompression.rpcEndpoint);
+    try {
+        const result = await anchor.verifySession(sessionId, options.commitment);
+        const output = outputOptions(program);
+        if (!output.json && result.valid) {
+            console.log(`Session valid ✓ | ${result.entryCount} entries | anchored at slot ${result.slot ?? "unknown"}`);
+        }
+        else if (!output.json) {
+            console.log(`Session invalid ✗${result.reason ? ` | ${result.reason}` : ""}`);
+        }
+        (0, output_1.printResult)(output, result, "Session verification");
+    }
+    catch (error) {
+        (0, output_1.failWithMessage)(error);
+    }
+});
+program
+    .command("verify-tx <txSignature>")
+    .description("verify a transaction's compressed policy proof on Solana devnet")
+    .action(async (txSignature) => {
+    const { ProofAnchor } = await Promise.resolve().then(() => __importStar(require("../zk/ProofAnchor")));
+    const { defaultPRKTConfig } = await Promise.resolve().then(() => __importStar(require("../config/PRKTConfig")));
+    const anchor = new ProofAnchor(defaultPRKTConfig.zkCompression.rpcEndpoint);
+    try {
+        const result = await anchor.verifyProof(txSignature);
+        const output = outputOptions(program);
+        if (!output.json && result.valid) {
+            console.log(`Policy attestation valid ✓ | prover ${result.attestation?.prover ?? "unknown"} | slot ${result.slot ?? "unknown"}`);
+        }
+        else if (!output.json) {
+            console.log(`Policy attestation invalid ✗${result.reason ? ` | ${result.reason}` : ""}`);
+        }
+        (0, output_1.printResult)(output, result, "Transaction proof verification");
+    }
+    catch (error) {
+        (0, output_1.failWithMessage)(error);
+    }
+});
 const wallet = program.command("wallet").description("wallet management and transfers");
 wallet
     .command("create")
@@ -1052,8 +1200,8 @@ program
         status: (0, env_1.detectClusterFromRpcUrl)(rpc) === "devnet" ? "ok" : "warn"
     });
     try {
-        const connection = new web3_js_1.Connection(rpc, "confirmed");
-        await connection.getLatestBlockhash("confirmed");
+        const rpcClient = new RpcClient_1.RpcClient(rpc, "confirmed");
+        await rpcClient.getLatestBlockhash("confirmed");
         checks.push({
             check: "rpc-connectivity",
             details: rpc,
@@ -1067,21 +1215,11 @@ program
             status: "fail"
         });
     }
-    const remoteSigner = (0, env_1.getRemoteSignerConfig)();
-    const treasurySecretKey = (0, env_1.getOptionalDevnetTreasurySecretKey)();
-    const treasuryExists = Boolean(remoteSigner ||
-        treasurySecretKey ||
-        (process.env.AGENT_PRIVATE_KEY && process.env.AGENT_PRIVATE_KEY.length > 0));
+    const signerCheck = inspectSignerConfiguration();
     checks.push({
         check: "treasury-key",
-        details: remoteSigner
-            ? `remote signer ${remoteSigner.publicKey.toBase58()}`
-            : treasurySecretKey
-                ? "devnet treasury key present"
-                : treasuryExists
-                    ? "local demo key present"
-                    : "missing signer configuration",
-        status: treasuryExists ? "ok" : "warn"
+        details: signerCheck.detail,
+        status: signerCheck.status
     });
     checks.push({
         check: "custody-model",
@@ -1148,6 +1286,9 @@ program
 });
 async function main() {
     try {
+        if (shouldPrintStartupBanner(process.argv.slice(2))) {
+            console.log(`${CLI_BANNER}\n`);
+        }
         await program.parseAsync(process.argv);
     }
     catch (error) {

package/dist/cli/services/activityStore.d.ts

@@ -0,0 +1,8 @@
+import type { ActivityRecord } from "../types";
+export declare class ActivityStore {
+    append(record: ActivityRecord): void;
+    list(limit?: number): ActivityRecord[];
+    listByAgent(agent: string, limit?: number): ActivityRecord[];
+    private read;
+    private write;
+}

package/dist/cli/services/agentRegistry.d.ts

@@ -0,0 +1,20 @@
+import type { StoredAgentRecord } from "../types";
+import { WalletRegistry } from "./walletRegistry";
+export declare class AgentRegistryStore {
+    private readonly walletRegistry;
+    constructor(walletRegistry?: WalletRegistry);
+    list(): StoredAgentRecord[];
+    find(name: string): StoredAgentRecord | undefined;
+    ensureForWallet(walletName: string): StoredAgentRecord;
+    createAgent(input: {
+        agentId: string;
+        ownerId?: string;
+        walletName?: string;
+    }): StoredAgentRecord;
+    upsert(record: StoredAgentRecord): StoredAgentRecord;
+    patch(name: string, update: Partial<StoredAgentRecord>): StoredAgentRecord;
+    synchronizeWithWallets(): StoredAgentRecord[];
+    private read;
+    private write;
+    private normalize;
+}

package/dist/cli/services/agentRuntime.d.ts

@@ -0,0 +1,6 @@
+import type { AgentRunResult } from "../../agent/runner/AgentRunner";
+import type { StoredAgentRecord } from "../types";
+export declare function runAgentOnce(input: {
+    agent: StoredAgentRecord;
+    overrideStrategy?: string;
+}): Promise<AgentRunResult>;

package/dist/cli/services/storagePaths.d.ts

@@ -0,0 +1,8 @@
+export declare function getCliDataDir(): string;
+export declare function resolveCliDataPath(fileName: string): string;
+export declare function getCliHomeEnvName(): string;
+export declare function probeCliDataDir(): {
+    details: string;
+    path: string;
+    writable: boolean;
+};

package/dist/cli/services/strategyFactory.d.ts

@@ -0,0 +1,5 @@
+import type { Strategy } from "../../agent/types/AgentContext";
+export declare function createStrategy(input: {
+    name: string;
+    config?: Record<string, unknown>;
+}): Strategy;

package/dist/cli/services/walletCrypto.d.ts

@@ -0,0 +1,12 @@
+import type { RecoveryPackage, WalletCiphertext } from "../types";
+export declare function encryptSecretKeyForPlatform(secretKey: Uint8Array): WalletCiphertext;
+export declare function decryptSecretKeyForPlatform(payload: WalletCiphertext): Uint8Array;
+export declare function createRecoveryPackage(secretKey: Uint8Array): {
+    recoveryKey: string;
+    recoveryPackage: RecoveryPackage;
+};
+export declare function decryptSecretKeyWithRecovery(input: {
+    recoveryKey: string;
+    recoveryPackage: RecoveryPackage;
+}): Uint8Array;
+export declare function getPlatformMasterKeySource(): "env" | "local-file";

package/dist/cli/services/walletRegistry.d.ts

@@ -0,0 +1,26 @@
+import type { StoredWalletRecord } from "../types";
+import { WalletManager } from "../../core/wallet/WalletManager";
+export type WalletProvisionResult = {
+    created: boolean;
+    record: StoredWalletRecord;
+    recoveryKey: string | null;
+};
+export declare class WalletRegistry {
+    list(): StoredWalletRecord[];
+    find(name: string): StoredWalletRecord | undefined;
+    create(name: string): WalletProvisionResult;
+    toWalletManager(name: string): WalletManager;
+    ensureFromEnv(name: string): WalletProvisionResult;
+    exportSecretKeyWithRecovery(input: {
+        name: string;
+        recoveryKey: string;
+    }): Uint8Array;
+    private provision;
+    private requireRecord;
+    private read;
+    private write;
+    private maybeMigrateLegacyRecord;
+    private normalize;
+    private resolveSecretKey;
+}
+export declare function generateTemporaryWalletName(): string;

package/dist/cli/types.d.ts

@@ -0,0 +1,68 @@
+export type StoredWalletRecord = {
+    createdAtIso: string;
+    encryptedSecretKey?: WalletCiphertext;
+    name: string;
+    publicKey: string;
+    recoveryPackage?: RecoveryPackage;
+    secretKey?: number[];
+    version?: 1 | 2;
+};
+export type WalletCiphertext = {
+    algorithm: "aes-256-gcm";
+    ciphertext: string;
+    iv: string;
+    tag: string;
+};
+export type RecoveryPackage = {
+    algorithm: "scrypt-aes-256-gcm";
+    ciphertext: string;
+    iv: string;
+    kdf: "scrypt";
+    salt: string;
+    tag: string;
+};
+export type ActivityKind = "wallet" | "transfer" | "token" | "policy" | "agent" | "monitor" | "demo" | "doctor" | "config";
+export type ActivityRecord = {
+    agent?: string;
+    createdAtIso: string;
+    details: Record<string, unknown>;
+    kind: ActivityKind;
+    signature?: string;
+};
+export type StoredAgentRecord = {
+    createdAtIso: string;
+    lastAction?: string;
+    lastError?: string;
+    lastRunAtIso?: string;
+    lastSignature?: string;
+    name: string;
+    ownerId?: string;
+    policyMode: "sandbox" | "live";
+    policyOverrides?: StoredPolicyOverrides;
+    policyPreset: PolicyPresetName;
+    status: "active" | "stopped";
+    strategy: string;
+    strategyConfig?: Record<string, unknown>;
+    trackedMints?: string[];
+    walletName: string;
+};
+export type PolicyPresetName = "observe-only" | "simulate-only" | "auto-devnet-safe" | "guarded-live" | "custom";
+export type StoredPolicyOverrides = {
+    allowOpaqueProgramIds?: string[];
+    allowedCloseAccountDestinations?: string[];
+    allowedMints?: string[];
+    allowedTransferDestinations?: string[];
+    approvalMode?: "sandbox" | "live";
+    denyUnknownInstructionsByDefault?: boolean;
+    extraAllowedProgramIds?: string[];
+    maxSolPerTxLamports?: number;
+    maxSplPerTxRawAmount?: string;
+    maxTransactionsPerDay?: number;
+    maxTransactionsPerSession?: number;
+    rejectSuspiciousBalanceDeltas?: boolean;
+    requireSimulationSuccess?: boolean;
+    sessionTtlMinutes?: number;
+};
+export type CliOutputOptions = {
+    json: boolean;
+};

package/dist/cli/utils/completion.d.ts

@@ -0,0 +1,4 @@
+export declare function completionWords(): string;
+export declare function buildBashCompletion(): string;
+export declare function buildZshCompletion(): string;
+export declare function buildPowerShellCompletion(): string;

package/dist/cli/utils/output.d.ts

@@ -0,0 +1,5 @@
+import type { CliOutputOptions } from "../types";
+export declare function printResult(output: CliOutputOptions, payload: unknown, title?: string): void;
+export declare function txExplorer(signature: string): string;
+export declare function addressExplorer(address: string): string;
+export declare function failWithMessage(error: unknown): never;

package/dist/cli/utils/output.js

@@ -8,9 +8,12 @@ exports.txExplorer = txExplorer;
 exports.addressExplorer = addressExplorer;
 exports.failWithMessage = failWithMessage;
 const chalk_1 = __importDefault(require("chalk"));
+function jsonReplacer(_, value) {
+    return typeof value === "bigint" ? value.toString() : value;
+}
 function printResult(output, payload, title) {
     if (output.json) {
-        console.log(JSON.stringify(payload, null, 2));
+        console.log(JSON.stringify(payload, jsonReplacer, 2));
         return;
     }
     if (title) {