@epicentral/sos-sdk 0.9.0-beta

package/long/builders.ts

@@ -0,0 +1,690 @@
+import {
+  getBuyFromPoolInstructionAsync,
+  getCloseLongToPoolInstructionAsync,
+} from "../generated/instructions";
+import type { Instruction } from "@solana/kit";
+import { toAddress } from "../client/program";
+import type { AddressLike, BuiltTransaction, KitRpc } from "../client/types";
+import { resolveOptionAccounts } from "../accounts/resolve-option";
+import {
+  deriveAssociatedTokenAddress,
+  deriveBuyerPositionPda,
+} from "../accounts/pdas";
+import { assertNonNegativeAmount, assertPositiveAmount } from "../shared/amounts";
+import { invariant } from "../shared/errors";
+import {
+  appendRemainingAccounts,
+  type RemainingAccountInput,
+} from "../shared/remaining-accounts";
+import type { OptionType } from "../generated/types";
+import {
+  getCloseAccountInstruction,
+  getCreateAssociatedTokenIdempotentInstructionWithAddress,
+  NATIVE_MINT,
+} from "../wsol/instructions";
+import { fetchMarketDataAccount, fetchOptionPool } from "../accounts/fetchers";
+import {
+  getBuyFromPoolRemainingAccounts,
+  getCloseLongToPoolRemainingAccounts,
+} from "./remaining-accounts";
+import { applySlippageBps } from "./quotes";
+import {
+  buildSwitchboardQuoteInstruction,
+  feedIdBytesToHex,
+  getDefaultSwitchboardQueueAddress,
+  inferSwitchboardNetwork,
+  prependSwitchboardQuote,
+} from "../oracle/switchboard";
+import { fetchWriterPositionsForPool } from "../accounts/list";
+import { getGlobalTradeConfig } from "../shared/trade-config";
+
+export interface BuildBuyFromPoolParams {
+  optionPool: AddressLike;
+  optionAccount: AddressLike;
+  longMint: AddressLike;
+  underlyingMint: AddressLike;
+  marketData: AddressLike;
+  /** Program `switchboard_queue` — use {@link getDefaultSwitchboardQueueAddress} for the cluster. */
+  switchboardQueue: AddressLike;
+  buyer: AddressLike;
+  buyerPaymentAccount: AddressLike;
+  escrowLongAccount: AddressLike;
+  premiumVault: AddressLike;
+  quantity: bigint | number;
+  premiumAmount: bigint | number;
+  buyerPosition?: AddressLike;
+  buyerOptionAccount?: AddressLike;
+  remainingAccounts?: RemainingAccountInput[];
+}
+
+export interface BuildCloseLongToPoolParams {
+  optionPool: AddressLike;
+  optionAccount: AddressLike;
+  collateralPool: AddressLike;
+  underlyingMint: AddressLike;
+  longMint: AddressLike;
+  escrowLongAccount: AddressLike;
+  premiumVault: AddressLike;
+  marketData: AddressLike;
+  switchboardQueue: AddressLike;
+  buyer: AddressLike;
+  buyerLongAccount: AddressLike;
+  buyerPayoutAccount: AddressLike;
+  collateralVault: AddressLike;
+  quantity: bigint | number;
+  minPayoutAmount: bigint | number;
+  buyerPosition?: AddressLike;
+  /**
+   * When true, appends an SPL CloseAccount to close the buyer's LONG token account after close_long_to_pool (reclaim rent).
+   * Set to true only when closing the entire position; for partial closes the LONG ATA still holds remaining tokens.
+   */
+  closeLongTokenAccount?: boolean;
+  /**
+   * When true and underlying is WSOL, appends an SPL CloseAccount to unwrap the payout ATA so the buyer receives native SOL.
+   * Ignored when underlyingMint is not WSOL.
+   */
+  unwrapPayoutSol?: boolean;
+  remainingAccounts?: RemainingAccountInput[];
+}
+
+export async function buildBuyFromPoolInstruction(
+  params: BuildBuyFromPoolParams
+): Promise<Instruction<string>> {
+  assertPositiveAmount(params.quantity, "quantity");
+  assertPositiveAmount(params.premiumAmount, "premiumAmount");
+
+  const kitInstruction = await getBuyFromPoolInstructionAsync({
+    optionPool: toAddress(params.optionPool),
+    optionAccount: toAddress(params.optionAccount),
+    longMint: toAddress(params.longMint),
+    underlyingMint: toAddress(params.underlyingMint),
+    marketData: toAddress(params.marketData),
+    switchboardQueue: toAddress(params.switchboardQueue),
+    buyer: toAddress(params.buyer) as any,
+    buyerPosition: params.buyerPosition ? toAddress(params.buyerPosition) : undefined,
+    buyerOptionAccount: params.buyerOptionAccount
+      ? toAddress(params.buyerOptionAccount)
+      : undefined,
+    buyerPaymentAccount: toAddress(params.buyerPaymentAccount),
+    escrowLongAccount: toAddress(params.escrowLongAccount),
+    premiumVault: toAddress(params.premiumVault),
+    quantity: params.quantity,
+    premiumAmount: params.premiumAmount,
+  });
+
+  return appendRemainingAccounts(kitInstruction, params.remainingAccounts);
+}
+
+/**
+ * Builds a buy-from-pool transaction. The returned transaction may include a
+ * leading create-ATA-idempotent instruction for the buyer's option account so
+ * first-time buyers succeed without a separate setup step.
+ */
+export async function buildBuyFromPoolTransaction(
+  params: BuildBuyFromPoolParams
+): Promise<BuiltTransaction> {
+  const buyerOptionAccountAddress = params.buyerOptionAccount
+    ? toAddress(params.buyerOptionAccount)
+    : await deriveAssociatedTokenAddress(params.buyer, params.longMint);
+
+  const createAtaIx =
+    await getCreateAssociatedTokenIdempotentInstructionWithAddress(
+      params.buyer,
+      params.buyer,
+      params.longMint,
+      buyerOptionAccountAddress
+    );
+
+  const buyFromPoolIx = await buildBuyFromPoolInstruction(params);
+  return { instructions: [createAtaIx, buyFromPoolIx] };
+}
+
+export interface BuildBuyFromPoolTransactionWithDerivationParams {
+  underlyingAsset: AddressLike;
+  optionType: OptionType;
+  strikePrice: number;
+  expirationDate: bigint | number;
+  buyer: AddressLike;
+  buyerPaymentAccount: AddressLike;
+  /** When `disableSwitchboardCrank` is true, optional explicit queue (else devnet/mainnet default). */
+  switchboardQueue?: AddressLike;
+  quantity: bigint | number;
+  premiumAmount: bigint | number;
+  rpc: KitRpc;
+  /** Required unless `disableSwitchboardCrank` — HTTP RPC URL for Switchboard `fetchQuoteIx`. */
+  rpcEndpoint?: string;
+  programId?: AddressLike;
+  buyerPosition?: AddressLike;
+  buyerOptionAccount?: AddressLike;
+  remainingAccounts?: RemainingAccountInput[];
+  /** When false (default), prepends Switchboard quote ix and uses its queue in the program ix. */
+  disableSwitchboardCrank?: boolean;
+  switchboardCrossbarUrl?: string;
+  switchboardNumSignatures?: number;
+  /**
+   * 0-based index of the Switchboard quote ix in the **final** serialized transaction (after the wallet prepends compute-budget ixs).
+   * OPX `sendInstructions` prepends SetComputeUnitLimit + SetComputeUnitPrice by default → **2**.
+   * Use **1** if only SetComputeUnitLimit is prepended (e.g. `omitComputeUnitPriceInstruction`); **0** if no CU prepend.
+   */
+  switchboardQuoteInstructionIndex?: number;
+}
+
+const DEFAULT_MARKET_ORDER_SLIPPAGE_BUFFER_BASE_UNITS = 500_000n;
+
+/**
+ * Bps added to the *cap* for `max_premium_amount` (stacked on user `slippageBps` / buffer paths).
+ * Primary alignment for 6042 is UI `quotedPremiumTotal` (see solana-opx pool buy + Switchboard spot vs UI spot).
+ * This is a small extra cushion for f64/rounding in `option-program` `pool.rs`.
+ */
+const POOL_BUY_MAX_PREMIUM_ONCHAIN_PAD_BPS = 100;
+
+interface MarketOrderBufferLikeParams {
+  slippageBufferBaseUnits?: bigint | number;
+  slippageBufferLamports?: bigint | number;
+}
+
+function normalizeMarketOrderSlippageBuffer(
+  params: MarketOrderBufferLikeParams,
+  underlyingMint: AddressLike
+): bigint {
+  const hasBaseUnits = params.slippageBufferBaseUnits !== undefined;
+  const hasLamports = params.slippageBufferLamports !== undefined;
+
+  invariant(
+    !(hasBaseUnits && hasLamports),
+    "Provide only one of slippageBufferBaseUnits or slippageBufferLamports."
+  );
+
+  if (hasBaseUnits) {
+    assertNonNegativeAmount(params.slippageBufferBaseUnits!, "slippageBufferBaseUnits");
+    return BigInt(params.slippageBufferBaseUnits!);
+  }
+
+  if (hasLamports) {
+    assertNonNegativeAmount(params.slippageBufferLamports!, "slippageBufferLamports");
+    invariant(
+      String(toAddress(underlyingMint)) === String(NATIVE_MINT),
+      "slippageBufferLamports is only supported for SOL/WSOL underlyings. Use slippageBufferBaseUnits for other assets."
+    );
+    return BigInt(params.slippageBufferLamports!);
+  }
+
+  return DEFAULT_MARKET_ORDER_SLIPPAGE_BUFFER_BASE_UNITS;
+}
+
+export async function buildBuyFromPoolTransactionWithDerivation(
+  params: BuildBuyFromPoolTransactionWithDerivationParams
+): Promise<BuiltTransaction> {
+  const resolved = await resolveOptionAccounts({
+    underlyingAsset: params.underlyingAsset,
+    optionType: params.optionType,
+    strikePrice: params.strikePrice,
+    expirationDate: params.expirationDate,
+    programId: params.programId,
+    rpc: params.rpc,
+  });
+
+  invariant(
+    !!resolved.escrowLongAccount &&
+      !!resolved.premiumVault &&
+      !!resolved.underlyingMint,
+    "Option pool must exist; ensure rpc is provided and pool is initialized."
+  );
+
+  const [buyerPosition, buyerOptionAccount] = await Promise.all([
+    params.buyerPosition
+      ? Promise.resolve(params.buyerPosition)
+      : deriveBuyerPositionPda(
+          params.buyer,
+          resolved.optionAccount,
+          params.programId
+        ).then(([addr]) => addr),
+    params.buyerOptionAccount
+      ? Promise.resolve(params.buyerOptionAccount)
+      : deriveAssociatedTokenAddress(params.buyer, resolved.longMint),
+  ]);
+
+  const marketDataAccount = await fetchMarketDataAccount(params.rpc, resolved.marketData);
+  invariant(
+    !!marketDataAccount,
+    "Market data account not found for resolved option market."
+  );
+  const feedIdHex = feedIdBytesToHex(
+    Uint8Array.from(marketDataAccount.switchboardFeedId as unknown as Uint8Array)
+  );
+  const network = await inferSwitchboardNetwork(params.rpc);
+
+  if (params.disableSwitchboardCrank === true) {
+    const switchboardQueue = params.switchboardQueue
+      ? toAddress(params.switchboardQueue)
+      : getDefaultSwitchboardQueueAddress(network);
+    return buildBuyFromPoolTransaction({
+      optionPool: resolved.optionPool,
+      optionAccount: resolved.optionAccount,
+      longMint: resolved.longMint,
+      underlyingMint: resolved.underlyingMint!,
+      marketData: resolved.marketData,
+      switchboardQueue,
+      buyer: params.buyer,
+      buyerPaymentAccount: params.buyerPaymentAccount,
+      escrowLongAccount: resolved.escrowLongAccount!,
+      premiumVault: resolved.premiumVault!,
+      quantity: params.quantity,
+      premiumAmount: params.premiumAmount,
+      buyerPosition,
+      buyerOptionAccount,
+      remainingAccounts: params.remainingAccounts,
+    });
+  }
+
+  invariant(
+    !!params.rpcEndpoint,
+    "rpcEndpoint is required to fetch Switchboard quote instructions (or set disableSwitchboardCrank)."
+  );
+
+  const quote = await buildSwitchboardQuoteInstruction({
+    rpcEndpoint: params.rpcEndpoint,
+    feedIdHex,
+    network,
+    crossbarUrl: params.switchboardCrossbarUrl,
+    numSignatures: params.switchboardNumSignatures,
+    instructionIdx: params.switchboardQuoteInstructionIndex ?? 2,
+  });
+
+  const actionTx = await buildBuyFromPoolTransaction({
+    optionPool: resolved.optionPool,
+    optionAccount: resolved.optionAccount,
+    longMint: resolved.longMint,
+    underlyingMint: resolved.underlyingMint!,
+    marketData: resolved.marketData,
+    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);
+}
+
+export interface BuildBuyFromPoolMarketOrderParams
+  extends Omit<
+      BuildBuyFromPoolTransactionWithDerivationParams,
+      "premiumAmount" | "remainingAccounts"
+    >,
+    MarketOrderBufferLikeParams {
+  quotedPremiumTotal: bigint | number;
+}
+
+/**
+ * High-level market-order buy builder.
+ * Refetches option pool and remaining writer-position accounts right before
+ * build and sets max premium = quotedPremiumTotal + slippage buffer.
+ */
+export async function buildBuyFromPoolMarketOrderTransactionWithDerivation(
+  params: BuildBuyFromPoolMarketOrderParams
+): Promise<BuiltTransaction> {
+  assertPositiveAmount(params.quantity, "quantity");
+  assertPositiveAmount(params.quotedPremiumTotal, "quotedPremiumTotal");
+
+  const resolved = await resolveOptionAccounts({
+    underlyingAsset: params.underlyingAsset,
+    optionType: params.optionType,
+    strikePrice: params.strikePrice,
+    expirationDate: params.expirationDate,
+    programId: params.programId,
+    rpc: params.rpc,
+  });
+
+  const [refetchedPool, remainingAccounts, buyerPosition, buyerOptionAccount] =
+    await Promise.all([
+      fetchOptionPool(params.rpc, resolved.optionPool),
+      getBuyFromPoolRemainingAccounts(params.rpc, resolved.optionPool, params.programId),
+      params.buyerPosition
+        ? Promise.resolve(params.buyerPosition)
+        : deriveBuyerPositionPda(
+            params.buyer,
+            resolved.optionAccount,
+            params.programId
+          ).then(([addr]) => addr),
+      params.buyerOptionAccount
+        ? Promise.resolve(params.buyerOptionAccount)
+        : deriveAssociatedTokenAddress(params.buyer, resolved.longMint),
+    ]);
+
+  invariant(
+    !!refetchedPool,
+    "Option pool must exist; ensure rpc is provided and pool is initialized."
+  );
+
+  // Build-time coverage assertion: verify active writer liquidity >= requested quantity
+  // This catches data staleness between preflight and build
+  const quantity = BigInt(params.quantity);
+  const writerPositions = await fetchWriterPositionsForPool(
+    params.rpc,
+    resolved.optionPool,
+    params.programId
+  );
+  const activeUnsoldTotal = writerPositions
+    .filter((p) => !p.data.isSettled && !p.data.isLiquidated && p.data.unsoldQty > 0n)
+    .reduce((sum, p) => sum + p.data.unsoldQty, 0n);
+
+  invariant(
+    activeUnsoldTotal >= quantity,
+    `Insufficient active writer liquidity: available=${activeUnsoldTotal}, requested=${quantity}. ` +
+    `This may indicate data staleness - please refresh and retry.`
+  );
+
+  const globalTradeConfig = getGlobalTradeConfig();
+  const hasExplicitSlippageBuffer =
+    params.slippageBufferBaseUnits !== undefined ||
+    params.slippageBufferLamports !== undefined;
+  const quotePremium = BigInt(params.quotedPremiumTotal);
+  const onchainPad = (q: bigint) =>
+    (q * BigInt(POOL_BUY_MAX_PREMIUM_ONCHAIN_PAD_BPS)) / 10_000n;
+  const slippageBuffer = hasExplicitSlippageBuffer
+    ? normalizeMarketOrderSlippageBuffer(params, refetchedPool.underlyingMint) +
+        onchainPad(quotePremium)
+    : globalTradeConfig.slippageBps !== undefined
+      ? applySlippageBps(
+          quotePremium,
+          globalTradeConfig.slippageBps + POOL_BUY_MAX_PREMIUM_ONCHAIN_PAD_BPS
+        ) - quotePremium
+      : normalizeMarketOrderSlippageBuffer(params, refetchedPool.underlyingMint) +
+        onchainPad(quotePremium);
+  const maxPremiumAmount = quotePremium + slippageBuffer;
+  assertPositiveAmount(maxPremiumAmount, "maxPremiumAmount");
+
+  const marketDataAccount = await fetchMarketDataAccount(params.rpc, resolved.marketData);
+  invariant(
+    !!marketDataAccount,
+    "Market data account not found for resolved option market."
+  );
+  const feedIdHex = feedIdBytesToHex(
+    Uint8Array.from(marketDataAccount.switchboardFeedId as unknown as Uint8Array)
+  );
+  const network = await inferSwitchboardNetwork(params.rpc);
+
+  if (params.disableSwitchboardCrank === true) {
+    const switchboardQueue = params.switchboardQueue
+      ? toAddress(params.switchboardQueue)
+      : getDefaultSwitchboardQueueAddress(network);
+    return buildBuyFromPoolTransaction({
+      optionPool: resolved.optionPool,
+      optionAccount: resolved.optionAccount,
+      longMint: resolved.longMint,
+      underlyingMint: refetchedPool.underlyingMint,
+      marketData: resolved.marketData,
+      switchboardQueue,
+      buyer: params.buyer,
+      buyerPaymentAccount: params.buyerPaymentAccount,
+      escrowLongAccount: refetchedPool.escrowLongAccount,
+      premiumVault: refetchedPool.premiumVault,
+      quantity: params.quantity,
+      premiumAmount: maxPremiumAmount,
+      buyerPosition,
+      buyerOptionAccount,
+      remainingAccounts,
+    });
+  }
+
+  invariant(
+    !!params.rpcEndpoint,
+    "rpcEndpoint is required to fetch Switchboard quote instructions (or set disableSwitchboardCrank)."
+  );
+
+  const quote = await buildSwitchboardQuoteInstruction({
+    rpcEndpoint: params.rpcEndpoint,
+    feedIdHex,
+    network,
+    crossbarUrl: params.switchboardCrossbarUrl,
+    numSignatures: params.switchboardNumSignatures,
+    instructionIdx: params.switchboardQuoteInstructionIndex ?? 2,
+  });
+
+  const actionTx = await buildBuyFromPoolTransaction({
+    optionPool: resolved.optionPool,
+    optionAccount: resolved.optionAccount,
+    longMint: resolved.longMint,
+    underlyingMint: refetchedPool.underlyingMint,
+    marketData: resolved.marketData,
+    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);
+}
+
+export async function buildCloseLongToPoolInstruction(
+  params: BuildCloseLongToPoolParams
+): Promise<Instruction<string>> {
+  assertPositiveAmount(params.quantity, "quantity");
+  invariant(
+    BigInt(params.minPayoutAmount) >= 0n,
+    "minPayoutAmount must be greater than or equal to zero."
+  );
+
+  const kitInstruction = await getCloseLongToPoolInstructionAsync({
+    optionPool: toAddress(params.optionPool),
+    optionAccount: toAddress(params.optionAccount),
+    collateralPool: toAddress(params.collateralPool),
+    underlyingMint: toAddress(params.underlyingMint),
+    longMint: toAddress(params.longMint),
+    escrowLongAccount: toAddress(params.escrowLongAccount),
+    premiumVault: toAddress(params.premiumVault),
+    marketData: toAddress(params.marketData),
+    switchboardQueue: toAddress(params.switchboardQueue),
+    buyer: toAddress(params.buyer) as any,
+    buyerLongAccount: toAddress(params.buyerLongAccount),
+    buyerPayoutAccount: toAddress(params.buyerPayoutAccount),
+    collateralVault: toAddress(params.collateralVault),
+    buyerPosition: params.buyerPosition ? toAddress(params.buyerPosition) : undefined,
+    quantity: params.quantity,
+    minPayoutAmount: params.minPayoutAmount,
+  });
+
+  return appendRemainingAccounts(kitInstruction, params.remainingAccounts);
+}
+
+export async function buildCloseLongToPoolTransaction(
+  params: BuildCloseLongToPoolParams
+): Promise<BuiltTransaction> {
+  const instruction = await buildCloseLongToPoolInstruction(params);
+  const instructions = [instruction];
+
+  if (params.closeLongTokenAccount === true) {
+    instructions.push(
+      getCloseAccountInstruction(
+        params.buyerLongAccount,
+        params.buyer,
+        params.buyer
+      )
+    );
+  }
+
+  const shouldUnwrapPayout =
+    params.unwrapPayoutSol === true &&
+    toAddress(params.underlyingMint) === toAddress(NATIVE_MINT);
+  if (shouldUnwrapPayout) {
+    instructions.push(
+      getCloseAccountInstruction(
+        params.buyerPayoutAccount,
+        params.buyer,
+        params.buyer
+      )
+    );
+  }
+
+  return { instructions };
+}
+
+export interface BuildCloseLongToPoolTransactionWithDerivationParams {
+  underlyingAsset: AddressLike;
+  optionType: OptionType;
+  strikePrice: number;
+  expirationDate: bigint | number;
+  buyer: AddressLike;
+  buyerLongAccount: AddressLike;
+  buyerPayoutAccount: AddressLike;
+  switchboardQueue?: AddressLike;
+  quantity: bigint | number;
+  minPayoutAmount: bigint | number;
+  rpc: KitRpc;
+  rpcEndpoint?: string;
+  programId?: AddressLike;
+  buyerPosition?: AddressLike;
+  /**
+   * When true (default), appends CloseAccount for the buyer's LONG token account after close_long_to_pool.
+   * Set to false when doing a partial close (LONG ATA still holds remaining tokens).
+   */
+  closeLongTokenAccount?: boolean;
+  /**
+   * When true (default for WSOL underlying), appends CloseAccount to unwrap payout WSOL ATA to native SOL.
+   * Only applies when option underlying is WSOL.
+   */
+  unwrapPayoutSol?: boolean;
+  remainingAccounts?: RemainingAccountInput[];
+  disableSwitchboardCrank?: boolean;
+  switchboardCrossbarUrl?: string;
+  switchboardNumSignatures?: number;
+  /**
+   * 0-based index of the Switchboard quote ix in the **final** tx after the wallet prepends compute-budget ixs.
+   * OPX `sendInstructions` prepends only `SetComputeUnitLimit` before program ixs → default **1** (quote after CU limit).
+   */
+  switchboardQuoteInstructionIndex?: number;
+}
+
+export async function buildCloseLongToPoolTransactionWithDerivation(
+  params: BuildCloseLongToPoolTransactionWithDerivationParams
+): Promise<BuiltTransaction> {
+  const resolved = await resolveOptionAccounts({
+    underlyingAsset: params.underlyingAsset,
+    optionType: params.optionType,
+    strikePrice: params.strikePrice,
+    expirationDate: params.expirationDate,
+    programId: params.programId,
+    rpc: params.rpc,
+  });
+
+  invariant(
+    !!resolved.escrowLongAccount &&
+      !!resolved.premiumVault &&
+      !!resolved.collateralVault &&
+      !!resolved.underlyingMint,
+    "Option pool and collateral pool must exist; ensure rpc is provided and pools are initialized."
+  );
+
+  const buyerPosition = params.buyerPosition
+    ? params.buyerPosition
+    : (await deriveBuyerPositionPda(
+        params.buyer,
+        resolved.optionAccount,
+        params.programId
+      ))[0];
+
+  const isWsolUnderlying =
+    toAddress(resolved.underlyingMint!) === toAddress(NATIVE_MINT);
+  const closeLongTokenAccount =
+    params.closeLongTokenAccount !== false;
+  const unwrapPayoutSol =
+    params.unwrapPayoutSol !== false && isWsolUnderlying;
+
+  // close_long_to_pool requires a complete set of active WriterPositions so the
+  // program can run the strict Hamilton completeness check. Auto-populate if
+  // the caller didn't supply remaining accounts explicitly.
+  const remainingAccounts =
+    params.remainingAccounts ??
+    (await getCloseLongToPoolRemainingAccounts(
+      params.rpc,
+      resolved.optionPool,
+      params.programId
+    ));
+
+  const marketDataAccount = await fetchMarketDataAccount(params.rpc, resolved.marketData);
+  invariant(
+    !!marketDataAccount,
+    "Market data account not found for resolved option market."
+  );
+  const feedIdHex = feedIdBytesToHex(
+    Uint8Array.from(marketDataAccount.switchboardFeedId as unknown as Uint8Array)
+  );
+  const network = await inferSwitchboardNetwork(params.rpc);
+
+  if (params.disableSwitchboardCrank === true) {
+    const switchboardQueue = params.switchboardQueue
+      ? toAddress(params.switchboardQueue)
+      : getDefaultSwitchboardQueueAddress(network);
+    return buildCloseLongToPoolTransaction({
+      optionPool: resolved.optionPool,
+      optionAccount: resolved.optionAccount,
+      collateralPool: resolved.collateralPool,
+      underlyingMint: resolved.underlyingMint!,
+      longMint: resolved.longMint,
+      escrowLongAccount: resolved.escrowLongAccount!,
+      premiumVault: resolved.premiumVault!,
+      marketData: resolved.marketData,
+      switchboardQueue,
+      buyer: params.buyer,
+      buyerLongAccount: params.buyerLongAccount,
+      buyerPayoutAccount: params.buyerPayoutAccount,
+      collateralVault: resolved.collateralVault!,
+      quantity: params.quantity,
+      minPayoutAmount: params.minPayoutAmount,
+      buyerPosition,
+      closeLongTokenAccount,
+      unwrapPayoutSol,
+      remainingAccounts,
+    });
+  }
+
+  invariant(
+    !!params.rpcEndpoint,
+    "rpcEndpoint is required to fetch Switchboard quote instructions (or set disableSwitchboardCrank)."
+  );
+
+  const quote = await buildSwitchboardQuoteInstruction({
+    rpcEndpoint: params.rpcEndpoint,
+    feedIdHex,
+    network,
+    crossbarUrl: params.switchboardCrossbarUrl,
+    numSignatures: params.switchboardNumSignatures,
+    instructionIdx: params.switchboardQuoteInstructionIndex ?? 1,
+  });
+
+  const actionTx = await buildCloseLongToPoolTransaction({
+    optionPool: resolved.optionPool,
+    optionAccount: resolved.optionAccount,
+    collateralPool: resolved.collateralPool,
+    underlyingMint: resolved.underlyingMint!,
+    longMint: resolved.longMint,
+    escrowLongAccount: resolved.escrowLongAccount!,
+    premiumVault: resolved.premiumVault!,
+    marketData: resolved.marketData,
+    switchboardQueue: getDefaultSwitchboardQueueAddress(network),
+    buyer: params.buyer,
+    buyerLongAccount: params.buyerLongAccount,
+    buyerPayoutAccount: params.buyerPayoutAccount,
+    collateralVault: resolved.collateralVault!,
+    quantity: params.quantity,
+    minPayoutAmount: params.minPayoutAmount,
+    buyerPosition,
+    closeLongTokenAccount,
+    unwrapPayoutSol,
+    remainingAccounts,
+  });
+
+  return prependSwitchboardQuote(quote, actionTx);
+}