@exponent-labs/exponent-sdk 0.9.1 → 0.9.2

package/build/exponentVaults/vault-interaction.js

@@ -26,9 +26,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwapDirection = exports.clmmAction = exports.loopscaleAction = exports.titanAction = exports.createOrderbookSyncTransaction = exports.coreAction = exports.syAction = exports.orderbookAction = exports.buildSetupStatePriceRefreshInstructions = exports.createStrategySetupContext = exports.createVaultSyncTransaction = exports.kaminoFarmAction = exports.kaminoVaultAction = exports.kaminoAction = exports.ClmmAction = exports.LoopscaleAction = exports.TitanAction = exports.SyAction = exports.CoreAction = exports.OrderbookAction = exports.OrderbookTradeDirection = exports.KaminoFarmAction = exports.KaminoVaultAction = exports.VaultAction = void 0;
+exports.SwapDirection = exports.clmmAction = exports.loopscaleAction = exports.titanAction = exports.createOrderbookSyncTransaction = exports.coreAction = exports.syAction = exports.orderbookAction = exports.__kaminoVaultTesting = exports.buildSetupStatePriceRefreshInstructions = exports.createStrategySetupContext = exports.createVaultSyncTransaction = exports.createVaultSyncTransactions = exports.kaminoFarmAction = exports.kaminoVaultAction = exports.kaminoAction = exports.ClmmAction = exports.LoopscaleAction = exports.TitanAction = exports.SyAction = exports.CoreAction = exports.OrderbookAction = exports.OrderbookTradeDirection = exports.KaminoFarmAction = exports.KaminoVaultAction = exports.VaultAction = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
 const kamino_reserve_deserializer_1 = require("@exponent-labs/kamino-reserve-deserializer");
 const exponent_fetcher_1 = require("@exponent-labs/exponent-fetcher");
+const kamino_vault_idl_1 = require("@exponent-labs/kamino-vault-idl");
 const kamino_markets_1 = require("./kamino-markets");
 const decimal_js_1 = __importDefault(require("decimal.js"));
 const constants_1 = require("./../../../kamino-lend-standard/src/constants");
@@ -63,6 +65,7 @@ const KAMINO_VAULT_ALLOCATION_STRATEGY_OFFSET = 304;
 const KAMINO_VAULT_ALLOCATION_SIZE = 2160;
 const KAMINO_VAULT_ALLOCATION_CTOKEN_VAULT_OFFSET = 32;
 const KAMINO_VAULT_GLOBAL_CONFIG_SEED = Buffer.from("global_config");
+const KAMINO_VAULT_CODER = new anchor_1.BorshCoder(kamino_vault_idl_1.IDL);
 // ============================================================================
 // Vault Instruction Types (re-exported from vault-instruction-types.ts)
 // ============================================================================
@@ -181,8 +184,8 @@ exports.kaminoVaultAction = {
     },
     /**
      * Withdraw Kamino Vault shares back into the vault-owned token account.
-     * When the Kamino Vault currently allocates across multiple reserves,
-     * specify the reserve to disinvest from.
+     * `reserve` is an optional override. When omitted, the SDK plans the
+     * withdraw across the vault's active reserves automatically.
      */
     withdraw(params) {
         return { action: vault_instruction_types_2.KaminoVaultAction.WITHDRAW, ...params };
@@ -218,7 +221,19 @@ exports.kaminoFarmAction = {
     },
 };
 /**
- * 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.
+ */
+async function createVaultSyncTransactions(params) {
+    return buildVaultSyncTransactionResults(params, true);
+}
+exports.createVaultSyncTransactions = createVaultSyncTransactions;
+/**
+ * Build exactly one vault sync transaction and return its wrapped instruction set.
  *
  * Takes high-level `VaultInstruction` descriptors (built with `kamino.*`),
  * resolves them to raw Solana instructions, then separates them:
@@ -228,27 +243,16 @@ exports.kaminoFarmAction = {
  * KLend's `check_refresh` requires refreshReserve to be a top-level instruction
  * so it can be found via the instruction sysvar.
  *
- * @returns `{ setupInstructions, preInstructions, instruction, postInstructions, signers, addressLookupTableAddresses }`
- *
- * @example
- * ```ts
- * const { setupInstructions, preInstructions, instruction, postInstructions, signers, addressLookupTableAddresses } = await createVaultSyncTransaction({
- *   instructions: [
- *     kamino.initUserMetadata(KaminoMarket.MAIN),
- *     kamino.initObligation(KaminoMarket.MAIN),
- *     kamino.deposit(KaminoMarket.MAIN, "USDC", new BN(1_000_000)),
- *   ],
- *   owner: vaultPda,
- *   connection,
- *   policyPda,
- *   vaultPda,
- *   signer: wallet.publicKey,
- *   vaultAddress: VAULT_ADDRESS,
- * })
- * // Send: [...setupInstructions, ...preInstructions, instruction, ...postInstructions]
- * ```
+ * When a smart Kamino Vault withdraw expands beyond one sync transaction, this
+ * singular helper throws and asks the caller to use
+ * {@link createVaultSyncTransactions} or {@link VaultTransactionBuilder}.
  */
-async function createVaultSyncTransaction({ instructions, owner, connection, policyPda, vaultPda, signer, accountIndex = 0, constraintIndices, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram = syncTransaction_1.SQUADS_PROGRAM_ID, autoManagePositions = false, setupContext, }) {
+async function createVaultSyncTransaction(params) {
+    const results = await buildVaultSyncTransactionResults(params, false);
+    return results[0];
+}
+exports.createVaultSyncTransaction = createVaultSyncTransaction;
+async function buildVaultSyncTransactionResults({ instructions, owner, connection, policyPda, vaultPda, signer, accountIndex = 0, constraintIndices, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram = syncTransaction_1.SQUADS_PROGRAM_ID, autoManagePositions = false, setupContext, }, splitOversizedKaminoVaultWithdraw) {
     vaultPda ??= owner;
     const resolvedSetupContext = setupContext ?? createStrategySetupContext({
         connection,
@@ -265,10 +269,92 @@ async function createVaultSyncTransaction({ instructions, owner, connection, pol
         postHookAccounts,
         autoManagePositions,
     });
-    const { setupInstructions, syncInstructions, preInstructions, postInstructions, signers, addressLookupTableAddresses } = await buildVaultInstructions(instructions, owner, connection, signer, policyPda, vaultPda, accountIndex, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram, autoManagePositions, resolvedSetupContext);
+    const buckets = await buildVaultInstructions(instructions, owner, connection, signer, policyPda, vaultPda, accountIndex, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram, autoManagePositions, resolvedSetupContext);
     const setupStatePriceRefreshInstructions = setupContext
         ? []
         : await buildSetupStatePriceRefreshInstructions(resolvedSetupContext);
+    const fullResult = await buildWrappedVaultSyncTransactionResult({
+        connection,
+        policyPda,
+        vaultPda,
+        signer,
+        accountIndex,
+        constraintIndices,
+        vaultAddress,
+        leadingAccounts,
+        preHookAccounts,
+        postHookAccounts,
+        squadsProgram,
+        syncInstructions: buckets.syncInstructions,
+        setupInstructions: buckets.setupInstructions,
+        preInstructions: [...setupStatePriceRefreshInstructions, ...buckets.preInstructions],
+        postInstructions: buckets.postInstructions,
+        signers: buckets.signers,
+        addressLookupTableAddresses: buckets.addressLookupTableAddresses,
+    });
+    const isPlannerExpandedKaminoVaultWithdraw = instructions.length === 1
+        && instructions[0]?.action === vault_instruction_types_2.KaminoVaultAction.WITHDRAW
+        && !instructions[0].reserve
+        && buckets.syncInstructions.length > 1;
+    if (!isPlannerExpandedKaminoVaultWithdraw) {
+        return [fullResult];
+    }
+    if (await vaultSyncResultFitsInSingleTransaction({
+        connection,
+        payer: signer,
+        result: fullResult,
+    })) {
+        return [fullResult];
+    }
+    if (!splitOversizedKaminoVaultWithdraw) {
+        throw new Error("Kamino Vault withdraw expands beyond one sync transaction; use createVaultSyncTransactions() or VaultTransactionBuilder.");
+    }
+    if (buckets.preInstructions.length > 0 || buckets.postInstructions.length > 0) {
+        throw new Error("Kamino Vault withdraw chunking only supports sync-only actions; use explicit reserve overrides if you need custom refresh handling.");
+    }
+    const splitResults = [];
+    for (const [index, syncInstruction] of buckets.syncInstructions.entries()) {
+        const chunkConstraintIndices = constraintIndices
+            ? constraintIndices.length === buckets.syncInstructions.length
+                ? [constraintIndices[index]]
+                : constraintIndices.length === 1
+                    ? constraintIndices
+                    : (() => {
+                        throw new Error("constraintIndices must contain either one entry or one entry per generated sync instruction when splitting a Kamino Vault withdraw.");
+                    })()
+            : undefined;
+        const chunkResult = await buildWrappedVaultSyncTransactionResult({
+            connection,
+            policyPda,
+            vaultPda,
+            signer,
+            accountIndex,
+            constraintIndices: chunkConstraintIndices,
+            vaultAddress,
+            leadingAccounts,
+            preHookAccounts,
+            postHookAccounts,
+            squadsProgram,
+            syncInstructions: [syncInstruction],
+            setupInstructions: index === 0 ? buckets.setupInstructions : [],
+            preInstructions: index === 0 ? [...setupStatePriceRefreshInstructions] : [],
+            postInstructions: [],
+            signers: buckets.signers,
+            addressLookupTableAddresses: buckets.addressLookupTableAddresses,
+        });
+        const chunkFits = await vaultSyncResultFitsInSingleTransaction({
+            connection,
+            payer: signer,
+            result: chunkResult,
+        });
+        if (!chunkFits) {
+            throw new Error(`Kamino Vault withdraw chunk ${index + 1} still exceeds one sync transaction; use explicit reserve overrides or smaller steps.`);
+        }
+        splitResults.push(chunkResult);
+    }
+    return splitResults;
+}
+async function buildWrappedVaultSyncTransactionResult({ connection, policyPda, vaultPda, signer, accountIndex, constraintIndices, vaultAddress, leadingAccounts, preHookAccounts, postHookAccounts, squadsProgram, syncInstructions, setupInstructions, preInstructions, postInstructions, signers, addressLookupTableAddresses, }) {
     let resolvedPolicyPda = policyPda;
     let resolvedConstraintIndices = constraintIndices;
     if (!resolvedPolicyPda) {
@@ -279,9 +365,7 @@ async function createVaultSyncTransaction({ instructions, owner, connection, pol
         resolvedPolicyPda = match.policyPda;
         resolvedConstraintIndices ??= match.constraintIndices;
     }
-    // Auto-resolve constraint indices when not explicitly provided
     resolvedConstraintIndices ??= await (0, policyMatcher_1.resolveConstraintIndices)(connection, resolvedPolicyPda, syncInstructions);
-    // Auto-resolve policy prefix and hook accounts when not explicitly provided
     let resolvedLeadingAccounts = leadingAccounts;
     let resolvedPreHookAccounts = preHookAccounts;
     let resolvedPostHookAccounts = postHookAccounts;
@@ -305,14 +389,33 @@ async function createVaultSyncTransaction({ instructions, owner, connection, pol
     });
     return {
         setupInstructions,
-        preInstructions: [...setupStatePriceRefreshInstructions, ...preInstructions],
+        preInstructions,
         instruction,
         postInstructions,
         signers,
         addressLookupTableAddresses,
     };
 }
-exports.createVaultSyncTransaction = createVaultSyncTransaction;
+async function vaultSyncResultFitsInSingleTransaction(params) {
+    try {
+        const altAccounts = await resolveVaultSyncAltAccounts(params.connection, params.result.addressLookupTableAddresses);
+        const message = new web3_js_1.TransactionMessage({
+            payerKey: params.payer,
+            recentBlockhash: web3_js_1.PublicKey.default.toBase58(),
+            instructions: [...params.result.preInstructions, params.result.instruction, ...params.result.postInstructions],
+        }).compileToV0Message(altAccounts);
+        return new web3_js_1.VersionedTransaction(message).serialize().length <= 1232;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveVaultSyncAltAccounts(connection, addresses) {
+    const lookupTables = await Promise.all(addresses.map((address) => connection.getAddressLookupTable(address)));
+    return lookupTables
+        .map((entry) => entry.value)
+        .filter((entry) => entry !== null);
+}
 // ============================================================================
 // Internal: Instruction Assembly
 // ============================================================================
@@ -1095,6 +1198,9 @@ function toBn(value) {
     }
     return new bn_js_1.default(value.toString());
 }
+function minBn(lhs, rhs) {
+    return lhs.lte(rhs) ? lhs : rhs;
+}
 function encodeU64InstructionData(discriminator, value) {
     return Buffer.concat([discriminator, toBn(value).toArrayLike(Buffer, "le", 8)]);
 }
@@ -1151,6 +1257,94 @@ function resolveKaminoVaultTrackedPriceId(params) {
     const reservePriceIds = (0, pricePathResolver_1.extractPriceIds)(reservePriceId).map((id) => BigInt(id));
     return { __kind: "Multiply", priceIds: [...reservePriceIds, params.sharePriceId] };
 }
+function decodeKaminoVaultState(data) {
+    const decoded = KAMINO_VAULT_CODER.accounts.decode("VaultState", data);
+    return {
+        tokenAvailable: decoded.token_available,
+        sharesIssued: decoded.shares_issued,
+        pendingFeesSf: decoded.pending_fees_sf,
+        allocations: decoded.vault_allocation_strategy
+            .filter((allocation) => !allocation.reserve.equals(web3_js_1.PublicKey.default))
+            .map((allocation) => ({
+            reserve: allocation.reserve,
+            ctokenAllocation: allocation.ctoken_allocation,
+        })),
+    };
+}
+function calculateKaminoVaultTokensPerShareFromSnapshot(snapshot) {
+    if (snapshot.sharesIssued.isZero()) {
+        return new decimal_js_1.default(0);
+    }
+    const investedTotal = snapshot.reserves.reduce((total, reserve) => total.add(reserve.investedLiquidityAmount), new decimal_js_1.default(0));
+    const pendingFees = new kamino_reserve_deserializer_1.Fraction(snapshot.pendingFeesSf).toDecimal();
+    const currentVaultAum = new decimal_js_1.default(snapshot.tokenAvailable.toString())
+        .add(investedTotal)
+        .sub(pendingFees);
+    if (currentVaultAum.lte(0)) {
+        return new decimal_js_1.default(0);
+    }
+    return currentVaultAum.div(snapshot.sharesIssued.toString());
+}
+function planKaminoVaultWithdrawLegsFromSnapshot(params) {
+    if (params.reserve) {
+        return [{ reserveAddress: params.reserve, sharesAmount: params.sharesAmount }];
+    }
+    const actualSharesToWithdraw = minBn(params.sharesAmount, params.snapshot.sharesBalance);
+    if (actualSharesToWithdraw.isZero()) {
+        throw new Error("Cannot withdraw zero Kamino Vault shares");
+    }
+    if (params.snapshot.reserves.length === 0) {
+        throw new Error("Kamino Vault has no active reserves to anchor a reserve-specific withdraw instruction");
+    }
+    const withdrawAllShares = params.sharesAmount.gte(params.snapshot.sharesBalance);
+    const tokensPerShare = calculateKaminoVaultTokensPerShareFromSnapshot(params.snapshot);
+    if (tokensPerShare.lte(0)) {
+        throw new Error("Kamino Vault has zero share price; cannot plan a withdraw");
+    }
+    const tokensToWithdraw = new decimal_js_1.default(actualSharesToWithdraw.toString()).mul(tokensPerShare);
+    const availableTokens = new decimal_js_1.default(params.snapshot.tokenAvailable.toString());
+    if (tokensToWithdraw.lte(availableTokens)) {
+        return [{
+                reserveAddress: params.snapshot.reserves[0].reserveAddress,
+                sharesAmount: withdrawAllShares ? params.snapshot.sharesBalance : actualSharesToWithdraw,
+            }];
+    }
+    let tokensRemaining = tokensToWithdraw;
+    const plannedLegs = [];
+    const sortedReserves = [...params.snapshot.reserves].sort((lhs, rhs) => rhs.availableLiquidityToWithdraw.comparedTo(lhs.availableLiquidityToWithdraw));
+    for (const [index, reserve] of sortedReserves.entries()) {
+        const legCapacity = reserve.availableLiquidityToWithdraw.add(index === 0 ? availableTokens : 0);
+        if (legCapacity.lte(0)) {
+            continue;
+        }
+        const tokensForLeg = decimal_js_1.default.min(tokensRemaining, legCapacity);
+        if (tokensForLeg.lte(0)) {
+            continue;
+        }
+        const sharesForLeg = withdrawAllShares
+            ? params.snapshot.sharesBalance
+            : new bn_js_1.default(tokensForLeg.div(tokensPerShare).floor().toFixed(0));
+        if (sharesForLeg.isZero()) {
+            continue;
+        }
+        plannedLegs.push({
+            reserveAddress: reserve.reserveAddress,
+            sharesAmount: sharesForLeg,
+        });
+        tokensRemaining = tokensRemaining.sub(tokensForLeg);
+        if (tokensRemaining.lte(0)) {
+            break;
+        }
+    }
+    if (plannedLegs.length === 0) {
+        throw new Error("Unable to plan a Kamino Vault withdraw across the vault's active reserves");
+    }
+    return plannedLegs;
+}
+exports.__kaminoVaultTesting = {
+    calculateKaminoVaultTokensPerShareFromSnapshot,
+    planKaminoVaultWithdrawLegsFromSnapshot,
+};
 async function resolveKaminoVaultContext(vaultAddress, setupContext) {
     const rawIndex = await (0, exponent_fetcher_1.fetchKaminoVaultIndex)({
         connection: setupContext.connection,
@@ -1166,6 +1360,7 @@ async function resolveKaminoVaultContext(vaultAddress, setupContext) {
     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()}`);
@@ -1175,12 +1370,17 @@ async function resolveKaminoVaultContext(vaultAddress, setupContext) {
     const collateralMintInfos = await setupContext.connection.getMultipleAccountsInfo(decodedReserves.map((reserve) => reserve.collateral.mintPubkey));
     const normalizedReserves = reserveAddresses.map((reserveAddress, index) => {
         const reserveAccount = decodedReserves[index];
+        const allocation = decodedVaultState.allocations[index];
         const rawReserve = rawIndex.reserves[index];
         const allocationOffset = KAMINO_VAULT_ACCOUNT_DISCRIMINATOR_LEN
             + KAMINO_VAULT_ALLOCATION_STRATEGY_OFFSET
             + (index * KAMINO_VAULT_ALLOCATION_SIZE);
         const ctokenVaultOffset = allocationOffset + KAMINO_VAULT_ALLOCATION_CTOKEN_VAULT_OFFSET;
         const [lendingMarketAuthority] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("lma"), reserveAccount.lendingMarket.toBuffer()], policyBuilders_1.KAMINO_LENDING_PROGRAM_ID);
+        const investedLiquidityAmount = allocation
+            ? new decimal_js_1.default(allocation.ctokenAllocation.toString()).mul(reserveAccount.getCollateralExchangeRate())
+            : new decimal_js_1.default(0);
+        const availableLiquidityToWithdraw = decimal_js_1.default.min(investedLiquidityAmount, reserveAccount.getLiquidityAvailableAmount());
         return {
             reserveAddress,
             marketAddress: rawReserve.marketAddress ?? rawReserve.reserve ?? reserveAccount.lendingMarket,
@@ -1196,6 +1396,9 @@ async function resolveKaminoVaultContext(vaultAddress, setupContext) {
             reserveLiquiditySupply: rawReserve.reserveLiquiditySupply ?? reserveAccount.liquidity.supplyVault,
             reserveCollateralMint: rawReserve.reserveCollateralMint ?? reserveAccount.collateral.mintPubkey,
             reserveCollateralTokenProgram: rawReserve.reserveCollateralTokenProgram ?? collateralMintInfos[index]?.owner ?? web3_js_1.PublicKey.default,
+            account: reserveAccount,
+            investedLiquidityAmount,
+            availableLiquidityToWithdraw,
         };
     });
     const index = {
@@ -1209,7 +1412,11 @@ async function resolveKaminoVaultContext(vaultAddress, setupContext) {
     };
     const tokenAta = (0, spl_token_1.getAssociatedTokenAddressSync)(index.tokenMint, setupContext.owner, true, index.tokenProgram);
     const sharesAta = (0, spl_token_1.getAssociatedTokenAddressSync)(index.sharesMint, setupContext.owner, true, index.sharesTokenProgram);
-    return { index, tokenAta, sharesAta };
+    const sharesAtaInfo = await setupContext.connection.getAccountInfo(sharesAta);
+    const sharesBalance = sharesAtaInfo?.data
+        ? new bn_js_1.default(spl_token_1.AccountLayout.decode(sharesAtaInfo.data).amount.toString())
+        : new bn_js_1.default(0);
+    return { index, tokenAta, sharesAta, sharesBalance, state: decodedVaultState };
 }
 async function queueKaminoVaultSharesTracking(params) {
     const state = await loadStrategySetupState(params.setupContext);
@@ -1337,21 +1544,49 @@ function buildKaminoVaultDepositInstruction(params) {
         data: encodeU64InstructionData(policyBuilders_1.KAMINO_VAULT_DISCRIMINATORS.deposit, params.amount),
     });
 }
-function resolveKaminoVaultWithdrawReserve(ix, vaultContext) {
+function resolveExplicitKaminoVaultWithdrawReserve(ix, vaultContext) {
+    if (!ix.reserve) {
+        throw new Error("reserve is required when resolving an explicit Kamino Vault withdraw reserve");
+    }
+    const reserve = vaultContext.index.reserves.find((entry) => entry.reserveAddress.equals(ix.reserve));
+    if (!reserve) {
+        throw new Error(`Kamino Vault ${ix.vault.toBase58()} does not use reserve ${ix.reserve.toBase58()}`);
+    }
+    return reserve;
+}
+function planKaminoVaultWithdrawLegs(ix, vaultContext) {
     if (ix.reserve) {
-        const reserve = vaultContext.index.reserves.find((entry) => entry.reserveAddress.equals(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 ${ix.reserve.toBase58()}`);
+            throw new Error(`Kamino Vault ${ix.vault.toBase58()} does not use reserve ${leg.reserveAddress.toBase58()}`);
         }
-        return reserve;
-    }
-    if (vaultContext.index.reserves.length !== 1) {
-        throw new Error(`Kamino Vault ${ix.vault.toBase58()} uses ${vaultContext.index.reserves.length} reserves; specify withdraw.reserve`);
-    }
-    return vaultContext.index.reserves[0];
+        return {
+            reserve,
+            sharesAmount: leg.sharesAmount,
+        };
+    });
 }
 function buildKaminoVaultWithdrawInstruction(params) {
-    const reserve = resolveKaminoVaultWithdrawReserve(params.ix, params.vaultContext);
     const [globalConfig] = web3_js_1.PublicKey.findProgramAddressSync([KAMINO_VAULT_GLOBAL_CONFIG_SEED], policyBuilders_1.KAMINO_VAULT_PROGRAM_ID);
     return new web3_js_1.TransactionInstruction({
         programId: policyBuilders_1.KAMINO_VAULT_PROGRAM_ID,
@@ -1371,13 +1606,13 @@ function buildKaminoVaultWithdrawInstruction(params) {
             { pubkey: KAMINO_VAULT_EVENT_AUTHORITY, isSigner: false, isWritable: false },
             { pubkey: policyBuilders_1.KAMINO_VAULT_PROGRAM_ID, isSigner: false, isWritable: false },
             { pubkey: params.ix.vault, isSigner: false, isWritable: true },
-            { pubkey: reserve.reserveAddress, isSigner: false, isWritable: true },
-            { pubkey: reserve.ctokenVault, isSigner: false, isWritable: true },
-            { pubkey: reserve.marketAddress, isSigner: false, isWritable: false },
-            { pubkey: reserve.lendingMarketAuthority, isSigner: false, isWritable: false },
-            { pubkey: reserve.reserveLiquiditySupply, isSigner: false, isWritable: true },
-            { pubkey: reserve.reserveCollateralMint, isSigner: false, isWritable: true },
-            { pubkey: reserve.reserveCollateralTokenProgram, isSigner: false, isWritable: false },
+            { pubkey: params.reserve.reserveAddress, isSigner: false, isWritable: true },
+            { pubkey: params.reserve.ctokenVault, isSigner: false, isWritable: true },
+            { pubkey: params.reserve.marketAddress, isSigner: false, isWritable: false },
+            { pubkey: params.reserve.lendingMarketAuthority, isSigner: false, isWritable: false },
+            { pubkey: params.reserve.reserveLiquiditySupply, isSigner: false, isWritable: true },
+            { pubkey: params.reserve.reserveCollateralMint, isSigner: false, isWritable: true },
+            { pubkey: params.reserve.reserveCollateralTokenProgram, isSigner: false, isWritable: false },
             { pubkey: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
             { pubkey: KAMINO_VAULT_EVENT_AUTHORITY, isSigner: false, isWritable: false },
             { pubkey: policyBuilders_1.KAMINO_VAULT_PROGRAM_ID, isSigner: false, isWritable: false },
@@ -1388,7 +1623,7 @@ function buildKaminoVaultWithdrawInstruction(params) {
             })),
             ...(params.validationAccounts ?? []),
         ],
-        data: encodeU64InstructionData(policyBuilders_1.KAMINO_VAULT_DISCRIMINATORS.withdraw, params.ix.sharesAmount),
+        data: encodeU64InstructionData(policyBuilders_1.KAMINO_VAULT_DISCRIMINATORS.withdraw, params.sharesAmount),
     });
 }
 async function buildKaminoVaultInstruction(ix, buckets, setupContext) {
@@ -1430,12 +1665,17 @@ async function buildKaminoVaultInstruction(ix, buckets, setupContext) {
         }
         return;
     }
-    buckets.syncInstructions.push(buildKaminoVaultWithdrawInstruction({
-        owner: setupContext.owner,
-        ix,
-        vaultContext,
-        validationAccounts,
-    }));
+    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, placeholderProgram) {
     return {