@epicentral/sos-sdk 0.1.0 → 0.2.0

package/.env.example

@@ -0,0 +1 @@
+NPM_TOKEN=EnterNpmTokenHere

package/README.md

@@ -1,54 +1,50 @@
-# SDK (Frontend-First)
+# @epicentral/sos-sdk
 
-This SDK is organized by feature and wraps the Codama-generated client for the `option_program`.
-It is Kit-native and uses `@solana/kit` types (`Address`, `Instruction`, `Rpc`) across the public API.
-The package entrypoint is `@epicentral/sos-sdk`.
+Solana Option Standard SDK. A frontend-first SDK for native options trading on Solana, built by Epicentral Labs.
+
+Uses `@solana/kit` types (`Address`, `Instruction`, `Rpc`) across the public API.
 
 ## Install
 
 ```bash
-pnpm add @solana/kit decimal.js
+pnpm add @epicentral/sos-sdk @solana/kit decimal.js
 ```
 
-In this repository, the SDK source lives at `epicentral/sos-sdk` and is packaged as
-`@epicentral/sos-sdk`.
-
-## Structure
-
-- `client/` shared program constants and address helpers for the option program.
-- `accounts/` PDA derivation and account fetch helpers.
-- `long/` LONG buy/close/exercise/quote builders.
-- `short/` SHORT mint/unwind/sync/settle plus premium/pool/loan builders.
-- `omlp/` lender deposit/withdraw instruction builders.
-- `shared/` common amount, error, and remaining account helpers.
-- `generated/` Codama-generated client (bundled; do not edit).
+## Overview
 
-## Updating the bundled client
+- **LONG** — Buy from pool, close to pool, exercise options.
+- **SHORT** — Mint options, unwind, sync, settle, claim premium, close option.
+- **Pool** — Deposit, withdraw, borrow, repay liquidity.
+- **OMLP** — Lender deposit and withdraw.
+- **Accounts** — PDA derivation and account fetchers for options, pools, vaults.
 
-The SDK bundles the program client in `generated/`. From the **option-program** repo root:
+Each flow exposes `build*Instruction` for single instruction composition and `build*Transaction` for full-flow `Instruction[]` construction.
 
-1. Regenerate the client: `yarn generate:client`.
-2. Sync into the SDK and copy to the standalone repo: `yarn sync:sdk`.
+## Usage
 
-Or run the full pipeline: `yarn generate:client:with-sdk`. The script copies the client into `epicentral/sos-sdk/generated` and then copies the entire SDK to the standalone repo (default `../sos-sdk`) so you can commit from there. Override the standalone path with `STANDALONE_SDK_PATH=/path/to/sos-sdk yarn sync:sdk`.
+### Build + send (recommended)
 
-## Usage model
-
-Each flow exposes:
-
-- `build*Instruction(params)` for single instruction composition.
-- `build*Transaction(params)` for one-flow `Instruction[]` construction.
-- optional domain services for multi-step flows (no send/confirm).
+```ts
+import {
+  buildBuyFromPoolTransaction,
+  sendBuiltTransaction,
+} from "@epicentral/sos-sdk";
 
-## Core examples
+const built = await buildBuyFromPoolTransaction(params);
+const signature = await sendBuiltTransaction({
+  rpc,
+  rpcSubscriptions,
+  feePayer: walletSigner,
+  instructions: built.instructions,
+});
+```
 
-### Build + send (app-owned)
+### Build + send (manual)
 
 ```ts
 import {
   appendTransactionMessageInstructions,
   createTransactionMessage,
-  getSignatureFromTransaction,
   pipe,
   sendAndConfirmTransactionFactory,
   setTransactionMessageFeePayerSigner,
@@ -71,64 +67,41 @@ const signedTx = await signTransactionMessageWithSigners(txMessage);
 await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(signedTx, {
   commitment: "confirmed",
 });
-
-const signature = getSignatureFromTransaction(signedTx);
 ```
 
-### Build + send (SDK helper)
-
-```ts
-import {
-  buildBuyFromPoolTransaction,
-  sendBuiltTransaction,
-} from "@epicentral/sos-sdk";
-
-const built = await buildBuyFromPoolTransaction(params);
-const signature = await sendBuiltTransaction({
-  rpc,
-  rpcSubscriptions,
-  feePayer: walletSigner,
-  instructions: built.instructions,
-});
-```
-
-### Open LONG / close LONG
+### LONG
 
 ```ts
 import {
   buildBuyFromPoolTransaction,
   buildCloseLongToPoolTransaction,
+  buildOptionExerciseTransaction,
 } from "@epicentral/sos-sdk";
 
+// Open LONG
 const openLong = await buildBuyFromPoolTransaction(openLongParams);
-const closeLong = await buildCloseLongToPoolTransaction(closeLongParams);
-```
-
-### Exercise LONG
 
-```ts
-import { buildOptionExerciseTransaction } from "@epicentral/sos-sdk";
+// Close LONG
+const closeLong = await buildCloseLongToPoolTransaction(closeLongParams);
 
-const exercise = buildOptionExerciseTransaction({
-  optionAccount,
-  positionAccount,
-  marketData,
-  underlyingMint,
-  priceUpdate,
-  buyerPaymentAccount,
-  makerCollateralAccount,
-  escrowState,
-  escrowTokenAccount,
-  escrowAuthority,
-  buyer,
-});
+// Exercise LONG
+const exercise = buildOptionExerciseTransaction({ optionAccount, positionAccount, /* ... */ });
 ```
 
-### Open SHORT (option mint)
+### SHORT
 
 ```ts
-import { buildOptionMintTransaction, OptionType } from "@epicentral/sos-sdk";
+import {
+  buildOptionMintTransaction,
+  buildUnwindWriterUnsoldTransaction,
+  buildSyncWriterPositionTransaction,
+  buildSettleMakerCollateralTransaction,
+  buildClaimPremiumTransaction,
+  buildCloseOptionTransaction,
+} from "@epicentral/sos-sdk";
+import { OptionType } from "@epicentral/sos-sdk";
 
+// Mint (open SHORT)
 const built = await buildOptionMintTransaction({
   optionType: OptionType.Call,
   strikePrice,
@@ -142,53 +115,25 @@ const built = await buildOptionMintTransaction({
   makerCollateralAccount,
   underlyingMint,
 });
-```
-
-### Unwind / Sync / Settle SHORT
-
-```ts
-import {
-  buildSettleMakerCollateralTransaction,
-  buildSyncWriterPositionTransaction,
-  buildUnwindWriterUnsoldTransaction,
-} from "@epicentral/sos-sdk";
 
+// Unwind / Sync / Settle
 const unwind = await buildUnwindWriterUnsoldTransaction(unwindParams);
 const sync = buildSyncWriterPositionTransaction(syncParams);
 const settle = await buildSettleMakerCollateralTransaction(settleParams);
-```
-
-### Claim premium / close option
-
-```ts
-import {
-  buildClaimPremiumTransaction,
-  buildCloseOptionTransaction,
-} from "@epicentral/sos-sdk";
-
-const claim = await buildClaimPremiumTransaction({
-  optionPool,
-  makerPaymentAccount,
-  premiumVault,
-  maker,
-});
 
-const close = buildCloseOptionTransaction({
-  optionAccount,
-  optionMint,
-  makerOptionAccount,
-  maker,
-});
+// Claim premium / close option
+const claim = await buildClaimPremiumTransaction({ optionPool, makerPaymentAccount, premiumVault, maker });
+const close = buildCloseOptionTransaction({ optionAccount, optionMint, makerOptionAccount, maker });
 ```
 
-### Pool liquidity / borrow / repay
+### Pool
 
 ```ts
 import {
-  buildBorrowFromPoolTransaction,
   buildDepositToPoolTransaction,
-  buildRepayPoolLoanTransaction,
   buildWithdrawFromPoolTransaction,
+  buildBorrowFromPoolTransaction,
+  buildRepayPoolLoanTransaction,
 } from "@epicentral/sos-sdk";
 
 const deposit = await buildDepositToPoolTransaction(depositToPoolParams);
@@ -197,12 +142,7 @@ const borrow = await buildBorrowFromPoolTransaction(borrowFromPoolParams);
 const repay = await buildRepayPoolLoanTransaction(repayPoolLoanParams);
 ```
 
-Repayment source behavior:
-
-- `buildRepayPoolLoanTransaction`: principal is repaid from `escrowTokenAccount`; accrued interest + protocol fees are repaid from `makerTokenAccount`.
-- `buildRepayPoolLoanFromCollateralTransaction`: full repayment is sourced from `collateralVault`.
-
-### OMLP deposit/withdraw
+### OMLP
 
 ```ts
 import {
@@ -210,16 +150,23 @@ import {
   buildWithdrawFromPositionTransaction,
 } from "@epicentral/sos-sdk";
 
-const deposit = await buildDepositToPositionTransaction(
-  { vault, lenderTokenAccount, vaultTokenAccount, lender, amount }
-);
-
-const withdraw = await buildWithdrawFromPositionTransaction(
-  { vault, vaultTokenAccount, lenderTokenAccount, lender, amount }
-);
+const deposit = await buildDepositToPositionTransaction({
+  vault,
+  lenderTokenAccount,
+  vaultTokenAccount,
+  lender,
+  amount,
+});
+const withdraw = await buildWithdrawFromPositionTransaction({
+  vault,
+  vaultTokenAccount,
+  lenderTokenAccount,
+  lender,
+  amount,
+});
 ```
 
-### Replace Anchor reads with SDK fetchers
+### Fetch accounts
 
 ```ts
 import { fetchOptionAccount, fetchOptionPool, fetchVault } from "@epicentral/sos-sdk";
@@ -228,12 +175,3 @@ const option = await fetchOptionAccount(rpc, optionAddress);
 const pool = await fetchOptionPool(rpc, optionPoolAddress);
 const vault = await fetchVault(rpc, vaultAddress);
 ```
-
-## Migration notes
-
-- This SDK is the only frontend integration surface for this repository.
-- Legacy `frontend/constants`, `frontend/services`, and `frontend/utils` modules were removed.
-- Replace Anchor `program.account.*` reads with SDK fetchers.
-- Replace Anchor `program.methods.*` writes with SDK builders.
-- App code should own message building, signing, send, and confirmation via `@solana/kit`.
-- `long/service.ts` and `short/service.ts` were removed in favor of direct builder calls.

package/accounts/resolve-option.ts

@@ -0,0 +1,104 @@
+import type { Address } from "@solana/kit";
+import { OptionType } from "../generated/types";
+import { toAddress } from "../client/program";
+import type { AddressLike, KitRpc } from "../client/types";
+import {
+  deriveCollateralPoolPda,
+  deriveLongMintPda,
+  deriveMarketDataPda,
+  deriveMintAuthorityPda,
+  deriveOptionAccountPda,
+  deriveOptionPoolPda,
+  deriveShortMintPda,
+} from "./pdas";
+import { fetchCollateralPool, fetchOptionAccount, fetchOptionPool } from "./fetchers";
+
+export interface ResolveOptionAccountsParams {
+  underlyingAsset: AddressLike;
+  optionType: OptionType;
+  strikePrice: number;
+  expirationDate: bigint | number;
+  programId?: AddressLike;
+  rpc?: KitRpc;
+}
+
+export interface ResolvedOptionAccounts {
+  optionAccount: Address;
+  longMint: Address;
+  shortMint: Address;
+  optionPool: Address;
+  marketData: Address;
+  collateralPool: Address;
+  mintAuthority: Address;
+  underlyingMint?: Address;
+  escrowLongAccount?: Address;
+  premiumVault?: Address;
+  collateralVault?: Address;
+  optionPoolData?: Awaited<ReturnType<typeof fetchOptionPool>>;
+  optionAccountData?: Awaited<ReturnType<typeof fetchOptionAccount>>;
+  collateralPoolData?: Awaited<ReturnType<typeof fetchCollateralPool>>;
+}
+
+/**
+ * Resolves all derived and optionally fetched accounts for an option.
+ * Given option identity (underlyingAsset, optionType, strikePrice, expirationDate),
+ * returns PDAs and, when rpc is provided, fetches OptionPool and CollateralPool
+ * to expose escrowLongAccount, premiumVault, collateralVault, underlyingMint.
+ */
+export async function resolveOptionAccounts(
+  params: ResolveOptionAccountsParams
+): Promise<ResolvedOptionAccounts> {
+  const programId = params.programId;
+
+  const [optionAccount] = await deriveOptionAccountPda({
+    underlyingAsset: params.underlyingAsset,
+    optionType: params.optionType,
+    strikePrice: params.strikePrice,
+    expirationDate: params.expirationDate,
+    programId,
+  });
+
+  const [longMint] = await deriveLongMintPda(optionAccount, programId);
+  const [shortMint] = await deriveShortMintPda(optionAccount, programId);
+  const [optionPool] = await deriveOptionPoolPda(optionAccount, programId);
+  const [marketData] = await deriveMarketDataPda(params.underlyingAsset, programId);
+  const [collateralPool] = await deriveCollateralPoolPda(optionAccount, programId);
+  const [mintAuthority] = await deriveMintAuthorityPda(programId);
+
+  const result: ResolvedOptionAccounts = {
+    optionAccount,
+    longMint,
+    shortMint,
+    optionPool,
+    marketData,
+    collateralPool,
+    mintAuthority,
+  };
+
+  if (params.rpc) {
+    const [optionPoolFetched, optionAccountFetched, collateralPoolFetched] =
+      await Promise.all([
+        fetchOptionPool(params.rpc, optionPool),
+        fetchOptionAccount(params.rpc, optionAccount),
+        fetchCollateralPool(params.rpc, collateralPool),
+      ]);
+
+    if (optionPoolFetched) {
+      result.optionPoolData = optionPoolFetched;
+      result.escrowLongAccount = optionPoolFetched.escrowLongAccount;
+      result.premiumVault = optionPoolFetched.premiumVault;
+      result.underlyingMint = optionPoolFetched.underlyingMint;
+    }
+
+    if (optionAccountFetched) {
+      result.optionAccountData = optionAccountFetched;
+    }
+
+    if (collateralPoolFetched) {
+      result.collateralPoolData = collateralPoolFetched;
+      result.collateralVault = collateralPoolFetched.collateralVault;
+    }
+  }
+
+  return result;
+}

package/index.ts

@@ -6,6 +6,7 @@ export { OptionType } from "./generated/types";
 export * from "./accounts/pdas";
 export * from "./accounts/fetchers";
 export * from "./accounts/list";
+export * from "./accounts/resolve-option";
 
 export * from "./shared/amounts";
 export * from "./shared/errors";

package/long/builders.ts

@@ -4,13 +4,19 @@ 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 { resolveOptionAccounts } from "../accounts/resolve-option";
+import {
+  deriveAssociatedTokenAddress,
+  deriveBuyerPositionPda,
+} from "../accounts/pdas";
 import { assertPositiveAmount } from "../shared/amounts";
 import { invariant } from "../shared/errors";
 import {
   appendRemainingAccounts,
   type RemainingAccountInput,
 } from "../shared/remaining-accounts";
+import type { OptionType } from "../generated/types";
 
 export interface BuildBuyFromPoolParams {
   optionPool: AddressLike;
@@ -86,6 +92,74 @@ export async function buildBuyFromPoolTransaction(
   return { instructions: [instruction] };
 }
 
+export interface BuildBuyFromPoolTransactionWithDerivationParams {
+  underlyingAsset: AddressLike;
+  optionType: OptionType;
+  strikePrice: number;
+  expirationDate: bigint | number;
+  buyer: AddressLike;
+  buyerPaymentAccount: AddressLike;
+  priceUpdate: AddressLike;
+  quantity: bigint | number;
+  premiumAmount: bigint | number;
+  rpc: KitRpc;
+  programId?: AddressLike;
+  buyerPosition?: AddressLike;
+  buyerOptionAccount?: AddressLike;
+  remainingAccounts?: RemainingAccountInput[];
+}
+
+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),
+  ]);
+
+  return buildBuyFromPoolTransaction({
+    optionPool: resolved.optionPool,
+    optionAccount: resolved.optionAccount,
+    longMint: resolved.longMint,
+    underlyingMint: resolved.underlyingMint!,
+    marketData: resolved.marketData,
+    priceUpdate: params.priceUpdate,
+    buyer: params.buyer,
+    buyerPaymentAccount: params.buyerPaymentAccount,
+    escrowLongAccount: resolved.escrowLongAccount!,
+    premiumVault: resolved.premiumVault!,
+    quantity: params.quantity,
+    premiumAmount: params.premiumAmount,
+    buyerPosition,
+    buyerOptionAccount,
+    remainingAccounts: params.remainingAccounts,
+  });
+}
+
 export async function buildCloseLongToPoolInstruction(
   params: BuildCloseLongToPoolParams
 ): Promise<Instruction<string>> {
@@ -124,3 +198,71 @@ export async function buildCloseLongToPoolTransaction(
   const instruction = await buildCloseLongToPoolInstruction(params);
   return { instructions: [instruction] };
 }
+
+export interface BuildCloseLongToPoolTransactionWithDerivationParams {
+  underlyingAsset: AddressLike;
+  optionType: OptionType;
+  strikePrice: number;
+  expirationDate: bigint | number;
+  buyer: AddressLike;
+  buyerLongAccount: AddressLike;
+  buyerPayoutAccount: AddressLike;
+  priceUpdate: AddressLike;
+  quantity: bigint | number;
+  minPayoutAmount: bigint | number;
+  rpc: KitRpc;
+  programId?: AddressLike;
+  buyerPosition?: AddressLike;
+  omlpVault?: AddressLike;
+  remainingAccounts?: RemainingAccountInput[];
+}
+
+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];
+
+  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,
+    priceUpdate: params.priceUpdate,
+    buyer: params.buyer,
+    buyerLongAccount: params.buyerLongAccount,
+    buyerPayoutAccount: params.buyerPayoutAccount,
+    collateralVault: resolved.collateralVault!,
+    quantity: params.quantity,
+    minPayoutAmount: params.minPayoutAmount,
+    buyerPosition,
+    omlpVault: params.omlpVault,
+    remainingAccounts: params.remainingAccounts,
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epicentral/sos-sdk",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "description": "Solana Option Standard SDK. The frontend-first SDK for Native Options Trading on Solana. Created by Epicentral Labs.",
   "type": "module",
@@ -11,12 +11,17 @@
     ".": "./index.ts",
     "./*": "./*"
   },
-  "scripts": {
-    "typecheck": "tsc --project tsconfig.json --noEmit"
+  "devDependencies": {
+    "dotenv-cli": "^8.0.0"
   },
   "dependencies": {
+    "@solana-program/address-lookup-table": "^0.11.0",
+    "@solana-program/compute-budget": "^0.13.0",
     "@solana/kit": "^6.1.0",
     "bs58": "^6.0.0",
     "decimal.js": "^10.4.3"
+  },
+  "scripts": {
+    "typecheck": "tsc --project tsconfig.json --noEmit"
   }
-}
+}

package/shared/transactions.ts

@@ -1,5 +1,6 @@
 import {
   appendTransactionMessageInstructions,
+  compressTransactionMessageUsingAddressLookupTables,
   createTransactionMessage,
   getSignatureFromTransaction,
   pipe,
@@ -7,22 +8,34 @@ import {
   setTransactionMessageFeePayerSigner,
   setTransactionMessageLifetimeUsingBlockhash,
   signTransactionMessageWithSigners,
+  type AddressesByLookupTableAddress,
   type RpcSubscriptions,
   type SolanaRpcSubscriptionsApi,
   type TransactionSigner,
 } from "@solana/kit";
-import type { BuiltTransaction, KitRpc } from "../client/types";
+import { fetchAddressLookupTable } from "@solana-program/address-lookup-table";
+import {
+  getSetComputeUnitLimitInstruction,
+  getSetComputeUnitPriceInstruction,
+} from "@solana-program/compute-budget";
+import type { Instruction } from "@solana/kit";
+import { toAddress } from "../client/program";
+import type { AddressLike, BuiltTransaction, KitRpc } from "../client/types";
 
 export interface SendBuiltTransactionParams extends BuiltTransaction {
   rpc: KitRpc;
   rpcSubscriptions: RpcSubscriptions<SolanaRpcSubscriptionsApi>;
   feePayer: TransactionSigner<string>;
   commitment?: "processed" | "confirmed" | "finalized";
+  computeUnitLimit?: number;
+  computeUnitPriceMicroLamports?: number;
+  addressLookupTableAddresses?: AddressLike[];
 }
 
 /**
  * Sends a built SDK transaction with common Solana Kit defaults.
  * The caller still controls the RPC clients and fee-payer signer.
+ * Supports optional compute budget (limit + priority fee) and ALT compression.
  */
 export async function sendBuiltTransaction(
   params: SendBuiltTransactionParams
@@ -30,13 +43,44 @@ export async function sendBuiltTransaction(
   const commitment = params.commitment ?? "confirmed";
   const { value: latestBlockhash } = await params.rpc.getLatestBlockhash().send();
 
-  const txMessage = pipe(
+  const computeBudgetInstructions: Instruction<string>[] = [];
+  if (params.computeUnitLimit !== undefined) {
+    computeBudgetInstructions.push(
+      getSetComputeUnitLimitInstruction({ units: params.computeUnitLimit })
+    );
+  }
+  if (params.computeUnitPriceMicroLamports !== undefined) {
+    computeBudgetInstructions.push(
+      getSetComputeUnitPriceInstruction({
+        microLamports: params.computeUnitPriceMicroLamports,
+      })
+    );
+  }
+  const allInstructions = [...computeBudgetInstructions, ...params.instructions];
+
+  let txMessage = pipe(
     createTransactionMessage({ version: 0 }),
     (tx) => setTransactionMessageFeePayerSigner(params.feePayer, tx),
     (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
-    (tx) => appendTransactionMessageInstructions(params.instructions, tx)
+    (tx) => appendTransactionMessageInstructions(allInstructions, tx)
   );
 
+  if (
+    params.addressLookupTableAddresses &&
+    params.addressLookupTableAddresses.length > 0
+  ) {
+    const addressesByAddressLookupTable: AddressesByLookupTableAddress = {};
+    for (const altAddress of params.addressLookupTableAddresses) {
+      const resolvedAddress = toAddress(altAddress);
+      const { data } = await fetchAddressLookupTable(params.rpc, resolvedAddress);
+      addressesByAddressLookupTable[resolvedAddress] = data.addresses;
+    }
+    txMessage = compressTransactionMessageUsingAddressLookupTables(
+      txMessage,
+      addressesByAddressLookupTable
+    );
+  }
+
   const signedTx = await signTransactionMessageWithSigners(txMessage);
   const sendAndConfirm = sendAndConfirmTransactionFactory({
     rpc: params.rpc,

package/short/builders.ts

@@ -7,8 +7,14 @@ import {
 } from "../generated";
 import type { Instruction } from "@solana/kit";
 import { toAddress } from "../client/program";
-import type { AddressLike, BuiltTransaction } from "../client/types";
-import { deriveMakerCollateralSharePda, deriveMetadataPda } from "../accounts/pdas";
+import type { AddressLike, BuiltTransaction, KitRpc } from "../client/types";
+import { resolveOptionAccounts } from "../accounts/resolve-option";
+import {
+  deriveAssociatedTokenAddress,
+  deriveMakerCollateralSharePda,
+  deriveMetadataPda,
+  deriveWriterPositionPda,
+} from "../accounts/pdas";
 import { assertNonNegativeAmount, assertPositiveAmount } from "../shared/amounts";
 import { invariant } from "../shared/errors";
 import {
@@ -184,6 +190,99 @@ export async function buildOptionMintTransaction(
   return { instructions: [instruction] };
 }
 
+export interface BuildOptionMintTransactionWithDerivationParams {
+  underlyingAsset: AddressLike;
+  optionType: OptionType;
+  strikePrice: number;
+  expirationDate: bigint | number;
+  quantity: bigint | number;
+  underlyingMint: AddressLike;
+  underlyingSymbol: string;
+  makerCollateralAmount: bigint | number;
+  borrowedAmount: bigint | number;
+  maker: AddressLike;
+  makerCollateralAccount: AddressLike;
+  rpc: KitRpc;
+  programId?: AddressLike;
+  vault?: AddressLike;
+  vaultTokenAccount?: AddressLike;
+  escrowState?: AddressLike;
+  escrowAuthority?: AddressLike;
+  escrowTokenAccount?: AddressLike;
+  poolLoan?: AddressLike;
+  liquidityRouter?: AddressLike;
+  remainingAccounts?: RemainingAccountInput[];
+}
+
+export async function buildOptionMintTransactionWithDerivation(
+  params: BuildOptionMintTransactionWithDerivationParams
+): Promise<BuiltTransaction> {
+  const borrowedAmount = BigInt(params.borrowedAmount);
+  if (borrowedAmount > 0n) {
+    invariant(!!params.vault, "vault is required when borrowedAmount > 0");
+    invariant(
+      !!params.vaultTokenAccount,
+      "vaultTokenAccount is required when borrowedAmount > 0"
+    );
+    invariant(!!params.escrowState, "escrowState is required when borrowedAmount > 0");
+    invariant(
+      !!params.escrowAuthority,
+      "escrowAuthority is required when borrowedAmount > 0"
+    );
+    invariant(
+      !!params.escrowTokenAccount,
+      "escrowTokenAccount is required when borrowedAmount > 0"
+    );
+    invariant(!!params.poolLoan, "poolLoan is required when borrowedAmount > 0");
+  }
+
+  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,
+    "Option pool and collateral pool must exist; ensure rpc is provided and pools are initialized."
+  );
+
+  const underlyingMint = resolved.underlyingMint ?? params.underlyingMint;
+  const [makerLongAccount, makerShortAccount] = await Promise.all([
+    deriveAssociatedTokenAddress(params.maker, resolved.longMint),
+    deriveAssociatedTokenAddress(params.maker, resolved.shortMint),
+  ]);
+
+  return buildOptionMintTransaction({
+    ...params,
+    underlyingAsset: params.underlyingAsset,
+    underlyingMint,
+    optionAccount: resolved.optionAccount,
+    longMint: resolved.longMint,
+    shortMint: resolved.shortMint,
+    mintAuthority: resolved.mintAuthority,
+    makerLongAccount,
+    makerShortAccount,
+    marketData: resolved.marketData,
+    optionPool: resolved.optionPool,
+    escrowLongAccount: resolved.escrowLongAccount,
+    premiumVault: resolved.premiumVault,
+    collateralPool: resolved.collateralPool,
+    collateralVault: resolved.collateralVault,
+    vault: params.vault,
+    vaultTokenAccount: params.vaultTokenAccount,
+    escrowState: params.escrowState,
+    escrowAuthority: params.escrowAuthority,
+    escrowTokenAccount: params.escrowTokenAccount,
+    poolLoan: params.poolLoan,
+    liquidityRouter: params.liquidityRouter,
+    remainingAccounts: params.remainingAccounts,
+  });
+}
+
 export async function buildUnwindWriterUnsoldInstruction(
   params: BuildUnwindWriterUnsoldParams
 ): Promise<Instruction<string>> {
@@ -216,6 +315,63 @@ export async function buildUnwindWriterUnsoldTransaction(
   return { instructions: [instruction] };
 }
 
+export interface BuildUnwindWriterUnsoldTransactionWithDerivationParams {
+  underlyingAsset: AddressLike;
+  optionType: OptionType;
+  strikePrice: number;
+  expirationDate: bigint | number;
+  writer: AddressLike;
+  unwindQty: bigint | number;
+  rpc: KitRpc;
+  programId?: AddressLike;
+  omlpVault?: AddressLike;
+  feeWallet?: AddressLike;
+  remainingAccounts?: RemainingAccountInput[];
+}
+
+export async function buildUnwindWriterUnsoldTransactionWithDerivation(
+  params: BuildUnwindWriterUnsoldTransactionWithDerivationParams
+): 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.collateralVault && !!resolved.underlyingMint,
+    "Option pool and collateral pool must exist; ensure rpc is provided and pools are initialized."
+  );
+
+  const [writerShortAccount, writerCollateralAccount, writerPosition] =
+    await Promise.all([
+      deriveAssociatedTokenAddress(params.writer, resolved.shortMint),
+      deriveAssociatedTokenAddress(params.writer, resolved.underlyingMint),
+      deriveWriterPositionPda(resolved.optionPool, params.writer, params.programId),
+    ]);
+
+  return buildUnwindWriterUnsoldTransaction({
+    optionPool: resolved.optionPool,
+    optionAccount: resolved.optionAccount,
+    longMint: resolved.longMint,
+    shortMint: resolved.shortMint,
+    escrowLongAccount: resolved.escrowLongAccount!,
+    writerShortAccount,
+    collateralVault: resolved.collateralVault!,
+    writerCollateralAccount,
+    writer: params.writer,
+    unwindQty: params.unwindQty,
+    collateralPool: resolved.collateralPool,
+    writerPosition: writerPosition[0],
+    omlpVault: params.omlpVault,
+    feeWallet: params.feeWallet,
+    remainingAccounts: params.remainingAccounts,
+  });
+}
+
 export function buildSyncWriterPositionInstruction(
   params: BuildSyncWriterPositionParams
 ): Instruction<string> {

package/tsconfig.json

@@ -5,7 +5,8 @@
     "moduleResolution": "node",
     "strict": true,
     "declaration": true,
-    "outDir": "dist"
+    "outDir": "dist",
+    "skipLibCheck": true
   },
   "include": ["**/*.ts"],
   "exclude": ["dist", "node_modules"]