@prktsol/prkt 1.0.0

package/dist/defi/universal/UniversalDeFiOrchestrator.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniversalDeFiOrchestrator = void 0;
+const policyFactory_1 = require("../../agent/policyFactory");
+const env_1 = require("../../config/env");
+const DeFiExecutor_1 = require("../DeFiExecutor");
+const adapters_1 = require("./adapters");
+const liveExecutors_1 = require("./liveExecutors");
+class UniversalDeFiOrchestrator {
+    deps;
+    adapters;
+    executor;
+    constructor(deps, adapters) {
+        this.deps = deps;
+        this.adapters = adapters ?? [
+            new adapters_1.JupiterUniversalAdapter(),
+            new adapters_1.MarinadeUniversalAdapter(),
+            new adapters_1.RaydiumUniversalAdapter(),
+            new adapters_1.KaminoUniversalAdapter()
+        ];
+        this.executor = new DeFiExecutor_1.DeFiExecutor(deps.policy ??
+            (0, policyFactory_1.createDefaultAgentPolicy)({
+                maxSpend: {
+                    lamports: 2_000_000_000
+                }
+            }));
+    }
+    async execute(request, options) {
+        const adapter = this.resolveAdapter(request);
+        if (!adapter) {
+            this.log(`No compatible adapter for capability=${request.capability} protocol=${request.protocol ?? "auto"}`);
+            return {
+                capability: request.capability,
+                protocol: request.protocol ?? "raydium",
+                result: null
+            };
+        }
+        const intent = adapter.buildIntent(request);
+        if (!intent) {
+            this.log(`${adapter.protocol} returned HOLD for capability ${request.capability}`);
+            return {
+                capability: request.capability,
+                protocol: adapter.protocol,
+                result: null
+            };
+        }
+        const liveFirst = this.deps.liveFirst ?? (0, env_1.isUniversalDeFiLiveFirstEnabled)();
+        if (liveFirst) {
+            const preparedLive = (await (0, liveExecutors_1.prepareLiveJupiter)({
+                intent,
+                logger: this.deps.logger,
+                walletManager: this.deps.walletManager
+            })) ??
+                (await (0, liveExecutors_1.prepareLiveRaydiumLp)({
+                    intent,
+                    logger: this.deps.logger,
+                    walletManager: this.deps.walletManager
+                })) ??
+                (await (0, liveExecutors_1.prepareLiveKamino)({
+                    intent,
+                    logger: this.deps.logger,
+                    walletManager: this.deps.walletManager
+                })) ??
+                (await (0, liveExecutors_1.prepareLiveMarinade)({
+                    intent,
+                    logger: this.deps.logger,
+                    walletManager: this.deps.walletManager
+                }));
+            const liveResult = await this.tryExecutePreparedLive(preparedLive, options);
+            if (liveResult) {
+                return {
+                    capability: request.capability,
+                    protocol: adapter.protocol,
+                    result: liveResult
+                };
+            }
+        }
+        const result = await this.executor.executeIntent({
+            intent,
+            koraSigner: this.deps.koraSigner,
+            walletManager: this.deps.walletManager
+        });
+        return {
+            capability: request.capability,
+            protocol: adapter.protocol,
+            result
+        };
+    }
+    async executeBatch(requests, options) {
+        return Promise.all(requests.map((request) => this.execute(request, options)));
+    }
+    resolveAdapter(request) {
+        const scoped = request.protocol
+            ? this.adapters.filter((adapter) => adapter.protocol === request.protocol)
+            : this.adapters;
+        return scoped.find((adapter) => adapter.capabilities.includes(request.capability)) ?? null;
+    }
+    log(message) {
+        (this.deps.logger ?? (() => undefined))(message);
+    }
+    async tryExecutePreparedLive(prepared, options) {
+        if (!prepared) {
+            return null;
+        }
+        if (!options?.liveExecutor) {
+            this.log(`guarded live ${prepared.protocol} transaction prepared but no guarded executor was provided`);
+            return null;
+        }
+        const execution = await options.liveExecutor.executePreparedTransaction({
+            confirmationStrategy: prepared.confirmationStrategy,
+            inspectionContext: prepared.inspectionContext,
+            policyConfigPatch: prepared.policyConfigPatch,
+            transaction: prepared.transaction
+        });
+        if (!execution.signature) {
+            const reasons = execution.inspection.reasons.join("; ");
+            this.log(`guarded live ${prepared.protocol} execution blocked${reasons ? `: ${reasons}` : ""}`);
+            return null;
+        }
+        if (prepared.verifyExecution) {
+            await prepared.verifyExecution(execution.signature);
+        }
+        return prepared.toExecutionResult(execution.signature);
+    }
+}
+exports.UniversalDeFiOrchestrator = UniversalDeFiOrchestrator;

package/dist/defi/universal/adapters.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KaminoUniversalAdapter = exports.RaydiumUniversalAdapter = exports.MarinadeUniversalAdapter = exports.JupiterUniversalAdapter = void 0;
+const JupiterAdapter_1 = require("../adapters/JupiterAdapter");
+const KaminoAdapter_1 = require("../adapters/KaminoAdapter");
+const MarinadeAdapter_1 = require("../adapters/MarinadeAdapter");
+const RaydiumAdapter_1 = require("../adapters/RaydiumAdapter");
+class JupiterUniversalAdapter {
+    protocol = "jupiter";
+    capabilities = ["trade"];
+    adapter = new JupiterAdapter_1.JupiterAdapter();
+    buildIntent(request) {
+        if (request.capability !== "trade") {
+            return null;
+        }
+        return this.adapter.buildTradeIntent(request.snapshot);
+    }
+}
+exports.JupiterUniversalAdapter = JupiterUniversalAdapter;
+class MarinadeUniversalAdapter {
+    protocol = "marinade";
+    capabilities = ["staking"];
+    adapter = new MarinadeAdapter_1.MarinadeAdapter();
+    buildIntent(request) {
+        if (request.capability !== "staking") {
+            return null;
+        }
+        return this.adapter.buildStakeIntent(request.snapshot);
+    }
+}
+exports.MarinadeUniversalAdapter = MarinadeUniversalAdapter;
+class RaydiumUniversalAdapter {
+    protocol = "raydium";
+    capabilities = ["lp", "yield"];
+    adapter = new RaydiumAdapter_1.RaydiumAdapter();
+    buildIntent(request) {
+        if (request.capability === "lp") {
+            return this.adapter.buildAddLiquidityIntent(request.snapshot);
+        }
+        if (request.capability === "yield") {
+            const rewards = request.snapshot.rewardsClaimableAtomic ?? 0;
+            if (rewards <= 0) {
+                return null;
+            }
+            const plan = this.adapter.buildAddLiquidityPlan();
+            return {
+                action: "harvest",
+                amountLamports: 0,
+                marketId: plan.poolId,
+                memo: `DEFI_INTENT:RAYDIUM:harvest:${rewards}`,
+                protocol: this.protocol,
+                slippageBps: plan.slippageBps
+            };
+        }
+        return null;
+    }
+}
+exports.RaydiumUniversalAdapter = RaydiumUniversalAdapter;
+class KaminoUniversalAdapter {
+    protocol = "kamino";
+    capabilities = ["lending", "borrowing", "yield"];
+    adapter = new KaminoAdapter_1.KaminoAdapter();
+    buildIntent(request) {
+        if (request.capability === "borrowing") {
+            return this.adapter.buildBorrowIntent(request.snapshot);
+        }
+        if (request.capability !== "lending" && request.capability !== "yield") {
+            return null;
+        }
+        return this.adapter.buildDepositIntent(request.snapshot);
+    }
+}
+exports.KaminoUniversalAdapter = KaminoUniversalAdapter;

package/dist/defi/universal/index.js

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

package/dist/defi/universal/liveExecutors.js

@@ -0,0 +1,394 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareLiveJupiter = prepareLiveJupiter;
+exports.prepareLiveRaydiumLp = prepareLiveRaydiumLp;
+exports.prepareLiveKamino = prepareLiveKamino;
+exports.prepareLiveMarinade = prepareLiveMarinade;
+const kit_1 = require("@solana/kit");
+const marinade_ts_sdk_1 = require("@marinade.finance/marinade-ts-sdk");
+const klend_sdk_1 = require("@kamino-finance/klend-sdk");
+const web3_js_1 = require("@solana/web3.js");
+const env_1 = require("../../config/env");
+const RpcClient_1 = require("../../core/rpc/RpcClient");
+const PostTransactionVerifier_1 = require("../../core/transactions/PostTransactionVerifier");
+const TokenService_1 = require("../../core/tokens/TokenService");
+const JupiterSwapClient_1 = require("../../dex/JupiterSwapClient");
+const SwapExecutor_1 = require("../../dex/SwapExecutor");
+const raydiumDevnetConfig_1 = require("../lp/raydiumDevnetConfig");
+const RaydiumAdapter_1 = require("../adapters/RaydiumAdapter");
+const kaminoInstructionCompat_1 = require("../kamino/kaminoInstructionCompat");
+const kaminoLiveConfig_1 = require("../kamino/kaminoLiveConfig");
+const loadKaminoMarketWithFallback_1 = require("../kamino/loadKaminoMarketWithFallback");
+async function prepareLiveJupiter(input) {
+    if (input.intent.protocol !== "jupiter" || input.intent.action !== "trade") {
+        return null;
+    }
+    if (!(0, env_1.isLiveSwapPathEnabled)()) {
+        input.logger?.("live jupiter disabled via ENABLE_LIVE_SWAP_PATH");
+        return null;
+    }
+    const amountSol = input.intent.amountLamports / web3_js_1.LAMPORTS_PER_SOL;
+    const outputMint = (0, env_1.getUsdcMintAddress)();
+    const rpcClient = new RpcClient_1.RpcClient((0, env_1.getRpcUrl)(), "confirmed");
+    const tokenService = new TokenService_1.TokenService(rpcClient);
+    const verifier = new PostTransactionVerifier_1.PostTransactionVerifier(rpcClient, tokenService);
+    const outputSnapshot = await verifier.snapshotSplBalanceForOwner({
+        label: `Jupiter output token balance (${outputMint})`,
+        mint: new web3_js_1.PublicKey(outputMint),
+        owner: input.walletManager.publicKey
+    });
+    const swapExecutor = new SwapExecutor_1.SwapExecutor(new JupiterSwapClient_1.JupiterSwapClient((0, env_1.getJupiterApiBaseUrl)()));
+    const prepared = await swapExecutor.buildSolToTokenSwapTransaction({
+        amountSol,
+        outputMint,
+        slippageBps: input.intent.slippageBps,
+        walletManager: input.walletManager
+    });
+    return {
+        protocol: input.intent.protocol,
+        toExecutionResult(signature) {
+            return {
+                action: input.intent.action,
+                memo: `LIVE:JUPITER:${input.intent.marketId}:${input.intent.amountLamports}`,
+                mock: false,
+                protocol: input.intent.protocol,
+                signature
+            };
+        },
+        transaction: prepared.transaction,
+        async verifyExecution(signature) {
+            const [report] = await verifier.assertBalanceChanges([
+                {
+                    minIncreaseRaw: 1n,
+                    snapshot: outputSnapshot
+                }
+            ]);
+            input.logger?.(`verified ${signature}: ${report.label} ${report.beforeUi} -> ${report.afterUi} (${report.deltaUi})`);
+        }
+    };
+}
+async function prepareLiveRaydiumLp(input) {
+    if (input.intent.protocol !== "raydium" || input.intent.action !== "add_liquidity") {
+        return null;
+    }
+    if (!(0, env_1.isLiveRaydiumLpEnabled)()) {
+        input.logger?.("live raydium disabled via ENABLE_LIVE_RAYDIUM_LP");
+        return null;
+    }
+    const rpcUrl = (0, env_1.getRpcUrl)();
+    const cluster = (0, env_1.detectClusterFromRpcUrl)(rpcUrl);
+    if (cluster !== "devnet" && cluster !== "unknown") {
+        input.logger?.(`live raydium lp currently intended for devnet; current cluster=${cluster}`);
+        return null;
+    }
+    const connection = new web3_js_1.Connection(rpcUrl, "confirmed");
+    const rpcClient = new RpcClient_1.RpcClient(rpcUrl, "confirmed");
+    const tokenService = new TokenService_1.TokenService(rpcClient);
+    const verifier = new PostTransactionVerifier_1.PostTransactionVerifier(rpcClient, tokenService);
+    const config = (0, raydiumDevnetConfig_1.loadRaydiumLpDevnetConfig)();
+    const adapter = new RaydiumAdapter_1.RaydiumAdapter();
+    const requiredAccounts = [
+        config.poolConfig.poolId,
+        config.poolConfig.authority,
+        config.poolConfig.baseVault,
+        config.poolConfig.quoteVault,
+        config.poolConfig.openOrders,
+        config.poolConfig.targetOrders,
+        config.poolConfig.marketId,
+        config.poolConfig.marketEventQueue,
+        config.poolConfig.lpMint,
+        config.userTokenAccounts.baseTokenAccount,
+        config.userTokenAccounts.quoteTokenAccount,
+        config.userTokenAccounts.lpTokenAccount
+    ];
+    const accountInfos = await connection.getMultipleAccountsInfo(requiredAccounts.map((key) => new web3_js_1.PublicKey(key)), "confirmed");
+    const missing = requiredAccounts.filter((_, index) => accountInfos[index] === null);
+    if (missing.length > 0) {
+        input.logger?.(`live raydium config invalid on cluster; missing ${missing.length} accounts`);
+        return null;
+    }
+    const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+    const lpBalanceSnapshot = await verifier.snapshotSplTokenAccount({
+        label: "Raydium LP token balance",
+        mint: new web3_js_1.PublicKey(config.poolConfig.lpMint),
+        tokenAccount: new web3_js_1.PublicKey(config.userTokenAccounts.lpTokenAccount)
+    });
+    const transaction = await adapter.buildAddLiquidityTransactionDraft({
+        baseAmountIn: config.amounts.baseAmountIn,
+        otherAmountMin: config.amounts.otherAmountMin,
+        owner: input.walletManager,
+        poolConfig: config.poolConfig,
+        quoteAmountIn: config.amounts.quoteAmountIn,
+        recentBlockhash: latestBlockhash.blockhash,
+        userTokenAccounts: config.userTokenAccounts
+    });
+    return {
+        confirmationStrategy: {
+            blockhash: latestBlockhash.blockhash,
+            lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+            signature: ""
+        },
+        protocol: input.intent.protocol,
+        policyConfigPatch: {
+            rules: {
+                allowOpaqueProgramIds: [config.poolConfig.programId],
+                allowedProgramIds: [config.poolConfig.programId]
+            }
+        },
+        toExecutionResult(signature) {
+            return {
+                action: input.intent.action,
+                memo: `LIVE:RAYDIUM:${config.poolConfig.poolId}`,
+                mock: false,
+                protocol: input.intent.protocol,
+                signature
+            };
+        },
+        transaction,
+        async verifyExecution(signature) {
+            const [report] = await verifier.assertBalanceChanges([
+                {
+                    minIncreaseRaw: 1n,
+                    snapshot: lpBalanceSnapshot
+                }
+            ]);
+            input.logger?.(`verified ${signature}: ${report.label} ${report.beforeUi} -> ${report.afterUi} (${report.deltaUi})`);
+        }
+    };
+}
+async function prepareLiveKamino(input) {
+    if (input.intent.protocol !== "kamino" ||
+        (input.intent.action !== "deposit" && input.intent.action !== "borrow")) {
+        return null;
+    }
+    if (!(0, env_1.isLiveKaminoEnabled)()) {
+        input.logger?.("live kamino disabled via ENABLE_LIVE_KAMINO");
+        return null;
+    }
+    const rpcUrl = (0, env_1.getRpcUrl)();
+    const cluster = (0, env_1.detectClusterFromRpcUrl)(rpcUrl);
+    const config = (0, kaminoLiveConfig_1.loadKaminoLiveConfig)();
+    if (config.cluster && cluster !== "unknown" && cluster !== config.cluster) {
+        throw new Error(`Kamino live config cluster=${config.cluster} does not match current RPC cluster=${cluster}. Check ${(0, env_1.getKaminoLiveConfigPath)()}.`);
+    }
+    const rpcClient = new RpcClient_1.RpcClient(rpcUrl, "confirmed");
+    const tokenService = new TokenService_1.TokenService(rpcClient);
+    const verifier = new PostTransactionVerifier_1.PostTransactionVerifier(rpcClient, tokenService);
+    const connection = new web3_js_1.Connection(rpcUrl, "confirmed");
+    const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+    const configuredMarketAddress = new web3_js_1.PublicKey(config.marketAddress);
+    const configuredProgramId = new web3_js_1.PublicKey(config.programId);
+    const marketAccount = await rpcClient.getAccountInfo(configuredMarketAddress, "confirmed");
+    if (!marketAccount) {
+        throw new Error(`Kamino market ${config.marketAddress} does not exist on ${rpcUrl}. Update ${(0, env_1.getKaminoLiveConfigPath)()} with a valid market address for this cluster.`);
+    }
+    if (!marketAccount.owner.equals(configuredProgramId)) {
+        throw new Error(`Kamino market ${config.marketAddress} is owned by ${marketAccount.owner.toBase58()}, not Kamino program ${config.programId}. Update ${(0, env_1.getKaminoLiveConfigPath)()} with a valid market address for this cluster.`);
+    }
+    const ownerAddress = (0, kit_1.address)(input.walletManager.publicKey.toBase58());
+    const ownerSigner = (0, kit_1.createNoopSigner)(ownerAddress);
+    const programAddress = (0, kit_1.address)(config.programId);
+    const marketAddress = (0, kit_1.address)(config.marketAddress);
+    const obligationType = new klend_sdk_1.VanillaObligation(programAddress);
+    const market = await (0, loadKaminoMarketWithFallback_1.loadKaminoMarketWithFallback)({
+        cluster,
+        logger: input.logger,
+        marketAddress,
+        programAddress,
+        rpcUrl
+    });
+    if (input.intent.action === "deposit") {
+        const depositMint = (0, kit_1.address)(config.depositMint);
+        market.getExistingReserveByMint(depositMint, "configured deposit mint");
+        const beforeDeposit = await market.getObligationDepositByWallet(ownerAddress, depositMint, obligationType);
+        const action = await klend_sdk_1.KaminoAction.buildDepositTxns(market, config.actions.depositAmountRaw.toString(), depositMint, ownerSigner, obligationType, true, undefined, 0, true, false, {
+            skipInitialization: false,
+            skipLutCreation: true
+        });
+        return {
+            confirmationStrategy: {
+                blockhash: latestBlockhash.blockhash,
+                lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+                signature: ""
+            },
+            protocol: input.intent.protocol,
+            policyConfigPatch: {
+                rules: {
+                    allowedCloseAccountDestinations: [input.walletManager.publicKey.toBase58()],
+                    allowOpaqueProgramIds: [config.programId],
+                    allowedProgramIds: [config.programId]
+                }
+            },
+            toExecutionResult(signature) {
+                return {
+                    action: input.intent.action,
+                    memo: `LIVE:KAMINO:deposit:${config.marketAddress}:${config.depositMint}`,
+                    mock: false,
+                    protocol: input.intent.protocol,
+                    signature
+                };
+            },
+            transaction: await buildSignedVersionedTransaction({
+                instructions: buildKaminoInstructions(action, cluster, input.logger),
+                payer: input.walletManager.publicKey,
+                recentBlockhash: latestBlockhash.blockhash,
+                walletManager: input.walletManager
+            }),
+            async verifyExecution(signature) {
+                const afterDeposit = await market.getObligationDepositByWallet(ownerAddress, depositMint, obligationType);
+                if (!afterDeposit.greaterThan(beforeDeposit)) {
+                    throw new Error(`Kamino deposit verification failed: obligation deposit did not increase (${beforeDeposit.toString()} -> ${afterDeposit.toString()}).`);
+                }
+                input.logger?.(`verified ${signature}: Kamino obligation deposit ${beforeDeposit.toString()} -> ${afterDeposit.toString()} (${afterDeposit.minus(beforeDeposit).toString()})`);
+            }
+        };
+    }
+    const borrowMint = (0, kit_1.address)(config.borrowMint);
+    market.getExistingReserveByMint(borrowMint, "configured borrow mint");
+    const beforeBorrow = await market.getObligationBorrowByWallet(ownerAddress, borrowMint, obligationType);
+    const borrowSnapshot = await verifier.snapshotSplBalanceForOwner({
+        label: `Kamino borrowed token balance (${config.borrowMint})`,
+        mint: new web3_js_1.PublicKey(config.borrowMint),
+        owner: input.walletManager.publicKey
+    });
+    const action = await klend_sdk_1.KaminoAction.buildBorrowTxns(market, config.actions.borrowAmountRaw.toString(), borrowMint, ownerSigner, obligationType, true, undefined, 0, true, false, {
+        skipInitialization: false,
+        skipLutCreation: true
+    });
+    return {
+        confirmationStrategy: {
+            blockhash: latestBlockhash.blockhash,
+            lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+            signature: ""
+        },
+        protocol: input.intent.protocol,
+        policyConfigPatch: {
+            rules: {
+                allowedCloseAccountDestinations: [input.walletManager.publicKey.toBase58()],
+                allowOpaqueProgramIds: [config.programId],
+                allowedProgramIds: [config.programId]
+            }
+        },
+        toExecutionResult(signature) {
+            return {
+                action: input.intent.action,
+                memo: `LIVE:KAMINO:borrow:${config.marketAddress}:${config.borrowMint}`,
+                mock: false,
+                protocol: input.intent.protocol,
+                signature
+            };
+        },
+        transaction: await buildSignedVersionedTransaction({
+            instructions: buildKaminoInstructions(action, cluster, input.logger),
+            payer: input.walletManager.publicKey,
+            recentBlockhash: latestBlockhash.blockhash,
+            walletManager: input.walletManager
+        }),
+        async verifyExecution(signature) {
+            const afterBorrow = await market.getObligationBorrowByWallet(ownerAddress, borrowMint, obligationType);
+            if (!afterBorrow.greaterThan(beforeBorrow)) {
+                throw new Error(`Kamino borrow verification failed: obligation borrow did not increase (${beforeBorrow.toString()} -> ${afterBorrow.toString()}).`);
+            }
+            const [report] = await verifier.assertBalanceChanges([
+                {
+                    minIncreaseRaw: 1n,
+                    snapshot: borrowSnapshot
+                }
+            ]);
+            input.logger?.(`verified ${signature}: ${report.label} ${report.beforeUi} -> ${report.afterUi} (${report.deltaUi}); obligation borrow ${beforeBorrow.toString()} -> ${afterBorrow.toString()}`);
+        }
+    };
+}
+async function prepareLiveMarinade(input) {
+    if (input.intent.protocol !== "marinade" || input.intent.action !== "stake") {
+        return null;
+    }
+    if (!(0, env_1.isLiveMarinadeEnabled)()) {
+        input.logger?.("live marinade disabled via ENABLE_LIVE_MARINADE");
+        return null;
+    }
+    const rpcUrl = (0, env_1.getRpcUrl)();
+    const cluster = (0, env_1.detectClusterFromRpcUrl)(rpcUrl);
+    if (cluster !== "devnet" && cluster !== "unknown") {
+        input.logger?.(`live marinade staking currently intended for devnet; current cluster=${cluster}`);
+        return null;
+    }
+    const rpcClient = new RpcClient_1.RpcClient(rpcUrl, "confirmed");
+    const tokenService = new TokenService_1.TokenService(rpcClient);
+    const verifier = new PostTransactionVerifier_1.PostTransactionVerifier(rpcClient, tokenService);
+    const connection = new web3_js_1.Connection(rpcUrl, "confirmed");
+    const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+    const marinade = new marinade_ts_sdk_1.Marinade(new marinade_ts_sdk_1.MarinadeConfig({
+        connection,
+        publicKey: input.walletManager.publicKey
+    }));
+    const marinadeState = await marinade.getMarinadeState();
+    const msolSnapshot = await verifier.snapshotSplBalanceForOwner({
+        label: `Marinade mSOL balance (${marinadeState.mSolMintAddress.toBase58()})`,
+        mint: marinadeState.mSolMintAddress,
+        owner: input.walletManager.publicKey
+    });
+    const prepared = await marinade.deposit(new marinade_ts_sdk_1.BN(input.intent.amountLamports));
+    return {
+        confirmationStrategy: {
+            blockhash: latestBlockhash.blockhash,
+            lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+            signature: ""
+        },
+        protocol: input.intent.protocol,
+        policyConfigPatch: {
+            rules: {
+                allowOpaqueProgramIds: [marinade.config.marinadeFinanceProgramId.toBase58()],
+                allowedProgramIds: [marinade.config.marinadeFinanceProgramId.toBase58()]
+            }
+        },
+        toExecutionResult(signature) {
+            return {
+                action: input.intent.action,
+                memo: `LIVE:MARINADE:stake:${input.intent.amountLamports}`,
+                mock: false,
+                protocol: input.intent.protocol,
+                signature
+            };
+        },
+        transaction: await buildSignedVersionedTransaction({
+            instructions: prepared.transaction.instructions,
+            payer: input.walletManager.publicKey,
+            recentBlockhash: latestBlockhash.blockhash,
+            walletManager: input.walletManager
+        }),
+        async verifyExecution(signature) {
+            const [report] = await verifier.assertBalanceChanges([
+                {
+                    minIncreaseRaw: 1n,
+                    snapshot: msolSnapshot
+                }
+            ]);
+            input.logger?.(`verified ${signature}: ${report.label} ${report.beforeUi} -> ${report.afterUi} (${report.deltaUi})`);
+        }
+    };
+}
+function buildVersionedTransaction(input) {
+    const message = new web3_js_1.TransactionMessage({
+        instructions: input.instructions,
+        payerKey: input.payer,
+        recentBlockhash: input.recentBlockhash
+    }).compileToV0Message();
+    return new web3_js_1.VersionedTransaction(message);
+}
+async function buildSignedVersionedTransaction(input) {
+    const transaction = buildVersionedTransaction(input);
+    return input.walletManager.signTransaction(transaction);
+}
+function buildKaminoInstructions(action, cluster, logger) {
+    const instructions = klend_sdk_1.KaminoAction.actionToIxs(action);
+    const labels = klend_sdk_1.KaminoAction.actionToIxLabels(action);
+    if (cluster !== "devnet") {
+        return instructions.map(kaminoInstructionCompat_1.convertKaminoInstruction);
+    }
+    const filtered = instructions.filter((_, index) => !labels[index]?.startsWith("RefreshReserve["));
+    if (filtered.length !== instructions.length) {
+        logger?.(`kamino devnet compatibility removed ${instructions.length - filtered.length} RefreshReserve instructions`);
+    }
+    return filtered.map(kaminoInstructionCompat_1.convertKaminoInstruction);
+}

package/dist/defi/universal/types.js

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