@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/build/exponentVaults/vault-interaction.js

@@ -26,14 +26,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwapDirection = exports.clmmAction = exports.loopscaleAction = exports.titanAction = exports.createOrderbookSyncTransaction = exports.coreAction = exports.syAction = exports.orderbookAction = exports.createVaultSyncTransaction = exports.kaminoAction = exports.ClmmAction = exports.LoopscaleAction = exports.TitanAction = exports.SyAction = exports.CoreAction = exports.OrderbookAction = exports.OrderbookTradeDirection = exports.VaultAction = void 0;
+exports.SwapDirection = exports.clmmAction = exports.loopscaleAction = exports.titanAction = exports.createOrderbookSyncTransaction = exports.coreAction = exports.syAction = exports.orderbookAction = exports.__kaminoVaultTesting = exports.buildSetupStatePriceRefreshInstructions = exports.createStrategySetupContext = exports.createVaultSyncTransaction = exports.createVaultSyncTransactions = 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 anchor_1 = require("@coral-xyz/anchor");
 const kamino_reserve_deserializer_1 = require("@exponent-labs/kamino-reserve-deserializer");
+const exponent_fetcher_1 = require("@exponent-labs/exponent-fetcher");
+const kamino_vault_idl_1 = require("@exponent-labs/kamino-vault-idl");
 const kamino_markets_1 = require("./kamino-markets");
 const decimal_js_1 = __importDefault(require("decimal.js"));
 const constants_1 = require("./../../../kamino-lend-standard/src/constants");
 const policyBuilders_1 = require("./policyBuilders");
 const accounts_1 = require("@exponent-labs/klend-idl/accounts");
-const precise_number_1 = require("@exponent-labs/precise-number");
 const orderbook_1 = require("../orderbook/orderbook");
 const marketThree_1 = require("../marketThree");
 const utils_1 = require("../utils");
@@ -44,8 +46,11 @@ const exponentVaults = __importStar(require("../client/vaults"));
 const orderbook_2 = require("../client/orderbook");
 const environment_1 = require("../environment");
 const vault_1 = require("../vault");
-const ytPosition_1 = require("../ytPosition");
 const vault_2 = require("./vault");
+const 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");
@@ -54,109 +59,28 @@ const scope_refresh_1 = require("./scope-refresh");
 const web3_js_1 = require("@solana/web3.js");
 const bn_js_1 = __importDefault(require("bn.js"));
 const KAMINO_FARMS_PROGRAM_ID = new web3_js_1.PublicKey("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr");
-/** Actions that can be performed through the vault instruction builder. */
-var VaultAction;
-(function (VaultAction) {
-    VaultAction["INIT_USER_METADATA"] = "INIT_USER_METADATA";
-    VaultAction["INIT_OBLIGATION"] = "INIT_OBLIGATION";
-    VaultAction["DEPOSIT"] = "DEPOSIT";
-    VaultAction["WITHDRAW"] = "WITHDRAW";
-    VaultAction["BORROW"] = "BORROW";
-    VaultAction["REPAY"] = "REPAY";
-})(VaultAction || (exports.VaultAction = VaultAction = {}));
-// ============================================================================
-// Orderbook Instruction Types
-// ============================================================================
-/** Orderbook trade direction */
-var OrderbookTradeDirection;
-(function (OrderbookTradeDirection) {
-    OrderbookTradeDirection["BUY_PT"] = "BUY_PT";
-    OrderbookTradeDirection["SELL_PT"] = "SELL_PT";
-    OrderbookTradeDirection["BUY_YT"] = "BUY_YT";
-    OrderbookTradeDirection["SELL_YT"] = "SELL_YT";
-})(OrderbookTradeDirection || (exports.OrderbookTradeDirection = OrderbookTradeDirection = {}));
-/** Actions that can be performed on the Exponent Orderbook */
-var OrderbookAction;
-(function (OrderbookAction) {
-    OrderbookAction["POST_OFFER"] = "POST_OFFER";
-    OrderbookAction["MARKET_OFFER"] = "MARKET_OFFER";
-    OrderbookAction["REMOVE_OFFER"] = "REMOVE_OFFER";
-    OrderbookAction["WITHDRAW_FUNDS"] = "WITHDRAW_FUNDS";
-})(OrderbookAction || (exports.OrderbookAction = OrderbookAction = {}));
-// ============================================================================
-// Core Instruction Types (Strip/Merge)
-// ============================================================================
-/** Actions that can be performed on Exponent Core */
-var CoreAction;
-(function (CoreAction) {
-    CoreAction["STRIP"] = "STRIP";
-    CoreAction["MERGE"] = "MERGE";
-    CoreAction["WITHDRAW_YT"] = "WITHDRAW_YT";
-    CoreAction["DEPOSIT_YT"] = "DEPOSIT_YT";
-    CoreAction["INITIALIZE_YIELD_POSITION"] = "INITIALIZE_YIELD_POSITION";
-})(CoreAction || (exports.CoreAction = CoreAction = {}));
-// ============================================================================
-// Standard Program Instruction Types (mint_sy / redeem_sy)
-// ============================================================================
-var SyAction;
-(function (SyAction) {
-    SyAction["MINT"] = "MINT_SY";
-    SyAction["REDEEM"] = "REDEEM_SY";
-})(SyAction || (exports.SyAction = SyAction = {}));
-// ============================================================================
-// Titan Instruction Types
-// ============================================================================
-var TitanAction;
-(function (TitanAction) {
-    TitanAction["SWAP"] = "SWAP";
-})(TitanAction || (exports.TitanAction = TitanAction = {}));
-// ============================================================================
-// Loopscale Instruction Types
-// ============================================================================
-/** Actions for Loopscale interactions (loans = borrower side, strategies = lender side). */
-var LoopscaleAction;
-(function (LoopscaleAction) {
-    LoopscaleAction["CREATE_LOAN"] = "LOOPSCALE_CREATE_LOAN";
-    LoopscaleAction["DEPOSIT_COLLATERAL"] = "LOOPSCALE_DEPOSIT_COLLATERAL";
-    LoopscaleAction["BORROW_PRINCIPAL"] = "LOOPSCALE_BORROW_PRINCIPAL";
-    LoopscaleAction["REPAY_PRINCIPAL"] = "LOOPSCALE_REPAY_PRINCIPAL";
-    LoopscaleAction["WITHDRAW_COLLATERAL"] = "LOOPSCALE_WITHDRAW_COLLATERAL";
-    LoopscaleAction["CLOSE_LOAN"] = "LOOPSCALE_CLOSE_LOAN";
-    LoopscaleAction["UPDATE_WEIGHT_MATRIX"] = "LOOPSCALE_UPDATE_WEIGHT_MATRIX";
-    LoopscaleAction["CREATE_STRATEGY"] = "LOOPSCALE_CREATE_STRATEGY";
-    LoopscaleAction["DEPOSIT_STRATEGY"] = "LOOPSCALE_DEPOSIT_STRATEGY";
-    LoopscaleAction["WITHDRAW_STRATEGY"] = "LOOPSCALE_WITHDRAW_STRATEGY";
-    LoopscaleAction["CLOSE_STRATEGY"] = "LOOPSCALE_CLOSE_STRATEGY";
-    LoopscaleAction["UPDATE_STRATEGY"] = "LOOPSCALE_UPDATE_STRATEGY";
-    LoopscaleAction["LOCK_LOAN"] = "LOOPSCALE_LOCK_LOAN";
-    LoopscaleAction["UNLOCK_LOAN"] = "LOOPSCALE_UNLOCK_LOAN";
-    LoopscaleAction["REFINANCE_LEDGER"] = "LOOPSCALE_REFINANCE_LEDGER";
-})(LoopscaleAction || (exports.LoopscaleAction = LoopscaleAction = {}));
+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");
+const KAMINO_VAULT_CODER = new anchor_1.BorshCoder(kamino_vault_idl_1.IDL);
 // ============================================================================
-// CLMM Instruction Types
+// Vault Instruction Types (re-exported from vault-instruction-types.ts)
 // ============================================================================
-/** Actions that can be performed on the Exponent CLMM (Concentrated Liquidity Market Maker). */
-var ClmmAction;
-(function (ClmmAction) {
-    /** Create a new LP position with a specified tick range. Generates keypair internally. */
-    ClmmAction["DEPOSIT_LIQUIDITY"] = "CLMM_DEPOSIT_LIQUIDITY";
-    /** Add more liquidity to an existing LP position. */
-    ClmmAction["ADD_LIQUIDITY"] = "CLMM_ADD_LIQUIDITY";
-    /** Remove liquidity from an LP position and receive PT + SY. */
-    ClmmAction["WITHDRAW_LIQUIDITY"] = "CLMM_WITHDRAW_LIQUIDITY";
-    /** Low-level PT/SY swap. Prefer buyPt/sellPt for directional trades. */
-    ClmmAction["TRADE_PT"] = "CLMM_TRADE_PT";
-    /** Buy PT with SY on the CLMM. */
-    ClmmAction["BUY_PT"] = "CLMM_BUY_PT";
-    /** Sell PT for SY on the CLMM. */
-    ClmmAction["SELL_PT"] = "CLMM_SELL_PT";
-    /** Buy YT with SY on the CLMM. */
-    ClmmAction["BUY_YT"] = "CLMM_BUY_YT";
-    /** Sell YT for SY on the CLMM. */
-    ClmmAction["SELL_YT"] = "CLMM_SELL_YT";
-    /** Claim farm emissions from an LP position. */
-    ClmmAction["CLAIM_FARM_EMISSION"] = "CLMM_CLAIM_FARM_EMISSION";
-})(ClmmAction || (exports.ClmmAction = ClmmAction = {}));
+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
 // ============================================================================
@@ -193,15 +117,16 @@ exports.kaminoAction = {
      * @param market - The Kamino lending market
      */
     initUserMetadata(market) {
-        return { action: VaultAction.INIT_USER_METADATA, market };
+        return { action: vault_instruction_types_2.VaultAction.INIT_USER_METADATA, market };
     },
     /**
      * Initialize a Kamino obligation for a market.
-     * No-ops if the account already exists on-chain.
+     * 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: VaultAction.INIT_OBLIGATION, market };
+        return { action: vault_instruction_types_2.VaultAction.INIT_OBLIGATION, market };
     },
     /**
      * Deposit collateral into a Kamino reserve.
@@ -211,7 +136,7 @@ exports.kaminoAction = {
      * @param amount - Amount in the asset's native units
      */
     deposit(market, asset, amount) {
-        return { action: VaultAction.DEPOSIT, market, asset: asset, amount };
+        return { action: vault_instruction_types_2.VaultAction.DEPOSIT, market, asset: asset, amount };
     },
     /**
      * Withdraw collateral from a Kamino reserve.
@@ -220,7 +145,7 @@ exports.kaminoAction = {
      * @param amount - Amount in the asset's native units
      */
     withdraw(market, asset, amount) {
-        return { action: VaultAction.WITHDRAW, market, asset: asset, amount };
+        return { action: vault_instruction_types_2.VaultAction.WITHDRAW, market, asset: asset, amount };
     },
     /**
      * Borrow from a Kamino reserve.
@@ -229,7 +154,7 @@ exports.kaminoAction = {
      * @param amount - Amount in the asset's native units
      */
     borrow(market, asset, amount) {
-        return { action: VaultAction.BORROW, market, asset: asset, amount };
+        return { action: vault_instruction_types_2.VaultAction.BORROW, market, asset: asset, amount };
     },
     /**
      * Repay a borrow on a Kamino reserve.
@@ -238,11 +163,77 @@ exports.kaminoAction = {
      * @param amount - Amount in the asset's native units
      */
     repay(market, asset, amount) {
-        return { action: VaultAction.REPAY, market, asset: 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.
+     * `reserve` is an optional override. When omitted, the SDK plans the
+     * withdraw across the vault's active reserves automatically.
+     */
+    withdraw(params) {
+        return { action: vault_instruction_types_2.KaminoVaultAction.WITHDRAW, ...params };
     },
 };
 /**
- * Build vault instructions and wrap them in a Squads sync transaction.
+ * 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 one or more vault sync transactions from high-level instruction descriptors.
+ *
+ * This is the plural companion to {@link createVaultSyncTransaction}. Most
+ * calls return a single result. Smart Kamino Vault withdraws can expand into
+ * multiple reserve-specific sync transactions when the wrapper needs to split
+ * an oversized withdraw across sequential chunks.
+ */
+async function createVaultSyncTransactions(params) {
+    return buildVaultSyncTransactionResults(params, true);
+}
+exports.createVaultSyncTransactions = createVaultSyncTransactions;
+/**
+ * Build exactly one vault sync transaction and return its wrapped instruction set.
  *
  * Takes high-level `VaultInstruction` descriptors (built with `kamino.*`),
  * resolves them to raw Solana instructions, then separates them:
@@ -252,28 +243,118 @@ exports.kaminoAction = {
  * 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]
- * ```
+ * When a smart Kamino Vault withdraw expands beyond one sync transaction, this
+ * singular helper throws and asks the caller to use
+ * {@link createVaultSyncTransactions} or {@link VaultTransactionBuilder}.
  */
-async function createVaultSyncTransaction({ instructions, owner, connection, policyPda, vaultPda, signer, accountIndex = 0, constraintIndices, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram = syncTransaction_1.SQUADS_PROGRAM_ID, }) {
-    const { setupInstructions, syncInstructions, preInstructions, postInstructions, signers, addressLookupTableAddresses } = await buildVaultInstructions(instructions, owner, connection, signer, policyPda, vaultPda, accountIndex, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram);
+async function createVaultSyncTransaction(params) {
+    const results = await buildVaultSyncTransactionResults(params, false);
+    return results[0];
+}
+exports.createVaultSyncTransaction = createVaultSyncTransaction;
+async function buildVaultSyncTransactionResults({ instructions, owner, connection, policyPda, vaultPda, signer, accountIndex = 0, constraintIndices, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram = syncTransaction_1.SQUADS_PROGRAM_ID, autoManagePositions = false, setupContext, }, splitOversizedKaminoVaultWithdraw) {
+    vaultPda ??= owner;
+    const resolvedSetupContext = setupContext ?? createStrategySetupContext({
+        connection,
+        env: environment_1.LOCAL_ENV,
+        owner,
+        signer,
+        vaultAddress,
+        policyPda,
+        vaultPda,
+        accountIndex,
+        squadsProgram,
+        leadingAccounts,
+        preHookAccounts,
+        postHookAccounts,
+        autoManagePositions,
+    });
+    const buckets = await buildVaultInstructions(instructions, owner, connection, signer, policyPda, vaultPda, accountIndex, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram, autoManagePositions, resolvedSetupContext);
+    const setupStatePriceRefreshInstructions = setupContext
+        ? []
+        : await buildSetupStatePriceRefreshInstructions(resolvedSetupContext);
+    const fullResult = await buildWrappedVaultSyncTransactionResult({
+        connection,
+        policyPda,
+        vaultPda,
+        signer,
+        accountIndex,
+        constraintIndices,
+        vaultAddress,
+        leadingAccounts,
+        preHookAccounts,
+        postHookAccounts,
+        squadsProgram,
+        syncInstructions: buckets.syncInstructions,
+        setupInstructions: buckets.setupInstructions,
+        preInstructions: [...setupStatePriceRefreshInstructions, ...buckets.preInstructions],
+        postInstructions: buckets.postInstructions,
+        signers: buckets.signers,
+        addressLookupTableAddresses: buckets.addressLookupTableAddresses,
+    });
+    const isPlannerExpandedKaminoVaultWithdraw = instructions.length === 1
+        && instructions[0]?.action === vault_instruction_types_2.KaminoVaultAction.WITHDRAW
+        && !instructions[0].reserve
+        && buckets.syncInstructions.length > 1;
+    if (!isPlannerExpandedKaminoVaultWithdraw) {
+        return [fullResult];
+    }
+    if (await vaultSyncResultFitsInSingleTransaction({
+        connection,
+        payer: signer,
+        result: fullResult,
+    })) {
+        return [fullResult];
+    }
+    if (!splitOversizedKaminoVaultWithdraw) {
+        throw new Error("Kamino Vault withdraw expands beyond one sync transaction; use createVaultSyncTransactions() or VaultTransactionBuilder.");
+    }
+    if (buckets.preInstructions.length > 0 || buckets.postInstructions.length > 0) {
+        throw new Error("Kamino Vault withdraw chunking only supports sync-only actions; use explicit reserve overrides if you need custom refresh handling.");
+    }
+    const splitResults = [];
+    for (const [index, syncInstruction] of buckets.syncInstructions.entries()) {
+        const chunkConstraintIndices = constraintIndices
+            ? constraintIndices.length === buckets.syncInstructions.length
+                ? [constraintIndices[index]]
+                : constraintIndices.length === 1
+                    ? constraintIndices
+                    : (() => {
+                        throw new Error("constraintIndices must contain either one entry or one entry per generated sync instruction when splitting a Kamino Vault withdraw.");
+                    })()
+            : undefined;
+        const chunkResult = await buildWrappedVaultSyncTransactionResult({
+            connection,
+            policyPda,
+            vaultPda,
+            signer,
+            accountIndex,
+            constraintIndices: chunkConstraintIndices,
+            vaultAddress,
+            leadingAccounts,
+            preHookAccounts,
+            postHookAccounts,
+            squadsProgram,
+            syncInstructions: [syncInstruction],
+            setupInstructions: index === 0 ? buckets.setupInstructions : [],
+            preInstructions: index === 0 ? [...setupStatePriceRefreshInstructions] : [],
+            postInstructions: [],
+            signers: buckets.signers,
+            addressLookupTableAddresses: buckets.addressLookupTableAddresses,
+        });
+        const chunkFits = await vaultSyncResultFitsInSingleTransaction({
+            connection,
+            payer: signer,
+            result: chunkResult,
+        });
+        if (!chunkFits) {
+            throw new Error(`Kamino Vault withdraw chunk ${index + 1} still exceeds one sync transaction; use explicit reserve overrides or smaller steps.`);
+        }
+        splitResults.push(chunkResult);
+    }
+    return splitResults;
+}
+async function buildWrappedVaultSyncTransactionResult({ connection, policyPda, vaultPda, signer, accountIndex, constraintIndices, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram, syncInstructions, setupInstructions, preInstructions, postInstructions, signers, addressLookupTableAddresses, }) {
     let resolvedPolicyPda = policyPda;
     let resolvedConstraintIndices = constraintIndices;
     if (!resolvedPolicyPda) {
@@ -284,9 +365,7 @@ async function createVaultSyncTransaction({ instructions, owner, connection, pol
         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;
@@ -308,32 +387,64 @@ async function createVaultSyncTransaction({ instructions, owner, connection, pol
         preHookAccounts: resolvedPreHookAccounts,
         postHookAccounts: resolvedPostHookAccounts,
     });
-    return { setupInstructions, preInstructions, instruction, postInstructions, signers, addressLookupTableAddresses };
+    return {
+        setupInstructions,
+        preInstructions,
+        instruction,
+        postInstructions,
+        signers,
+        addressLookupTableAddresses,
+    };
+}
+async function vaultSyncResultFitsInSingleTransaction(params) {
+    try {
+        const altAccounts = await resolveVaultSyncAltAccounts(params.connection, params.result.addressLookupTableAddresses);
+        const message = new web3_js_1.TransactionMessage({
+            payerKey: params.payer,
+            recentBlockhash: web3_js_1.PublicKey.default.toBase58(),
+            instructions: [...params.result.preInstructions, params.result.instruction, ...params.result.postInstructions],
+        }).compileToV0Message(altAccounts);
+        return new web3_js_1.VersionedTransaction(message).serialize().length <= 1232;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveVaultSyncAltAccounts(connection, addresses) {
+    const lookupTables = await Promise.all(addresses.map((address) => connection.getAddressLookupTable(address)));
+    return lookupTables
+        .map((entry) => entry.value)
+        .filter((entry) => entry !== null);
 }
-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(OrderbookAction).includes(ix.action);
+    return Object.values(vault_instruction_types_2.OrderbookAction).includes(ix.action);
 }
 function isCoreInstruction(ix) {
-    return Object.values(CoreAction).includes(ix.action);
+    return Object.values(vault_instruction_types_2.CoreAction).includes(ix.action);
 }
 function isSyInstruction(ix) {
-    return Object.values(SyAction).includes(ix.action);
+    return Object.values(vault_instruction_types_2.SyAction).includes(ix.action);
 }
 function isTitanInstruction(ix) {
-    return Object.values(TitanAction).includes(ix.action);
+    return Object.values(vault_instruction_types_2.TitanAction).includes(ix.action);
 }
 function isClmmInstruction(ix) {
-    return Object.values(ClmmAction).includes(ix.action);
+    return Object.values(vault_instruction_types_2.ClmmAction).includes(ix.action);
 }
 function isLoopscaleInstruction(ix) {
-    return Object.values(LoopscaleAction).includes(ix.action);
+    return Object.values(vault_instruction_types_2.LoopscaleAction).includes(ix.action);
 }
 /** Cache for loaded vaults to avoid redundant fetches */
 const vaultCache = new Map();
@@ -345,7 +456,7 @@ 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, }) {
+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,
@@ -359,22 +470,36 @@ function createStrategySetupContext({ connection, env, owner, signer, vaultAddre
         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_2.ExponentVault.load({
+            const strategyVault = await vault_3.ExponentVault.load({
                 env: context.env,
                 connection: context.connection,
                 address: context.vaultAddress,
             });
-            const prices = await strategyVault.fetcher.fetchExponentPrices();
+            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();
@@ -391,6 +516,25 @@ async function loadStrategySetupState(context) {
                     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);
@@ -402,38 +546,148 @@ async function loadStrategySetupState(context) {
             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;
 }
-function findSimplePrice(prices, priceMint, underlyingMint) {
-    for (const entry of prices.prices) {
-        if (!entry)
-            continue;
-        if (!entry.priceMint.equals(priceMint) || !entry.underlyingMint.equals(underlyingMint)) {
+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;
         }
-        return {
-            priceId: entry.priceId,
-            price: exponentPriceToDecimal(entry),
-        };
+        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 });
+        }
     }
-    return null;
+    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 exponentPriceToDecimal(entry) {
-    const raw = entry.price[0];
-    if (!Array.isArray(raw)) {
-        throw new Error(`Invalid Exponent price format for ${entry.priceId.toString()}`);
+function getTrackedKaminoFarmFromPosition(position) {
+    if (!position || typeof position !== "object" || !("kaminoFarm" in position)) {
+        return null;
     }
-    return new decimal_js_1.default((0, precise_number_1.bigintU256ToString)(raw.map((value) => BigInt(value.toString()))));
+    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();
@@ -445,6 +699,173 @@ async function accountExists(state, connection, address) {
     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;
@@ -465,10 +886,13 @@ async function ensureOrderbookPositionSetup(orderbook, buckets, setupContext) {
     if (state.trackedOrderbooks.has(orderbookKey)) {
         return;
     }
-    const ptPrice = findSimplePrice(state.prices, orderbook.mintPt, state.strategyVault.state.underlyingMint);
-    if (!ptPrice) {
-        throw new Error(`Missing Exponent price for orderbook setup (${orderbook.selfAddress.toBase58()})`);
-    }
+    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: [
@@ -479,7 +903,7 @@ async function ensureOrderbookPositionSetup(orderbook, buckets, setupContext) {
                     userEscrowIdx: 0,
                     mint: orderbook.vault.mintSy,
                     offerIdxVec: [],
-                    priceIdPt: exponentVaults.priceId("Simple", { priceId: ptPrice.priceId }),
+                    priceIdPt,
                     baseMint: state.strategyVault.state.underlyingMint,
                 }]),
         ],
@@ -488,8 +912,12 @@ async function ensureOrderbookPositionSetup(orderbook, buckets, setupContext) {
             { pubkey: orderbook.state.vault, isSigner: false, isWritable: false },
         ],
     }));
-    state.trackedOrderbooks.add(orderbookKey);
-    state.nextStrategyPositionIndex += 1;
+    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);
@@ -500,10 +928,13 @@ async function ensureYieldPositionSetup(coreVault, buckets, setupContext) {
     if (state.trackedYieldVaults.has(coreVaultKey)) {
         return;
     }
-    const ptPrice = findSimplePrice(state.prices, coreVault.mintPt, state.strategyVault.state.underlyingMint);
-    if (!ptPrice) {
-        throw new Error(`Missing Exponent price for core vault setup (${coreVault.selfAddress.toBase58()})`);
-    }
+    const 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));
@@ -534,7 +965,7 @@ async function ensureYieldPositionSetup(coreVault, buckets, setupContext) {
             exponentVaults.vaultSettingsAction("AddYieldPositionEntry", {
                 yieldPosition,
                 vault: coreVault.selfAddress,
-                priceIdPt: exponentVaults.priceId("Simple", { priceId: ptPrice.priceId }),
+                priceIdPt,
             }),
         ],
         remainingAccounts: [
@@ -542,8 +973,11 @@ async function ensureYieldPositionSetup(coreVault, buckets, setupContext) {
             { pubkey: yieldPosition, isSigner: false, isWritable: false },
         ],
     }));
-    state.trackedYieldVaults.add(coreVaultKey);
-    state.nextStrategyPositionIndex += 1;
+    recordPlannedYieldPosition(state, {
+        yieldPosition,
+        vault: coreVault.selfAddress,
+        priceIdPt,
+    });
 }
 async function wrapVaultSignedSetupInstruction({ instruction, setupContext, }) {
     if (!setupContext.vaultPda) {
@@ -567,7 +1001,12 @@ async function wrapVaultSignedSetupInstruction({ instruction, setupContext, }) {
     let resolvedPostHookAccounts = setupContext.postHookAccounts;
     if (setupContext.vaultAddress
         && (!resolvedLeadingAccounts || !resolvedPreHookAccounts || !resolvedPostHookAccounts)) {
-        const hooks = await (0, policyMatcher_1.resolveHookAccounts)(setupContext.connection, resolvedPolicyPda, setupContext.vaultAddress, setupContext.signer);
+        // 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;
@@ -603,10 +1042,13 @@ async function ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenPr
     if (state.trackedTokenAccounts.has(tokenAccountKey)) {
         return;
     }
-    const price = findSimplePrice(state.prices, tokenMint, state.strategyVault.state.underlyingMint);
-    if (!price) {
-        throw new Error(`Missing Exponent price for token position setup (${tokenMint.toBase58()})`);
-    }
+    const 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,
@@ -629,7 +1071,7 @@ async function ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenPr
                         balances: [{
                                 tokenAccount,
                                 mint: tokenMint,
-                                priceId: exponentVaults.priceId("Simple", { priceId: price.priceId }),
+                                priceId,
                             }],
                     }]),
             ],
@@ -637,8 +1079,11 @@ async function ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenPr
                 { pubkey: tokenAccount, isSigner: false, isWritable: false },
             ],
         }));
-        state.tokenPositionIndexByMint.set(tokenMintKey, state.nextStrategyPositionIndex);
-        state.nextStrategyPositionIndex += 1;
+        recordPlannedTokenAccountEntry(state, {
+            tokenMint,
+            tokenAccount,
+            priceId,
+        });
     }
     else {
         buckets.setupInstructions.push(state.strategyVault.ixWrapperManagerUpdatePosition({
@@ -649,86 +1094,811 @@ async function ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenPr
                 balance: {
                     tokenAccount,
                     mint: tokenMint,
-                    priceId: exponentVaults.priceId("Simple", { priceId: price.priceId }),
+                    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 minBn(lhs, rhs) {
+    return lhs.lte(rhs) ? lhs : rhs;
+}
+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] };
+}
+function decodeKaminoVaultState(data) {
+    const decoded = KAMINO_VAULT_CODER.accounts.decode("VaultState", data);
+    return {
+        tokenAvailable: decoded.token_available,
+        sharesIssued: decoded.shares_issued,
+        pendingFeesSf: decoded.pending_fees_sf,
+        allocations: decoded.vault_allocation_strategy
+            .filter((allocation) => !allocation.reserve.equals(web3_js_1.PublicKey.default))
+            .map((allocation) => ({
+            reserve: allocation.reserve,
+            ctokenAllocation: allocation.ctoken_allocation,
+        })),
+    };
+}
+function calculateKaminoVaultTokensPerShareFromSnapshot(snapshot) {
+    if (snapshot.sharesIssued.isZero()) {
+        return new decimal_js_1.default(0);
+    }
+    const investedTotal = snapshot.reserves.reduce((total, reserve) => total.add(reserve.investedLiquidityAmount), new decimal_js_1.default(0));
+    const pendingFees = new kamino_reserve_deserializer_1.Fraction(snapshot.pendingFeesSf).toDecimal();
+    const currentVaultAum = new decimal_js_1.default(snapshot.tokenAvailable.toString())
+        .add(investedTotal)
+        .sub(pendingFees);
+    if (currentVaultAum.lte(0)) {
+        return new decimal_js_1.default(0);
+    }
+    return currentVaultAum.div(snapshot.sharesIssued.toString());
+}
+function planKaminoVaultWithdrawLegsFromSnapshot(params) {
+    if (params.reserve) {
+        return [{ reserveAddress: params.reserve, sharesAmount: params.sharesAmount }];
+    }
+    const actualSharesToWithdraw = minBn(params.sharesAmount, params.snapshot.sharesBalance);
+    if (actualSharesToWithdraw.isZero()) {
+        throw new Error("Cannot withdraw zero Kamino Vault shares");
+    }
+    if (params.snapshot.reserves.length === 0) {
+        throw new Error("Kamino Vault has no active reserves to anchor a reserve-specific withdraw instruction");
+    }
+    const withdrawAllShares = params.sharesAmount.gte(params.snapshot.sharesBalance);
+    const tokensPerShare = calculateKaminoVaultTokensPerShareFromSnapshot(params.snapshot);
+    if (tokensPerShare.lte(0)) {
+        throw new Error("Kamino Vault has zero share price; cannot plan a withdraw");
+    }
+    const tokensToWithdraw = new decimal_js_1.default(actualSharesToWithdraw.toString()).mul(tokensPerShare);
+    const availableTokens = new decimal_js_1.default(params.snapshot.tokenAvailable.toString());
+    if (tokensToWithdraw.lte(availableTokens)) {
+        return [{
+                reserveAddress: params.snapshot.reserves[0].reserveAddress,
+                sharesAmount: withdrawAllShares ? params.snapshot.sharesBalance : actualSharesToWithdraw,
+            }];
+    }
+    let tokensRemaining = tokensToWithdraw;
+    const plannedLegs = [];
+    const sortedReserves = [...params.snapshot.reserves].sort((lhs, rhs) => rhs.availableLiquidityToWithdraw.comparedTo(lhs.availableLiquidityToWithdraw));
+    for (const [index, reserve] of sortedReserves.entries()) {
+        const legCapacity = reserve.availableLiquidityToWithdraw.add(index === 0 ? availableTokens : 0);
+        if (legCapacity.lte(0)) {
+            continue;
+        }
+        const tokensForLeg = decimal_js_1.default.min(tokensRemaining, legCapacity);
+        if (tokensForLeg.lte(0)) {
+            continue;
+        }
+        const sharesForLeg = withdrawAllShares
+            ? params.snapshot.sharesBalance
+            : new bn_js_1.default(tokensForLeg.div(tokensPerShare).floor().toFixed(0));
+        if (sharesForLeg.isZero()) {
+            continue;
+        }
+        plannedLegs.push({
+            reserveAddress: reserve.reserveAddress,
+            sharesAmount: sharesForLeg,
+        });
+        tokensRemaining = tokensRemaining.sub(tokensForLeg);
+        if (tokensRemaining.lte(0)) {
+            break;
+        }
+    }
+    if (plannedLegs.length === 0) {
+        throw new Error("Unable to plan a Kamino Vault withdraw across the vault's active reserves");
+    }
+    return plannedLegs;
+}
+exports.__kaminoVaultTesting = {
+    calculateKaminoVaultTokensPerShareFromSnapshot,
+    planKaminoVaultWithdrawLegsFromSnapshot,
+};
+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 decodedVaultState = decodeKaminoVaultState(Buffer.from(vaultInfo.data));
+    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 allocation = decodedVaultState.allocations[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);
+        const investedLiquidityAmount = allocation
+            ? new decimal_js_1.default(allocation.ctokenAllocation.toString()).mul(reserveAccount.getCollateralExchangeRate())
+            : new decimal_js_1.default(0);
+        const availableLiquidityToWithdraw = decimal_js_1.default.min(investedLiquidityAmount, reserveAccount.getLiquidityAvailableAmount());
+        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,
+            account: reserveAccount,
+            investedLiquidityAmount,
+            availableLiquidityToWithdraw,
+        };
+    });
+    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);
+    const sharesAtaInfo = await setupContext.connection.getAccountInfo(sharesAta);
+    const sharesBalance = sharesAtaInfo?.data
+        ? new bn_js_1.default(spl_token_1.AccountLayout.decode(sharesAtaInfo.data).amount.toString())
+        : new bn_js_1.default(0);
+    return { index, tokenAta, sharesAta, sharesBalance, state: decodedVaultState };
+}
+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 resolveExplicitKaminoVaultWithdrawReserve(ix, vaultContext) {
+    if (!ix.reserve) {
+        throw new Error("reserve is required when resolving an explicit Kamino Vault withdraw 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;
+}
+function planKaminoVaultWithdrawLegs(ix, vaultContext) {
+    if (ix.reserve) {
+        return [{
+                reserve: resolveExplicitKaminoVaultWithdrawReserve(ix, vaultContext),
+                sharesAmount: ix.sharesAmount,
+            }];
+    }
+    const plannedLegs = planKaminoVaultWithdrawLegsFromSnapshot({
+        sharesAmount: ix.sharesAmount,
+        snapshot: {
+            sharesBalance: vaultContext.sharesBalance,
+            tokenAvailable: vaultContext.state.tokenAvailable,
+            sharesIssued: vaultContext.state.sharesIssued,
+            pendingFeesSf: vaultContext.state.pendingFeesSf,
+            reserves: vaultContext.index.reserves.map((reserve) => ({
+                reserveAddress: reserve.reserveAddress,
+                investedLiquidityAmount: reserve.investedLiquidityAmount,
+                availableLiquidityToWithdraw: reserve.availableLiquidityToWithdraw,
+            })),
+        },
+    });
+    return plannedLegs.map((leg) => {
+        const reserve = vaultContext.index.reserves.find((entry) => entry.reserveAddress.equals(leg.reserveAddress));
+        if (!reserve) {
+            throw new Error(`Kamino Vault ${ix.vault.toBase58()} does not use reserve ${leg.reserveAddress.toBase58()}`);
+        }
+        return {
+            reserve,
+            sharesAmount: leg.sharesAmount,
+        };
+    });
+}
+function buildKaminoVaultWithdrawInstruction(params) {
+    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: params.reserve.reserveAddress, isSigner: false, isWritable: true },
+            { pubkey: params.reserve.ctokenVault, isSigner: false, isWritable: true },
+            { pubkey: params.reserve.marketAddress, isSigner: false, isWritable: false },
+            { pubkey: params.reserve.lendingMarketAuthority, isSigner: false, isWritable: false },
+            { pubkey: params.reserve.reserveLiquiditySupply, isSigner: false, isWritable: true },
+            { pubkey: params.reserve.reserveCollateralMint, isSigner: false, isWritable: true },
+            { pubkey: params.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.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;
+    }
+    const withdrawLegs = planKaminoVaultWithdrawLegs(ix, vaultContext);
+    for (const leg of withdrawLegs) {
+        buckets.syncInstructions.push(buildKaminoVaultWithdrawInstruction({
+            owner: setupContext.owner,
+            ix,
+            reserve: leg.reserve,
+            sharesAmount: leg.sharesAmount,
+            vaultContext,
+            validationAccounts,
+        }));
     }
-    state.trackedTokenAccounts.add(tokenAccountKey);
 }
-async function buildVaultInstructions(instructions, owner, connection, signer, policyPda, vaultPda, accountIndex, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram = syncTransaction_1.SQUADS_PROGRAM_ID) {
-    const buckets = {
-        setupInstructions: [],
-        syncInstructions: [],
-        preInstructions: [],
-        postInstructions: [],
-        signers: [],
-        addressLookupTableAddresses: [],
+function getOptionalReadonlyAccountMeta(account, placeholderProgram) {
+    return {
+        pubkey: account ?? placeholderProgram,
+        isSigner: false,
+        isWritable: false,
     };
-    const setupContext = createStrategySetupContext({
-        connection,
-        env: environment_1.LOCAL_ENV,
-        owner,
-        signer,
-        vaultAddress,
-        policyPda,
-        vaultPda,
-        accountIndex,
-        squadsProgram,
-        leadingAccounts,
-        preHookAccounts,
-        postHookAccounts,
+}
+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),
     });
-    for (const ix of instructions) {
-        if (isOrderbookInstruction(ix)) {
-            await buildOrderbookInstruction(ix, owner, connection, buckets, setupContext);
-            continue;
-        }
-        if (isCoreInstruction(ix)) {
-            await buildCoreInstruction(ix, owner, connection, buckets, setupContext);
-            continue;
-        }
-        if (isSyInstruction(ix)) {
-            await buildSyInstruction(ix, owner, connection, buckets, setupContext);
-            continue;
+}
+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;
         }
-        if (isTitanInstruction(ix)) {
-            await buildTitanInstruction(ix, buckets, setupContext);
-            continue;
+        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;
         }
-        if (isLoopscaleInstruction(ix)) {
-            await buildLoopscaleInstruction(ix, buckets, setupContext);
-            continue;
+        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;
         }
-        if (isClmmInstruction(ix)) {
-            await buildClmmInstruction(ix, owner, connection, buckets, setupContext);
-            continue;
+        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;
         }
-        switch (ix.action) {
-            case VaultAction.INIT_USER_METADATA:
-                await buildInitUserMetadata(owner, connection, buckets);
-                break;
-            case VaultAction.INIT_OBLIGATION:
-                await buildInitObligation(ix, owner, connection, buckets);
-                break;
-            case VaultAction.DEPOSIT:
-                await buildDeposit(ix, owner, connection, signer, buckets);
-                break;
-            case VaultAction.WITHDRAW:
-                await buildWithdraw(ix, owner, connection, signer, buckets);
-                break;
-            case VaultAction.BORROW:
-                await buildBorrow(ix, owner, connection, signer, buckets);
-                break;
-            case VaultAction.REPAY:
-                await buildRepay(ix, owner, connection, signer, buckets);
-                break;
+        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;
         }
     }
-    return buckets;
 }
 async function buildTitanInstruction(ix, buckets, setupContext) {
     const inputMint = ix.instruction.keys[TITAN_INPUT_MINT_ACCOUNT_INDEX]?.pubkey;
@@ -759,94 +1929,37 @@ async function buildTitanInstruction(ix, buckets, setupContext) {
         buckets,
         setupContext,
     });
+    if (ix.addressLookupTableAddresses?.length) {
+        buckets.addressLookupTableAddresses.push(...ix.addressLookupTableAddresses);
+    }
     buckets.syncInstructions.push(ix.instruction);
 }
-// Loopscale account indices per instruction (from the Loopscale IDL)
-const LOOPSCALE_DEPOSIT_COLLATERAL_MINT_INDEX = 6;
-const LOOPSCALE_DEPOSIT_COLLATERAL_BORROWER_TA_INDEX = 4;
-const LOOPSCALE_DEPOSIT_COLLATERAL_TOKEN_PROGRAM_INDEX = 9;
-const LOOPSCALE_BORROW_PRINCIPAL_MINT_INDEX = 6;
-const LOOPSCALE_BORROW_PRINCIPAL_BORROWER_TA_INDEX = 7;
-const LOOPSCALE_BORROW_PRINCIPAL_TOKEN_PROGRAM_INDEX = 10;
-const LOOPSCALE_REPAY_PRINCIPAL_MINT_INDEX = 6;
-const LOOPSCALE_REPAY_PRINCIPAL_BORROWER_TA_INDEX = 7;
-const LOOPSCALE_REPAY_PRINCIPAL_TOKEN_PROGRAM_INDEX = 10;
-const LOOPSCALE_WITHDRAW_COLLATERAL_MINT_INDEX = 7;
-const LOOPSCALE_WITHDRAW_COLLATERAL_BORROWER_TA_INDEX = 4;
-const LOOPSCALE_WITHDRAW_COLLATERAL_TOKEN_PROGRAM_INDEX = 8;
-const LOOPSCALE_DEPOSIT_STRATEGY_MINT_INDEX = 4;
-const LOOPSCALE_DEPOSIT_STRATEGY_LENDER_TA_INDEX = 6;
-const LOOPSCALE_DEPOSIT_STRATEGY_TOKEN_PROGRAM_INDEX = 8;
-const LOOPSCALE_WITHDRAW_STRATEGY_MINT_INDEX = 4;
-const LOOPSCALE_WITHDRAW_STRATEGY_LENDER_TA_INDEX = 6;
-const LOOPSCALE_WITHDRAW_STRATEGY_TOKEN_PROGRAM_INDEX = 9;
+/**
+ * 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) {
-    switch (ix.action) {
-        case LoopscaleAction.DEPOSIT_COLLATERAL: {
-            const tokenMint = ix.instruction.keys[LOOPSCALE_DEPOSIT_COLLATERAL_MINT_INDEX]?.pubkey;
-            const tokenAccount = ix.instruction.keys[LOOPSCALE_DEPOSIT_COLLATERAL_BORROWER_TA_INDEX]?.pubkey;
-            const tokenProgram = ix.instruction.keys[LOOPSCALE_DEPOSIT_COLLATERAL_TOKEN_PROGRAM_INDEX]?.pubkey;
-            if (!tokenMint || !tokenAccount || !tokenProgram) {
-                throw new Error("Loopscale deposit_collateral instruction is missing expected token accounts");
-            }
-            await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
-            break;
-        }
-        case LoopscaleAction.BORROW_PRINCIPAL: {
-            const tokenMint = ix.instruction.keys[LOOPSCALE_BORROW_PRINCIPAL_MINT_INDEX]?.pubkey;
-            const tokenAccount = ix.instruction.keys[LOOPSCALE_BORROW_PRINCIPAL_BORROWER_TA_INDEX]?.pubkey;
-            const tokenProgram = ix.instruction.keys[LOOPSCALE_BORROW_PRINCIPAL_TOKEN_PROGRAM_INDEX]?.pubkey;
-            if (!tokenMint || !tokenAccount || !tokenProgram) {
-                throw new Error("Loopscale borrow_principal instruction is missing expected token accounts");
-            }
-            await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
-            break;
-        }
-        case LoopscaleAction.REPAY_PRINCIPAL: {
-            const tokenMint = ix.instruction.keys[LOOPSCALE_REPAY_PRINCIPAL_MINT_INDEX]?.pubkey;
-            const tokenAccount = ix.instruction.keys[LOOPSCALE_REPAY_PRINCIPAL_BORROWER_TA_INDEX]?.pubkey;
-            const tokenProgram = ix.instruction.keys[LOOPSCALE_REPAY_PRINCIPAL_TOKEN_PROGRAM_INDEX]?.pubkey;
-            if (!tokenMint || !tokenAccount || !tokenProgram) {
-                throw new Error("Loopscale repay_principal instruction is missing expected token accounts");
-            }
-            await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
-            break;
-        }
-        case LoopscaleAction.WITHDRAW_COLLATERAL: {
-            const tokenMint = ix.instruction.keys[LOOPSCALE_WITHDRAW_COLLATERAL_MINT_INDEX]?.pubkey;
-            const tokenAccount = ix.instruction.keys[LOOPSCALE_WITHDRAW_COLLATERAL_BORROWER_TA_INDEX]?.pubkey;
-            const tokenProgram = ix.instruction.keys[LOOPSCALE_WITHDRAW_COLLATERAL_TOKEN_PROGRAM_INDEX]?.pubkey;
-            if (!tokenMint || !tokenAccount || !tokenProgram) {
-                throw new Error("Loopscale withdraw_collateral instruction is missing expected token accounts");
-            }
-            await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
-            break;
-        }
-        // create_loan, close_loan, and update_weight_matrix have no token accounts to track —
-        // the on-chain hook handles TrackLoopscaleLoan/UntrackLoopscaleLoan mutations.
-        // update_weight_matrix only has 3 accounts (bs_auth, borrower, loan).
-        case LoopscaleAction.DEPOSIT_STRATEGY: {
-            const tokenMint = ix.instruction.keys[LOOPSCALE_DEPOSIT_STRATEGY_MINT_INDEX]?.pubkey;
-            const tokenAccount = ix.instruction.keys[LOOPSCALE_DEPOSIT_STRATEGY_LENDER_TA_INDEX]?.pubkey;
-            const tokenProgram = ix.instruction.keys[LOOPSCALE_DEPOSIT_STRATEGY_TOKEN_PROGRAM_INDEX]?.pubkey;
-            if (!tokenMint || !tokenAccount || !tokenProgram) {
-                throw new Error("Loopscale deposit_strategy instruction is missing expected token accounts");
-            }
-            await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
-            break;
-        }
-        case LoopscaleAction.WITHDRAW_STRATEGY: {
-            const tokenMint = ix.instruction.keys[LOOPSCALE_WITHDRAW_STRATEGY_MINT_INDEX]?.pubkey;
-            const tokenAccount = ix.instruction.keys[LOOPSCALE_WITHDRAW_STRATEGY_LENDER_TA_INDEX]?.pubkey;
-            const tokenProgram = ix.instruction.keys[LOOPSCALE_WITHDRAW_STRATEGY_TOKEN_PROGRAM_INDEX]?.pubkey;
-            if (!tokenMint || !tokenAccount || !tokenProgram) {
-                throw new Error("Loopscale withdraw_strategy instruction is missing expected token accounts");
-            }
-            await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
-            break;
+    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`);
         }
-        // create_strategy and close_strategy have no token accounts to track
+        await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext });
     }
     buckets.syncInstructions.push(ix.instruction);
 }
@@ -859,16 +1972,16 @@ async function buildOrderbookInstruction(ix, owner, connection, buckets, setupCo
         orderbookCache.set(cacheKey, orderbook);
     }
     switch (ix.action) {
-        case OrderbookAction.POST_OFFER:
+        case vault_instruction_types_2.OrderbookAction.POST_OFFER:
             await buildPostOffer(ix, orderbook, owner, setupContext?.signer ?? owner, buckets, setupContext);
             break;
-        case OrderbookAction.MARKET_OFFER:
+        case vault_instruction_types_2.OrderbookAction.MARKET_OFFER:
             await buildMarketOffer(ix, orderbook, owner, setupContext?.signer ?? owner, buckets, setupContext);
             break;
-        case OrderbookAction.REMOVE_OFFER:
+        case vault_instruction_types_2.OrderbookAction.REMOVE_OFFER:
             await buildRemoveOffer(ix, orderbook, owner, buckets);
             break;
-        case OrderbookAction.WITHDRAW_FUNDS:
+        case vault_instruction_types_2.OrderbookAction.WITHDRAW_FUNDS:
             await buildWithdrawFunds(ix, orderbook, owner, buckets);
             break;
     }
@@ -876,30 +1989,24 @@ async function buildOrderbookInstruction(ix, owner, connection, buckets, setupCo
 // ============================================================================
 // Action Builders (one per VaultAction)
 // ============================================================================
-async function buildInitUserMetadata(owner, connection, { syncInstructions }) {
+function createKaminoInitUserMetadataInstruction(owner) {
     const userMetadata = (0, constants_1.getKaminoUserMetadata)(owner, policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
-    const userMetadataAccount = await connection.getAccountInfo(userMetadata);
-    if (userMetadataAccount)
-        return;
-    syncInstructions.push((0, instructions_1.initUserMetadata)({ userLookupTable: web3_js_1.PublicKey.default }, {
+    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,
-    }));
+    });
 }
-async function buildInitObligation(ix, owner, connection, { syncInstructions }) {
-    const lendingMarket = kamino_markets_1.KAMINO_MARKETS[ix.market];
-    const obligation = (0, constants_1.getKaminoLendObligation)(owner, lendingMarket, policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
-    const userMetadata = (0, constants_1.getKaminoUserMetadata)(owner, policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
-    const obligationAccount = await connection.getAccountInfo(obligation);
-    if (obligationAccount)
-        return;
-    syncInstructions.push((0, instructions_1.initObligation)({ args: { tag: 0, id: 0 } }, {
-        obligationOwner: owner,
-        feePayer: owner,
+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,
@@ -907,10 +2014,250 @@ async function buildInitObligation(ix, owner, connection, { syncInstructions })
         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 }) {
+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,
     });
@@ -942,8 +2289,9 @@ async function buildDeposit(ix, owner, connection, signer, { setupInstructions,
         farmsProgram: KAMINO_FARMS_PROGRAM_ID,
     }));
 }
-async function buildWithdraw(ix, owner, connection, signer, { setupInstructions, syncInstructions, preInstructions, postInstructions }) {
+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,
     });
@@ -981,8 +2329,9 @@ async function buildWithdraw(ix, owner, connection, signer, { setupInstructions,
         farmsProgram: KAMINO_FARMS_PROGRAM_ID,
     }));
 }
-async function buildBorrow(ix, owner, connection, signer, { setupInstructions, syncInstructions, preInstructions, postInstructions }) {
+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,
     });
@@ -1011,8 +2360,9 @@ async function buildBorrow(ix, owner, connection, signer, { setupInstructions, s
         farmsProgram: KAMINO_FARMS_PROGRAM_ID,
     }));
 }
-async function buildRepay(ix, owner, connection, signer, { setupInstructions, syncInstructions, preInstructions, postInstructions }) {
+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,
     });
@@ -1208,19 +2558,16 @@ exports.orderbookAction = {
     /**
      * Post a limit order on the orderbook.
      * @param params - Order parameters
-     * @param params.offerIdx - Required offer index for position tracking. Must be unique per trader.
      */
     postOffer(params) {
         return {
-            action: OrderbookAction.POST_OFFER,
+            action: vault_instruction_types_2.OrderbookAction.POST_OFFER,
             orderbook: params.orderbook,
             mode: params.mode,
             direction: params.direction,
             priceApy: params.priceApy,
             amount: params.amount,
-            offerIdx: params.offerIdx,
             offerOption: params.offerOption,
-            virtualOffer: params.virtualOffer,
             expirySeconds: params.expirySeconds,
         };
     },
@@ -1230,7 +2577,7 @@ exports.orderbookAction = {
      */
     marketOffer(params) {
         return {
-            action: OrderbookAction.MARKET_OFFER,
+            action: vault_instruction_types_2.OrderbookAction.MARKET_OFFER,
             orderbook: params.orderbook,
             mode: params.mode,
             direction: params.direction,
@@ -1246,7 +2593,7 @@ exports.orderbookAction = {
      */
     removeOffer(params) {
         return {
-            action: OrderbookAction.REMOVE_OFFER,
+            action: vault_instruction_types_2.OrderbookAction.REMOVE_OFFER,
             orderbook: params.orderbook,
             offerIdx: params.offerIdx,
         };
@@ -1257,7 +2604,7 @@ exports.orderbookAction = {
      */
     withdrawFunds(params) {
         return {
-            action: OrderbookAction.WITHDRAW_FUNDS,
+            action: vault_instruction_types_2.OrderbookAction.WITHDRAW_FUNDS,
             orderbook: params.orderbook,
             ptAmount: params.ptAmount,
             ytAmount: params.ytAmount,
@@ -1268,14 +2615,14 @@ exports.orderbookAction = {
 exports.syAction = {
     mint(params) {
         return {
-            action: SyAction.MINT,
+            action: vault_instruction_types_2.SyAction.MINT,
             vault: params.vault,
             amountBase: params.amountBase,
         };
     },
     redeem(params) {
         return {
-            action: SyAction.REDEEM,
+            action: vault_instruction_types_2.SyAction.REDEEM,
             vault: params.vault,
             amountSy: params.amountSy,
         };
@@ -1317,7 +2664,7 @@ exports.coreAction = {
      */
     strip(params) {
         return {
-            action: CoreAction.STRIP,
+            action: vault_instruction_types_2.CoreAction.STRIP,
             vault: params.vault,
             amountBase: params.amountBase,
         };
@@ -1329,7 +2676,7 @@ exports.coreAction = {
      */
     merge(params) {
         return {
-            action: CoreAction.MERGE,
+            action: vault_instruction_types_2.CoreAction.MERGE,
             vault: params.vault,
             amountPy: params.amountPy,
         };
@@ -1340,7 +2687,7 @@ exports.coreAction = {
      */
     withdrawYt(params) {
         return {
-            action: CoreAction.WITHDRAW_YT,
+            action: vault_instruction_types_2.CoreAction.WITHDRAW_YT,
             vault: params.vault,
             amountYt: params.amountYt,
         };
@@ -1351,18 +2698,19 @@ exports.coreAction = {
      */
     depositYt(params) {
         return {
-            action: CoreAction.DEPOSIT_YT,
+            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.
+     * Required before buying YT or depositing YT. When `autoManagePositions`
+     * is enabled, the SDK also tracks the new yield position automatically.
      */
     initializeYieldPosition(params) {
         return {
-            action: CoreAction.INITIALIZE_YIELD_POSITION,
+            action: vault_instruction_types_2.CoreAction.INITIALIZE_YIELD_POSITION,
             vault: params.vault,
         };
     },
@@ -1372,11 +2720,11 @@ exports.coreAction = {
  */
 function directionToOfferType(direction) {
     switch (direction) {
-        case OrderbookTradeDirection.BUY_PT:
-        case OrderbookTradeDirection.SELL_YT:
+        case vault_instruction_types_2.OrderbookTradeDirection.BUY_PT:
+        case vault_instruction_types_2.OrderbookTradeDirection.SELL_YT:
             return orderbook_2.OfferType.SellYt;
-        case OrderbookTradeDirection.SELL_PT:
-        case OrderbookTradeDirection.BUY_YT:
+        case vault_instruction_types_2.OrderbookTradeDirection.SELL_PT:
+        case vault_instruction_types_2.OrderbookTradeDirection.BUY_YT:
             return orderbook_2.OfferType.BuyYt;
     }
 }
@@ -1411,6 +2759,7 @@ function directionToOfferType(direction) {
  * ```
  */
 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;
@@ -1485,6 +2834,7 @@ async function buildOrderbookInstructions(instructions, owner, connection, signe
 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({
@@ -1517,10 +2867,10 @@ async function buildPostOffer(ix, orderbook, owner, setupPayer, buckets, setupCo
             amount: ix.amount,
             offerType,
             offerOption: (0, orderbook_2.offerOptions)(option, [false]),
-            virtualOffer: ix.virtualOffer ?? false,
+            virtualOffer: true,
             expirySeconds: ix.expirySeconds ?? 3600,
             mintSy: orderbook.vault.mintSy,
-            offerIdx: ix.offerIdx,
+            offerIdx,
         }));
         return;
     }
@@ -1531,10 +2881,10 @@ async function buildPostOffer(ix, orderbook, owner, setupPayer, buckets, setupCo
         amount: ix.amount,
         offerType,
         offerOption: (0, orderbook_2.offerOptions)(option, [false]),
-        virtualOffer: ix.virtualOffer ?? false,
+        virtualOffer: true,
         expirySeconds: ix.expirySeconds ?? 3600,
         mintSy: orderbook.vault.mintSy,
-        offerIdx: ix.offerIdx,
+        offerIdx,
     });
     buckets.preInstructions.push(...setupIxs);
     buckets.syncInstructions.push(postOfferIx);
@@ -1619,6 +2969,42 @@ async function buildWithdrawFunds(ix, orderbook, owner, { syncInstructions }) {
 // ============================================================================
 // 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();
@@ -1627,7 +3013,7 @@ async function buildCoreInstruction(ix, owner, connection, buckets, setupContext
         vault = await vault_1.Vault.load(environment_1.LOCAL_ENV, connection, ix.vault);
         vaultCache.set(cacheKey, vault);
     }
-    const isInitializeYieldPosition = ix.action === CoreAction.INITIALIZE_YIELD_POSITION;
+    const isInitializeYieldPosition = ix.action === vault_instruction_types_2.CoreAction.INITIALIZE_YIELD_POSITION;
     if (setupContext && !isInitializeYieldPosition) {
         await ensureTrackedTokenAccountSetup({
             tokenMint: vault.mintPt,
@@ -1637,7 +3023,7 @@ async function buildCoreInstruction(ix, owner, connection, buckets, setupContext
             setupContext,
         });
         await ensureYieldPositionSetup(vault, buckets, setupContext);
-        if (ix.action === CoreAction.WITHDRAW_YT) {
+        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),
@@ -1648,26 +3034,33 @@ async function buildCoreInstruction(ix, owner, connection, buckets, setupContext
         }
     }
     switch (ix.action) {
-        case CoreAction.STRIP:
+        case vault_instruction_types_2.CoreAction.STRIP:
             await buildStrip(ix, vault, owner, setupContext?.signer ?? owner, buckets);
             break;
-        case CoreAction.MERGE:
+        case vault_instruction_types_2.CoreAction.MERGE:
             await buildMerge(ix, vault, owner, setupContext?.signer ?? owner, buckets);
             break;
-        case CoreAction.WITHDRAW_YT:
+        case vault_instruction_types_2.CoreAction.WITHDRAW_YT:
             await buildWithdrawYt(ix, vault, owner, setupContext?.signer ?? owner, buckets);
             break;
-        case CoreAction.DEPOSIT_YT:
+        case vault_instruction_types_2.CoreAction.DEPOSIT_YT:
             await buildDepositYt(ix, vault, owner, buckets);
             break;
-        case CoreAction.INITIALIZE_YIELD_POSITION:
-            await buildInitializeYieldPosition(ix, vault, owner, buckets);
+        case vault_instruction_types_2.CoreAction.INITIALIZE_YIELD_POSITION:
+            await buildInitializeYieldPosition(ix, vault, owner, buckets, setupContext);
             break;
     }
 }
-async function buildInitializeYieldPosition(ix, vault, owner, { syncInstructions }) {
+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);
@@ -1742,7 +3135,7 @@ async function buildSyInstruction(ix, owner, connection, buckets, setupContext)
         throw new Error(`Base mint ${vault.flavor.mintBase.toBase58()} must be tracked on the strategy vault before using mint_sy/redeem_sy`);
     }
     switch (ix.action) {
-        case SyAction.MINT:
+        case vault_instruction_types_2.SyAction.MINT:
             buckets.syncInstructions.push(await vault.flavor.ixMintSy({
                 amountBase: ix.amountBase.toString(),
                 depositor: owner,
@@ -1750,7 +3143,7 @@ async function buildSyInstruction(ix, owner, connection, buckets, setupContext)
                 depositorSyTokenAccount: syTokenAccount,
             }));
             break;
-        case SyAction.REDEEM:
+        case vault_instruction_types_2.SyAction.REDEEM:
             buckets.syncInstructions.push(await vault.flavor.ixRedeemSy({
                 amountSy: ix.amountSy.toString(),
                 redeemer: owner,
@@ -1785,16 +3178,21 @@ 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: TitanAction.SWAP, instruction: params.instruction };
+        return {
+            action: vault_instruction_types_2.TitanAction.SWAP,
+            instruction: params.instruction,
+            addressLookupTableAddresses: params.addressLookupTableAddresses,
+        };
     },
 };
 // ============================================================================
 // Loopscale Action Builder
 // ============================================================================
 /**
- * Builder for Loopscale vault action descriptors.
+ * 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.
@@ -1824,54 +3222,54 @@ exports.titanAction = {
  */
 exports.loopscaleAction = {
     createLoan(params) {
-        return { action: LoopscaleAction.CREATE_LOAN, instruction: params.instruction };
+        return { action: vault_instruction_types_2.LoopscaleAction.CREATE_LOAN, instruction: params.instruction };
     },
     depositCollateral(params) {
-        return { action: LoopscaleAction.DEPOSIT_COLLATERAL, instruction: params.instruction };
+        return { action: vault_instruction_types_2.LoopscaleAction.DEPOSIT_COLLATERAL, instruction: params.instruction };
     },
     borrowPrincipal(params) {
-        return { action: LoopscaleAction.BORROW_PRINCIPAL, instruction: params.instruction };
+        return { action: vault_instruction_types_2.LoopscaleAction.BORROW_PRINCIPAL, instruction: params.instruction };
     },
     repayPrincipal(params) {
-        return { action: LoopscaleAction.REPAY_PRINCIPAL, instruction: params.instruction };
+        return { action: vault_instruction_types_2.LoopscaleAction.REPAY_PRINCIPAL, instruction: params.instruction };
     },
     withdrawCollateral(params) {
-        return { action: LoopscaleAction.WITHDRAW_COLLATERAL, instruction: params.instruction };
+        return { action: vault_instruction_types_2.LoopscaleAction.WITHDRAW_COLLATERAL, instruction: params.instruction };
     },
     closeLoan(params) {
-        return { action: LoopscaleAction.CLOSE_LOAN, instruction: params.instruction };
+        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: LoopscaleAction.UPDATE_WEIGHT_MATRIX, instruction: params.instruction };
+        return { action: vault_instruction_types_2.LoopscaleAction.UPDATE_WEIGHT_MATRIX, instruction: params.instruction };
     },
     createStrategy(params) {
-        return { action: LoopscaleAction.CREATE_STRATEGY, instruction: params.instruction };
+        return { action: vault_instruction_types_2.LoopscaleAction.CREATE_STRATEGY, instruction: params.instruction };
     },
     depositStrategy(params) {
-        return { action: LoopscaleAction.DEPOSIT_STRATEGY, instruction: params.instruction };
+        return { action: vault_instruction_types_2.LoopscaleAction.DEPOSIT_STRATEGY, instruction: params.instruction };
     },
     withdrawStrategy(params) {
-        return { action: LoopscaleAction.WITHDRAW_STRATEGY, instruction: params.instruction };
+        return { action: vault_instruction_types_2.LoopscaleAction.WITHDRAW_STRATEGY, instruction: params.instruction };
     },
     closeStrategy(params) {
-        return { action: LoopscaleAction.CLOSE_STRATEGY, instruction: params.instruction };
+        return { action: vault_instruction_types_2.LoopscaleAction.CLOSE_STRATEGY, instruction: params.instruction };
     },
     /** Configure collateral terms on a strategy (LENDER side). */
     updateStrategy(params) {
-        return { action: LoopscaleAction.UPDATE_STRATEGY, instruction: params.instruction };
+        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: LoopscaleAction.LOCK_LOAN, instruction: params.instruction };
+        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: LoopscaleAction.UNLOCK_LOAN, instruction: params.instruction };
+        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: LoopscaleAction.REFINANCE_LEDGER, instruction: params.instruction };
+        return { action: vault_instruction_types_2.LoopscaleAction.REFINANCE_LEDGER, instruction: params.instruction };
     },
 };
 // ============================================================================
@@ -1912,7 +3310,9 @@ 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`.
+     * `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
@@ -1921,7 +3321,7 @@ exports.clmmAction = {
      * @param params.upperTickKey - Upper tick boundary (APY value)
      */
     depositLiquidity(params) {
-        return { action: ClmmAction.DEPOSIT_LIQUIDITY, ...params };
+        return { action: vault_instruction_types_2.ClmmAction.DEPOSIT_LIQUIDITY, ...params };
     },
     /**
      * Add liquidity to an existing LP position.
@@ -1932,7 +3332,7 @@ exports.clmmAction = {
      * @param params.syInIntent - Maximum SY to add
      */
     addLiquidity(params) {
-        return { action: ClmmAction.ADD_LIQUIDITY, ...params };
+        return { action: vault_instruction_types_2.ClmmAction.ADD_LIQUIDITY, ...params };
     },
     /**
      * Withdraw liquidity from an LP position, receiving PT + SY.
@@ -1944,7 +3344,7 @@ exports.clmmAction = {
      * @param params.minSyOut - Minimum SY to receive (slippage protection)
      */
     withdrawLiquidity(params) {
-        return { action: ClmmAction.WITHDRAW_LIQUIDITY, ...params };
+        return { action: vault_instruction_types_2.ClmmAction.WITHDRAW_LIQUIDITY, ...params };
     },
     /**
      * Low-level PT/SY swap on the CLMM. Prefer {@link buyPt} / {@link sellPt}
@@ -1957,7 +3357,7 @@ exports.clmmAction = {
      * @param params.lnImpliedApyLimit - Optional price limit (ln implied APY)
      */
     tradePt(params) {
-        return { action: ClmmAction.TRADE_PT, ...params };
+        return { action: vault_instruction_types_2.ClmmAction.TRADE_PT, ...params };
     },
     /**
      * Buy PT with SY on the CLMM.
@@ -1968,7 +3368,7 @@ exports.clmmAction = {
      * @param params.lnImpliedApyLimit - Optional price limit (ln implied APY)
      */
     buyPt(params) {
-        return { action: ClmmAction.BUY_PT, ...params };
+        return { action: vault_instruction_types_2.ClmmAction.BUY_PT, ...params };
     },
     /**
      * Sell PT for SY on the CLMM.
@@ -1979,7 +3379,7 @@ exports.clmmAction = {
      * @param params.lnImpliedApyLimit - Optional price limit (ln implied APY)
      */
     sellPt(params) {
-        return { action: ClmmAction.SELL_PT, ...params };
+        return { action: vault_instruction_types_2.ClmmAction.SELL_PT, ...params };
     },
     /**
      * Buy YT with SY on the CLMM.
@@ -1990,7 +3390,7 @@ exports.clmmAction = {
      * @param params.lnImpliedApyLimit - Optional price limit (ln implied APY)
      */
     buyYt(params) {
-        return { action: ClmmAction.BUY_YT, ...params };
+        return { action: vault_instruction_types_2.ClmmAction.BUY_YT, ...params };
     },
     /**
      * Sell YT for SY on the CLMM.
@@ -2001,7 +3401,7 @@ exports.clmmAction = {
      * @param params.lnImpliedApyLimit - Optional price limit (ln implied APY)
      */
     sellYt(params) {
-        return { action: ClmmAction.SELL_YT, ...params };
+        return { action: vault_instruction_types_2.ClmmAction.SELL_YT, ...params };
     },
     /**
      * Claim farm emissions from an LP position.
@@ -2011,7 +3411,7 @@ exports.clmmAction = {
      * @param params.farmIndex - Index of the farm emission to claim
      */
     claimFarmEmission(params) {
-        return { action: ClmmAction.CLAIM_FARM_EMISSION, ...params };
+        return { action: vault_instruction_types_2.ClmmAction.CLAIM_FARM_EMISSION, ...params };
     },
 };
 // ============================================================================
@@ -2019,6 +3419,63 @@ exports.clmmAction = {
 // ============================================================================
 /** 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
@@ -2051,31 +3508,34 @@ async function buildClmmInstruction(ix, owner, connection, buckets, setupContext
     // Include the CLMM market's ALT so callers can compress remaining accounts
     buckets.addressLookupTableAddresses.push(market.addressLookupTable);
     switch (ix.action) {
-        case ClmmAction.DEPOSIT_LIQUIDITY:
-            buildClmmDepositLiquidity(ix, market, owner, buckets);
+        case vault_instruction_types_2.ClmmAction.DEPOSIT_LIQUIDITY:
+            await buildClmmDepositLiquidity(ix, market, owner, buckets, setupContext);
             break;
-        case ClmmAction.ADD_LIQUIDITY:
+        case vault_instruction_types_2.ClmmAction.ADD_LIQUIDITY:
+            await ensureTrackedClmmPosition({ lpPosition: ix.lpPosition, setupContext });
             buildClmmAddLiquidity(ix, market, owner, buckets);
             break;
-        case ClmmAction.WITHDRAW_LIQUIDITY:
+        case vault_instruction_types_2.ClmmAction.WITHDRAW_LIQUIDITY:
+            await ensureTrackedClmmPosition({ lpPosition: ix.lpPosition, setupContext });
             buildClmmWithdrawLiquidity(ix, market, owner, buckets);
             break;
-        case ClmmAction.TRADE_PT:
+        case vault_instruction_types_2.ClmmAction.TRADE_PT:
             buildClmmTradePt(ix, market, owner, buckets);
             break;
-        case ClmmAction.BUY_PT:
+        case vault_instruction_types_2.ClmmAction.BUY_PT:
             buildClmmBuyPt(ix, market, owner, buckets);
             break;
-        case ClmmAction.SELL_PT:
+        case vault_instruction_types_2.ClmmAction.SELL_PT:
             buildClmmSellPt(ix, market, owner, buckets);
             break;
-        case ClmmAction.BUY_YT:
+        case vault_instruction_types_2.ClmmAction.BUY_YT:
             await buildClmmBuyYt(ix, market, owner, buckets, setupContext);
             break;
-        case ClmmAction.SELL_YT:
+        case vault_instruction_types_2.ClmmAction.SELL_YT:
             await buildClmmSellYt(ix, market, owner, buckets, setupContext);
             break;
-        case ClmmAction.CLAIM_FARM_EMISSION:
+        case vault_instruction_types_2.ClmmAction.CLAIM_FARM_EMISSION:
+            await ensureTrackedClmmPosition({ lpPosition: ix.lpPosition, setupContext });
             buildClmmClaimFarmEmission(ix, market, owner, buckets);
             break;
     }
@@ -2084,7 +3544,7 @@ async function buildClmmInstruction(ix, owner, connection, buckets, setupContext
  * Create a new LP position. Generates the keypair internally and adds it
  * to `buckets.signers` so consumers can include it in the transaction.
  */
-function buildClmmDepositLiquidity(ix, market, owner, buckets) {
+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({
@@ -2098,6 +3558,12 @@ function buildClmmDepositLiquidity(ix, market, owner, buckets) {
     });
     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) {
@@ -2191,6 +3657,7 @@ async function buildClmmBuyYt(ix, market, owner, buckets, setupContext) {
     }
     const { ixs, setupIxs } = market.ixBuyYt({
         trader: owner,
+        payer: setupContext?.signer,
         ytOut: ix.ytOut,
         maxSyIn: ix.maxSyIn,
         lnImpliedApyLimit: ix.lnImpliedApyLimit,
@@ -2212,6 +3679,7 @@ async function buildClmmSellYt(ix, market, owner, buckets, setupContext) {
     }
     const { ixs, setupIxs } = market.ixSellYt({
         trader: owner,
+        payer: setupContext?.signer,
         ytIn: ix.ytIn,
         minSyOut: ix.minSyOut,
         lnImpliedApyLimit: ix.lnImpliedApyLimit,