@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/build/exponentVaults/vault-interaction.d.ts

@@ -1,304 +1,17 @@
-import { KAMINO_RESERVES, KaminoMarket } from "./kamino-markets";
+import { KaminoMarket } from "./kamino-markets";
+import Decimal from "decimal.js";
 import { SwapDirection } from "../client/clmm";
 import { Environment } from "../environment";
+import { ExponentVault as StrategyVault } from "./vault";
+import type { ExponentPrices } from "@exponent-labs/exponent-vaults-fetcher";
+import type { PriceId as ClientPriceId } from "../client/vaults/types/priceId";
 import * as web3 from "@solana/web3.js";
 import { AccountMeta, Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
 import BN from "bn.js";
-type KaminoReserves = typeof KAMINO_RESERVES;
-/** Actions that can be performed through the vault instruction builder. */
-export declare 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 trade direction */
-export declare 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 declare 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;
-/** Actions that can be performed on Exponent Core */
-export declare 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;
-export declare 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;
-export declare 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;
-}
-/** Actions for Loopscale interactions (loans = borrower side, strategies = lender side). */
-export declare 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;
-}
-/** Actions that can be performed on the Exponent CLMM (Concentrated Liquidity Market Maker). */
-export declare 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;
-}
-/** 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;
+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, KaminoVaultDepositInstruction, KaminoVaultWithdrawInstruction, KaminoFarmInitializeUserInstruction, KaminoFarmStakeInstruction, KaminoFarmUnstakeInstruction, KaminoFarmWithdrawUnstakedDepositsInstruction, KaminoFarmHarvestRewardInstruction, OrderbookOfferOption, OrderbookInstructionMode, OrderbookInstruction, OrderbookPostOfferInstruction, OrderbookMarketOfferInstruction, OrderbookRemoveOfferInstruction, OrderbookWithdrawFundsInstruction, CoreStripInstruction, CoreMergeInstruction, CoreWithdrawYtInstruction, CoreDepositYtInstruction, CoreInitializeYieldPositionInstruction, TitanSwapInstruction, LoopscaleInstruction, ClmmDepositLiquidityInstruction, ClmmAddLiquidityInstruction, ClmmWithdrawLiquidityInstruction, ClmmTradePtInstruction, ClmmBuyPtInstruction, ClmmSellPtInstruction, ClmmBuyYtInstruction, ClmmSellYtInstruction, ClmmClaimFarmEmissionInstruction, VaultInstruction, KaminoReserves, SyMintInstruction, SyRedeemInstruction } from "./vault-instruction-types";
+import { OrderbookTradeDirection } from "./vault-instruction-types";
 /**
  * Builder for Kamino Lending (KLend) vault action descriptors.
  *
@@ -334,7 +47,8 @@ export declare const kaminoAction: {
     initUserMetadata(market: KaminoMarket): MarketInstruction;
     /**
      * 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;
@@ -634,7 +348,6 @@ export declare const kaminoAction: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
             };
-            /** The existing LpPosition account public key. */
             readonly KMNO: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
@@ -662,7 +375,7 @@ export declare const kaminoAction: {
             readonly TNSR: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
-            };
+            }; /** Harvest a specific reward index into a managed vault reward ATA. */
             readonly GOAT: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
@@ -671,7 +384,6 @@ export declare const kaminoAction: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
             };
-            /** Swap direction: SyToPt or PtToSy. */
             readonly USDH: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
@@ -1488,7 +1200,6 @@ export declare const kaminoAction: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
             };
-            /** The existing LpPosition account public key. */
             readonly KMNO: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
@@ -1516,7 +1227,7 @@ export declare const kaminoAction: {
             readonly TNSR: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
-            };
+            }; /** Harvest a specific reward index into a managed vault reward ATA. */
             readonly GOAT: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
@@ -1525,7 +1236,6 @@ export declare const kaminoAction: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
             };
-            /** Swap direction: SyToPt or PtToSy. */
             readonly USDH: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
@@ -2342,7 +2052,6 @@ export declare const kaminoAction: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
             };
-            /** The existing LpPosition account public key. */
             readonly KMNO: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
@@ -2370,7 +2079,7 @@ export declare const kaminoAction: {
             readonly TNSR: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
-            };
+            }; /** Harvest a specific reward index into a managed vault reward ATA. */
             readonly GOAT: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
@@ -2379,7 +2088,6 @@ export declare const kaminoAction: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
             };
-            /** Swap direction: SyToPt or PtToSy. */
             readonly USDH: {
                 pubkey: web3.PublicKey;
                 mint: web3.PublicKey;
@@ -2909,6 +2617,71 @@ export declare const kaminoAction: {
         };
     }[M_3], amount: BN): ReserveInstruction;
 };
+/**
+ * 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 declare 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;
+    /**
+     * 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;
+};
+/**
+ * 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 declare const kaminoFarmAction: {
+    /** Initialize the farm `user_state` PDA. */
+    initializeUser(params: {
+        farmState: PublicKey;
+        delegatee?: PublicKey;
+    }): KaminoFarmInitializeUserInstruction;
+    /** Stake the managed vault's token ATA into the farm. */
+    stake(params: {
+        farmState: PublicKey;
+        amount: BN | "ALL";
+        delegatee?: PublicKey;
+    }): KaminoFarmStakeInstruction;
+    /** Unstake a scaled share amount from the farm. */
+    unstake(params: {
+        farmState: PublicKey;
+        stakeSharesScaled: BN;
+        delegatee?: PublicKey;
+    }): KaminoFarmUnstakeInstruction;
+    /** Withdraw matured unstaked deposits back into the managed vault ATA. */
+    withdrawUnstakedDeposits(params: {
+        farmState: PublicKey;
+        delegatee?: PublicKey;
+    }): KaminoFarmWithdrawUnstakedDepositsInstruction;
+    /** Harvest a specific reward index into a managed vault reward ATA. */
+    harvestReward(params: {
+        farmState: PublicKey;
+        rewardIndex: number;
+        delegatee?: PublicKey;
+    }): KaminoFarmHarvestRewardInstruction;
+};
 /**
  * Result of building a vault sync transaction.
  *
@@ -2937,8 +2710,37 @@ export interface VaultSyncTransactionResult {
     /** ALT addresses that should be loaded and included in the versioned transaction's lookup tables. */
     addressLookupTableAddresses: PublicKey[];
 }
+type CreateVaultSyncTransactionParams = {
+    instructions: VaultInstruction[];
+    owner: PublicKey;
+    connection: Connection;
+    policyPda?: PublicKey;
+    vaultPda?: PublicKey;
+    signer: PublicKey;
+    accountIndex?: number;
+    constraintIndices?: number[];
+    /** ExponentStrategyVault PDA — used to auto-resolve hook accounts from the on-chain policy */
+    vaultAddress?: PublicKey;
+    leadingAccounts?: PublicKey[] | AccountMeta[];
+    preHookAccounts?: PublicKey[] | AccountMeta[];
+    postHookAccounts?: PublicKey[] | AccountMeta[];
+    squadsProgram?: PublicKey;
+    /** 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 vault instructions and wrap them in a Squads sync transaction.
+ * 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 declare function createVaultSyncTransactions(params: CreateVaultSyncTransactionParams): Promise<VaultSyncTransactionResult[]>;
+/**
+ * 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:
@@ -2948,42 +2750,99 @@ export interface VaultSyncTransactionResult {
  * KLend's `check_refresh` requires refreshReserve to be a top-level instruction
  * so it can be found via the instruction sysvar.
  *
- * @returns `{ setupInstructions, preInstructions, instruction, postInstructions, signers, addressLookupTableAddresses }`
- *
- * @example
- * ```ts
- * const { setupInstructions, preInstructions, instruction, postInstructions, signers, addressLookupTableAddresses } = await createVaultSyncTransaction({
- *   instructions: [
- *     kamino.initUserMetadata(KaminoMarket.MAIN),
- *     kamino.initObligation(KaminoMarket.MAIN),
- *     kamino.deposit(KaminoMarket.MAIN, "USDC", new BN(1_000_000)),
- *   ],
- *   owner: vaultPda,
- *   connection,
- *   policyPda,
- *   vaultPda,
- *   signer: wallet.publicKey,
- *   vaultAddress: VAULT_ADDRESS,
- * })
- * // Send: [...setupInstructions, ...preInstructions, instruction, ...postInstructions]
- * ```
+ * When a smart Kamino Vault withdraw expands beyond one sync transaction, this
+ * singular helper throws and asks the caller to use
+ * {@link createVaultSyncTransactions} or {@link VaultTransactionBuilder}.
  */
-export declare function createVaultSyncTransaction({ instructions, owner, connection, policyPda, vaultPda, signer, accountIndex, constraintIndices, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram, }: {
-    instructions: VaultInstruction[];
-    owner: PublicKey;
+export declare function createVaultSyncTransaction(params: CreateVaultSyncTransactionParams): Promise<VaultSyncTransactionResult>;
+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 ResolvedHookAccounts = {
+    leadingAccounts: PublicKey[] | AccountMeta[];
+    preHookAccounts: PublicKey[] | AccountMeta[];
+    postHookAccounts: PublicKey[] | AccountMeta[];
+};
+export type StrategySetupContext = {
     connection: Connection;
-    policyPda?: PublicKey;
-    vaultPda: PublicKey;
+    env: Environment;
+    owner: PublicKey;
     signer: PublicKey;
-    accountIndex?: number;
-    constraintIndices?: number[];
-    /** ExponentStrategyVault PDA — used to auto-resolve hook accounts from the on-chain policy */
     vaultAddress?: PublicKey;
+    policyPda?: PublicKey;
+    vaultPda?: PublicKey;
+    accountIndex: number;
+    squadsProgram: PublicKey;
     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>;
+};
+export declare function createStrategySetupContext({ connection, env, owner, signer, vaultAddress, policyPda, vaultPda, accountIndex, squadsProgram, leadingAccounts, preHookAccounts, postHookAccounts, autoManagePositions, pricesAccount, }: {
+    connection: Connection;
+    env: Environment;
+    owner: PublicKey;
+    signer: PublicKey;
+    vaultAddress?: PublicKey;
+    policyPda?: PublicKey;
+    vaultPda?: PublicKey;
+    accountIndex?: number;
     squadsProgram?: PublicKey;
-}): Promise<VaultSyncTransactionResult>;
+    leadingAccounts?: PublicKey[] | AccountMeta[];
+    preHookAccounts?: PublicKey[] | AccountMeta[];
+    postHookAccounts?: PublicKey[] | AccountMeta[];
+    autoManagePositions?: boolean;
+    pricesAccount?: ExponentPrices;
+}): StrategySetupContext;
+export declare function buildSetupStatePriceRefreshInstructions(setupContext: StrategySetupContext): Promise<TransactionInstruction[]>;
+type KaminoVaultWithdrawPlanningSnapshot = {
+    sharesBalance: BN;
+    tokenAvailable: BN;
+    sharesIssued: BN;
+    pendingFeesSf: BN;
+    reserves: Array<{
+        reserveAddress: PublicKey;
+        investedLiquidityAmount: Decimal;
+        availableLiquidityToWithdraw: Decimal;
+    }>;
+};
+type KaminoVaultWithdrawPlanningLeg = {
+    reserveAddress: PublicKey;
+    sharesAmount: BN;
+};
+declare function calculateKaminoVaultTokensPerShareFromSnapshot(snapshot: KaminoVaultWithdrawPlanningSnapshot): Decimal;
+declare function planKaminoVaultWithdrawLegsFromSnapshot(params: {
+    sharesAmount: BN;
+    reserve?: PublicKey;
+    snapshot: KaminoVaultWithdrawPlanningSnapshot;
+}): KaminoVaultWithdrawPlanningLeg[];
+export declare const __kaminoVaultTesting: {
+    calculateKaminoVaultTokensPerShareFromSnapshot: typeof calculateKaminoVaultTokensPerShareFromSnapshot;
+    planKaminoVaultWithdrawLegsFromSnapshot: typeof planKaminoVaultWithdrawLegsFromSnapshot;
+};
 /**
  * Builder for Exponent Orderbook vault action descriptors.
  *
@@ -3016,17 +2875,13 @@ export declare 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;
@@ -3142,7 +2997,8 @@ export declare const coreAction: {
     }): CoreDepositYtInstruction;
     /**
      * 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;
@@ -3183,7 +3039,7 @@ export declare function createOrderbookSyncTransaction({ instructions, owner, co
     owner: PublicKey;
     connection: Connection;
     policyPda?: PublicKey;
-    vaultPda: PublicKey;
+    vaultPda?: PublicKey;
     signer: PublicKey;
     accountIndex?: number;
     constraintIndices?: number[];
@@ -3220,13 +3076,15 @@ export declare 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;
+        addressLookupTableAddresses?: PublicKey[];
     }): TitanSwapInstruction;
 };
 /**
- * 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.
@@ -3341,7 +3199,9 @@ export declare 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