@prktsol/prkt 1.0.0

package/dist/core/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionIdempotencyGuard = exports.BalanceService = exports.TokenService = exports.PostTransactionVerifier = exports.TransactionService = exports.WalletManager = exports.RpcFailoverClient = exports.RpcClient = void 0;
+var RpcClient_1 = require("./rpc/RpcClient");
+Object.defineProperty(exports, "RpcClient", { enumerable: true, get: function () { return RpcClient_1.RpcClient; } });
+var RpcFailoverClient_1 = require("./rpc/RpcFailoverClient");
+Object.defineProperty(exports, "RpcFailoverClient", { enumerable: true, get: function () { return RpcFailoverClient_1.RpcFailoverClient; } });
+var WalletManager_1 = require("./wallet/WalletManager");
+Object.defineProperty(exports, "WalletManager", { enumerable: true, get: function () { return WalletManager_1.WalletManager; } });
+var TransactionService_1 = require("./transactions/TransactionService");
+Object.defineProperty(exports, "TransactionService", { enumerable: true, get: function () { return TransactionService_1.TransactionService; } });
+var PostTransactionVerifier_1 = require("./transactions/PostTransactionVerifier");
+Object.defineProperty(exports, "PostTransactionVerifier", { enumerable: true, get: function () { return PostTransactionVerifier_1.PostTransactionVerifier; } });
+var TokenService_1 = require("./tokens/TokenService");
+Object.defineProperty(exports, "TokenService", { enumerable: true, get: function () { return TokenService_1.TokenService; } });
+var BalanceService_1 = require("./balances/BalanceService");
+Object.defineProperty(exports, "BalanceService", { enumerable: true, get: function () { return BalanceService_1.BalanceService; } });
+var ExecutionIdempotencyGuard_1 = require("./idempotency/ExecutionIdempotencyGuard");
+Object.defineProperty(exports, "ExecutionIdempotencyGuard", { enumerable: true, get: function () { return ExecutionIdempotencyGuard_1.ExecutionIdempotencyGuard; } });

package/dist/core/rpc/RpcClient.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const env_1 = require("../../config/env");
+class RpcClient {
+    connection;
+    constructor(rpcUrl = (0, env_1.getRpcUrl)(), commitment = "confirmed") {
+        this.connection = new web3_js_1.Connection(rpcUrl, commitment);
+    }
+    get rpcUrl() {
+        return this.connection.rpcEndpoint;
+    }
+    async getLatestBlockhash(commitment = "confirmed") {
+        return this.connection.getLatestBlockhash(commitment);
+    }
+    async getBalance(publicKey, commitment = "confirmed") {
+        return this.connection.getBalance(publicKey, commitment);
+    }
+    async getTokenAccountBalance(publicKey, commitment = "confirmed") {
+        return this.connection.getTokenAccountBalance(publicKey, commitment);
+    }
+    async getAccountInfo(publicKey, commitment = "confirmed") {
+        return this.connection.getAccountInfo(publicKey, commitment);
+    }
+    async sendTransaction(transaction, options) {
+        return this.connection.sendTransaction(transaction, options);
+    }
+    async confirmTransaction(strategy, commitment = "confirmed") {
+        if (typeof strategy === "string") {
+            return this.connection.confirmTransaction(strategy, commitment);
+        }
+        return this.connection.confirmTransaction(strategy, commitment);
+    }
+    async simulateTransaction(transaction, options) {
+        return this.connection.simulateTransaction(transaction, {
+            commitment: options?.commitment ?? "confirmed",
+            sigVerify: options?.sigVerify ?? true
+        });
+    }
+    async requestAirdrop(publicKey, lamports) {
+        return this.connection.requestAirdrop(publicKey, lamports);
+    }
+}
+exports.RpcClient = RpcClient;

package/dist/core/rpc/RpcFailoverClient.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcFailoverClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_BASE_DELAY_MS = 500;
+const DEFAULT_MAX_DELAY_MS = 4000;
+/**
+ * RPC client with automatic failover from primary to fallback URL,
+ * exponential backoff, and random jitter on retries.
+ */
+class RpcFailoverClient {
+    primaryConnection;
+    fallbackConnection;
+    maxRetries;
+    baseDelayMs;
+    maxDelayMs;
+    commitment;
+    primaryUrl;
+    fallbackUrl;
+    constructor(config) {
+        this.commitment = config.commitment ?? "confirmed";
+        this.primaryUrl = config.primaryUrl;
+        this.fallbackUrl = config.fallbackUrl ?? null;
+        this.primaryConnection = new web3_js_1.Connection(config.primaryUrl, this.commitment);
+        this.fallbackConnection = config.fallbackUrl
+            ? new web3_js_1.Connection(config.fallbackUrl, this.commitment)
+            : null;
+        this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.baseDelayMs = config.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+        this.maxDelayMs = config.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+    }
+    get connection() {
+        return this.primaryConnection;
+    }
+    get rpcUrl() {
+        return this.primaryConnection.rpcEndpoint;
+    }
+    async getLatestBlockhash(commitment = "confirmed") {
+        return this.executeWithFailover((conn) => conn.getLatestBlockhash(commitment));
+    }
+    async getBalance(publicKey, commitment = "confirmed") {
+        return this.executeWithFailover((conn) => conn.getBalance(publicKey, commitment));
+    }
+    async getTokenAccountBalance(publicKey, commitment = "confirmed") {
+        return this.executeWithFailover((conn) => conn.getTokenAccountBalance(publicKey, commitment));
+    }
+    async getAccountInfo(publicKey, commitment = "confirmed") {
+        return this.executeWithFailover((conn) => conn.getAccountInfo(publicKey, commitment));
+    }
+    async sendTransaction(transaction, options) {
+        return this.executeWithFailover((conn) => conn.sendTransaction(transaction, options));
+    }
+    async confirmTransaction(strategy, commitment = "confirmed") {
+        return this.executeWithFailover((conn) => conn.confirmTransaction(strategy, commitment));
+    }
+    async simulateTransaction(transaction, options) {
+        return this.executeWithFailover((conn) => conn.simulateTransaction(transaction, {
+            commitment: options?.commitment ?? "confirmed",
+            sigVerify: options?.sigVerify ?? true
+        }));
+    }
+    async requestAirdrop(publicKey, lamports) {
+        return this.executeWithFailover((conn) => conn.requestAirdrop(publicKey, lamports));
+    }
+    async executeWithFailover(operation) {
+        const connections = [this.primaryConnection];
+        if (this.fallbackConnection) {
+            connections.push(this.fallbackConnection);
+        }
+        let lastError = null;
+        for (const conn of connections) {
+            for (let attempt = 0; attempt < this.maxRetries; attempt += 1) {
+                try {
+                    return await operation(conn);
+                }
+                catch (error) {
+                    lastError = error instanceof Error ? error : new Error(String(error));
+                    if (attempt < this.maxRetries - 1) {
+                        await this.backoff(attempt);
+                    }
+                }
+            }
+        }
+        throw lastError ?? new Error("RPC failover exhausted all retries on all endpoints.");
+    }
+    async backoff(attempt) {
+        const exponentialDelay = this.baseDelayMs * Math.pow(2, attempt);
+        const cappedDelay = Math.min(exponentialDelay, this.maxDelayMs);
+        const jitter = Math.random() * cappedDelay * 0.3;
+        const totalDelay = cappedDelay + jitter;
+        await new Promise((resolve) => {
+            setTimeout(resolve, totalDelay);
+        });
+    }
+}
+exports.RpcFailoverClient = RpcFailoverClient;

package/dist/core/tokens/TokenService.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenService = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const programs_1 = require("../../solana/programs");
+class TokenService {
+    rpcClient;
+    constructor(rpcClient) {
+        this.rpcClient = rpcClient;
+    }
+    async getMintDecimals(mint) {
+        const mintInfo = await (0, spl_token_1.getMint)(this.rpcClient.connection, mint, "confirmed");
+        return mintInfo.decimals;
+    }
+    findAssociatedTokenAddress(owner, mint) {
+        return (0, spl_token_1.getAssociatedTokenAddressSync)(mint, owner, false, programs_1.TOKEN_PROGRAM_ID, programs_1.ASSOCIATED_TOKEN_PROGRAM_ID);
+    }
+    async ensureAtaInstruction(input) {
+        const address = this.findAssociatedTokenAddress(input.owner, input.mint);
+        const accountInfo = await this.rpcClient.getAccountInfo(address, "confirmed");
+        if (accountInfo) {
+            return {
+                address,
+                createInstruction: null
+            };
+        }
+        return {
+            address,
+            createInstruction: (0, spl_token_1.createAssociatedTokenAccountInstruction)(input.payer, address, input.owner, input.mint, programs_1.TOKEN_PROGRAM_ID, programs_1.ASSOCIATED_TOKEN_PROGRAM_ID)
+        };
+    }
+    buildWrapSolInstructions(input) {
+        if (!Number.isInteger(input.amountLamports) || input.amountLamports <= 0) {
+            throw new Error("Wrap SOL amount must be a positive integer lamport value.");
+        }
+        const associatedTokenAddress = this.findAssociatedTokenAddress(input.wallet.publicKey, programs_1.NATIVE_MINT);
+        const instructions = [];
+        if (input.createAtaIfMissing) {
+            instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(input.wallet.publicKey, associatedTokenAddress, input.wallet.publicKey, programs_1.NATIVE_MINT, programs_1.TOKEN_PROGRAM_ID, programs_1.ASSOCIATED_TOKEN_PROGRAM_ID));
+        }
+        instructions.push(web3_js_1.SystemProgram.transfer({
+            fromPubkey: input.wallet.publicKey,
+            toPubkey: associatedTokenAddress,
+            lamports: input.amountLamports
+        }), (0, spl_token_1.createSyncNativeInstruction)(associatedTokenAddress, programs_1.TOKEN_PROGRAM_ID));
+        return {
+            associatedTokenAddress,
+            createdAssociatedTokenAccount: input.createAtaIfMissing,
+            instructions
+        };
+    }
+    async buildCreateMintInstructions(input) {
+        const mintKeypair = web3_js_1.Keypair.generate();
+        const rent = await this.rpcClient.connection.getMinimumBalanceForRentExemption(82);
+        const instructions = [
+            web3_js_1.SystemProgram.createAccount({
+                fromPubkey: input.payer,
+                newAccountPubkey: mintKeypair.publicKey,
+                lamports: rent,
+                programId: programs_1.TOKEN_PROGRAM_ID,
+                space: 82
+            }),
+            (0, spl_token_1.createInitializeMint2Instruction)(mintKeypair.publicKey, input.decimals, input.mintAuthority, input.mintAuthority, programs_1.TOKEN_PROGRAM_ID)
+        ];
+        return {
+            mintKeypair,
+            instructions
+        };
+    }
+    buildMintToInstruction(input) {
+        return (0, spl_token_1.createMintToInstruction)(input.mint, input.destinationAta, input.authority, input.amount, [], programs_1.TOKEN_PROGRAM_ID);
+    }
+}
+exports.TokenService = TokenService;

package/dist/core/transactions/PostTransactionVerifier.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostTransactionVerifier = void 0;
+const SOL_DECIMALS = 9;
+class PostTransactionVerifier {
+    rpcClient;
+    tokenService;
+    constructor(rpcClient, tokenService) {
+        this.rpcClient = rpcClient;
+        this.tokenService = tokenService;
+    }
+    async snapshotSolBalance(owner, label = "SOL balance") {
+        const beforeLamports = await this.rpcClient.getBalance(owner, "confirmed");
+        return {
+            address: owner,
+            beforeRaw: BigInt(beforeLamports),
+            decimals: SOL_DECIMALS,
+            kind: "sol",
+            label
+        };
+    }
+    async snapshotSplBalanceForOwner(input) {
+        const tokenAccount = this.tokenService.findAssociatedTokenAddress(input.owner, input.mint);
+        return this.snapshotSplTokenAccount({
+            label: input.label ?? `Token balance for ${input.mint.toBase58()}`,
+            mint: input.mint,
+            tokenAccount
+        });
+    }
+    async snapshotSplTokenAccount(input) {
+        const decimals = await this.tokenService.getMintDecimals(input.mint);
+        const beforeRaw = await this.getSplTokenBalanceRaw(input.tokenAccount);
+        return {
+            address: input.tokenAccount,
+            beforeRaw,
+            decimals,
+            kind: "spl",
+            label: input.label ?? `Token account ${input.tokenAccount.toBase58()}`
+        };
+    }
+    async assertBalanceChanges(expectations) {
+        const reports = await Promise.all(expectations.map(async (expectation) => this.buildReport(expectation)));
+        for (const [index, report] of reports.entries()) {
+            const expectation = expectations[index];
+            if (expectation.minIncreaseRaw !== undefined && report.deltaRaw < expectation.minIncreaseRaw) {
+                throw new Error(`${report.label} verification failed: expected increase >= ${expectation.minIncreaseRaw.toString()} raw, got ${report.deltaRaw.toString()} raw (${report.beforeUi} -> ${report.afterUi}).`);
+            }
+            if (expectation.maxDecreaseRaw !== undefined &&
+                report.deltaRaw < 0n &&
+                -report.deltaRaw > expectation.maxDecreaseRaw) {
+                throw new Error(`${report.label} verification failed: expected decrease <= ${expectation.maxDecreaseRaw.toString()} raw, got ${(-report.deltaRaw).toString()} raw (${report.beforeUi} -> ${report.afterUi}).`);
+            }
+        }
+        return reports;
+    }
+    async buildReport(expectation) {
+        const afterRaw = await this.readCurrentRaw(expectation.snapshot);
+        const deltaRaw = afterRaw - expectation.snapshot.beforeRaw;
+        return {
+            address: expectation.snapshot.address.toBase58(),
+            afterRaw,
+            afterUi: formatRawAmount(afterRaw, expectation.snapshot.decimals),
+            beforeRaw: expectation.snapshot.beforeRaw,
+            beforeUi: formatRawAmount(expectation.snapshot.beforeRaw, expectation.snapshot.decimals),
+            deltaRaw,
+            deltaUi: formatSignedRawAmount(deltaRaw, expectation.snapshot.decimals),
+            kind: expectation.snapshot.kind,
+            label: expectation.label ?? expectation.snapshot.label
+        };
+    }
+    async readCurrentRaw(snapshot) {
+        if (snapshot.kind === "sol") {
+            return BigInt(await this.rpcClient.getBalance(snapshot.address, "confirmed"));
+        }
+        return this.getSplTokenBalanceRaw(snapshot.address);
+    }
+    async getSplTokenBalanceRaw(tokenAccount) {
+        const account = await this.rpcClient.getAccountInfo(tokenAccount, "confirmed");
+        if (!account) {
+            return 0n;
+        }
+        const tokenBalance = await this.rpcClient.getTokenAccountBalance(tokenAccount, "confirmed");
+        return BigInt(tokenBalance.value.amount);
+    }
+}
+exports.PostTransactionVerifier = PostTransactionVerifier;
+function formatSignedRawAmount(raw, decimals) {
+    const sign = raw < 0n ? "-" : "+";
+    const absolute = raw < 0n ? -raw : raw;
+    return `${sign}${formatRawAmount(absolute, decimals)}`;
+}
+function formatRawAmount(raw, decimals) {
+    const negative = raw < 0n;
+    const absolute = negative ? -raw : raw;
+    const divisor = 10n ** BigInt(decimals);
+    const whole = absolute / divisor;
+    const fraction = absolute % divisor;
+    if (fraction === 0n) {
+        return `${negative ? "-" : ""}${whole.toString()}`;
+    }
+    const fractionString = fraction.toString().padStart(decimals, "0").replace(/0+$/u, "");
+    return `${negative ? "-" : ""}${whole.toString()}.${fractionString}`;
+}

package/dist/core/transactions/TransactionService.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionService = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const programs_1 = require("../../solana/programs");
+const LAMPORTS_PER_SOL = 1_000_000_000;
+class TransactionService {
+    rpcClient;
+    constructor(rpcClient) {
+        this.rpcClient = rpcClient;
+    }
+    async buildTransaction(input) {
+        const latestBlockhash = await this.rpcClient.getLatestBlockhash("confirmed");
+        const message = new web3_js_1.TransactionMessage({
+            payerKey: input.feePayer,
+            recentBlockhash: latestBlockhash.blockhash,
+            instructions: input.instructions
+        }).compileToV0Message();
+        const transaction = new web3_js_1.VersionedTransaction(message);
+        const signedTransaction = await input.signer.signTransaction(transaction);
+        return {
+            confirmationStrategy: {
+                blockhash: latestBlockhash.blockhash,
+                lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+                signature: ""
+            },
+            instructionsCount: input.instructions.length,
+            transaction: signedTransaction
+        };
+    }
+    buildSolTransferInstruction(input) {
+        return web3_js_1.SystemProgram.transfer({
+            fromPubkey: input.from,
+            toPubkey: input.to,
+            lamports: input.lamports
+        });
+    }
+    buildSolTransferInstructionInSol(input) {
+        const lamports = Math.round(input.amountSol * LAMPORTS_PER_SOL);
+        return this.buildSolTransferInstruction({
+            from: input.from,
+            to: input.to,
+            lamports
+        });
+    }
+    buildSplTransferInstruction(input) {
+        return (0, spl_token_1.createTransferInstruction)(input.sourceAta, input.destinationAta, input.owner, input.amount, input.multiSigners, input.programId);
+    }
+    buildSplTransferCheckedInstruction(input) {
+        return (0, spl_token_1.createTransferCheckedInstruction)(input.sourceAta, input.mint, input.destinationAta, input.owner, input.amount, input.decimals, input.multiSigners, input.programId);
+    }
+    buildMemoInstruction(memo) {
+        return new web3_js_1.TransactionInstruction({
+            programId: programs_1.MEMO_PROGRAM_ID,
+            keys: [],
+            data: Buffer.from(memo, "utf8")
+        });
+    }
+    async simulate(transaction) {
+        const simulation = await this.rpcClient.simulateTransaction(transaction, {
+            commitment: "confirmed",
+            sigVerify: true
+        });
+        return {
+            err: simulation.value.err,
+            logs: simulation.value.logs ?? null,
+            unitsConsumed: simulation.value.unitsConsumed ?? null
+        };
+    }
+    async sendAndConfirm(input) {
+        const sendable = this.normalizeSendable(input);
+        const signature = await this.rpcClient.sendTransaction(sendable.transaction, {
+            maxRetries: 3,
+            preflightCommitment: "confirmed"
+        });
+        const confirmation = await this.rpcClient.confirmTransaction(this.resolveConfirmationTarget(sendable.confirmationStrategy, signature), "confirmed");
+        return {
+            signature,
+            slot: confirmation.context.slot
+        };
+    }
+    normalizeSendable(input) {
+        if (input instanceof web3_js_1.VersionedTransaction) {
+            return {
+                transaction: input
+            };
+        }
+        return input;
+    }
+    resolveConfirmationTarget(confirmationStrategy, signature) {
+        if (!confirmationStrategy) {
+            return signature;
+        }
+        if (typeof confirmationStrategy === "string") {
+            return confirmationStrategy;
+        }
+        return {
+            ...confirmationStrategy,
+            signature
+        };
+    }
+}
+exports.TransactionService = TransactionService;

package/dist/core/types/services.js

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

package/dist/core/wallet/WalletManager.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletManager = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const env_1 = require("../../config/env");
+class LocalTransactionSigner {
+    keypair;
+    source;
+    constructor(keypair, source) {
+        this.keypair = keypair;
+        this.source = source;
+    }
+    get publicKey() {
+        return this.keypair.publicKey;
+    }
+    async signTransaction(transaction) {
+        transaction.sign([this.keypair]);
+        return transaction;
+    }
+}
+class RemoteTransactionSigner {
+    publicKey;
+    bearerToken;
+    url;
+    source = "remote";
+    constructor(publicKey, bearerToken, url) {
+        this.publicKey = publicKey;
+        this.bearerToken = bearerToken;
+        this.url = url;
+    }
+    async signTransaction(transaction) {
+        const response = await fetch(this.url, {
+            body: JSON.stringify({
+                publicKey: this.publicKey.toBase58(),
+                transactionBase64: Buffer.from(transaction.serialize()).toString("base64")
+            }),
+            headers: {
+                Authorization: `Bearer ${this.bearerToken}`,
+                "Content-Type": "application/json"
+            },
+            method: "POST"
+        });
+        if (!response.ok) {
+            const message = await response.text();
+            throw new Error(`Remote signer request failed (${response.status} ${response.statusText}): ${message || "no response body"}`);
+        }
+        const payload = (await response.json());
+        const signedTransactionBase64 = payload.signedTransactionBase64 ?? payload.transactionBase64 ?? null;
+        if (!signedTransactionBase64) {
+            throw new Error("Remote signer response did not include signedTransactionBase64.");
+        }
+        return web3_js_1.VersionedTransaction.deserialize(Buffer.from(signedTransactionBase64, "base64"));
+    }
+}
+class WalletManager {
+    signer;
+    constructor(signer) {
+        this.signer = signer;
+    }
+    static generate() {
+        return new WalletManager(new LocalTransactionSigner(web3_js_1.Keypair.generate(), "generated"));
+    }
+    static loadFromEnv() {
+        const secretKey = (0, env_1.getOptionalSecretKey)();
+        if (!secretKey) {
+            throw new Error("AGENT_PRIVATE_KEY is not configured.");
+        }
+        return new WalletManager(new LocalTransactionSigner(web3_js_1.Keypair.fromSecretKey(secretKey), "env"));
+    }
+    static loadRemoteSigner() {
+        const remoteSigner = (0, env_1.getRemoteSignerConfig)();
+        if (!remoteSigner) {
+            throw new Error("Remote signer is not configured.");
+        }
+        return new WalletManager(new RemoteTransactionSigner(remoteSigner.publicKey, remoteSigner.bearerToken, remoteSigner.url));
+    }
+    static loadConfigured() {
+        const remoteSigner = (0, env_1.getRemoteSignerConfig)();
+        if (remoteSigner) {
+            return new WalletManager(new RemoteTransactionSigner(remoteSigner.publicKey, remoteSigner.bearerToken, remoteSigner.url));
+        }
+        return WalletManager.loadFromEnv();
+    }
+    static loadOrGenerate() {
+        const remoteSigner = (0, env_1.getRemoteSignerConfig)();
+        if (remoteSigner) {
+            return new WalletManager(new RemoteTransactionSigner(remoteSigner.publicKey, remoteSigner.bearerToken, remoteSigner.url));
+        }
+        const secretKey = (0, env_1.getOptionalSecretKey)();
+        if (!secretKey) {
+            return WalletManager.generate();
+        }
+        return new WalletManager(new LocalTransactionSigner(web3_js_1.Keypair.fromSecretKey(secretKey), "env"));
+    }
+    static fromSecretKey(secretKey, source = "env") {
+        return new WalletManager(new LocalTransactionSigner(web3_js_1.Keypair.fromSecretKey(secretKey), source));
+    }
+    get payer() {
+        if (!(this.signer instanceof LocalTransactionSigner)) {
+            throw new Error("This wallet uses a remote signer and does not expose a local keypair.");
+        }
+        return this.signer.keypair;
+    }
+    get publicKey() {
+        return this.signer.publicKey;
+    }
+    get source() {
+        return this.signer.source;
+    }
+    async signTransaction(transaction) {
+        return this.signer.signTransaction(transaction);
+    }
+    toSafeSummary() {
+        return {
+            publicKey: this.publicKey.toBase58(),
+            source: this.source
+        };
+    }
+}
+exports.WalletManager = WalletManager;

package/dist/defi/DeFiCoordinator.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeFiCoordinator = void 0;
+const policyFactory_1 = require("../agent/policyFactory");
+const DeFiExecutor_1 = require("./DeFiExecutor");
+const KaminoAdapter_1 = require("./adapters/KaminoAdapter");
+const JupiterAdapter_1 = require("./adapters/JupiterAdapter");
+const MarinadeAdapter_1 = require("./adapters/MarinadeAdapter");
+const RaydiumAdapter_1 = require("./adapters/RaydiumAdapter");
+const protocols_1 = require("./protocols");
+class DeFiCoordinator {
+    walletManager;
+    koraSigner;
+    logger;
+    policy;
+    kaminoAdapter = new KaminoAdapter_1.KaminoAdapter();
+    jupiterAdapter = new JupiterAdapter_1.JupiterAdapter();
+    marinadeAdapter = new MarinadeAdapter_1.MarinadeAdapter();
+    raydiumAdapter = new RaydiumAdapter_1.RaydiumAdapter();
+    constructor(walletManager, koraSigner, logger = () => undefined, policy = (0, policyFactory_1.createDefaultAgentPolicy)({
+        maxSpend: {
+            lamports: 2_000_000
+        }
+    })) {
+        this.walletManager = walletManager;
+        this.koraSigner = koraSigner;
+        this.logger = logger;
+        this.policy = policy;
+    }
+    async runStakingStrategy(snapshot) {
+        const intent = this.marinadeAdapter.buildStakeIntent(snapshot);
+        if (!intent) {
+            this.logger("Staking strategy -> HOLD (Marinade adapter found insufficient idle SOL).");
+            return null;
+        }
+        return this.execute(intent);
+    }
+    async runLiquidityStrategy(snapshot) {
+        const intent = this.raydiumAdapter.buildAddLiquidityIntent(snapshot);
+        if (!intent) {
+            this.logger("LP strategy -> HOLD (Raydium adapter found pool pricing out of range).");
+            return null;
+        }
+        return this.execute(intent);
+    }
+    async runLendingStrategy(snapshot) {
+        const intent = this.kaminoAdapter.buildDepositIntent(snapshot);
+        if (!intent) {
+            this.logger("Lending strategy -> HOLD (Kamino adapter found insufficient idle USDC).");
+            return null;
+        }
+        return this.execute(intent);
+    }
+    async runBorrowingStrategy(snapshot) {
+        const intent = this.kaminoAdapter.buildBorrowIntent(snapshot);
+        if (!intent) {
+            this.logger("Borrowing strategy -> HOLD (Kamino adapter found insufficient collateral or borrow demand).");
+            return null;
+        }
+        return this.execute(intent);
+    }
+    async runTradeStrategy(snapshot) {
+        const intent = this.jupiterAdapter.buildTradeIntent(snapshot);
+        if (!intent) {
+            this.logger("Trade strategy -> HOLD (Jupiter adapter found no favorable setup).");
+            return null;
+        }
+        return this.execute(intent);
+    }
+    async runFullSuite(snapshot) {
+        const results = await Promise.all([
+            this.runTradeStrategy(snapshot),
+            this.runStakingStrategy(snapshot),
+            this.runLiquidityStrategy(snapshot),
+            this.runLendingStrategy(snapshot),
+            this.runBorrowingStrategy(snapshot)
+        ]);
+        return results.filter((result) => result !== null);
+    }
+    async execute(intent) {
+        const preset = protocols_1.PROTOCOL_PRESETS[intent.protocol];
+        this.logger(`${preset.label} strategy -> Policy Check -> Gasless Execution (${intent.action} on ${intent.marketId}).`);
+        const executor = new DeFiExecutor_1.DeFiExecutor(this.policy);
+        const result = await executor.executeIntent({
+            intent,
+            koraSigner: this.koraSigner,
+            walletManager: this.walletManager
+        });
+        this.logger(`${preset.label} strategy -> Executed ${result.mock ? "mock " : ""}${result.action} ${result.signature}`);
+        return result;
+    }
+}
+exports.DeFiCoordinator = DeFiCoordinator;