@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/src/exponentVaults/vault-interaction.ts

@@ -1,22 +1,44 @@
-import { Reserve } from "@exponent-labs/kamino-reserve-deserializer"
+import { BorshCoder, Idl } from "@coral-xyz/anchor"
+import { Fraction, Reserve } from "@exponent-labs/kamino-reserve-deserializer"
+import { fetchKaminoVaultIndex } from "@exponent-labs/exponent-fetcher"
+import { IDL as KaminoVaultIdl } from "@exponent-labs/kamino-vault-idl"
 import { KAMINO_MARKETS, KAMINO_RESERVES, KaminoMarket } from "./kamino-markets"
 import Decimal from "decimal.js"
-import { getKaminoLendObligation, getKaminoUserMetadata, getKaminoFarmsObligationFarm } from "./../../../kamino-lend-standard/src/constants"
-import { KAMINO_LENDING_PROGRAM_ID } from "./policyBuilders"
+import {
+  getKaminoFarmsObligationFarm,
+  getKaminoFarmsRewardsTreasuryVault,
+  getKaminoLendObligation,
+  getKaminoUserMetadata,
+} from "./../../../kamino-lend-standard/src/constants"
+import {
+  KAMINO_FARM_DISCRIMINATORS,
+  KAMINO_LENDING_PROGRAM_ID,
+  KAMINO_VAULT_DISCRIMINATORS,
+  KAMINO_VAULT_PROGRAM_ID,
+} from "./policyBuilders"
 import { Obligation } from "@exponent-labs/klend-idl/accounts"
-import { bigintU256ToString } from "@exponent-labs/precise-number"
 import { Orderbook } from "../orderbook/orderbook"
 import { MarketThree } from "../marketThree"
-import { uniqueRemainingAccounts } from "../utils"
+import { emitEventAuthority, uniqueRemainingAccounts } from "../utils"
 import { SwapDirection } from "../client/clmm"
 import * as exponentClmm from "../client/clmm"
 import * as exponentVaults from "../client/vaults"
 import { OfferType, offerOptions, amount as createAmount } from "../client/orderbook"
 import { LOCAL_ENV, Environment } from "../environment"
 import { Vault } from "../vault"
+import { collectTrackedStrategyVaultPriceIds } from "./vault"
 import { YtPosition } from "../ytPosition"
 import { ExponentVault as StrategyVault } from "./vault"
 import type { ExponentPrice, ExponentPrices } from "@exponent-labs/exponent-vaults-fetcher"
+import { decodeKaminoFarmState, getKaminoFarmScopePricesAddress } from "./kamino-farms"
+import type { PriceId as ClientPriceId } from "../client/vaults/types/priceId"
+import {
+  extractPriceIds,
+  getPriceInputMintFromPriceId,
+  resolveBestKaminoQuotePath,
+  resolveKaminoReservePriceIdOrThrow,
+  resolvePriceIdFromMintToUnderlyingOrThrow,
+} from "./pricePathResolver"
 
 import {
   depositReserveLiquidityAndObligationCollateralV2,
@@ -30,6 +52,7 @@ import {
   refreshObligation,
 } from "@exponent-labs/klend-idl/instructions"
 import {
+  AccountLayout,
   TOKEN_PROGRAM_ID,
   NATIVE_MINT,
   getAssociatedTokenAddressSync,
@@ -43,403 +66,146 @@ import {
 } from "./policyMatcher"
 import { buildScopeRefreshInstructions } from "./scope-refresh"
 import * as web3 from "@solana/web3.js"
-import { AccountMeta, Connection, PublicKey, SystemProgram, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RENT_PUBKEY, TransactionInstruction } from "@solana/web3.js"
+import {
+  AccountMeta,
+  AddressLookupTableAccount,
+  Connection,
+  PublicKey,
+  SystemProgram,
+  SYSVAR_INSTRUCTIONS_PUBKEY,
+  SYSVAR_RENT_PUBKEY,
+  TransactionInstruction,
+  TransactionMessage,
+  VersionedTransaction,
+} from "@solana/web3.js"
 import BN from "bn.js"
 
 const KAMINO_FARMS_PROGRAM_ID = new PublicKey("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr")
+const KAMINO_VAULT_PRICE_TYPE_WIRE = 14
+const KAMINO_VAULT_ACCOUNT_DISCRIMINATOR_LEN = 8
+const KAMINO_VAULT_ALLOCATION_STRATEGY_OFFSET = 304
+const KAMINO_VAULT_ALLOCATION_SIZE = 2160
+const KAMINO_VAULT_ALLOCATION_CTOKEN_VAULT_OFFSET = 32
+const KAMINO_VAULT_GLOBAL_CONFIG_SEED = Buffer.from("global_config")
+const KAMINO_VAULT_CODER = new BorshCoder(KaminoVaultIdl as Idl)
 
 // ============================================================================
-// Vault Instruction Types
-// ============================================================================
-
-type KaminoReserves = typeof KAMINO_RESERVES
-
-/** Actions that can be performed through the vault instruction builder. */
-export enum VaultAction {
-  INIT_USER_METADATA = "INIT_USER_METADATA",
-  INIT_OBLIGATION = "INIT_OBLIGATION",
-  DEPOSIT = "DEPOSIT",
-  WITHDRAW = "WITHDRAW",
-  BORROW = "BORROW",                      
-  REPAY = "REPAY",
-}
-
-/** A market-level instruction (no specific reserve needed). */
-export type MarketInstruction = {
-  action: VaultAction.INIT_USER_METADATA | VaultAction.INIT_OBLIGATION
-  market: KaminoMarket
-}
-
-/** A reserve-level instruction with an amount. */
-export type ReserveInstruction = {
-  action: VaultAction.DEPOSIT | VaultAction.WITHDRAW | VaultAction.BORROW | VaultAction.REPAY
-  market: KaminoMarket
-  asset: string
-  amount: BN
-}
-
-// ============================================================================
-// Orderbook Instruction Types
-// ============================================================================
-
-/** Orderbook trade direction */
-export enum OrderbookTradeDirection {
-  BUY_PT = "BUY_PT",
-  SELL_PT = "SELL_PT",
-  BUY_YT = "BUY_YT",
-  SELL_YT = "SELL_YT",
-}
-
-/** Offer options for limit orders (currently only FillOrKill supported) */
-export type OrderbookOfferOption = "FillOrKill"
-
-/** Actions that can be performed on the Exponent Orderbook */
-export enum OrderbookAction {
-  POST_OFFER = "POST_OFFER",
-  MARKET_OFFER = "MARKET_OFFER",
-  REMOVE_OFFER = "REMOVE_OFFER",
-  WITHDRAW_FUNDS = "WITHDRAW_FUNDS",
-}
-
-export type OrderbookInstructionMode = "wrapper" | "raw"
-
-/** Base instruction type for all orderbook operations */
-interface OrderbookInstructionBase {
-  action: OrderbookAction
-  orderbook: PublicKey
-  mode?: OrderbookInstructionMode
-}
-
-/** Post a limit order on the orderbook */
-export interface OrderbookPostOfferInstruction extends OrderbookInstructionBase {
-  action: OrderbookAction.POST_OFFER
-  direction: OrderbookTradeDirection
-  priceApy: number
-  amount: bigint
-  offerIdx: number
-  offerOption?: OrderbookOfferOption
-  virtualOffer?: boolean
-  expirySeconds?: number
-}
-
-/** Execute a market order on the orderbook */
-export interface OrderbookMarketOfferInstruction extends OrderbookInstructionBase {
-  action: OrderbookAction.MARKET_OFFER
-  direction: OrderbookTradeDirection
-  maxPriceApy: number
-  amount: bigint
-  minAmountOut: bigint
-  virtualOffer?: boolean
-}
-
-/** Cancel an existing limit order */
-export interface OrderbookRemoveOfferInstruction extends OrderbookInstructionBase {
-  action: OrderbookAction.REMOVE_OFFER
-  offerIdx: number
-}
-
-/** Withdraw funds from user escrow */
-export interface OrderbookWithdrawFundsInstruction extends OrderbookInstructionBase {
-  action: OrderbookAction.WITHDRAW_FUNDS
-  ptAmount?: bigint | null
-  ytAmount?: bigint | null
-  syAmount?: bigint | null
-}
-
-/** A single orderbook instruction */
-export type OrderbookInstruction =
-  | OrderbookPostOfferInstruction
-  | OrderbookMarketOfferInstruction
-  | OrderbookRemoveOfferInstruction
-  | OrderbookWithdrawFundsInstruction
-
-// ============================================================================
-// Core Instruction Types (Strip/Merge)
-// ============================================================================
-
-/** Actions that can be performed on Exponent Core */
-export enum CoreAction {
-  STRIP = "STRIP",
-  MERGE = "MERGE",
-  WITHDRAW_YT = "WITHDRAW_YT",
-  DEPOSIT_YT = "DEPOSIT_YT",
-  INITIALIZE_YIELD_POSITION = "INITIALIZE_YIELD_POSITION",
-}
-
-/** Base instruction type for all core operations */
-interface CoreInstructionBase {
-  action: CoreAction
-  vault: PublicKey
-}
-
-/** Strip LST into PT + YT */
-export interface CoreStripInstruction extends CoreInstructionBase {
-  action: CoreAction.STRIP
-  /** Amount of base token (LST) to strip */
-  amountBase: bigint
-}
-
-/** Merge PT + YT into LST */
-export interface CoreMergeInstruction extends CoreInstructionBase {
-  action: CoreAction.MERGE
-  /** Amount of PT/YT to merge (must have equal amounts of both) */
-  amountPy: bigint
-}
-
-/** Withdraw YT from the tracked yield position back into the YT token account */
-export interface CoreWithdrawYtInstruction extends CoreInstructionBase {
-  action: CoreAction.WITHDRAW_YT
-  amountYt: bigint
-}
-
-/** Deposit YT from the YT token account back into the tracked yield position */
-export interface CoreDepositYtInstruction extends CoreInstructionBase {
-  action: CoreAction.DEPOSIT_YT
-  amountYt: bigint
-}
-
-/** Initialize yield position for a vault (owner = Squads vault) */
-export interface CoreInitializeYieldPositionInstruction extends CoreInstructionBase {
-  action: CoreAction.INITIALIZE_YIELD_POSITION
-}
-
-/** A single core instruction */
-export type CoreInstruction =
-  | CoreStripInstruction
-  | CoreMergeInstruction
-  | CoreWithdrawYtInstruction
-  | CoreDepositYtInstruction
-  | CoreInitializeYieldPositionInstruction
-
-// ============================================================================
-// Standard Program Instruction Types (mint_sy / redeem_sy)
-// ============================================================================
-
-export enum SyAction {
-  MINT = "MINT_SY",
-  REDEEM = "REDEEM_SY",
-}
-
-interface SyInstructionBase {
-  action: SyAction
-  vault: PublicKey
-}
-
-export interface SyMintInstruction extends SyInstructionBase {
-  action: SyAction.MINT
-  amountBase: bigint
-}
-
-export interface SyRedeemInstruction extends SyInstructionBase {
-  action: SyAction.REDEEM
-  amountSy: bigint
-}
-
-export type SyInstruction = SyMintInstruction | SyRedeemInstruction
-
-// ============================================================================
-// Titan Instruction Types
-// ============================================================================
-
-export enum TitanAction {
-  SWAP = "SWAP",
-}
-
-/** A pre-built Titan swap instruction to wrap in a sync transaction. */
-export interface TitanSwapInstruction {
-  action: TitanAction.SWAP
-  /** The raw Titan SwapRouteV2 TransactionInstruction (from Titan's router API) */
-  instruction: TransactionInstruction
-}
-
-// ============================================================================
-// Loopscale Instruction Types
-// ============================================================================
-
-/** Actions for Loopscale interactions (loans = borrower side, strategies = lender side). */
-export enum LoopscaleAction {
-  CREATE_LOAN = "LOOPSCALE_CREATE_LOAN",
-  DEPOSIT_COLLATERAL = "LOOPSCALE_DEPOSIT_COLLATERAL",
-  BORROW_PRINCIPAL = "LOOPSCALE_BORROW_PRINCIPAL",
-  REPAY_PRINCIPAL = "LOOPSCALE_REPAY_PRINCIPAL",
-  WITHDRAW_COLLATERAL = "LOOPSCALE_WITHDRAW_COLLATERAL",
-  CLOSE_LOAN = "LOOPSCALE_CLOSE_LOAN",
-  UPDATE_WEIGHT_MATRIX = "LOOPSCALE_UPDATE_WEIGHT_MATRIX",
-  CREATE_STRATEGY = "LOOPSCALE_CREATE_STRATEGY",
-  DEPOSIT_STRATEGY = "LOOPSCALE_DEPOSIT_STRATEGY",
-  WITHDRAW_STRATEGY = "LOOPSCALE_WITHDRAW_STRATEGY",
-  CLOSE_STRATEGY = "LOOPSCALE_CLOSE_STRATEGY",
-  UPDATE_STRATEGY = "LOOPSCALE_UPDATE_STRATEGY",
-  LOCK_LOAN = "LOOPSCALE_LOCK_LOAN",
-  UNLOCK_LOAN = "LOOPSCALE_UNLOCK_LOAN",
-  REFINANCE_LEDGER = "LOOPSCALE_REFINANCE_LEDGER",
-}
-
-/** A pre-built Loopscale instruction (loan or strategy) to wrap in a sync transaction. */
-export interface LoopscaleInstruction {
-  action: LoopscaleAction
-  /** The raw Loopscale TransactionInstruction (from Loopscale API or local builder) */
-  instruction: TransactionInstruction
-}
-
-// ============================================================================
-// 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). */
-export enum ClmmAction {
-  /** Create a new LP position with a specified tick range. Generates keypair internally. */
-  DEPOSIT_LIQUIDITY = "CLMM_DEPOSIT_LIQUIDITY",
-  /** Add more liquidity to an existing LP position. */
-  ADD_LIQUIDITY = "CLMM_ADD_LIQUIDITY",
-  /** Remove liquidity from an LP position and receive PT + SY. */
-  WITHDRAW_LIQUIDITY = "CLMM_WITHDRAW_LIQUIDITY",
-  /** Low-level PT/SY swap. Prefer buyPt/sellPt for directional trades. */
-  TRADE_PT = "CLMM_TRADE_PT",
-  /** Buy PT with SY on the CLMM. */
-  BUY_PT = "CLMM_BUY_PT",
-  /** Sell PT for SY on the CLMM. */
-  SELL_PT = "CLMM_SELL_PT",
-  /** Buy YT with SY on the CLMM. */
-  BUY_YT = "CLMM_BUY_YT",
-  /** Sell YT for SY on the CLMM. */
-  SELL_YT = "CLMM_SELL_YT",
-  /** Claim farm emissions from an LP position. */
-  CLAIM_FARM_EMISSION = "CLMM_CLAIM_FARM_EMISSION",
-}
-
-/** Base type for all CLMM instructions. */
-interface ClmmInstructionBase {
-  action: ClmmAction
-  /** The CLMM MarketThree account address. */
-  market: PublicKey
-}
-
-/** Create a new LP position on the CLMM. The lpPosition keypair is generated internally for good UX. */
-export interface ClmmDepositLiquidityInstruction extends ClmmInstructionBase {
-  action: ClmmAction.DEPOSIT_LIQUIDITY
-  /** Maximum amount of PT to deposit. */
-  ptInIntent: bigint
-  /** Maximum amount of SY to deposit. */
-  syInIntent: bigint
-  /** Lower tick boundary (APY value). */
-  lowerTickKey: number
-  /** Upper tick boundary (APY value). */
-  upperTickKey: number
-}
-
-/** Add liquidity to an existing LP position. */
-export interface ClmmAddLiquidityInstruction extends ClmmInstructionBase {
-  action: ClmmAction.ADD_LIQUIDITY
-  /** The existing LpPosition account public key. */
-  lpPosition: PublicKey
-  /** Maximum amount of PT to add. */
-  ptInIntent: bigint
-  /** Maximum amount of SY to add. */
-  syInIntent: bigint
-}
+export {
+  VaultAction,
+  KaminoVaultAction,
+  KaminoFarmAction,
+  OrderbookTradeDirection,
+  OrderbookAction,
+  CoreAction,
+  SyAction,
+  TitanAction,
+  LoopscaleAction,
+  ClmmAction,
+} from "./vault-instruction-types"
+
+export type {
+  MarketInstruction,
+  ReserveInstruction,
+  KaminoVaultInstruction,
+  KaminoVaultDepositInstruction,
+  KaminoVaultWithdrawInstruction,
+  KaminoFarmInstruction,
+  KaminoFarmInitializeUserInstruction,
+  KaminoFarmStakeInstruction,
+  KaminoFarmUnstakeInstruction,
+  KaminoFarmWithdrawUnstakedDepositsInstruction,
+  KaminoFarmHarvestRewardInstruction,
+  OrderbookOfferOption,
+  OrderbookInstructionMode,
+  OrderbookPostOfferInstruction,
+  OrderbookMarketOfferInstruction,
+  OrderbookRemoveOfferInstruction,
+  OrderbookWithdrawFundsInstruction,
+  OrderbookInstruction,
+  CoreStripInstruction,
+  CoreMergeInstruction,
+  CoreWithdrawYtInstruction,
+  CoreDepositYtInstruction,
+  CoreInitializeYieldPositionInstruction,
+  CoreInstruction,
+  SyMintInstruction,
+  SyRedeemInstruction,
+  SyInstruction,
+  TitanSwapInstruction,
+  LoopscaleInstruction,
+  ClmmDepositLiquidityInstruction,
+  ClmmAddLiquidityInstruction,
+  ClmmWithdrawLiquidityInstruction,
+  ClmmTradePtInstruction,
+  ClmmBuyPtInstruction,
+  ClmmSellPtInstruction,
+  ClmmBuyYtInstruction,
+  ClmmSellYtInstruction,
+  ClmmClaimFarmEmissionInstruction,
+  ClmmInstruction,
+  VaultInstruction,
+  KaminoReserves,
+} from "./vault-instruction-types"
+
+import type {
+  MarketInstruction,
+  ReserveInstruction,
+  KaminoVaultInstruction,
+  KaminoVaultDepositInstruction,
+  KaminoVaultWithdrawInstruction,
+  KaminoFarmInstruction,
+  KaminoFarmInitializeUserInstruction,
+  KaminoFarmStakeInstruction,
+  KaminoFarmUnstakeInstruction,
+  KaminoFarmWithdrawUnstakedDepositsInstruction,
+  KaminoFarmHarvestRewardInstruction,
+  OrderbookOfferOption,
+  OrderbookInstructionMode,
+  OrderbookInstruction,
+  OrderbookPostOfferInstruction,
+  OrderbookMarketOfferInstruction,
+  OrderbookRemoveOfferInstruction,
+  OrderbookWithdrawFundsInstruction,
+  CoreInstruction,
+  CoreStripInstruction,
+  CoreMergeInstruction,
+  CoreWithdrawYtInstruction,
+  CoreDepositYtInstruction,
+  CoreInitializeYieldPositionInstruction,
+  SyInstruction,
+  TitanSwapInstruction,
+  LoopscaleInstruction,
+  ClmmInstruction,
+  ClmmDepositLiquidityInstruction,
+  ClmmAddLiquidityInstruction,
+  ClmmWithdrawLiquidityInstruction,
+  ClmmTradePtInstruction,
+  ClmmBuyPtInstruction,
+  ClmmSellPtInstruction,
+  ClmmBuyYtInstruction,
+  ClmmSellYtInstruction,
+  ClmmClaimFarmEmissionInstruction,
+  VaultInstruction,
+  KaminoReserves,
+  SyMintInstruction,
+  SyRedeemInstruction,
+} from "./vault-instruction-types"
 
-/** Withdraw liquidity from an LP position. */
-export interface ClmmWithdrawLiquidityInstruction extends ClmmInstructionBase {
-  action: ClmmAction.WITHDRAW_LIQUIDITY
-  /** The LpPosition account to withdraw from. */
-  lpPosition: PublicKey
-  /** Amount of liquidity (LP units) to remove. */
-  lpIn: bigint
-  /** Minimum PT to receive (slippage protection). */
-  minPtOut: bigint
-  /** Minimum SY to receive (slippage protection). */
-  minSyOut: bigint
-}
-
-/** Low-level PT/SY swap on the CLMM. Prefer buyPt/sellPt for directional trades. */
-export interface ClmmTradePtInstruction extends ClmmInstructionBase {
-  action: ClmmAction.TRADE_PT
-  /** Amount of the input token. */
-  traderAmount: bigint
-  /** Minimum output amount (slippage protection). */
-  outConstraint: bigint
-  /** Swap direction: SyToPt or PtToSy. */
-  swapDirection: SwapDirection
-  /** Optional price limit (ln implied APY). */
-  lnImpliedApyLimit?: number
-}
-
-/** Buy PT with SY on the CLMM. */
-export interface ClmmBuyPtInstruction extends ClmmInstructionBase {
-  action: ClmmAction.BUY_PT
-  /** Amount of SY to spend. */
-  amountSy: bigint
-  /** Minimum PT to receive (slippage protection). */
-  outConstraint: bigint
-  /** Optional price limit (ln implied APY). */
-  lnImpliedApyLimit?: number
-}
-
-/** Sell PT for SY on the CLMM. */
-export interface ClmmSellPtInstruction extends ClmmInstructionBase {
-  action: ClmmAction.SELL_PT
-  /** Amount of PT to sell. */
-  amountPt: bigint
-  /** Minimum SY to receive (slippage protection). */
-  outConstraint: bigint
-  /** Optional price limit (ln implied APY). */
-  lnImpliedApyLimit?: number
-}
-
-/** Buy YT with SY on the CLMM. */
-export interface ClmmBuyYtInstruction extends ClmmInstructionBase {
-  action: ClmmAction.BUY_YT
-  /** Minimum amount of YT to receive. */
-  ytOut: bigint
-  /** Maximum amount of SY to spend. */
-  maxSyIn: bigint
-  /** Optional price limit (ln implied APY). */
-  lnImpliedApyLimit?: number
-}
-
-/** Sell YT for SY on the CLMM. */
-export interface ClmmSellYtInstruction extends ClmmInstructionBase {
-  action: ClmmAction.SELL_YT
-  /** Amount of YT to sell. */
-  ytIn: bigint
-  /** Minimum SY to receive (slippage protection). */
-  minSyOut: bigint
-  /** Optional price limit (ln implied APY). */
-  lnImpliedApyLimit?: number
-}
-
-/** Claim farm emissions from an LP position. */
-export interface ClmmClaimFarmEmissionInstruction extends ClmmInstructionBase {
-  action: ClmmAction.CLAIM_FARM_EMISSION
-  /** The LpPosition account to claim from. */
-  lpPosition: PublicKey
-  /** Index of the farm to claim from. */
-  farmIndex: number
-}
-
-/** A single CLMM instruction. */
-export type ClmmInstruction =
-  | ClmmDepositLiquidityInstruction
-  | ClmmAddLiquidityInstruction
-  | ClmmWithdrawLiquidityInstruction
-  | ClmmTradePtInstruction
-  | ClmmBuyPtInstruction
-  | ClmmSellPtInstruction
-  | ClmmBuyYtInstruction
-  | ClmmSellYtInstruction
-  | ClmmClaimFarmEmissionInstruction
-
-/** A single vault instruction — pass an array of these to `createVaultSyncTransaction`. */
-export type VaultInstruction =
-  | MarketInstruction
-  | ReserveInstruction
-  | OrderbookInstruction
-  | CoreInstruction
-  | SyInstruction
-  | TitanSwapInstruction
-  | ClmmInstruction
-  | LoopscaleInstruction
+import {
+  VaultAction,
+  KaminoVaultAction,
+  KaminoFarmAction,
+  OrderbookAction,
+  CoreAction,
+  SyAction,
+  TitanAction,
+  LoopscaleAction,
+  ClmmAction,
+  OrderbookTradeDirection,
+} from "./vault-instruction-types"
 
 // ============================================================================
 // Kamino Action Builders
@@ -483,7 +249,8 @@ export const kaminoAction = {
 
   /**
    * 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: KaminoMarket): MarketInstruction {
@@ -532,6 +299,92 @@ export const kaminoAction = {
   },
 }
 
+/**
+ * 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.
+ */
+export const 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: {
+    vault: PublicKey
+    amount: BN
+  }): KaminoVaultDepositInstruction {
+    return { action: 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: {
+    vault: PublicKey
+    sharesAmount: BN
+    reserve?: PublicKey
+  }): KaminoVaultWithdrawInstruction {
+    return { action: KaminoVaultAction.WITHDRAW, ...params }
+  },
+}
+
+/**
+ * Builder for direct Kamino Farm action descriptors.
+ *
+ * These actions operate on a farm `user_state` derived from the managed vault
+ * owner by default. Pass `delegatee` when targeting a delegated farm user
+ * state, such as a Kamino obligation-owned farm entry.
+ */
+export const kaminoFarmAction = {
+  /** Initialize the farm `user_state` PDA. */
+  initializeUser(params: {
+    farmState: PublicKey
+    delegatee?: PublicKey
+  }): KaminoFarmInitializeUserInstruction {
+    return { action: KaminoFarmAction.INITIALIZE_USER, ...params }
+  },
+
+  /** Stake the managed vault's token ATA into the farm. */
+  stake(params: {
+    farmState: PublicKey
+    amount: BN | "ALL"
+    delegatee?: PublicKey
+  }): KaminoFarmStakeInstruction {
+    return { action: KaminoFarmAction.STAKE, ...params }
+  },
+
+  /** Unstake a scaled share amount from the farm. */
+  unstake(params: {
+    farmState: PublicKey
+    stakeSharesScaled: BN
+    delegatee?: PublicKey
+  }): KaminoFarmUnstakeInstruction {
+    return { action: KaminoFarmAction.UNSTAKE, ...params }
+  },
+
+  /** Withdraw matured unstaked deposits back into the managed vault ATA. */
+  withdrawUnstakedDeposits(params: {
+    farmState: PublicKey
+    delegatee?: PublicKey
+  }): KaminoFarmWithdrawUnstakedDepositsInstruction {
+    return { action: KaminoFarmAction.WITHDRAW_UNSTAKED_DEPOSITS, ...params }
+  },
+
+  /** Harvest a specific reward index into a managed vault reward ATA. */
+  harvestReward(params: {
+    farmState: PublicKey
+    rewardIndex: number
+    delegatee?: PublicKey
+  }): KaminoFarmHarvestRewardInstruction {
+    return { action: KaminoFarmAction.HARVEST_REWARD, ...params }
+  },
+}
+
 // ============================================================================
 // Sync Transaction Builder
 // ============================================================================
@@ -565,57 +418,12 @@ export interface VaultSyncTransactionResult {
   addressLookupTableAddresses: PublicKey[]
 }
 
-/**
- * Build vault instructions and wrap them in a Squads sync transaction.
- *
- * Takes high-level `VaultInstruction` descriptors (built with `kamino.*`),
- * resolves them to raw Solana instructions, then separates them:
- * - Permissionless refresh instructions → `preInstructions` (top-level)
- * - Vault-signed instructions → `instruction` (Squads sync transaction)
- *
- * KLend's `check_refresh` requires refreshReserve to be a top-level instruction
- * so it can be found via the instruction sysvar.
- *
- * @returns `{ setupInstructions, preInstructions, instruction, postInstructions, signers, addressLookupTableAddresses }`
- *
- * @example
- * ```ts
- * const { setupInstructions, preInstructions, instruction, postInstructions, signers, addressLookupTableAddresses } = await createVaultSyncTransaction({
- *   instructions: [
- *     kamino.initUserMetadata(KaminoMarket.MAIN),
- *     kamino.initObligation(KaminoMarket.MAIN),
- *     kamino.deposit(KaminoMarket.MAIN, "USDC", new BN(1_000_000)),
- *   ],
- *   owner: vaultPda,
- *   connection,
- *   policyPda,
- *   vaultPda,
- *   signer: wallet.publicKey,
- *   vaultAddress: VAULT_ADDRESS,
- * })
- * // Send: [...setupInstructions, ...preInstructions, instruction, ...postInstructions]
- * ```
- */
-export async function createVaultSyncTransaction({
-  instructions,
-  owner,
-  connection,
-  policyPda,
-  vaultPda,
-  signer,
-  accountIndex = 0,
-  constraintIndices,
-  vaultAddress,
-  leadingAccounts,
-  preHookAccounts,
-  postHookAccounts,
-  squadsProgram = SQUADS_PROGRAM_ID,
-}: {
+type CreateVaultSyncTransactionParams = {
   instructions: VaultInstruction[]
   owner: PublicKey
   connection: Connection
   policyPda?: PublicKey
-  vaultPda: PublicKey
+  vaultPda?: PublicKey
   signer: PublicKey
   accountIndex?: number
   constraintIndices?: number[]
@@ -625,8 +433,87 @@ export async function createVaultSyncTransaction({
   preHookAccounts?: PublicKey[] | AccountMeta[]
   postHookAccounts?: PublicKey[] | AccountMeta[]
   squadsProgram?: PublicKey
-}): Promise<VaultSyncTransactionResult> {
-  const { setupInstructions, syncInstructions, preInstructions, postInstructions, signers, addressLookupTableAddresses } = await buildVaultInstructions(
+  /** Automatically manage new Kamino/CLMM/yield position tracking for manager flows. Defaults to `false` for this low-level helper. */
+  autoManagePositions?: boolean
+  /** Optional shared setup context — when provided, setup state (tracked accounts, positions) is shared across calls, preventing duplicate setup instructions. */
+  setupContext?: StrategySetupContext
+}
+
+/**
+ * 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.
+ */
+export async function createVaultSyncTransactions(
+  params: CreateVaultSyncTransactionParams,
+): Promise<VaultSyncTransactionResult[]> {
+  return buildVaultSyncTransactionResults(params, true)
+}
+
+/**
+ * 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:
+ * - Permissionless refresh instructions → `preInstructions` (top-level)
+ * - Vault-signed instructions → `instruction` (Squads sync transaction)
+ *
+ * KLend's `check_refresh` requires refreshReserve to be a top-level instruction
+ * so it can be found via the instruction sysvar.
+ *
+ * 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}.
+ */
+export async function createVaultSyncTransaction(
+  params: CreateVaultSyncTransactionParams,
+): Promise<VaultSyncTransactionResult> {
+  const results = await buildVaultSyncTransactionResults(params, false)
+  return results[0]!
+}
+
+async function buildVaultSyncTransactionResults(
+  {
+    instructions,
+    owner,
+    connection,
+    policyPda,
+    vaultPda,
+    signer,
+    accountIndex = 0,
+    constraintIndices,
+    vaultAddress,
+    leadingAccounts,
+    preHookAccounts,
+    postHookAccounts,
+    squadsProgram = SQUADS_PROGRAM_ID,
+    autoManagePositions = false,
+    setupContext,
+  }: CreateVaultSyncTransactionParams,
+  splitOversizedKaminoVaultWithdraw: boolean,
+): Promise<VaultSyncTransactionResult[]> {
+  vaultPda ??= owner
+
+  const resolvedSetupContext = setupContext ?? createStrategySetupContext({
+    connection,
+    env: LOCAL_ENV,
+    owner,
+    signer,
+    vaultAddress,
+    policyPda,
+    vaultPda,
+    accountIndex,
+    squadsProgram,
+    leadingAccounts,
+    preHookAccounts,
+    postHookAccounts,
+    autoManagePositions,
+  })
+
+  const buckets = await buildVaultInstructions(
     instructions,
     owner,
     connection,
@@ -639,55 +526,236 @@ export async function createVaultSyncTransaction({
     preHookAccounts,
     postHookAccounts,
     squadsProgram,
+    autoManagePositions,
+    resolvedSetupContext,
   )
 
-  let resolvedPolicyPda = policyPda
-  let resolvedConstraintIndices = constraintIndices
-  if (!resolvedPolicyPda) {
-    if (!vaultAddress) {
-      throw new Error("vaultAddress is required when policyPda is not provided")
-    }
-    const match = await resolvePolicyMatchForVault(connection, vaultAddress, signer, syncInstructions)
-    resolvedPolicyPda = match.policyPda
-    resolvedConstraintIndices ??= match.constraintIndices
-  }
+  const setupStatePriceRefreshInstructions = setupContext
+    ? []
+    : await buildSetupStatePriceRefreshInstructions(resolvedSetupContext)
 
-  // Auto-resolve constraint indices when not explicitly provided
-  resolvedConstraintIndices ??= await resolveConstraintIndices(
+  const fullResult = await buildWrappedVaultSyncTransactionResult({
     connection,
-    resolvedPolicyPda,
-    syncInstructions,
-  )
-
-  // Auto-resolve policy prefix and hook accounts when not explicitly provided
-  let resolvedLeadingAccounts = leadingAccounts
-  let resolvedPreHookAccounts = preHookAccounts
-  let resolvedPostHookAccounts = postHookAccounts
-  if (vaultAddress && (!leadingAccounts || !preHookAccounts || !postHookAccounts)) {
-    const hooks = await resolveHookAccounts(connection, resolvedPolicyPda, vaultAddress, signer)
-    resolvedLeadingAccounts ??= hooks.leadingAccounts
-    resolvedPreHookAccounts ??= hooks.preHookAccounts
-    resolvedPostHookAccounts ??= hooks.postHookAccounts
-  }
-
-  const instruction = wrapInstructionsInSyncTransaction({
-    policyPda: resolvedPolicyPda,
+    policyPda,
     vaultPda,
     signer,
-    instructions: syncInstructions,
-    squadsProgram,
     accountIndex,
-    constraintIndices: resolvedConstraintIndices,
-    leadingAccounts: resolvedLeadingAccounts,
-    preHookAccounts: resolvedPreHookAccounts,
-    postHookAccounts: resolvedPostHookAccounts,
+    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,
   })
 
-  return { setupInstructions, preInstructions, instruction, postInstructions, signers, addressLookupTableAddresses }
-}
+  const isPlannerExpandedKaminoVaultWithdraw =
+    instructions.length === 1
+    && instructions[0]?.action === KaminoVaultAction.WITHDRAW
+    && !(instructions[0] as KaminoVaultWithdrawInstruction).reserve
+    && buckets.syncInstructions.length > 1
 
-// ============================================================================
-// Internal: Instruction Assembly
+  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: VaultSyncTransactionResult[] = []
+  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,
+}: {
+  connection: Connection
+  policyPda?: PublicKey
+  vaultPda: PublicKey
+  signer: PublicKey
+  accountIndex: number
+  constraintIndices?: number[]
+  vaultAddress?: PublicKey
+  leadingAccounts?: PublicKey[] | AccountMeta[]
+  preHookAccounts?: PublicKey[] | AccountMeta[]
+  postHookAccounts?: PublicKey[] | AccountMeta[]
+  squadsProgram: PublicKey
+  syncInstructions: TransactionInstruction[]
+  setupInstructions: TransactionInstruction[]
+  preInstructions: TransactionInstruction[]
+  postInstructions: TransactionInstruction[]
+  signers: web3.Signer[]
+  addressLookupTableAddresses: PublicKey[]
+}): Promise<VaultSyncTransactionResult> {
+  let resolvedPolicyPda = policyPda
+  let resolvedConstraintIndices = constraintIndices
+  if (!resolvedPolicyPda) {
+    if (!vaultAddress) {
+      throw new Error("vaultAddress is required when policyPda is not provided")
+    }
+    const match = await resolvePolicyMatchForVault(connection, vaultAddress, signer, syncInstructions)
+    resolvedPolicyPda = match.policyPda
+    resolvedConstraintIndices ??= match.constraintIndices
+  }
+
+  resolvedConstraintIndices ??= await resolveConstraintIndices(
+    connection,
+    resolvedPolicyPda,
+    syncInstructions,
+  )
+
+  let resolvedLeadingAccounts = leadingAccounts
+  let resolvedPreHookAccounts = preHookAccounts
+  let resolvedPostHookAccounts = postHookAccounts
+  if (vaultAddress && (!leadingAccounts || !preHookAccounts || !postHookAccounts)) {
+    const hooks = await resolveHookAccounts(connection, resolvedPolicyPda, vaultAddress, signer)
+    resolvedLeadingAccounts ??= hooks.leadingAccounts
+    resolvedPreHookAccounts ??= hooks.preHookAccounts
+    resolvedPostHookAccounts ??= hooks.postHookAccounts
+  }
+
+  const instruction = wrapInstructionsInSyncTransaction({
+    policyPda: resolvedPolicyPda,
+    vaultPda,
+    signer,
+    instructions: syncInstructions,
+    squadsProgram,
+    accountIndex,
+    constraintIndices: resolvedConstraintIndices,
+    leadingAccounts: resolvedLeadingAccounts,
+    preHookAccounts: resolvedPreHookAccounts,
+    postHookAccounts: resolvedPostHookAccounts,
+  })
+
+  return {
+    setupInstructions,
+    preInstructions,
+    instruction,
+    postInstructions,
+    signers,
+    addressLookupTableAddresses,
+  }
+}
+
+async function vaultSyncResultFitsInSingleTransaction(params: {
+  connection: Connection
+  payer: PublicKey
+  result: VaultSyncTransactionResult
+}): Promise<boolean> {
+  try {
+    const altAccounts = await resolveVaultSyncAltAccounts(
+      params.connection,
+      params.result.addressLookupTableAddresses,
+    )
+    const message = new TransactionMessage({
+      payerKey: params.payer,
+      recentBlockhash: PublicKey.default.toBase58(),
+      instructions: [...params.result.preInstructions, params.result.instruction, ...params.result.postInstructions],
+    }).compileToV0Message(altAccounts)
+
+    return new VersionedTransaction(message).serialize().length <= 1232
+  } catch {
+    return false
+  }
+}
+
+async function resolveVaultSyncAltAccounts(
+  connection: Connection,
+  addresses: PublicKey[],
+): Promise<AddressLookupTableAccount[]> {
+  const lookupTables = await Promise.all(addresses.map((address) => connection.getAddressLookupTable(address)))
+  return lookupTables
+    .map((entry) => entry.value)
+    .filter((entry): entry is AddressLookupTableAccount => entry !== null)
+}
+
+// ============================================================================
+// Internal: Instruction Assembly
 // ============================================================================
 
 /** KLend farm modes — collateral for deposit/withdraw, debt for borrow/repay. */
@@ -704,6 +772,14 @@ interface InstructionBuckets {
   addressLookupTableAddresses: PublicKey[]
 }
 
+function isKaminoVaultInstruction(ix: VaultInstruction): ix is KaminoVaultInstruction {
+  return Object.values(KaminoVaultAction).includes(ix.action as KaminoVaultAction)
+}
+
+function isKaminoFarmInstruction(ix: VaultInstruction): ix is KaminoFarmInstruction {
+  return Object.values(KaminoFarmAction).includes(ix.action as KaminoFarmAction)
+}
+
 function isOrderbookInstruction(ix: VaultInstruction): ix is OrderbookInstruction {
   return Object.values(OrderbookAction).includes(ix.action as OrderbookAction)
 }
@@ -740,24 +816,37 @@ const TITAN_OUTPUT_TOKEN_PROGRAM_ACCOUNT_INDEX = 7
 const YIELD_POSITION_BASE_SIZE = 124
 const YIELD_POSITION_TRACKER_SIZE = 40
 
-type SimplePriceLookup = {
-  priceId: bigint
-  price: Decimal
+type TrackedKaminoObligationState = {
+  quotePriceId: ClientPriceId
+  quoteInputMint: PublicKey
+  mappedReserves: Set<string>
 }
 
 type StrategySetupState = {
   strategyVault: StrategyVault
   prices: ExponentPrices
+  requiredPriceIds: Set<number>
   nextStrategyPositionIndex: number
   trackedOrderbooks: Set<string>
   trackedYieldVaults: Set<string>
+  trackedKaminoObligations: Map<string, TrackedKaminoObligationState>
+  trackedKaminoFarms: Set<string>
+  trackedClmmPositions: Set<string>
   tokenEntryAccountByMint: Map<string, string>
   tokenPositionIndexByMint: Map<string, number>
   trackedTokenAccounts: Set<string>
+  baseAumAccounts: AccountMeta[]
+  plannedAumAccounts: AccountMeta[]
   existingAccounts: Map<string, boolean>
 }
 
-type StrategySetupContext = {
+type ResolvedHookAccounts = {
+  leadingAccounts: PublicKey[] | AccountMeta[]
+  preHookAccounts: PublicKey[] | AccountMeta[]
+  postHookAccounts: PublicKey[] | AccountMeta[]
+}
+
+export type StrategySetupContext = {
   connection: Connection
   env: Environment
   owner: PublicKey
@@ -770,10 +859,14 @@ type StrategySetupContext = {
   leadingAccounts?: PublicKey[] | AccountMeta[]
   preHookAccounts?: PublicKey[] | AccountMeta[]
   postHookAccounts?: PublicKey[] | AccountMeta[]
+  autoManagePositions: boolean
+  pricesAccount?: ExponentPrices
   statePromise?: Promise<StrategySetupState | null>
+  /** Cached hook resolution promise — avoids redundant RPC calls when wrapping multiple setup instructions. */
+  resolvedHooksPromise?: Promise<ResolvedHookAccounts>
 }
 
-function createStrategySetupContext({
+export function createStrategySetupContext({
   connection,
   env,
   owner,
@@ -786,6 +879,8 @@ function createStrategySetupContext({
   leadingAccounts,
   preHookAccounts,
   postHookAccounts,
+  autoManagePositions = true,
+  pricesAccount,
 }: {
   connection: Connection
   env: Environment
@@ -799,6 +894,8 @@ function createStrategySetupContext({
   leadingAccounts?: PublicKey[] | AccountMeta[]
   preHookAccounts?: PublicKey[] | AccountMeta[]
   postHookAccounts?: PublicKey[] | AccountMeta[]
+  autoManagePositions?: boolean
+  pricesAccount?: ExponentPrices
 }): StrategySetupContext {
   return {
     connection,
@@ -813,6 +910,17 @@ function createStrategySetupContext({
     leadingAccounts,
     preHookAccounts,
     postHookAccounts,
+    autoManagePositions,
+    pricesAccount,
+  }
+}
+
+function trackRequiredPriceIds(requiredPriceIds: Set<number>, priceIdValue: unknown) {
+  for (const id of extractPriceIds(priceIdValue)) {
+    const numericId = Number(id)
+    if (numericId !== 0) {
+      requiredPriceIds.add(numericId)
+    }
   }
 }
 
@@ -828,10 +936,13 @@ async function loadStrategySetupState(context: StrategySetupContext): Promise<St
         connection: context.connection,
         address: context.vaultAddress!,
       })
-      const prices = await strategyVault.fetcher.fetchExponentPrices()
+      const prices = context.pricesAccount ?? await strategyVault.fetcher.fetchExponentPrices()
 
       const trackedOrderbooks = new Set<string>()
       const trackedYieldVaults = new Set<string>()
+      const trackedKaminoObligations = new Map<string, TrackedKaminoObligationState>()
+      const trackedKaminoFarms = new Set<string>()
+      const trackedClmmPositions = new Set<string>()
       const tokenEntryAccountByMint = new Map<string, string>()
       const tokenPositionIndexByMint = new Map<string, number>()
       const trackedTokenAccounts = new Set<string>()
@@ -850,6 +961,27 @@ async function loadStrategySetupState(context: StrategySetupContext): Promise<St
           trackedYieldVaults.add(position.yieldPosition[0].vault.toBase58())
           continue
         }
+        const kaminoEntry = getTrackedKaminoObligationFromPosition(position)
+        if (kaminoEntry) {
+          trackedKaminoObligations.set(kaminoEntry.obligation.toBase58(), {
+            quotePriceId: kaminoEntry.quotePriceId,
+            quoteInputMint: 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)
@@ -862,12 +994,21 @@ async function loadStrategySetupState(context: StrategySetupContext): Promise<St
       return {
         strategyVault,
         prices,
+        requiredPriceIds: collectTrackedStrategyVaultPriceIds({
+          tokenEntries: strategyVault.state.tokenEntries,
+          strategyPositions: strategyVault.state.strategyPositions as Array<Record<string, unknown>>,
+        }),
         nextStrategyPositionIndex: strategyVault.state.strategyPositions.length,
         trackedOrderbooks,
         trackedYieldVaults,
+        trackedKaminoObligations,
+        trackedKaminoFarms,
+        trackedClmmPositions,
         tokenEntryAccountByMint,
         tokenPositionIndexByMint,
         trackedTokenAccounts,
+        baseAumAccounts: mutableStrategyVault(strategyVault).aumRemainingAccounts(),
+        plannedAumAccounts: [],
         existingAccounts: new Map<string, boolean>(),
       }
     })()
@@ -876,163 +1017,544 @@ async function loadStrategySetupState(context: StrategySetupContext): Promise<St
   return context.statePromise
 }
 
-function findSimplePrice(
-  prices: ExponentPrices,
-  priceMint: PublicKey,
-  underlyingMint: PublicKey,
-): SimplePriceLookup | null {
-  for (const entry of prices.prices) {
-    if (!entry) continue
-    if (!entry.priceMint.equals(priceMint) || !entry.underlyingMint.equals(underlyingMint)) {
+export async function buildSetupStatePriceRefreshInstructions(
+  setupContext: StrategySetupContext,
+): Promise<TransactionInstruction[]> {
+  const state = await loadStrategySetupState(setupContext)
+  if (!state) {
+    return []
+  }
+
+  const refreshInstructions: TransactionInstruction[] = []
+  const reserveAccounts = new Map<string, { account: Reserve }>()
+  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 Reserve.fetch(setupContext.connection, reserveAddress)
+      if (!reserveAccount) {
+        throw new Error(`Missing Kamino reserve account ${reserveKey} required to refresh Kamino vault prices`)
+      }
+
+      reserveAccounts.set(reserveKey, { account: reserveAccount })
+    }
+  }
+
+  if (reserveAccounts.size > 0) {
+    const reserves = [...reserveAccounts.values()]
+    const defaultKey = PublicKey.default
+    const oracleOrSentinel = (key: PublicKey) =>
+      key.equals(defaultKey) ? KAMINO_LENDING_PROGRAM_ID : key
+
+    refreshInstructions.push(...await buildScopeRefreshInstructions(setupContext.connection, reserves))
+
+    for (const [reserveKey, { account }] of reserveAccounts.entries()) {
+      const tokenInfo = account.config.tokenInfo
+      refreshInstructions.push(
+        refreshReserve({
+          reserve: new 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),
+        }),
+      )
     }
   }
 
-  return null
+  const updatePriceInstructions = await state.strategyVault.ixsUpdateStrategyVaultPrices(state.prices, {
+    manager: setupContext.signer,
+    priceIds: [...state.requiredPriceIds].sort((a, b) => a - b),
+  })
+
+  return [...refreshInstructions, ...updatePriceInstructions]
 }
 
-function exponentPriceToDecimal(entry: ExponentPrice): Decimal {
-  const raw = entry.price[0]
-  if (!Array.isArray(raw)) {
-    throw new Error(`Invalid Exponent price format for ${entry.priceId.toString()}`)
-  }
-  return new Decimal(bigintU256ToString(raw.map((value) => BigInt(value.toString()))))
+function isAutoManagePositionsEnabled(setupContext?: StrategySetupContext): boolean {
+  return setupContext?.autoManagePositions ?? true
 }
 
-async function accountExists(
-  state: StrategySetupState,
-  connection: Connection,
-  address: PublicKey,
-): Promise<boolean> {
-  const cacheKey = address.toBase58()
-  const cached = state.existingAccounts.get(cacheKey)
-  if (cached !== undefined) {
-    return cached
+function unwrapTupleLikeValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value[0]
   }
-
-  const exists = (await connection.getAccountInfo(address)) !== null
-  state.existingAccounts.set(cacheKey, exists)
-  return exists
+  if (value && typeof value === "object" && "0" in value) {
+    return (value as { 0?: unknown })[0]
+  }
+  return value ?? undefined
 }
 
-async function maybeCreateOwnedAtaSetupInstruction({
-  state,
-  connection,
-  payer,
-  owner,
-  mint,
-  tokenProgram,
-  tokenAccount,
-}: {
-  state: StrategySetupState
-  connection: Connection
-  payer: PublicKey
-  owner: PublicKey
-  mint: PublicKey
-  tokenProgram: PublicKey
-  tokenAccount: PublicKey
-}): Promise<TransactionInstruction | null> {
-  if (await accountExists(state, connection, tokenAccount)) {
+function getTrackedKaminoObligationFromPosition(position: unknown): {
+  obligation: PublicKey
+  quotePriceId: ClientPriceId
+  reservePriceMappings: Array<{ reserve: PublicKey; reservePriceId: ClientPriceId }>
+} | null {
+  if (!position || typeof position !== "object" || !("obligation" in position)) {
     return null
   }
 
-  const expectedAta = getAssociatedTokenAddressSync(mint, owner, true, tokenProgram)
-  if (!expectedAta.equals(tokenAccount)) {
+  const obligationContainer = (position as { obligation?: unknown }).obligation
+  const obligationValue = unwrapTupleLikeValue(obligationContainer)
+  const kaminoContainer = (
+    obligationValue
+    && typeof obligationValue === "object"
+    && "kaminoObligation" in (obligationValue as Record<string, unknown>)
+  )
+    ? (obligationValue as { kaminoObligation?: unknown }).kaminoObligation
+    : obligationValue
+  const kaminoEntry = unwrapTupleLikeValue(kaminoContainer)
+
+  if (
+    !kaminoEntry
+    || typeof kaminoEntry !== "object"
+    || !("obligation" in kaminoEntry)
+    || !((kaminoEntry as { obligation?: unknown }).obligation instanceof PublicKey)
+  ) {
     return null
   }
 
-  state.existingAccounts.set(tokenAccount.toBase58(), true)
-  return createAssociatedTokenAccountIdempotentInstruction(payer, tokenAccount, owner, mint, tokenProgram)
-}
+  const typedKaminoEntry = kaminoEntry as {
+    obligation: PublicKey
+    quotePriceId: ClientPriceId
+    reservePriceMappings?: Array<{ reserve: PublicKey; reservePriceId: ClientPriceId }>
+  }
 
-async function ensureOrderbookPositionSetup(
-  orderbook: Orderbook,
-  buckets: InstructionBuckets,
-  setupContext: StrategySetupContext,
-) {
-  const state = await loadStrategySetupState(setupContext)
-  if (!state) {
-    return
+  return {
+    obligation: typedKaminoEntry.obligation,
+    quotePriceId: typedKaminoEntry.quotePriceId,
+    reservePriceMappings: typedKaminoEntry.reservePriceMappings ?? [],
   }
+}
 
-  const orderbookKey = orderbook.selfAddress.toBase58()
-  if (state.trackedOrderbooks.has(orderbookKey)) {
-    return
+function getTrackedKaminoFarmFromPosition(position: unknown): {
+  farmState: PublicKey
+  userState: PublicKey
+} | null {
+  if (!position || typeof position !== "object" || !("kaminoFarm" in position)) {
+    return null
   }
 
-  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 kaminoFarmContainer = (position as { kaminoFarm?: unknown }).kaminoFarm
+  const kaminoFarmEntry = unwrapTupleLikeValue(kaminoFarmContainer)
+  if (
+    !kaminoFarmEntry
+    || typeof kaminoFarmEntry !== "object"
+    || !((kaminoFarmEntry as { farmState?: unknown }).farmState instanceof PublicKey)
+    || !((kaminoFarmEntry as { userState?: unknown }).userState instanceof PublicKey)
+  ) {
+    return null
   }
 
-  buckets.setupInstructions.push(
-    state.strategyVault.ixWrapperManageVaultSettings({
-      manager: setupContext.signer,
-      actions: [
-        exponentVaults.vaultSettingsAction("AddOrderbookEntry", [{
-          orderbook: orderbook.selfAddress,
-          // Legacy field retained for layout compatibility. Order ownership is
-          // derived from live orderbook state during AUM calculation.
-          userEscrowIdx: 0,
-          mint: orderbook.vault.mintSy,
-          offerIdxVec: [],
-          priceIdPt: exponentVaults.priceId("Simple", { priceId: ptPrice.priceId }),
-          baseMint: state.strategyVault.state.underlyingMint,
-        }]),
-      ],
-      remainingAccounts: [
-        { pubkey: orderbook.selfAddress, isSigner: false, isWritable: false },
-        { pubkey: orderbook.state.vault, isSigner: false, isWritable: false },
-      ],
-    }),
-  )
+  return {
+    farmState: (kaminoFarmEntry as { farmState: PublicKey }).farmState,
+    userState: (kaminoFarmEntry as { userState: PublicKey }).userState,
+  }
+}
 
-  state.trackedOrderbooks.add(orderbookKey)
-  state.nextStrategyPositionIndex += 1
+function kaminoFarmKey(farmState: PublicKey, userState: PublicKey): string {
+  return `${farmState.toBase58()}:${userState.toBase58()}`
 }
 
-async function ensureYieldPositionSetup(
-  coreVault: Vault,
-  buckets: InstructionBuckets,
-  setupContext: StrategySetupContext,
-) {
-  const state = await loadStrategySetupState(setupContext)
-  if (!state) {
-    return
+function getTrackedClmmPositionFromPosition(position: unknown): {
+  lpPosition: PublicKey
+  market: PublicKey
+} | null {
+  if (!position || typeof position !== "object" || !("clmmPosition" in position)) {
+    return null
   }
 
-  const coreVaultKey = coreVault.selfAddress.toBase58()
-  if (state.trackedYieldVaults.has(coreVaultKey)) {
-    return
+  const clmmContainer = (position as { clmmPosition?: unknown }).clmmPosition
+  const clmmEntry = unwrapTupleLikeValue(clmmContainer)
+  if (
+    !clmmEntry
+    || typeof clmmEntry !== "object"
+    || !((clmmEntry as { lpPosition?: unknown }).lpPosition instanceof PublicKey)
+    || !((clmmEntry as { market?: unknown }).market instanceof PublicKey)
+  ) {
+    return null
   }
 
-  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()})`)
+  return {
+    lpPosition: (clmmEntry as { lpPosition: PublicKey }).lpPosition,
+    market: (clmmEntry as { market: PublicKey }).market,
   }
+}
 
-  const yieldPosition = coreVault.pda.yieldPosition({ owner: setupContext.owner, vault: coreVault.selfAddress })
-  if (!(await accountExists(state, setupContext.connection, yieldPosition))) {
-    const requiredLamports = await setupContext.connection.getMinimumBalanceForRentExemption(
-      YIELD_POSITION_BASE_SIZE + (coreVault.state.emissions.length * YIELD_POSITION_TRACKER_SIZE),
-    )
-    const ownerLamports = await setupContext.connection.getBalance(setupContext.owner)
-    if (ownerLamports < requiredLamports) {
+async function accountExists(
+  state: StrategySetupState,
+  connection: Connection,
+  address: PublicKey,
+): Promise<boolean> {
+  const cacheKey = address.toBase58()
+  const cached = state.existingAccounts.get(cacheKey)
+  if (cached !== undefined) {
+    return cached
+  }
+
+  const exists = (await connection.getAccountInfo(address)) !== null
+  state.existingAccounts.set(cacheKey, exists)
+  return exists
+}
+
+type MutableStrategyVault = {
+  aumRemainingAccounts(): AccountMeta[]
+  clmmTicksMap: Map<string, PublicKey>
+}
+
+function mutableStrategyVault(value: StrategySetupState | StrategyVault): MutableStrategyVault {
+  return ("strategyVault" in value ? value.strategyVault : value) as unknown as MutableStrategyVault
+}
+
+function buildTrackedAumRemainingAccounts(
+  state: StrategySetupState,
+  extraAccounts: AccountMeta[] = [],
+): AccountMeta[] {
+  return uniqueRemainingAccounts([
+    ...state.baseAumAccounts,
+    ...state.plannedAumAccounts,
+    ...extraAccounts,
+  ])
+}
+
+function recordPlannedOrderbookEntry(
+  state: StrategySetupState,
+  params: { orderbook: PublicKey; mint: PublicKey; priceIdPt: ClientPriceId; baseMint: PublicKey },
+) {
+  state.trackedOrderbooks.add(params.orderbook.toBase58())
+  state.plannedAumAccounts.push({ pubkey: params.orderbook, isSigner: false, isWritable: false })
+  ;(state.strategyVault.state.strategyPositions as unknown as Array<Record<string, unknown>>).push({
+    orderbook: [{
+      orderbook: params.orderbook,
+      mint: params.mint,
+      offerIdxVec: [],
+      priceIdPt: params.priceIdPt,
+      baseMint: params.baseMint,
+    }],
+  })
+  state.nextStrategyPositionIndex += 1
+}
+
+function recordPlannedYieldPosition(
+  state: StrategySetupState,
+  params: { yieldPosition: PublicKey; vault: PublicKey; priceIdPt: ClientPriceId },
+) {
+  state.trackedYieldVaults.add(params.vault.toBase58())
+  state.existingAccounts.set(params.yieldPosition.toBase58(), true)
+  ;(state.strategyVault.state.strategyPositions as unknown as Array<Record<string, unknown>>).push({
+    yieldPosition: [{
+      yieldPosition: params.yieldPosition,
+      vault: params.vault,
+      priceIdPt: params.priceIdPt,
+    }],
+  })
+  state.nextStrategyPositionIndex += 1
+}
+
+function recordPlannedTokenAccountEntry(
+  state: StrategySetupState,
+  params: { tokenMint: PublicKey; tokenAccount: PublicKey; priceId: ClientPriceId },
+) {
+  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 as unknown as Array<Record<string, unknown>>).push({
+    tokenAccount: [{
+      tokenMint: params.tokenMint,
+      balances: [{
+        tokenAccount: params.tokenAccount,
+        mint: params.tokenMint,
+        priceId: params.priceId,
+      }],
+    }],
+  })
+  state.nextStrategyPositionIndex += 1
+}
+
+function recordPlannedTokenAccountBalance(
+  state: StrategySetupState,
+  params: { tokenMint: PublicKey; tokenAccount: PublicKey; priceId: ClientPriceId },
+) {
+  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 as unknown as Array<Record<string, unknown>>
+  const target = positions.find((position) => {
+    const tokenAccountEntry = Array.isArray(position.tokenAccount) ? position.tokenAccount[0] : undefined
+    return tokenAccountEntry && tokenAccountEntry.tokenMint instanceof PublicKey && tokenAccountEntry.tokenMint.equals(params.tokenMint)
+  })
+  const tokenAccountEntry = target?.tokenAccount?.[0] as
+    | { balances?: Array<{ tokenAccount: PublicKey; mint: PublicKey; priceId: ClientPriceId }> }
+    | undefined
+  tokenAccountEntry?.balances?.push({
+    tokenAccount: params.tokenAccount,
+    mint: params.tokenMint,
+    priceId: params.priceId,
+  })
+}
+
+function recordPlannedKaminoObligation(
+  state: StrategySetupState,
+  entry: {
+    obligation: PublicKey
+    quotePriceId: ClientPriceId
+    quoteInputMint: PublicKey
+    reservePriceMappings: Array<{ reserve: PublicKey; reservePriceId: ClientPriceId }>
+    remainingAccountsAmount: bigint
+    minPriceStatusFlags: number
+  },
+) {
+  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 as unknown as Array<Record<string, unknown>>).push({
+    obligation: [{
+      kaminoObligation: [{
+        obligation: entry.obligation,
+        lendingProgramId: KAMINO_LENDING_PROGRAM_ID,
+        quotePriceId: entry.quotePriceId,
+        reservePriceMappings: entry.reservePriceMappings,
+        remainingAccountsAmount: entry.remainingAccountsAmount,
+        minPriceStatusFlags: entry.minPriceStatusFlags,
+      }],
+    }],
+  })
+  state.nextStrategyPositionIndex += 1
+}
+
+function recordPlannedKaminoReserveMappings(
+  state: StrategySetupState,
+  params: {
+    obligation: PublicKey
+    quoteInputMint: PublicKey
+    reservePriceMappings: Array<{ reserve: PublicKey; reservePriceId: ClientPriceId }>
+  },
+) {
+  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 as unknown as Array<Record<string, unknown>>
+  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
+  ) as { reservePriceMappings?: Array<{ reserve: PublicKey; reservePriceId: ClientPriceId }>; remainingAccountsAmount?: bigint } | 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: StrategySetupState,
+  params: {
+    farmState: PublicKey
+    userState: PublicKey
+    globalConfig: PublicKey
+    scopePrices: PublicKey | null
+  },
+) {
+  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 as unknown as Array<Record<string, unknown>>).push({
+    kaminoFarm: [{
+      farmState: params.farmState,
+      userState: params.userState,
+    }],
+  })
+  state.nextStrategyPositionIndex += 1
+}
+
+function recordPlannedClmmPosition(
+  state: StrategySetupState,
+  params: {
+    lpPosition: PublicKey
+    market: PublicKey
+    priceIdPt: ClientPriceId
+    priceIdSy: ClientPriceId
+    ticksKey: PublicKey
+  },
+) {
+  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 as unknown as Array<Record<string, unknown>>).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,
+}: {
+  state: StrategySetupState
+  connection: Connection
+  payer: PublicKey
+  owner: PublicKey
+  mint: PublicKey
+  tokenProgram: PublicKey
+  tokenAccount: PublicKey
+}): Promise<TransactionInstruction | null> {
+  if (await accountExists(state, connection, tokenAccount)) {
+    return null
+  }
+
+  const expectedAta = getAssociatedTokenAddressSync(mint, owner, true, tokenProgram)
+  if (!expectedAta.equals(tokenAccount)) {
+    return null
+  }
+
+  state.existingAccounts.set(tokenAccount.toBase58(), true)
+  return createAssociatedTokenAccountIdempotentInstruction(payer, tokenAccount, owner, mint, tokenProgram)
+}
+
+async function ensureOrderbookPositionSetup(
+  orderbook: Orderbook,
+  buckets: InstructionBuckets,
+  setupContext: StrategySetupContext,
+) {
+  const state = await loadStrategySetupState(setupContext)
+  if (!state) {
+    return
+  }
+
+  const orderbookKey = orderbook.selfAddress.toBase58()
+  if (state.trackedOrderbooks.has(orderbookKey)) {
+    return
+  }
+
+  const priceIdPt = resolvePriceIdFromMintToUnderlyingOrThrow({
+    prices: state.prices,
+    sourceMint: orderbook.mintPt,
+    targetMint: state.strategyVault.state.underlyingMint,
+    label: `orderbook setup (${orderbook.selfAddress.toBase58()})`,
+  })
+  trackRequiredPriceIds(state.requiredPriceIds, priceIdPt)
+
+  buckets.setupInstructions.push(
+    state.strategyVault.ixWrapperManageVaultSettings({
+      manager: setupContext.signer,
+      actions: [
+        exponentVaults.vaultSettingsAction("AddOrderbookEntry", [{
+          orderbook: orderbook.selfAddress,
+          // Legacy field retained for layout compatibility. Order ownership is
+          // derived from live orderbook state during AUM calculation.
+          userEscrowIdx: 0,
+          mint: orderbook.vault.mintSy,
+          offerIdxVec: [],
+          priceIdPt,
+          baseMint: state.strategyVault.state.underlyingMint,
+        }]),
+      ],
+      remainingAccounts: [
+        { pubkey: orderbook.selfAddress, isSigner: false, isWritable: false },
+        { pubkey: orderbook.state.vault, isSigner: false, isWritable: false },
+      ],
+    }),
+  )
+
+  recordPlannedOrderbookEntry(state, {
+    orderbook: orderbook.selfAddress,
+    mint: orderbook.vault.mintSy,
+    priceIdPt,
+    baseMint: state.strategyVault.state.underlyingMint,
+  })
+}
+
+async function ensureYieldPositionSetup(
+  coreVault: Vault,
+  buckets: InstructionBuckets,
+  setupContext: StrategySetupContext,
+) {
+  const state = await loadStrategySetupState(setupContext)
+  if (!state) {
+    return
+  }
+
+  const coreVaultKey = coreVault.selfAddress.toBase58()
+  if (state.trackedYieldVaults.has(coreVaultKey)) {
+    return
+  }
+
+  const priceIdPt = resolvePriceIdFromMintToUnderlyingOrThrow({
+    prices: state.prices,
+    sourceMint: coreVault.mintPt,
+    targetMint: state.strategyVault.state.underlyingMint,
+    label: `core vault setup (${coreVault.selfAddress.toBase58()})`,
+  })
+  trackRequiredPriceIds(state.requiredPriceIds, priceIdPt)
+
+  const yieldPosition = coreVault.pda.yieldPosition({ owner: setupContext.owner, vault: coreVault.selfAddress })
+  if (!(await accountExists(state, setupContext.connection, yieldPosition))) {
+    const requiredLamports = await setupContext.connection.getMinimumBalanceForRentExemption(
+      YIELD_POSITION_BASE_SIZE + (coreVault.state.emissions.length * YIELD_POSITION_TRACKER_SIZE),
+    )
+    const ownerLamports = await setupContext.connection.getBalance(setupContext.owner)
+    if (ownerLamports < requiredLamports) {
       buckets.setupInstructions.push(
         SystemProgram.transfer({
           fromPubkey: setupContext.signer,
@@ -1066,7 +1588,7 @@ async function ensureYieldPositionSetup(
         exponentVaults.vaultSettingsAction("AddYieldPositionEntry", {
           yieldPosition,
           vault: coreVault.selfAddress,
-          priceIdPt: exponentVaults.priceId("Simple", { priceId: ptPrice.priceId }),
+          priceIdPt,
         }),
       ],
       remainingAccounts: [
@@ -1076,8 +1598,11 @@ async function ensureYieldPositionSetup(
     }),
   )
 
-  state.trackedYieldVaults.add(coreVaultKey)
-  state.nextStrategyPositionIndex += 1
+  recordPlannedYieldPosition(state, {
+    yieldPosition,
+    vault: coreVault.selfAddress,
+    priceIdPt,
+  })
 }
 
 async function wrapVaultSignedSetupInstruction({
@@ -1120,12 +1645,17 @@ async function wrapVaultSignedSetupInstruction({
     setupContext.vaultAddress
     && (!resolvedLeadingAccounts || !resolvedPreHookAccounts || !resolvedPostHookAccounts)
   ) {
-    const hooks = await 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 = resolveHookAccounts(
+        setupContext.connection,
+        resolvedPolicyPda,
+        setupContext.vaultAddress,
+        setupContext.signer,
+      )
+    }
+    const hooks = await setupContext.resolvedHooksPromise
     resolvedLeadingAccounts ??= hooks.leadingAccounts
     resolvedPreHookAccounts ??= hooks.preHookAccounts
     resolvedPostHookAccounts ??= hooks.postHookAccounts
@@ -1180,14 +1710,13 @@ async function ensureTrackedTokenAccountSetup({
     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 = 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,
@@ -1213,7 +1742,7 @@ async function ensureTrackedTokenAccountSetup({
             balances: [{
               tokenAccount,
               mint: tokenMint,
-              priceId: exponentVaults.priceId("Simple", { priceId: price.priceId }),
+              priceId,
             }],
           }]),
         ],
@@ -1222,8 +1751,11 @@ async function ensureTrackedTokenAccountSetup({
         ],
       }),
     )
-    state.tokenPositionIndexByMint.set(tokenMintKey, state.nextStrategyPositionIndex)
-    state.nextStrategyPositionIndex += 1
+    recordPlannedTokenAccountEntry(state, {
+      tokenMint,
+      tokenAccount,
+      priceId,
+    })
   } else {
     buckets.setupInstructions.push(
       state.strategyVault.ixWrapperManagerUpdatePosition({
@@ -1234,7 +1766,7 @@ async function ensureTrackedTokenAccountSetup({
           balance: {
             tokenAccount,
             mint: tokenMint,
-            priceId: exponentVaults.priceId("Simple", { priceId: price.priceId }),
+            priceId,
           },
         },
         remainingAccounts: [
@@ -1242,6 +1774,11 @@ async function ensureTrackedTokenAccountSetup({
         ],
       }),
     )
+    recordPlannedTokenAccountBalance(state, {
+      tokenMint,
+      tokenAccount,
+      priceId,
+    })
   }
 
   state.trackedTokenAccounts.add(tokenAccountKey)
@@ -1260,6 +1797,8 @@ async function buildVaultInstructions(
   preHookAccounts?: PublicKey[] | AccountMeta[],
   postHookAccounts?: PublicKey[] | AccountMeta[],
   squadsProgram: PublicKey = SQUADS_PROGRAM_ID,
+  autoManagePositions: boolean = true,
+  sharedSetupContext?: StrategySetupContext,
 ): Promise<InstructionBuckets> {
   const buckets: InstructionBuckets = {
     setupInstructions: [],
@@ -1269,7 +1808,7 @@ async function buildVaultInstructions(
     signers: [],
     addressLookupTableAddresses: [],
   }
-  const setupContext = createStrategySetupContext({
+  const setupContext = sharedSetupContext ?? createStrategySetupContext({
     connection,
     env: LOCAL_ENV,
     owner,
@@ -1282,9 +1821,20 @@ async function buildVaultInstructions(
     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
@@ -1320,19 +1870,19 @@ async function buildVaultInstructions(
         await buildInitUserMetadata(owner, connection, buckets)
         break
       case VaultAction.INIT_OBLIGATION:
-        await buildInitObligation(ix, owner, connection, buckets)
+        await buildInitObligation(ix, owner, connection, buckets, setupContext)
         break
       case VaultAction.DEPOSIT:
-        await buildDeposit(ix, owner, connection, signer, buckets)
+        await buildDeposit(ix, owner, connection, signer, buckets, setupContext)
         break
       case VaultAction.WITHDRAW:
-        await buildWithdraw(ix, owner, connection, signer, buckets)
+        await buildWithdraw(ix, owner, connection, signer, buckets, setupContext)
         break
       case VaultAction.BORROW:
-        await buildBorrow(ix, owner, connection, signer, buckets)
+        await buildBorrow(ix, owner, connection, signer, buckets, setupContext)
         break
       case VaultAction.REPAY:
-        await buildRepay(ix, owner, connection, signer, buckets)
+        await buildRepay(ix, owner, connection, signer, buckets, setupContext)
         break
     }
   }
@@ -1340,138 +1890,1139 @@ async function buildVaultInstructions(
   return buckets
 }
 
-async function buildTitanInstruction(
-  ix: TitanSwapInstruction,
-  buckets: InstructionBuckets,
-  setupContext: StrategySetupContext,
-): Promise<void> {
-  const inputMint = ix.instruction.keys[TITAN_INPUT_MINT_ACCOUNT_INDEX]?.pubkey
-  const inputTokenAccount = ix.instruction.keys[TITAN_INPUT_TOKEN_ACCOUNT_INDEX]?.pubkey
-  const outputMint = ix.instruction.keys[TITAN_OUTPUT_MINT_ACCOUNT_INDEX]?.pubkey
-  const outputTokenAccount = ix.instruction.keys[TITAN_OUTPUT_TOKEN_ACCOUNT_INDEX]?.pubkey
-  const inputTokenProgram = ix.instruction.keys[TITAN_INPUT_TOKEN_PROGRAM_ACCOUNT_INDEX]?.pubkey
-  const outputTokenProgram = ix.instruction.keys[TITAN_OUTPUT_TOKEN_PROGRAM_ACCOUNT_INDEX]?.pubkey
+const KAMINO_VAULT_EVENT_AUTHORITY = emitEventAuthority(KAMINO_VAULT_PROGRAM_ID)
+const KAMINO_FARM_USER_STATE_SIZE = 920
+const KAMINO_STAKE_ALL_AMOUNT = new BN("18446744073709551615")
 
-  if (
-    !inputMint
-    || !inputTokenAccount
-    || !outputMint
-    || !outputTokenAccount
-    || !inputTokenProgram
-    || !outputTokenProgram
-  ) {
-    throw new Error("Titan SwapRouteV2 instruction is missing expected token accounts")
-  }
+type KaminoVaultIndex = Awaited<ReturnType<typeof fetchKaminoVaultIndex>>
 
-  await ensureTrackedTokenAccountSetup({
-    tokenMint: inputMint,
-    tokenAccount: inputTokenAccount,
-    tokenProgram: inputTokenProgram,
-    buckets,
-    setupContext,
-  })
-  await ensureTrackedTokenAccountSetup({
-    tokenMint: outputMint,
-    tokenAccount: outputTokenAccount,
-    tokenProgram: outputTokenProgram,
-    buckets,
-    setupContext,
-  })
+type KaminoVaultDecodedState = {
+  tokenAvailable: BN
+  sharesIssued: BN
+  pendingFeesSf: BN
+  allocations: Array<{
+    reserve: PublicKey
+    ctokenAllocation: BN
+  }>
+}
 
-  buckets.syncInstructions.push(ix.instruction)
+type KaminoVaultResolvedReserve = KaminoVaultIndex["reserves"][number] & {
+  account: Reserve
+  investedLiquidityAmount: Decimal
+  availableLiquidityToWithdraw: Decimal
 }
 
-// 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
+type KaminoVaultContext = {
+  index: Omit<KaminoVaultIndex, "reserves"> & {
+    reserves: KaminoVaultResolvedReserve[]
+  }
+  tokenAta: PublicKey
+  sharesAta: PublicKey
+  sharesBalance: BN
+  state: KaminoVaultDecodedState
+}
 
-/** Build a single Loopscale instruction (loan or strategy). Extracts token accounts for tracking. */
-async function buildLoopscaleInstruction(
-  ix: LoopscaleInstruction,
+type KaminoFarmContext = {
+  farm: ReturnType<typeof decodeKaminoFarmState>
+  farmState: PublicKey
+  userState: PublicKey
+  delegatee: PublicKey
+  sourceAta: PublicKey
+  scopePrices: PublicKey | null
+}
+
+function toBn(value: BN | bigint | number): BN {
+  if (BN.isBN(value)) {
+    return value
+  }
+  return new BN(value.toString())
+}
+
+function minBn(lhs: BN, rhs: BN): BN {
+  return lhs.lte(rhs) ? lhs : rhs
+}
+
+function encodeU64InstructionData(discriminator: Buffer, value: BN | bigint | number): Buffer {
+  return Buffer.concat([discriminator, toBn(value).toArrayLike(Buffer, "le", 8)])
+}
+
+function encodeU128InstructionData(discriminator: Buffer, value: BN | bigint | number): Buffer {
+  return Buffer.concat([discriminator, toBn(value).toArrayLike(Buffer, "le", 16)])
+}
+
+function getKaminoFarmUserStateAddress(delegatee: PublicKey, farmState: PublicKey): PublicKey {
+  return getKaminoFarmsObligationFarm(delegatee, farmState, KAMINO_FARMS_PROGRAM_ID)
+}
+
+async function accountExistsMaybeTracked(
+  setupContext: StrategySetupContext | undefined,
+  address: PublicKey,
+): Promise<boolean> {
+  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: ExponentPrice,
+  interfaceAccounts: PublicKey[],
+): boolean {
+  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: number): boolean {
+  return priceType === KAMINO_VAULT_PRICE_TYPE_WIRE || priceType === exponentVaults.PriceType.KaminoVault
+}
+
+function resolveKaminoVaultPriceEntry(params: {
+  prices: ExponentPrices
+  sharesMint: PublicKey
+  depositTokenMint: PublicKey
+  interfaceAccounts: PublicKey[]
+}): ExponentPrice {
+  const candidates = params.prices.prices.filter((entry): entry is ExponentPrice => 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: {
+  state: StrategySetupState
+  depositTokenMint: PublicKey
+  sharePriceId: bigint
+  label: string
+}): ClientPriceId {
+  if (params.depositTokenMint.equals(params.state.strategyVault.state.underlyingMint)) {
+    return { __kind: "Simple", priceId: params.sharePriceId }
+  }
+
+  const reservePriceId = resolvePriceIdFromMintToUnderlyingOrThrow({
+    prices: params.state.prices,
+    sourceMint: params.depositTokenMint,
+    targetMint: params.state.strategyVault.state.underlyingMint,
+    label: params.label,
+  })
+  const reservePriceIds = extractPriceIds(reservePriceId).map((id) => BigInt(id))
+  return { __kind: "Multiply", priceIds: [...reservePriceIds, params.sharePriceId] }
+}
+
+type KaminoVaultWithdrawPlanningSnapshot = {
+  sharesBalance: BN
+  tokenAvailable: BN
+  sharesIssued: BN
+  pendingFeesSf: BN
+  reserves: Array<{
+    reserveAddress: PublicKey
+    investedLiquidityAmount: Decimal
+    availableLiquidityToWithdraw: Decimal
+  }>
+}
+
+type KaminoVaultWithdrawPlanningLeg = {
+  reserveAddress: PublicKey
+  sharesAmount: BN
+}
+
+function decodeKaminoVaultState(data: Buffer): KaminoVaultDecodedState {
+  const decoded = KAMINO_VAULT_CODER.accounts.decode("VaultState", data) as {
+    token_available: BN
+    shares_issued: BN
+    pending_fees_sf: BN
+    vault_allocation_strategy: Array<{
+      reserve: PublicKey
+      ctoken_allocation: BN
+    }>
+  }
+
+  return {
+    tokenAvailable: decoded.token_available,
+    sharesIssued: decoded.shares_issued,
+    pendingFeesSf: decoded.pending_fees_sf,
+    allocations: decoded.vault_allocation_strategy
+      .filter((allocation) => !allocation.reserve.equals(PublicKey.default))
+      .map((allocation) => ({
+        reserve: allocation.reserve,
+        ctokenAllocation: allocation.ctoken_allocation,
+      })),
+  }
+}
+
+function calculateKaminoVaultTokensPerShareFromSnapshot(
+  snapshot: KaminoVaultWithdrawPlanningSnapshot,
+): Decimal {
+  if (snapshot.sharesIssued.isZero()) {
+    return new Decimal(0)
+  }
+
+  const investedTotal = snapshot.reserves.reduce(
+    (total, reserve) => total.add(reserve.investedLiquidityAmount),
+    new Decimal(0),
+  )
+  const pendingFees = new Fraction(snapshot.pendingFeesSf).toDecimal()
+  const currentVaultAum = new Decimal(snapshot.tokenAvailable.toString())
+    .add(investedTotal)
+    .sub(pendingFees)
+
+  if (currentVaultAum.lte(0)) {
+    return new Decimal(0)
+  }
+
+  return currentVaultAum.div(snapshot.sharesIssued.toString())
+}
+
+function planKaminoVaultWithdrawLegsFromSnapshot(params: {
+  sharesAmount: BN
+  reserve?: PublicKey
+  snapshot: KaminoVaultWithdrawPlanningSnapshot
+}): KaminoVaultWithdrawPlanningLeg[] {
+  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(actualSharesToWithdraw.toString()).mul(tokensPerShare)
+  const availableTokens = new Decimal(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: KaminoVaultWithdrawPlanningLeg[] = []
+  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.min(tokensRemaining, legCapacity)
+    if (tokensForLeg.lte(0)) {
+      continue
+    }
+
+    const sharesForLeg = withdrawAllShares
+      ? params.snapshot.sharesBalance
+      : new BN(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
+}
+
+export const __kaminoVaultTesting = {
+  calculateKaminoVaultTokensPerShareFromSnapshot,
+  planKaminoVaultWithdrawLegsFromSnapshot,
+}
+
+async function resolveKaminoVaultContext(
+  vaultAddress: PublicKey,
+  setupContext: StrategySetupContext,
+): Promise<KaminoVaultContext> {
+  const rawIndex = await 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 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] as typeof rawIndex.reserves[number] & {
+      reserve?: PublicKey
+      marketAddress?: PublicKey
+      ctokenVault?: PublicKey
+      lendingMarketAuthority?: PublicKey
+      pythOracle?: PublicKey
+      switchboardPriceOracle?: PublicKey
+      switchboardTwapOracle?: PublicKey
+      scopePrices?: PublicKey
+      reserveLiquiditySupply?: PublicKey
+      reserveCollateralMint?: PublicKey
+      reserveCollateralTokenProgram?: PublicKey
+    }
+    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] = PublicKey.findProgramAddressSync(
+      [Buffer.from("lma"), reserveAccount.lendingMarket.toBuffer()],
+      KAMINO_LENDING_PROGRAM_ID,
+    )
+    const investedLiquidityAmount = allocation
+      ? new Decimal(allocation.ctokenAllocation.toString()).mul(reserveAccount.getCollateralExchangeRate())
+      : new Decimal(0)
+    const availableLiquidityToWithdraw = Decimal.min(
+      investedLiquidityAmount,
+      reserveAccount.getLiquidityAvailableAmount(),
+    )
+
+    return {
+      reserveAddress,
+      marketAddress: rawReserve.marketAddress ?? rawReserve.reserve ?? reserveAccount.lendingMarket,
+      ctokenVault:
+        rawReserve.ctokenVault
+        ?? new 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 ?? PublicKey.default,
+      account: reserveAccount,
+      investedLiquidityAmount,
+      availableLiquidityToWithdraw,
+    }
+  })
+  const index = {
+    ...rawIndex,
+    reserves: normalizedReserves,
+    tokenProgram: (rawIndex as typeof rawIndex & { tokenProgram?: PublicKey }).tokenProgram ?? tokenMintInfo?.owner ?? TOKEN_PROGRAM_ID,
+    sharesTokenProgram:
+      (rawIndex as typeof rawIndex & { sharesTokenProgram?: PublicKey }).sharesTokenProgram
+      ?? sharesMintInfo?.owner
+      ?? TOKEN_PROGRAM_ID,
+    vaultLookupTable:
+      (rawIndex as typeof rawIndex & { vaultLookupTable?: PublicKey }).vaultLookupTable ?? PublicKey.default,
+  }
+  const tokenAta = getAssociatedTokenAddressSync(index.tokenMint, setupContext.owner, true, index.tokenProgram)
+  const sharesAta = getAssociatedTokenAddressSync(index.sharesMint, setupContext.owner, true, index.sharesTokenProgram)
+  const sharesAtaInfo = await setupContext.connection.getAccountInfo(sharesAta)
+  const sharesBalance = sharesAtaInfo?.data
+    ? new BN(AccountLayout.decode(sharesAtaInfo.data).amount.toString())
+    : new BN(0)
+  return { index, tokenAta, sharesAta, sharesBalance, state: decodedVaultState }
+}
+
+async function queueKaminoVaultSharesTracking(params: {
+  setupContext: StrategySetupContext
+  buckets: InstructionBuckets
+  kaminoVaultAddress: PublicKey
+  vaultContext: KaminoVaultContext
+}) {
+  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 = 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: {
+  setupContext: StrategySetupContext
+  kaminoVaultAddress: PublicKey
+  vaultContext: KaminoVaultContext
+}): Promise<AccountMeta[]> {
+  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: {
+  owner: PublicKey
+  kaminoVaultAddress: PublicKey
+  vaultContext: KaminoVaultContext
+  amount: BN
+  validationAccounts?: AccountMeta[]
+}): TransactionInstruction {
+  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: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
+    { pubkey: KAMINO_VAULT_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+    { pubkey: KAMINO_VAULT_PROGRAM_ID, isSigner: false, isWritable: false },
+  ])
+
+  return new TransactionInstruction({
+    programId: 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: 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: 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(KAMINO_VAULT_DISCRIMINATORS.deposit, params.amount),
+  })
+}
+
+function resolveExplicitKaminoVaultWithdrawReserve(
+  ix: KaminoVaultWithdrawInstruction,
+  vaultContext: KaminoVaultContext,
+): KaminoVaultContext["index"]["reserves"][number] {
+  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: KaminoVaultWithdrawInstruction,
+  vaultContext: KaminoVaultContext,
+): Array<{
+  reserve: KaminoVaultContext["index"]["reserves"][number]
+  sharesAmount: BN
+}> {
+  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: {
+  owner: PublicKey
+  ix: KaminoVaultWithdrawInstruction
+  reserve: KaminoVaultContext["index"]["reserves"][number]
+  sharesAmount: BN
+  vaultContext: KaminoVaultContext
+  validationAccounts?: AccountMeta[]
+}): TransactionInstruction {
+  const [globalConfig] = PublicKey.findProgramAddressSync(
+    [KAMINO_VAULT_GLOBAL_CONFIG_SEED],
+    KAMINO_VAULT_PROGRAM_ID,
+  )
+  return new TransactionInstruction({
+    programId: 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: KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: KAMINO_VAULT_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+      { pubkey: 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: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
+      { pubkey: KAMINO_VAULT_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+      { pubkey: 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(KAMINO_VAULT_DISCRIMINATORS.withdraw, params.sharesAmount),
+  })
+}
+
+async function buildKaminoVaultInstruction(
+  ix: KaminoVaultInstruction,
+  buckets: InstructionBuckets,
+  setupContext: StrategySetupContext,
+): Promise<void> {
+  const vaultContext = await resolveKaminoVaultContext(ix.vault, setupContext)
+  const validationAccounts = await resolveKaminoVaultValidationAccounts({
+    setupContext,
+    kaminoVaultAddress: ix.vault,
+    vaultContext,
+  })
+
+  buckets.setupInstructions.push(
+    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 as typeof vaultContext.index & {
+    vaultLookupTable?: PublicKey
+  }).vaultLookupTable ?? PublicKey.default
+
+  if (!vaultLookupTable.equals(PublicKey.default)) {
+    buckets.addressLookupTableAddresses.push(vaultLookupTable)
+  }
+
+  if (ix.action === 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,
+    }))
+  }
+}
+
+function getOptionalReadonlyAccountMeta(account: PublicKey | null, placeholderProgram: PublicKey): AccountMeta {
+  return {
+    pubkey: account ?? placeholderProgram,
+    isSigner: false,
+    isWritable: false,
+  }
+}
+
+async function resolveKaminoFarmContext(
+  ix: KaminoFarmInstruction,
+  setupContext: StrategySetupContext,
+): Promise<KaminoFarmContext> {
+  const farmInfo = await setupContext.connection.getAccountInfo(ix.farmState)
+  if (!farmInfo?.data) {
+    throw new Error(`Kamino farm not found: ${ix.farmState.toBase58()}`)
+  }
+
+  const farm = decodeKaminoFarmState(Buffer.from(farmInfo.data))
+  const delegatee = ix.delegatee ?? setupContext.owner
+  const userState = getKaminoFarmUserStateAddress(delegatee, ix.farmState)
+  const sourceAta = getAssociatedTokenAddressSync(
+    farm.underlyingMint,
+    setupContext.owner,
+    true,
+    farm.tokenProgram,
+  )
+
+  return {
+    farm,
+    farmState: ix.farmState,
+    userState,
+    delegatee,
+    sourceAta,
+    scopePrices: getKaminoFarmScopePricesAddress(farm),
+  }
+}
+
+function buildKaminoFarmInitializeUserRawInstruction(params: {
+  owner: PublicKey
+  delegatee: PublicKey
+  userState: PublicKey
+  farmState: PublicKey
+}): TransactionInstruction {
+  return new 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: SystemProgram.programId, isSigner: false, isWritable: false },
+      { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
+    ],
+    data: Buffer.from(KAMINO_FARM_DISCRIMINATORS.initializeUser),
+  })
+}
+
+async function ensureKaminoFarmUserSetup(params: {
+  farmContext: KaminoFarmContext
+  buckets: InstructionBuckets
+  setupContext: StrategySetupContext
+}) {
+  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(
+      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: {
+  owner: PublicKey
+  farmContext: KaminoFarmContext
+  amount: BN | "ALL"
+}): TransactionInstruction {
+  const amount = params.amount === "ALL" ? KAMINO_STAKE_ALL_AMOUNT : params.amount
+  return new 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(KAMINO_FARM_DISCRIMINATORS.stake, amount),
+  })
+}
+
+function buildKaminoFarmUnstakeInstructionRaw(params: {
+  owner: PublicKey
+  farmContext: KaminoFarmContext
+  stakeSharesScaled: BN
+}): TransactionInstruction {
+  return new 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(KAMINO_FARM_DISCRIMINATORS.unstake, params.stakeSharesScaled),
+  })
+}
+
+function buildKaminoFarmWithdrawUnstakedDepositsRawInstruction(params: {
+  owner: PublicKey
+  farmContext: KaminoFarmContext
+}): TransactionInstruction {
+  return new 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(KAMINO_FARM_DISCRIMINATORS.withdrawUnstakedDeposits),
+  })
+}
+
+function buildKaminoFarmHarvestRewardRawInstruction(params: {
+  owner: PublicKey
+  farmContext: KaminoFarmContext
+  rewardIndex: number
+  rewardAta: PublicKey
+}): TransactionInstruction {
+  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 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: 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(KAMINO_FARM_DISCRIMINATORS.harvestReward, params.rewardIndex),
+  })
+}
+
+async function buildKaminoFarmInstruction(
+  ix: KaminoFarmInstruction,
   buckets: InstructionBuckets,
   setupContext: StrategySetupContext,
 ): Promise<void> {
+  const farmContext = await resolveKaminoFarmContext(ix, 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")
+    case 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 ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext })
-      break
+
+      await ensureKaminoFarmUserSetup({ farmContext, buckets, setupContext })
+      return
     }
-    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")
+    case KaminoFarmAction.STAKE: {
+      if (farmContext.farm.isDelegated) {
+        throw new Error(`Kamino farm ${ix.farmState.toBase58()} is delegated and cannot be staked directly`)
       }
-      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")
+      if (isAutoManagePositionsEnabled(setupContext)) {
+        await ensureKaminoFarmUserSetup({ farmContext, buckets, setupContext })
+        await ensureTrackedTokenAccountSetup({
+          tokenMint: farmContext.farm.underlyingMint,
+          tokenAccount: farmContext.sourceAta,
+          tokenProgram: farmContext.farm.tokenProgram,
+          buckets,
+          setupContext,
+        })
       }
-      await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext })
-      break
+
+      buckets.syncInstructions.push(
+        buildKaminoFarmStakeInstructionRaw({
+          owner: setupContext.owner,
+          farmContext,
+          amount: ix.amount,
+        }),
+      )
+
+      if (isAutoManagePositionsEnabled(setupContext)) {
+        const state = await loadStrategySetupState(setupContext)
+        if (state) {
+          recordPlannedKaminoFarmPosition(state, {
+            farmState: ix.farmState,
+            userState: farmContext.userState,
+            globalConfig: farmContext.farm.globalConfig,
+            scopePrices: farmContext.scopePrices,
+          })
+        }
+      }
+      return
     }
-    case 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")
+    case KaminoFarmAction.UNSTAKE: {
+      if (farmContext.farm.isDelegated) {
+        throw new Error(`Kamino farm ${ix.farmState.toBase58()} is delegated and cannot be unstaked directly`)
       }
-      await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext })
-      break
+
+      buckets.syncInstructions.push(
+        buildKaminoFarmUnstakeInstructionRaw({
+          owner: setupContext.owner,
+          farmContext,
+          stakeSharesScaled: ix.stakeSharesScaled,
+        }),
+      )
+      return
     }
-    // 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")
+    case KaminoFarmAction.WITHDRAW_UNSTAKED_DEPOSITS: {
+      if (farmContext.farm.isDelegated) {
+        throw new Error(
+          `Kamino farm ${ix.farmState.toBase58()} is delegated and cannot withdraw unstaked deposits directly`,
+        )
       }
-      await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext })
-      break
+
+      buckets.syncInstructions.push(
+        buildKaminoFarmWithdrawUnstakedDepositsRawInstruction({
+          owner: setupContext.owner,
+          farmContext,
+        }),
+      )
+      return
     }
-    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")
+    case 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()}`)
       }
-      await ensureTrackedTokenAccountSetup({ tokenMint, tokenAccount, tokenProgram, buckets, setupContext })
-      break
+
+      const rewardAta = 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(
+        createAssociatedTokenAccountIdempotentInstruction(
+          setupContext.signer,
+          rewardAta,
+          setupContext.owner,
+          rewardInfo.rewardMint,
+          rewardInfo.tokenProgram,
+        ),
+      )
+      buckets.syncInstructions.push(
+        buildKaminoFarmHarvestRewardRawInstruction({
+          owner: setupContext.owner,
+          farmContext,
+          rewardIndex: ix.rewardIndex,
+          rewardAta,
+        }),
+      )
+      return
+    }
+  }
+}
+
+
+async function buildTitanInstruction(
+  ix: TitanSwapInstruction,
+  buckets: InstructionBuckets,
+  setupContext: StrategySetupContext,
+): Promise<void> {
+  const inputMint = ix.instruction.keys[TITAN_INPUT_MINT_ACCOUNT_INDEX]?.pubkey
+  const inputTokenAccount = ix.instruction.keys[TITAN_INPUT_TOKEN_ACCOUNT_INDEX]?.pubkey
+  const outputMint = ix.instruction.keys[TITAN_OUTPUT_MINT_ACCOUNT_INDEX]?.pubkey
+  const outputTokenAccount = ix.instruction.keys[TITAN_OUTPUT_TOKEN_ACCOUNT_INDEX]?.pubkey
+  const inputTokenProgram = ix.instruction.keys[TITAN_INPUT_TOKEN_PROGRAM_ACCOUNT_INDEX]?.pubkey
+  const outputTokenProgram = ix.instruction.keys[TITAN_OUTPUT_TOKEN_PROGRAM_ACCOUNT_INDEX]?.pubkey
+
+  if (
+    !inputMint
+    || !inputTokenAccount
+    || !outputMint
+    || !outputTokenAccount
+    || !inputTokenProgram
+    || !outputTokenProgram
+  ) {
+    throw new Error("Titan SwapRouteV2 instruction is missing expected token accounts")
+  }
+
+  await ensureTrackedTokenAccountSetup({
+    tokenMint: inputMint,
+    tokenAccount: inputTokenAccount,
+    tokenProgram: inputTokenProgram,
+    buckets,
+    setupContext,
+  })
+  await ensureTrackedTokenAccountSetup({
+    tokenMint: outputMint,
+    tokenAccount: outputTokenAccount,
+    tokenProgram: outputTokenProgram,
+    buckets,
+    setupContext,
+  })
+
+  if (ix.addressLookupTableAddresses?.length) {
+    buckets.addressLookupTableAddresses.push(...ix.addressLookupTableAddresses)
+  }
+  buckets.syncInstructions.push(ix.instruction)
+}
+
+/**
+ * Loopscale account index mapping per instruction (from the Loopscale IDL).
+ * Actions not listed here (create_loan, close_loan, update_weight_matrix,
+ * create_strategy, close_strategy, lock_loan, unlock_loan, refinance_ledger,
+ * update_strategy) have no token accounts to track — the on-chain hook handles
+ * TrackLoopscaleLoan/UntrackLoopscaleLoan mutations.
+ */
+const LOOPSCALE_TOKEN_INDICES: Partial<Record<LoopscaleAction, { mint: number; account: number; program: number }>> = {
+  [LoopscaleAction.DEPOSIT_COLLATERAL]:  { mint: 6, account: 4, program: 9 },
+  [LoopscaleAction.BORROW_PRINCIPAL]:    { mint: 6, account: 7, program: 10 },
+  [LoopscaleAction.REPAY_PRINCIPAL]:     { mint: 6, account: 7, program: 10 },
+  [LoopscaleAction.WITHDRAW_COLLATERAL]: { mint: 7, account: 4, program: 8 },
+  [LoopscaleAction.DEPOSIT_STRATEGY]:    { mint: 4, account: 6, program: 8 },
+  [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: LoopscaleInstruction,
+  buckets: InstructionBuckets,
+  setupContext: StrategySetupContext,
+): Promise<void> {
+  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)
@@ -1513,6 +3064,45 @@ async function buildOrderbookInstruction(
 // Action Builders (one per VaultAction)
 // ============================================================================
 
+function createKaminoInitUserMetadataInstruction(owner: PublicKey): TransactionInstruction {
+  const userMetadata = getKaminoUserMetadata(owner, KAMINO_LENDING_PROGRAM_ID)
+  return initUserMetadata(
+    { userLookupTable: PublicKey.default },
+    {
+      owner,
+      feePayer: owner,
+      userMetadata,
+      referrerUserMetadata: KAMINO_LENDING_PROGRAM_ID,
+      rent: SYSVAR_RENT_PUBKEY,
+      systemProgram: SystemProgram.programId,
+    },
+  )
+}
+
+function createKaminoInitObligationInstruction(params: {
+  market: KaminoMarket
+  owner: PublicKey
+}): TransactionInstruction {
+  const lendingMarket = KAMINO_MARKETS[params.market]
+  const obligation = getKaminoLendObligation(params.owner, lendingMarket, KAMINO_LENDING_PROGRAM_ID)
+  const userMetadata = getKaminoUserMetadata(params.owner, KAMINO_LENDING_PROGRAM_ID)
+
+  return initObligation(
+    { args: { tag: 0, id: 0 } },
+    {
+      obligationOwner: params.owner,
+      feePayer: params.owner,
+      obligation,
+      lendingMarket,
+      seed1Account: SystemProgram.programId,
+      seed2Account: SystemProgram.programId,
+      ownerUserMetadata: userMetadata,
+      rent: SYSVAR_RENT_PUBKEY,
+      systemProgram: SystemProgram.programId,
+    },
+  )
+}
+
 async function buildInitUserMetadata(
   owner: PublicKey,
   connection: Connection,
@@ -1522,49 +3112,317 @@ async function buildInitUserMetadata(
   const userMetadataAccount = await connection.getAccountInfo(userMetadata)
   if (userMetadataAccount) return
 
-  syncInstructions.push(
-    initUserMetadata(
-      { userLookupTable: PublicKey.default },
-      {
-        owner,
-        feePayer: owner,
-        userMetadata,
-        referrerUserMetadata: KAMINO_LENDING_PROGRAM_ID,
-        rent: SYSVAR_RENT_PUBKEY,
-        systemProgram: SystemProgram.programId,
-      },
-    ),
-  )
+  syncInstructions.push(createKaminoInitUserMetadataInstruction(owner))
 }
 
 async function buildInitObligation(
   ix: MarketInstruction,
   owner: PublicKey,
   connection: Connection,
-  { syncInstructions }: InstructionBuckets,
+  { syncInstructions, postInstructions }: InstructionBuckets,
+  setupContext?: StrategySetupContext,
 ) {
   const lendingMarket = KAMINO_MARKETS[ix.market]
   const obligation = getKaminoLendObligation(owner, lendingMarket, KAMINO_LENDING_PROGRAM_ID)
-  const userMetadata = getKaminoUserMetadata(owner, KAMINO_LENDING_PROGRAM_ID)
   const obligationAccount = await connection.getAccountInfo(obligation)
   if (obligationAccount) return
 
-  syncInstructions.push(
-    initObligation(
-      { args: { tag: 0, id: 0 } },
-      {
-        obligationOwner: owner,
-        feePayer: owner,
-        obligation,
+  syncInstructions.push(createKaminoInitObligationInstruction({ market: ix.market, owner }))
+  if (setupContext && isAutoManagePositionsEnabled(setupContext)) {
+    await queueKaminoObligationTrackingAfterInit({
+      market: ix.market,
+      obligation,
+      postInstructions,
+      setupContext,
+    })
+  }
+}
+
+async function queueKaminoObligationTrackingAfterInit(params: {
+  market: KaminoMarket
+  obligation: PublicKey
+  postInstructions: TransactionInstruction[]
+  setupContext: StrategySetupContext
+}) {
+  const state = await loadStrategySetupState(params.setupContext)
+  if (!state || state.trackedKaminoObligations.has(params.obligation.toBase58())) {
+    return
+  }
+
+  const quotePath = resolveBestKaminoQuotePath({
+    prices: state.prices,
+    vaultUnderlyingMint: state.strategyVault.state.underlyingMint,
+  })
+  trackRequiredPriceIds(state.requiredPriceIds, quotePath.quotePriceId)
+  const remainingAccountsAmount = 1n
+  const obligationEntry: exponentVaults.KaminoObligationEntry = {
+    obligation: params.obligation,
+    lendingProgramId: 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] as [exponentVaults.KaminoObligationEntry]),
+      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: {
+  ix: ReserveInstruction
+  reserveContext: ReserveContext
+  buckets: InstructionBuckets
+  setupContext?: StrategySetupContext
+}) {
+  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 = getKaminoUserMetadata(setupContext.owner, 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 = resolveBestKaminoQuotePath({
+      prices: state.prices,
+      vaultUnderlyingMint: state.strategyVault.state.underlyingMint,
+    })
+    const reservePriceMapping = {
+      reserve: reserveContext.reservePubkey,
+      reservePriceId: 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: exponentVaults.KaminoObligationEntry = {
+      obligation: reserveContext.obligation,
+      lendingProgramId: 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] as [exponentVaults.KaminoObligationEntry]),
+        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: {
+  state: StrategySetupState
+  reserveContext: ReserveContext
+  setupContext: StrategySetupContext
+  buckets: InstructionBuckets
+  trackedObligation: TrackedKaminoObligationState
+}) {
+  const { state, reserveContext, setupContext, buckets, trackedObligation } = params
+
+  if (trackedObligation.mappedReserves.has(reserveContext.reservePubkey.toBase58())) {
+    return
+  }
+
+  const reservePriceMapping = {
+    reserve: reserveContext.reservePubkey,
+    reservePriceId: 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,
+}: {
+  reservePubkey: PublicKey
+  reserveAccount: Reserve
+  lendingMarket: PublicKey
+  obligation: PublicKey
+  connection: Connection
+}): Promise<TransactionInstruction[]> {
+  const instructions: TransactionInstruction[] = []
+  const defaultKey = PublicKey.default
+  const oracleOrSentinel = (key: PublicKey) =>
+    key.equals(defaultKey) ? KAMINO_LENDING_PROGRAM_ID : key
+
+  const obligationState = await Obligation.fetch(connection, obligation)
+  const otherReservePubkeys: PublicKey[] = []
+  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: Array<{ pubkey: PublicKey; account: Reserve }> = []
+  for (const otherReservePubkey of otherReservePubkeys) {
+    const otherReserveAccount = await 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(
+      refreshReserve({
+        reserve: pubkey,
         lendingMarket,
-        seed1Account: SystemProgram.programId,
-        seed2Account: SystemProgram.programId,
-        ownerUserMetadata: userMetadata,
-        rent: SYSVAR_RENT_PUBKEY,
-        systemProgram: SystemProgram.programId,
-      },
-    ),
+        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(
+    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 = 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(
@@ -1573,8 +3431,10 @@ async function buildDeposit(
   connection: Connection,
   signer: PublicKey,
   { setupInstructions, syncInstructions, preInstructions, postInstructions }: InstructionBuckets,
+  setupContext?: StrategySetupContext,
 ) {
   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,
   })
@@ -1628,8 +3488,10 @@ async function buildWithdraw(
   connection: Connection,
   signer: PublicKey,
   { setupInstructions, syncInstructions, preInstructions, postInstructions }: InstructionBuckets,
+  setupContext?: StrategySetupContext,
 ) {
   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,
   })
@@ -1690,8 +3552,10 @@ async function buildBorrow(
   connection: Connection,
   signer: PublicKey,
   { setupInstructions, syncInstructions, preInstructions, postInstructions }: InstructionBuckets,
+  setupContext?: StrategySetupContext,
 ) {
   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,
   })
@@ -1743,8 +3607,10 @@ async function buildRepay(
   connection: Connection,
   signer: PublicKey,
   { setupInstructions, syncInstructions, preInstructions, postInstructions }: InstructionBuckets,
+  setupContext?: StrategySetupContext,
 ) {
   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,
   })
@@ -2023,17 +3889,13 @@ export const 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: {
     orderbook: PublicKey
     direction: OrderbookTradeDirection
     priceApy: number
     amount: bigint
-    /** Required offer index for position tracking. Must be unique per trader. */
-    offerIdx: number
     offerOption?: OrderbookOfferOption
-    virtualOffer?: boolean
     expirySeconds?: number
     mode?: OrderbookInstructionMode
   }): OrderbookPostOfferInstruction {
@@ -2044,9 +3906,7 @@ export const orderbookAction = {
       direction: params.direction,
       priceApy: params.priceApy,
       amount: params.amount,
-      offerIdx: params.offerIdx,
       offerOption: params.offerOption,
-      virtualOffer: params.virtualOffer,
       expirySeconds: params.expirySeconds,
     }
   },
@@ -2237,7 +4097,8 @@ export const coreAction = {
 
   /**
    * 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: { vault: PublicKey }): CoreInitializeYieldPositionInstruction {
     return {
@@ -2311,7 +4172,7 @@ export async function createOrderbookSyncTransaction({
   owner: PublicKey
   connection: Connection
   policyPda?: PublicKey
-  vaultPda: PublicKey
+  vaultPda?: PublicKey
   signer: PublicKey
   accountIndex?: number
   constraintIndices?: number[]
@@ -2323,6 +4184,7 @@ export async function createOrderbookSyncTransaction({
   squadsProgram?: PublicKey
   env?: Environment
 }): Promise<VaultSyncTransactionResult> {
+  vaultPda ??= owner
   const { setupInstructions, syncInstructions, preInstructions, postInstructions, signers, addressLookupTableAddresses } = await buildOrderbookInstructions(
     instructions,
     owner,
@@ -2445,6 +4307,7 @@ async function buildPostOffer(
 ) {
   const offerType = directionToOfferType(ix.direction)
   const option = ix.offerOption ?? "FillOrKill"
+  const offerIdx = orderbook.getNextOfferIndex()
 
   if (setupContext) {
     await ensureOrderbookPositionSetup(orderbook, buckets, setupContext)
@@ -2480,10 +4343,10 @@ async function buildPostOffer(
         amount: ix.amount,
         offerType,
         offerOption: offerOptions(option, [false]),
-        virtualOffer: ix.virtualOffer ?? false,
+        virtualOffer: true,
         expirySeconds: ix.expirySeconds ?? 3600,
         mintSy: orderbook.vault.mintSy,
-        offerIdx: ix.offerIdx,
+        offerIdx,
       }),
     )
     return
@@ -2496,10 +4359,10 @@ async function buildPostOffer(
     amount: ix.amount,
     offerType,
     offerOption: 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)
@@ -2616,6 +4479,52 @@ async function buildWithdrawFunds(
 // Core Instruction Builders (Strip/Merge)
 // ============================================================================
 
+async function queueYieldPositionTrackingAfterInit(params: {
+  vault: Vault
+  setupContext: StrategySetupContext
+  postInstructions: TransactionInstruction[]
+}) {
+  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 = 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: CoreInstruction,
@@ -2667,7 +4576,7 @@ async function buildCoreInstruction(
       await buildDepositYt(ix, vault, owner, buckets)
       break
     case CoreAction.INITIALIZE_YIELD_POSITION:
-      await buildInitializeYieldPosition(ix, vault, owner, buckets)
+      await buildInitializeYieldPosition(ix, vault, owner, buckets, setupContext)
       break
   }
 }
@@ -2676,10 +4585,18 @@ async function buildInitializeYieldPosition(
   ix: CoreInitializeYieldPositionInstruction,
   vault: Vault,
   owner: PublicKey,
-  { syncInstructions }: InstructionBuckets,
+  { syncInstructions, postInstructions }: InstructionBuckets,
+  setupContext?: StrategySetupContext,
 ) {
   const initIx = vault.ixInitializeYieldPosition({ owner })
   syncInstructions.push(initIx)
+  if (setupContext && isAutoManagePositionsEnabled(setupContext)) {
+    await queueYieldPositionTrackingAfterInit({
+      vault,
+      setupContext,
+      postInstructions,
+    })
+  }
 }
 
 async function buildStrip(
@@ -2859,9 +4776,17 @@ export const 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: { instruction: TransactionInstruction }): TitanSwapInstruction {
-    return { action: TitanAction.SWAP, instruction: params.instruction }
+  swap(params: {
+    instruction: TransactionInstruction
+    addressLookupTableAddresses?: PublicKey[]
+  }): TitanSwapInstruction {
+    return {
+      action: TitanAction.SWAP,
+      instruction: params.instruction,
+      addressLookupTableAddresses: params.addressLookupTableAddresses,
+    }
   },
 }
 
@@ -2870,7 +4795,7 @@ export const titanAction = {
 // ============================================================================
 
 /**
- * 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.
@@ -2990,7 +4915,9 @@ export const 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
@@ -3158,6 +5085,86 @@ export { SwapDirection }
 /** Cache for loaded MarketThree instances to avoid redundant fetches. */
 const marketThreeCache = new Map<string, MarketThree>()
 
+async function ensureTrackedClmmPosition(params: {
+  lpPosition: PublicKey
+  setupContext?: StrategySetupContext
+}) {
+  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: {
+  market: MarketThree
+  lpPosition: PublicKey
+  postInstructions: TransactionInstruction[]
+  setupContext?: StrategySetupContext
+}) {
+  if (!params.setupContext || !isAutoManagePositionsEnabled(params.setupContext)) {
+    return
+  }
+
+  const state = await loadStrategySetupState(params.setupContext)
+  if (!state || state.trackedClmmPositions.has(params.lpPosition.toBase58())) {
+    return
+  }
+
+  const priceIdPt = 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 = 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
@@ -3201,12 +5208,14 @@ async function buildClmmInstruction(
 
   switch (ix.action) {
     case ClmmAction.DEPOSIT_LIQUIDITY:
-      buildClmmDepositLiquidity(ix, market, owner, buckets)
+      await buildClmmDepositLiquidity(ix, market, owner, buckets, setupContext)
       break
     case ClmmAction.ADD_LIQUIDITY:
+      await ensureTrackedClmmPosition({ lpPosition: ix.lpPosition, setupContext })
       buildClmmAddLiquidity(ix, market, owner, buckets)
       break
     case ClmmAction.WITHDRAW_LIQUIDITY:
+      await ensureTrackedClmmPosition({ lpPosition: ix.lpPosition, setupContext })
       buildClmmWithdrawLiquidity(ix, market, owner, buckets)
       break
     case ClmmAction.TRADE_PT:
@@ -3225,6 +5234,7 @@ async function buildClmmInstruction(
       await buildClmmSellYt(ix, market, owner, buckets, setupContext)
       break
     case ClmmAction.CLAIM_FARM_EMISSION:
+      await ensureTrackedClmmPosition({ lpPosition: ix.lpPosition, setupContext })
       buildClmmClaimFarmEmission(ix, market, owner, buckets)
       break
   }
@@ -3234,12 +5244,13 @@ async function buildClmmInstruction(
  * 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(
+async function buildClmmDepositLiquidity(
   ix: ClmmDepositLiquidityInstruction,
   market: MarketThree,
   owner: PublicKey,
   buckets: InstructionBuckets,
-): void {
+  setupContext?: StrategySetupContext,
+): Promise<void> {
   const ptSrc = getAssociatedTokenAddressSync(market.mintPt, owner, true, TOKEN_PROGRAM_ID)
   const sySrc = getAssociatedTokenAddressSync(market.mintSy, owner, true, TOKEN_PROGRAM_ID)
 
@@ -3255,6 +5266,12 @@ function buildClmmDepositLiquidity(
 
   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. */
@@ -3396,6 +5413,7 @@ async function buildClmmBuyYt(
 
   const { ixs, setupIxs } = market.ixBuyYt({
     trader: owner,
+    payer: setupContext?.signer,
     ytOut: ix.ytOut,
     maxSyIn: ix.maxSyIn,
     lnImpliedApyLimit: ix.lnImpliedApyLimit,
@@ -3426,6 +5444,7 @@ async function buildClmmSellYt(
 
   const { ixs, setupIxs } = market.ixSellYt({
     trader: owner,
+    payer: setupContext?.signer,
     ytIn: ix.ytIn,
     minSyOut: ix.minSyOut,
     lnImpliedApyLimit: ix.lnImpliedApyLimit,