@prktsol/prkt 1.0.0

package/dist/defi/DeFiExecutor.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeFiExecutor = void 0;
+const PolicyGuard_1 = require("../policy/PolicyGuard");
+const DeFiPolicyGuard_1 = require("./DeFiPolicyGuard");
+class DeFiExecutor {
+    policy;
+    defiPolicyGuard;
+    policyGuard;
+    constructor(policy) {
+        this.policy = policy;
+        this.defiPolicyGuard = new DeFiPolicyGuard_1.DeFiPolicyGuard(policy);
+        this.policyGuard = new PolicyGuard_1.PolicyGuard(policy);
+    }
+    async executeIntent(input) {
+        this.defiPolicyGuard.validateIntent(input.intent);
+        const transaction = await input.koraSigner.buildMemoTransaction(input.walletManager, input.intent.memo);
+        this.policyGuard.validate(transaction);
+        const execution = await input.koraSigner.signAndSendGasless(transaction, input.intent.memo);
+        return {
+            action: input.intent.action,
+            memo: input.intent.memo,
+            mock: execution.mock,
+            protocol: input.intent.protocol,
+            signature: execution.signature
+        };
+    }
+}
+exports.DeFiExecutor = DeFiExecutor;

package/dist/defi/DeFiPolicyGuard.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeFiPolicyGuard = void 0;
+const errors_1 = require("../policy/errors");
+class DeFiPolicyGuard {
+    policy;
+    constructor(policy) {
+        this.policy = policy;
+    }
+    validateIntent(intent) {
+        const protocolPolicy = this.policy.protocolPolicies[intent.protocol];
+        if (!protocolPolicy || !protocolPolicy.enabled) {
+            throw new errors_1.SecurityViolationError(`Protocol blocked: ${intent.protocol} is disabled.`);
+        }
+        if (!protocolPolicy.allowedMarkets.includes(intent.marketId)) {
+            throw new errors_1.SecurityViolationError(`Protocol blocked: market ${intent.marketId} is not approved for ${intent.protocol}.`);
+        }
+        if (intent.amountLamports > protocolPolicy.maxExposureLamports) {
+            throw new errors_1.SecurityViolationError(`Protocol blocked: amount ${intent.amountLamports} exceeds protocol exposure ${protocolPolicy.maxExposureLamports}.`);
+        }
+        if (intent.slippageBps > protocolPolicy.maxSlippageBps) {
+            throw new errors_1.SecurityViolationError(`Protocol blocked: slippage ${intent.slippageBps} exceeds max ${protocolPolicy.maxSlippageBps}.`);
+        }
+        if (protocolPolicy.minHealthFactor !== undefined &&
+            intent.expectedHealthFactor !== undefined &&
+            intent.expectedHealthFactor < protocolPolicy.minHealthFactor) {
+            throw new errors_1.SecurityViolationError(`Protocol blocked: health factor ${intent.expectedHealthFactor.toFixed(2)} is below minimum ${protocolPolicy.minHealthFactor.toFixed(2)}.`);
+        }
+    }
+}
+exports.DeFiPolicyGuard = DeFiPolicyGuard;

package/dist/defi/adapters/JupiterAdapter.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JupiterAdapter = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const protocols_1 = require("../protocols");
+class JupiterAdapter {
+    protocol = "jupiter";
+    buildTradeIntent(snapshot) {
+        const solPriceUsd = snapshot.solPriceUsd ?? 0;
+        const buyThresholdUsd = snapshot.buyThresholdUsd ?? 0;
+        if (solPriceUsd <= 0 || buyThresholdUsd <= 0 || solPriceUsd > buyThresholdUsd) {
+            return null;
+        }
+        const amountLamports = Math.round(0.01 * web3_js_1.LAMPORTS_PER_SOL);
+        return {
+            action: "trade",
+            amountLamports,
+            marketId: protocols_1.PROTOCOL_PRESETS.jupiter.defaultMarketId,
+            memo: `DEFI_INTENT:JUPITER:trade:${amountLamports}`,
+            protocol: this.protocol,
+            slippageBps: 50
+        };
+    }
+}
+exports.JupiterAdapter = JupiterAdapter;

package/dist/defi/adapters/KaminoAdapter.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KaminoAdapter = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const protocols_1 = require("../protocols");
+const USDC_ATOMIC = 1_000_000;
+const MIN_BORROW_USDC_ATOMIC = 2 * USDC_ATOMIC;
+const MIN_COLLATERAL_SOL_LAMPORTS = Math.round(0.75 * web3_js_1.LAMPORTS_PER_SOL);
+class KaminoAdapter {
+    protocol = "kamino";
+    buildDepositIntent(snapshot) {
+        const idleUsdcAtomic = snapshot.idleUsdcAtomic ?? 0;
+        if (idleUsdcAtomic < 2 * USDC_ATOMIC) {
+            return null;
+        }
+        return {
+            action: "deposit",
+            amountLamports: Math.round(0.5 * web3_js_1.LAMPORTS_PER_SOL),
+            expectedHealthFactor: snapshot.healthFactor ?? 2,
+            marketId: protocols_1.PROTOCOL_PRESETS.kamino.defaultMarketId,
+            memo: "DEFI_INTENT:KAMINO:deposit:USDC",
+            protocol: this.protocol,
+            slippageBps: 40
+        };
+    }
+    buildBorrowIntent(snapshot) {
+        const borrowDemandUsdcAtomic = snapshot.borrowDemandUsdcAtomic ?? 0;
+        const collateralSolLamports = snapshot.collateralSolLamports ?? 0;
+        const expectedHealthFactor = snapshot.healthFactor ?? 0;
+        if (borrowDemandUsdcAtomic < MIN_BORROW_USDC_ATOMIC) {
+            return null;
+        }
+        if (collateralSolLamports < MIN_COLLATERAL_SOL_LAMPORTS) {
+            return null;
+        }
+        if (expectedHealthFactor < 2) {
+            return null;
+        }
+        return {
+            action: "borrow",
+            amountLamports: Math.round(0.25 * web3_js_1.LAMPORTS_PER_SOL),
+            expectedHealthFactor,
+            marketId: protocols_1.PROTOCOL_PRESETS.kamino.defaultMarketId,
+            memo: `DEFI_INTENT:KAMINO:borrow:USDC:${borrowDemandUsdcAtomic}`,
+            protocol: this.protocol,
+            slippageBps: 40
+        };
+    }
+}
+exports.KaminoAdapter = KaminoAdapter;

package/dist/defi/adapters/MarinadeAdapter.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarinadeAdapter = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const protocols_1 = require("../protocols");
+class MarinadeAdapter {
+    protocol = "marinade";
+    buildStakeIntent(snapshot) {
+        const idleSolLamports = snapshot.idleSolLamports ?? 0;
+        const reserveLamports = Math.round(0.2 * web3_js_1.LAMPORTS_PER_SOL);
+        const amountLamports = Math.round(0.15 * web3_js_1.LAMPORTS_PER_SOL);
+        if (idleSolLamports <= reserveLamports + amountLamports) {
+            return null;
+        }
+        return {
+            action: "stake",
+            amountLamports,
+            marketId: protocols_1.PROTOCOL_PRESETS.marinade.defaultMarketId,
+            memo: `DEFI_INTENT:MARINADE:stake:${amountLamports}`,
+            protocol: this.protocol,
+            slippageBps: 25
+        };
+    }
+}
+exports.MarinadeAdapter = MarinadeAdapter;

package/dist/defi/adapters/RaydiumAdapter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RaydiumAdapter = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const RaydiumLpInstructionBuilder_1 = require("../lp/RaydiumLpInstructionBuilder");
+const protocols_1 = require("../protocols");
+class RaydiumAdapter {
+    protocol = "raydium";
+    lpInstructionBuilder = new RaydiumLpInstructionBuilder_1.RaydiumLpInstructionBuilder();
+    createDefaultPositionSettings() {
+        return {
+            harvestThresholdAtomic: 250_000,
+            maxCapitalLamports: Math.round(0.2 * web3_js_1.LAMPORTS_PER_SOL),
+            maxSlippageBps: 80,
+            poolId: protocols_1.PROTOCOL_PRESETS.raydium.defaultMarketId,
+            rebalanceOnOutOfRange: true,
+            tokenPair: "SOL/USDC"
+        };
+    }
+    buildAddLiquidityPlan(settings) {
+        const resolvedSettings = settings ?? this.createDefaultPositionSettings();
+        return this.lpInstructionBuilder.buildAddLiquidityPlan({
+            depositLamports: Math.round(0.12 * web3_js_1.LAMPORTS_PER_SOL),
+            settings: resolvedSettings
+        });
+    }
+    async buildAddLiquidityTransactionDraft(input) {
+        return this.lpInstructionBuilder.buildAddLiquidityTransactionDraft(input);
+    }
+    buildAddLiquidityIntent(snapshot, settings) {
+        if (!snapshot.liquidityInRange) {
+            return null;
+        }
+        const plan = this.buildAddLiquidityPlan(settings);
+        return {
+            action: plan.action,
+            amountLamports: plan.amountLamports,
+            marketId: plan.poolId,
+            memo: `DEFI_INTENT:RAYDIUM:${plan.action}:${plan.tokenPair}`,
+            protocol: this.protocol,
+            slippageBps: plan.slippageBps
+        };
+    }
+}
+exports.RaydiumAdapter = RaydiumAdapter;

package/dist/defi/kamino/kaminoInstructionCompat.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertKaminoInstruction = convertKaminoInstruction;
+const kit_1 = require("@solana/kit");
+const web3_js_1 = require("@solana/web3.js");
+function convertKaminoInstruction(instruction) {
+    return new web3_js_1.TransactionInstruction({
+        data: Buffer.from(instruction.data ?? new Uint8Array()),
+        keys: (instruction.accounts ?? []).map((account) => convertAccount(account)),
+        programId: new web3_js_1.PublicKey(instruction.programAddress)
+    });
+}
+function convertAccount(account) {
+    if ("lookupTableAddress" in account && account.lookupTableAddress) {
+        throw new Error(`Kamino instruction references lookup table ${account.lookupTableAddress}; lookup-table-backed Kamino transactions are not supported by this live path yet.`);
+    }
+    return {
+        isSigner: account.role === kit_1.AccountRole.READONLY_SIGNER ||
+            account.role === kit_1.AccountRole.WRITABLE_SIGNER,
+        isWritable: account.role === kit_1.AccountRole.WRITABLE ||
+            account.role === kit_1.AccountRole.WRITABLE_SIGNER,
+        pubkey: new web3_js_1.PublicKey(account.address)
+    };
+}

package/dist/defi/kamino/kaminoLiveConfig.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadKaminoLiveConfig = loadKaminoLiveConfig;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const web3_js_1 = require("@solana/web3.js");
+const env_1 = require("../../config/env");
+function loadKaminoLiveConfig() {
+    const configPath = path_1.default.resolve(process.cwd(), (0, env_1.getKaminoLiveConfigPath)());
+    if (!(0, fs_1.existsSync)(configPath)) {
+        throw new Error(`Kamino live config not found at ${configPath}. Create kamino_live.json from kamino_live.example.json first.`);
+    }
+    const raw = (0, fs_1.readFileSync)(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+        actions: {
+            borrowAmountRaw: parsePositiveBigInt(parsed.actions?.borrowAmountRaw, "actions.borrowAmountRaw"),
+            depositAmountRaw: parsePositiveBigInt(parsed.actions?.depositAmountRaw, "actions.depositAmountRaw")
+        },
+        borrowMint: parsePublicKey(parsed.borrowMint, "borrowMint"),
+        cluster: parseOptionalCluster(parsed.cluster),
+        depositMint: parsePublicKey(parsed.depositMint, "depositMint"),
+        marketAddress: parsePublicKey(parsed.marketAddress, "marketAddress"),
+        programId: parsePublicKey(parsed.programId, "programId")
+    };
+}
+function parseOptionalCluster(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "devnet" || value === "localnet" || value === "mainnet-beta") {
+        return value;
+    }
+    throw new Error("cluster must be one of 'devnet', 'localnet', or 'mainnet-beta'.");
+}
+function parsePositiveBigInt(value, field) {
+    if (typeof value === "number") {
+        if (!Number.isInteger(value) || value <= 0) {
+            throw new Error(`${field} must be a positive integer or digit string.`);
+        }
+        return BigInt(value);
+    }
+    if (typeof value === "string" && /^[0-9]+$/u.test(value)) {
+        const parsed = BigInt(value);
+        if (parsed <= 0n) {
+            throw new Error(`${field} must be greater than zero.`);
+        }
+        return parsed;
+    }
+    throw new Error(`${field} must be a positive integer or digit string.`);
+}
+function parsePublicKey(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${field} must be a base58 public key string.`);
+    }
+    return new web3_js_1.PublicKey(value).toBase58();
+}

package/dist/defi/kamino/loadKaminoMarketWithFallback.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadKaminoMarketWithFallback = loadKaminoMarketWithFallback;
+const kit_1 = require("@solana/kit");
+const klend_sdk_1 = require("@kamino-finance/klend-sdk");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const readCdnData_1 = require("@kamino-finance/klend-sdk/dist/utils/readCdnData");
+async function loadKaminoMarketWithFallback(input) {
+    const rpc = (0, kit_1.createSolanaRpc)(input.rpcUrl);
+    if (input.cluster !== "devnet") {
+        const market = await klend_sdk_1.KaminoMarket.load(rpc, input.marketAddress, klend_sdk_1.DEFAULT_RECENT_SLOT_DURATION_MS, input.programAddress);
+        if (!market) {
+            throw new Error(`Kamino market ${input.marketAddress} could not be loaded from ${input.rpcUrl}.`);
+        }
+        return market;
+    }
+    input.logger?.("loading Kamino devnet market via reserve-state compatibility path (fallback reserve prices)");
+    const [marketState, reserveStates, cdnResourcesData] = await Promise.all([
+        klend_sdk_1.LendingMarket.fetch(rpc, input.marketAddress, input.programAddress),
+        (0, klend_sdk_1.getReserveStatesForMarket)(input.marketAddress, rpc, input.programAddress),
+        (0, readCdnData_1.fetchKaminoCdnData)()
+    ]);
+    if (!marketState) {
+        throw new Error(`Kamino market ${input.marketAddress} could not be loaded from ${input.rpcUrl}.`);
+    }
+    const mintAddresses = reserveStates.map((reserve) => reserve.state.liquidity.mintPubkey);
+    const mintAccounts = (await rpc.getMultipleAccounts(mintAddresses).send()).value;
+    const mintOwners = new Map();
+    mintAddresses.forEach((mintAddress, index) => {
+        const mintAccount = mintAccounts[index];
+        if (mintAccount) {
+            mintOwners.set(mintAddress, mintAccount.owner);
+        }
+    });
+    const reserves = new Map();
+    for (const reserveWithAddress of reserveStates) {
+        const normalizedReserveState = normalizeReserveTokenProgram(reserveWithAddress.state, mintOwners.get(reserveWithAddress.state.liquidity.mintPubkey));
+        const reserve = klend_sdk_1.KaminoReserve.initialize(reserveWithAddress.address, normalizedReserveState, createFallbackOracleData(normalizedReserveState), rpc, klend_sdk_1.DEFAULT_RECENT_SLOT_DURATION_MS, cdnResourcesData);
+        reserves.set(reserve.address, reserve);
+    }
+    return klend_sdk_1.KaminoMarket.loadWithReserves(rpc, marketState, reserves, input.marketAddress, klend_sdk_1.DEFAULT_RECENT_SLOT_DURATION_MS, input.programAddress);
+}
+function createFallbackOracleData(reserveState) {
+    const marketPrice = new klend_sdk_1.Fraction(reserveState.liquidity.marketPriceSf).toDecimal();
+    const price = marketPrice.greaterThan(0) ? marketPrice : new decimal_js_1.default(1);
+    return {
+        decimals: decimal_js_1.default.pow(10, reserveState.liquidity.mintDecimals.toString()),
+        mintAddress: reserveState.liquidity.mintPubkey,
+        price,
+        timestamp: BigInt(Math.floor(Date.now() / 1000)),
+        valid: true
+    };
+}
+function normalizeReserveTokenProgram(reserveState, mintOwner) {
+    if (!mintOwner || reserveState.liquidity.tokenProgram !== (0, kit_1.address)("11111111111111111111111111111111")) {
+        return reserveState;
+    }
+    return {
+        ...reserveState,
+        liquidity: {
+            ...reserveState.liquidity,
+            tokenProgram: mintOwner
+        }
+    };
+}

package/dist/defi/lp/LpInstructionBuilder.js

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

package/dist/defi/lp/RaydiumLpInstructionBuilder.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RaydiumLpInstructionBuilder = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const raydium_sdk_v2_1 = require("@raydium-io/raydium-sdk-v2");
+const programs_1 = require("../../solana/programs");
+class RaydiumLpInstructionBuilder {
+    buildAddLiquidityPlan(input) {
+        return {
+            action: "add_liquidity",
+            amountLamports: Math.min(input.depositLamports, input.settings.maxCapitalLamports),
+            operatorSummary: `Add liquidity on Raydium ${input.settings.tokenPair} with max slippage ${input.settings.maxSlippageBps} bps.`,
+            poolId: input.settings.poolId,
+            protocol: "raydium",
+            requiredAccounts: [
+                `${input.settings.poolId}:pool-state`,
+                `${input.settings.poolId}:lp-vault`,
+                `${input.settings.tokenPair}:token-a-ata`,
+                `${input.settings.tokenPair}:token-b-ata`
+            ],
+            slippageBps: input.settings.maxSlippageBps,
+            tokenPair: input.settings.tokenPair
+        };
+    }
+    async buildAddLiquidityTransactionDraft(input) {
+        const instruction = (0, raydium_sdk_v2_1.makeAddLiquidityInstruction)({
+            baseAmountIn: input.baseAmountIn,
+            fixedSide: input.fixedSide ?? "base",
+            otherAmountMin: input.otherAmountMin,
+            poolInfo: {
+                id: input.poolConfig.poolId,
+                lpMint: {
+                    address: input.poolConfig.lpMint
+                },
+                marketId: input.poolConfig.marketId,
+                pooltype: [input.poolConfig.poolType],
+                programId: input.poolConfig.programId
+            },
+            poolKeys: {
+                authority: input.poolConfig.authority,
+                marketEventQueue: input.poolConfig.marketEventQueue,
+                openOrders: input.poolConfig.openOrders,
+                targetOrders: input.poolConfig.targetOrders,
+                vault: {
+                    A: input.poolConfig.baseVault,
+                    B: input.poolConfig.quoteVault
+                }
+            },
+            quoteAmountIn: input.quoteAmountIn,
+            userKeys: {
+                baseTokenAccount: new web3_js_1.PublicKey(input.userTokenAccounts.baseTokenAccount),
+                lpTokenAccount: new web3_js_1.PublicKey(input.userTokenAccounts.lpTokenAccount),
+                owner: input.owner.publicKey,
+                quoteTokenAccount: new web3_js_1.PublicKey(input.userTokenAccounts.quoteTokenAccount)
+            }
+        });
+        const message = new web3_js_1.TransactionMessage({
+            payerKey: input.owner.publicKey,
+            recentBlockhash: input.recentBlockhash ?? programs_1.MOCK_BLOCKHASH,
+            instructions: [instruction]
+        }).compileToV0Message();
+        const transaction = new web3_js_1.VersionedTransaction(message);
+        return input.owner.signTransaction(transaction);
+    }
+    buildHarvestFeesPlan(input) {
+        const rewards = input.snapshot.rewardsClaimableAtomic ?? 0;
+        if (rewards < input.settings.harvestThresholdAtomic) {
+            return null;
+        }
+        return {
+            action: "harvest",
+            amountLamports: 0,
+            operatorSummary: `Harvest accrued Raydium fees for ${input.settings.tokenPair}.`,
+            poolId: input.settings.poolId,
+            protocol: "raydium",
+            requiredAccounts: [
+                `${input.settings.poolId}:pool-state`,
+                `${input.settings.poolId}:fee-vault`
+            ],
+            slippageBps: 0,
+            tokenPair: input.settings.tokenPair
+        };
+    }
+    buildRemoveLiquidityPlan(input) {
+        return {
+            action: "remove_liquidity",
+            amountLamports: Math.min(input.withdrawLamports, input.settings.maxCapitalLamports),
+            operatorSummary: `Remove liquidity from Raydium ${input.settings.tokenPair}.`,
+            poolId: input.settings.poolId,
+            protocol: "raydium",
+            requiredAccounts: [
+                `${input.settings.poolId}:pool-state`,
+                `${input.settings.poolId}:lp-token-ata`
+            ],
+            slippageBps: input.settings.maxSlippageBps,
+            tokenPair: input.settings.tokenPair
+        };
+    }
+}
+exports.RaydiumLpInstructionBuilder = RaydiumLpInstructionBuilder;

package/dist/defi/lp/raydiumDevnetConfig.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRaydiumLpDevnetConfig = loadRaydiumLpDevnetConfig;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const web3_js_1 = require("@solana/web3.js");
+const env_1 = require("../../config/env");
+function loadRaydiumLpDevnetConfig() {
+    const configPath = path_1.default.resolve(process.cwd(), (0, env_1.getRaydiumLpConfigPath)());
+    if (!(0, fs_1.existsSync)(configPath)) {
+        throw new Error(`Raydium LP config not found at ${configPath}. Create raydium_lp.devnet.json from the example file first.`);
+    }
+    const raw = (0, fs_1.readFileSync)(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const config = {
+        amounts: {
+            baseAmountIn: parsePositiveInteger(parsed.amounts?.baseAmountIn, "amounts.baseAmountIn"),
+            otherAmountMin: parsePositiveInteger(parsed.amounts?.otherAmountMin, "amounts.otherAmountMin"),
+            quoteAmountIn: parsePositiveInteger(parsed.amounts?.quoteAmountIn, "amounts.quoteAmountIn")
+        },
+        poolConfig: {
+            authority: parsePublicKey(parsed.poolConfig?.authority, "poolConfig.authority"),
+            baseVault: parsePublicKey(parsed.poolConfig?.baseVault, "poolConfig.baseVault"),
+            lpMint: parsePublicKey(parsed.poolConfig?.lpMint, "poolConfig.lpMint"),
+            marketEventQueue: parsePublicKey(parsed.poolConfig?.marketEventQueue, "poolConfig.marketEventQueue"),
+            marketId: parsePublicKey(parsed.poolConfig?.marketId, "poolConfig.marketId"),
+            openOrders: parsePublicKey(parsed.poolConfig?.openOrders, "poolConfig.openOrders"),
+            poolId: parsePublicKey(parsed.poolConfig?.poolId, "poolConfig.poolId"),
+            poolType: parsePoolType(parsed.poolConfig?.poolType),
+            programId: parsePublicKey(parsed.poolConfig?.programId, "poolConfig.programId"),
+            quoteVault: parsePublicKey(parsed.poolConfig?.quoteVault, "poolConfig.quoteVault"),
+            targetOrders: parsePublicKey(parsed.poolConfig?.targetOrders, "poolConfig.targetOrders")
+        },
+        userTokenAccounts: {
+            baseTokenAccount: parsePublicKey(parsed.userTokenAccounts?.baseTokenAccount, "userTokenAccounts.baseTokenAccount"),
+            lpTokenAccount: parsePublicKey(parsed.userTokenAccounts?.lpTokenAccount, "userTokenAccounts.lpTokenAccount"),
+            quoteTokenAccount: parsePublicKey(parsed.userTokenAccounts?.quoteTokenAccount, "userTokenAccounts.quoteTokenAccount")
+        }
+    };
+    return config;
+}
+function parsePositiveInteger(value, field) {
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`${field} must be a positive integer.`);
+    }
+    return value;
+}
+function parsePoolType(value) {
+    if (value === "Standard" || value === "StablePool") {
+        return value;
+    }
+    throw new Error("poolConfig.poolType must be either 'Standard' or 'StablePool'.");
+}
+function parsePublicKey(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${field} must be a base58 public key string.`);
+    }
+    return new web3_js_1.PublicKey(value).toBase58();
+}

package/dist/defi/protocols.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROTOCOL_PRESETS = void 0;
+exports.PROTOCOL_PRESETS = {
+    jupiter: {
+        defaultMarketId: "sol-usdc",
+        description: "Spot swap routing for token rebalancing.",
+        label: "Jupiter",
+        protocol: "jupiter"
+    },
+    kamino: {
+        defaultMarketId: "main-usdc-vault",
+        description: "Yield and lending posture for idle stablecoin capital.",
+        label: "Kamino",
+        protocol: "kamino"
+    },
+    marinade: {
+        defaultMarketId: "primary-stake-pool",
+        description: "Liquid staking posture for idle SOL reserves.",
+        label: "Marinade",
+        protocol: "marinade"
+    },
+    raydium: {
+        defaultMarketId: "sol-usdc-core-pool",
+        description: "AMM liquidity posture for SOL/USDC LP management.",
+        label: "Raydium",
+        protocol: "raydium"
+    }
+};

package/dist/defi/types.js

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