@exponent-labs/exponent-sdk 0.1.8 → 0.9.1

package/build/exponentVaults/vault-interaction.js

@@ -0,0 +1,3479 @@
+"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.buildSetupStatePriceRefreshInstructions = exports.createStrategySetupContext = exports.createVaultSyncTransaction = exports.kaminoFarmAction = exports.kaminoVaultAction = exports.kaminoAction = exports.ClmmAction = exports.LoopscaleAction = exports.TitanAction = exports.SyAction = exports.CoreAction = exports.OrderbookAction = exports.OrderbookTradeDirection = exports.KaminoFarmAction = exports.KaminoVaultAction = exports.VaultAction = void 0;
+const kamino_reserve_deserializer_1 = require("@exponent-labs/kamino-reserve-deserializer");
+const exponent_fetcher_1 = require("@exponent-labs/exponent-fetcher");
+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 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 vault_2 = require("./vault");
+const ytPosition_1 = require("../ytPosition");
+const vault_3 = require("./vault");
+const kamino_farms_1 = require("./kamino-farms");
+const pricePathResolver_1 = require("./pricePathResolver");
+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");
+const KAMINO_VAULT_PRICE_TYPE_WIRE = 14;
+const KAMINO_VAULT_ACCOUNT_DISCRIMINATOR_LEN = 8;
+const KAMINO_VAULT_ALLOCATION_STRATEGY_OFFSET = 304;
+const KAMINO_VAULT_ALLOCATION_SIZE = 2160;
+const KAMINO_VAULT_ALLOCATION_CTOKEN_VAULT_OFFSET = 32;
+const KAMINO_VAULT_GLOBAL_CONFIG_SEED = Buffer.from("global_config");
+// ============================================================================
+// Vault Instruction Types (re-exported from vault-instruction-types.ts)
+// ============================================================================
+var vault_instruction_types_1 = require("./vault-instruction-types");
+Object.defineProperty(exports, "VaultAction", { enumerable: true, get: function () { return vault_instruction_types_1.VaultAction; } });
+Object.defineProperty(exports, "KaminoVaultAction", { enumerable: true, get: function () { return vault_instruction_types_1.KaminoVaultAction; } });
+Object.defineProperty(exports, "KaminoFarmAction", { enumerable: true, get: function () { return vault_instruction_types_1.KaminoFarmAction; } });
+Object.defineProperty(exports, "OrderbookTradeDirection", { enumerable: true, get: function () { return vault_instruction_types_1.OrderbookTradeDirection; } });
+Object.defineProperty(exports, "OrderbookAction", { enumerable: true, get: function () { return vault_instruction_types_1.OrderbookAction; } });
+Object.defineProperty(exports, "CoreAction", { enumerable: true, get: function () { return vault_instruction_types_1.CoreAction; } });
+Object.defineProperty(exports, "SyAction", { enumerable: true, get: function () { return vault_instruction_types_1.SyAction; } });
+Object.defineProperty(exports, "TitanAction", { enumerable: true, get: function () { return vault_instruction_types_1.TitanAction; } });
+Object.defineProperty(exports, "LoopscaleAction", { enumerable: true, get: function () { return vault_instruction_types_1.LoopscaleAction; } });
+Object.defineProperty(exports, "ClmmAction", { enumerable: true, get: function () { return vault_instruction_types_1.ClmmAction; } });
+const vault_instruction_types_2 = require("./vault-instruction-types");
+// ============================================================================
+// 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: vault_instruction_types_2.VaultAction.INIT_USER_METADATA, market };
+    },
+    /**
+     * Initialize a Kamino obligation for a market.
+     * When `autoManagePositions` is enabled, the SDK also registers the new
+     * obligation as a tracked strategy position after the init succeeds.
+     * @param market - The Kamino lending market
+     */
+    initObligation(market) {
+        return { action: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.VaultAction.REPAY, market, asset: asset, amount };
+    },
+};
+/**
+ * Builder for direct Kamino Vault action descriptors.
+ *
+ * These actions move vault-owned tokens into a Kamino Vault and, when
+ * `autoManagePositions` is enabled, automatically track the resulting share
+ * token account as a managed strategy position.
+ */
+exports.kaminoVaultAction = {
+    /**
+     * Deposit the vault-owned token account into a Kamino Vault.
+     * @param params.vault - Kamino Vault address
+     * @param params.amount - Amount of deposit tokens to move into the vault
+     */
+    deposit(params) {
+        return { action: vault_instruction_types_2.KaminoVaultAction.DEPOSIT, ...params };
+    },
+    /**
+     * Withdraw Kamino Vault shares back into the vault-owned token account.
+     * When the Kamino Vault currently allocates across multiple reserves,
+     * specify the reserve to disinvest from.
+     */
+    withdraw(params) {
+        return { action: vault_instruction_types_2.KaminoVaultAction.WITHDRAW, ...params };
+    },
+};
+/**
+ * Builder for direct Kamino Farm action descriptors.
+ *
+ * These actions operate on a farm `user_state` derived from the managed vault
+ * owner by default. Pass `delegatee` when targeting a delegated farm user
+ * state, such as a Kamino obligation-owned farm entry.
+ */
+exports.kaminoFarmAction = {
+    /** Initialize the farm `user_state` PDA. */
+    initializeUser(params) {
+        return { action: vault_instruction_types_2.KaminoFarmAction.INITIALIZE_USER, ...params };
+    },
+    /** Stake the managed vault's token ATA into the farm. */
+    stake(params) {
+        return { action: vault_instruction_types_2.KaminoFarmAction.STAKE, ...params };
+    },
+    /** Unstake a scaled share amount from the farm. */
+    unstake(params) {
+        return { action: vault_instruction_types_2.KaminoFarmAction.UNSTAKE, ...params };
+    },
+    /** Withdraw matured unstaked deposits back into the managed vault ATA. */
+    withdrawUnstakedDeposits(params) {
+        return { action: vault_instruction_types_2.KaminoFarmAction.WITHDRAW_UNSTAKED_DEPOSITS, ...params };
+    },
+    /** Harvest a specific reward index into a managed vault reward ATA. */
+    harvestReward(params) {
+        return { action: vault_instruction_types_2.KaminoFarmAction.HARVEST_REWARD, ...params };
+    },
+};
+/**
+ * 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, autoManagePositions = false, setupContext, }) {
+    vaultPda ??= owner;
+    const resolvedSetupContext = setupContext ?? createStrategySetupContext({
+        connection,
+        env: environment_1.LOCAL_ENV,
+        owner,
+        signer,
+        vaultAddress,
+        policyPda,
+        vaultPda,
+        accountIndex,
+        squadsProgram,
+        leadingAccounts,
+        preHookAccounts,
+        postHookAccounts,
+        autoManagePositions,
+    });
+    const { setupInstructions, syncInstructions, preInstructions, postInstructions, signers, addressLookupTableAddresses } = await buildVaultInstructions(instructions, owner, connection, signer, policyPda, vaultPda, accountIndex, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram, autoManagePositions, resolvedSetupContext);
+    const setupStatePriceRefreshInstructions = setupContext
+        ? []
+        : await buildSetupStatePriceRefreshInstructions(resolvedSetupContext);
+    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: [...setupStatePriceRefreshInstructions, ...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 isKaminoVaultInstruction(ix) {
+    return Object.values(vault_instruction_types_2.KaminoVaultAction).includes(ix.action);
+}
+function isKaminoFarmInstruction(ix) {
+    return Object.values(vault_instruction_types_2.KaminoFarmAction).includes(ix.action);
+}
+function isOrderbookInstruction(ix) {
+    return Object.values(vault_instruction_types_2.OrderbookAction).includes(ix.action);
+}
+function isCoreInstruction(ix) {
+    return Object.values(vault_instruction_types_2.CoreAction).includes(ix.action);
+}
+function isSyInstruction(ix) {
+    return Object.values(vault_instruction_types_2.SyAction).includes(ix.action);
+}
+function isTitanInstruction(ix) {
+    return Object.values(vault_instruction_types_2.TitanAction).includes(ix.action);
+}
+function isClmmInstruction(ix) {
+    return Object.values(vault_instruction_types_2.ClmmAction).includes(ix.action);
+}
+function isLoopscaleInstruction(ix) {
+    return Object.values(vault_instruction_types_2.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, autoManagePositions = true, pricesAccount, }) {
+    return {
+        connection,
+        env,
+        owner,
+        signer,
+        vaultAddress,
+        policyPda,
+        vaultPda,
+        accountIndex,
+        squadsProgram,
+        leadingAccounts,
+        preHookAccounts,
+        postHookAccounts,
+        autoManagePositions,
+        pricesAccount,
+    };
+}
+exports.createStrategySetupContext = createStrategySetupContext;
+function trackRequiredPriceIds(requiredPriceIds, priceIdValue) {
+    for (const id of (0, pricePathResolver_1.extractPriceIds)(priceIdValue)) {
+        const numericId = Number(id);
+        if (numericId !== 0) {
+            requiredPriceIds.add(numericId);
+        }
+    }
+}
+async function loadStrategySetupState(context) {
+    if (!context.vaultAddress) {
+        return null;
+    }
+    if (!context.statePromise) {
+        context.statePromise = (async () => {
+            const strategyVault = await vault_3.ExponentVault.load({
+                env: context.env,
+                connection: context.connection,
+                address: context.vaultAddress,
+            });
+            const prices = context.pricesAccount ?? await strategyVault.fetcher.fetchExponentPrices();
+            const trackedOrderbooks = new Set();
+            const trackedYieldVaults = new Set();
+            const trackedKaminoObligations = new Map();
+            const trackedKaminoFarms = new Set();
+            const trackedClmmPositions = 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;
+                }
+                const kaminoEntry = getTrackedKaminoObligationFromPosition(position);
+                if (kaminoEntry) {
+                    trackedKaminoObligations.set(kaminoEntry.obligation.toBase58(), {
+                        quotePriceId: kaminoEntry.quotePriceId,
+                        quoteInputMint: (0, pricePathResolver_1.getPriceInputMintFromPriceId)(prices, kaminoEntry.quotePriceId),
+                        mappedReserves: new Set((kaminoEntry.reservePriceMappings ?? []).map((mapping) => mapping.reserve.toBase58())),
+                    });
+                    continue;
+                }
+                const kaminoFarmEntry = getTrackedKaminoFarmFromPosition(position);
+                if (kaminoFarmEntry) {
+                    trackedKaminoFarms.add(kaminoFarmKey(kaminoFarmEntry.farmState, kaminoFarmEntry.userState));
+                    continue;
+                }
+                const clmmEntry = getTrackedClmmPositionFromPosition(position);
+                if (clmmEntry) {
+                    trackedClmmPositions.add(clmmEntry.lpPosition.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,
+                requiredPriceIds: (0, vault_2.collectTrackedStrategyVaultPriceIds)({
+                    tokenEntries: strategyVault.state.tokenEntries,
+                    strategyPositions: strategyVault.state.strategyPositions,
+                }),
+                nextStrategyPositionIndex: strategyVault.state.strategyPositions.length,
+                trackedOrderbooks,
+                trackedYieldVaults,
+                trackedKaminoObligations,
+                trackedKaminoFarms,
+                trackedClmmPositions,
+                tokenEntryAccountByMint,
+                tokenPositionIndexByMint,
+                trackedTokenAccounts,
+                baseAumAccounts: mutableStrategyVault(strategyVault).aumRemainingAccounts(),
+                plannedAumAccounts: [],
+                existingAccounts: new Map(),
+            };
+        })();
+    }
+    return context.statePromise;
+}
+async function buildSetupStatePriceRefreshInstructions(setupContext) {
+    const state = await loadStrategySetupState(setupContext);
+    if (!state) {
+        return [];
+    }
+    const refreshInstructions = [];
+    const reserveAccounts = new Map();
+    for (const priceId of state.requiredPriceIds) {
+        const priceEntry = state.prices.prices[priceId];
+        if (!priceEntry || !isKaminoVaultPriceType(priceEntry.priceType)) {
+            continue;
+        }
+        for (const reserveAddress of priceEntry.interfaceAccounts.slice(1)) {
+            const reserveKey = reserveAddress.toBase58();
+            if (reserveAccounts.has(reserveKey)) {
+                continue;
+            }
+            const reserveAccount = await kamino_reserve_deserializer_1.Reserve.fetch(setupContext.connection, reserveAddress);
+            if (!reserveAccount) {
+                throw new Error(`Missing Kamino reserve account ${reserveKey} required to refresh Kamino vault prices`);
+            }
+            reserveAccounts.set(reserveKey, { account: reserveAccount });
+        }
+    }
+    if (reserveAccounts.size > 0) {
+        const reserves = [...reserveAccounts.values()];
+        const defaultKey = web3_js_1.PublicKey.default;
+        const oracleOrSentinel = (key) => key.equals(defaultKey) ? policyBuilders_1.KAMINO_LENDING_PROGRAM_ID : key;
+        refreshInstructions.push(...await (0, scope_refresh_1.buildScopeRefreshInstructions)(setupContext.connection, reserves));
+        for (const [reserveKey, { account }] of reserveAccounts.entries()) {
+            const tokenInfo = account.config.tokenInfo;
+            refreshInstructions.push((0, instructions_1.refreshReserve)({
+                reserve: new web3_js_1.PublicKey(reserveKey),
+                lendingMarket: account.lendingMarket,
+                pythOracle: oracleOrSentinel(tokenInfo.pythConfiguration.price),
+                switchboardPriceOracle: oracleOrSentinel(tokenInfo.switchboardConfiguration.priceAggregator),
+                switchboardTwapOracle: oracleOrSentinel(tokenInfo.switchboardConfiguration.twapAggregator),
+                scopePrices: oracleOrSentinel(tokenInfo.scopeConfiguration.priceFeed),
+            }));
+        }
+    }
+    const updatePriceInstructions = await state.strategyVault.ixsUpdateStrategyVaultPrices(state.prices, {
+        manager: setupContext.signer,
+        priceIds: [...state.requiredPriceIds].sort((a, b) => a - b),
+    });
+    return [...refreshInstructions, ...updatePriceInstructions];
+}
+exports.buildSetupStatePriceRefreshInstructions = buildSetupStatePriceRefreshInstructions;
+function isAutoManagePositionsEnabled(setupContext) {
+    return setupContext?.autoManagePositions ?? true;
+}
+function unwrapTupleLikeValue(value) {
+    if (Array.isArray(value)) {
+        return value[0];
+    }
+    if (value && typeof value === "object" && "0" in value) {
+        return value[0];
+    }
+    return value ?? undefined;
+}
+function getTrackedKaminoObligationFromPosition(position) {
+    if (!position || typeof position !== "object" || !("obligation" in position)) {
+        return null;
+    }
+    const obligationContainer = position.obligation;
+    const obligationValue = unwrapTupleLikeValue(obligationContainer);
+    const kaminoContainer = (obligationValue
+        && typeof obligationValue === "object"
+        && "kaminoObligation" in obligationValue)
+        ? obligationValue.kaminoObligation
+        : obligationValue;
+    const kaminoEntry = unwrapTupleLikeValue(kaminoContainer);
+    if (!kaminoEntry
+        || typeof kaminoEntry !== "object"
+        || !("obligation" in kaminoEntry)
+        || !(kaminoEntry.obligation instanceof web3_js_1.PublicKey)) {
+        return null;
+    }
+    const typedKaminoEntry = kaminoEntry;
+    return {
+        obligation: typedKaminoEntry.obligation,
+        quotePriceId: typedKaminoEntry.quotePriceId,
+        reservePriceMappings: typedKaminoEntry.reservePriceMappings ?? [],
+    };
+}
+function getTrackedKaminoFarmFromPosition(position) {
+    if (!position || typeof position !== "object" || !("kaminoFarm" in position)) {
+        return null;
+    }
+    const kaminoFarmContainer = position.kaminoFarm;
+    const kaminoFarmEntry = unwrapTupleLikeValue(kaminoFarmContainer);
+    if (!kaminoFarmEntry
+        || typeof kaminoFarmEntry !== "object"
+        || !(kaminoFarmEntry.farmState instanceof web3_js_1.PublicKey)
+        || !(kaminoFarmEntry.userState instanceof web3_js_1.PublicKey)) {
+        return null;
+    }
+    return {
+        farmState: kaminoFarmEntry.farmState,
+        userState: kaminoFarmEntry.userState,
+    };
+}
+function kaminoFarmKey(farmState, userState) {
+    return `${farmState.toBase58()}:${userState.toBase58()}`;
+}
+function getTrackedClmmPositionFromPosition(position) {
+    if (!position || typeof position !== "object" || !("clmmPosition" in position)) {
+        return null;
+    }
+    const clmmContainer = position.clmmPosition;
+    const clmmEntry = unwrapTupleLikeValue(clmmContainer);
+    if (!clmmEntry
+        || typeof clmmEntry !== "object"
+        || !(clmmEntry.lpPosition instanceof web3_js_1.PublicKey)
+        || !(clmmEntry.market instanceof web3_js_1.PublicKey)) {
+        return null;
+    }
+    return {
+        lpPosition: clmmEntry.lpPosition,
+        market: clmmEntry.market,
+    };
+}
+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;
+}
+function mutableStrategyVault(value) {
+    return ("strategyVault" in value ? value.strategyVault : value);
+}
+function buildTrackedAumRemainingAccounts(state, extraAccounts = []) {
+    return (0, utils_1.uniqueRemainingAccounts)([
+        ...state.baseAumAccounts,
+        ...state.plannedAumAccounts,
+        ...extraAccounts,
+    ]);
+}
+function recordPlannedOrderbookEntry(state, params) {
+    state.trackedOrderbooks.add(params.orderbook.toBase58());
+    state.plannedAumAccounts.push({ pubkey: params.orderbook, isSigner: false, isWritable: false });
+    state.strategyVault.state.strategyPositions.push({
+        orderbook: [{
+                orderbook: params.orderbook,
+                mint: params.mint,
+                offerIdxVec: [],
+                priceIdPt: params.priceIdPt,
+                baseMint: params.baseMint,
+            }],
+    });
+    state.nextStrategyPositionIndex += 1;
+}
+function recordPlannedYieldPosition(state, params) {
+    state.trackedYieldVaults.add(params.vault.toBase58());
+    state.existingAccounts.set(params.yieldPosition.toBase58(), true);
+    state.strategyVault.state.strategyPositions.push({
+        yieldPosition: [{
+                yieldPosition: params.yieldPosition,
+                vault: params.vault,
+                priceIdPt: params.priceIdPt,
+            }],
+    });
+    state.nextStrategyPositionIndex += 1;
+}
+function recordPlannedTokenAccountEntry(state, params) {
+    const tokenMintKey = params.tokenMint.toBase58();
+    const tokenAccountKey = params.tokenAccount.toBase58();
+    state.tokenPositionIndexByMint.set(tokenMintKey, state.nextStrategyPositionIndex);
+    state.trackedTokenAccounts.add(tokenAccountKey);
+    state.plannedAumAccounts.push({ pubkey: params.tokenAccount, isSigner: false, isWritable: false });
+    state.strategyVault.state.strategyPositions.push({
+        tokenAccount: [{
+                tokenMint: params.tokenMint,
+                balances: [{
+                        tokenAccount: params.tokenAccount,
+                        mint: params.tokenMint,
+                        priceId: params.priceId,
+                    }],
+            }],
+    });
+    state.nextStrategyPositionIndex += 1;
+}
+function recordPlannedTokenAccountBalance(state, params) {
+    const tokenMintKey = params.tokenMint.toBase58();
+    const tokenAccountKey = params.tokenAccount.toBase58();
+    state.trackedTokenAccounts.add(tokenAccountKey);
+    state.plannedAumAccounts.push({ pubkey: params.tokenAccount, isSigner: false, isWritable: false });
+    const positions = state.strategyVault.state.strategyPositions;
+    const target = positions.find((position) => {
+        const tokenAccountEntry = Array.isArray(position.tokenAccount) ? position.tokenAccount[0] : undefined;
+        return tokenAccountEntry && tokenAccountEntry.tokenMint instanceof web3_js_1.PublicKey && tokenAccountEntry.tokenMint.equals(params.tokenMint);
+    });
+    const tokenAccountEntry = target?.tokenAccount?.[0];
+    tokenAccountEntry?.balances?.push({
+        tokenAccount: params.tokenAccount,
+        mint: params.tokenMint,
+        priceId: params.priceId,
+    });
+}
+function recordPlannedKaminoObligation(state, entry) {
+    state.existingAccounts.set(entry.obligation.toBase58(), true);
+    state.trackedKaminoObligations.set(entry.obligation.toBase58(), {
+        quotePriceId: entry.quotePriceId,
+        quoteInputMint: entry.quoteInputMint,
+        mappedReserves: new Set(entry.reservePriceMappings.map((mapping) => mapping.reserve.toBase58())),
+    });
+    state.plannedAumAccounts.push({ pubkey: entry.obligation, isSigner: false, isWritable: false });
+    for (const mapping of entry.reservePriceMappings) {
+        state.plannedAumAccounts.push({ pubkey: mapping.reserve, isSigner: false, isWritable: false });
+    }
+    ;
+    state.strategyVault.state.strategyPositions.push({
+        obligation: [{
+                kaminoObligation: [{
+                        obligation: entry.obligation,
+                        lendingProgramId: policyBuilders_1.KAMINO_LENDING_PROGRAM_ID,
+                        quotePriceId: entry.quotePriceId,
+                        reservePriceMappings: entry.reservePriceMappings,
+                        remainingAccountsAmount: entry.remainingAccountsAmount,
+                        minPriceStatusFlags: entry.minPriceStatusFlags,
+                    }],
+            }],
+    });
+    state.nextStrategyPositionIndex += 1;
+}
+function recordPlannedKaminoReserveMappings(state, params) {
+    const tracked = state.trackedKaminoObligations.get(params.obligation.toBase58());
+    if (!tracked) {
+        return;
+    }
+    tracked.quoteInputMint = params.quoteInputMint;
+    for (const mapping of params.reservePriceMappings) {
+        tracked.mappedReserves.add(mapping.reserve.toBase58());
+    }
+    const positions = state.strategyVault.state.strategyPositions;
+    const target = positions.find((position) => {
+        const entry = getTrackedKaminoObligationFromPosition(position);
+        return entry?.obligation.equals(params.obligation);
+    });
+    const kaminoEntry = (Array.isArray(target?.obligation)
+        ? target?.obligation?.[0]?.kaminoObligation?.[0]
+        : undefined);
+    if (!kaminoEntry) {
+        return;
+    }
+    for (const mapping of params.reservePriceMappings) {
+        const existing = kaminoEntry.reservePriceMappings?.find((item) => item.reserve.equals(mapping.reserve));
+        if (existing) {
+            existing.reservePriceId = mapping.reservePriceId;
+        }
+        else {
+            kaminoEntry.reservePriceMappings ??= [];
+            kaminoEntry.reservePriceMappings.push(mapping);
+        }
+        state.plannedAumAccounts.push({ pubkey: mapping.reserve, isSigner: false, isWritable: false });
+    }
+    kaminoEntry.remainingAccountsAmount = BigInt(1 + (kaminoEntry.reservePriceMappings?.length ?? 0));
+}
+function recordPlannedKaminoFarmPosition(state, params) {
+    const trackingKey = kaminoFarmKey(params.farmState, params.userState);
+    if (state.trackedKaminoFarms.has(trackingKey)) {
+        return;
+    }
+    state.trackedKaminoFarms.add(trackingKey);
+    state.existingAccounts.set(params.userState.toBase58(), true);
+    state.plannedAumAccounts.push({ pubkey: params.farmState, isSigner: false, isWritable: false });
+    state.plannedAumAccounts.push({ pubkey: params.userState, isSigner: false, isWritable: false });
+    state.plannedAumAccounts.push({ pubkey: params.globalConfig, isSigner: false, isWritable: false });
+    if (params.scopePrices) {
+        state.plannedAumAccounts.push({ pubkey: params.scopePrices, isSigner: false, isWritable: false });
+    }
+    ;
+    state.strategyVault.state.strategyPositions.push({
+        kaminoFarm: [{
+                farmState: params.farmState,
+                userState: params.userState,
+            }],
+    });
+    state.nextStrategyPositionIndex += 1;
+}
+function recordPlannedClmmPosition(state, params) {
+    state.existingAccounts.set(params.lpPosition.toBase58(), true);
+    state.trackedClmmPositions.add(params.lpPosition.toBase58());
+    state.plannedAumAccounts.push({ pubkey: params.lpPosition, isSigner: false, isWritable: false });
+    mutableStrategyVault(state).clmmTicksMap.set(params.market.toBase58(), params.ticksKey);
+    state.strategyVault.state.strategyPositions.push({
+        clmmPosition: [{
+                lpPosition: params.lpPosition,
+                market: params.market,
+                priceIdPt: params.priceIdPt,
+                priceIdSy: params.priceIdSy,
+            }],
+    });
+    state.nextStrategyPositionIndex += 1;
+}
+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 priceIdPt = (0, pricePathResolver_1.resolvePriceIdFromMintToUnderlyingOrThrow)({
+        prices: state.prices,
+        sourceMint: orderbook.mintPt,
+        targetMint: state.strategyVault.state.underlyingMint,
+        label: `orderbook setup (${orderbook.selfAddress.toBase58()})`,
+    });
+    trackRequiredPriceIds(state.requiredPriceIds, priceIdPt);
+    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,
+                    baseMint: state.strategyVault.state.underlyingMint,
+                }]),
+        ],
+        remainingAccounts: [
+            { pubkey: orderbook.selfAddress, isSigner: false, isWritable: false },
+            { pubkey: orderbook.state.vault, isSigner: false, isWritable: false },
+        ],
+    }));
+    recordPlannedOrderbookEntry(state, {
+        orderbook: orderbook.selfAddress,
+        mint: orderbook.vault.mintSy,
+        priceIdPt,
+        baseMint: state.strategyVault.state.underlyingMint,
+    });
+}
+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 priceIdPt = (0, pricePathResolver_1.resolvePriceIdFromMintToUnderlyingOrThrow)({
+        prices: state.prices,
+        sourceMint: coreVault.mintPt,
+        targetMint: state.strategyVault.state.underlyingMint,
+        label: `core vault setup (${coreVault.selfAddress.toBase58()})`,
+    });
+    trackRequiredPriceIds(state.requiredPriceIds, priceIdPt);
+    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,
+            }),
+        ],
+        remainingAccounts: [
+            { pubkey: coreVault.selfAddress, isSigner: false, isWritable: false },
+            { pubkey: yieldPosition, isSigner: false, isWritable: false },
+        ],
+    }));
+    recordPlannedYieldPosition(state, {
+        yieldPosition,
+        vault: coreVault.selfAddress,
+        priceIdPt,
+    });
+}
+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)) {
+        // Cache hook resolution on the context to avoid redundant RPC calls
+        // when wrapping multiple setup instructions in the same build.
+        if (!setupContext.resolvedHooksPromise) {
+            setupContext.resolvedHooksPromise = (0, policyMatcher_1.resolveHookAccounts)(setupContext.connection, resolvedPolicyPda, setupContext.vaultAddress, setupContext.signer);
+        }
+        const hooks = await setupContext.resolvedHooksPromise;
+        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 priceId = (0, pricePathResolver_1.resolvePriceIdFromMintToUnderlyingOrThrow)({
+        prices: state.prices,
+        sourceMint: tokenMint,
+        targetMint: state.strategyVault.state.underlyingMint,
+        label: `token position setup (${tokenMint.toBase58()})`,
+    });
+    trackRequiredPriceIds(state.requiredPriceIds, priceId);
+    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,
+                            }],
+                    }]),
+            ],
+            remainingAccounts: [
+                { pubkey: tokenAccount, isSigner: false, isWritable: false },
+            ],
+        }));
+        recordPlannedTokenAccountEntry(state, {
+            tokenMint,
+            tokenAccount,
+            priceId,
+        });
+    }
+    else {
+        buckets.setupInstructions.push(state.strategyVault.ixWrapperManagerUpdatePosition({
+            manager: setupContext.signer,
+            update: {
+                __kind: "AddTokenAccountBalance",
+                tokenMint,
+                balance: {
+                    tokenAccount,
+                    mint: tokenMint,
+                    priceId,
+                },
+            },
+            remainingAccounts: [
+                { pubkey: tokenAccount, isSigner: false, isWritable: false },
+            ],
+        }));
+        recordPlannedTokenAccountBalance(state, {
+            tokenMint,
+            tokenAccount,
+            priceId,
+        });
+    }
+    state.trackedTokenAccounts.add(tokenAccountKey);
+}
+async function buildVaultInstructions(instructions, owner, connection, signer, policyPda, vaultPda, accountIndex, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram = syncTransaction_1.SQUADS_PROGRAM_ID, autoManagePositions = true, sharedSetupContext) {
+    const buckets = {
+        setupInstructions: [],
+        syncInstructions: [],
+        preInstructions: [],
+        postInstructions: [],
+        signers: [],
+        addressLookupTableAddresses: [],
+    };
+    const setupContext = sharedSetupContext ?? createStrategySetupContext({
+        connection,
+        env: environment_1.LOCAL_ENV,
+        owner,
+        signer,
+        vaultAddress,
+        policyPda,
+        vaultPda,
+        accountIndex,
+        squadsProgram,
+        leadingAccounts,
+        preHookAccounts,
+        postHookAccounts,
+        autoManagePositions,
+    });
+    for (const ix of instructions) {
+        if (isKaminoVaultInstruction(ix)) {
+            await buildKaminoVaultInstruction(ix, buckets, setupContext);
+            continue;
+        }
+        if (isKaminoFarmInstruction(ix)) {
+            await buildKaminoFarmInstruction(ix, buckets, setupContext);
+            continue;
+        }
+        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 vault_instruction_types_2.VaultAction.INIT_USER_METADATA:
+                await buildInitUserMetadata(owner, connection, buckets);
+                break;
+            case vault_instruction_types_2.VaultAction.INIT_OBLIGATION:
+                await buildInitObligation(ix, owner, connection, buckets, setupContext);
+                break;
+            case vault_instruction_types_2.VaultAction.DEPOSIT:
+                await buildDeposit(ix, owner, connection, signer, buckets, setupContext);
+                break;
+            case vault_instruction_types_2.VaultAction.WITHDRAW:
+                await buildWithdraw(ix, owner, connection, signer, buckets, setupContext);
+                break;
+            case vault_instruction_types_2.VaultAction.BORROW:
+                await buildBorrow(ix, owner, connection, signer, buckets, setupContext);
+                break;
+            case vault_instruction_types_2.VaultAction.REPAY:
+                await buildRepay(ix, owner, connection, signer, buckets, setupContext);
+                break;
+        }
+    }
+    return buckets;
+}
+const KAMINO_VAULT_EVENT_AUTHORITY = (0, utils_1.emitEventAuthority)(policyBuilders_1.KAMINO_VAULT_PROGRAM_ID);
+const KAMINO_FARM_USER_STATE_SIZE = 920;
+const KAMINO_STAKE_ALL_AMOUNT = new bn_js_1.default("18446744073709551615");
+function toBn(value) {
+    if (bn_js_1.default.isBN(value)) {
+        return value;
+    }
+    return new bn_js_1.default(value.toString());
+}
+function encodeU64InstructionData(discriminator, value) {
+    return Buffer.concat([discriminator, toBn(value).toArrayLike(Buffer, "le", 8)]);
+}
+function encodeU128InstructionData(discriminator, value) {
+    return Buffer.concat([discriminator, toBn(value).toArrayLike(Buffer, "le", 16)]);
+}
+function getKaminoFarmUserStateAddress(delegatee, farmState) {
+    return (0, constants_1.getKaminoFarmsObligationFarm)(delegatee, farmState, KAMINO_FARMS_PROGRAM_ID);
+}
+async function accountExistsMaybeTracked(setupContext, address) {
+    if (!setupContext) {
+        return false;
+    }
+    const state = await loadStrategySetupState(setupContext);
+    if (state) {
+        return accountExists(state, setupContext.connection, address);
+    }
+    return (await setupContext.connection.getAccountInfo(address)) !== null;
+}
+function matchesKaminoVaultInterfaceAccounts(entry, interfaceAccounts) {
+    return (entry.interfaceAccounts.length === interfaceAccounts.length
+        && entry.interfaceAccounts.every((account, index) => account.equals(interfaceAccounts[index])));
+}
+// ExponentPrices stores explicit wire discriminators, which can drift from the
+// generated TypeScript enum ordinals. Accept both so Kamino vault share
+// tracking works across current program/IDL combinations.
+function isKaminoVaultPriceType(priceType) {
+    return priceType === KAMINO_VAULT_PRICE_TYPE_WIRE || priceType === exponentVaults.PriceType.KaminoVault;
+}
+function resolveKaminoVaultPriceEntry(params) {
+    const candidates = params.prices.prices.filter((entry) => entry !== null).filter((entry) => isKaminoVaultPriceType(entry.priceType)
+        && entry.priceMint.equals(params.sharesMint)
+        && entry.underlyingMint.equals(params.depositTokenMint)
+        && matchesKaminoVaultInterfaceAccounts(entry, params.interfaceAccounts));
+    if (candidates.length === 0) {
+        const interfaceAccountsLabel = params.interfaceAccounts.map((account) => account.toBase58()).join(", ");
+        throw new Error(`Missing Exponent KaminoVault price for shares mint ${params.sharesMint.toBase58()} and deposit mint ${params.depositTokenMint.toBase58()} (interface accounts: ${interfaceAccountsLabel}). Register a PriceType.KaminoVault price for this vault before using auto-managed Kamino vault share tracking.`);
+    }
+    if (candidates.length > 1) {
+        throw new Error(`Multiple Exponent KaminoVault prices matched shares mint ${params.sharesMint.toBase58()} and deposit mint ${params.depositTokenMint.toBase58()}`);
+    }
+    return candidates[0];
+}
+function resolveKaminoVaultTrackedPriceId(params) {
+    if (params.depositTokenMint.equals(params.state.strategyVault.state.underlyingMint)) {
+        return { __kind: "Simple", priceId: params.sharePriceId };
+    }
+    const reservePriceId = (0, pricePathResolver_1.resolvePriceIdFromMintToUnderlyingOrThrow)({
+        prices: params.state.prices,
+        sourceMint: params.depositTokenMint,
+        targetMint: params.state.strategyVault.state.underlyingMint,
+        label: params.label,
+    });
+    const reservePriceIds = (0, pricePathResolver_1.extractPriceIds)(reservePriceId).map((id) => BigInt(id));
+    return { __kind: "Multiply", priceIds: [...reservePriceIds, params.sharePriceId] };
+}
+async function resolveKaminoVaultContext(vaultAddress, setupContext) {
+    const rawIndex = await (0, exponent_fetcher_1.fetchKaminoVaultIndex)({
+        connection: setupContext.connection,
+        kaminoVaultAccount: vaultAddress,
+    });
+    const reserveAddresses = rawIndex.reserves.map((reserve) => reserve.reserveAddress);
+    const [vaultInfo, tokenMintInfo, sharesMintInfo, reserveInfos] = await Promise.all([
+        setupContext.connection.getAccountInfo(vaultAddress),
+        setupContext.connection.getAccountInfo(rawIndex.tokenMint),
+        setupContext.connection.getAccountInfo(rawIndex.sharesMint),
+        setupContext.connection.getMultipleAccountsInfo(reserveAddresses),
+    ]);
+    if (!vaultInfo?.data) {
+        throw new Error(`Kamino vault account not found: ${vaultAddress.toBase58()}`);
+    }
+    const decodedReserves = reserveInfos.map((reserveInfo, index) => {
+        if (!reserveInfo?.data) {
+            throw new Error(`Missing Kamino reserve account ${reserveAddresses[index].toBase58()}`);
+        }
+        return kamino_reserve_deserializer_1.Reserve.decode(reserveInfo.data);
+    });
+    const collateralMintInfos = await setupContext.connection.getMultipleAccountsInfo(decodedReserves.map((reserve) => reserve.collateral.mintPubkey));
+    const normalizedReserves = reserveAddresses.map((reserveAddress, index) => {
+        const reserveAccount = decodedReserves[index];
+        const rawReserve = rawIndex.reserves[index];
+        const allocationOffset = KAMINO_VAULT_ACCOUNT_DISCRIMINATOR_LEN
+            + KAMINO_VAULT_ALLOCATION_STRATEGY_OFFSET
+            + (index * KAMINO_VAULT_ALLOCATION_SIZE);
+        const ctokenVaultOffset = allocationOffset + KAMINO_VAULT_ALLOCATION_CTOKEN_VAULT_OFFSET;
+        const [lendingMarketAuthority] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("lma"), reserveAccount.lendingMarket.toBuffer()], policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
+        return {
+            reserveAddress,
+            marketAddress: rawReserve.marketAddress ?? rawReserve.reserve ?? reserveAccount.lendingMarket,
+            ctokenVault: rawReserve.ctokenVault
+                ?? new web3_js_1.PublicKey(vaultInfo.data.subarray(ctokenVaultOffset, ctokenVaultOffset + 32)),
+            lendingMarketAuthority: rawReserve.lendingMarketAuthority ?? lendingMarketAuthority,
+            pythOracle: rawReserve.pythOracle ?? reserveAccount.config.tokenInfo.pythConfiguration.price,
+            switchboardPriceOracle: rawReserve.switchboardPriceOracle
+                ?? reserveAccount.config.tokenInfo.switchboardConfiguration.priceAggregator,
+            switchboardTwapOracle: rawReserve.switchboardTwapOracle
+                ?? reserveAccount.config.tokenInfo.switchboardConfiguration.twapAggregator,
+            scopePrices: rawReserve.scopePrices ?? reserveAccount.config.tokenInfo.scopeConfiguration.priceFeed,
+            reserveLiquiditySupply: rawReserve.reserveLiquiditySupply ?? reserveAccount.liquidity.supplyVault,
+            reserveCollateralMint: rawReserve.reserveCollateralMint ?? reserveAccount.collateral.mintPubkey,
+            reserveCollateralTokenProgram: rawReserve.reserveCollateralTokenProgram ?? collateralMintInfos[index]?.owner ?? web3_js_1.PublicKey.default,
+        };
+    });
+    const index = {
+        ...rawIndex,
+        reserves: normalizedReserves,
+        tokenProgram: rawIndex.tokenProgram ?? tokenMintInfo?.owner ?? spl_token_1.TOKEN_PROGRAM_ID,
+        sharesTokenProgram: rawIndex.sharesTokenProgram
+            ?? sharesMintInfo?.owner
+            ?? spl_token_1.TOKEN_PROGRAM_ID,
+        vaultLookupTable: rawIndex.vaultLookupTable ?? web3_js_1.PublicKey.default,
+    };
+    const tokenAta = (0, spl_token_1.getAssociatedTokenAddressSync)(index.tokenMint, setupContext.owner, true, index.tokenProgram);
+    const sharesAta = (0, spl_token_1.getAssociatedTokenAddressSync)(index.sharesMint, setupContext.owner, true, index.sharesTokenProgram);
+    return { index, tokenAta, sharesAta };
+}
+async function queueKaminoVaultSharesTracking(params) {
+    const state = await loadStrategySetupState(params.setupContext);
+    if (!state) {
+        return;
+    }
+    const sharesMintKey = params.vaultContext.index.sharesMint.toBase58();
+    const sharesAtaKey = params.vaultContext.sharesAta.toBase58();
+    if (state.trackedTokenAccounts.has(sharesAtaKey)) {
+        return;
+    }
+    const tokenEntryAccount = state.tokenEntryAccountByMint.get(sharesMintKey);
+    if (tokenEntryAccount) {
+        throw new Error(`Kamino Vault shares mint ${sharesMintKey} is already configured as a token entry on ${tokenEntryAccount}`);
+    }
+    const interfaceAccounts = [
+        params.kaminoVaultAddress,
+        ...params.vaultContext.index.reserves.map((reserve) => reserve.reserveAddress),
+    ];
+    const priceEntry = resolveKaminoVaultPriceEntry({
+        prices: state.prices,
+        sharesMint: params.vaultContext.index.sharesMint,
+        depositTokenMint: params.vaultContext.index.tokenMint,
+        interfaceAccounts,
+    });
+    const resolvedPriceId = resolveKaminoVaultTrackedPriceId({
+        state,
+        depositTokenMint: params.vaultContext.index.tokenMint,
+        sharePriceId: priceEntry.priceId,
+        label: `Kamino Vault shares tracking (${params.kaminoVaultAddress.toBase58()})`,
+    });
+    const remainingAccounts = (0, utils_1.uniqueRemainingAccounts)([
+        { pubkey: params.vaultContext.sharesAta, isSigner: false, isWritable: false },
+        { pubkey: priceEntry.priceInterfaceAccounts, isSigner: false, isWritable: false },
+        ...priceEntry.interfaceAccounts.map((account) => ({
+            pubkey: account,
+            isSigner: false,
+            isWritable: false,
+        })),
+        ...buildTrackedAumRemainingAccounts(state),
+    ]);
+    // The hook validates Kamino vault deposits against the currently tracked
+    // shares ATA, so this registration must happen before the Squads sync step.
+    params.buckets.preInstructions.push(state.strategyVault.ixWrapperManagerUpdatePosition({
+        manager: params.setupContext.signer,
+        update: exponentVaults.positionUpdate("TrackKaminoVaultShares", {
+            sharesMint: params.vaultContext.index.sharesMint,
+            depositTokenMint: params.vaultContext.index.tokenMint,
+            sharesTokenAccount: params.vaultContext.sharesAta,
+            priceInterfaceAccounts: priceEntry.priceInterfaceAccounts,
+        }),
+        remainingAccounts,
+    }));
+    trackRequiredPriceIds(state.requiredPriceIds, resolvedPriceId);
+    if (state.tokenPositionIndexByMint.get(sharesMintKey) === undefined) {
+        recordPlannedTokenAccountEntry(state, {
+            tokenMint: params.vaultContext.index.sharesMint,
+            tokenAccount: params.vaultContext.sharesAta,
+            priceId: resolvedPriceId,
+        });
+    }
+    else {
+        recordPlannedTokenAccountBalance(state, {
+            tokenMint: params.vaultContext.index.sharesMint,
+            tokenAccount: params.vaultContext.sharesAta,
+            priceId: resolvedPriceId,
+        });
+    }
+}
+async function resolveKaminoVaultValidationAccounts(params) {
+    const state = await loadStrategySetupState(params.setupContext);
+    if (!state) {
+        return [];
+    }
+    const priceEntry = resolveKaminoVaultPriceEntry({
+        prices: state.prices,
+        sharesMint: params.vaultContext.index.sharesMint,
+        depositTokenMint: params.vaultContext.index.tokenMint,
+        interfaceAccounts: [
+            params.kaminoVaultAddress,
+            ...params.vaultContext.index.reserves.map((reserve) => reserve.reserveAddress),
+        ],
+    });
+    return [
+        { pubkey: priceEntry.priceInterfaceAccounts, isSigner: false, isWritable: false },
+    ];
+}
+function buildKaminoVaultDepositInstruction(params) {
+    const reserveAccounts = params.vaultContext.index.reserves.flatMap((reserve) => [
+        { pubkey: reserve.reserveAddress, isSigner: false, isWritable: true },
+        { pubkey: reserve.ctokenVault, isSigner: false, isWritable: true },
+        { pubkey: reserve.marketAddress, isSigner: false, isWritable: false },
+        { pubkey: reserve.lendingMarketAuthority, isSigner: false, isWritable: false },
+        { pubkey: reserve.reserveLiquiditySupply, isSigner: false, isWritable: true },
+        { pubkey: reserve.reserveCollateralMint, isSigner: false, isWritable: true },
+        { pubkey: reserve.reserveCollateralTokenProgram, isSigner: false, isWritable: false },
+        { pubkey: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
+        { pubkey: KAMINO_VAULT_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+        { pubkey: policyBuilders_1.KAMINO_VAULT_PROGRAM_ID, isSigner: false, isWritable: false },
+    ]);
+    return new web3_js_1.TransactionInstruction({
+        programId: policyBuilders_1.KAMINO_VAULT_PROGRAM_ID,
+        keys: [
+            { pubkey: params.owner, isSigner: true, isWritable: true },
+            { pubkey: params.kaminoVaultAddress, isSigner: false, isWritable: true },
+            { pubkey: params.vaultContext.index.tokenVault, isSigner: false, isWritable: true },
+            { pubkey: params.vaultContext.index.tokenMint, isSigner: false, isWritable: false },
+            { pubkey: params.vaultContext.index.baseVaultAuthority, isSigner: false, isWritable: false },
+            { pubkey: params.vaultContext.index.sharesMint, isSigner: false, isWritable: true },
+            { pubkey: params.vaultContext.tokenAta, isSigner: false, isWritable: true },
+            { pubkey: params.vaultContext.sharesAta, isSigner: false, isWritable: true },
+            { pubkey: policyBuilders_1.KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: params.vaultContext.index.tokenProgram, isSigner: false, isWritable: false },
+            { pubkey: params.vaultContext.index.sharesTokenProgram, isSigner: false, isWritable: false },
+            { pubkey: KAMINO_VAULT_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+            { pubkey: policyBuilders_1.KAMINO_VAULT_PROGRAM_ID, isSigner: false, isWritable: false },
+            ...reserveAccounts,
+            ...params.vaultContext.index.reserves.map((reserve) => ({
+                pubkey: reserve.reserveAddress,
+                isSigner: false,
+                isWritable: true,
+            })),
+            ...(params.validationAccounts ?? []),
+        ],
+        data: encodeU64InstructionData(policyBuilders_1.KAMINO_VAULT_DISCRIMINATORS.deposit, params.amount),
+    });
+}
+function resolveKaminoVaultWithdrawReserve(ix, vaultContext) {
+    if (ix.reserve) {
+        const reserve = vaultContext.index.reserves.find((entry) => entry.reserveAddress.equals(ix.reserve));
+        if (!reserve) {
+            throw new Error(`Kamino Vault ${ix.vault.toBase58()} does not use reserve ${ix.reserve.toBase58()}`);
+        }
+        return reserve;
+    }
+    if (vaultContext.index.reserves.length !== 1) {
+        throw new Error(`Kamino Vault ${ix.vault.toBase58()} uses ${vaultContext.index.reserves.length} reserves; specify withdraw.reserve`);
+    }
+    return vaultContext.index.reserves[0];
+}
+function buildKaminoVaultWithdrawInstruction(params) {
+    const reserve = resolveKaminoVaultWithdrawReserve(params.ix, params.vaultContext);
+    const [globalConfig] = web3_js_1.PublicKey.findProgramAddressSync([KAMINO_VAULT_GLOBAL_CONFIG_SEED], policyBuilders_1.KAMINO_VAULT_PROGRAM_ID);
+    return new web3_js_1.TransactionInstruction({
+        programId: policyBuilders_1.KAMINO_VAULT_PROGRAM_ID,
+        keys: [
+            { pubkey: params.owner, isSigner: true, isWritable: true },
+            { pubkey: params.ix.vault, isSigner: false, isWritable: true },
+            { pubkey: globalConfig, isSigner: false, isWritable: false },
+            { pubkey: params.vaultContext.index.tokenVault, isSigner: false, isWritable: true },
+            { pubkey: params.vaultContext.index.baseVaultAuthority, isSigner: false, isWritable: false },
+            { pubkey: params.vaultContext.tokenAta, isSigner: false, isWritable: true },
+            { pubkey: params.vaultContext.index.tokenMint, isSigner: false, isWritable: true },
+            { pubkey: params.vaultContext.sharesAta, isSigner: false, isWritable: true },
+            { pubkey: params.vaultContext.index.sharesMint, isSigner: false, isWritable: true },
+            { pubkey: params.vaultContext.index.tokenProgram, isSigner: false, isWritable: false },
+            { pubkey: params.vaultContext.index.sharesTokenProgram, isSigner: false, isWritable: false },
+            { pubkey: policyBuilders_1.KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: KAMINO_VAULT_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+            { pubkey: policyBuilders_1.KAMINO_VAULT_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: params.ix.vault, isSigner: false, isWritable: true },
+            { pubkey: reserve.reserveAddress, isSigner: false, isWritable: true },
+            { pubkey: reserve.ctokenVault, isSigner: false, isWritable: true },
+            { pubkey: reserve.marketAddress, isSigner: false, isWritable: false },
+            { pubkey: reserve.lendingMarketAuthority, isSigner: false, isWritable: false },
+            { pubkey: reserve.reserveLiquiditySupply, isSigner: false, isWritable: true },
+            { pubkey: reserve.reserveCollateralMint, isSigner: false, isWritable: true },
+            { pubkey: reserve.reserveCollateralTokenProgram, isSigner: false, isWritable: false },
+            { pubkey: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
+            { pubkey: KAMINO_VAULT_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+            { pubkey: policyBuilders_1.KAMINO_VAULT_PROGRAM_ID, isSigner: false, isWritable: false },
+            ...params.vaultContext.index.reserves.map((entry) => ({
+                pubkey: entry.reserveAddress,
+                isSigner: false,
+                isWritable: true,
+            })),
+            ...(params.validationAccounts ?? []),
+        ],
+        data: encodeU64InstructionData(policyBuilders_1.KAMINO_VAULT_DISCRIMINATORS.withdraw, params.ix.sharesAmount),
+    });
+}
+async function buildKaminoVaultInstruction(ix, buckets, setupContext) {
+    const vaultContext = await resolveKaminoVaultContext(ix.vault, setupContext);
+    const validationAccounts = await resolveKaminoVaultValidationAccounts({
+        setupContext,
+        kaminoVaultAddress: ix.vault,
+        vaultContext,
+    });
+    buckets.setupInstructions.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(setupContext.signer, vaultContext.sharesAta, setupContext.owner, vaultContext.index.sharesMint, vaultContext.index.sharesTokenProgram));
+    if (setupContext.autoManagePositions) {
+        await ensureTrackedTokenAccountSetup({
+            tokenMint: vaultContext.index.tokenMint,
+            tokenAccount: vaultContext.tokenAta,
+            tokenProgram: vaultContext.index.tokenProgram,
+            buckets,
+            setupContext,
+        });
+    }
+    const vaultLookupTable = vaultContext.index.vaultLookupTable ?? web3_js_1.PublicKey.default;
+    if (!vaultLookupTable.equals(web3_js_1.PublicKey.default)) {
+        buckets.addressLookupTableAddresses.push(vaultLookupTable);
+    }
+    if (ix.action === vault_instruction_types_2.KaminoVaultAction.DEPOSIT) {
+        buckets.syncInstructions.push(buildKaminoVaultDepositInstruction({
+            owner: setupContext.owner,
+            kaminoVaultAddress: ix.vault,
+            vaultContext,
+            amount: ix.amount,
+            validationAccounts,
+        }));
+        if (isAutoManagePositionsEnabled(setupContext)) {
+            await queueKaminoVaultSharesTracking({
+                setupContext,
+                buckets,
+                kaminoVaultAddress: ix.vault,
+                vaultContext,
+            });
+        }
+        return;
+    }
+    buckets.syncInstructions.push(buildKaminoVaultWithdrawInstruction({
+        owner: setupContext.owner,
+        ix,
+        vaultContext,
+        validationAccounts,
+    }));
+}
+function getOptionalReadonlyAccountMeta(account, placeholderProgram) {
+    return {
+        pubkey: account ?? placeholderProgram,
+        isSigner: false,
+        isWritable: false,
+    };
+}
+async function resolveKaminoFarmContext(ix, setupContext) {
+    const farmInfo = await setupContext.connection.getAccountInfo(ix.farmState);
+    if (!farmInfo?.data) {
+        throw new Error(`Kamino farm not found: ${ix.farmState.toBase58()}`);
+    }
+    const farm = (0, kamino_farms_1.decodeKaminoFarmState)(Buffer.from(farmInfo.data));
+    const delegatee = ix.delegatee ?? setupContext.owner;
+    const userState = getKaminoFarmUserStateAddress(delegatee, ix.farmState);
+    const sourceAta = (0, spl_token_1.getAssociatedTokenAddressSync)(farm.underlyingMint, setupContext.owner, true, farm.tokenProgram);
+    return {
+        farm,
+        farmState: ix.farmState,
+        userState,
+        delegatee,
+        sourceAta,
+        scopePrices: (0, kamino_farms_1.getKaminoFarmScopePricesAddress)(farm),
+    };
+}
+function buildKaminoFarmInitializeUserRawInstruction(params) {
+    return new web3_js_1.TransactionInstruction({
+        programId: KAMINO_FARMS_PROGRAM_ID,
+        keys: [
+            { pubkey: params.owner, isSigner: true, isWritable: true },
+            { pubkey: params.owner, isSigner: true, isWritable: true },
+            { pubkey: params.owner, isSigner: false, isWritable: false },
+            { pubkey: params.delegatee, isSigner: false, isWritable: false },
+            { pubkey: params.userState, isSigner: false, isWritable: true },
+            { pubkey: params.farmState, isSigner: false, isWritable: true },
+            { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
+            { pubkey: web3_js_1.SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
+        ],
+        data: Buffer.from(policyBuilders_1.KAMINO_FARM_DISCRIMINATORS.initializeUser),
+    });
+}
+async function ensureKaminoFarmUserSetup(params) {
+    if (await accountExistsMaybeTracked(params.setupContext, params.farmContext.userState)) {
+        return;
+    }
+    const requiredLamports = await params.setupContext.connection.getMinimumBalanceForRentExemption(KAMINO_FARM_USER_STATE_SIZE);
+    const ownerLamports = await params.setupContext.connection.getBalance(params.setupContext.owner);
+    if (ownerLamports < requiredLamports) {
+        params.buckets.setupInstructions.push(web3_js_1.SystemProgram.transfer({
+            fromPubkey: params.setupContext.signer,
+            toPubkey: params.setupContext.owner,
+            lamports: requiredLamports - ownerLamports,
+        }));
+    }
+    params.buckets.syncInstructions.push(buildKaminoFarmInitializeUserRawInstruction({
+        owner: params.setupContext.owner,
+        delegatee: params.farmContext.delegatee,
+        userState: params.farmContext.userState,
+        farmState: params.farmContext.farmState,
+    }));
+    const state = await loadStrategySetupState(params.setupContext);
+    state?.existingAccounts.set(params.farmContext.userState.toBase58(), true);
+}
+function buildKaminoFarmStakeInstructionRaw(params) {
+    const amount = params.amount === "ALL" ? KAMINO_STAKE_ALL_AMOUNT : params.amount;
+    return new web3_js_1.TransactionInstruction({
+        programId: KAMINO_FARMS_PROGRAM_ID,
+        keys: [
+            { pubkey: params.owner, isSigner: true, isWritable: true },
+            { pubkey: params.farmContext.userState, isSigner: false, isWritable: true },
+            { pubkey: params.farmContext.farmState, isSigner: false, isWritable: true },
+            { pubkey: params.farmContext.farm.farmVault, isSigner: false, isWritable: true },
+            { pubkey: params.farmContext.sourceAta, isSigner: false, isWritable: true },
+            { pubkey: params.farmContext.farm.underlyingMint, isSigner: false, isWritable: false },
+            getOptionalReadonlyAccountMeta(params.farmContext.scopePrices, KAMINO_FARMS_PROGRAM_ID),
+            { pubkey: params.farmContext.farm.tokenProgram, isSigner: false, isWritable: false },
+        ],
+        data: encodeU64InstructionData(policyBuilders_1.KAMINO_FARM_DISCRIMINATORS.stake, amount),
+    });
+}
+function buildKaminoFarmUnstakeInstructionRaw(params) {
+    return new web3_js_1.TransactionInstruction({
+        programId: KAMINO_FARMS_PROGRAM_ID,
+        keys: [
+            { pubkey: params.owner, isSigner: true, isWritable: true },
+            { pubkey: params.farmContext.userState, isSigner: false, isWritable: true },
+            { pubkey: params.farmContext.farmState, isSigner: false, isWritable: true },
+            getOptionalReadonlyAccountMeta(params.farmContext.scopePrices, KAMINO_FARMS_PROGRAM_ID),
+        ],
+        data: encodeU128InstructionData(policyBuilders_1.KAMINO_FARM_DISCRIMINATORS.unstake, params.stakeSharesScaled),
+    });
+}
+function buildKaminoFarmWithdrawUnstakedDepositsRawInstruction(params) {
+    return new web3_js_1.TransactionInstruction({
+        programId: KAMINO_FARMS_PROGRAM_ID,
+        keys: [
+            { pubkey: params.owner, isSigner: true, isWritable: true },
+            { pubkey: params.farmContext.userState, isSigner: false, isWritable: true },
+            { pubkey: params.farmContext.farmState, isSigner: false, isWritable: true },
+            { pubkey: params.farmContext.sourceAta, isSigner: false, isWritable: true },
+            { pubkey: params.farmContext.farm.farmVault, isSigner: false, isWritable: true },
+            { pubkey: params.farmContext.farm.farmVaultsAuthority, isSigner: false, isWritable: false },
+            { pubkey: params.farmContext.farm.tokenProgram, isSigner: false, isWritable: false },
+        ],
+        data: Buffer.from(policyBuilders_1.KAMINO_FARM_DISCRIMINATORS.withdrawUnstakedDeposits),
+    });
+}
+function buildKaminoFarmHarvestRewardRawInstruction(params) {
+    const rewardInfo = params.farmContext.farm.rewardInfos[params.rewardIndex];
+    if (!rewardInfo) {
+        throw new Error(`Reward index ${params.rewardIndex} is out of range for Kamino farm ${params.farmContext.farmState.toBase58()}`);
+    }
+    return new web3_js_1.TransactionInstruction({
+        programId: KAMINO_FARMS_PROGRAM_ID,
+        keys: [
+            { pubkey: params.owner, isSigner: true, isWritable: true },
+            { pubkey: params.farmContext.userState, isSigner: false, isWritable: true },
+            { pubkey: params.farmContext.farmState, isSigner: false, isWritable: true },
+            { pubkey: params.farmContext.farm.globalConfig, isSigner: false, isWritable: false },
+            { pubkey: rewardInfo.rewardMint, isSigner: false, isWritable: false },
+            { pubkey: params.rewardAta, isSigner: false, isWritable: true },
+            { pubkey: rewardInfo.rewardsVault, isSigner: false, isWritable: true },
+            {
+                pubkey: (0, constants_1.getKaminoFarmsRewardsTreasuryVault)(rewardInfo.rewardMint, params.farmContext.farm.globalConfig, KAMINO_FARMS_PROGRAM_ID),
+                isSigner: false,
+                isWritable: true,
+            },
+            { pubkey: params.farmContext.farm.farmVaultsAuthority, isSigner: false, isWritable: false },
+            getOptionalReadonlyAccountMeta(params.farmContext.scopePrices, KAMINO_FARMS_PROGRAM_ID),
+            { pubkey: rewardInfo.tokenProgram, isSigner: false, isWritable: false },
+        ],
+        data: encodeU64InstructionData(policyBuilders_1.KAMINO_FARM_DISCRIMINATORS.harvestReward, params.rewardIndex),
+    });
+}
+async function buildKaminoFarmInstruction(ix, buckets, setupContext) {
+    const farmContext = await resolveKaminoFarmContext(ix, setupContext);
+    switch (ix.action) {
+        case vault_instruction_types_2.KaminoFarmAction.INITIALIZE_USER: {
+            if (farmContext.farm.isDelegated && !farmContext.delegatee.equals(setupContext.owner)) {
+                throw new Error(`Delegated Kamino farm initialization is not supported for ${ix.farmState.toBase58()}`);
+            }
+            await ensureKaminoFarmUserSetup({ farmContext, buckets, setupContext });
+            return;
+        }
+        case vault_instruction_types_2.KaminoFarmAction.STAKE: {
+            if (farmContext.farm.isDelegated) {
+                throw new Error(`Kamino farm ${ix.farmState.toBase58()} is delegated and cannot be staked directly`);
+            }
+            if (isAutoManagePositionsEnabled(setupContext)) {
+                await ensureKaminoFarmUserSetup({ farmContext, buckets, setupContext });
+                await ensureTrackedTokenAccountSetup({
+                    tokenMint: farmContext.farm.underlyingMint,
+                    tokenAccount: farmContext.sourceAta,
+                    tokenProgram: farmContext.farm.tokenProgram,
+                    buckets,
+                    setupContext,
+                });
+            }
+            buckets.syncInstructions.push(buildKaminoFarmStakeInstructionRaw({
+                owner: setupContext.owner,
+                farmContext,
+                amount: ix.amount,
+            }));
+            if (isAutoManagePositionsEnabled(setupContext)) {
+                const state = await loadStrategySetupState(setupContext);
+                if (state) {
+                    recordPlannedKaminoFarmPosition(state, {
+                        farmState: ix.farmState,
+                        userState: farmContext.userState,
+                        globalConfig: farmContext.farm.globalConfig,
+                        scopePrices: farmContext.scopePrices,
+                    });
+                }
+            }
+            return;
+        }
+        case vault_instruction_types_2.KaminoFarmAction.UNSTAKE: {
+            if (farmContext.farm.isDelegated) {
+                throw new Error(`Kamino farm ${ix.farmState.toBase58()} is delegated and cannot be unstaked directly`);
+            }
+            buckets.syncInstructions.push(buildKaminoFarmUnstakeInstructionRaw({
+                owner: setupContext.owner,
+                farmContext,
+                stakeSharesScaled: ix.stakeSharesScaled,
+            }));
+            return;
+        }
+        case vault_instruction_types_2.KaminoFarmAction.WITHDRAW_UNSTAKED_DEPOSITS: {
+            if (farmContext.farm.isDelegated) {
+                throw new Error(`Kamino farm ${ix.farmState.toBase58()} is delegated and cannot withdraw unstaked deposits directly`);
+            }
+            buckets.syncInstructions.push(buildKaminoFarmWithdrawUnstakedDepositsRawInstruction({
+                owner: setupContext.owner,
+                farmContext,
+            }));
+            return;
+        }
+        case vault_instruction_types_2.KaminoFarmAction.HARVEST_REWARD: {
+            const rewardInfo = farmContext.farm.rewardInfos[ix.rewardIndex];
+            if (!rewardInfo) {
+                throw new Error(`Reward index ${ix.rewardIndex} is out of range for Kamino farm ${ix.farmState.toBase58()}`);
+            }
+            const rewardAta = (0, spl_token_1.getAssociatedTokenAddressSync)(rewardInfo.rewardMint, setupContext.owner, true, rewardInfo.tokenProgram);
+            if (isAutoManagePositionsEnabled(setupContext)) {
+                await ensureTrackedTokenAccountSetup({
+                    tokenMint: rewardInfo.rewardMint,
+                    tokenAccount: rewardAta,
+                    tokenProgram: rewardInfo.tokenProgram,
+                    buckets,
+                    setupContext,
+                });
+            }
+            buckets.setupInstructions.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(setupContext.signer, rewardAta, setupContext.owner, rewardInfo.rewardMint, rewardInfo.tokenProgram));
+            buckets.syncInstructions.push(buildKaminoFarmHarvestRewardRawInstruction({
+                owner: setupContext.owner,
+                farmContext,
+                rewardIndex: ix.rewardIndex,
+                rewardAta,
+            }));
+            return;
+        }
+    }
+}
+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,
+    });
+    if (ix.addressLookupTableAddresses?.length) {
+        buckets.addressLookupTableAddresses.push(...ix.addressLookupTableAddresses);
+    }
+    buckets.syncInstructions.push(ix.instruction);
+}
+/**
+ * Loopscale account index mapping per instruction (from the Loopscale IDL).
+ * Actions not listed here (create_loan, close_loan, update_weight_matrix,
+ * create_strategy, close_strategy, lock_loan, unlock_loan, refinance_ledger,
+ * update_strategy) have no token accounts to track — the on-chain hook handles
+ * TrackLoopscaleLoan/UntrackLoopscaleLoan mutations.
+ */
+const LOOPSCALE_TOKEN_INDICES = {
+    [vault_instruction_types_2.LoopscaleAction.DEPOSIT_COLLATERAL]: { mint: 6, account: 4, program: 9 },
+    [vault_instruction_types_2.LoopscaleAction.BORROW_PRINCIPAL]: { mint: 6, account: 7, program: 10 },
+    [vault_instruction_types_2.LoopscaleAction.REPAY_PRINCIPAL]: { mint: 6, account: 7, program: 10 },
+    [vault_instruction_types_2.LoopscaleAction.WITHDRAW_COLLATERAL]: { mint: 7, account: 4, program: 8 },
+    [vault_instruction_types_2.LoopscaleAction.DEPOSIT_STRATEGY]: { mint: 4, account: 6, program: 8 },
+    [vault_instruction_types_2.LoopscaleAction.WITHDRAW_STRATEGY]: { mint: 4, account: 6, program: 9 },
+};
+/** Build a single Loopscale instruction (loan or strategy). Extracts token accounts for tracking. */
+async function buildLoopscaleInstruction(ix, buckets, setupContext) {
+    const indices = LOOPSCALE_TOKEN_INDICES[ix.action];
+    if (indices) {
+        const tokenMint = ix.instruction.keys[indices.mint]?.pubkey;
+        const tokenAccount = ix.instruction.keys[indices.account]?.pubkey;
+        const tokenProgram = ix.instruction.keys[indices.program]?.pubkey;
+        if (!tokenMint || !tokenAccount || !tokenProgram) {
+            throw new Error(`Loopscale ${ix.action} instruction is missing expected token accounts`);
+        }
+        await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
+    }
+    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 vault_instruction_types_2.OrderbookAction.POST_OFFER:
+            await buildPostOffer(ix, orderbook, owner, setupContext?.signer ?? owner, buckets, setupContext);
+            break;
+        case vault_instruction_types_2.OrderbookAction.MARKET_OFFER:
+            await buildMarketOffer(ix, orderbook, owner, setupContext?.signer ?? owner, buckets, setupContext);
+            break;
+        case vault_instruction_types_2.OrderbookAction.REMOVE_OFFER:
+            await buildRemoveOffer(ix, orderbook, owner, buckets);
+            break;
+        case vault_instruction_types_2.OrderbookAction.WITHDRAW_FUNDS:
+            await buildWithdrawFunds(ix, orderbook, owner, buckets);
+            break;
+    }
+}
+// ============================================================================
+// Action Builders (one per VaultAction)
+// ============================================================================
+function createKaminoInitUserMetadataInstruction(owner) {
+    const userMetadata = (0, constants_1.getKaminoUserMetadata)(owner, policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
+    return (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,
+    });
+}
+function createKaminoInitObligationInstruction(params) {
+    const lendingMarket = kamino_markets_1.KAMINO_MARKETS[params.market];
+    const obligation = (0, constants_1.getKaminoLendObligation)(params.owner, lendingMarket, policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
+    const userMetadata = (0, constants_1.getKaminoUserMetadata)(params.owner, policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
+    return (0, instructions_1.initObligation)({ args: { tag: 0, id: 0 } }, {
+        obligationOwner: params.owner,
+        feePayer: params.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 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(createKaminoInitUserMetadataInstruction(owner));
+}
+async function buildInitObligation(ix, owner, connection, { syncInstructions, postInstructions }, setupContext) {
+    const lendingMarket = kamino_markets_1.KAMINO_MARKETS[ix.market];
+    const obligation = (0, constants_1.getKaminoLendObligation)(owner, lendingMarket, policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
+    const obligationAccount = await connection.getAccountInfo(obligation);
+    if (obligationAccount)
+        return;
+    syncInstructions.push(createKaminoInitObligationInstruction({ market: ix.market, owner }));
+    if (setupContext && isAutoManagePositionsEnabled(setupContext)) {
+        await queueKaminoObligationTrackingAfterInit({
+            market: ix.market,
+            obligation,
+            postInstructions,
+            setupContext,
+        });
+    }
+}
+async function queueKaminoObligationTrackingAfterInit(params) {
+    const state = await loadStrategySetupState(params.setupContext);
+    if (!state || state.trackedKaminoObligations.has(params.obligation.toBase58())) {
+        return;
+    }
+    const quotePath = (0, pricePathResolver_1.resolveBestKaminoQuotePath)({
+        prices: state.prices,
+        vaultUnderlyingMint: state.strategyVault.state.underlyingMint,
+    });
+    trackRequiredPriceIds(state.requiredPriceIds, quotePath.quotePriceId);
+    const remainingAccountsAmount = 1n;
+    const obligationEntry = {
+        obligation: params.obligation,
+        lendingProgramId: policyBuilders_1.KAMINO_LENDING_PROGRAM_ID,
+        quotePriceId: quotePath.quotePriceId,
+        reservePriceMappings: [],
+        reserveFarmMappings: [],
+        minPriceStatusFlags: 0,
+    };
+    params.postInstructions.push(state.strategyVault.ixWrapperManagerUpdatePosition({
+        manager: params.setupContext.signer,
+        update: exponentVaults.positionUpdate("AddKaminoObligationEntry", [obligationEntry]),
+        remainingAccounts: buildTrackedAumRemainingAccounts(state, [
+            { pubkey: params.obligation, isSigner: false, isWritable: false },
+        ]),
+    }));
+    recordPlannedKaminoObligation(state, {
+        obligation: params.obligation,
+        quotePriceId: quotePath.quotePriceId,
+        quoteInputMint: quotePath.quoteInputMint,
+        reservePriceMappings: [],
+        remainingAccountsAmount,
+        minPriceStatusFlags: 0,
+    });
+}
+async function ensureKaminoObligationSetup(params) {
+    const { ix, reserveContext, buckets, setupContext } = params;
+    if (!setupContext || !isAutoManagePositionsEnabled(setupContext)) {
+        return;
+    }
+    const state = await loadStrategySetupState(setupContext);
+    if (!state) {
+        return;
+    }
+    // Ensure user metadata exists
+    const userMetadata = (0, constants_1.getKaminoUserMetadata)(setupContext.owner, policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
+    if (!(await accountExists(state, setupContext.connection, userMetadata))) {
+        buckets.setupInstructions.push(await wrapVaultSignedSetupInstruction({
+            instruction: createKaminoInitUserMetadataInstruction(setupContext.owner),
+            setupContext,
+        }));
+        state.existingAccounts.set(userMetadata.toBase58(), true);
+    }
+    // Ensure obligation exists and is tracked
+    const obligationKey = reserveContext.obligation.toBase58();
+    const obligationExistsOnChain = await accountExists(state, setupContext.connection, reserveContext.obligation);
+    const trackedObligation = state.trackedKaminoObligations.get(obligationKey);
+    if (!trackedObligation) {
+        if (obligationExistsOnChain) {
+            throw new Error(`Kamino obligation ${obligationKey} already exists on-chain but is not tracked on vault ${state.strategyVault.selfAddress.toBase58()}. Automatic repair is disabled; manually add the Kamino obligation entry.`);
+        }
+        buckets.setupInstructions.push(await wrapVaultSignedSetupInstruction({
+            instruction: createKaminoInitObligationInstruction({ market: ix.market, owner: setupContext.owner }),
+            setupContext,
+        }));
+        state.existingAccounts.set(obligationKey, true);
+        const quotePath = (0, pricePathResolver_1.resolveBestKaminoQuotePath)({
+            prices: state.prices,
+            vaultUnderlyingMint: state.strategyVault.state.underlyingMint,
+        });
+        const reservePriceMapping = {
+            reserve: reserveContext.reservePubkey,
+            reservePriceId: (0, pricePathResolver_1.resolveKaminoReservePriceIdOrThrow)({
+                prices: state.prices,
+                reserveMint: reserveContext.reserveAccount.liquidity.mintPubkey,
+                quoteInputMint: quotePath.quoteInputMint,
+            }),
+        };
+        trackRequiredPriceIds(state.requiredPriceIds, quotePath.quotePriceId);
+        trackRequiredPriceIds(state.requiredPriceIds, reservePriceMapping.reservePriceId);
+        const remainingAccountsAmount = BigInt(1 + 1);
+        const obligationEntry = {
+            obligation: reserveContext.obligation,
+            lendingProgramId: policyBuilders_1.KAMINO_LENDING_PROGRAM_ID,
+            quotePriceId: quotePath.quotePriceId,
+            reservePriceMappings: [reservePriceMapping],
+            reserveFarmMappings: [],
+            minPriceStatusFlags: 0,
+        };
+        buckets.setupInstructions.push(state.strategyVault.ixWrapperManagerUpdatePosition({
+            manager: setupContext.signer,
+            update: exponentVaults.positionUpdate("AddKaminoObligationEntry", [obligationEntry]),
+            remainingAccounts: buildTrackedAumRemainingAccounts(state, [
+                { pubkey: reserveContext.obligation, isSigner: false, isWritable: false },
+                { pubkey: reserveContext.reservePubkey, isSigner: false, isWritable: false },
+            ]),
+        }));
+        recordPlannedKaminoObligation(state, {
+            obligation: reserveContext.obligation,
+            quotePriceId: quotePath.quotePriceId,
+            quoteInputMint: quotePath.quoteInputMint,
+            reservePriceMappings: [reservePriceMapping],
+            remainingAccountsAmount,
+            minPriceStatusFlags: 0,
+        });
+        return;
+    }
+    // Obligation exists and is tracked — ensure the reserve is mapped
+    await ensureKaminoReserveMapped({
+        state,
+        reserveContext,
+        setupContext,
+        buckets,
+        trackedObligation,
+    });
+}
+/** Ensure a Kamino reserve is mapped on an already-tracked obligation. */
+async function ensureKaminoReserveMapped(params) {
+    const { state, reserveContext, setupContext, buckets, trackedObligation } = params;
+    if (trackedObligation.mappedReserves.has(reserveContext.reservePubkey.toBase58())) {
+        return;
+    }
+    const reservePriceMapping = {
+        reserve: reserveContext.reservePubkey,
+        reservePriceId: (0, pricePathResolver_1.resolveKaminoReservePriceIdOrThrow)({
+            prices: state.prices,
+            reserveMint: reserveContext.reserveAccount.liquidity.mintPubkey,
+            quoteInputMint: trackedObligation.quoteInputMint,
+        }),
+    };
+    trackRequiredPriceIds(state.requiredPriceIds, reservePriceMapping.reservePriceId);
+    buckets.setupInstructions.push(...await buildKaminoPositionFreshnessInstructions({
+        reservePubkey: reserveContext.reservePubkey,
+        reserveAccount: reserveContext.reserveAccount,
+        lendingMarket: reserveContext.lendingMarket,
+        obligation: reserveContext.obligation,
+        connection: setupContext.connection,
+    }));
+    buckets.setupInstructions.push(state.strategyVault.ixWrapperManagerUpdatePosition({
+        manager: setupContext.signer,
+        update: exponentVaults.positionUpdate("UpsertKaminoObligationReservePriceMappings", {
+            obligation: reserveContext.obligation,
+            reservePriceMappings: [reservePriceMapping],
+            reserveFarmMappings: [],
+        }),
+        remainingAccounts: buildTrackedAumRemainingAccounts(state, [
+            { pubkey: reserveContext.reservePubkey, isSigner: false, isWritable: false },
+        ]),
+    }));
+    recordPlannedKaminoReserveMappings(state, {
+        obligation: reserveContext.obligation,
+        quoteInputMint: trackedObligation.quoteInputMint,
+        reservePriceMappings: [reservePriceMapping],
+    });
+}
+async function buildKaminoPositionFreshnessInstructions({ reservePubkey, reserveAccount, lendingMarket, obligation, connection, }) {
+    const instructions = [];
+    const defaultKey = web3_js_1.PublicKey.default;
+    const oracleOrSentinel = (key) => key.equals(defaultKey) ? policyBuilders_1.KAMINO_LENDING_PROGRAM_ID : key;
+    const obligationState = await accounts_1.Obligation.fetch(connection, obligation);
+    const otherReservePubkeys = [];
+    if (obligationState) {
+        for (const deposit of obligationState.deposits) {
+            if (!deposit.depositReserve.equals(defaultKey) && !deposit.depositReserve.equals(reservePubkey)) {
+                otherReservePubkeys.push(deposit.depositReserve);
+            }
+        }
+        for (const borrow of obligationState.borrows) {
+            if (!borrow.borrowReserve.equals(defaultKey) && !borrow.borrowReserve.equals(reservePubkey)) {
+                otherReservePubkeys.push(borrow.borrowReserve);
+            }
+        }
+    }
+    const otherReserves = [];
+    for (const otherReservePubkey of otherReservePubkeys) {
+        const otherReserveAccount = await kamino_reserve_deserializer_1.Reserve.fetch(connection, otherReservePubkey);
+        if (!otherReserveAccount) {
+            continue;
+        }
+        otherReserves.push({ pubkey: otherReservePubkey, account: otherReserveAccount });
+    }
+    for (const { pubkey, account } of otherReserves) {
+        const tokenInfo = account.config.tokenInfo;
+        instructions.push((0, instructions_1.refreshReserve)({
+            reserve: pubkey,
+            lendingMarket,
+            pythOracle: oracleOrSentinel(tokenInfo.pythConfiguration.price),
+            switchboardPriceOracle: oracleOrSentinel(tokenInfo.switchboardConfiguration.priceAggregator),
+            switchboardTwapOracle: oracleOrSentinel(tokenInfo.switchboardConfiguration.twapAggregator),
+            scopePrices: oracleOrSentinel(tokenInfo.scopeConfiguration.priceFeed),
+        }));
+    }
+    const tokenInfo = reserveAccount.config.tokenInfo;
+    instructions.push((0, instructions_1.refreshReserve)({
+        reserve: reservePubkey,
+        lendingMarket,
+        pythOracle: oracleOrSentinel(tokenInfo.pythConfiguration.price),
+        switchboardPriceOracle: oracleOrSentinel(tokenInfo.switchboardConfiguration.priceAggregator),
+        switchboardTwapOracle: oracleOrSentinel(tokenInfo.switchboardConfiguration.twapAggregator),
+        scopePrices: oracleOrSentinel(tokenInfo.scopeConfiguration.priceFeed),
+    }));
+    const refreshObligationIx = (0, instructions_1.refreshObligation)({ lendingMarket, obligation });
+    if (obligationState) {
+        const depositReserves = obligationState.deposits
+            .map((deposit) => deposit.depositReserve)
+            .filter((reserve) => !reserve.equals(defaultKey));
+        const borrowReserves = obligationState.borrows
+            .map((borrow) => borrow.borrowReserve)
+            .filter((reserve) => !reserve.equals(defaultKey));
+        for (const reserve of [...depositReserves, ...borrowReserves]) {
+            refreshObligationIx.keys.push({ pubkey: reserve, isSigner: false, isWritable: false });
+        }
+    }
+    instructions.push(refreshObligationIx);
+    return instructions;
+}
+async function buildDeposit(ix, owner, connection, signer, { setupInstructions, syncInstructions, preInstructions, postInstructions }, setupContext) {
+    const ctx = await resolveReserveContext(ix, owner, connection);
+    await ensureKaminoObligationSetup({ ix, reserveContext: ctx, buckets: { setupInstructions, syncInstructions, preInstructions, postInstructions, signers: [], addressLookupTableAddresses: [] }, setupContext });
+    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 }, setupContext) {
+    const ctx = await resolveReserveContext(ix, owner, connection);
+    await ensureKaminoObligationSetup({ ix, reserveContext: ctx, buckets: { setupInstructions, syncInstructions, preInstructions, postInstructions, signers: [], addressLookupTableAddresses: [] }, setupContext });
+    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 }, setupContext) {
+    const ctx = await resolveReserveContext(ix, owner, connection);
+    await ensureKaminoObligationSetup({ ix, reserveContext: ctx, buckets: { setupInstructions, syncInstructions, preInstructions, postInstructions, signers: [], addressLookupTableAddresses: [] }, setupContext });
+    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 }, setupContext) {
+    const ctx = await resolveReserveContext(ix, owner, connection);
+    await ensureKaminoObligationSetup({ ix, reserveContext: ctx, buckets: { setupInstructions, syncInstructions, preInstructions, postInstructions, signers: [], addressLookupTableAddresses: [] }, setupContext });
+    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
+     */
+    postOffer(params) {
+        return {
+            action: vault_instruction_types_2.OrderbookAction.POST_OFFER,
+            orderbook: params.orderbook,
+            mode: params.mode,
+            direction: params.direction,
+            priceApy: params.priceApy,
+            amount: params.amount,
+            offerOption: params.offerOption,
+            expirySeconds: params.expirySeconds,
+        };
+    },
+    /**
+     * Execute a market order on the orderbook.
+     * @param params - Order parameters
+     */
+    marketOffer(params) {
+        return {
+            action: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.OrderbookAction.WITHDRAW_FUNDS,
+            orderbook: params.orderbook,
+            ptAmount: params.ptAmount,
+            ytAmount: params.ytAmount,
+            syAmount: params.syAmount,
+        };
+    },
+};
+exports.syAction = {
+    mint(params) {
+        return {
+            action: vault_instruction_types_2.SyAction.MINT,
+            vault: params.vault,
+            amountBase: params.amountBase,
+        };
+    },
+    redeem(params) {
+        return {
+            action: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.CoreAction.DEPOSIT_YT,
+            vault: params.vault,
+            amountYt: params.amountYt,
+        };
+    },
+    /**
+     * Initialize yield position for the Squads vault (owner).
+     * Required before buying YT or depositing YT. When `autoManagePositions`
+     * is enabled, the SDK also tracks the new yield position automatically.
+     */
+    initializeYieldPosition(params) {
+        return {
+            action: vault_instruction_types_2.CoreAction.INITIALIZE_YIELD_POSITION,
+            vault: params.vault,
+        };
+    },
+};
+/**
+ * Convert trade direction to OfferType used by the orderbook program.
+ */
+function directionToOfferType(direction) {
+    switch (direction) {
+        case vault_instruction_types_2.OrderbookTradeDirection.BUY_PT:
+        case vault_instruction_types_2.OrderbookTradeDirection.SELL_YT:
+            return orderbook_2.OfferType.SellYt;
+        case vault_instruction_types_2.OrderbookTradeDirection.SELL_PT:
+        case vault_instruction_types_2.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, }) {
+    vaultPda ??= owner;
+    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";
+    const offerIdx = orderbook.getNextOfferIndex();
+    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: true,
+            expirySeconds: ix.expirySeconds ?? 3600,
+            mintSy: orderbook.vault.mintSy,
+            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: true,
+        expirySeconds: ix.expirySeconds ?? 3600,
+        mintSy: orderbook.vault.mintSy,
+        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)
+// ============================================================================
+async function queueYieldPositionTrackingAfterInit(params) {
+    const state = await loadStrategySetupState(params.setupContext);
+    if (!state || state.trackedYieldVaults.has(params.vault.selfAddress.toBase58())) {
+        return;
+    }
+    const yieldPosition = params.vault.pda.yieldPosition({
+        owner: params.setupContext.owner,
+        vault: params.vault.selfAddress,
+    });
+    const priceIdPt = (0, pricePathResolver_1.resolvePriceIdFromMintToUnderlyingOrThrow)({
+        prices: state.prices,
+        sourceMint: params.vault.mintPt,
+        targetMint: state.strategyVault.state.underlyingMint,
+        label: `yield position setup (${params.vault.selfAddress.toBase58()})`,
+    });
+    trackRequiredPriceIds(state.requiredPriceIds, priceIdPt);
+    params.postInstructions.push(state.strategyVault.ixWrapperManageVaultSettings({
+        manager: params.setupContext.signer,
+        actions: [
+            exponentVaults.vaultSettingsAction("AddYieldPositionEntry", {
+                yieldPosition,
+                vault: params.vault.selfAddress,
+                priceIdPt,
+            }),
+        ],
+        remainingAccounts: [
+            { pubkey: params.vault.selfAddress, isSigner: false, isWritable: false },
+            { pubkey: yieldPosition, isSigner: false, isWritable: false },
+        ],
+    }));
+    recordPlannedYieldPosition(state, {
+        yieldPosition,
+        vault: params.vault.selfAddress,
+        priceIdPt,
+    });
+}
+/** 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 === vault_instruction_types_2.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 === vault_instruction_types_2.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 vault_instruction_types_2.CoreAction.STRIP:
+            await buildStrip(ix, vault, owner, setupContext?.signer ?? owner, buckets);
+            break;
+        case vault_instruction_types_2.CoreAction.MERGE:
+            await buildMerge(ix, vault, owner, setupContext?.signer ?? owner, buckets);
+            break;
+        case vault_instruction_types_2.CoreAction.WITHDRAW_YT:
+            await buildWithdrawYt(ix, vault, owner, setupContext?.signer ?? owner, buckets);
+            break;
+        case vault_instruction_types_2.CoreAction.DEPOSIT_YT:
+            await buildDepositYt(ix, vault, owner, buckets);
+            break;
+        case vault_instruction_types_2.CoreAction.INITIALIZE_YIELD_POSITION:
+            await buildInitializeYieldPosition(ix, vault, owner, buckets, setupContext);
+            break;
+    }
+}
+async function buildInitializeYieldPosition(ix, vault, owner, { syncInstructions, postInstructions }, setupContext) {
+    const initIx = vault.ixInitializeYieldPosition({ owner });
+    syncInstructions.push(initIx);
+    if (setupContext && isAutoManagePositionsEnabled(setupContext)) {
+        await queueYieldPositionTrackingAfterInit({
+            vault,
+            setupContext,
+            postInstructions,
+        });
+    }
+}
+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 vault_instruction_types_2.SyAction.MINT:
+            buckets.syncInstructions.push(await vault.flavor.ixMintSy({
+                amountBase: ix.amountBase.toString(),
+                depositor: owner,
+                depositorBaseTokenAccount: baseTokenAccount,
+                depositorSyTokenAccount: syTokenAccount,
+            }));
+            break;
+        case vault_instruction_types_2.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
+     * @param params.addressLookupTableAddresses - Optional ALT addresses returned by Titan for this route
+     */
+    swap(params) {
+        return {
+            action: vault_instruction_types_2.TitanAction.SWAP,
+            instruction: params.instruction,
+            addressLookupTableAddresses: params.addressLookupTableAddresses,
+        };
+    },
+};
+// ============================================================================
+// Loopscale Action Builder
+// ============================================================================
+/**
+ * Builder for Loopscale action descriptors used in Exponent sync transactions.
+ *
+ * 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: vault_instruction_types_2.LoopscaleAction.CREATE_LOAN, instruction: params.instruction };
+    },
+    depositCollateral(params) {
+        return { action: vault_instruction_types_2.LoopscaleAction.DEPOSIT_COLLATERAL, instruction: params.instruction };
+    },
+    borrowPrincipal(params) {
+        return { action: vault_instruction_types_2.LoopscaleAction.BORROW_PRINCIPAL, instruction: params.instruction };
+    },
+    repayPrincipal(params) {
+        return { action: vault_instruction_types_2.LoopscaleAction.REPAY_PRINCIPAL, instruction: params.instruction };
+    },
+    withdrawCollateral(params) {
+        return { action: vault_instruction_types_2.LoopscaleAction.WITHDRAW_COLLATERAL, instruction: params.instruction };
+    },
+    closeLoan(params) {
+        return { action: vault_instruction_types_2.LoopscaleAction.CLOSE_LOAN, instruction: params.instruction };
+    },
+    /** Assign collateral fractions to ledgers (BORROWER side). Must call before borrow_principal. */
+    updateWeightMatrix(params) {
+        return { action: vault_instruction_types_2.LoopscaleAction.UPDATE_WEIGHT_MATRIX, instruction: params.instruction };
+    },
+    createStrategy(params) {
+        return { action: vault_instruction_types_2.LoopscaleAction.CREATE_STRATEGY, instruction: params.instruction };
+    },
+    depositStrategy(params) {
+        return { action: vault_instruction_types_2.LoopscaleAction.DEPOSIT_STRATEGY, instruction: params.instruction };
+    },
+    withdrawStrategy(params) {
+        return { action: vault_instruction_types_2.LoopscaleAction.WITHDRAW_STRATEGY, instruction: params.instruction };
+    },
+    closeStrategy(params) {
+        return { action: vault_instruction_types_2.LoopscaleAction.CLOSE_STRATEGY, instruction: params.instruction };
+    },
+    /** Configure collateral terms on a strategy (LENDER side). */
+    updateStrategy(params) {
+        return { action: vault_instruction_types_2.LoopscaleAction.UPDATE_STRATEGY, instruction: params.instruction };
+    },
+    /** Lock loan before borrow_principal (BORROWER side). Must be in same tx as unlock. */
+    lockLoan(params) {
+        return { action: vault_instruction_types_2.LoopscaleAction.LOCK_LOAN, instruction: params.instruction };
+    },
+    /** Unlock loan after borrow_principal (BORROWER side). Runs health check. */
+    unlockLoan(params) {
+        return { action: vault_instruction_types_2.LoopscaleAction.UNLOCK_LOAN, instruction: params.instruction };
+    },
+    /** Refinance a loan ledger from one strategy to another (BORROWER side). */
+    refinanceLedger(params) {
+        return { action: vault_instruction_types_2.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`. When
+     * `autoManagePositions` is enabled, the SDK also tracks the new LP
+     * position automatically after the deposit sync instruction succeeds.
+     *
+     * @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: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.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: vault_instruction_types_2.ClmmAction.CLAIM_FARM_EMISSION, ...params };
+    },
+};
+// ============================================================================
+// Internal: CLMM Instruction Resolution
+// ============================================================================
+/** Cache for loaded MarketThree instances to avoid redundant fetches. */
+const marketThreeCache = new Map();
+async function ensureTrackedClmmPosition(params) {
+    if (!params.setupContext || !isAutoManagePositionsEnabled(params.setupContext)) {
+        return;
+    }
+    const state = await loadStrategySetupState(params.setupContext);
+    if (!state || state.trackedClmmPositions.has(params.lpPosition.toBase58())) {
+        return;
+    }
+    const existsOnChain = await accountExists(state, params.setupContext.connection, params.lpPosition);
+    if (existsOnChain) {
+        throw new Error(`CLMM lp position ${params.lpPosition.toBase58()} already exists on-chain but is not tracked on vault ${state.strategyVault.selfAddress.toBase58()}. Automatic repair is disabled; manually add the CLMM position entry.`);
+    }
+    throw new Error(`CLMM lp position ${params.lpPosition.toBase58()} is not tracked on vault ${state.strategyVault.selfAddress.toBase58()}. Create it with clmmAction.depositLiquidity() through this SDK flow or manually add the position entry.`);
+}
+async function queueClmmPositionTrackingAfterDeposit(params) {
+    if (!params.setupContext || !isAutoManagePositionsEnabled(params.setupContext)) {
+        return;
+    }
+    const state = await loadStrategySetupState(params.setupContext);
+    if (!state || state.trackedClmmPositions.has(params.lpPosition.toBase58())) {
+        return;
+    }
+    const priceIdPt = (0, pricePathResolver_1.resolvePriceIdFromMintToUnderlyingOrThrow)({
+        prices: state.prices,
+        sourceMint: params.market.mintPt,
+        targetMint: state.strategyVault.state.underlyingMint,
+        label: `CLMM PT position setup (${params.market.selfAddress.toBase58()})`,
+    });
+    trackRequiredPriceIds(state.requiredPriceIds, priceIdPt);
+    const priceIdSy = (0, pricePathResolver_1.resolvePriceIdFromMintToUnderlyingOrThrow)({
+        prices: state.prices,
+        sourceMint: params.market.mintSy,
+        targetMint: state.strategyVault.state.underlyingMint,
+        label: `CLMM SY position setup (${params.market.selfAddress.toBase58()})`,
+    });
+    trackRequiredPriceIds(state.requiredPriceIds, priceIdSy);
+    params.postInstructions.push(state.strategyVault.ixWrapperManageVaultSettings({
+        manager: params.setupContext.signer,
+        actions: [exponentVaults.vaultSettingsAction("AddClmmPositionEntry", [{
+                    lpPosition: params.lpPosition,
+                    market: params.market.selfAddress,
+                    priceIdPt,
+                    priceIdSy,
+                }])],
+        remainingAccounts: [
+            { pubkey: params.lpPosition, isSigner: false, isWritable: false },
+            { pubkey: params.market.selfAddress, isSigner: false, isWritable: false },
+        ],
+    }));
+    recordPlannedClmmPosition(state, {
+        lpPosition: params.lpPosition,
+        market: params.market.selfAddress,
+        priceIdPt,
+        priceIdSy,
+        ticksKey: params.market.ticksKey,
+    });
+}
+/**
+ * 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 vault_instruction_types_2.ClmmAction.DEPOSIT_LIQUIDITY:
+            await buildClmmDepositLiquidity(ix, market, owner, buckets, setupContext);
+            break;
+        case vault_instruction_types_2.ClmmAction.ADD_LIQUIDITY:
+            await ensureTrackedClmmPosition({ lpPosition: ix.lpPosition, setupContext });
+            buildClmmAddLiquidity(ix, market, owner, buckets);
+            break;
+        case vault_instruction_types_2.ClmmAction.WITHDRAW_LIQUIDITY:
+            await ensureTrackedClmmPosition({ lpPosition: ix.lpPosition, setupContext });
+            buildClmmWithdrawLiquidity(ix, market, owner, buckets);
+            break;
+        case vault_instruction_types_2.ClmmAction.TRADE_PT:
+            buildClmmTradePt(ix, market, owner, buckets);
+            break;
+        case vault_instruction_types_2.ClmmAction.BUY_PT:
+            buildClmmBuyPt(ix, market, owner, buckets);
+            break;
+        case vault_instruction_types_2.ClmmAction.SELL_PT:
+            buildClmmSellPt(ix, market, owner, buckets);
+            break;
+        case vault_instruction_types_2.ClmmAction.BUY_YT:
+            await buildClmmBuyYt(ix, market, owner, buckets, setupContext);
+            break;
+        case vault_instruction_types_2.ClmmAction.SELL_YT:
+            await buildClmmSellYt(ix, market, owner, buckets, setupContext);
+            break;
+        case vault_instruction_types_2.ClmmAction.CLAIM_FARM_EMISSION:
+            await ensureTrackedClmmPosition({ lpPosition: ix.lpPosition, setupContext });
+            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.
+ */
+async function buildClmmDepositLiquidity(ix, market, owner, buckets, setupContext) {
+    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);
+    await queueClmmPositionTrackingAfterDeposit({
+        market,
+        lpPosition: lpPositionKeypair.publicKey,
+        postInstructions: buckets.postInstructions,
+        setupContext,
+    });
+}
+/** 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,
+        payer: setupContext?.signer,
+        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,
+        payer: setupContext?.signer,
+        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