@epicentral/sos-sdk 0.1.1 → 0.2.0

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.1",
+  "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",
@@ -15,6 +15,8 @@
     "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"

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"]