@epicentral/sos-sdk 0.6.1-alpha → 0.7.0-alpha

package/long/builders.ts

@@ -24,7 +24,13 @@ import {
 } from "../wsol/instructions";
 import { fetchMarketDataAccount, fetchOptionPool } from "../accounts/fetchers";
 import { getBuyFromPoolRemainingAccounts } from "./remaining-accounts";
+import { applySlippageBps } from "./quotes";
+import {
+  buildSwitchboardCrank,
+  prependSwitchboardCrank,
+} from "../oracle/switchboard";
 import { fetchWriterPositionsForPool } from "../accounts/list";
+import { getGlobalTradeConfig } from "../shared/trade-config";
 import bs58 from "bs58";
 
 export interface BuildBuyFromPoolParams {
@@ -143,6 +149,9 @@ export interface BuildBuyFromPoolTransactionWithDerivationParams {
   buyerPosition?: AddressLike;
   buyerOptionAccount?: AddressLike;
   remainingAccounts?: RemainingAccountInput[];
+  disableSwitchboardCrank?: boolean;
+  switchboardCrossbarUrl?: string;
+  switchboardNumSignatures?: number;
 }
 
 const DEFAULT_MARKET_ORDER_SLIPPAGE_BUFFER_BASE_UNITS = 500_000n;
@@ -224,7 +233,7 @@ export async function buildBuyFromPoolTransactionWithDerivation(
       Array.from(marketDataAccount.switchboardFeedId as unknown as Uint8Array)
     );
 
-  return buildBuyFromPoolTransaction({
+  const actionTx = await buildBuyFromPoolTransaction({
     optionPool: resolved.optionPool,
     optionAccount: resolved.optionAccount,
     longMint: resolved.longMint,
@@ -241,6 +250,20 @@ export async function buildBuyFromPoolTransactionWithDerivation(
     buyerOptionAccount,
     remainingAccounts: params.remainingAccounts,
   });
+
+  if (params.disableSwitchboardCrank) {
+    return actionTx;
+  }
+
+  const crank = await buildSwitchboardCrank({
+    rpc: params.rpc,
+    payer: params.buyer,
+    switchboardFeed,
+    marketData: resolved.marketData,
+    crossbarUrl: params.switchboardCrossbarUrl,
+    numSignatures: params.switchboardNumSignatures,
+  });
+  return prependSwitchboardCrank(crank, actionTx);
 }
 
 export interface BuildBuyFromPoolMarketOrderParams
@@ -311,10 +334,16 @@ export async function buildBuyFromPoolMarketOrderTransactionWithDerivation(
     `This may indicate data staleness - please refresh and retry.`
   );
 
-  const slippageBuffer = normalizeMarketOrderSlippageBuffer(
-    params,
-    refetchedPool.underlyingMint
-  );
+  const globalTradeConfig = getGlobalTradeConfig();
+  const hasExplicitSlippageBuffer =
+    params.slippageBufferBaseUnits !== undefined ||
+    params.slippageBufferLamports !== undefined;
+  const slippageBuffer = hasExplicitSlippageBuffer
+    ? normalizeMarketOrderSlippageBuffer(params, refetchedPool.underlyingMint)
+    : globalTradeConfig.slippageBps !== undefined
+      ? applySlippageBps(params.quotedPremiumTotal, globalTradeConfig.slippageBps) -
+        BigInt(params.quotedPremiumTotal)
+      : normalizeMarketOrderSlippageBuffer(params, refetchedPool.underlyingMint);
   const maxPremiumAmount = BigInt(params.quotedPremiumTotal) + slippageBuffer;
   assertPositiveAmount(maxPremiumAmount, "maxPremiumAmount");
 
@@ -329,7 +358,7 @@ export async function buildBuyFromPoolMarketOrderTransactionWithDerivation(
       Array.from(marketDataAccount.switchboardFeedId as unknown as Uint8Array)
     );
 
-  return buildBuyFromPoolTransaction({
+  const actionTx = await buildBuyFromPoolTransaction({
     optionPool: resolved.optionPool,
     optionAccount: resolved.optionAccount,
     longMint: resolved.longMint,
@@ -346,6 +375,20 @@ export async function buildBuyFromPoolMarketOrderTransactionWithDerivation(
     buyerOptionAccount,
     remainingAccounts,
   });
+
+  if (params.disableSwitchboardCrank) {
+    return actionTx;
+  }
+
+  const crank = await buildSwitchboardCrank({
+    rpc: params.rpc,
+    payer: params.buyer,
+    switchboardFeed,
+    marketData: resolved.marketData,
+    crossbarUrl: params.switchboardCrossbarUrl,
+    numSignatures: params.switchboardNumSignatures,
+  });
+  return prependSwitchboardCrank(crank, actionTx);
 }
 
 export async function buildCloseLongToPoolInstruction(
@@ -438,6 +481,9 @@ export interface BuildCloseLongToPoolTransactionWithDerivationParams {
    */
   unwrapPayoutSol?: boolean;
   remainingAccounts?: RemainingAccountInput[];
+  disableSwitchboardCrank?: boolean;
+  switchboardCrossbarUrl?: string;
+  switchboardNumSignatures?: number;
 }
 
 export async function buildCloseLongToPoolTransactionWithDerivation(
@@ -485,7 +531,7 @@ export async function buildCloseLongToPoolTransactionWithDerivation(
       Array.from(marketDataAccount.switchboardFeedId as unknown as Uint8Array)
     );
 
-  return buildCloseLongToPoolTransaction({
+  const actionTx = await buildCloseLongToPoolTransaction({
     optionPool: resolved.optionPool,
     optionAccount: resolved.optionAccount,
     collateralPool: resolved.collateralPool,
@@ -507,4 +553,18 @@ export async function buildCloseLongToPoolTransactionWithDerivation(
     unwrapPayoutSol,
     remainingAccounts: params.remainingAccounts,
   });
+
+  if (params.disableSwitchboardCrank) {
+    return actionTx;
+  }
+
+  const crank = await buildSwitchboardCrank({
+    rpc: params.rpc,
+    payer: params.buyer,
+    switchboardFeed,
+    marketData: resolved.marketData,
+    crossbarUrl: params.switchboardCrossbarUrl,
+    numSignatures: params.switchboardNumSignatures,
+  });
+  return prependSwitchboardCrank(crank, actionTx);
 }

package/long/exercise.ts

@@ -1,7 +1,11 @@
 import { getOptionExerciseInstruction } from "../generated/instructions";
 import type { Instruction } from "@solana/kit";
 import { toAddress } from "../client/program";
-import type { AddressLike, BuiltTransaction } from "../client/types";
+import type { AddressLike, BuiltTransaction, KitRpc } from "../client/types";
+import {
+  buildSwitchboardCrank,
+  prependSwitchboardCrank,
+} from "../oracle/switchboard";
 
 export interface BuildOptionExerciseParams {
   optionAccount: AddressLike;
@@ -16,6 +20,10 @@ export interface BuildOptionExerciseParams {
   escrowAuthority: AddressLike;
   buyer: AddressLike;
   tokenProgram?: AddressLike;
+  rpc?: KitRpc;
+  disableSwitchboardCrank?: boolean;
+  switchboardCrossbarUrl?: string;
+  switchboardNumSignatures?: number;
 }
 
 /**
@@ -48,7 +56,18 @@ export function buildOptionExerciseInstruction(
  */
 export function buildOptionExerciseTransaction(
   params: BuildOptionExerciseParams
-): BuiltTransaction {
+): Promise<BuiltTransaction> {
   const instruction = buildOptionExerciseInstruction(params);
-  return { instructions: [instruction] };
+  const actionTx = { instructions: [instruction] };
+  if (params.disableSwitchboardCrank || !params.rpc) {
+    return Promise.resolve(actionTx);
+  }
+
+  return buildSwitchboardCrank({
+    rpc: params.rpc,
+    payer: params.buyer,
+    switchboardFeed: params.switchboardFeed,
+    crossbarUrl: params.switchboardCrossbarUrl,
+    numSignatures: params.switchboardNumSignatures,
+  }).then((crank) => prependSwitchboardCrank(crank, actionTx));
 }

package/omlp/builders.ts

@@ -4,9 +4,13 @@ import {
 } from "../generated/instructions";
 import type { Instruction } from "@solana/kit";
 import { toAddress } from "../client/program";
-import type { AddressLike, BuiltTransaction } from "../client/types";
+import type { AddressLike, BuiltTransaction, KitRpc } from "../client/types";
 import { assertPositiveAmount } from "../shared/amounts";
 import { getCloseAccountInstruction, NATIVE_MINT } from "../wsol/instructions";
+import {
+  buildSwitchboardCrank,
+  prependSwitchboardCrank,
+} from "../oracle/switchboard";
 
 export interface BuildDepositToPositionParams {
   vault: AddressLike;
@@ -15,6 +19,12 @@ export interface BuildDepositToPositionParams {
   lender: AddressLike;
   amount: bigint | number;
   position?: AddressLike;
+  rpc?: KitRpc;
+  switchboardFeed?: AddressLike;
+  marketData?: AddressLike;
+  disableSwitchboardCrank?: boolean;
+  switchboardCrossbarUrl?: string;
+  switchboardNumSignatures?: number;
 }
 
 export interface BuildWithdrawFromPositionParams {
@@ -26,6 +36,12 @@ export interface BuildWithdrawFromPositionParams {
   position?: AddressLike;
   unwrapSol?: boolean;
   vaultMint?: AddressLike;
+  rpc?: KitRpc;
+  switchboardFeed?: AddressLike;
+  marketData?: AddressLike;
+  disableSwitchboardCrank?: boolean;
+  switchboardCrossbarUrl?: string;
+  switchboardNumSignatures?: number;
 }
 
 export async function buildDepositToPositionInstruction(
@@ -49,7 +65,24 @@ export async function buildDepositToPositionTransaction(
   params: BuildDepositToPositionParams
 ): Promise<BuiltTransaction> {
   const instruction = await buildDepositToPositionInstruction(params);
-  return { instructions: [instruction] };
+  const actionTx = { instructions: [instruction] };
+  if (
+    params.disableSwitchboardCrank ||
+    !params.rpc ||
+    (!params.switchboardFeed && !params.marketData)
+  ) {
+    return actionTx;
+  }
+
+  const crank = await buildSwitchboardCrank({
+    rpc: params.rpc,
+    payer: params.lender,
+    switchboardFeed: params.switchboardFeed,
+    marketData: params.marketData,
+    crossbarUrl: params.switchboardCrossbarUrl,
+    numSignatures: params.switchboardNumSignatures,
+  });
+  return prependSwitchboardCrank(crank, actionTx);
 }
 
 export async function buildWithdrawFromPositionInstruction(
@@ -90,5 +123,22 @@ export async function buildWithdrawFromPositionTransaction(
     );
   }
 
-  return { instructions };
+  const actionTx = { instructions };
+  if (
+    params.disableSwitchboardCrank ||
+    !params.rpc ||
+    (!params.switchboardFeed && !params.marketData)
+  ) {
+    return actionTx;
+  }
+
+  const crank = await buildSwitchboardCrank({
+    rpc: params.rpc,
+    payer: params.lender,
+    switchboardFeed: params.switchboardFeed,
+    marketData: params.marketData,
+    crossbarUrl: params.switchboardCrossbarUrl,
+    numSignatures: params.switchboardNumSignatures,
+  });
+  return prependSwitchboardCrank(crank, actionTx);
 }

package/oracle/switchboard.ts

@@ -1,10 +1,17 @@
-import type { Address } from "@solana/kit";
+import type { Address, Instruction } from "@solana/kit";
+import { fromLegacyTransactionInstruction } from "@solana/compat";
+import { CrossbarClient } from "@switchboard-xyz/common";
 import bs58 from "bs58";
 import { toAddress } from "../client/program";
-import type { AddressLike, KitRpc } from "../client/types";
+import type { AddressLike, BuiltTransaction, KitRpc } from "../client/types";
 import { fetchMarketDataAccount } from "../accounts/fetchers";
 import { invariant } from "../shared/errors";
 
+const DEVNET_GENESIS_HASH = "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG";
+const MAINNET_BETA_GENESIS_HASH = "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d";
+
+export type SwitchboardNetwork = "devnet" | "mainnet";
+
 export async function resolveSwitchboardFeedFromMarketData(
   rpc: KitRpc,
   marketData: AddressLike
@@ -54,3 +61,84 @@ export async function buildSwitchboardPullFeedUpdate<
     lookupTables: luts ?? [],
   };
 }
+
+export interface BuildSwitchboardCrankParams {
+  rpc: KitRpc;
+  payer: AddressLike;
+  switchboardFeed?: AddressLike;
+  marketData?: AddressLike;
+  network?: SwitchboardNetwork;
+  crossbarUrl?: string;
+  numSignatures?: number;
+}
+
+export interface SwitchboardCrankResult {
+  instructions: Instruction<string>[];
+  addressLookupTableAddresses: AddressLike[];
+}
+
+export async function inferSwitchboardNetwork(
+  rpc: KitRpc
+): Promise<SwitchboardNetwork> {
+  const genesisHash = await rpc.getGenesisHash().send();
+  if (genesisHash === DEVNET_GENESIS_HASH) {
+    return "devnet";
+  }
+  if (genesisHash === MAINNET_BETA_GENESIS_HASH) {
+    return "mainnet";
+  }
+  throw new Error(
+    `Unable to infer Switchboard network from genesis hash: ${genesisHash}`
+  );
+}
+
+export async function buildSwitchboardCrank(
+  params: BuildSwitchboardCrankParams
+): Promise<SwitchboardCrankResult> {
+  const resolvedFeed =
+    params.switchboardFeed ??
+    (params.marketData
+      ? await resolveSwitchboardFeedFromMarketData(params.rpc, params.marketData)
+      : undefined);
+
+  invariant(
+    !!resolvedFeed,
+    "switchboardFeed or marketData is required to build Switchboard crank instructions."
+  );
+
+  const network = params.network ?? (await inferSwitchboardNetwork(params.rpc));
+  const crossbar = params.crossbarUrl
+    ? new CrossbarClient(params.crossbarUrl)
+    : CrossbarClient.default();
+  const updates = await crossbar.fetchSolanaUpdates(
+    network,
+    [toAddress(resolvedFeed)],
+    toAddress(params.payer),
+    params.numSignatures
+  );
+  const update = updates[0];
+
+  const instructions =
+    update?.pullIxns?.map((instruction) =>
+      fromLegacyTransactionInstruction(instruction)
+    ) ?? [];
+  const addressLookupTableAddresses = update?.lookupTables ?? [];
+
+  return {
+    instructions,
+    addressLookupTableAddresses,
+  };
+}
+
+export function prependSwitchboardCrank(
+  crank: SwitchboardCrankResult,
+  action: BuiltTransaction
+): BuiltTransaction {
+  return {
+    instructions: [...crank.instructions, ...action.instructions],
+    addressLookupTableAddresses: [
+      ...(crank.addressLookupTableAddresses ?? []),
+      ...(action.addressLookupTableAddresses ?? []),
+    ],
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epicentral/sos-sdk",
-  "version": "0.6.1-alpha",
+  "version": "0.7.0-alpha",
   "private": false,
   "description": "Solana Option Standard SDK. The frontend-first SDK for Native Options Trading on Solana. Created by Epicentral Labs.",
   "type": "module",
@@ -18,7 +18,10 @@
     "@solana-program/address-lookup-table": "^0.11.0",
     "@solana-program/compute-budget": "^0.13.0",
     "@solana-program/system": "^0.11.0",
+    "@solana/compat": "^6.1.0",
     "@solana/kit": "^6.1.0",
+    "@switchboard-xyz/common": "^5.7.0",
+    "@switchboard-xyz/on-demand": "^3.9.0",
     "bs58": "^6.0.0",
     "decimal.js": "^10.4.3"
   },

package/shared/trade-config.ts

@@ -0,0 +1,27 @@
+export interface TradeConfig {
+  slippageBps?: number;
+  computeUnitLimit?: number;
+  computeUnitPriceMicroLamports?: number;
+}
+
+let globalTradeConfig: TradeConfig = {};
+
+export function setGlobalTradeConfig(config: TradeConfig): void {
+  globalTradeConfig = { ...config };
+}
+
+export function updateGlobalTradeConfig(config: Partial<TradeConfig>): void {
+  globalTradeConfig = { ...globalTradeConfig, ...config };
+}
+
+export function getGlobalTradeConfig(): TradeConfig {
+  return { ...globalTradeConfig };
+}
+
+export function resetGlobalTradeConfig(): void {
+  globalTradeConfig = {};
+}
+
+export function resolveTradeConfig(overrides?: Partial<TradeConfig>): TradeConfig {
+  return { ...globalTradeConfig, ...overrides };
+}

package/shared/transactions.ts

@@ -21,6 +21,11 @@ import {
 import type { Instruction } from "@solana/kit";
 import { toAddress } from "../client/program";
 import type { AddressLike, BuiltTransaction, KitRpc } from "../client/types";
+import {
+  getLookupTableAddressForNetwork,
+  type LookupTableNetwork,
+} from "../client/lookup-table";
+import { getGlobalTradeConfig } from "./trade-config";
 
 export interface SendBuiltTransactionParams extends BuiltTransaction {
   rpc: KitRpc;
@@ -29,7 +34,18 @@ export interface SendBuiltTransactionParams extends BuiltTransaction {
   commitment?: "processed" | "confirmed" | "finalized";
   computeUnitLimit?: number;
   computeUnitPriceMicroLamports?: number;
+  /**
+   * Address Lookup Table addresses to compress the transaction.
+   * REQUIRED for option_mint and other large transactions to avoid
+   * "encoding overruns Uint8Array" (Solana's 1232-byte tx limit).
+   * Use getLookupTableAddressForNetwork(network) or pass network to auto-include.
+   */
   addressLookupTableAddresses?: AddressLike[];
+  /**
+   * When set, automatically includes the option program's lookup table for this network.
+   * Use this when sending option_mint, buy_from_pool, or other large transactions.
+   */
+  network?: LookupTableNetwork;
 }
 
 /**
@@ -41,23 +57,38 @@ export async function sendBuiltTransaction(
   params: SendBuiltTransactionParams
 ): Promise<string> {
   const commitment = params.commitment ?? "confirmed";
+  const globalTradeConfig = getGlobalTradeConfig();
   const { value: latestBlockhash } = await params.rpc.getLatestBlockhash().send();
 
   const computeBudgetInstructions: Instruction<string>[] = [];
-  if (params.computeUnitLimit !== undefined) {
+  const computeUnitLimit =
+    params.computeUnitLimit ?? globalTradeConfig.computeUnitLimit;
+  if (computeUnitLimit !== undefined) {
     computeBudgetInstructions.push(
-      getSetComputeUnitLimitInstruction({ units: params.computeUnitLimit })
+      getSetComputeUnitLimitInstruction({ units: computeUnitLimit })
     );
   }
-  if (params.computeUnitPriceMicroLamports !== undefined) {
+  const computeUnitPriceMicroLamports =
+    params.computeUnitPriceMicroLamports ??
+    globalTradeConfig.computeUnitPriceMicroLamports;
+  if (computeUnitPriceMicroLamports !== undefined) {
     computeBudgetInstructions.push(
       getSetComputeUnitPriceInstruction({
-        microLamports: params.computeUnitPriceMicroLamports,
+        microLamports: computeUnitPriceMicroLamports,
       })
     );
   }
   const allInstructions = [...computeBudgetInstructions, ...params.instructions];
 
+  // Resolve address lookup tables: explicit list, or from network for option program
+  let addressLookupTableAddresses = params.addressLookupTableAddresses ?? [];
+  if (params.network) {
+    const programAlt = getLookupTableAddressForNetwork(params.network);
+    if (programAlt && !addressLookupTableAddresses.some((a) => String(a) === String(programAlt))) {
+      addressLookupTableAddresses = [programAlt, ...addressLookupTableAddresses];
+    }
+  }
+
   let txMessage = pipe(
     createTransactionMessage({ version: 0 }),
     (tx) => setTransactionMessageFeePayerSigner(params.feePayer, tx),
@@ -65,12 +96,9 @@ export async function sendBuiltTransaction(
     (tx) => appendTransactionMessageInstructions(allInstructions, tx)
   );
 
-  if (
-    params.addressLookupTableAddresses &&
-    params.addressLookupTableAddresses.length > 0
-  ) {
+  if (addressLookupTableAddresses.length > 0) {
     const addressesByAddressLookupTable: AddressesByLookupTableAddress = {};
-    for (const altAddress of params.addressLookupTableAddresses) {
+    for (const altAddress of addressLookupTableAddresses) {
       const resolvedAddress = toAddress(altAddress);
       const { data } = await fetchAddressLookupTable(params.rpc, resolvedAddress);
       addressesByAddressLookupTable[resolvedAddress] = data.addresses;

package/short/builders.ts

@@ -31,6 +31,12 @@ import {
   getWrapSOLInstructions,
 } from "../wsol/instructions";
 import { preflightUnwindWriterUnsold } from "./preflight";
+import {
+  buildSwitchboardCrank,
+  prependSwitchboardCrank,
+} from "../oracle/switchboard";
+import { applySlippageBps } from "../long/quotes";
+import { getGlobalTradeConfig } from "../shared/trade-config";
 import bs58 from "bs58";
 
 export interface BuildOptionMintParams {
@@ -48,6 +54,7 @@ export interface BuildOptionMintParams {
   collateralMint?: AddressLike;
   makerCollateralAmount: bigint | number;
   borrowedAmount: bigint | number;
+  maxRequiredCollateralAmount?: bigint | number;
   maker: AddressLike;
   makerCollateralAccount: AddressLike;
   underlyingMint: AddressLike;
@@ -133,6 +140,16 @@ export async function buildOptionMintInstruction(
   invariant(params.underlyingSymbol.length > 0, "underlyingSymbol is required.");
 
   const borrowedAmount = BigInt(params.borrowedAmount);
+  const globalTradeConfig = getGlobalTradeConfig();
+  const maxRequiredCollateralAmount =
+    params.maxRequiredCollateralAmount !== undefined
+      ? BigInt(params.maxRequiredCollateralAmount)
+      : globalTradeConfig.slippageBps !== undefined
+        ? applySlippageBps(
+            BigInt(params.makerCollateralAmount) + borrowedAmount,
+            globalTradeConfig.slippageBps
+          )
+        : BigInt(params.makerCollateralAmount) + borrowedAmount;
   if (borrowedAmount > 0n) {
     invariant(!!params.vault, "vault is required when borrowedAmount > 0");
     invariant(
@@ -209,6 +226,7 @@ export async function buildOptionMintInstruction(
     collateralMintArg: toAddress(params.collateralMint ?? params.underlyingMint),
     makerCollateralAmount: params.makerCollateralAmount,
     borrowedAmount: params.borrowedAmount,
+    maxRequiredCollateralAmount,
   });
 
   return appendRemainingAccounts(kitInstruction, params.remainingAccounts);
@@ -251,6 +269,7 @@ export interface BuildOptionMintTransactionWithDerivationParams {
   collateralMint?: AddressLike;
   makerCollateralAmount: bigint | number;
   borrowedAmount: bigint | number;
+  maxRequiredCollateralAmount?: bigint | number;
   maker: AddressLike;
   /**
    * Optional. When omitted, the SDK derives the maker's collateral ATA for collateralMint
@@ -268,6 +287,9 @@ export interface BuildOptionMintTransactionWithDerivationParams {
   escrowTokenAccount?: AddressLike;
   poolLoan?: AddressLike;
   remainingAccounts?: RemainingAccountInput[];
+  disableSwitchboardCrank?: boolean;
+  switchboardCrossbarUrl?: string;
+  switchboardNumSignatures?: number;
 }
 
 export async function buildOptionMintTransactionWithDerivation(
@@ -357,9 +379,23 @@ export async function buildOptionMintTransactionWithDerivation(
       makerCollateralAccount
     );
 
-  return {
+  const actionTx = {
     instructions: [createAtaIx, ...tx.instructions],
   };
+
+  if (params.disableSwitchboardCrank) {
+    return actionTx;
+  }
+
+  const crank = await buildSwitchboardCrank({
+    rpc: params.rpc,
+    payer: params.maker,
+    switchboardFeed,
+    marketData: resolved.marketData,
+    crossbarUrl: params.switchboardCrossbarUrl,
+    numSignatures: params.switchboardNumSignatures,
+  });
+  return prependSwitchboardCrank(crank, actionTx);
 }
 
 export async function buildUnwindWriterUnsoldInstruction(
@@ -480,8 +516,12 @@ export async function buildUnwindWriterUnsoldWithLoanRepayment(
   ]);
 
   const vaultLoans = loans
-    .filter((item) => toAddress(item.data.vault) === vaultPdaStr)
-    .slice(0, MAX_POOL_LOANS_PER_UNWIND);
+    .filter((item) => toAddress(item.data.vault) === vaultPdaStr);
+
+  invariant(
+    vaultLoans.length <= MAX_POOL_LOANS_PER_UNWIND,
+    `Too many active pool loans for unwind: ${vaultLoans.length}. Max supported in one unwind is ${MAX_POOL_LOANS_PER_UNWIND}.`
+  );
 
   const remainingAccounts: RemainingAccountInput[] = vaultLoans.map((item) => ({
     address: item.address,
@@ -515,8 +555,8 @@ export async function buildUnwindWriterUnsoldWithLoanRepayment(
       : 0n;
 
   invariant(
-    preflight.canRepayFully,
-    `Unwind cannot fully repay loans: required=${preflight.summary.proportionalTotalOwed} available_now=${preflight.summary.collateralVaultAvailable + preflight.summary.walletFallbackAvailable} native_sol_available=${preflight.summary.nativeSolAvailable} remaining_shortfall=${preflight.summary.proportionalTotalOwed - (preflight.summary.collateralVaultAvailable + preflight.summary.walletFallbackAvailable + preflight.summary.nativeSolAvailable)}`
+    preflight.canRepayRequestedSlice,
+    `Unwind cannot repay the requested slice: required=${preflight.summary.proportionalTotalOwed} available_now=${preflight.summary.collateralVaultAvailable + preflight.summary.walletFallbackAvailable} native_sol_available=${preflight.summary.nativeSolAvailable} remaining_shortfall=${preflight.summary.proportionalTotalOwed - (preflight.summary.collateralVaultAvailable + preflight.summary.walletFallbackAvailable + preflight.summary.nativeSolAvailable)}`
   );
   if (isWsolPath && lamportsToWrap > 0n && !params.includeWrapForShortfall) {
     invariant(