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

package/README.md

@@ -136,10 +136,25 @@ Or pass `addressLookupTableAddresses: [getLookupTableAddressForNetwork("devnet")
 | Function | Description |
 |----------|-------------|
 | `resolveSwitchboardFeedFromMarketData` | Resolves Switchboard feed address from market data account. |
-| `buildSwitchboardPullFeedUpdate` | Builds Switchboard pull-feed update instructions for prepending to trade transactions. |
+| `buildSwitchboardPullFeedUpdate` | Low-level helper that fetches Switchboard pull-feed update instructions. |
+| `buildSwitchboardCrank` | Returns Kit-native crank instructions plus lookup tables for the configured feed. |
+| `prependSwitchboardCrank` | Prepends crank instructions/ALTs to a built SDK transaction. |
+
+Price-sensitive option builders and OMLP deposit/withdraw builders now prepend Switchboard crank instructions by default, so frontends can keep using the same Kit transaction pipeline without managing a separate oracle update step.
 
 See [Frontend Switchboard Integration](../../docs/FRONTEND_SWITCHBOARD_INTEGRATION.md) for full setup and usage.
 
+### Global Trade Config
+
+Use the shared trade config helpers to set SDK-wide defaults for slippage and compute-budget settings:
+
+- `setGlobalTradeConfig`
+- `updateGlobalTradeConfig`
+- `getGlobalTradeConfig`
+- `resetGlobalTradeConfig`
+
+These defaults are used by the high-level builders unless an action-specific override is provided. `option_mint` also forwards a max-collateral bound on-chain so signer delays cannot silently widen required collateral past the configured tolerance.
+
 ## Multi-Collateral Settlement
 
 The SDK supports universal multi-collateral settlement, allowing writers to use ANY supported asset as collateral for options (not just the underlying). This enables:
@@ -215,7 +230,7 @@ When a writer unwinds an unsold short that had borrowed from the OMLP pool, the
 **Collateral Return:**
 - Proportional collateral share = `(collateral_deposited * unwind_qty) / written_qty`
 - Returnable collateral = `proportional_share - amount_already_repaid_from_vault`
-- If vault lacks sufficient post-repayment balance, fails with `InsufficientCollateralVault` (6090)
+- If vault lacks sufficient post-repayment balance, fails with `InsufficientCollateralVault` (6092)
 
 Use **`buildUnwindWriterUnsoldWithLoanRepayment`** so that:
 
@@ -232,7 +247,8 @@ Use **`preflightUnwindWriterUnsold`** before building the transaction to get:
 - Collateral-vault available, wallet fallback required, and shortfall.
 - **Top-up UX fields:** `collateralVaultShortfall`, `needsWalletTopUp`.
 - WSOL repay metadata: `solTopUpRequired`, `topUpRequiredForRepay`, `nativeSolAvailable`.
-- `canRepayFully`, which now reflects effective repay solvency (including native SOL top-up capacity for WSOL paths).
+- `canRepayRequestedSlice`, which reflects solvency for the proportional unwind slice (including native SOL top-up capacity for WSOL paths).
+- Deprecated compatibility field: `canRepayFully` mirrors the slice-based result for older callers.
 
 If there are no active pool loans for that vault, the API still works and passes empty `remaining_accounts`.
 
@@ -333,7 +349,7 @@ The program uses distinct error codes for liquidity failures:
 - `InsufficientPoolAggregateLiquidity` (6042) – `option_pool.total_available < quantity`
 - `InsufficientWriterPositionLiquidity` (6043) – remaining writer-position accounts cannot cover full quantity in the smallest-first fill loop
 
-**Ghost Liquidity:** When `total_available` appears sufficient but active writer positions cannot cover the request. This happens when positions are settled/liquidated but still counted in the aggregate. The SDK now filters inactive positions, and the program skips them in the fill loop.
+`option_pool.total_available` is now treated as writer-backed unsold inventory. `close_long_to_pool` no longer inflates the aggregate counter by re-adding buyer-closed LONGs, which removes the false-liquidity drift behind `InsufficientWriterPositionLiquidity`.
 
 **Recommended client flow:**
   1. Run `preflightBuyFromPoolMarketOrder` for UX gating (checks both pool and active writer liquidity).
@@ -365,7 +381,7 @@ The program uses the **Switchboard pull feed account** you pass in (or that the
 - **Buy:** Premium computation (Black-Scholes).
 - **Close:** Payout computation (mark-to-market). If the price is stale, the close payout will not reflect the current option value; the buyer may receive back only their premium instead of profit.
 
-**You must ensure the Switchboard feed is recently updated** when building buy and close transactions. The SDK does not post oracle updates by default; use the Switchboard helper exports and your update pipeline before trading instructions.
+The SDK now prepends Switchboard crank instructions by default for mint, buy, close, unwind, exercise/settle/liquidate, and OMLP deposit/withdraw builders. Keep feeds configured correctly, but frontends no longer need a separate crank transaction in the standard path.
 
 - **Mainnet:** keep feed updates fresh enough to satisfy the feed's configured `max_staleness`.
 - **Devnet:** ensure your keeper/update pipeline runs before user trade flows; payouts reflect the feed's staleness config.

package/client/lookup-table.ts

@@ -4,7 +4,7 @@ import { PROGRAM_ID } from "./program";
 import type { KitRpc } from "./types";
 
 export const LOOKUP_TABLE_ADDRESSES: Record<"devnet" | "mainnet", Address | null> = {
-  devnet: address("FTLPczoQpTmND126pMiJpnPudsDxfGuCNUQAPk4SUcJd"),
+  devnet: address("CxJn2cyXF8wRr4Cg7GKhSbGS7VW8wAnz3C4uQq537kXr"),
   mainnet: null,
 };
 

package/client/types.ts

@@ -5,4 +5,5 @@ export type KitRpc = Rpc<SolanaRpcApi>;
 
 export interface BuiltTransaction {
   instructions: Instruction<string>[];
+  addressLookupTableAddresses?: AddressLike[];
 }

package/generated/accounts/vault.ts

@@ -111,6 +111,11 @@ export type Vault = {
    * Set by admin, enforced on deposits. 0 = unlimited.
    */
   supplyLimit: bigint;
+  /**
+   * Maximum aggregate borrow cap as a share of total liquidity (basis points).
+   * Example: 9000 = at most 90% of liquidity may be loaned out.
+   */
+  maxBorrowCapBps: number;
   /**
    * Cumulative interest earned per deposited unit (fixed-point)
    * Increases whenever loans are repaid/liquidated
@@ -177,6 +182,11 @@ export type VaultArgs = {
    * Set by admin, enforced on deposits. 0 = unlimited.
    */
   supplyLimit: number | bigint;
+  /**
+   * Maximum aggregate borrow cap as a share of total liquidity (basis points).
+   * Example: 9000 = at most 90% of liquidity may be loaned out.
+   */
+  maxBorrowCapBps: number;
   /**
    * Cumulative interest earned per deposited unit (fixed-point)
    * Increases whenever loans are repaid/liquidated
@@ -208,6 +218,7 @@ export function getVaultEncoder(): FixedSizeEncoder<VaultArgs> {
       ["rateSlope1Bps", getU16Encoder()],
       ["rateSlope2Bps", getU16Encoder()],
       ["supplyLimit", getU64Encoder()],
+      ["maxBorrowCapBps", getU16Encoder()],
       ["accInterestPerShareFp", getU128Encoder()],
       ["lastInterestUpdateSlot", getU64Encoder()],
     ]),
@@ -236,6 +247,7 @@ export function getVaultDecoder(): FixedSizeDecoder<Vault> {
     ["rateSlope1Bps", getU16Decoder()],
     ["rateSlope2Bps", getU16Decoder()],
     ["supplyLimit", getU64Decoder()],
+    ["maxBorrowCapBps", getU16Decoder()],
     ["accInterestPerShareFp", getU128Decoder()],
     ["lastInterestUpdateSlot", getU64Decoder()],
   ]);
@@ -300,5 +312,5 @@ export async function fetchAllMaybeVault(
 }
 
 export function getVaultSize(): number {
-  return 191;
+  return 193;
 }

package/generated/instructions/index.ts

@@ -23,6 +23,7 @@ export * from "./initializeMarketData";
 export * from "./initOptionPool";
 export * from "./liquidateWriterPosition";
 export * from "./omlpCreateVault";
+export * from "./omlpUpdateMaxBorrowCap";
 export * from "./omlpUpdateMaxLeverage";
 export * from "./omlpUpdateProtocolFee";
 export * from "./omlpUpdateSupplyLimit";

package/generated/instructions/omlpCreateVault.ts

@@ -107,6 +107,7 @@ export type OmlpCreateVaultInstruction<
 export type OmlpCreateVaultInstructionData = {
   discriminator: ReadonlyUint8Array;
   liqThresholdBps: number;
+  maxBorrowCapBps: number;
   maxLeverageMultiplier: number;
   baseRateBps: number;
   optimalUtilizationBps: number;
@@ -117,6 +118,7 @@ export type OmlpCreateVaultInstructionData = {
 
 export type OmlpCreateVaultInstructionDataArgs = {
   liqThresholdBps: number;
+  maxBorrowCapBps: number;
   maxLeverageMultiplier: number;
   baseRateBps: number;
   optimalUtilizationBps: number;
@@ -130,6 +132,7 @@ export function getOmlpCreateVaultInstructionDataEncoder(): FixedSizeEncoder<Oml
     getStructEncoder([
       ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
       ["liqThresholdBps", getU16Encoder()],
+      ["maxBorrowCapBps", getU16Encoder()],
       ["maxLeverageMultiplier", getU16Encoder()],
       ["baseRateBps", getU16Encoder()],
       ["optimalUtilizationBps", getU16Encoder()],
@@ -145,6 +148,7 @@ export function getOmlpCreateVaultInstructionDataDecoder(): FixedSizeDecoder<Oml
   return getStructDecoder([
     ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
     ["liqThresholdBps", getU16Decoder()],
+    ["maxBorrowCapBps", getU16Decoder()],
     ["maxLeverageMultiplier", getU16Decoder()],
     ["baseRateBps", getU16Decoder()],
     ["optimalUtilizationBps", getU16Decoder()],
@@ -189,6 +193,7 @@ export type OmlpCreateVaultAsyncInput<
   associatedTokenProgram?: Address<TAccountAssociatedTokenProgram>;
   systemProgram?: Address<TAccountSystemProgram>;
   liqThresholdBps: OmlpCreateVaultInstructionDataArgs["liqThresholdBps"];
+  maxBorrowCapBps: OmlpCreateVaultInstructionDataArgs["maxBorrowCapBps"];
   maxLeverageMultiplier: OmlpCreateVaultInstructionDataArgs["maxLeverageMultiplier"];
   baseRateBps: OmlpCreateVaultInstructionDataArgs["baseRateBps"];
   optimalUtilizationBps: OmlpCreateVaultInstructionDataArgs["optimalUtilizationBps"];
@@ -369,6 +374,7 @@ export type OmlpCreateVaultInput<
   associatedTokenProgram?: Address<TAccountAssociatedTokenProgram>;
   systemProgram?: Address<TAccountSystemProgram>;
   liqThresholdBps: OmlpCreateVaultInstructionDataArgs["liqThresholdBps"];
+  maxBorrowCapBps: OmlpCreateVaultInstructionDataArgs["maxBorrowCapBps"];
   maxLeverageMultiplier: OmlpCreateVaultInstructionDataArgs["maxLeverageMultiplier"];
   baseRateBps: OmlpCreateVaultInstructionDataArgs["baseRateBps"];
   optimalUtilizationBps: OmlpCreateVaultInstructionDataArgs["optimalUtilizationBps"];

package/generated/instructions/omlpUpdateMaxBorrowCap.ts

@@ -0,0 +1,304 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+  combineCodec,
+  fixDecoderSize,
+  fixEncoderSize,
+  getBytesDecoder,
+  getBytesEncoder,
+  getProgramDerivedAddress,
+  getStructDecoder,
+  getStructEncoder,
+  getU16Decoder,
+  getU16Encoder,
+  transformEncoder,
+  type AccountMeta,
+  type AccountSignerMeta,
+  type Address,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
+  type Instruction,
+  type InstructionWithAccounts,
+  type InstructionWithData,
+  type ReadonlyAccount,
+  type ReadonlySignerAccount,
+  type ReadonlyUint8Array,
+  type TransactionSigner,
+  type WritableAccount,
+} from "@solana/kit";
+import { OPTION_PROGRAM_PROGRAM_ADDRESS } from "../programs";
+import { getAccountMetaFactory, type ResolvedAccount } from "../shared";
+
+export const OMLP_UPDATE_MAX_BORROW_CAP_DISCRIMINATOR = new Uint8Array([
+  156, 196, 135, 28, 127, 162, 101, 52,
+]);
+
+export function getOmlpUpdateMaxBorrowCapDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    OMLP_UPDATE_MAX_BORROW_CAP_DISCRIMINATOR,
+  );
+}
+
+export type OmlpUpdateMaxBorrowCapInstruction<
+  TProgram extends string = typeof OPTION_PROGRAM_PROGRAM_ADDRESS,
+  TAccountConfig extends string | AccountMeta<string> = string,
+  TAccountVault extends string | AccountMeta<string> = string,
+  TAccountAdmin extends string | AccountMeta<string> = string,
+  TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+  InstructionWithData<ReadonlyUint8Array> &
+  InstructionWithAccounts<
+    [
+      TAccountConfig extends string
+        ? ReadonlyAccount<TAccountConfig>
+        : TAccountConfig,
+      TAccountVault extends string
+        ? WritableAccount<TAccountVault>
+        : TAccountVault,
+      TAccountAdmin extends string
+        ? ReadonlySignerAccount<TAccountAdmin> &
+            AccountSignerMeta<TAccountAdmin>
+        : TAccountAdmin,
+      ...TRemainingAccounts,
+    ]
+  >;
+
+export type OmlpUpdateMaxBorrowCapInstructionData = {
+  discriminator: ReadonlyUint8Array;
+  newMaxBorrowCapBps: number;
+};
+
+export type OmlpUpdateMaxBorrowCapInstructionDataArgs = {
+  newMaxBorrowCapBps: number;
+};
+
+export function getOmlpUpdateMaxBorrowCapInstructionDataEncoder(): FixedSizeEncoder<OmlpUpdateMaxBorrowCapInstructionDataArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["newMaxBorrowCapBps", getU16Encoder()],
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: OMLP_UPDATE_MAX_BORROW_CAP_DISCRIMINATOR,
+    }),
+  );
+}
+
+export function getOmlpUpdateMaxBorrowCapInstructionDataDecoder(): FixedSizeDecoder<OmlpUpdateMaxBorrowCapInstructionData> {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["newMaxBorrowCapBps", getU16Decoder()],
+  ]);
+}
+
+export function getOmlpUpdateMaxBorrowCapInstructionDataCodec(): FixedSizeCodec<
+  OmlpUpdateMaxBorrowCapInstructionDataArgs,
+  OmlpUpdateMaxBorrowCapInstructionData
+> {
+  return combineCodec(
+    getOmlpUpdateMaxBorrowCapInstructionDataEncoder(),
+    getOmlpUpdateMaxBorrowCapInstructionDataDecoder(),
+  );
+}
+
+export type OmlpUpdateMaxBorrowCapAsyncInput<
+  TAccountConfig extends string = string,
+  TAccountVault extends string = string,
+  TAccountAdmin extends string = string,
+> = {
+  /** Protocol config - stores admin authority */
+  config?: Address<TAccountConfig>;
+  vault: Address<TAccountVault>;
+  /** Admin signer - must match config.admin */
+  admin: TransactionSigner<TAccountAdmin>;
+  newMaxBorrowCapBps: OmlpUpdateMaxBorrowCapInstructionDataArgs["newMaxBorrowCapBps"];
+};
+
+export async function getOmlpUpdateMaxBorrowCapInstructionAsync<
+  TAccountConfig extends string,
+  TAccountVault extends string,
+  TAccountAdmin extends string,
+  TProgramAddress extends Address = typeof OPTION_PROGRAM_PROGRAM_ADDRESS,
+>(
+  input: OmlpUpdateMaxBorrowCapAsyncInput<
+    TAccountConfig,
+    TAccountVault,
+    TAccountAdmin
+  >,
+  config?: { programAddress?: TProgramAddress },
+): Promise<
+  OmlpUpdateMaxBorrowCapInstruction<
+    TProgramAddress,
+    TAccountConfig,
+    TAccountVault,
+    TAccountAdmin
+  >
+> {
+  // Program address.
+  const programAddress =
+    config?.programAddress ?? OPTION_PROGRAM_PROGRAM_ADDRESS;
+
+  // Original accounts.
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    vault: { value: input.vault ?? null, isWritable: true },
+    admin: { value: input.admin ?? null, isWritable: false },
+  };
+  const accounts = originalAccounts as Record<
+    keyof typeof originalAccounts,
+    ResolvedAccount
+  >;
+
+  // Original args.
+  const args = { ...input };
+
+  // Resolve default values.
+  if (!accounts.config.value) {
+    accounts.config.value = await getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        getBytesEncoder().encode(new Uint8Array([99, 111, 110, 102, 105, 103])),
+      ],
+    });
+  }
+
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.config),
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.admin),
+    ],
+    data: getOmlpUpdateMaxBorrowCapInstructionDataEncoder().encode(
+      args as OmlpUpdateMaxBorrowCapInstructionDataArgs,
+    ),
+    programAddress,
+  } as OmlpUpdateMaxBorrowCapInstruction<
+    TProgramAddress,
+    TAccountConfig,
+    TAccountVault,
+    TAccountAdmin
+  >);
+}
+
+export type OmlpUpdateMaxBorrowCapInput<
+  TAccountConfig extends string = string,
+  TAccountVault extends string = string,
+  TAccountAdmin extends string = string,
+> = {
+  /** Protocol config - stores admin authority */
+  config: Address<TAccountConfig>;
+  vault: Address<TAccountVault>;
+  /** Admin signer - must match config.admin */
+  admin: TransactionSigner<TAccountAdmin>;
+  newMaxBorrowCapBps: OmlpUpdateMaxBorrowCapInstructionDataArgs["newMaxBorrowCapBps"];
+};
+
+export function getOmlpUpdateMaxBorrowCapInstruction<
+  TAccountConfig extends string,
+  TAccountVault extends string,
+  TAccountAdmin extends string,
+  TProgramAddress extends Address = typeof OPTION_PROGRAM_PROGRAM_ADDRESS,
+>(
+  input: OmlpUpdateMaxBorrowCapInput<
+    TAccountConfig,
+    TAccountVault,
+    TAccountAdmin
+  >,
+  config?: { programAddress?: TProgramAddress },
+): OmlpUpdateMaxBorrowCapInstruction<
+  TProgramAddress,
+  TAccountConfig,
+  TAccountVault,
+  TAccountAdmin
+> {
+  // Program address.
+  const programAddress =
+    config?.programAddress ?? OPTION_PROGRAM_PROGRAM_ADDRESS;
+
+  // Original accounts.
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    vault: { value: input.vault ?? null, isWritable: true },
+    admin: { value: input.admin ?? null, isWritable: false },
+  };
+  const accounts = originalAccounts as Record<
+    keyof typeof originalAccounts,
+    ResolvedAccount
+  >;
+
+  // Original args.
+  const args = { ...input };
+
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.config),
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.admin),
+    ],
+    data: getOmlpUpdateMaxBorrowCapInstructionDataEncoder().encode(
+      args as OmlpUpdateMaxBorrowCapInstructionDataArgs,
+    ),
+    programAddress,
+  } as OmlpUpdateMaxBorrowCapInstruction<
+    TProgramAddress,
+    TAccountConfig,
+    TAccountVault,
+    TAccountAdmin
+  >);
+}
+
+export type ParsedOmlpUpdateMaxBorrowCapInstruction<
+  TProgram extends string = typeof OPTION_PROGRAM_PROGRAM_ADDRESS,
+  TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+  programAddress: Address<TProgram>;
+  accounts: {
+    /** Protocol config - stores admin authority */
+    config: TAccountMetas[0];
+    vault: TAccountMetas[1];
+    /** Admin signer - must match config.admin */
+    admin: TAccountMetas[2];
+  };
+  data: OmlpUpdateMaxBorrowCapInstructionData;
+};
+
+export function parseOmlpUpdateMaxBorrowCapInstruction<
+  TProgram extends string,
+  TAccountMetas extends readonly AccountMeta[],
+>(
+  instruction: Instruction<TProgram> &
+    InstructionWithAccounts<TAccountMetas> &
+    InstructionWithData<ReadonlyUint8Array>,
+): ParsedOmlpUpdateMaxBorrowCapInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 3) {
+    // TODO: Coded error.
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      vault: getNextAccount(),
+      admin: getNextAccount(),
+    },
+    data: getOmlpUpdateMaxBorrowCapInstructionDataDecoder().decode(
+      instruction.data,
+    ),
+  };
+}

package/generated/instructions/optionMint.ts

@@ -219,6 +219,7 @@ export type OptionMintInstructionData = {
   collateralMint: Address;
   makerCollateralAmount: bigint;
   borrowedAmount: bigint;
+  maxRequiredCollateralAmount: bigint;
 };
 
 export type OptionMintInstructionDataArgs = {
@@ -231,6 +232,7 @@ export type OptionMintInstructionDataArgs = {
   collateralMint: Address;
   makerCollateralAmount: number | bigint;
   borrowedAmount: number | bigint;
+  maxRequiredCollateralAmount: number | bigint;
 };
 
 export function getOptionMintInstructionDataEncoder(): Encoder<OptionMintInstructionDataArgs> {
@@ -249,6 +251,7 @@ export function getOptionMintInstructionDataEncoder(): Encoder<OptionMintInstruc
       ["collateralMint", getAddressEncoder()],
       ["makerCollateralAmount", getU64Encoder()],
       ["borrowedAmount", getU64Encoder()],
+      ["maxRequiredCollateralAmount", getU64Encoder()],
     ]),
     (value) => ({ ...value, discriminator: OPTION_MINT_DISCRIMINATOR }),
   );
@@ -269,6 +272,7 @@ export function getOptionMintInstructionDataDecoder(): Decoder<OptionMintInstruc
     ["collateralMint", getAddressDecoder()],
     ["makerCollateralAmount", getU64Decoder()],
     ["borrowedAmount", getU64Decoder()],
+    ["maxRequiredCollateralAmount", getU64Decoder()],
   ]);
 }
 
@@ -389,6 +393,7 @@ export type OptionMintAsyncInput<
   collateralMintArg: OptionMintInstructionDataArgs["collateralMint"];
   makerCollateralAmount: OptionMintInstructionDataArgs["makerCollateralAmount"];
   borrowedAmount: OptionMintInstructionDataArgs["borrowedAmount"];
+  maxRequiredCollateralAmount: OptionMintInstructionDataArgs["maxRequiredCollateralAmount"];
 };
 
 export async function getOptionMintInstructionAsync<
@@ -973,6 +978,7 @@ export type OptionMintInput<
   collateralMintArg: OptionMintInstructionDataArgs["collateralMint"];
   makerCollateralAmount: OptionMintInstructionDataArgs["makerCollateralAmount"];
   borrowedAmount: OptionMintInstructionDataArgs["borrowedAmount"];
+  maxRequiredCollateralAmount: OptionMintInstructionDataArgs["maxRequiredCollateralAmount"];
 };
 
 export function getOptionMintInstruction<

package/generated/programs/optionProgram.ts

@@ -31,6 +31,7 @@ import {
   type ParsedInitOptionPoolInstruction,
   type ParsedLiquidateWriterPositionInstruction,
   type ParsedOmlpCreateVaultInstruction,
+  type ParsedOmlpUpdateMaxBorrowCapInstruction,
   type ParsedOmlpUpdateMaxLeverageInstruction,
   type ParsedOmlpUpdateProtocolFeeInstruction,
   type ParsedOmlpUpdateSupplyLimitInstruction,
@@ -51,7 +52,7 @@ import {
 } from "../instructions";
 
 export const OPTION_PROGRAM_PROGRAM_ADDRESS =
-  "ASTGCefQVGEQ79ZSC6d2G9oMqmn2dk1onb4N75Bc5djQ" as Address<"ASTGCefQVGEQ79ZSC6d2G9oMqmn2dk1onb4N75Bc5djQ">;
+  "CCigZRDDjYiJCRL3FfkG3LbNYBpYaG6mGRiYGQnct1co" as Address<"CCigZRDDjYiJCRL3FfkG3LbNYBpYaG6mGRiYGQnct1co">;
 
 export enum OptionProgramAccount {
   CollateralPool,
@@ -227,6 +228,7 @@ export enum OptionProgramInstruction {
   InitializeMarketData,
   LiquidateWriterPosition,
   OmlpCreateVault,
+  OmlpUpdateMaxBorrowCap,
   OmlpUpdateMaxLeverage,
   OmlpUpdateProtocolFee,
   OmlpUpdateSupplyLimit,
@@ -437,6 +439,17 @@ export function identifyOptionProgramInstruction(
   ) {
     return OptionProgramInstruction.OmlpCreateVault;
   }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([156, 196, 135, 28, 127, 162, 101, 52]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.OmlpUpdateMaxBorrowCap;
+  }
   if (
     containsBytes(
       data,
@@ -630,7 +643,7 @@ export function identifyOptionProgramInstruction(
 }
 
 export type ParsedOptionProgramInstruction<
-  TProgram extends string = "ASTGCefQVGEQ79ZSC6d2G9oMqmn2dk1onb4N75Bc5djQ",
+  TProgram extends string = "CCigZRDDjYiJCRL3FfkG3LbNYBpYaG6mGRiYGQnct1co",
 > =
   | ({
       instructionType: OptionProgramInstruction.AcceptAdmin;
@@ -683,6 +696,9 @@ export type ParsedOptionProgramInstruction<
   | ({
       instructionType: OptionProgramInstruction.OmlpCreateVault;
     } & ParsedOmlpCreateVaultInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.OmlpUpdateMaxBorrowCap;
+    } & ParsedOmlpUpdateMaxBorrowCapInstruction<TProgram>)
   | ({
       instructionType: OptionProgramInstruction.OmlpUpdateMaxLeverage;
     } & ParsedOmlpUpdateMaxLeverageInstruction<TProgram>)

package/index.ts

@@ -30,11 +30,18 @@ export * from "./short/preflight";
 
 export * from "./omlp/builders";
 export * from "./omlp/service";
+export * from "./shared/trade-config";
 export {
   resolveSwitchboardFeedFromMarketData,
   buildSwitchboardPullFeedUpdate,
+  buildSwitchboardCrank,
+  inferSwitchboardNetwork,
+  prependSwitchboardCrank,
   type SwitchboardPullFeedLike,
   type BuildSwitchboardPullFeedUpdateParams,
+  type BuildSwitchboardCrankParams,
+  type SwitchboardCrankResult,
+  type SwitchboardNetwork,
 } from "./oracle/switchboard";
 
 export {

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.2-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

@@ -25,6 +25,7 @@ import {
   getLookupTableAddressForNetwork,
   type LookupTableNetwork,
 } from "../client/lookup-table";
+import { getGlobalTradeConfig } from "./trade-config";
 
 export interface SendBuiltTransactionParams extends BuiltTransaction {
   rpc: KitRpc;
@@ -56,18 +57,24 @@ 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,
       })
     );
   }

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(

package/short/preflight.ts

@@ -87,6 +87,8 @@ export interface UnwindPreflightSummary {
 
 export interface UnwindPreflightResult {
   canUnwind: boolean;
+  canRepayRequestedSlice: boolean;
+  /** @deprecated Use canRepayRequestedSlice. */
   canRepayFully: boolean;
   reason?: string;
   writerPositionAddress: string;
@@ -145,6 +147,7 @@ export async function preflightUnwindWriterUnsold(
   if (unwindQty <= 0n) {
     return {
       canUnwind: false,
+      canRepayRequestedSlice: false,
       canRepayFully: false,
       reason: "unwindQty must be > 0",
       writerPositionAddress: String(writerPositionAddress),
@@ -178,6 +181,7 @@ export async function preflightUnwindWriterUnsold(
   if (unwindQty > unsoldQty) {
     return {
       canUnwind: false,
+      canRepayRequestedSlice: false,
       canRepayFully: false,
       reason: "unwindQty exceeds writer unsold quantity",
       writerPositionAddress: String(writerPositionAddress),
@@ -211,7 +215,7 @@ export async function preflightUnwindWriterUnsold(
 
   const slotNow = toBigInt(currentSlot);
   const protocolFeeBps = BigInt(vault.protocolFeeBps);
-  const slotsPerYear = 63_072_000n;
+  const slotsPerYear = 78_840_000n;
   const loanBreakdown: Array<UnwindLoanBreakdown> = [];
 
   for (const loan of loans) {
@@ -267,20 +271,20 @@ export async function preflightUnwindWriterUnsold(
 
   // Calculate proportional obligations for partial unwinds
   const writtenQty = toBigInt(writerPosition.writtenQty);
-  const unwindRatio = writtenQty > 0n ? (unwindQty * 1_000_000n) / writtenQty : 0n; // Basis points precision
-  const unwindRatioDecimal = Number(unwindRatio) / 1_000_000; // Convert to decimal
-
-  // Proportional obligations (for partial unwind logic)
   const proportionalPrincipal = writtenQty > 0n ? (totals.principal * unwindQty) / writtenQty : 0n;
   const proportionalInterest = writtenQty > 0n ? (totals.interest * unwindQty) / writtenQty : 0n;
   const proportionalProtocolFees = writtenQty > 0n ? (totals.fees * unwindQty) / writtenQty : 0n;
   const proportionalTotalOwed = proportionalPrincipal + proportionalInterest + proportionalProtocolFees;
 
-  // Collateral return calculation (proportional share minus proportional obligations)
+  // On-chain unwind repays from collateral vault first, then optional wallet fallback.
+  // The collateral share returned to the writer is therefore reduced only by the
+  // amount actually sourced from the collateral vault, not by the entire debt slice.
   const collateralDeposited = toBigInt(writerPosition.collateralDeposited);
   const proportionalCollateralShare = writtenQty > 0n ? (collateralDeposited * unwindQty) / writtenQty : 0n;
-  const returnableCollateral = proportionalCollateralShare > proportionalTotalOwed
-    ? proportionalCollateralShare - proportionalTotalOwed
+  const collateralUsedForRepay =
+    proportionalTotalOwed > collateralVaultAvailable ? collateralVaultAvailable : proportionalTotalOwed;
+  const returnableCollateral = proportionalCollateralShare > collateralUsedForRepay
+    ? proportionalCollateralShare - collateralUsedForRepay
     : 0n;
 
   // Calculate shortfall against proportional obligations
@@ -295,14 +299,13 @@ export async function preflightUnwindWriterUnsold(
   const effectiveShortfall =
     proportionalTotalOwed > effectiveTotalAvailable ? proportionalTotalOwed - effectiveTotalAvailable : 0n;
 
-  // For top-up UX: explicit collateral vault shortfall
-  const collateralVaultShortfall = returnableCollateral > collateralVaultAvailable
-    ? returnableCollateral - collateralVaultAvailable
-    : 0n;
-  const needsWalletTopUp = collateralVaultShortfall > 0n && walletFallbackAvailable < collateralVaultShortfall;
+  // For top-up UX, surface the wallet contribution required after collateral-vault-first repayment.
+  const collateralVaultShortfall = walletFallbackRequired;
+  const needsWalletTopUp = walletFallbackRequired > walletFallbackAvailable;
 
   return {
     canUnwind: true,
+    canRepayRequestedSlice: effectiveShortfall === 0n,
     canRepayFully: effectiveShortfall === 0n,
     reason:
       effectiveShortfall === 0n