@exponent-labs/exponent-sdk 0.1.8 → 0.9.0

package/build/exponentVaults/vault-interaction.js

@@ -0,0 +1,2251 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapDirection = exports.clmmAction = exports.loopscaleAction = exports.titanAction = exports.createOrderbookSyncTransaction = exports.coreAction = exports.syAction = exports.orderbookAction = exports.createVaultSyncTransaction = exports.kaminoAction = exports.ClmmAction = exports.LoopscaleAction = exports.TitanAction = exports.SyAction = exports.CoreAction = exports.OrderbookAction = exports.OrderbookTradeDirection = exports.VaultAction = void 0;
+const kamino_reserve_deserializer_1 = require("@exponent-labs/kamino-reserve-deserializer");
+const kamino_markets_1 = require("./kamino-markets");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const constants_1 = require("./../../../kamino-lend-standard/src/constants");
+const policyBuilders_1 = require("./policyBuilders");
+const accounts_1 = require("@exponent-labs/klend-idl/accounts");
+const precise_number_1 = require("@exponent-labs/precise-number");
+const orderbook_1 = require("../orderbook/orderbook");
+const marketThree_1 = require("../marketThree");
+const utils_1 = require("../utils");
+const clmm_1 = require("../client/clmm");
+Object.defineProperty(exports, "SwapDirection", { enumerable: true, get: function () { return clmm_1.SwapDirection; } });
+const exponentClmm = __importStar(require("../client/clmm"));
+const exponentVaults = __importStar(require("../client/vaults"));
+const orderbook_2 = require("../client/orderbook");
+const environment_1 = require("../environment");
+const vault_1 = require("../vault");
+const ytPosition_1 = require("../ytPosition");
+const vault_2 = require("./vault");
+const instructions_1 = require("@exponent-labs/klend-idl/instructions");
+const spl_token_1 = require("@solana/spl-token");
+const syncTransaction_1 = require("./syncTransaction");
+const policyMatcher_1 = require("./policyMatcher");
+const scope_refresh_1 = require("./scope-refresh");
+const web3_js_1 = require("@solana/web3.js");
+const bn_js_1 = __importDefault(require("bn.js"));
+const KAMINO_FARMS_PROGRAM_ID = new web3_js_1.PublicKey("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr");
+/** Actions that can be performed through the vault instruction builder. */
+var VaultAction;
+(function (VaultAction) {
+    VaultAction["INIT_USER_METADATA"] = "INIT_USER_METADATA";
+    VaultAction["INIT_OBLIGATION"] = "INIT_OBLIGATION";
+    VaultAction["DEPOSIT"] = "DEPOSIT";
+    VaultAction["WITHDRAW"] = "WITHDRAW";
+    VaultAction["BORROW"] = "BORROW";
+    VaultAction["REPAY"] = "REPAY";
+})(VaultAction || (exports.VaultAction = VaultAction = {}));
+// ============================================================================
+// Orderbook Instruction Types
+// ============================================================================
+/** Orderbook trade direction */
+var OrderbookTradeDirection;
+(function (OrderbookTradeDirection) {
+    OrderbookTradeDirection["BUY_PT"] = "BUY_PT";
+    OrderbookTradeDirection["SELL_PT"] = "SELL_PT";
+    OrderbookTradeDirection["BUY_YT"] = "BUY_YT";
+    OrderbookTradeDirection["SELL_YT"] = "SELL_YT";
+})(OrderbookTradeDirection || (exports.OrderbookTradeDirection = OrderbookTradeDirection = {}));
+/** Actions that can be performed on the Exponent Orderbook */
+var OrderbookAction;
+(function (OrderbookAction) {
+    OrderbookAction["POST_OFFER"] = "POST_OFFER";
+    OrderbookAction["MARKET_OFFER"] = "MARKET_OFFER";
+    OrderbookAction["REMOVE_OFFER"] = "REMOVE_OFFER";
+    OrderbookAction["WITHDRAW_FUNDS"] = "WITHDRAW_FUNDS";
+})(OrderbookAction || (exports.OrderbookAction = OrderbookAction = {}));
+// ============================================================================
+// Core Instruction Types (Strip/Merge)
+// ============================================================================
+/** Actions that can be performed on Exponent Core */
+var CoreAction;
+(function (CoreAction) {
+    CoreAction["STRIP"] = "STRIP";
+    CoreAction["MERGE"] = "MERGE";
+    CoreAction["WITHDRAW_YT"] = "WITHDRAW_YT";
+    CoreAction["DEPOSIT_YT"] = "DEPOSIT_YT";
+    CoreAction["INITIALIZE_YIELD_POSITION"] = "INITIALIZE_YIELD_POSITION";
+})(CoreAction || (exports.CoreAction = CoreAction = {}));
+// ============================================================================
+// Standard Program Instruction Types (mint_sy / redeem_sy)
+// ============================================================================
+var SyAction;
+(function (SyAction) {
+    SyAction["MINT"] = "MINT_SY";
+    SyAction["REDEEM"] = "REDEEM_SY";
+})(SyAction || (exports.SyAction = SyAction = {}));
+// ============================================================================
+// Titan Instruction Types
+// ============================================================================
+var TitanAction;
+(function (TitanAction) {
+    TitanAction["SWAP"] = "SWAP";
+})(TitanAction || (exports.TitanAction = TitanAction = {}));
+// ============================================================================
+// Loopscale Instruction Types
+// ============================================================================
+/** Actions for Loopscale interactions (loans = borrower side, strategies = lender side). */
+var LoopscaleAction;
+(function (LoopscaleAction) {
+    LoopscaleAction["CREATE_LOAN"] = "LOOPSCALE_CREATE_LOAN";
+    LoopscaleAction["DEPOSIT_COLLATERAL"] = "LOOPSCALE_DEPOSIT_COLLATERAL";
+    LoopscaleAction["BORROW_PRINCIPAL"] = "LOOPSCALE_BORROW_PRINCIPAL";
+    LoopscaleAction["REPAY_PRINCIPAL"] = "LOOPSCALE_REPAY_PRINCIPAL";
+    LoopscaleAction["WITHDRAW_COLLATERAL"] = "LOOPSCALE_WITHDRAW_COLLATERAL";
+    LoopscaleAction["CLOSE_LOAN"] = "LOOPSCALE_CLOSE_LOAN";
+    LoopscaleAction["UPDATE_WEIGHT_MATRIX"] = "LOOPSCALE_UPDATE_WEIGHT_MATRIX";
+    LoopscaleAction["CREATE_STRATEGY"] = "LOOPSCALE_CREATE_STRATEGY";
+    LoopscaleAction["DEPOSIT_STRATEGY"] = "LOOPSCALE_DEPOSIT_STRATEGY";
+    LoopscaleAction["WITHDRAW_STRATEGY"] = "LOOPSCALE_WITHDRAW_STRATEGY";
+    LoopscaleAction["CLOSE_STRATEGY"] = "LOOPSCALE_CLOSE_STRATEGY";
+    LoopscaleAction["UPDATE_STRATEGY"] = "LOOPSCALE_UPDATE_STRATEGY";
+    LoopscaleAction["LOCK_LOAN"] = "LOOPSCALE_LOCK_LOAN";
+    LoopscaleAction["UNLOCK_LOAN"] = "LOOPSCALE_UNLOCK_LOAN";
+    LoopscaleAction["REFINANCE_LEDGER"] = "LOOPSCALE_REFINANCE_LEDGER";
+})(LoopscaleAction || (exports.LoopscaleAction = LoopscaleAction = {}));
+// ============================================================================
+// CLMM Instruction Types
+// ============================================================================
+/** Actions that can be performed on the Exponent CLMM (Concentrated Liquidity Market Maker). */
+var ClmmAction;
+(function (ClmmAction) {
+    /** Create a new LP position with a specified tick range. Generates keypair internally. */
+    ClmmAction["DEPOSIT_LIQUIDITY"] = "CLMM_DEPOSIT_LIQUIDITY";
+    /** Add more liquidity to an existing LP position. */
+    ClmmAction["ADD_LIQUIDITY"] = "CLMM_ADD_LIQUIDITY";
+    /** Remove liquidity from an LP position and receive PT + SY. */
+    ClmmAction["WITHDRAW_LIQUIDITY"] = "CLMM_WITHDRAW_LIQUIDITY";
+    /** Low-level PT/SY swap. Prefer buyPt/sellPt for directional trades. */
+    ClmmAction["TRADE_PT"] = "CLMM_TRADE_PT";
+    /** Buy PT with SY on the CLMM. */
+    ClmmAction["BUY_PT"] = "CLMM_BUY_PT";
+    /** Sell PT for SY on the CLMM. */
+    ClmmAction["SELL_PT"] = "CLMM_SELL_PT";
+    /** Buy YT with SY on the CLMM. */
+    ClmmAction["BUY_YT"] = "CLMM_BUY_YT";
+    /** Sell YT for SY on the CLMM. */
+    ClmmAction["SELL_YT"] = "CLMM_SELL_YT";
+    /** Claim farm emissions from an LP position. */
+    ClmmAction["CLAIM_FARM_EMISSION"] = "CLMM_CLAIM_FARM_EMISSION";
+})(ClmmAction || (exports.ClmmAction = ClmmAction = {}));
+// ============================================================================
+// Kamino Action Builders
+// ============================================================================
+/**
+ * Builder for Kamino Lending (KLend) vault action descriptors.
+ *
+ * Each method returns a `VaultInstruction` that describes what to do.
+ * Pass these to `createVaultSyncTransaction` which resolves them into
+ * raw Solana instructions, handles refresh ordering, and wraps them
+ * in a Squads sync transaction.
+ *
+ * @example
+ * ```ts
+ * import { kaminoAction, KaminoMarket, createVaultSyncTransaction } from "@exponent-labs/exponent-sdk"
+ *
+ * const syncTx = await createVaultSyncTransaction({
+ *   instructions: [
+ *     kaminoAction.initUserMetadata(KaminoMarket.MAIN),
+ *     kaminoAction.initObligation(KaminoMarket.MAIN),
+ *     kaminoAction.deposit(KaminoMarket.MAIN, "USDC", new BN(1_000_000)),
+ *   ],
+ *   owner: vaultPda,
+ *   connection,
+ *   policyPda,
+ *   vaultPda,
+ *   signer: walletPublicKey,
+ * })
+ * ```
+ */
+exports.kaminoAction = {
+    /**
+     * Initialize Kamino user metadata for a market.
+     * No-ops if the account already exists on-chain.
+     * @param market - The Kamino lending market
+     */
+    initUserMetadata(market) {
+        return { action: VaultAction.INIT_USER_METADATA, market };
+    },
+    /**
+     * Initialize a Kamino obligation for a market.
+     * No-ops if the account already exists on-chain.
+     * @param market - The Kamino lending market
+     */
+    initObligation(market) {
+        return { action: VaultAction.INIT_OBLIGATION, market };
+    },
+    /**
+     * Deposit collateral into a Kamino reserve.
+     * Automatically prepends refreshReserve + refreshObligation instructions.
+     * @param market - The Kamino lending market
+     * @param asset - The reserve asset (e.g. "USDC", "SOL")
+     * @param amount - Amount in the asset's native units
+     */
+    deposit(market, asset, amount) {
+        return { action: VaultAction.DEPOSIT, market, asset: asset, amount };
+    },
+    /**
+     * Withdraw collateral from a Kamino reserve.
+     * @param market - The Kamino lending market
+     * @param asset - The reserve asset (e.g. "USDC", "SOL")
+     * @param amount - Amount in the asset's native units
+     */
+    withdraw(market, asset, amount) {
+        return { action: VaultAction.WITHDRAW, market, asset: asset, amount };
+    },
+    /**
+     * Borrow from a Kamino reserve.
+     * @param market - The Kamino lending market
+     * @param asset - The reserve asset (e.g. "USDC", "SOL")
+     * @param amount - Amount in the asset's native units
+     */
+    borrow(market, asset, amount) {
+        return { action: VaultAction.BORROW, market, asset: asset, amount };
+    },
+    /**
+     * Repay a borrow on a Kamino reserve.
+     * @param market - The Kamino lending market
+     * @param asset - The reserve asset (e.g. "USDC", "SOL")
+     * @param amount - Amount in the asset's native units
+     */
+    repay(market, asset, amount) {
+        return { action: VaultAction.REPAY, market, asset: asset, amount };
+    },
+};
+/**
+ * Build vault instructions and wrap them in a Squads sync transaction.
+ *
+ * Takes high-level `VaultInstruction` descriptors (built with `kamino.*`),
+ * resolves them to raw Solana instructions, then separates them:
+ * - Permissionless refresh instructions → `preInstructions` (top-level)
+ * - Vault-signed instructions → `instruction` (Squads sync transaction)
+ *
+ * KLend's `check_refresh` requires refreshReserve to be a top-level instruction
+ * so it can be found via the instruction sysvar.
+ *
+ * @returns `{ setupInstructions, preInstructions, instruction, postInstructions, signers, addressLookupTableAddresses }`
+ *
+ * @example
+ * ```ts
+ * const { setupInstructions, preInstructions, instruction, postInstructions, signers, addressLookupTableAddresses } = await createVaultSyncTransaction({
+ *   instructions: [
+ *     kamino.initUserMetadata(KaminoMarket.MAIN),
+ *     kamino.initObligation(KaminoMarket.MAIN),
+ *     kamino.deposit(KaminoMarket.MAIN, "USDC", new BN(1_000_000)),
+ *   ],
+ *   owner: vaultPda,
+ *   connection,
+ *   policyPda,
+ *   vaultPda,
+ *   signer: wallet.publicKey,
+ *   vaultAddress: VAULT_ADDRESS,
+ * })
+ * // Send: [...setupInstructions, ...preInstructions, instruction, ...postInstructions]
+ * ```
+ */
+async function createVaultSyncTransaction({ instructions, owner, connection, policyPda, vaultPda, signer, accountIndex = 0, constraintIndices, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram = syncTransaction_1.SQUADS_PROGRAM_ID, }) {
+    const { setupInstructions, syncInstructions, preInstructions, postInstructions, signers, addressLookupTableAddresses } = await buildVaultInstructions(instructions, owner, connection, signer, policyPda, vaultPda, accountIndex, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram);
+    let resolvedPolicyPda = policyPda;
+    let resolvedConstraintIndices = constraintIndices;
+    if (!resolvedPolicyPda) {
+        if (!vaultAddress) {
+            throw new Error("vaultAddress is required when policyPda is not provided");
+        }
+        const match = await (0, policyMatcher_1.resolvePolicyMatchForVault)(connection, vaultAddress, signer, syncInstructions);
+        resolvedPolicyPda = match.policyPda;
+        resolvedConstraintIndices ??= match.constraintIndices;
+    }
+    // Auto-resolve constraint indices when not explicitly provided
+    resolvedConstraintIndices ??= await (0, policyMatcher_1.resolveConstraintIndices)(connection, resolvedPolicyPda, syncInstructions);
+    // Auto-resolve policy prefix and hook accounts when not explicitly provided
+    let resolvedLeadingAccounts = leadingAccounts;
+    let resolvedPreHookAccounts = preHookAccounts;
+    let resolvedPostHookAccounts = postHookAccounts;
+    if (vaultAddress && (!leadingAccounts || !preHookAccounts || !postHookAccounts)) {
+        const hooks = await (0, policyMatcher_1.resolveHookAccounts)(connection, resolvedPolicyPda, vaultAddress, signer);
+        resolvedLeadingAccounts ??= hooks.leadingAccounts;
+        resolvedPreHookAccounts ??= hooks.preHookAccounts;
+        resolvedPostHookAccounts ??= hooks.postHookAccounts;
+    }
+    const instruction = (0, syncTransaction_1.wrapInstructionsInSyncTransaction)({
+        policyPda: resolvedPolicyPda,
+        vaultPda,
+        signer,
+        instructions: syncInstructions,
+        squadsProgram,
+        accountIndex,
+        constraintIndices: resolvedConstraintIndices,
+        leadingAccounts: resolvedLeadingAccounts,
+        preHookAccounts: resolvedPreHookAccounts,
+        postHookAccounts: resolvedPostHookAccounts,
+    });
+    return { setupInstructions, preInstructions, instruction, postInstructions, signers, addressLookupTableAddresses };
+}
+exports.createVaultSyncTransaction = createVaultSyncTransaction;
+// ============================================================================
+// Internal: Instruction Assembly
+// ============================================================================
+/** KLend farm modes — collateral for deposit/withdraw, debt for borrow/repay. */
+const FARM_COLLATERAL = 0;
+const FARM_DEBT = 1;
+function isOrderbookInstruction(ix) {
+    return Object.values(OrderbookAction).includes(ix.action);
+}
+function isCoreInstruction(ix) {
+    return Object.values(CoreAction).includes(ix.action);
+}
+function isSyInstruction(ix) {
+    return Object.values(SyAction).includes(ix.action);
+}
+function isTitanInstruction(ix) {
+    return Object.values(TitanAction).includes(ix.action);
+}
+function isClmmInstruction(ix) {
+    return Object.values(ClmmAction).includes(ix.action);
+}
+function isLoopscaleInstruction(ix) {
+    return Object.values(LoopscaleAction).includes(ix.action);
+}
+/** Cache for loaded vaults to avoid redundant fetches */
+const vaultCache = new Map();
+const TITAN_INPUT_MINT_ACCOUNT_INDEX = 2;
+const TITAN_INPUT_TOKEN_ACCOUNT_INDEX = 3;
+const TITAN_OUTPUT_MINT_ACCOUNT_INDEX = 4;
+const TITAN_OUTPUT_TOKEN_ACCOUNT_INDEX = 5;
+const TITAN_INPUT_TOKEN_PROGRAM_ACCOUNT_INDEX = 6;
+const TITAN_OUTPUT_TOKEN_PROGRAM_ACCOUNT_INDEX = 7;
+const YIELD_POSITION_BASE_SIZE = 124;
+const YIELD_POSITION_TRACKER_SIZE = 40;
+function createStrategySetupContext({ connection, env, owner, signer, vaultAddress, policyPda, vaultPda, accountIndex = 0, squadsProgram = syncTransaction_1.SQUADS_PROGRAM_ID, leadingAccounts, preHookAccounts, postHookAccounts, }) {
+    return {
+        connection,
+        env,
+        owner,
+        signer,
+        vaultAddress,
+        policyPda,
+        vaultPda,
+        accountIndex,
+        squadsProgram,
+        leadingAccounts,
+        preHookAccounts,
+        postHookAccounts,
+    };
+}
+async function loadStrategySetupState(context) {
+    if (!context.vaultAddress) {
+        return null;
+    }
+    if (!context.statePromise) {
+        context.statePromise = (async () => {
+            const strategyVault = await vault_2.ExponentVault.load({
+                env: context.env,
+                connection: context.connection,
+                address: context.vaultAddress,
+            });
+            const prices = await strategyVault.fetcher.fetchExponentPrices();
+            const trackedOrderbooks = new Set();
+            const trackedYieldVaults = new Set();
+            const tokenEntryAccountByMint = new Map();
+            const tokenPositionIndexByMint = new Map();
+            const trackedTokenAccounts = new Set();
+            for (const entry of strategyVault.state.tokenEntries) {
+                tokenEntryAccountByMint.set(entry.mint.toBase58(), entry.tokenSquadsAccount.toBase58());
+                trackedTokenAccounts.add(entry.tokenSquadsAccount.toBase58());
+            }
+            for (const [index, position] of strategyVault.state.strategyPositions.entries()) {
+                if ("orderbook" in position && position.orderbook?.[0]) {
+                    trackedOrderbooks.add(position.orderbook[0].orderbook.toBase58());
+                    continue;
+                }
+                if ("yieldPosition" in position && position.yieldPosition?.[0]) {
+                    trackedYieldVaults.add(position.yieldPosition[0].vault.toBase58());
+                    continue;
+                }
+                if ("tokenAccount" in position && position.tokenAccount?.[0]) {
+                    const entry = position.tokenAccount[0];
+                    tokenPositionIndexByMint.set(entry.tokenMint.toBase58(), index);
+                    for (const balance of entry.balances) {
+                        trackedTokenAccounts.add(balance.tokenAccount.toBase58());
+                    }
+                }
+            }
+            return {
+                strategyVault,
+                prices,
+                nextStrategyPositionIndex: strategyVault.state.strategyPositions.length,
+                trackedOrderbooks,
+                trackedYieldVaults,
+                tokenEntryAccountByMint,
+                tokenPositionIndexByMint,
+                trackedTokenAccounts,
+                existingAccounts: new Map(),
+            };
+        })();
+    }
+    return context.statePromise;
+}
+function findSimplePrice(prices, priceMint, underlyingMint) {
+    for (const entry of prices.prices) {
+        if (!entry)
+            continue;
+        if (!entry.priceMint.equals(priceMint) || !entry.underlyingMint.equals(underlyingMint)) {
+            continue;
+        }
+        return {
+            priceId: entry.priceId,
+            price: exponentPriceToDecimal(entry),
+        };
+    }
+    return null;
+}
+function exponentPriceToDecimal(entry) {
+    const raw = entry.price[0];
+    if (!Array.isArray(raw)) {
+        throw new Error(`Invalid Exponent price format for ${entry.priceId.toString()}`);
+    }
+    return new decimal_js_1.default((0, precise_number_1.bigintU256ToString)(raw.map((value) => BigInt(value.toString()))));
+}
+async function accountExists(state, connection, address) {
+    const cacheKey = address.toBase58();
+    const cached = state.existingAccounts.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const exists = (await connection.getAccountInfo(address)) !== null;
+    state.existingAccounts.set(cacheKey, exists);
+    return exists;
+}
+async function maybeCreateOwnedAtaSetupInstruction({ state, connection, payer, owner, mint, tokenProgram, tokenAccount, }) {
+    if (await accountExists(state, connection, tokenAccount)) {
+        return null;
+    }
+    const expectedAta = (0, spl_token_1.getAssociatedTokenAddressSync)(mint, owner, true, tokenProgram);
+    if (!expectedAta.equals(tokenAccount)) {
+        return null;
+    }
+    state.existingAccounts.set(tokenAccount.toBase58(), true);
+    return (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(payer, tokenAccount, owner, mint, tokenProgram);
+}
+async function ensureOrderbookPositionSetup(orderbook, buckets, setupContext) {
+    const state = await loadStrategySetupState(setupContext);
+    if (!state) {
+        return;
+    }
+    const orderbookKey = orderbook.selfAddress.toBase58();
+    if (state.trackedOrderbooks.has(orderbookKey)) {
+        return;
+    }
+    const ptPrice = findSimplePrice(state.prices, orderbook.mintPt, state.strategyVault.state.underlyingMint);
+    if (!ptPrice) {
+        throw new Error(`Missing Exponent price for orderbook setup (${orderbook.selfAddress.toBase58()})`);
+    }
+    buckets.setupInstructions.push(state.strategyVault.ixWrapperManageVaultSettings({
+        manager: setupContext.signer,
+        actions: [
+            exponentVaults.vaultSettingsAction("AddOrderbookEntry", [{
+                    orderbook: orderbook.selfAddress,
+                    // Legacy field retained for layout compatibility. Order ownership is
+                    // derived from live orderbook state during AUM calculation.
+                    userEscrowIdx: 0,
+                    mint: orderbook.vault.mintSy,
+                    offerIdxVec: [],
+                    priceIdPt: exponentVaults.priceId("Simple", { priceId: ptPrice.priceId }),
+                    baseMint: state.strategyVault.state.underlyingMint,
+                }]),
+        ],
+        remainingAccounts: [
+            { pubkey: orderbook.selfAddress, isSigner: false, isWritable: false },
+            { pubkey: orderbook.state.vault, isSigner: false, isWritable: false },
+        ],
+    }));
+    state.trackedOrderbooks.add(orderbookKey);
+    state.nextStrategyPositionIndex += 1;
+}
+async function ensureYieldPositionSetup(coreVault, buckets, setupContext) {
+    const state = await loadStrategySetupState(setupContext);
+    if (!state) {
+        return;
+    }
+    const coreVaultKey = coreVault.selfAddress.toBase58();
+    if (state.trackedYieldVaults.has(coreVaultKey)) {
+        return;
+    }
+    const ptPrice = findSimplePrice(state.prices, coreVault.mintPt, state.strategyVault.state.underlyingMint);
+    if (!ptPrice) {
+        throw new Error(`Missing Exponent price for core vault setup (${coreVault.selfAddress.toBase58()})`);
+    }
+    const yieldPosition = coreVault.pda.yieldPosition({ owner: setupContext.owner, vault: coreVault.selfAddress });
+    if (!(await accountExists(state, setupContext.connection, yieldPosition))) {
+        const requiredLamports = await setupContext.connection.getMinimumBalanceForRentExemption(YIELD_POSITION_BASE_SIZE + (coreVault.state.emissions.length * YIELD_POSITION_TRACKER_SIZE));
+        const ownerLamports = await setupContext.connection.getBalance(setupContext.owner);
+        if (ownerLamports < requiredLamports) {
+            buckets.setupInstructions.push(web3_js_1.SystemProgram.transfer({
+                fromPubkey: setupContext.signer,
+                toPubkey: setupContext.owner,
+                lamports: requiredLamports - ownerLamports,
+            }));
+        }
+        const initializeYieldPositionIx = coreVault.ixInitializeYieldPosition({ owner: setupContext.owner });
+        try {
+            buckets.setupInstructions.push(await wrapVaultSignedSetupInstruction({
+                instruction: initializeYieldPositionIx,
+                setupContext,
+            }));
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to auto-initialize yield position ${yieldPosition.toBase58()} for ${coreVault.selfAddress.toBase58()}: ${reason}`);
+        }
+        state.existingAccounts.set(yieldPosition.toBase58(), true);
+    }
+    buckets.setupInstructions.push(state.strategyVault.ixWrapperManageVaultSettings({
+        manager: setupContext.signer,
+        actions: [
+            exponentVaults.vaultSettingsAction("AddYieldPositionEntry", {
+                yieldPosition,
+                vault: coreVault.selfAddress,
+                priceIdPt: exponentVaults.priceId("Simple", { priceId: ptPrice.priceId }),
+            }),
+        ],
+        remainingAccounts: [
+            { pubkey: coreVault.selfAddress, isSigner: false, isWritable: false },
+            { pubkey: yieldPosition, isSigner: false, isWritable: false },
+        ],
+    }));
+    state.trackedYieldVaults.add(coreVaultKey);
+    state.nextStrategyPositionIndex += 1;
+}
+async function wrapVaultSignedSetupInstruction({ instruction, setupContext, }) {
+    if (!setupContext.vaultPda) {
+        throw new Error("vaultPda is required to auto-wrap setup instructions");
+    }
+    let resolvedPolicyPda = setupContext.policyPda;
+    let constraintIndices;
+    if (!resolvedPolicyPda) {
+        if (!setupContext.vaultAddress) {
+            throw new Error("vaultAddress is required when policyPda is not provided");
+        }
+        const match = await (0, policyMatcher_1.resolvePolicyMatchForVault)(setupContext.connection, setupContext.vaultAddress, setupContext.signer, [instruction]);
+        resolvedPolicyPda = match.policyPda;
+        constraintIndices = match.constraintIndices;
+    }
+    else {
+        constraintIndices = await (0, policyMatcher_1.resolveConstraintIndices)(setupContext.connection, resolvedPolicyPda, [instruction]);
+    }
+    let resolvedLeadingAccounts = setupContext.leadingAccounts;
+    let resolvedPreHookAccounts = setupContext.preHookAccounts;
+    let resolvedPostHookAccounts = setupContext.postHookAccounts;
+    if (setupContext.vaultAddress
+        && (!resolvedLeadingAccounts || !resolvedPreHookAccounts || !resolvedPostHookAccounts)) {
+        const hooks = await (0, policyMatcher_1.resolveHookAccounts)(setupContext.connection, resolvedPolicyPda, setupContext.vaultAddress, setupContext.signer);
+        resolvedLeadingAccounts ??= hooks.leadingAccounts;
+        resolvedPreHookAccounts ??= hooks.preHookAccounts;
+        resolvedPostHookAccounts ??= hooks.postHookAccounts;
+    }
+    return (0, syncTransaction_1.wrapInstructionsInSyncTransaction)({
+        policyPda: resolvedPolicyPda,
+        vaultPda: setupContext.vaultPda,
+        signer: setupContext.signer,
+        instructions: [instruction],
+        squadsProgram: setupContext.squadsProgram,
+        accountIndex: setupContext.accountIndex,
+        constraintIndices,
+        leadingAccounts: resolvedLeadingAccounts,
+        preHookAccounts: resolvedPreHookAccounts,
+        postHookAccounts: resolvedPostHookAccounts,
+    });
+}
+async function ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext, }) {
+    const state = await loadStrategySetupState(setupContext);
+    if (!state) {
+        return;
+    }
+    const tokenMintKey = tokenMint.toBase58();
+    const tokenAccountKey = tokenAccount.toBase58();
+    const tokenEntryAccount = state.tokenEntryAccountByMint.get(tokenMintKey);
+    if (tokenEntryAccount) {
+        if (tokenEntryAccount !== tokenAccountKey) {
+            throw new Error(`Mint ${tokenMintKey} is tracked as a token entry on ${tokenEntryAccount}; use that account instead of ${tokenAccountKey}`);
+        }
+        state.trackedTokenAccounts.add(tokenAccountKey);
+        return;
+    }
+    if (state.trackedTokenAccounts.has(tokenAccountKey)) {
+        return;
+    }
+    const price = findSimplePrice(state.prices, tokenMint, state.strategyVault.state.underlyingMint);
+    if (!price) {
+        throw new Error(`Missing Exponent price for token position setup (${tokenMint.toBase58()})`);
+    }
+    const maybeAtaIx = await maybeCreateOwnedAtaSetupInstruction({
+        state,
+        connection: setupContext.connection,
+        payer: setupContext.signer,
+        owner: setupContext.owner,
+        mint: tokenMint,
+        tokenProgram,
+        tokenAccount,
+    });
+    if (maybeAtaIx) {
+        buckets.setupInstructions.push(maybeAtaIx);
+    }
+    const positionIndex = state.tokenPositionIndexByMint.get(tokenMintKey);
+    if (positionIndex === undefined) {
+        buckets.setupInstructions.push(state.strategyVault.ixWrapperManageVaultSettings({
+            manager: setupContext.signer,
+            actions: [
+                exponentVaults.vaultSettingsAction("AddTokenAccountEntry", [{
+                        tokenMint,
+                        balances: [{
+                                tokenAccount,
+                                mint: tokenMint,
+                                priceId: exponentVaults.priceId("Simple", { priceId: price.priceId }),
+                            }],
+                    }]),
+            ],
+            remainingAccounts: [
+                { pubkey: tokenAccount, isSigner: false, isWritable: false },
+            ],
+        }));
+        state.tokenPositionIndexByMint.set(tokenMintKey, state.nextStrategyPositionIndex);
+        state.nextStrategyPositionIndex += 1;
+    }
+    else {
+        buckets.setupInstructions.push(state.strategyVault.ixWrapperManagerUpdatePosition({
+            manager: setupContext.signer,
+            update: {
+                __kind: "AddTokenAccountBalance",
+                tokenMint,
+                balance: {
+                    tokenAccount,
+                    mint: tokenMint,
+                    priceId: exponentVaults.priceId("Simple", { priceId: price.priceId }),
+                },
+            },
+            remainingAccounts: [
+                { pubkey: tokenAccount, isSigner: false, isWritable: false },
+            ],
+        }));
+    }
+    state.trackedTokenAccounts.add(tokenAccountKey);
+}
+async function buildVaultInstructions(instructions, owner, connection, signer, policyPda, vaultPda, accountIndex, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram = syncTransaction_1.SQUADS_PROGRAM_ID) {
+    const buckets = {
+        setupInstructions: [],
+        syncInstructions: [],
+        preInstructions: [],
+        postInstructions: [],
+        signers: [],
+        addressLookupTableAddresses: [],
+    };
+    const setupContext = createStrategySetupContext({
+        connection,
+        env: environment_1.LOCAL_ENV,
+        owner,
+        signer,
+        vaultAddress,
+        policyPda,
+        vaultPda,
+        accountIndex,
+        squadsProgram,
+        leadingAccounts,
+        preHookAccounts,
+        postHookAccounts,
+    });
+    for (const ix of instructions) {
+        if (isOrderbookInstruction(ix)) {
+            await buildOrderbookInstruction(ix, owner, connection, buckets, setupContext);
+            continue;
+        }
+        if (isCoreInstruction(ix)) {
+            await buildCoreInstruction(ix, owner, connection, buckets, setupContext);
+            continue;
+        }
+        if (isSyInstruction(ix)) {
+            await buildSyInstruction(ix, owner, connection, buckets, setupContext);
+            continue;
+        }
+        if (isTitanInstruction(ix)) {
+            await buildTitanInstruction(ix, buckets, setupContext);
+            continue;
+        }
+        if (isLoopscaleInstruction(ix)) {
+            await buildLoopscaleInstruction(ix, buckets, setupContext);
+            continue;
+        }
+        if (isClmmInstruction(ix)) {
+            await buildClmmInstruction(ix, owner, connection, buckets, setupContext);
+            continue;
+        }
+        switch (ix.action) {
+            case VaultAction.INIT_USER_METADATA:
+                await buildInitUserMetadata(owner, connection, buckets);
+                break;
+            case VaultAction.INIT_OBLIGATION:
+                await buildInitObligation(ix, owner, connection, buckets);
+                break;
+            case VaultAction.DEPOSIT:
+                await buildDeposit(ix, owner, connection, signer, buckets);
+                break;
+            case VaultAction.WITHDRAW:
+                await buildWithdraw(ix, owner, connection, signer, buckets);
+                break;
+            case VaultAction.BORROW:
+                await buildBorrow(ix, owner, connection, signer, buckets);
+                break;
+            case VaultAction.REPAY:
+                await buildRepay(ix, owner, connection, signer, buckets);
+                break;
+        }
+    }
+    return buckets;
+}
+async function buildTitanInstruction(ix, buckets, setupContext) {
+    const inputMint = ix.instruction.keys[TITAN_INPUT_MINT_ACCOUNT_INDEX]?.pubkey;
+    const inputTokenAccount = ix.instruction.keys[TITAN_INPUT_TOKEN_ACCOUNT_INDEX]?.pubkey;
+    const outputMint = ix.instruction.keys[TITAN_OUTPUT_MINT_ACCOUNT_INDEX]?.pubkey;
+    const outputTokenAccount = ix.instruction.keys[TITAN_OUTPUT_TOKEN_ACCOUNT_INDEX]?.pubkey;
+    const inputTokenProgram = ix.instruction.keys[TITAN_INPUT_TOKEN_PROGRAM_ACCOUNT_INDEX]?.pubkey;
+    const outputTokenProgram = ix.instruction.keys[TITAN_OUTPUT_TOKEN_PROGRAM_ACCOUNT_INDEX]?.pubkey;
+    if (!inputMint
+        || !inputTokenAccount
+        || !outputMint
+        || !outputTokenAccount
+        || !inputTokenProgram
+        || !outputTokenProgram) {
+        throw new Error("Titan SwapRouteV2 instruction is missing expected token accounts");
+    }
+    await ensureTrackedTokenAccountSetup({
+        tokenMint: inputMint,
+        tokenAccount: inputTokenAccount,
+        tokenProgram: inputTokenProgram,
+        buckets,
+        setupContext,
+    });
+    await ensureTrackedTokenAccountSetup({
+        tokenMint: outputMint,
+        tokenAccount: outputTokenAccount,
+        tokenProgram: outputTokenProgram,
+        buckets,
+        setupContext,
+    });
+    buckets.syncInstructions.push(ix.instruction);
+}
+// Loopscale account indices per instruction (from the Loopscale IDL)
+const LOOPSCALE_DEPOSIT_COLLATERAL_MINT_INDEX = 6;
+const LOOPSCALE_DEPOSIT_COLLATERAL_BORROWER_TA_INDEX = 4;
+const LOOPSCALE_DEPOSIT_COLLATERAL_TOKEN_PROGRAM_INDEX = 9;
+const LOOPSCALE_BORROW_PRINCIPAL_MINT_INDEX = 6;
+const LOOPSCALE_BORROW_PRINCIPAL_BORROWER_TA_INDEX = 7;
+const LOOPSCALE_BORROW_PRINCIPAL_TOKEN_PROGRAM_INDEX = 10;
+const LOOPSCALE_REPAY_PRINCIPAL_MINT_INDEX = 6;
+const LOOPSCALE_REPAY_PRINCIPAL_BORROWER_TA_INDEX = 7;
+const LOOPSCALE_REPAY_PRINCIPAL_TOKEN_PROGRAM_INDEX = 10;
+const LOOPSCALE_WITHDRAW_COLLATERAL_MINT_INDEX = 7;
+const LOOPSCALE_WITHDRAW_COLLATERAL_BORROWER_TA_INDEX = 4;
+const LOOPSCALE_WITHDRAW_COLLATERAL_TOKEN_PROGRAM_INDEX = 8;
+const LOOPSCALE_DEPOSIT_STRATEGY_MINT_INDEX = 4;
+const LOOPSCALE_DEPOSIT_STRATEGY_LENDER_TA_INDEX = 6;
+const LOOPSCALE_DEPOSIT_STRATEGY_TOKEN_PROGRAM_INDEX = 8;
+const LOOPSCALE_WITHDRAW_STRATEGY_MINT_INDEX = 4;
+const LOOPSCALE_WITHDRAW_STRATEGY_LENDER_TA_INDEX = 6;
+const LOOPSCALE_WITHDRAW_STRATEGY_TOKEN_PROGRAM_INDEX = 9;
+/** Build a single Loopscale instruction (loan or strategy). Extracts token accounts for tracking. */
+async function buildLoopscaleInstruction(ix, buckets, setupContext) {
+    switch (ix.action) {
+        case LoopscaleAction.DEPOSIT_COLLATERAL: {
+            const tokenMint = ix.instruction.keys[LOOPSCALE_DEPOSIT_COLLATERAL_MINT_INDEX]?.pubkey;
+            const tokenAccount = ix.instruction.keys[LOOPSCALE_DEPOSIT_COLLATERAL_BORROWER_TA_INDEX]?.pubkey;
+            const tokenProgram = ix.instruction.keys[LOOPSCALE_DEPOSIT_COLLATERAL_TOKEN_PROGRAM_INDEX]?.pubkey;
+            if (!tokenMint || !tokenAccount || !tokenProgram) {
+                throw new Error("Loopscale deposit_collateral instruction is missing expected token accounts");
+            }
+            await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
+            break;
+        }
+        case LoopscaleAction.BORROW_PRINCIPAL: {
+            const tokenMint = ix.instruction.keys[LOOPSCALE_BORROW_PRINCIPAL_MINT_INDEX]?.pubkey;
+            const tokenAccount = ix.instruction.keys[LOOPSCALE_BORROW_PRINCIPAL_BORROWER_TA_INDEX]?.pubkey;
+            const tokenProgram = ix.instruction.keys[LOOPSCALE_BORROW_PRINCIPAL_TOKEN_PROGRAM_INDEX]?.pubkey;
+            if (!tokenMint || !tokenAccount || !tokenProgram) {
+                throw new Error("Loopscale borrow_principal instruction is missing expected token accounts");
+            }
+            await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
+            break;
+        }
+        case LoopscaleAction.REPAY_PRINCIPAL: {
+            const tokenMint = ix.instruction.keys[LOOPSCALE_REPAY_PRINCIPAL_MINT_INDEX]?.pubkey;
+            const tokenAccount = ix.instruction.keys[LOOPSCALE_REPAY_PRINCIPAL_BORROWER_TA_INDEX]?.pubkey;
+            const tokenProgram = ix.instruction.keys[LOOPSCALE_REPAY_PRINCIPAL_TOKEN_PROGRAM_INDEX]?.pubkey;
+            if (!tokenMint || !tokenAccount || !tokenProgram) {
+                throw new Error("Loopscale repay_principal instruction is missing expected token accounts");
+            }
+            await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
+            break;
+        }
+        case LoopscaleAction.WITHDRAW_COLLATERAL: {
+            const tokenMint = ix.instruction.keys[LOOPSCALE_WITHDRAW_COLLATERAL_MINT_INDEX]?.pubkey;
+            const tokenAccount = ix.instruction.keys[LOOPSCALE_WITHDRAW_COLLATERAL_BORROWER_TA_INDEX]?.pubkey;
+            const tokenProgram = ix.instruction.keys[LOOPSCALE_WITHDRAW_COLLATERAL_TOKEN_PROGRAM_INDEX]?.pubkey;
+            if (!tokenMint || !tokenAccount || !tokenProgram) {
+                throw new Error("Loopscale withdraw_collateral instruction is missing expected token accounts");
+            }
+            await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
+            break;
+        }
+        // create_loan, close_loan, and update_weight_matrix have no token accounts to track —
+        // the on-chain hook handles TrackLoopscaleLoan/UntrackLoopscaleLoan mutations.
+        // update_weight_matrix only has 3 accounts (bs_auth, borrower, loan).
+        case LoopscaleAction.DEPOSIT_STRATEGY: {
+            const tokenMint = ix.instruction.keys[LOOPSCALE_DEPOSIT_STRATEGY_MINT_INDEX]?.pubkey;
+            const tokenAccount = ix.instruction.keys[LOOPSCALE_DEPOSIT_STRATEGY_LENDER_TA_INDEX]?.pubkey;
+            const tokenProgram = ix.instruction.keys[LOOPSCALE_DEPOSIT_STRATEGY_TOKEN_PROGRAM_INDEX]?.pubkey;
+            if (!tokenMint || !tokenAccount || !tokenProgram) {
+                throw new Error("Loopscale deposit_strategy instruction is missing expected token accounts");
+            }
+            await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
+            break;
+        }
+        case LoopscaleAction.WITHDRAW_STRATEGY: {
+            const tokenMint = ix.instruction.keys[LOOPSCALE_WITHDRAW_STRATEGY_MINT_INDEX]?.pubkey;
+            const tokenAccount = ix.instruction.keys[LOOPSCALE_WITHDRAW_STRATEGY_LENDER_TA_INDEX]?.pubkey;
+            const tokenProgram = ix.instruction.keys[LOOPSCALE_WITHDRAW_STRATEGY_TOKEN_PROGRAM_INDEX]?.pubkey;
+            if (!tokenMint || !tokenAccount || !tokenProgram) {
+                throw new Error("Loopscale withdraw_strategy instruction is missing expected token accounts");
+            }
+            await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
+            break;
+        }
+        // create_strategy and close_strategy have no token accounts to track
+    }
+    buckets.syncInstructions.push(ix.instruction);
+}
+/** Build a single orderbook instruction (uses LOCAL_ENV for Orderbook.load) */
+async function buildOrderbookInstruction(ix, owner, connection, buckets, setupContext, env = environment_1.LOCAL_ENV) {
+    const cacheKey = ix.orderbook.toBase58();
+    let orderbook = orderbookCache.get(cacheKey);
+    if (!orderbook) {
+        orderbook = await orderbook_1.Orderbook.load(env, connection, ix.orderbook);
+        orderbookCache.set(cacheKey, orderbook);
+    }
+    switch (ix.action) {
+        case OrderbookAction.POST_OFFER:
+            await buildPostOffer(ix, orderbook, owner, setupContext?.signer ?? owner, buckets, setupContext);
+            break;
+        case OrderbookAction.MARKET_OFFER:
+            await buildMarketOffer(ix, orderbook, owner, setupContext?.signer ?? owner, buckets, setupContext);
+            break;
+        case OrderbookAction.REMOVE_OFFER:
+            await buildRemoveOffer(ix, orderbook, owner, buckets);
+            break;
+        case OrderbookAction.WITHDRAW_FUNDS:
+            await buildWithdrawFunds(ix, orderbook, owner, buckets);
+            break;
+    }
+}
+// ============================================================================
+// Action Builders (one per VaultAction)
+// ============================================================================
+async function buildInitUserMetadata(owner, connection, { syncInstructions }) {
+    const userMetadata = (0, constants_1.getKaminoUserMetadata)(owner, policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
+    const userMetadataAccount = await connection.getAccountInfo(userMetadata);
+    if (userMetadataAccount)
+        return;
+    syncInstructions.push((0, instructions_1.initUserMetadata)({ userLookupTable: web3_js_1.PublicKey.default }, {
+        owner,
+        feePayer: owner,
+        userMetadata,
+        referrerUserMetadata: policyBuilders_1.KAMINO_LENDING_PROGRAM_ID,
+        rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+        systemProgram: web3_js_1.SystemProgram.programId,
+    }));
+}
+async function buildInitObligation(ix, owner, connection, { syncInstructions }) {
+    const lendingMarket = kamino_markets_1.KAMINO_MARKETS[ix.market];
+    const obligation = (0, constants_1.getKaminoLendObligation)(owner, lendingMarket, policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
+    const userMetadata = (0, constants_1.getKaminoUserMetadata)(owner, policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
+    const obligationAccount = await connection.getAccountInfo(obligation);
+    if (obligationAccount)
+        return;
+    syncInstructions.push((0, instructions_1.initObligation)({ args: { tag: 0, id: 0 } }, {
+        obligationOwner: owner,
+        feePayer: owner,
+        obligation,
+        lendingMarket,
+        seed1Account: web3_js_1.SystemProgram.programId,
+        seed2Account: web3_js_1.SystemProgram.programId,
+        ownerUserMetadata: userMetadata,
+        rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+        systemProgram: web3_js_1.SystemProgram.programId,
+    }));
+}
+async function buildDeposit(ix, owner, connection, signer, { setupInstructions, syncInstructions, preInstructions, postInstructions }) {
+    const ctx = await resolveReserveContext(ix, owner, connection);
+    const refreshes = await buildRefreshInstructions({
+        ...ctx, owner, farmMode: FARM_COLLATERAL, signer, connection, needsScopeRefresh: false,
+    });
+    const isSOL = ctx.reserveAccount.liquidity.mintPubkey.equals(spl_token_1.NATIVE_MINT);
+    const userSourceLiquidity = (0, spl_token_1.getAssociatedTokenAddressSync)(ctx.reserveAccount.liquidity.mintPubkey, owner, true, ctx.reserveAccount.liquidity.tokenProgram);
+    if (isSOL) {
+        setupInstructions.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(signer, userSourceLiquidity, owner, spl_token_1.NATIVE_MINT, spl_token_1.TOKEN_PROGRAM_ID));
+    }
+    preInstructions.push(...refreshes.preInstructions);
+    postInstructions.push(...refreshes.postInstructions);
+    syncInstructions.push((0, instructions_1.depositReserveLiquidityAndObligationCollateralV2)({ liquidityAmount: ix.amount }, {
+        depositAccounts: {
+            owner,
+            obligation: ctx.obligation,
+            lendingMarket: ctx.lendingMarket,
+            lendingMarketAuthority: ctx.lendingMarketAuthority,
+            reserve: ctx.reservePubkey,
+            reserveLiquidityMint: ctx.reserveAccount.liquidity.mintPubkey,
+            reserveLiquiditySupply: ctx.reserveAccount.liquidity.supplyVault,
+            reserveCollateralMint: ctx.reserveAccount.collateral.mintPubkey,
+            reserveDestinationDepositCollateral: ctx.reserveAccount.collateral.supplyVault,
+            userSourceLiquidity,
+            placeholderUserDestinationCollateral: owner,
+            collateralTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            liquidityTokenProgram: ctx.reserveAccount.liquidity.tokenProgram,
+            instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+        },
+        farmsAccounts: refreshes.farmsAccounts,
+        farmsProgram: KAMINO_FARMS_PROGRAM_ID,
+    }));
+}
+async function buildWithdraw(ix, owner, connection, signer, { setupInstructions, syncInstructions, preInstructions, postInstructions }) {
+    const ctx = await resolveReserveContext(ix, owner, connection);
+    const refreshes = await buildRefreshInstructions({
+        ...ctx, owner, farmMode: FARM_COLLATERAL, signer, connection, needsScopeRefresh: true,
+    });
+    const isSOL = ctx.reserveAccount.liquidity.mintPubkey.equals(spl_token_1.NATIVE_MINT);
+    const userDestinationLiquidity = (0, spl_token_1.getAssociatedTokenAddressSync)(ctx.reserveAccount.liquidity.mintPubkey, owner, true, ctx.reserveAccount.liquidity.tokenProgram);
+    preInstructions.push(...refreshes.scopeRefreshInstructions);
+    if (isSOL) {
+        setupInstructions.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(signer, userDestinationLiquidity, owner, spl_token_1.NATIVE_MINT, spl_token_1.TOKEN_PROGRAM_ID));
+    }
+    preInstructions.push(...refreshes.preInstructions);
+    postInstructions.push(...refreshes.postInstructions);
+    // Convert liquidity amount → collateral amount using the reserve's exchange rate
+    const exchangeRate = ctx.reserveAccount.getCollateralExchangeRate();
+    if (exchangeRate.isZero())
+        throw new Error(`Reserve ${ctx.reservePubkey.toBase58()} has zero exchange rate`);
+    const collateralAmount = new bn_js_1.default(new decimal_js_1.default(ix.amount.toString()).div(exchangeRate).floor().toString());
+    syncInstructions.push((0, instructions_1.withdrawObligationCollateralAndRedeemReserveCollateralV2)({ collateralAmount }, {
+        withdrawAccounts: {
+            owner,
+            obligation: ctx.obligation,
+            lendingMarket: ctx.lendingMarket,
+            lendingMarketAuthority: ctx.lendingMarketAuthority,
+            withdrawReserve: ctx.reservePubkey,
+            reserveLiquidityMint: ctx.reserveAccount.liquidity.mintPubkey,
+            reserveSourceCollateral: ctx.reserveAccount.collateral.supplyVault,
+            reserveCollateralMint: ctx.reserveAccount.collateral.mintPubkey,
+            reserveLiquiditySupply: ctx.reserveAccount.liquidity.supplyVault,
+            userDestinationLiquidity,
+            placeholderUserDestinationCollateral: owner,
+            collateralTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            liquidityTokenProgram: ctx.reserveAccount.liquidity.tokenProgram,
+            instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+        },
+        farmsAccounts: refreshes.farmsAccounts,
+        farmsProgram: KAMINO_FARMS_PROGRAM_ID,
+    }));
+}
+async function buildBorrow(ix, owner, connection, signer, { setupInstructions, syncInstructions, preInstructions, postInstructions }) {
+    const ctx = await resolveReserveContext(ix, owner, connection);
+    const refreshes = await buildRefreshInstructions({
+        ...ctx, owner, farmMode: FARM_DEBT, signer, connection, needsScopeRefresh: true,
+    });
+    const isSOL = ctx.reserveAccount.liquidity.mintPubkey.equals(spl_token_1.NATIVE_MINT);
+    const userDestinationLiquidity = (0, spl_token_1.getAssociatedTokenAddressSync)(ctx.reserveAccount.liquidity.mintPubkey, owner, true, ctx.reserveAccount.liquidity.tokenProgram);
+    preInstructions.push(...refreshes.scopeRefreshInstructions);
+    setupInstructions.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(signer, userDestinationLiquidity, owner, ctx.reserveAccount.liquidity.mintPubkey, ctx.reserveAccount.liquidity.tokenProgram));
+    preInstructions.push(...refreshes.preInstructions);
+    postInstructions.push(...refreshes.postInstructions);
+    syncInstructions.push((0, instructions_1.borrowObligationLiquidityV2)({ liquidityAmount: ix.amount }, {
+        borrowAccounts: {
+            owner,
+            obligation: ctx.obligation,
+            lendingMarket: ctx.lendingMarket,
+            lendingMarketAuthority: ctx.lendingMarketAuthority,
+            borrowReserve: ctx.reservePubkey,
+            borrowReserveLiquidityMint: ctx.reserveAccount.liquidity.mintPubkey,
+            reserveSourceLiquidity: ctx.reserveAccount.liquidity.supplyVault,
+            borrowReserveLiquidityFeeReceiver: ctx.reserveAccount.liquidity.feeVault,
+            userDestinationLiquidity,
+            referrerTokenState: null,
+            tokenProgram: ctx.reserveAccount.liquidity.tokenProgram,
+            instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+        },
+        farmsAccounts: refreshes.farmsAccounts,
+        farmsProgram: KAMINO_FARMS_PROGRAM_ID,
+    }));
+}
+async function buildRepay(ix, owner, connection, signer, { setupInstructions, syncInstructions, preInstructions, postInstructions }) {
+    const ctx = await resolveReserveContext(ix, owner, connection);
+    const refreshes = await buildRefreshInstructions({
+        ...ctx, owner, farmMode: FARM_DEBT, signer, connection, needsScopeRefresh: false,
+    });
+    const isSOL = ctx.reserveAccount.liquidity.mintPubkey.equals(spl_token_1.NATIVE_MINT);
+    const userSourceLiquidity = (0, spl_token_1.getAssociatedTokenAddressSync)(ctx.reserveAccount.liquidity.mintPubkey, owner, true, ctx.reserveAccount.liquidity.tokenProgram);
+    if (isSOL) {
+        setupInstructions.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(signer, userSourceLiquidity, owner, spl_token_1.NATIVE_MINT, spl_token_1.TOKEN_PROGRAM_ID));
+    }
+    preInstructions.push(...refreshes.preInstructions);
+    postInstructions.push(...refreshes.postInstructions);
+    syncInstructions.push((0, instructions_1.repayObligationLiquidityV2)({ liquidityAmount: ix.amount }, {
+        repayAccounts: {
+            owner,
+            obligation: ctx.obligation,
+            lendingMarket: ctx.lendingMarket,
+            repayReserve: ctx.reservePubkey,
+            reserveLiquidityMint: ctx.reserveAccount.liquidity.mintPubkey,
+            reserveDestinationLiquidity: ctx.reserveAccount.liquidity.supplyVault,
+            userSourceLiquidity,
+            tokenProgram: ctx.reserveAccount.liquidity.tokenProgram,
+            instructionSysvarAccount: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+        },
+        farmsAccounts: refreshes.farmsAccounts,
+        lendingMarketAuthority: ctx.lendingMarketAuthority,
+        farmsProgram: KAMINO_FARMS_PROGRAM_ID,
+    }));
+}
+async function resolveReserveContext(ix, owner, connection) {
+    const lendingMarket = kamino_markets_1.KAMINO_MARKETS[ix.market];
+    const reserveEntry = kamino_markets_1.KAMINO_RESERVES[ix.market][ix.asset];
+    const reservePubkey = reserveEntry?.pubkey;
+    if (!reservePubkey)
+        throw new Error(`Unknown reserve: ${ix.market}/${ix.asset}`);
+    const reserveAccount = await kamino_reserve_deserializer_1.Reserve.fetch(connection, reservePubkey);
+    if (!reserveAccount)
+        throw new Error(`Reserve not found: ${reservePubkey.toBase58()}`);
+    const obligation = (0, constants_1.getKaminoLendObligation)(owner, lendingMarket, policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
+    const [lendingMarketAuthority] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("lma"), lendingMarket.toBuffer()], policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
+    return { reservePubkey, reserveAccount, obligation, lendingMarket, lendingMarketAuthority };
+}
+/**
+ * Build the freshness and farm-setup instructions required before direct KLend operations.
+ *
+ * @param farmMode - FARM_COLLATERAL (deposit/withdraw) or FARM_DEBT (borrow/repay)
+ * @param needsScopeRefresh - true for borrow/withdraw (ALL_CHECKS), false for deposit/repay (NONE)
+ */
+async function buildRefreshInstructions({ reservePubkey, reserveAccount, lendingMarket, lendingMarketAuthority, obligation, owner, farmMode, signer, connection, needsScopeRefresh, }) {
+    const pre = [];
+    const post = [];
+    const defaultKey = web3_js_1.PublicKey.default;
+    const oracleOrSentinel = (key) => key.equals(defaultKey) ? policyBuilders_1.KAMINO_LENDING_PROGRAM_ID : key;
+    // Determine farm state based on mode (collateral vs debt)
+    const farmState = farmMode === FARM_COLLATERAL ? reserveAccount.farmCollateral : reserveAccount.farmDebt;
+    const hasFarm = !farmState.equals(defaultKey);
+    let obligationFarmUserState;
+    if (hasFarm) {
+        obligationFarmUserState = (0, constants_1.getKaminoFarmsObligationFarm)(obligation, farmState, KAMINO_FARMS_PROGRAM_ID);
+    }
+    const farmsAccounts = hasFarm
+        ? {
+            obligationFarmUserState,
+            reserveFarmState: farmState,
+        }
+        : {};
+    // 1. Init obligation farms (if needed, before all refreshes)
+    if (hasFarm) {
+        const farmUserStateAccount = await connection.getAccountInfo(obligationFarmUserState);
+        if (!farmUserStateAccount) {
+            pre.push((0, instructions_1.initObligationFarmsForReserve)({ mode: farmMode }, {
+                payer: signer,
+                owner,
+                obligation,
+                lendingMarketAuthority,
+                reserve: reservePubkey,
+                reserveFarmState: farmState,
+                obligationFarm: obligationFarmUserState,
+                lendingMarket,
+                farmsProgram: KAMINO_FARMS_PROGRAM_ID,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: web3_js_1.SystemProgram.programId,
+            }));
+        }
+    }
+    // 2. Refresh ALL active reserves in the obligation + the operation reserve.
+    // KLend's refreshObligation requires every reserve passed as a remaining
+    // account to have been refreshed in the same transaction.
+    // IMPORTANT: The operation reserve's refreshReserve MUST be the last one
+    // pushed (position -3 from the sync tx) because check_refresh looks for it there.
+    const obligationState = await accounts_1.Obligation.fetch(connection, obligation);
+    const otherReservePubkeys = [];
+    if (obligationState) {
+        for (const d of obligationState.deposits) {
+            if (!d.depositReserve.equals(defaultKey) && !d.depositReserve.equals(reservePubkey)) {
+                otherReservePubkeys.push(d.depositReserve);
+            }
+        }
+        for (const b of obligationState.borrows) {
+            if (!b.borrowReserve.equals(defaultKey) && !b.borrowReserve.equals(reservePubkey)) {
+                otherReservePubkeys.push(b.borrowReserve);
+            }
+        }
+    }
+    // Fetch all other reserve accounts (needed for refreshReserve and optionally Scope refresh)
+    const otherReserves = [];
+    for (const rPubkey of otherReservePubkeys) {
+        const rAccount = await kamino_reserve_deserializer_1.Reserve.fetch(connection, rPubkey);
+        if (!rAccount)
+            continue;
+        otherReserves.push({ pubkey: rPubkey, account: rAccount });
+    }
+    // Scope refreshPriceList — only needed for operations that check ALL_CHECKS
+    // (borrow/withdraw). Must be the FIRST instructions in the transaction
+    // (after ComputeBudget) because the Scope program validates ordering.
+    const allReserves = [...otherReserves, { pubkey: reservePubkey, account: reserveAccount }];
+    const scopeRefreshIxs = needsScopeRefresh
+        ? await (0, scope_refresh_1.buildScopeRefreshInstructions)(connection, allReserves)
+        : [];
+    // Refresh other reserves first (order doesn't matter for these)
+    for (const { pubkey: rPubkey, account: rAccount } of otherReserves) {
+        const ti = rAccount.config.tokenInfo;
+        pre.push((0, instructions_1.refreshReserve)({
+            reserve: rPubkey,
+            lendingMarket,
+            pythOracle: oracleOrSentinel(ti.pythConfiguration.price),
+            switchboardPriceOracle: oracleOrSentinel(ti.switchboardConfiguration.priceAggregator),
+            switchboardTwapOracle: oracleOrSentinel(ti.switchboardConfiguration.twapAggregator),
+            scopePrices: oracleOrSentinel(ti.scopeConfiguration.priceFeed),
+        }));
+    }
+    // Refresh the operation reserve LAST — must be at position -3 from the sync tx
+    const ti = reserveAccount.config.tokenInfo;
+    pre.push((0, instructions_1.refreshReserve)({
+        reserve: reservePubkey,
+        lendingMarket,
+        pythOracle: oracleOrSentinel(ti.pythConfiguration.price),
+        switchboardPriceOracle: oracleOrSentinel(ti.switchboardConfiguration.priceAggregator),
+        switchboardTwapOracle: oracleOrSentinel(ti.switchboardConfiguration.twapAggregator),
+        scopePrices: oracleOrSentinel(ti.scopeConfiguration.priceFeed),
+    }));
+    // 3. RefreshObligation — pass all active reserves as remaining accounts.
+    const refreshObligationIx = (0, instructions_1.refreshObligation)({ lendingMarket, obligation });
+    if (obligationState) {
+        const depositReserves = obligationState.deposits
+            .map(d => d.depositReserve)
+            .filter(r => !r.equals(defaultKey));
+        const borrowReserves = obligationState.borrows
+            .map(b => b.borrowReserve)
+            .filter(r => !r.equals(defaultKey));
+        for (const reserve of [...depositReserves, ...borrowReserves]) {
+            refreshObligationIx.keys.push({ pubkey: reserve, isSigner: false, isWritable: false });
+        }
+    }
+    pre.push(refreshObligationIx);
+    return {
+        scopeRefreshInstructions: scopeRefreshIxs,
+        preInstructions: pre,
+        postInstructions: post,
+        farmsAccounts,
+    };
+}
+// ============================================================================
+// Orderbook Action Builders
+// ============================================================================
+/**
+ * Builder for Exponent Orderbook vault action descriptors.
+ *
+ * Each method returns an `OrderbookInstruction` that describes what to do.
+ * Pass these to `createVaultSyncTransaction` which resolves them into
+ * raw Solana instructions and wraps them in a Squads sync transaction.
+ *
+ * @example
+ * ```ts
+ * import { orderbookAction, createVaultSyncTransaction, OrderbookTradeDirection } from "@exponent-labs/exponent-sdk"
+ *
+ * const { instruction, preInstructions } = await createVaultSyncTransaction({
+ *   instructions: [
+ *     orderbookAction.postOffer({
+ *       orderbook: ORDERBOOK_ADDRESS,
+ *       direction: OrderbookTradeDirection.BUY_PT,
+ *       priceApy: 0.10,
+ *       amount: 1_000_000n,
+ *     }),
+ *   ],
+ *   owner: squadsVault,
+ *   connection,
+ *   policyPda,
+ *   vaultPda: squadsVault,
+ *   signer: walletPublicKey,
+ * })
+ * ```
+ */
+exports.orderbookAction = {
+    /**
+     * Post a limit order on the orderbook.
+     * @param params - Order parameters
+     * @param params.offerIdx - Required offer index for position tracking. Must be unique per trader.
+     */
+    postOffer(params) {
+        return {
+            action: OrderbookAction.POST_OFFER,
+            orderbook: params.orderbook,
+            mode: params.mode,
+            direction: params.direction,
+            priceApy: params.priceApy,
+            amount: params.amount,
+            offerIdx: params.offerIdx,
+            offerOption: params.offerOption,
+            virtualOffer: params.virtualOffer,
+            expirySeconds: params.expirySeconds,
+        };
+    },
+    /**
+     * Execute a market order on the orderbook.
+     * @param params - Order parameters
+     */
+    marketOffer(params) {
+        return {
+            action: OrderbookAction.MARKET_OFFER,
+            orderbook: params.orderbook,
+            mode: params.mode,
+            direction: params.direction,
+            maxPriceApy: params.maxPriceApy,
+            amount: params.amount,
+            minAmountOut: params.minAmountOut,
+            virtualOffer: params.virtualOffer,
+        };
+    },
+    /**
+     * Cancel an existing limit order.
+     * @param params - Cancel parameters
+     */
+    removeOffer(params) {
+        return {
+            action: OrderbookAction.REMOVE_OFFER,
+            orderbook: params.orderbook,
+            offerIdx: params.offerIdx,
+        };
+    },
+    /**
+     * Withdraw funds from user escrow to token accounts.
+     * @param params - Withdraw parameters (null amounts = withdraw max)
+     */
+    withdrawFunds(params) {
+        return {
+            action: OrderbookAction.WITHDRAW_FUNDS,
+            orderbook: params.orderbook,
+            ptAmount: params.ptAmount,
+            ytAmount: params.ytAmount,
+            syAmount: params.syAmount,
+        };
+    },
+};
+exports.syAction = {
+    mint(params) {
+        return {
+            action: SyAction.MINT,
+            vault: params.vault,
+            amountBase: params.amountBase,
+        };
+    },
+    redeem(params) {
+        return {
+            action: SyAction.REDEEM,
+            vault: params.vault,
+            amountSy: params.amountSy,
+        };
+    },
+};
+// ============================================================================
+// Core Action Builders (Strip/Merge)
+// ============================================================================
+/**
+ * Builder for Exponent Core strip/merge action descriptors.
+ *
+ * Each method returns a `CoreInstruction` that describes what to do.
+ * Pass these to `createVaultSyncTransaction` which resolves them into
+ * raw Solana instructions and wraps them in a Squads sync transaction.
+ *
+ * @example
+ * ```ts
+ * import { coreAction, createVaultSyncTransaction } from "@exponent-labs/exponent-sdk"
+ *
+ * const { instruction, preInstructions } = await createVaultSyncTransaction({
+ *   instructions: [
+ *     coreAction.strip({
+ *       vault: VAULT_ADDRESS,
+ *       amountBase: 1_000_000_000n, // 1 SOL worth
+ *     }),
+ *   ],
+ *   owner: squadsVault,
+ *   connection,
+ *   policyPda,
+ *   vaultPda: squadsVault,
+ *   signer: walletPublicKey,
+ * })
+ * ```
+ */
+exports.coreAction = {
+    /**
+     * Strip LST (base token) into PT + YT.
+     * @param params - Strip parameters
+     */
+    strip(params) {
+        return {
+            action: CoreAction.STRIP,
+            vault: params.vault,
+            amountBase: params.amountBase,
+        };
+    },
+    /**
+     * Merge PT + YT into LST (base token).
+     * Requires equal amounts of PT and YT.
+     * @param params - Merge parameters
+     */
+    merge(params) {
+        return {
+            action: CoreAction.MERGE,
+            vault: params.vault,
+            amountPy: params.amountPy,
+        };
+    },
+    /**
+     * Withdraw YT from the tracked yield position into the owner's YT token account.
+     * Useful before wrapper_merge, which consumes YT from the token account.
+     */
+    withdrawYt(params) {
+        return {
+            action: CoreAction.WITHDRAW_YT,
+            vault: params.vault,
+            amountYt: params.amountYt,
+        };
+    },
+    /**
+     * Deposit YT from the owner's YT token account back into the tracked yield position.
+     * Use this to ensure idle YT continues earning yield.
+     */
+    depositYt(params) {
+        return {
+            action: CoreAction.DEPOSIT_YT,
+            vault: params.vault,
+            amountYt: params.amountYt,
+        };
+    },
+    /**
+     * Initialize yield position for the Squads vault (owner).
+     * Required before buying YT or depositing YT.
+     */
+    initializeYieldPosition(params) {
+        return {
+            action: CoreAction.INITIALIZE_YIELD_POSITION,
+            vault: params.vault,
+        };
+    },
+};
+/**
+ * Convert trade direction to OfferType used by the orderbook program.
+ */
+function directionToOfferType(direction) {
+    switch (direction) {
+        case OrderbookTradeDirection.BUY_PT:
+        case OrderbookTradeDirection.SELL_YT:
+            return orderbook_2.OfferType.SellYt;
+        case OrderbookTradeDirection.SELL_PT:
+        case OrderbookTradeDirection.BUY_YT:
+            return orderbook_2.OfferType.BuyYt;
+    }
+}
+/**
+ * Build orderbook instructions and wrap them in a Squads sync transaction.
+ *
+ * Takes high-level `OrderbookInstruction` descriptors (built with `orderbookAction.*`),
+ * loads the orderbook SDK, resolves them to raw Solana instructions, and wraps them
+ * in a Squads sync transaction.
+ *
+ * @returns `{ setupInstructions, preInstructions, instruction, postInstructions }` — include all in your transaction
+ *
+ * @example
+ * ```ts
+ * const { setupInstructions, preInstructions, instruction, postInstructions } = await createOrderbookSyncTransaction({
+ *   instructions: [
+ *     orderbookAction.postOffer({
+ *       orderbook: ORDERBOOK_ADDRESS,
+ *       direction: OrderbookTradeDirection.BUY_PT,
+ *       priceApy: 0.10,
+ *       amount: 1_000_000n,
+ *     }),
+ *   ],
+ *   owner: squadsVault,
+ *   connection,
+ *   policyPda,
+ *   vaultPda: squadsVault,
+ *   signer: wallet.publicKey,
+ *   vaultAddress: VAULT_ADDRESS,
+ * })
+ * // Send: [...setupInstructions, ...preInstructions, instruction, ...postInstructions]
+ * ```
+ */
+async function createOrderbookSyncTransaction({ instructions, owner, connection, policyPda, vaultPda, signer, accountIndex = 0, constraintIndices, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram = syncTransaction_1.SQUADS_PROGRAM_ID, env = environment_1.LOCAL_ENV, }) {
+    const { setupInstructions, syncInstructions, preInstructions, postInstructions, signers, addressLookupTableAddresses } = await buildOrderbookInstructions(instructions, owner, connection, signer, policyPda, vaultPda, accountIndex, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram, env);
+    let resolvedPolicyPda = policyPda;
+    let resolvedConstraintIndices = constraintIndices;
+    if (!resolvedPolicyPda) {
+        if (!vaultAddress) {
+            throw new Error("vaultAddress is required when policyPda is not provided");
+        }
+        const match = await (0, policyMatcher_1.resolvePolicyMatchForVault)(connection, vaultAddress, signer, syncInstructions);
+        resolvedPolicyPda = match.policyPda;
+        resolvedConstraintIndices ??= match.constraintIndices;
+    }
+    // Auto-resolve constraint indices when not explicitly provided
+    resolvedConstraintIndices ??= await (0, policyMatcher_1.resolveConstraintIndices)(connection, resolvedPolicyPda, syncInstructions);
+    // Auto-resolve policy prefix and hook accounts when not explicitly provided
+    let resolvedLeadingAccounts = leadingAccounts;
+    let resolvedPreHookAccounts = preHookAccounts;
+    let resolvedPostHookAccounts = postHookAccounts;
+    if (vaultAddress && (!leadingAccounts || !preHookAccounts || !postHookAccounts)) {
+        const hooks = await (0, policyMatcher_1.resolveHookAccounts)(connection, resolvedPolicyPda, vaultAddress, signer);
+        resolvedLeadingAccounts ??= hooks.leadingAccounts;
+        resolvedPreHookAccounts ??= hooks.preHookAccounts;
+        resolvedPostHookAccounts ??= hooks.postHookAccounts;
+    }
+    const instruction = (0, syncTransaction_1.wrapInstructionsInSyncTransaction)({
+        policyPda: resolvedPolicyPda,
+        vaultPda,
+        signer,
+        instructions: syncInstructions,
+        squadsProgram,
+        accountIndex,
+        constraintIndices: resolvedConstraintIndices,
+        leadingAccounts: resolvedLeadingAccounts,
+        preHookAccounts: resolvedPreHookAccounts,
+        postHookAccounts: resolvedPostHookAccounts,
+    });
+    return { setupInstructions, preInstructions, instruction, postInstructions, signers, addressLookupTableAddresses };
+}
+exports.createOrderbookSyncTransaction = createOrderbookSyncTransaction;
+/** Cache for loaded orderbooks to avoid redundant fetches */
+const orderbookCache = new Map();
+/**
+ * Build raw Solana instructions from orderbook action descriptors.
+ */
+async function buildOrderbookInstructions(instructions, owner, connection, signer, policyPda, vaultPda, accountIndex, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram, env) {
+    const buckets = {
+        setupInstructions: [],
+        syncInstructions: [],
+        preInstructions: [],
+        postInstructions: [],
+        signers: [],
+        addressLookupTableAddresses: [],
+    };
+    const setupContext = createStrategySetupContext({
+        connection,
+        env,
+        owner,
+        signer,
+        vaultAddress,
+        policyPda,
+        vaultPda,
+        accountIndex,
+        squadsProgram,
+        leadingAccounts,
+        preHookAccounts,
+        postHookAccounts,
+    });
+    for (const ix of instructions) {
+        await buildOrderbookInstruction(ix, owner, connection, buckets, setupContext, env);
+    }
+    return buckets;
+}
+async function buildPostOffer(ix, orderbook, owner, setupPayer, buckets, setupContext) {
+    const offerType = directionToOfferType(ix.direction);
+    const option = ix.offerOption ?? "FillOrKill";
+    if (setupContext) {
+        await ensureOrderbookPositionSetup(orderbook, buckets, setupContext);
+        await ensureTrackedTokenAccountSetup({
+            tokenMint: orderbook.vault.mintSy,
+            tokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(orderbook.vault.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            buckets,
+            setupContext,
+        });
+        await ensureTrackedTokenAccountSetup({
+            tokenMint: orderbook.mintPt,
+            tokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(orderbook.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            buckets,
+            setupContext,
+        });
+        await ensureTrackedTokenAccountSetup({
+            tokenMint: orderbook.mintYt,
+            tokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(orderbook.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            buckets,
+            setupContext,
+        });
+        await ensureYieldPositionSetup(orderbook.vault, buckets, setupContext);
+    }
+    if (ix.mode === "raw") {
+        buckets.syncInstructions.push(orderbook.ixPostOffer({
+            trader: owner,
+            price: ix.priceApy,
+            amount: ix.amount,
+            offerType,
+            offerOption: (0, orderbook_2.offerOptions)(option, [false]),
+            virtualOffer: ix.virtualOffer ?? false,
+            expirySeconds: ix.expirySeconds ?? 3600,
+            mintSy: orderbook.vault.mintSy,
+            offerIdx: ix.offerIdx,
+        }));
+        return;
+    }
+    const { ix: postOfferIx, setupIxs } = await orderbook.ixWrapperPostOffer({
+        trader: owner,
+        setupPayer,
+        price: ix.priceApy,
+        amount: ix.amount,
+        offerType,
+        offerOption: (0, orderbook_2.offerOptions)(option, [false]),
+        virtualOffer: ix.virtualOffer ?? false,
+        expirySeconds: ix.expirySeconds ?? 3600,
+        mintSy: orderbook.vault.mintSy,
+        offerIdx: ix.offerIdx,
+    });
+    buckets.preInstructions.push(...setupIxs);
+    buckets.syncInstructions.push(postOfferIx);
+}
+async function buildMarketOffer(ix, orderbook, owner, setupPayer, buckets, setupContext) {
+    const offerType = directionToOfferType(ix.direction);
+    if (setupContext) {
+        await ensureOrderbookPositionSetup(orderbook, buckets, setupContext);
+        await ensureTrackedTokenAccountSetup({
+            tokenMint: orderbook.vault.mintSy,
+            tokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(orderbook.vault.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            buckets,
+            setupContext,
+        });
+        await ensureTrackedTokenAccountSetup({
+            tokenMint: orderbook.mintPt,
+            tokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(orderbook.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            buckets,
+            setupContext,
+        });
+        await ensureTrackedTokenAccountSetup({
+            tokenMint: orderbook.mintYt,
+            tokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(orderbook.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            buckets,
+            setupContext,
+        });
+        await ensureYieldPositionSetup(orderbook.vault, buckets, setupContext);
+    }
+    if (ix.mode === "raw") {
+        buckets.syncInstructions.push(orderbook.ixMarketOffer({
+            trader: owner,
+            maxPriceApy: ix.maxPriceApy,
+            amount: ix.amount,
+            minAmountOut: ix.minAmountOut,
+            offerType,
+            virtualOffer: ix.virtualOffer ?? false,
+            mintSy: orderbook.vault.mintSy,
+        }));
+        return;
+    }
+    const { ix: marketOfferIx, setupIxs } = await orderbook.ixWrapperMarketOffer({
+        trader: owner,
+        setupPayer,
+        maxPriceApy: ix.maxPriceApy,
+        amount: ix.amount,
+        offerType,
+        minAmountOut: ix.minAmountOut,
+        virtualOffer: ix.virtualOffer ?? false,
+        mintSy: orderbook.vault.mintSy,
+    });
+    buckets.preInstructions.push(...setupIxs);
+    buckets.syncInstructions.push(marketOfferIx);
+}
+async function buildRemoveOffer(ix, orderbook, owner, { syncInstructions }) {
+    const removeOfferIx = await orderbook.ixWrapperRemoveOffer({
+        trader: owner,
+        offerIdx: ix.offerIdx,
+        mintSy: orderbook.vault.mintSy,
+    });
+    syncInstructions.push(removeOfferIx);
+}
+async function buildWithdrawFunds(ix, orderbook, owner, { syncInstructions }) {
+    // Convert bigint | null | undefined to Amount type
+    const toAmount = (value) => {
+        if (value === null || value === undefined) {
+            return (0, orderbook_2.amount)("All");
+        }
+        return (0, orderbook_2.amount)("Some", [value]);
+    };
+    const withdrawFundsIx = await orderbook.ixWrapperWithdrawFunds({
+        trader: owner,
+        mintSy: orderbook.vault.mintSy,
+        ptAmount: toAmount(ix.ptAmount),
+        ytAmount: toAmount(ix.ytAmount),
+        syAmount: toAmount(ix.syAmount),
+    });
+    syncInstructions.push(withdrawFundsIx);
+}
+// ============================================================================
+// Core Instruction Builders (Strip/Merge)
+// ============================================================================
+/** Build a single core instruction (strip/merge) */
+async function buildCoreInstruction(ix, owner, connection, buckets, setupContext) {
+    const cacheKey = ix.vault.toBase58();
+    let vault = vaultCache.get(cacheKey);
+    if (!vault) {
+        vault = await vault_1.Vault.load(environment_1.LOCAL_ENV, connection, ix.vault);
+        vaultCache.set(cacheKey, vault);
+    }
+    const isInitializeYieldPosition = ix.action === CoreAction.INITIALIZE_YIELD_POSITION;
+    if (setupContext && !isInitializeYieldPosition) {
+        await ensureTrackedTokenAccountSetup({
+            tokenMint: vault.mintPt,
+            tokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(vault.mintPt, setupContext.owner, true, spl_token_1.TOKEN_PROGRAM_ID),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            buckets,
+            setupContext,
+        });
+        await ensureYieldPositionSetup(vault, buckets, setupContext);
+        if (ix.action === CoreAction.WITHDRAW_YT) {
+            await ensureTrackedTokenAccountSetup({
+                tokenMint: vault.mintYt,
+                tokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(vault.mintYt, setupContext.owner, true, spl_token_1.TOKEN_PROGRAM_ID),
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                buckets,
+                setupContext,
+            });
+        }
+    }
+    switch (ix.action) {
+        case CoreAction.STRIP:
+            await buildStrip(ix, vault, owner, setupContext?.signer ?? owner, buckets);
+            break;
+        case CoreAction.MERGE:
+            await buildMerge(ix, vault, owner, setupContext?.signer ?? owner, buckets);
+            break;
+        case CoreAction.WITHDRAW_YT:
+            await buildWithdrawYt(ix, vault, owner, setupContext?.signer ?? owner, buckets);
+            break;
+        case CoreAction.DEPOSIT_YT:
+            await buildDepositYt(ix, vault, owner, buckets);
+            break;
+        case CoreAction.INITIALIZE_YIELD_POSITION:
+            await buildInitializeYieldPosition(ix, vault, owner, buckets);
+            break;
+    }
+}
+async function buildInitializeYieldPosition(ix, vault, owner, { syncInstructions }) {
+    const initIx = vault.ixInitializeYieldPosition({ owner });
+    syncInstructions.push(initIx);
+}
+async function buildStrip(ix, vault, owner, payer, { syncInstructions, preInstructions }) {
+    const sySrc = (0, spl_token_1.getAssociatedTokenAddressSync)(vault.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+    const ptDst = (0, spl_token_1.getAssociatedTokenAddressSync)(vault.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+    const ytDst = (0, spl_token_1.getAssociatedTokenAddressSync)(vault.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+    preInstructions.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(payer, sySrc, owner, vault.mintSy), (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(payer, ptDst, owner, vault.mintPt), (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(payer, ytDst, owner, vault.mintYt));
+    const stripIx = await vault.ixStripFromBase({
+        owner,
+        amountBase: ix.amountBase,
+        sySrc,
+        ptDst,
+        ytDst,
+    });
+    // Strip instruction needs vault signature
+    syncInstructions.push(stripIx);
+}
+async function buildMerge(ix, vault, owner, payer, { syncInstructions, preInstructions }) {
+    const { ixs, setupIxs } = await vault.ixMergeToBase({
+        owner,
+        payer,
+        amountPy: ix.amountPy,
+    });
+    // Setup instructions (ATA creation) go in preInstructions
+    preInstructions.push(...setupIxs);
+    // Merge instructions need vault signature
+    syncInstructions.push(...ixs);
+}
+async function buildWithdrawYt(ix, vault, owner, payer, { syncInstructions, preInstructions }) {
+    const ytDst = (0, spl_token_1.getAssociatedTokenAddressSync)(vault.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+    preInstructions.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(payer, ytDst, owner, vault.mintYt));
+    const ytPosition = await ytPosition_1.YtPosition.loadByOwner(environment_1.LOCAL_ENV, vault.connection, owner, vault);
+    syncInstructions.push(ytPosition.ixWithdrawYt({
+        amount: ix.amountYt,
+        ytDst,
+    }));
+}
+async function buildDepositYt(ix, vault, owner, { syncInstructions }) {
+    const ytSrc = (0, spl_token_1.getAssociatedTokenAddressSync)(vault.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+    const ytPosition = await ytPosition_1.YtPosition.loadByOwner(environment_1.LOCAL_ENV, vault.connection, owner, vault);
+    syncInstructions.push(ytPosition.ixDepositYt({
+        amount: ix.amountYt,
+        ytSrc,
+    }));
+}
+async function buildSyInstruction(ix, owner, connection, buckets, setupContext) {
+    const cacheKey = ix.vault.toBase58();
+    let vault = vaultCache.get(cacheKey);
+    if (!vault) {
+        vault = await vault_1.Vault.load(environment_1.LOCAL_ENV, connection, ix.vault);
+        vaultCache.set(cacheKey, vault);
+    }
+    if (!setupContext) {
+        throw new Error("SY actions require a strategy setup context");
+    }
+    const setupState = await loadStrategySetupState(setupContext);
+    if (!setupState) {
+        throw new Error("SY actions require a strategy vault context");
+    }
+    const trackedBaseTokenAccount = setupState.tokenEntryAccountByMint.get(vault.flavor.mintBase.toBase58());
+    const baseTokenAccount = trackedBaseTokenAccount
+        ? new web3_js_1.PublicKey(trackedBaseTokenAccount)
+        : (0, spl_token_1.getAssociatedTokenAddressSync)(vault.flavor.mintBase, owner, true, vault.flavor.baseTokenProgram);
+    const syTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(vault.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+    await ensureTrackedTokenAccountSetup({
+        tokenMint: vault.mintSy,
+        tokenAccount: syTokenAccount,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        buckets,
+        setupContext,
+    });
+    if (!setupState.trackedTokenAccounts.has(baseTokenAccount.toBase58())) {
+        throw new Error(`Base mint ${vault.flavor.mintBase.toBase58()} must be tracked on the strategy vault before using mint_sy/redeem_sy`);
+    }
+    switch (ix.action) {
+        case SyAction.MINT:
+            buckets.syncInstructions.push(await vault.flavor.ixMintSy({
+                amountBase: ix.amountBase.toString(),
+                depositor: owner,
+                depositorBaseTokenAccount: baseTokenAccount,
+                depositorSyTokenAccount: syTokenAccount,
+            }));
+            break;
+        case SyAction.REDEEM:
+            buckets.syncInstructions.push(await vault.flavor.ixRedeemSy({
+                amountSy: ix.amountSy.toString(),
+                redeemer: owner,
+                redeemerBaseTokenAccount: baseTokenAccount,
+                redeemerSyTokenAccount: syTokenAccount,
+            }));
+            break;
+    }
+}
+/**
+ * Builder for Titan swap vault action descriptors.
+ *
+ * Since Titan swap instructions contain complex routing data from Titan's API,
+ * you pass a pre-built `TransactionInstruction` and we wrap it in a sync transaction.
+ *
+ * @example
+ * ```ts
+ * import { titanAction, createVaultSyncTransaction } from "@exponent-labs/exponent-sdk"
+ *
+ * const { setupInstructions, instruction } = await createVaultSyncTransaction({
+ *   instructions: [titanAction.swap({ instruction: titanSwapIx })],
+ *   owner: squadsVault,
+ *   connection,
+ *   policyPda,
+ *   vaultPda: squadsVault,
+ *   signer: wallet.publicKey,
+ *   vaultAddress: VAULT_ADDRESS,
+ * })
+ * ```
+ */
+exports.titanAction = {
+    /**
+     * Wrap a Titan SwapRouteV2 instruction for vault execution.
+     * @param params.instruction - Pre-built TransactionInstruction from Titan's router API
+     */
+    swap(params) {
+        return { action: TitanAction.SWAP, instruction: params.instruction };
+    },
+};
+// ============================================================================
+// Loopscale Action Builder
+// ============================================================================
+/**
+ * Builder for Loopscale vault action descriptors.
+ *
+ * Loans (BORROWER side): create/close loan, deposit/withdraw collateral, borrow/repay principal.
+ * Strategies (LENDER side): create/close strategy, deposit/withdraw into strategy.
+ *
+ * Since Loopscale instructions come from the Loopscale API (which also
+ * handles `bs_auth` co-signing), you pass pre-built `TransactionInstruction`s
+ * and we wrap them in a sync transaction.
+ *
+ * @example
+ * ```ts
+ * import { loopscaleAction, createVaultSyncTransaction } from "@exponent-labs/exponent-sdk"
+ *
+ * const { instruction } = await createVaultSyncTransaction({
+ *   instructions: [
+ *     loopscaleAction.createLoan({ instruction: createLoanIx }),
+ *     loopscaleAction.depositCollateral({ instruction: depositIx }),
+ *     loopscaleAction.borrowPrincipal({ instruction: borrowIx }),
+ *   ],
+ *   owner: squadsSettings,
+ *   connection,
+ *   policyPda,
+ *   vaultPda: squadsVault,
+ *   signer: wallet.publicKey,
+ *   vaultAddress,
+ * })
+ * ```
+ */
+exports.loopscaleAction = {
+    createLoan(params) {
+        return { action: LoopscaleAction.CREATE_LOAN, instruction: params.instruction };
+    },
+    depositCollateral(params) {
+        return { action: LoopscaleAction.DEPOSIT_COLLATERAL, instruction: params.instruction };
+    },
+    borrowPrincipal(params) {
+        return { action: LoopscaleAction.BORROW_PRINCIPAL, instruction: params.instruction };
+    },
+    repayPrincipal(params) {
+        return { action: LoopscaleAction.REPAY_PRINCIPAL, instruction: params.instruction };
+    },
+    withdrawCollateral(params) {
+        return { action: LoopscaleAction.WITHDRAW_COLLATERAL, instruction: params.instruction };
+    },
+    closeLoan(params) {
+        return { action: LoopscaleAction.CLOSE_LOAN, instruction: params.instruction };
+    },
+    /** Assign collateral fractions to ledgers (BORROWER side). Must call before borrow_principal. */
+    updateWeightMatrix(params) {
+        return { action: LoopscaleAction.UPDATE_WEIGHT_MATRIX, instruction: params.instruction };
+    },
+    createStrategy(params) {
+        return { action: LoopscaleAction.CREATE_STRATEGY, instruction: params.instruction };
+    },
+    depositStrategy(params) {
+        return { action: LoopscaleAction.DEPOSIT_STRATEGY, instruction: params.instruction };
+    },
+    withdrawStrategy(params) {
+        return { action: LoopscaleAction.WITHDRAW_STRATEGY, instruction: params.instruction };
+    },
+    closeStrategy(params) {
+        return { action: LoopscaleAction.CLOSE_STRATEGY, instruction: params.instruction };
+    },
+    /** Configure collateral terms on a strategy (LENDER side). */
+    updateStrategy(params) {
+        return { action: LoopscaleAction.UPDATE_STRATEGY, instruction: params.instruction };
+    },
+    /** Lock loan before borrow_principal (BORROWER side). Must be in same tx as unlock. */
+    lockLoan(params) {
+        return { action: LoopscaleAction.LOCK_LOAN, instruction: params.instruction };
+    },
+    /** Unlock loan after borrow_principal (BORROWER side). Runs health check. */
+    unlockLoan(params) {
+        return { action: LoopscaleAction.UNLOCK_LOAN, instruction: params.instruction };
+    },
+    /** Refinance a loan ledger from one strategy to another (BORROWER side). */
+    refinanceLedger(params) {
+        return { action: LoopscaleAction.REFINANCE_LEDGER, instruction: params.instruction };
+    },
+};
+// ============================================================================
+// CLMM Action Builder
+// ============================================================================
+/**
+ * Builder for Exponent CLMM vault action descriptors.
+ *
+ * Each method returns a `VaultInstruction` descriptor. Pass these to
+ * `createVaultSyncTransaction` which resolves them into raw Solana
+ * instructions, wraps them in a Squads sync transaction, and returns
+ * any extra signers (e.g., the new LP position keypair from deposit).
+ *
+ * @example
+ * ```ts
+ * import { clmmAction, createVaultSyncTransaction } from "@exponent-labs/exponent-sdk"
+ *
+ * const result = await createVaultSyncTransaction({
+ *   instructions: [
+ *     clmmAction.depositLiquidity({
+ *       market: CLMM_MARKET,
+ *       ptInIntent: 1_000_000n,
+ *       syInIntent: 1_000_000n,
+ *       lowerTickKey: 500,
+ *       upperTickKey: 1500,
+ *     }),
+ *   ],
+ *   owner: squadsVault,
+ *   connection,
+ *   vaultPda: squadsVault,
+ *   signer: wallet.publicKey,
+ *   vaultAddress: VAULT_ADDRESS,
+ * })
+ * // result.signers contains the generated LP position keypair
+ * ```
+ */
+exports.clmmAction = {
+    /**
+     * Create a new LP position on the CLMM with a specified tick range.
+     * The LP position keypair is generated internally — retrieve it from
+     * `result.signers[0]` after calling `createVaultSyncTransaction`.
+     *
+     * @param params.market - CLMM MarketThree account address
+     * @param params.ptInIntent - Maximum PT to deposit
+     * @param params.syInIntent - Maximum SY to deposit
+     * @param params.lowerTickKey - Lower tick boundary (APY value)
+     * @param params.upperTickKey - Upper tick boundary (APY value)
+     */
+    depositLiquidity(params) {
+        return { action: ClmmAction.DEPOSIT_LIQUIDITY, ...params };
+    },
+    /**
+     * Add liquidity to an existing LP position.
+     *
+     * @param params.market - CLMM MarketThree account address
+     * @param params.lpPosition - Existing LpPosition account public key
+     * @param params.ptInIntent - Maximum PT to add
+     * @param params.syInIntent - Maximum SY to add
+     */
+    addLiquidity(params) {
+        return { action: ClmmAction.ADD_LIQUIDITY, ...params };
+    },
+    /**
+     * Withdraw liquidity from an LP position, receiving PT + SY.
+     *
+     * @param params.market - CLMM MarketThree account address
+     * @param params.lpPosition - LpPosition account to withdraw from
+     * @param params.lpIn - Amount of liquidity (LP units) to remove
+     * @param params.minPtOut - Minimum PT to receive (slippage protection)
+     * @param params.minSyOut - Minimum SY to receive (slippage protection)
+     */
+    withdrawLiquidity(params) {
+        return { action: ClmmAction.WITHDRAW_LIQUIDITY, ...params };
+    },
+    /**
+     * Low-level PT/SY swap on the CLMM. Prefer {@link buyPt} / {@link sellPt}
+     * for directional trades.
+     *
+     * @param params.market - CLMM MarketThree account address
+     * @param params.traderAmount - Amount of the input token
+     * @param params.outConstraint - Minimum output amount (slippage protection)
+     * @param params.swapDirection - `SwapDirection.SyToPt` or `SwapDirection.PtToSy`
+     * @param params.lnImpliedApyLimit - Optional price limit (ln implied APY)
+     */
+    tradePt(params) {
+        return { action: ClmmAction.TRADE_PT, ...params };
+    },
+    /**
+     * Buy PT with SY on the CLMM.
+     *
+     * @param params.market - CLMM MarketThree account address
+     * @param params.amountSy - Amount of SY to spend
+     * @param params.outConstraint - Minimum PT to receive (slippage protection)
+     * @param params.lnImpliedApyLimit - Optional price limit (ln implied APY)
+     */
+    buyPt(params) {
+        return { action: ClmmAction.BUY_PT, ...params };
+    },
+    /**
+     * Sell PT for SY on the CLMM.
+     *
+     * @param params.market - CLMM MarketThree account address
+     * @param params.amountPt - Amount of PT to sell
+     * @param params.outConstraint - Minimum SY to receive (slippage protection)
+     * @param params.lnImpliedApyLimit - Optional price limit (ln implied APY)
+     */
+    sellPt(params) {
+        return { action: ClmmAction.SELL_PT, ...params };
+    },
+    /**
+     * Buy YT with SY on the CLMM.
+     *
+     * @param params.market - CLMM MarketThree account address
+     * @param params.ytOut - Minimum YT to receive
+     * @param params.maxSyIn - Maximum SY to spend
+     * @param params.lnImpliedApyLimit - Optional price limit (ln implied APY)
+     */
+    buyYt(params) {
+        return { action: ClmmAction.BUY_YT, ...params };
+    },
+    /**
+     * Sell YT for SY on the CLMM.
+     *
+     * @param params.market - CLMM MarketThree account address
+     * @param params.ytIn - Amount of YT to sell
+     * @param params.minSyOut - Minimum SY to receive (slippage protection)
+     * @param params.lnImpliedApyLimit - Optional price limit (ln implied APY)
+     */
+    sellYt(params) {
+        return { action: ClmmAction.SELL_YT, ...params };
+    },
+    /**
+     * Claim farm emissions from an LP position.
+     *
+     * @param params.market - CLMM MarketThree account address
+     * @param params.lpPosition - LpPosition account to claim from
+     * @param params.farmIndex - Index of the farm emission to claim
+     */
+    claimFarmEmission(params) {
+        return { action: ClmmAction.CLAIM_FARM_EMISSION, ...params };
+    },
+};
+// ============================================================================
+// Internal: CLMM Instruction Resolution
+// ============================================================================
+/** Cache for loaded MarketThree instances to avoid redundant fetches. */
+const marketThreeCache = new Map();
+/**
+ * Resolve a high-level CLMM action descriptor into raw Solana instructions.
+ * Loads the MarketThree from cache, derives token accounts from the vault
+ * owner, and delegates to the appropriate sub-builder.
+ */
+async function buildClmmInstruction(ix, owner, connection, buckets, setupContext, env = environment_1.LOCAL_ENV) {
+    const cacheKey = ix.market.toBase58();
+    let market = marketThreeCache.get(cacheKey);
+    if (!market) {
+        market = await marketThree_1.MarketThree.load(env, connection, ix.market);
+        marketThreeCache.set(cacheKey, market);
+    }
+    // Ensure PT and SY token accounts are tracked (needed by all CLMM actions)
+    if (setupContext) {
+        await ensureTrackedTokenAccountSetup({
+            tokenMint: market.mintPt,
+            tokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(market.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            buckets,
+            setupContext,
+        });
+        await ensureTrackedTokenAccountSetup({
+            tokenMint: market.mintSy,
+            tokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(market.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            buckets,
+            setupContext,
+        });
+    }
+    // Include the CLMM market's ALT so callers can compress remaining accounts
+    buckets.addressLookupTableAddresses.push(market.addressLookupTable);
+    switch (ix.action) {
+        case ClmmAction.DEPOSIT_LIQUIDITY:
+            buildClmmDepositLiquidity(ix, market, owner, buckets);
+            break;
+        case ClmmAction.ADD_LIQUIDITY:
+            buildClmmAddLiquidity(ix, market, owner, buckets);
+            break;
+        case ClmmAction.WITHDRAW_LIQUIDITY:
+            buildClmmWithdrawLiquidity(ix, market, owner, buckets);
+            break;
+        case ClmmAction.TRADE_PT:
+            buildClmmTradePt(ix, market, owner, buckets);
+            break;
+        case ClmmAction.BUY_PT:
+            buildClmmBuyPt(ix, market, owner, buckets);
+            break;
+        case ClmmAction.SELL_PT:
+            buildClmmSellPt(ix, market, owner, buckets);
+            break;
+        case ClmmAction.BUY_YT:
+            await buildClmmBuyYt(ix, market, owner, buckets, setupContext);
+            break;
+        case ClmmAction.SELL_YT:
+            await buildClmmSellYt(ix, market, owner, buckets, setupContext);
+            break;
+        case ClmmAction.CLAIM_FARM_EMISSION:
+            buildClmmClaimFarmEmission(ix, market, owner, buckets);
+            break;
+    }
+}
+/**
+ * Create a new LP position. Generates the keypair internally and adds it
+ * to `buckets.signers` so consumers can include it in the transaction.
+ */
+function buildClmmDepositLiquidity(ix, market, owner, buckets) {
+    const ptSrc = (0, spl_token_1.getAssociatedTokenAddressSync)(market.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+    const sySrc = (0, spl_token_1.getAssociatedTokenAddressSync)(market.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+    const { ix: depositIx, signers: lpPositionKeypair } = market.ixDepositLiquidity({
+        depositor: owner,
+        ptInIntent: ix.ptInIntent,
+        syInIntent: ix.syInIntent,
+        lowerTickKey: ix.lowerTickKey,
+        upperTickKey: ix.upperTickKey,
+        ptSrc,
+        sySrc,
+    });
+    buckets.syncInstructions.push(depositIx);
+    buckets.signers.push(lpPositionKeypair);
+}
+/** Add liquidity to an existing LP position. */
+function buildClmmAddLiquidity(ix, market, owner, buckets) {
+    const ptSrc = (0, spl_token_1.getAssociatedTokenAddressSync)(market.mintPt, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+    const sySrc = (0, spl_token_1.getAssociatedTokenAddressSync)(market.mintSy, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+    const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+        ...market.cpiSyAccounts.depositSy,
+        ...market.cpiSyAccounts.withdrawSy,
+        ...market.cpiCoreAccounts.stripSy,
+        ...market.cpiSyAccounts.getPositionState,
+    ]);
+    const addLiqIx = exponentClmm.createAddLiquidityInstruction({
+        owner,
+        market: market.selfAddress,
+        ticks: market.ticksKey,
+        lpPosition: ix.lpPosition,
+        tokenPtSrc: ptSrc,
+        tokenSySrc: sySrc,
+        tokenPtEscrow: market.tokenPtEscrow,
+        tokenSyEscrow: market.tokenSyEscrow,
+        addressLookupTable: market.addressLookupTable,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        syProgram: market.syProgram,
+        instructionsSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+        systemProgram: web3_js_1.SystemProgram.programId,
+        rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+        eventAuthority: market.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+    }, {
+        maxSyInToAdd: ix.syInIntent,
+        maxPtInToAdd: ix.ptInIntent,
+        lowerTickKeyOptional: null,
+        upperTickKeyOptional: null,
+    });
+    addLiqIx.keys.push(...remainingAccounts);
+    buckets.syncInstructions.push(addLiqIx);
+}
+/** Remove liquidity from an LP position. */
+function buildClmmWithdrawLiquidity(ix, market, owner, buckets) {
+    const { ixs } = market.ixWithdrawLiquidity({
+        withdrawer: owner,
+        lpPosition: ix.lpPosition,
+        lpIn: ix.lpIn,
+        minPtOut: ix.minPtOut,
+        minSyOut: ix.minSyOut,
+    });
+    buckets.syncInstructions.push(...ixs);
+}
+/** Low-level PT/SY swap. */
+function buildClmmTradePt(ix, market, owner, buckets) {
+    const { ixs } = market.ixTradePt({
+        trader: owner,
+        traderAmount: ix.traderAmount,
+        outConstraint: ix.outConstraint,
+        swapDirection: ix.swapDirection,
+        lnImpliedApyLimit: ix.lnImpliedApyLimit,
+    });
+    buckets.syncInstructions.push(...ixs);
+}
+/** Buy PT with SY. */
+function buildClmmBuyPt(ix, market, owner, buckets) {
+    const { ixs } = market.ixBuyPt({
+        trader: owner,
+        amountSy: ix.amountSy,
+        outConstraint: ix.outConstraint,
+        lnImpliedApyLimit: ix.lnImpliedApyLimit,
+    });
+    buckets.syncInstructions.push(...ixs);
+}
+/** Sell PT for SY. */
+function buildClmmSellPt(ix, market, owner, buckets) {
+    const { ixs } = market.ixSellPt({
+        trader: owner,
+        amountPt: ix.amountPt,
+        outConstraint: ix.outConstraint,
+        lnImpliedApyLimit: ix.lnImpliedApyLimit,
+    });
+    buckets.syncInstructions.push(...ixs);
+}
+/** Buy YT with SY. Also ensures YT token account is tracked. */
+async function buildClmmBuyYt(ix, market, owner, buckets, setupContext) {
+    // YT operations need the YT token account tracked
+    if (setupContext) {
+        await ensureTrackedTokenAccountSetup({
+            tokenMint: market.mintYt,
+            tokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(market.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            buckets,
+            setupContext,
+        });
+    }
+    const { ixs, setupIxs } = market.ixBuyYt({
+        trader: owner,
+        ytOut: ix.ytOut,
+        maxSyIn: ix.maxSyIn,
+        lnImpliedApyLimit: ix.lnImpliedApyLimit,
+    });
+    buckets.setupInstructions.push(...setupIxs);
+    buckets.syncInstructions.push(...ixs);
+}
+/** Sell YT for SY. Also ensures YT token account is tracked. */
+async function buildClmmSellYt(ix, market, owner, buckets, setupContext) {
+    // YT operations need the YT token account tracked
+    if (setupContext) {
+        await ensureTrackedTokenAccountSetup({
+            tokenMint: market.mintYt,
+            tokenAccount: (0, spl_token_1.getAssociatedTokenAddressSync)(market.mintYt, owner, true, spl_token_1.TOKEN_PROGRAM_ID),
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            buckets,
+            setupContext,
+        });
+    }
+    const { ixs, setupIxs } = market.ixSellYt({
+        trader: owner,
+        ytIn: ix.ytIn,
+        minSyOut: ix.minSyOut,
+        lnImpliedApyLimit: ix.lnImpliedApyLimit,
+    });
+    buckets.setupInstructions.push(...setupIxs);
+    buckets.syncInstructions.push(...ixs);
+}
+/**
+ * Claim farm emissions from an LP position. Reads the farm info from the
+ * loaded market state and builds the instruction directly.
+ */
+function buildClmmClaimFarmEmission(ix, market, owner, buckets) {
+    const farm = market.state.lpFarm.farmEmissions[ix.farmIndex];
+    if (!farm) {
+        throw new Error(`Farm at index ${ix.farmIndex} not found on CLMM market ${ix.market.toBase58()}`);
+    }
+    const tokenDst = (0, spl_token_1.getAssociatedTokenAddressSync)(farm.mint, owner, true, spl_token_1.TOKEN_PROGRAM_ID);
+    const tokenFarm = (0, spl_token_1.getAssociatedTokenAddressSync)(farm.mint, ix.market, true, spl_token_1.TOKEN_PROGRAM_ID);
+    const claimIx = exponentClmm.createClaimFarmEmissionInstruction({
+        owner,
+        market: ix.market,
+        ticks: market.ticksKey,
+        lpPosition: ix.lpPosition,
+        tokenDst,
+        mint: farm.mint,
+        tokenFarm,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        eventAuthority: market.eventAuthority,
+        program: exponentClmm.EXPONENTCLMM_PROGRAM_ID,
+    }, {
+        amount: exponentClmm.amount("All"),
+    });
+    // Setup: ensure destination ATA exists
+    buckets.setupInstructions.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(owner, tokenDst, owner, farm.mint));
+    buckets.syncInstructions.push(claimIx);
+}
+//# sourceMappingURL=vault-interaction.js.map