@epicentral/sos-sdk 0.11.2-beta → 0.12.1-beta

package/long/builders.ts

@@ -10,7 +10,8 @@ import {
   deriveAssociatedTokenAddress,
   deriveBuyerPositionPda,
 } from "../accounts/pdas";
-import { assertNonNegativeAmount, assertPositiveAmount } from "../shared/amounts";
+import { assertNonNegativeAmount, assertPositiveAmount, getPremiumMint } from "../shared/amounts";
+import { fetchTokenAccountMint } from "../shared/balances";
 import { invariant } from "../shared/errors";
 import {
   appendRemainingAccounts,
@@ -47,6 +48,8 @@ export interface BuildBuyFromPoolParams {
   /** Program `switchboard_queue` — use {@link getDefaultSwitchboardQueueAddress} for the cluster. */
   switchboardQueue: AddressLike;
   buyer: AddressLike;
+  /** Premium payment mint — must match on-chain premium_vault.mint. */
+  paymentMint: AddressLike;
   buyerPaymentAccount: AddressLike;
   escrowLongAccount: AddressLike;
   premiumVault: AddressLike;
@@ -57,6 +60,29 @@ export interface BuildBuyFromPoolParams {
   remainingAccounts?: RemainingAccountInput[];
 }
 
+async function resolveBuyPaymentAccounts(
+  params: {
+    rpc: KitRpc;
+    buyer: AddressLike;
+    premiumVault: AddressLike;
+    underlyingMint: AddressLike;
+    collateralMint?: AddressLike;
+    paymentMint?: AddressLike;
+    buyerPaymentAccount?: AddressLike;
+  }
+): Promise<{ paymentMint: AddressLike; buyerPaymentAccount: AddressLike }> {
+  const onChainPremiumMint = await fetchTokenAccountMint(params.rpc, params.premiumVault);
+  const paymentMint = params.paymentMint ?? onChainPremiumMint;
+  invariant(
+    toAddress(paymentMint) === toAddress(onChainPremiumMint),
+    "paymentMint must match on-chain premium_vault.mint"
+  );
+  const buyerPaymentAccount =
+    params.buyerPaymentAccount ??
+    (await deriveAssociatedTokenAddress(params.buyer, paymentMint));
+  return { paymentMint, buyerPaymentAccount };
+}
+
 export interface BuildCloseLongToPoolParams {
   optionPool: AddressLike;
   optionAccount: AddressLike;
@@ -69,7 +95,11 @@ export interface BuildCloseLongToPoolParams {
   switchboardQueue: AddressLike;
   buyer: AddressLike;
   buyerLongAccount: AddressLike;
+  /** Settlement-mint ATA (collateral pool mint). */
   buyerPayoutAccount: AddressLike;
+  /** Underlying-mint ATA for premium-vault leg (same as buyerPayout when physical). */
+  buyerUnderlyingPayoutAccount: AddressLike;
+  collateralMint?: AddressLike;
   collateralVault: AddressLike;
   quantity: bigint | number;
   minPayoutAmount: bigint | number;
@@ -106,6 +136,7 @@ export async function buildBuyFromPoolInstruction(
       ? toAddress(params.buyerOptionAccount)
       : undefined,
     buyerPaymentAccount: toAddress(params.buyerPaymentAccount),
+    paymentMint: toAddress(params.paymentMint),
     escrowLongAccount: toAddress(params.escrowLongAccount),
     premiumVault: toAddress(params.premiumVault),
     quantity: params.quantity,
@@ -121,13 +152,13 @@ export async function buildBuyFromPoolInstruction(
  * first-time buyers succeed without a separate setup step.
  */
 export async function buildBuyFromPoolTransaction(
-  params: BuildBuyFromPoolParams
+  params: BuildBuyFromPoolParams & { createPaymentAta?: boolean }
 ): Promise<BuiltTransaction> {
   const buyerOptionAccountAddress = params.buyerOptionAccount
     ? toAddress(params.buyerOptionAccount)
     : await deriveAssociatedTokenAddress(params.buyer, params.longMint);
 
-  const createAtaIx =
+  const createLongAtaIx =
     await getCreateAssociatedTokenIdempotentInstructionWithAddress(
       params.buyer,
       params.buyer,
@@ -135,8 +166,22 @@ export async function buildBuyFromPoolTransaction(
       buyerOptionAccountAddress
     );
 
+  const instructions: Instruction<string>[] = [createLongAtaIx];
+
+  if (params.createPaymentAta !== false) {
+    const createPaymentAtaIx =
+      await getCreateAssociatedTokenIdempotentInstructionWithAddress(
+        params.buyer,
+        params.buyer,
+        params.paymentMint,
+        toAddress(params.buyerPaymentAccount)
+      );
+    instructions.push(createPaymentAtaIx);
+  }
+
   const buyFromPoolIx = await buildBuyFromPoolInstruction(params);
-  return { instructions: [createAtaIx, buyFromPoolIx] };
+  instructions.push(buyFromPoolIx);
+  return { instructions };
 }
 
 export interface BuildBuyFromPoolTransactionWithDerivationParams {
@@ -145,7 +190,10 @@ export interface BuildBuyFromPoolTransactionWithDerivationParams {
   strikePrice: number;
   expirationDate: bigint | number;
   buyer: AddressLike;
-  buyerPaymentAccount: AddressLike;
+  /** Optional — derived from on-chain premium_vault.mint when omitted. */
+  buyerPaymentAccount?: AddressLike;
+  /** Optional — derived from on-chain premium_vault.mint when omitted. */
+  paymentMint?: AddressLike;
   /** When `disableSwitchboardCrank` is true, optional explicit queue (else devnet/mainnet default). */
   switchboardQueue?: AddressLike;
   quantity: bigint | number;
@@ -231,7 +279,7 @@ export async function buildBuyFromPoolTransactionWithDerivation(
     "Option pool must exist; ensure rpc is provided and pool is initialized."
   );
 
-  const [buyerPosition, buyerOptionAccount] = await Promise.all([
+  const [buyerPosition, buyerOptionAccount, paymentAccounts] = await Promise.all([
     params.buyerPosition
       ? Promise.resolve(params.buyerPosition)
       : deriveBuyerPositionPda(
@@ -242,8 +290,35 @@ export async function buildBuyFromPoolTransactionWithDerivation(
     params.buyerOptionAccount
       ? Promise.resolve(params.buyerOptionAccount)
       : deriveAssociatedTokenAddress(params.buyer, resolved.longMint),
+    resolveBuyPaymentAccounts({
+      rpc: params.rpc,
+      buyer: params.buyer,
+      premiumVault: resolved.premiumVault!,
+      underlyingMint: resolved.underlyingMint!,
+      collateralMint: resolved.collateralPoolData?.collateralMint,
+      paymentMint: params.paymentMint,
+      buyerPaymentAccount: params.buyerPaymentAccount,
+    }),
   ]);
 
+  const buyParams = {
+    optionPool: resolved.optionPool,
+    optionAccount: resolved.optionAccount,
+    longMint: resolved.longMint,
+    underlyingMint: resolved.underlyingMint!,
+    marketData: resolved.marketData,
+    buyer: params.buyer,
+    paymentMint: paymentAccounts.paymentMint,
+    buyerPaymentAccount: paymentAccounts.buyerPaymentAccount,
+    escrowLongAccount: resolved.escrowLongAccount!,
+    premiumVault: resolved.premiumVault!,
+    quantity: params.quantity,
+    premiumAmount: params.premiumAmount,
+    buyerPosition,
+    buyerOptionAccount,
+    remainingAccounts: params.remainingAccounts,
+  };
+
   const marketDataAccount = await fetchMarketDataAccount(params.rpc, resolved.marketData);
   invariant(
     !!marketDataAccount,
@@ -259,21 +334,8 @@ export async function buildBuyFromPoolTransactionWithDerivation(
       ? toAddress(params.switchboardQueue)
       : getDefaultSwitchboardQueueAddress(network);
     return buildBuyFromPoolTransaction({
-      optionPool: resolved.optionPool,
-      optionAccount: resolved.optionAccount,
-      longMint: resolved.longMint,
-      underlyingMint: resolved.underlyingMint!,
-      marketData: resolved.marketData,
+      ...buyParams,
       switchboardQueue,
-      buyer: params.buyer,
-      buyerPaymentAccount: params.buyerPaymentAccount,
-      escrowLongAccount: resolved.escrowLongAccount!,
-      premiumVault: resolved.premiumVault!,
-      quantity: params.quantity,
-      premiumAmount: params.premiumAmount,
-      buyerPosition,
-      buyerOptionAccount,
-      remainingAccounts: params.remainingAccounts,
     });
   }
 
@@ -292,21 +354,8 @@ export async function buildBuyFromPoolTransactionWithDerivation(
   });
 
   const actionTx = await buildBuyFromPoolTransaction({
-    optionPool: resolved.optionPool,
-    optionAccount: resolved.optionAccount,
-    longMint: resolved.longMint,
-    underlyingMint: resolved.underlyingMint!,
-    marketData: resolved.marketData,
+    ...buyParams,
     switchboardQueue: getDefaultSwitchboardQueueAddress(network),
-    buyer: params.buyer,
-    buyerPaymentAccount: params.buyerPaymentAccount,
-    escrowLongAccount: resolved.escrowLongAccount!,
-    premiumVault: resolved.premiumVault!,
-    quantity: params.quantity,
-    premiumAmount: params.premiumAmount,
-    buyerPosition,
-    buyerOptionAccount,
-    remainingAccounts: params.remainingAccounts,
   });
 
   return prependSwitchboardQuote(quote, actionTx);
@@ -341,7 +390,7 @@ export async function buildBuyFromPoolMarketOrderTransactionWithDerivation(
     rpc: params.rpc,
   });
 
-  const [refetchedPool, remainingAccounts, buyerPosition, buyerOptionAccount] =
+  const [refetchedPool, remainingAccounts, buyerPosition, buyerOptionAccount, paymentAccounts] =
     await Promise.all([
       fetchOptionPool(params.rpc, resolved.optionPool),
       getBuyFromPoolRemainingAccounts(params.rpc, resolved.optionPool, params.programId),
@@ -355,6 +404,15 @@ export async function buildBuyFromPoolMarketOrderTransactionWithDerivation(
       params.buyerOptionAccount
         ? Promise.resolve(params.buyerOptionAccount)
         : deriveAssociatedTokenAddress(params.buyer, resolved.longMint),
+      resolveBuyPaymentAccounts({
+        rpc: params.rpc,
+        buyer: params.buyer,
+        premiumVault: resolved.premiumVault!,
+        underlyingMint: resolved.underlyingMint!,
+        collateralMint: resolved.collateralPoolData?.collateralMint,
+        paymentMint: params.paymentMint,
+        buyerPaymentAccount: params.buyerPaymentAccount,
+      }),
     ]);
 
   invariant(
@@ -388,18 +446,36 @@ export async function buildBuyFromPoolMarketOrderTransactionWithDerivation(
   const onchainPad = (q: bigint) =>
     (q * BigInt(POOL_BUY_MAX_PREMIUM_ONCHAIN_PAD_BPS)) / 10_000n;
   const slippageBuffer = hasExplicitSlippageBuffer
-    ? normalizeMarketOrderSlippageBuffer(params, refetchedPool.underlyingMint) +
+    ? normalizeMarketOrderSlippageBuffer(params, paymentAccounts.paymentMint) +
         onchainPad(quotePremium)
     : globalTradeConfig.slippageBps !== undefined
       ? applySlippageBps(
           quotePremium,
           globalTradeConfig.slippageBps + POOL_BUY_MAX_PREMIUM_ONCHAIN_PAD_BPS
         ) - quotePremium
-      : normalizeMarketOrderSlippageBuffer(params, refetchedPool.underlyingMint) +
+      : normalizeMarketOrderSlippageBuffer(params, paymentAccounts.paymentMint) +
         onchainPad(quotePremium);
   const maxPremiumAmount = quotePremium + slippageBuffer;
   assertPositiveAmount(maxPremiumAmount, "maxPremiumAmount");
 
+  const marketBuyParams = {
+    optionPool: resolved.optionPool,
+    optionAccount: resolved.optionAccount,
+    longMint: resolved.longMint,
+    underlyingMint: refetchedPool.underlyingMint,
+    marketData: resolved.marketData,
+    buyer: params.buyer,
+    paymentMint: paymentAccounts.paymentMint,
+    buyerPaymentAccount: paymentAccounts.buyerPaymentAccount,
+    escrowLongAccount: refetchedPool.escrowLongAccount,
+    premiumVault: refetchedPool.premiumVault,
+    quantity: params.quantity,
+    premiumAmount: maxPremiumAmount,
+    buyerPosition,
+    buyerOptionAccount,
+    remainingAccounts,
+  };
+
   const marketDataAccount = await fetchMarketDataAccount(params.rpc, resolved.marketData);
   invariant(
     !!marketDataAccount,
@@ -415,21 +491,8 @@ export async function buildBuyFromPoolMarketOrderTransactionWithDerivation(
       ? toAddress(params.switchboardQueue)
       : getDefaultSwitchboardQueueAddress(network);
     return buildBuyFromPoolTransaction({
-      optionPool: resolved.optionPool,
-      optionAccount: resolved.optionAccount,
-      longMint: resolved.longMint,
-      underlyingMint: refetchedPool.underlyingMint,
-      marketData: resolved.marketData,
+      ...marketBuyParams,
       switchboardQueue,
-      buyer: params.buyer,
-      buyerPaymentAccount: params.buyerPaymentAccount,
-      escrowLongAccount: refetchedPool.escrowLongAccount,
-      premiumVault: refetchedPool.premiumVault,
-      quantity: params.quantity,
-      premiumAmount: maxPremiumAmount,
-      buyerPosition,
-      buyerOptionAccount,
-      remainingAccounts,
     });
   }
 
@@ -448,21 +511,8 @@ export async function buildBuyFromPoolMarketOrderTransactionWithDerivation(
   });
 
   const actionTx = await buildBuyFromPoolTransaction({
-    optionPool: resolved.optionPool,
-    optionAccount: resolved.optionAccount,
-    longMint: resolved.longMint,
-    underlyingMint: refetchedPool.underlyingMint,
-    marketData: resolved.marketData,
+    ...marketBuyParams,
     switchboardQueue: getDefaultSwitchboardQueueAddress(network),
-    buyer: params.buyer,
-    buyerPaymentAccount: params.buyerPaymentAccount,
-    escrowLongAccount: refetchedPool.escrowLongAccount,
-    premiumVault: refetchedPool.premiumVault,
-    quantity: params.quantity,
-    premiumAmount: maxPremiumAmount,
-    buyerPosition,
-    buyerOptionAccount,
-    remainingAccounts,
   });
 
   return prependSwitchboardQuote(quote, actionTx);
@@ -477,11 +527,14 @@ export async function buildCloseLongToPoolInstruction(
     "minPayoutAmount must be greater than or equal to zero."
   );
 
+  const collateralMint = params.collateralMint ?? params.underlyingMint;
+
   const kitInstruction = await getCloseLongToPoolInstructionAsync({
     optionPool: toAddress(params.optionPool),
     optionAccount: toAddress(params.optionAccount),
     collateralPool: toAddress(params.collateralPool),
     underlyingMint: toAddress(params.underlyingMint),
+    collateralMint: toAddress(collateralMint),
     longMint: toAddress(params.longMint),
     escrowLongAccount: toAddress(params.escrowLongAccount),
     premiumVault: toAddress(params.premiumVault),
@@ -490,6 +543,7 @@ export async function buildCloseLongToPoolInstruction(
     buyer: toAddress(params.buyer) as any,
     buyerLongAccount: toAddress(params.buyerLongAccount),
     buyerPayoutAccount: toAddress(params.buyerPayoutAccount),
+    buyerUnderlyingPayoutAccount: toAddress(params.buyerUnderlyingPayoutAccount),
     collateralVault: toAddress(params.collateralVault),
     buyerPosition: params.buyerPosition ? toAddress(params.buyerPosition) : undefined,
     quantity: params.quantity,
@@ -521,7 +575,7 @@ export async function buildCloseLongToPoolTransaction(
   if (shouldUnwrapPayout) {
     instructions.push(
       getCloseAccountInstruction(
-        params.buyerPayoutAccount,
+        params.buyerUnderlyingPayoutAccount,
         params.buyer,
         params.buyer
       )
@@ -538,7 +592,10 @@ export interface BuildCloseLongToPoolTransactionWithDerivationParams {
   expirationDate: bigint | number;
   buyer: AddressLike;
   buyerLongAccount: AddressLike;
-  buyerPayoutAccount: AddressLike;
+  /** Optional — derived from collateral pool mint when omitted. */
+  buyerPayoutAccount?: AddressLike;
+  /** Optional — derived from underlying mint when omitted. */
+  buyerUnderlyingPayoutAccount?: AddressLike;
   switchboardQueue?: AddressLike;
   quantity: bigint | number;
   minPayoutAmount: bigint | number;
@@ -595,6 +652,17 @@ export async function buildCloseLongToPoolTransactionWithDerivation(
         params.programId
       ))[0];
 
+  const collateralMint =
+    resolved.collateralPoolData?.collateralMint ?? resolved.underlyingMint!;
+  const [buyerPayoutAccount, buyerUnderlyingPayoutAccount] = await Promise.all([
+    params.buyerPayoutAccount
+      ? Promise.resolve(params.buyerPayoutAccount)
+      : deriveAssociatedTokenAddress(params.buyer, collateralMint),
+    params.buyerUnderlyingPayoutAccount
+      ? Promise.resolve(params.buyerUnderlyingPayoutAccount)
+      : deriveAssociatedTokenAddress(params.buyer, resolved.underlyingMint!),
+  ]);
+
   const isWsolUnderlying =
     toAddress(resolved.underlyingMint!) === toAddress(NATIVE_MINT);
   const closeLongTokenAccount =
@@ -632,6 +700,7 @@ export async function buildCloseLongToPoolTransactionWithDerivation(
       optionAccount: resolved.optionAccount,
       collateralPool: resolved.collateralPool,
       underlyingMint: resolved.underlyingMint!,
+      collateralMint,
       longMint: resolved.longMint,
       escrowLongAccount: resolved.escrowLongAccount!,
       premiumVault: resolved.premiumVault!,
@@ -639,7 +708,8 @@ export async function buildCloseLongToPoolTransactionWithDerivation(
       switchboardQueue,
       buyer: params.buyer,
       buyerLongAccount: params.buyerLongAccount,
-      buyerPayoutAccount: params.buyerPayoutAccount,
+      buyerPayoutAccount,
+      buyerUnderlyingPayoutAccount,
       collateralVault: resolved.collateralVault!,
       quantity: params.quantity,
       minPayoutAmount: params.minPayoutAmount,
@@ -669,6 +739,7 @@ export async function buildCloseLongToPoolTransactionWithDerivation(
     optionAccount: resolved.optionAccount,
     collateralPool: resolved.collateralPool,
     underlyingMint: resolved.underlyingMint!,
+    collateralMint,
     longMint: resolved.longMint,
     escrowLongAccount: resolved.escrowLongAccount!,
     premiumVault: resolved.premiumVault!,
@@ -676,7 +747,8 @@ export async function buildCloseLongToPoolTransactionWithDerivation(
     switchboardQueue: getDefaultSwitchboardQueueAddress(network),
     buyer: params.buyer,
     buyerLongAccount: params.buyerLongAccount,
-    buyerPayoutAccount: params.buyerPayoutAccount,
+    buyerPayoutAccount,
+    buyerUnderlyingPayoutAccount,
     collateralVault: resolved.collateralVault!,
     quantity: params.quantity,
     minPayoutAmount: params.minPayoutAmount,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epicentral/sos-sdk",
-  "version": "0.11.2-beta",
+  "version": "0.12.1-beta",
   "private": false,
   "description": "Solana Option Standard SDK. The frontend-first SDK for Native Options Trading on Solana. Created by Epicentral Labs.",
   "type": "module",

package/shared/amounts.ts

@@ -1,4 +1,5 @@
 import Decimal from "decimal.js";
+import type { AddressLike } from "../client/types";
 import { SdkValidationError } from "./errors";
 
 export function toBaseUnits(amount: Decimal.Value, decimals: number): bigint {
@@ -24,30 +25,90 @@ export function assertNonNegativeAmount(value: bigint | number, label: string):
   }
 }
 
+export type SettlementMode = "physical" | "cash";
+
 /**
- * Calculate required collateral for option position in token base units
- * Matches on-chain formula: ((qty / 1_000_000) * 100 * strike) / spot * 10^decimals
- * 
- * @param quantity - Option quantity in base units (1 contract = 1_000_000)
- * @param strikePrice - Strike price in USD
- * @param spotPrice - Current spot price of underlying in USD (from oracle)
- * @param tokenDecimals - Number of decimals for the underlying token (e.g., 9 for SOL)
- * @returns Required collateral in token base units
+ * Calculate required collateral in **collateral mint** base units.
+ * Matches on-chain `Vault::calculate_required_collateral`:
+ * `((qty / 1_000_000) * 100 * strike) / conversionPrice * 10^decimals`.
+ *
+ * - **Physical:** pass underlying oracle spot + underlying/collateral decimals.
+ * - **Cash** (e.g. USDC backing SOL): pass collateral USD price (~1 for stables) + collateral decimals.
  */
 export function calculateRequiredCollateral(
   quantity: bigint | number,
   strikePrice: number,
-  spotPrice: number,
-  tokenDecimals: number
+  conversionPrice: number,
+  tokenDecimals: number,
+  settlementMode: SettlementMode = "physical"
 ): number {
-  // Convert base units to contract count
+  if (conversionPrice <= 0 || !Number.isFinite(conversionPrice)) {
+    return Number.POSITIVE_INFINITY;
+  }
+
   const contracts = Number(quantity) / 1_000_000;
-  const contractSize = 100; // 1 contract = 100 units of underlying
-  
-  // USD value needed for collateral
+  const contractSize = 100;
   const usdRequired = contracts * contractSize * strikePrice;
-  
-  // Convert USD to token base units
   const baseUnits = 10 ** tokenDecimals;
-  return (usdRequired / spotPrice) * baseUnits;
+
+  if (settlementMode === "cash") {
+    return usdRequired * baseUnits;
+  }
+
+  return (usdRequired / conversionPrice) * baseUnits;
+}
+
+/** @deprecated Use `calculateRequiredCollateral` with explicit settlement mode. */
+export function calculateRequiredCollateralLegacy(
+  quantity: bigint | number,
+  strikePrice: number,
+  spotPrice: number,
+  tokenDecimals: number
+): number {
+  return calculateRequiredCollateral(
+    quantity,
+    strikePrice,
+    spotPrice,
+    tokenDecimals,
+    "physical"
+  );
+}
+
+/**
+ * Premium payment mint for a pool: underlying when physical, collateral when cash.
+ * For **existing** pools, prefer on-chain `premium_vault.mint` (legacy cash may differ).
+ */
+export function getPremiumMint(
+  underlyingMint: AddressLike,
+  collateralMint: AddressLike
+): string {
+  const underlying = String(underlyingMint);
+  const collateral = String(collateralMint);
+  return underlying === collateral ? underlying : collateral;
+}
+
+/**
+ * Convert BS premium USD to payment-mint base units.
+ * - **Cash:** `premiumUsd × 10^decimals` (~$1 stable collateral)
+ * - **Physical:** `(premiumUsd / underlyingSpot) × 10^decimals`
+ */
+export function convertPremiumUsdToBaseUnits(
+  premiumUsd: number,
+  settlementMode: SettlementMode,
+  underlyingSpot: number,
+  tokenDecimals: number
+): bigint {
+  if (!Number.isFinite(premiumUsd) || premiumUsd <= 0) {
+    return 0n;
+  }
+  const scale = 10 ** tokenDecimals;
+  if (settlementMode === "cash") {
+    return BigInt(Math.ceil(premiumUsd * scale - Number.EPSILON));
+  }
+  if (!Number.isFinite(underlyingSpot) || underlyingSpot <= 0) {
+    return 0n;
+  }
+  return BigInt(
+    Math.ceil((premiumUsd / underlyingSpot) * scale - Number.EPSILON)
+  );
 }

package/shared/balances.ts

@@ -1,27 +1,62 @@
 import type { Address } from "@solana/kit";
+import { getAddressDecoder } from "@solana/kit";
 import { deriveAssociatedTokenAddress } from "../accounts/pdas";
 import { toAddress } from "../client/program";
 import type { AddressLike, KitRpc } from "../client/types";
 import { NATIVE_MINT } from "../wsol/instructions";
 
-/** SPL Token account data: amount field offset (u64 LE). */
+/** SPL Token account data: mint at offset 0 (32 bytes); amount at offset 64 (u64 LE). */
+const TOKEN_ACCOUNT_MINT_OFFSET = 0;
 const TOKEN_ACCOUNT_AMOUNT_OFFSET = 64;
 
+function decodeTokenAccountData(b64: string): Uint8Array {
+  const binary = atob(b64);
+  const data = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) data[i] = binary.charCodeAt(i);
+  return data;
+}
+
+function decodeTokenAccountMint(data: Uint8Array): Address | null {
+  if (data.length < TOKEN_ACCOUNT_MINT_OFFSET + 32) return null;
+  return getAddressDecoder().decode(
+    data.subarray(TOKEN_ACCOUNT_MINT_OFFSET, TOKEN_ACCOUNT_MINT_OFFSET + 32)
+  );
+}
+
 function decodeTokenAccountAmount(data: Uint8Array): bigint {
   if (data.length < TOKEN_ACCOUNT_AMOUNT_OFFSET + 8) return BigInt(0);
   const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
   return view.getBigUint64(TOKEN_ACCOUNT_AMOUNT_OFFSET, true);
 }
 
-async function fetchTokenAccountBalance(rpc: KitRpc, ata: Address): Promise<bigint> {
+async function fetchTokenAccountData(rpc: KitRpc, ata: Address): Promise<Uint8Array | null> {
   const response = await rpc.getAccountInfo(ata, { encoding: "base64" }).send();
   const accountInfo = response.value;
-  if (!accountInfo) return BigInt(0);
+  if (!accountInfo) return null;
   const [b64] = accountInfo.data;
-  if (!b64) return BigInt(0);
-  const binary = atob(b64);
-  const data = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) data[i] = binary.charCodeAt(i);
+  if (!b64) return null;
+  return decodeTokenAccountData(b64);
+}
+
+/** Read the mint pubkey from an SPL token account address. */
+export async function fetchTokenAccountMint(
+  rpc: KitRpc,
+  tokenAccount: AddressLike
+): Promise<Address> {
+  const data = await fetchTokenAccountData(rpc, toAddress(tokenAccount));
+  if (!data) {
+    throw new Error(`Token account not found: ${String(tokenAccount)}`);
+  }
+  const mint = decodeTokenAccountMint(data);
+  if (!mint) {
+    throw new Error(`Invalid token account data: ${String(tokenAccount)}`);
+  }
+  return mint;
+}
+
+async function fetchTokenAccountBalance(rpc: KitRpc, ata: Address): Promise<bigint> {
+  const data = await fetchTokenAccountData(rpc, ata);
+  if (!data) return BigInt(0);
   return decodeTokenAccountAmount(data);
 }
 

package/short/builders.ts

@@ -666,7 +666,9 @@ export async function buildUnwindWriterUnsoldWithLoanRepayment(
     "underlyingMint is required; ensure rpc is provided and option pool is initialized, or pass underlyingMint."
   );
 
-  const [vaultPda] = await deriveVaultPda(underlyingMint, params.programId);
+  const collateralMint =
+    resolved.collateralPoolData?.collateralMint ?? underlyingMint;
+  const [vaultPda] = await deriveVaultPda(collateralMint, params.programId);
   const vaultPdaStr = toAddress(vaultPda);
 
   const [writerPositionAddress] = await deriveWriterPositionPda(
@@ -733,9 +735,9 @@ export async function buildUnwindWriterUnsoldWithLoanRepayment(
     isWritable: true,
   }));
 
-  const omlpVault = await deriveAssociatedTokenAddress(vaultPda, underlyingMint);
+  const omlpVault = await deriveAssociatedTokenAddress(vaultPda, collateralMint);
   const feeWallet = vault
-    ? await deriveAssociatedTokenAddress(vault.feeWallet, underlyingMint)
+    ? await deriveAssociatedTokenAddress(vault.feeWallet, collateralMint)
     : undefined;
 
   // Theta-hedge model: if proportional debt cannot be covered by
@@ -795,10 +797,14 @@ export async function buildUnwindWriterUnsoldTransactionWithDerivation(
     "Option pool and collateral pool must exist; ensure rpc is provided and pools are initialized."
   );
 
+  const collateralMint =
+    resolved.collateralPoolData?.collateralMint ?? resolved.underlyingMint;
+  invariant(!!collateralMint, "collateral mint is required for unwind.");
+
   const [writerShortAccount, writerCollateralAccount, writerPosition] =
     await Promise.all([
       deriveAssociatedTokenAddress(params.writer, resolved.shortMint),
-      deriveAssociatedTokenAddress(params.writer, resolved.underlyingMint),
+      deriveAssociatedTokenAddress(params.writer, collateralMint),
       deriveWriterPositionPda(resolved.optionPool, params.writer, params.programId),
     ]);
 

package/short/preflight.ts

@@ -6,6 +6,7 @@ import { fetchPoolLoansByMaker } from "../accounts/list";
 import { deriveAssociatedTokenAddress, deriveVaultPda, deriveWriterPositionPda } from "../accounts/pdas";
 import { resolveOptionAccounts } from "../accounts/resolve-option";
 import { invariant } from "../shared/errors";
+import { fetchTokenAccountMint } from "../shared/balances";
 
 const TOKEN_ACCOUNT_AMOUNT_OFFSET = 64;
 const BPS_DENOMINATOR = 10_000n;
@@ -455,12 +456,12 @@ export async function preflightUnwindWriterUnsold(
   const thetaAvailable = computeThetaBalance(writerPosition, optionPoolData.accThetaPerOiFp);
 
   // Theta can only offset debt when premium_vault.mint == omlp_vault.mint.
-  // In OPX, premium_vault.mint == option_pool.underlying_mint (enforced via
-  // `buyer_payment_account.mint == option_pool.underlying_mint`), and the
-  // OMLP vault is derived for the collateral mint. They match when the
-  // collateral pool's collateral_mint equals the option pool's underlying_mint.
+  const premiumVaultMint = await fetchTokenAccountMint(
+    params.rpc,
+    resolved.premiumVault!
+  );
   const premiumMintMatchesCollateralMint =
-    toAddress(optionPoolData.underlyingMint) === toAddress(collateralPoolData.collateralMint);
+    toAddress(premiumVaultMint) === toAddress(collateralPoolData.collateralMint);
 
   const thetaToDebt = premiumMintMatchesCollateralMint
     ? minBigInt(thetaAvailable, proportionalTotalOwed)