@epicentral/sos-sdk 0.2.4 → 0.2.6

package/accounts/fetchers.ts

@@ -129,3 +129,41 @@ export async function fetchManyAccounts(
     exists: infos[index] !== null,
   }));
 }
+
+const optionDecoder = getOptionAccountDecoder();
+
+/**
+ * Batch-fetches option accounts via getMultipleAccounts (one RPC round-trip).
+ * Returns a Map from address to OptionAccount or null if missing/invalid.
+ */
+export async function fetchOptionAccounts(
+  rpc: KitRpc,
+  addresses: AddressLike[]
+): Promise<Map<Address, OptionAccount | null>> {
+  if (addresses.length === 0) return new Map();
+  const keys = addresses.map((value) => toAddress(value));
+  const response = await rpc.getMultipleAccounts(keys, { encoding: "base64" }).send();
+  const infos = response.value;
+  const result = new Map<Address, OptionAccount | null>();
+  for (let i = 0; i < keys.length; i++) {
+    const accountInfo = infos[i];
+    if (!accountInfo) {
+      result.set(keys[i], null);
+      continue;
+    }
+    const [b64] = accountInfo.data;
+    if (!b64) {
+      result.set(keys[i], null);
+      continue;
+    }
+    const binary = atob(b64);
+    const data = new Uint8Array(binary.length);
+    for (let j = 0; j < binary.length; j++) data[j] = binary.charCodeAt(j);
+    try {
+      result.set(keys[i], optionDecoder.decode(data));
+    } catch {
+      result.set(keys[i], null);
+    }
+  }
+  return result;
+}

package/accounts/list.ts

@@ -7,10 +7,15 @@ import {
   VAULT_DISCRIMINATOR,
   WRITER_POSITION_DISCRIMINATOR,
   getOptionPoolDecoder,
+  getOptionPoolSize,
   getPoolLoanDecoder,
+  getPoolLoanSize,
   getPositionAccountDecoder,
+  getPositionAccountSize,
   getVaultDecoder,
+  getVaultSize,
   getWriterPositionDecoder,
+  getWriterPositionSize,
   type OptionPool,
   type PoolLoan,
   type PositionAccount,
@@ -32,7 +37,7 @@ type ListedAccount<T> = {
 type ProgramAccountResponse = {
   pubkey: Address;
   account: {
-    data: [string, string];
+    data: [string, string] | string;
   };
 };
 
@@ -80,7 +85,8 @@ async function fetchAndDecodeProgramAccounts<T>(
     : (response as { value: Array<ProgramAccountResponse> }).value;
 
   return rawAccounts.map(({ pubkey, account }) => {
-    const [base64Data] = account.data;
+    const base64Data =
+      Array.isArray(account.data) ? account.data[0] : account.data;
     return {
       address: pubkey,
       data: decoder.decode(decodeBase64Data(base64Data)),
@@ -95,6 +101,7 @@ export async function fetchWriterPositionsByWriter(
   return fetchAndDecodeProgramAccounts(rpc, getWriterPositionDecoder(), [
     discriminatorFilter(WRITER_POSITION_DISCRIMINATOR),
     ownerFilter(writer),
+    { dataSize: BigInt(getWriterPositionSize()) },
   ]);
 }
 
@@ -105,6 +112,7 @@ export async function fetchPositionAccountsByBuyer(
   return fetchAndDecodeProgramAccounts(rpc, getPositionAccountDecoder(), [
     discriminatorFilter(POSITION_ACCOUNT_DISCRIMINATOR),
     ownerFilter(buyer),
+    { dataSize: BigInt(getPositionAccountSize()) },
   ]);
 }
 
@@ -115,6 +123,7 @@ export async function fetchPoolLoansByMaker(
   const decoded = await fetchAndDecodeProgramAccounts(rpc, getPoolLoanDecoder(), [
     discriminatorFilter(POOL_LOAN_DISCRIMINATOR),
     ownerFilter(maker),
+    { dataSize: BigInt(getPoolLoanSize()) },
   ]);
   return decoded.filter(
     (item: { address: Address; data: PoolLoan }) =>
@@ -127,6 +136,7 @@ export async function fetchAllOptionPools(
 ): Promise<Array<ListedAccount<OptionPool>>> {
   return fetchAndDecodeProgramAccounts(rpc, getOptionPoolDecoder(), [
     discriminatorFilter(OPTION_POOL_DISCRIMINATOR),
+    { dataSize: BigInt(getOptionPoolSize()) },
   ]);
 }
 
@@ -135,5 +145,6 @@ export async function fetchAllVaults(
 ): Promise<Array<ListedAccount<Vault>>> {
   return fetchAndDecodeProgramAccounts(rpc, getVaultDecoder(), [
     discriminatorFilter(VAULT_DISCRIMINATOR),
+    { dataSize: BigInt(getVaultSize()) },
   ]);
 }

package/index.ts

@@ -9,6 +9,7 @@ export * from "./accounts/list";
 export * from "./accounts/resolve-option";
 
 export * from "./shared/amounts";
+export * from "./shared/balances";
 export * from "./shared/errors";
 export * from "./shared/remaining-accounts";
 export * from "./shared/transactions";

package/long/exercise.ts

@@ -18,6 +18,10 @@ export interface BuildOptionExerciseParams {
   tokenProgram?: AddressLike;
 }
 
+/**
+ * Legacy escrow-based option exercise. Prefer pool flows: close_long_to_pool and auto_exercise_expired.
+ * @deprecated Use buildCloseLongToPoolTransaction for closing longs and rely on auto_exercise_expired for expiration.
+ */
 export function buildOptionExerciseInstruction(
   params: BuildOptionExerciseParams
 ): Instruction<string> {
@@ -38,8 +42,9 @@ export function buildOptionExerciseInstruction(
 }
 
 /**
- * Builds an option exercise transaction instruction set.
- * Use `priceUpdate` from a fresh Pyth receiver update for accurate exercise pricing.
+ * Builds an option exercise transaction (escrow/ask-based flow).
+ * Prefer pool-based flows: buildCloseLongToPoolTransaction for closing longs and auto_exercise_expired for expired ITM.
+ * @deprecated Use buildCloseLongToPoolTransaction and auto_exercise_expired; do not use for new flows.
  */
 export function buildOptionExerciseTransaction(
   params: BuildOptionExerciseParams

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epicentral/sos-sdk",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "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/balances.ts

@@ -0,0 +1,57 @@
+import type { Address } 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). */
+const TOKEN_ACCOUNT_AMOUNT_OFFSET = 64;
+
+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> {
+  const response = await rpc.getAccountInfo(ata, { encoding: "base64" }).send();
+  const accountInfo = response.value;
+  if (!accountInfo) return BigInt(0);
+  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);
+  return decodeTokenAccountAmount(data);
+}
+
+/**
+ * Returns the SPL token balance for an owner and mint in base units (smallest units).
+ * Derives the associated token account; returns 0n if the ATA does not exist or has no data.
+ */
+export async function getTokenBalance(
+  owner: AddressLike,
+  mint: AddressLike,
+  rpc: KitRpc
+): Promise<bigint> {
+  const ata = await deriveAssociatedTokenAddress(owner, mint);
+  return fetchTokenAccountBalance(rpc, ata);
+}
+
+/**
+ * Returns native SOL balance (lamports), wrapped SOL (WSOL) balance (base units), and total (native + wrapped).
+ * Use for SOL pools when the UI should show combined "total SOL".
+ */
+export async function getCombinedSOLBalance(
+  owner: AddressLike,
+  rpc: KitRpc
+): Promise<{ native: bigint; wrapped: bigint; total: bigint }> {
+  const ownerAddress = toAddress(owner);
+  const [nativeResponse, wrappedBalance] = await Promise.all([
+    rpc.getBalance(ownerAddress).send(),
+    getTokenBalance(ownerAddress, NATIVE_MINT, rpc),
+  ]);
+  const native = nativeResponse.value;
+  const total = native + wrappedBalance;
+  return { native, wrapped: wrappedBalance, total };
+}

package/short/claim-premium.ts

@@ -1,37 +0,0 @@
-import { getClaimPremiumInstructionAsync } from "../generated/instructions";
-import type { Instruction } from "@solana/kit";
-import { toAddress } from "../client/program";
-import type { AddressLike, BuiltTransaction } from "../client/types";
-
-export interface BuildClaimPremiumParams {
-  optionPool: AddressLike;
-  makerPaymentAccount: AddressLike;
-  premiumVault: AddressLike;
-  maker: AddressLike;
-  makerPoolShare?: AddressLike;
-  tokenProgram?: AddressLike;
-}
-
-export async function buildClaimPremiumInstruction(
-  params: BuildClaimPremiumParams
-): Promise<Instruction<string>> {
-  return getClaimPremiumInstructionAsync({
-    optionPool: toAddress(params.optionPool),
-    makerPoolShare: params.makerPoolShare ? toAddress(params.makerPoolShare) : undefined,
-    makerPaymentAccount: toAddress(params.makerPaymentAccount),
-    premiumVault: toAddress(params.premiumVault),
-    maker: toAddress(params.maker) as any,
-    tokenProgram: params.tokenProgram ? toAddress(params.tokenProgram) : undefined,
-  });
-}
-
-/**
- * Builds a premium claim transaction for a maker's pool share.
- * `makerPoolShare` is optional and can be derived by the generated instruction helper.
- */
-export async function buildClaimPremiumTransaction(
-  params: BuildClaimPremiumParams
-): Promise<BuiltTransaction> {
-  const instruction = await buildClaimPremiumInstruction(params);
-  return { instructions: [instruction] };
-}