@epicentral/sos-sdk 0.2.0 → 0.2.1

package/accounts/fetchers.ts

@@ -1,7 +1,6 @@
 import {
   getCollateralPoolDecoder,
   getLenderPositionDecoder,
-  getMakerPoolShareDecoder,
   getMarketDataAccountDecoder,
   getOptionAccountDecoder,
   getOptionPoolDecoder,
@@ -11,7 +10,6 @@ import {
   getWriterPositionDecoder,
   type CollateralPool,
   type LenderPosition,
-  type MakerPoolShare,
   type MarketDataAccount,
   type OptionAccount,
   type OptionPool,
@@ -104,13 +102,6 @@ export async function fetchMarketDataAccount(
   return decodeAccount(rpc, marketData, getMarketDataAccountDecoder());
 }
 
-export async function fetchMakerPoolShare(
-  rpc: KitRpc,
-  makerPoolShare: AddressLike
-): Promise<MakerPoolShare | null> {
-  return decodeAccount(rpc, makerPoolShare, getMakerPoolShareDecoder());
-}
-
 export async function fetchPoolLoan(
   rpc: KitRpc,
   poolLoan: AddressLike

package/accounts/list.ts

@@ -1,19 +1,16 @@
 import bs58 from "bs58";
 import type { Address } from "@solana/kit";
 import {
-  MAKER_POOL_SHARE_DISCRIMINATOR,
   OPTION_POOL_DISCRIMINATOR,
   POOL_LOAN_DISCRIMINATOR,
   POSITION_ACCOUNT_DISCRIMINATOR,
   VAULT_DISCRIMINATOR,
   WRITER_POSITION_DISCRIMINATOR,
-  getMakerPoolShareDecoder,
   getOptionPoolDecoder,
   getPoolLoanDecoder,
   getPositionAccountDecoder,
   getVaultDecoder,
   getWriterPositionDecoder,
-  type MakerPoolShare,
   type OptionPool,
   type PoolLoan,
   type PositionAccount,
@@ -91,16 +88,6 @@ async function fetchAndDecodeProgramAccounts<T>(
   });
 }
 
-export async function fetchMakerPoolSharesByMaker(
-  rpc: KitRpc,
-  maker: AddressLike
-): Promise<Array<ListedAccount<MakerPoolShare>>> {
-  return fetchAndDecodeProgramAccounts(rpc, getMakerPoolShareDecoder(), [
-    discriminatorFilter(MAKER_POOL_SHARE_DISCRIMINATOR),
-    ownerFilter(maker),
-  ]);
-}
-
 export async function fetchWriterPositionsByWriter(
   rpc: KitRpc,
   writer: AddressLike

package/accounts/pdas.ts

@@ -159,22 +159,6 @@ export async function deriveMakerCollateralSharePda(
   });
 }
 
-export async function deriveMakerPoolSharePda(
-  optionPool: AddressLike,
-  maker: AddressLike,
-  programId: AddressLike = PROGRAM_ID
-): Promise<readonly [Address, number]> {
-  const addressEncoder = getAddressEncoder();
-  return getProgramDerivedAddress({
-    programAddress: toAddress(programId),
-    seeds: [
-      new TextEncoder().encode("maker_pool_share"),
-      addressEncoder.encode(toAddress(optionPool)),
-      addressEncoder.encode(toAddress(maker)),
-    ],
-  });
-}
-
 export async function deriveBuyerPositionPda(
   buyer: AddressLike,
   optionAccount: AddressLike,

package/generated/accounts/index.ts

@@ -13,7 +13,6 @@ export * from "./escrowState";
 export * from "./lenderPosition";
 export * from "./liquidityRouter";
 export * from "./makerCollateralShare";
-export * from "./makerPoolShare";
 export * from "./marketDataAccount";
 export * from "./optionAccount";
 export * from "./optionPool";

package/generated/accounts/optionPool.ts

@@ -79,6 +79,7 @@ export type OptionPool = {
   totalOpenInterestQty: bigint;
   accClosedPerOiFp: bigint;
   accPayoutPerOiFp: bigint;
+  accThetaPerOiFp: bigint;
   makerCount: number;
   createdAt: bigint;
   lastUpdated: bigint;
@@ -109,6 +110,7 @@ export type OptionPoolArgs = {
   totalOpenInterestQty: number | bigint;
   accClosedPerOiFp: number | bigint;
   accPayoutPerOiFp: number | bigint;
+  accThetaPerOiFp: number | bigint;
   makerCount: number;
   createdAt: number | bigint;
   lastUpdated: number | bigint;
@@ -143,6 +145,7 @@ export function getOptionPoolEncoder(): FixedSizeEncoder<OptionPoolArgs> {
       ["totalOpenInterestQty", getU64Encoder()],
       ["accClosedPerOiFp", getU128Encoder()],
       ["accPayoutPerOiFp", getU128Encoder()],
+      ["accThetaPerOiFp", getU128Encoder()],
       ["makerCount", getU32Encoder()],
       ["createdAt", getI64Encoder()],
       ["lastUpdated", getI64Encoder()],
@@ -179,6 +182,7 @@ export function getOptionPoolDecoder(): FixedSizeDecoder<OptionPool> {
     ["totalOpenInterestQty", getU64Decoder()],
     ["accClosedPerOiFp", getU128Decoder()],
     ["accPayoutPerOiFp", getU128Decoder()],
+    ["accThetaPerOiFp", getU128Decoder()],
     ["makerCount", getU32Decoder()],
     ["createdAt", getI64Decoder()],
     ["lastUpdated", getI64Decoder()],
@@ -249,5 +253,5 @@ export async function fetchAllMaybeOptionPool(
 }
 
 export function getOptionPoolSize(): number {
-  return 366;
+  return 382;
 }

package/generated/accounts/writerPosition.ts

@@ -77,10 +77,12 @@ export type WriterPosition = {
   borrowedPrincipal: bigint;
   /** Number of active PoolLoan accounts for this writer */
   activeLoanCount: number;
-  /** Total premium earned from sales */
-  premiumEarned: bigint;
-  /** Premium already claimed/withdrawn */
-  premiumClaimed: bigint;
+  /** Theta (time-decay) allocated to this writer (from pool accumulator) */
+  thetaEarned: bigint;
+  /** Theta already claimed/withdrawn */
+  thetaClaimed: bigint;
+  /** Snapshot of pool's acc_theta_per_oi_fp at last claim (reward-debt pattern) */
+  lastPoolAccThetaFp: bigint;
   /** Snapshot of pool's acc_closed_per_oi_fp at last sync */
   lastPoolAccClosedFp: bigint;
   /** Snapshot of pool's acc_payout_per_oi_fp at last sync */
@@ -127,10 +129,12 @@ export type WriterPositionArgs = {
   borrowedPrincipal: number | bigint;
   /** Number of active PoolLoan accounts for this writer */
   activeLoanCount: number;
-  /** Total premium earned from sales */
-  premiumEarned: number | bigint;
-  /** Premium already claimed/withdrawn */
-  premiumClaimed: number | bigint;
+  /** Theta (time-decay) allocated to this writer (from pool accumulator) */
+  thetaEarned: number | bigint;
+  /** Theta already claimed/withdrawn */
+  thetaClaimed: number | bigint;
+  /** Snapshot of pool's acc_theta_per_oi_fp at last claim (reward-debt pattern) */
+  lastPoolAccThetaFp: number | bigint;
   /** Snapshot of pool's acc_closed_per_oi_fp at last sync */
   lastPoolAccClosedFp: number | bigint;
   /** Snapshot of pool's acc_payout_per_oi_fp at last sync */
@@ -171,8 +175,9 @@ export function getWriterPositionEncoder(): FixedSizeEncoder<WriterPositionArgs>
       ["collateralDeposited", getU64Encoder()],
       ["borrowedPrincipal", getU64Encoder()],
       ["activeLoanCount", getU8Encoder()],
-      ["premiumEarned", getU64Encoder()],
-      ["premiumClaimed", getU64Encoder()],
+      ["thetaEarned", getU64Encoder()],
+      ["thetaClaimed", getU64Encoder()],
+      ["lastPoolAccThetaFp", getU128Encoder()],
       ["lastPoolAccClosedFp", getU128Encoder()],
       ["lastPoolAccPayoutFp", getU128Encoder()],
       ["closedQtyDebtFp", getU128Encoder()],
@@ -205,8 +210,9 @@ export function getWriterPositionDecoder(): FixedSizeDecoder<WriterPosition> {
     ["collateralDeposited", getU64Decoder()],
     ["borrowedPrincipal", getU64Decoder()],
     ["activeLoanCount", getU8Decoder()],
-    ["premiumEarned", getU64Decoder()],
-    ["premiumClaimed", getU64Decoder()],
+    ["thetaEarned", getU64Decoder()],
+    ["thetaClaimed", getU64Decoder()],
+    ["lastPoolAccThetaFp", getU128Decoder()],
     ["lastPoolAccClosedFp", getU128Decoder()],
     ["lastPoolAccPayoutFp", getU128Decoder()],
     ["closedQtyDebtFp", getU128Decoder()],
@@ -293,5 +299,5 @@ export async function fetchAllMaybeWriterPosition(
 }
 
 export function getWriterPositionSize(): number {
-  return 284;
+  return 300;
 }

package/generated/instructions/claimTheta.ts

@@ -0,0 +1,375 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+  combineCodec,
+  fixDecoderSize,
+  fixEncoderSize,
+  getAddressEncoder,
+  getBytesDecoder,
+  getBytesEncoder,
+  getProgramDerivedAddress,
+  getStructDecoder,
+  getStructEncoder,
+  transformEncoder,
+  type AccountMeta,
+  type AccountSignerMeta,
+  type Address,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
+  type Instruction,
+  type InstructionWithAccounts,
+  type InstructionWithData,
+  type ReadonlyAccount,
+  type ReadonlyUint8Array,
+  type TransactionSigner,
+  type WritableAccount,
+  type WritableSignerAccount,
+} from "@solana/kit";
+import { OPTION_PROGRAM_PROGRAM_ADDRESS } from "../programs";
+import {
+  expectAddress,
+  getAccountMetaFactory,
+  type ResolvedAccount,
+} from "../shared";
+
+export const CLAIM_THETA_DISCRIMINATOR = new Uint8Array([
+  151, 147, 69, 241, 135, 166, 23, 62,
+]);
+
+export function getClaimThetaDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(CLAIM_THETA_DISCRIMINATOR);
+}
+
+export type ClaimThetaInstruction<
+  TProgram extends string = typeof OPTION_PROGRAM_PROGRAM_ADDRESS,
+  TAccountOptionPool extends string | AccountMeta<string> = string,
+  TAccountWriterPosition extends string | AccountMeta<string> = string,
+  TAccountWriterPaymentAccount extends string | AccountMeta<string> = string,
+  TAccountPremiumVault extends string | AccountMeta<string> = string,
+  TAccountWriter extends string | AccountMeta<string> = string,
+  TAccountTokenProgram extends string | AccountMeta<string> =
+    "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+  TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+  InstructionWithData<ReadonlyUint8Array> &
+  InstructionWithAccounts<
+    [
+      TAccountOptionPool extends string
+        ? WritableAccount<TAccountOptionPool>
+        : TAccountOptionPool,
+      TAccountWriterPosition extends string
+        ? WritableAccount<TAccountWriterPosition>
+        : TAccountWriterPosition,
+      TAccountWriterPaymentAccount extends string
+        ? WritableAccount<TAccountWriterPaymentAccount>
+        : TAccountWriterPaymentAccount,
+      TAccountPremiumVault extends string
+        ? WritableAccount<TAccountPremiumVault>
+        : TAccountPremiumVault,
+      TAccountWriter extends string
+        ? WritableSignerAccount<TAccountWriter> &
+            AccountSignerMeta<TAccountWriter>
+        : TAccountWriter,
+      TAccountTokenProgram extends string
+        ? ReadonlyAccount<TAccountTokenProgram>
+        : TAccountTokenProgram,
+      ...TRemainingAccounts,
+    ]
+  >;
+
+export type ClaimThetaInstructionData = { discriminator: ReadonlyUint8Array };
+
+export type ClaimThetaInstructionDataArgs = {};
+
+export function getClaimThetaInstructionDataEncoder(): FixedSizeEncoder<ClaimThetaInstructionDataArgs> {
+  return transformEncoder(
+    getStructEncoder([["discriminator", fixEncoderSize(getBytesEncoder(), 8)]]),
+    (value) => ({ ...value, discriminator: CLAIM_THETA_DISCRIMINATOR }),
+  );
+}
+
+export function getClaimThetaInstructionDataDecoder(): FixedSizeDecoder<ClaimThetaInstructionData> {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+  ]);
+}
+
+export function getClaimThetaInstructionDataCodec(): FixedSizeCodec<
+  ClaimThetaInstructionDataArgs,
+  ClaimThetaInstructionData
+> {
+  return combineCodec(
+    getClaimThetaInstructionDataEncoder(),
+    getClaimThetaInstructionDataDecoder(),
+  );
+}
+
+export type ClaimThetaAsyncInput<
+  TAccountOptionPool extends string = string,
+  TAccountWriterPosition extends string = string,
+  TAccountWriterPaymentAccount extends string = string,
+  TAccountPremiumVault extends string = string,
+  TAccountWriter extends string = string,
+  TAccountTokenProgram extends string = string,
+> = {
+  /** The pool */
+  optionPool: Address<TAccountOptionPool>;
+  /** Writer's position account */
+  writerPosition?: Address<TAccountWriterPosition>;
+  /** Writer's account to receive theta (in underlying asset) */
+  writerPaymentAccount: Address<TAccountWriterPaymentAccount>;
+  /** Pool's premium vault (source of theta) */
+  premiumVault: Address<TAccountPremiumVault>;
+  writer: TransactionSigner<TAccountWriter>;
+  tokenProgram?: Address<TAccountTokenProgram>;
+};
+
+export async function getClaimThetaInstructionAsync<
+  TAccountOptionPool extends string,
+  TAccountWriterPosition extends string,
+  TAccountWriterPaymentAccount extends string,
+  TAccountPremiumVault extends string,
+  TAccountWriter extends string,
+  TAccountTokenProgram extends string,
+  TProgramAddress extends Address = typeof OPTION_PROGRAM_PROGRAM_ADDRESS,
+>(
+  input: ClaimThetaAsyncInput<
+    TAccountOptionPool,
+    TAccountWriterPosition,
+    TAccountWriterPaymentAccount,
+    TAccountPremiumVault,
+    TAccountWriter,
+    TAccountTokenProgram
+  >,
+  config?: { programAddress?: TProgramAddress },
+): Promise<
+  ClaimThetaInstruction<
+    TProgramAddress,
+    TAccountOptionPool,
+    TAccountWriterPosition,
+    TAccountWriterPaymentAccount,
+    TAccountPremiumVault,
+    TAccountWriter,
+    TAccountTokenProgram
+  >
+> {
+  // Program address.
+  const programAddress =
+    config?.programAddress ?? OPTION_PROGRAM_PROGRAM_ADDRESS;
+
+  // Original accounts.
+  const originalAccounts = {
+    optionPool: { value: input.optionPool ?? null, isWritable: true },
+    writerPosition: { value: input.writerPosition ?? null, isWritable: true },
+    writerPaymentAccount: {
+      value: input.writerPaymentAccount ?? null,
+      isWritable: true,
+    },
+    premiumVault: { value: input.premiumVault ?? null, isWritable: true },
+    writer: { value: input.writer ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+  };
+  const accounts = originalAccounts as Record<
+    keyof typeof originalAccounts,
+    ResolvedAccount
+  >;
+
+  // Resolve default values.
+  if (!accounts.writerPosition.value) {
+    accounts.writerPosition.value = await getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        getBytesEncoder().encode(
+          new Uint8Array([
+            119, 114, 105, 116, 101, 114, 95, 112, 111, 115, 105, 116, 105, 111,
+            110,
+          ]),
+        ),
+        getAddressEncoder().encode(expectAddress(accounts.optionPool.value)),
+        getAddressEncoder().encode(expectAddress(accounts.writer.value)),
+      ],
+    });
+  }
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value =
+      "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">;
+  }
+
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.optionPool),
+      getAccountMeta(accounts.writerPosition),
+      getAccountMeta(accounts.writerPaymentAccount),
+      getAccountMeta(accounts.premiumVault),
+      getAccountMeta(accounts.writer),
+      getAccountMeta(accounts.tokenProgram),
+    ],
+    data: getClaimThetaInstructionDataEncoder().encode({}),
+    programAddress,
+  } as ClaimThetaInstruction<
+    TProgramAddress,
+    TAccountOptionPool,
+    TAccountWriterPosition,
+    TAccountWriterPaymentAccount,
+    TAccountPremiumVault,
+    TAccountWriter,
+    TAccountTokenProgram
+  >);
+}
+
+export type ClaimThetaInput<
+  TAccountOptionPool extends string = string,
+  TAccountWriterPosition extends string = string,
+  TAccountWriterPaymentAccount extends string = string,
+  TAccountPremiumVault extends string = string,
+  TAccountWriter extends string = string,
+  TAccountTokenProgram extends string = string,
+> = {
+  /** The pool */
+  optionPool: Address<TAccountOptionPool>;
+  /** Writer's position account */
+  writerPosition: Address<TAccountWriterPosition>;
+  /** Writer's account to receive theta (in underlying asset) */
+  writerPaymentAccount: Address<TAccountWriterPaymentAccount>;
+  /** Pool's premium vault (source of theta) */
+  premiumVault: Address<TAccountPremiumVault>;
+  writer: TransactionSigner<TAccountWriter>;
+  tokenProgram?: Address<TAccountTokenProgram>;
+};
+
+export function getClaimThetaInstruction<
+  TAccountOptionPool extends string,
+  TAccountWriterPosition extends string,
+  TAccountWriterPaymentAccount extends string,
+  TAccountPremiumVault extends string,
+  TAccountWriter extends string,
+  TAccountTokenProgram extends string,
+  TProgramAddress extends Address = typeof OPTION_PROGRAM_PROGRAM_ADDRESS,
+>(
+  input: ClaimThetaInput<
+    TAccountOptionPool,
+    TAccountWriterPosition,
+    TAccountWriterPaymentAccount,
+    TAccountPremiumVault,
+    TAccountWriter,
+    TAccountTokenProgram
+  >,
+  config?: { programAddress?: TProgramAddress },
+): ClaimThetaInstruction<
+  TProgramAddress,
+  TAccountOptionPool,
+  TAccountWriterPosition,
+  TAccountWriterPaymentAccount,
+  TAccountPremiumVault,
+  TAccountWriter,
+  TAccountTokenProgram
+> {
+  // Program address.
+  const programAddress =
+    config?.programAddress ?? OPTION_PROGRAM_PROGRAM_ADDRESS;
+
+  // Original accounts.
+  const originalAccounts = {
+    optionPool: { value: input.optionPool ?? null, isWritable: true },
+    writerPosition: { value: input.writerPosition ?? null, isWritable: true },
+    writerPaymentAccount: {
+      value: input.writerPaymentAccount ?? null,
+      isWritable: true,
+    },
+    premiumVault: { value: input.premiumVault ?? null, isWritable: true },
+    writer: { value: input.writer ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+  };
+  const accounts = originalAccounts as Record<
+    keyof typeof originalAccounts,
+    ResolvedAccount
+  >;
+
+  // Resolve default values.
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value =
+      "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">;
+  }
+
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.optionPool),
+      getAccountMeta(accounts.writerPosition),
+      getAccountMeta(accounts.writerPaymentAccount),
+      getAccountMeta(accounts.premiumVault),
+      getAccountMeta(accounts.writer),
+      getAccountMeta(accounts.tokenProgram),
+    ],
+    data: getClaimThetaInstructionDataEncoder().encode({}),
+    programAddress,
+  } as ClaimThetaInstruction<
+    TProgramAddress,
+    TAccountOptionPool,
+    TAccountWriterPosition,
+    TAccountWriterPaymentAccount,
+    TAccountPremiumVault,
+    TAccountWriter,
+    TAccountTokenProgram
+  >);
+}
+
+export type ParsedClaimThetaInstruction<
+  TProgram extends string = typeof OPTION_PROGRAM_PROGRAM_ADDRESS,
+  TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+  programAddress: Address<TProgram>;
+  accounts: {
+    /** The pool */
+    optionPool: TAccountMetas[0];
+    /** Writer's position account */
+    writerPosition: TAccountMetas[1];
+    /** Writer's account to receive theta (in underlying asset) */
+    writerPaymentAccount: TAccountMetas[2];
+    /** Pool's premium vault (source of theta) */
+    premiumVault: TAccountMetas[3];
+    writer: TAccountMetas[4];
+    tokenProgram: TAccountMetas[5];
+  };
+  data: ClaimThetaInstructionData;
+};
+
+export function parseClaimThetaInstruction<
+  TProgram extends string,
+  TAccountMetas extends readonly AccountMeta[],
+>(
+  instruction: Instruction<TProgram> &
+    InstructionWithAccounts<TAccountMetas> &
+    InstructionWithData<ReadonlyUint8Array>,
+): ParsedClaimThetaInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 6) {
+    // TODO: Coded error.
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      optionPool: getNextAccount(),
+      writerPosition: getNextAccount(),
+      writerPaymentAccount: getNextAccount(),
+      premiumVault: getNextAccount(),
+      writer: getNextAccount(),
+      tokenProgram: getNextAccount(),
+    },
+    data: getClaimThetaInstructionDataDecoder().decode(instruction.data),
+  };
+}

package/generated/instructions/index.ts

@@ -11,13 +11,12 @@ export * from "./autoExerciseAllExpired";
 export * from "./autoExerciseExpired";
 export * from "./borrowFromPool";
 export * from "./buyFromPool";
-export * from "./claimPremium";
+export * from "./claimTheta";
 export * from "./closeLongToPool";
 export * from "./closeOption";
 export * from "./createEscrowV2";
 export * from "./createLiquidityRouter";
 export * from "./depositCollateral";
-export * from "./depositToPool";
 export * from "./depositToPosition";
 export * from "./initCollateralPool";
 export * from "./initConfig";
@@ -40,6 +39,5 @@ export * from "./transferAdmin";
 export * from "./unwindWriterUnsold";
 export * from "./updateImpliedVolatility";
 export * from "./updateMarketData";
-export * from "./withdrawFromPool";
 export * from "./withdrawFromPosition";
 export * from "./writeToPool";

package/generated/programs/optionProgram.ts

@@ -7,25 +7,62 @@
  */
 
 import {
+  assertIsInstructionWithAccounts,
   containsBytes,
   fixEncoderSize,
   getBytesEncoder,
   type Address,
+  type Instruction,
+  type InstructionWithData,
   type ReadonlyUint8Array,
 } from "@solana/kit";
 import {
+  parseAcceptAdminInstruction,
+  parseAutoExerciseAllExpiredInstruction,
+  parseAutoExerciseExpiredInstruction,
+  parseBorrowFromPoolInstruction,
+  parseBuyFromPoolInstruction,
+  parseClaimThetaInstruction,
+  parseCloseLongToPoolInstruction,
+  parseCloseOptionInstruction,
+  parseCreateEscrowV2Instruction,
+  parseCreateLiquidityRouterInstruction,
+  parseDepositCollateralInstruction,
+  parseDepositToPositionInstruction,
+  parseInitCollateralPoolInstruction,
+  parseInitConfigInstruction,
+  parseInitializeMarketDataInstruction,
+  parseInitOptionPoolInstruction,
+  parseLiquidateWriterPositionInstruction,
+  parseOmlpCreateVaultInstruction,
+  parseOmlpTakeOfferWithFailoverInstruction,
+  parseOmlpUpdateMaxLeverageInstruction,
+  parseOmlpUpdateProtocolFeeInstruction,
+  parseOmlpUpdateSupplyLimitInstruction,
+  parseOptionExerciseInstruction,
+  parseOptionMintInstruction,
+  parseOptionValidateInstruction,
+  parseRepayPoolLoanFromCollateralInstruction,
+  parseRepayPoolLoanInstruction,
+  parseSettleMakerCollateralInstruction,
+  parseSyncWriterPositionInstruction,
+  parseTransferAdminInstruction,
+  parseUnwindWriterUnsoldInstruction,
+  parseUpdateImpliedVolatilityInstruction,
+  parseUpdateMarketDataInstruction,
+  parseWithdrawFromPositionInstruction,
+  parseWriteToPoolInstruction,
   type ParsedAcceptAdminInstruction,
   type ParsedAutoExerciseAllExpiredInstruction,
   type ParsedAutoExerciseExpiredInstruction,
   type ParsedBorrowFromPoolInstruction,
   type ParsedBuyFromPoolInstruction,
-  type ParsedClaimPremiumInstruction,
+  type ParsedClaimThetaInstruction,
   type ParsedCloseLongToPoolInstruction,
   type ParsedCloseOptionInstruction,
   type ParsedCreateEscrowV2Instruction,
   type ParsedCreateLiquidityRouterInstruction,
   type ParsedDepositCollateralInstruction,
-  type ParsedDepositToPoolInstruction,
   type ParsedDepositToPositionInstruction,
   type ParsedInitCollateralPoolInstruction,
   type ParsedInitConfigInstruction,
@@ -48,7 +85,6 @@ import {
   type ParsedUnwindWriterUnsoldInstruction,
   type ParsedUpdateImpliedVolatilityInstruction,
   type ParsedUpdateMarketDataInstruction,
-  type ParsedWithdrawFromPoolInstruction,
   type ParsedWithdrawFromPositionInstruction,
   type ParsedWriteToPoolInstruction,
 } from "../instructions";
@@ -64,7 +100,6 @@ export enum OptionProgramAccount {
   LenderPosition,
   LiquidityRouter,
   MakerCollateralShare,
-  MakerPoolShare,
   MarketDataAccount,
   OptionAccount,
   OptionPool,
@@ -156,17 +191,6 @@ export function identifyOptionProgramAccount(
   ) {
     return OptionProgramAccount.MakerCollateralShare;
   }
-  if (
-    containsBytes(
-      data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(
-        new Uint8Array([171, 211, 240, 11, 182, 141, 59, 217]),
-      ),
-      0,
-    )
-  ) {
-    return OptionProgramAccount.MakerPoolShare;
-  }
   if (
     containsBytes(
       data,
@@ -266,13 +290,12 @@ export enum OptionProgramInstruction {
   AutoExerciseExpired,
   BorrowFromPool,
   BuyFromPool,
-  ClaimPremium,
+  ClaimTheta,
   CloseLongToPool,
   CloseOption,
   CreateEscrowV2,
   CreateLiquidityRouter,
   DepositCollateral,
-  DepositToPool,
   DepositToPosition,
   InitCollateralPool,
   InitConfig,
@@ -295,7 +318,6 @@ export enum OptionProgramInstruction {
   UnwindWriterUnsold,
   UpdateImpliedVolatility,
   UpdateMarketData,
-  WithdrawFromPool,
   WithdrawFromPosition,
   WriteToPool,
 }
@@ -363,12 +385,12 @@ export function identifyOptionProgramInstruction(
     containsBytes(
       data,
       fixEncoderSize(getBytesEncoder(), 8).encode(
-        new Uint8Array([225, 124, 12, 107, 24, 154, 37, 100]),
+        new Uint8Array([151, 147, 69, 241, 135, 166, 23, 62]),
       ),
       0,
     )
   ) {
-    return OptionProgramInstruction.ClaimPremium;
+    return OptionProgramInstruction.ClaimTheta;
   }
   if (
     containsBytes(
@@ -425,17 +447,6 @@ export function identifyOptionProgramInstruction(
   ) {
     return OptionProgramInstruction.DepositCollateral;
   }
-  if (
-    containsBytes(
-      data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(
-        new Uint8Array([99, 136, 15, 66, 85, 146, 24, 89]),
-      ),
-      0,
-    )
-  ) {
-    return OptionProgramInstruction.DepositToPool;
-  }
   if (
     containsBytes(
       data,
@@ -678,17 +689,6 @@ export function identifyOptionProgramInstruction(
   ) {
     return OptionProgramInstruction.UpdateMarketData;
   }
-  if (
-    containsBytes(
-      data,
-      fixEncoderSize(getBytesEncoder(), 8).encode(
-        new Uint8Array([62, 33, 128, 81, 40, 234, 29, 77]),
-      ),
-      0,
-    )
-  ) {
-    return OptionProgramInstruction.WithdrawFromPool;
-  }
   if (
     containsBytes(
       data,
@@ -735,8 +735,8 @@ export type ParsedOptionProgramInstruction<
       instructionType: OptionProgramInstruction.BuyFromPool;
     } & ParsedBuyFromPoolInstruction<TProgram>)
   | ({
-      instructionType: OptionProgramInstruction.ClaimPremium;
-    } & ParsedClaimPremiumInstruction<TProgram>)
+      instructionType: OptionProgramInstruction.ClaimTheta;
+    } & ParsedClaimThetaInstruction<TProgram>)
   | ({
       instructionType: OptionProgramInstruction.CloseLongToPool;
     } & ParsedCloseLongToPoolInstruction<TProgram>)
@@ -752,9 +752,6 @@ export type ParsedOptionProgramInstruction<
   | ({
       instructionType: OptionProgramInstruction.DepositCollateral;
     } & ParsedDepositCollateralInstruction<TProgram>)
-  | ({
-      instructionType: OptionProgramInstruction.DepositToPool;
-    } & ParsedDepositToPoolInstruction<TProgram>)
   | ({
       instructionType: OptionProgramInstruction.DepositToPosition;
     } & ParsedDepositToPositionInstruction<TProgram>)
@@ -821,12 +818,266 @@ export type ParsedOptionProgramInstruction<
   | ({
       instructionType: OptionProgramInstruction.UpdateMarketData;
     } & ParsedUpdateMarketDataInstruction<TProgram>)
-  | ({
-      instructionType: OptionProgramInstruction.WithdrawFromPool;
-    } & ParsedWithdrawFromPoolInstruction<TProgram>)
   | ({
       instructionType: OptionProgramInstruction.WithdrawFromPosition;
     } & ParsedWithdrawFromPositionInstruction<TProgram>)
   | ({
       instructionType: OptionProgramInstruction.WriteToPool;
     } & ParsedWriteToPoolInstruction<TProgram>);
+
+export function parseOptionProgramInstruction<TProgram extends string>(
+  instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedOptionProgramInstruction<TProgram> {
+  const instructionType = identifyOptionProgramInstruction(instruction);
+  switch (instructionType) {
+    case OptionProgramInstruction.AcceptAdmin: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.AcceptAdmin,
+        ...parseAcceptAdminInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.AutoExerciseAllExpired: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.AutoExerciseAllExpired,
+        ...parseAutoExerciseAllExpiredInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.AutoExerciseExpired: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.AutoExerciseExpired,
+        ...parseAutoExerciseExpiredInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.BorrowFromPool: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.BorrowFromPool,
+        ...parseBorrowFromPoolInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.BuyFromPool: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.BuyFromPool,
+        ...parseBuyFromPoolInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.ClaimTheta: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.ClaimTheta,
+        ...parseClaimThetaInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.CloseLongToPool: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.CloseLongToPool,
+        ...parseCloseLongToPoolInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.CloseOption: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.CloseOption,
+        ...parseCloseOptionInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.CreateEscrowV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.CreateEscrowV2,
+        ...parseCreateEscrowV2Instruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.CreateLiquidityRouter: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.CreateLiquidityRouter,
+        ...parseCreateLiquidityRouterInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.DepositCollateral: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.DepositCollateral,
+        ...parseDepositCollateralInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.DepositToPosition: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.DepositToPosition,
+        ...parseDepositToPositionInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.InitCollateralPool: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.InitCollateralPool,
+        ...parseInitCollateralPoolInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.InitConfig: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.InitConfig,
+        ...parseInitConfigInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.InitOptionPool: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.InitOptionPool,
+        ...parseInitOptionPoolInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.InitializeMarketData: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.InitializeMarketData,
+        ...parseInitializeMarketDataInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.LiquidateWriterPosition: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.LiquidateWriterPosition,
+        ...parseLiquidateWriterPositionInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpCreateVault: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpCreateVault,
+        ...parseOmlpCreateVaultInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpTakeOfferWithFailover: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpTakeOfferWithFailover,
+        ...parseOmlpTakeOfferWithFailoverInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateMaxLeverage: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateMaxLeverage,
+        ...parseOmlpUpdateMaxLeverageInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateProtocolFee: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateProtocolFee,
+        ...parseOmlpUpdateProtocolFeeInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateSupplyLimit: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateSupplyLimit,
+        ...parseOmlpUpdateSupplyLimitInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OptionExercise: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OptionExercise,
+        ...parseOptionExerciseInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OptionMint: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OptionMint,
+        ...parseOptionMintInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OptionValidate: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OptionValidate,
+        ...parseOptionValidateInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.RepayPoolLoan: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.RepayPoolLoan,
+        ...parseRepayPoolLoanInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.RepayPoolLoanFromCollateral: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.RepayPoolLoanFromCollateral,
+        ...parseRepayPoolLoanFromCollateralInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.SettleMakerCollateral: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.SettleMakerCollateral,
+        ...parseSettleMakerCollateralInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.SyncWriterPosition: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.SyncWriterPosition,
+        ...parseSyncWriterPositionInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.TransferAdmin: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.TransferAdmin,
+        ...parseTransferAdminInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.UnwindWriterUnsold: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.UnwindWriterUnsold,
+        ...parseUnwindWriterUnsoldInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.UpdateImpliedVolatility: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.UpdateImpliedVolatility,
+        ...parseUpdateImpliedVolatilityInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.UpdateMarketData: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.UpdateMarketData,
+        ...parseUpdateMarketDataInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.WithdrawFromPosition: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.WithdrawFromPosition,
+        ...parseWithdrawFromPositionInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.WriteToPool: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.WriteToPool,
+        ...parseWriteToPoolInstruction(instruction),
+      };
+    }
+    default:
+      throw new Error(
+        `Unrecognized instruction type: ${instructionType as string}`,
+      );
+  }
+}

package/index.ts

@@ -18,7 +18,7 @@ export * from "./long/exercise";
 export * from "./long/quotes";
 
 export * from "./short/builders";
-export * from "./short/claim-premium";
+export * from "./short/claim-theta";
 export * from "./short/close-option";
 export * from "./short/pool";
 

package/package.json

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

package/short/claim-theta.ts

@@ -0,0 +1,38 @@
+import { getClaimThetaInstructionAsync } from "../generated/instructions";
+import type { Instruction } from "@solana/kit";
+import { toAddress } from "../client/program";
+import type { AddressLike, BuiltTransaction } from "../client/types";
+
+export interface BuildClaimThetaParams {
+  optionPool: AddressLike;
+  writerPosition?: AddressLike;
+  writerPaymentAccount: AddressLike;
+  premiumVault: AddressLike;
+  writer: AddressLike;
+  tokenProgram?: AddressLike;
+}
+
+export async function buildClaimThetaInstruction(
+  params: BuildClaimThetaParams
+): Promise<Instruction<string>> {
+  return getClaimThetaInstructionAsync({
+    optionPool: toAddress(params.optionPool),
+    writerPosition: params.writerPosition ? toAddress(params.writerPosition) : undefined,
+    writerPaymentAccount: toAddress(params.writerPaymentAccount),
+    premiumVault: toAddress(params.premiumVault),
+    writer: toAddress(params.writer) as any,
+    tokenProgram: params.tokenProgram ? toAddress(params.tokenProgram) : undefined,
+  });
+}
+
+/**
+ * Builds a theta claim transaction for a writer's position.
+ * Writers claim their reserved theta (time-decay share) only.
+ * `writerPosition` is optional and can be derived by the generated instruction helper.
+ */
+export async function buildClaimThetaTransaction(
+  params: BuildClaimThetaParams
+): Promise<BuiltTransaction> {
+  const instruction = await buildClaimThetaInstruction(params);
+  return { instructions: [instruction] };
+}

package/short/pool.ts

@@ -1,39 +1,13 @@
 import {
   getBorrowFromPoolInstructionAsync,
-  getDepositToPoolInstructionAsync,
   getRepayPoolLoanInstructionAsync,
   getRepayPoolLoanFromCollateralInstructionAsync,
-  getWithdrawFromPoolInstructionAsync,
 } from "../generated/instructions";
 import type { Instruction } from "@solana/kit";
 import { toAddress } from "../client/program";
 import type { AddressLike, BuiltTransaction } from "../client/types";
 import { assertNonNegativeAmount, assertPositiveAmount } from "../shared/amounts";
 
-export interface BuildDepositToPoolParams {
-  optionPool: AddressLike;
-  optionAccount: AddressLike;
-  makerOptionAccount: AddressLike;
-  escrowLongAccount: AddressLike;
-  maker: AddressLike;
-  amount: bigint | number;
-  makerPoolShare?: AddressLike;
-  tokenProgram?: AddressLike;
-  associatedTokenProgram?: AddressLike;
-  systemProgram?: AddressLike;
-}
-
-export interface BuildWithdrawFromPoolParams {
-  optionPool: AddressLike;
-  optionAccount: AddressLike;
-  makerOptionAccount: AddressLike;
-  escrowLongAccount: AddressLike;
-  maker: AddressLike;
-  amount: bigint | number;
-  makerPoolShare?: AddressLike;
-  tokenProgram?: AddressLike;
-}
-
 export interface BuildBorrowFromPoolParams {
   vault: AddressLike;
   vaultTokenAccount: AddressLike;
@@ -77,61 +51,6 @@ export interface BuildRepayPoolLoanFromCollateralParams {
   tokenProgram?: AddressLike;
 }
 
-export async function buildDepositToPoolInstruction(
-  params: BuildDepositToPoolParams
-): Promise<Instruction<string>> {
-  assertPositiveAmount(params.amount, "amount");
-
-  return getDepositToPoolInstructionAsync({
-    optionPool: toAddress(params.optionPool),
-    optionAccount: toAddress(params.optionAccount),
-    makerPoolShare: params.makerPoolShare ? toAddress(params.makerPoolShare) : undefined,
-    makerOptionAccount: toAddress(params.makerOptionAccount),
-    escrowLongAccount: toAddress(params.escrowLongAccount),
-    maker: toAddress(params.maker) as any,
-    tokenProgram: params.tokenProgram ? toAddress(params.tokenProgram) : undefined,
-    associatedTokenProgram: params.associatedTokenProgram
-      ? toAddress(params.associatedTokenProgram)
-      : undefined,
-    systemProgram: params.systemProgram ? toAddress(params.systemProgram) : undefined,
-    amount: params.amount,
-  });
-}
-
-export async function buildDepositToPoolTransaction(
-  params: BuildDepositToPoolParams
-): Promise<BuiltTransaction> {
-  const instruction = await buildDepositToPoolInstruction(params);
-  return { instructions: [instruction] };
-}
-
-export async function buildWithdrawFromPoolInstruction(
-  params: BuildWithdrawFromPoolParams
-): Promise<Instruction<string>> {
-  assertPositiveAmount(params.amount, "amount");
-
-  return getWithdrawFromPoolInstructionAsync({
-    optionPool: toAddress(params.optionPool),
-    optionAccount: toAddress(params.optionAccount),
-    makerPoolShare: params.makerPoolShare ? toAddress(params.makerPoolShare) : undefined,
-    makerOptionAccount: toAddress(params.makerOptionAccount),
-    escrowLongAccount: toAddress(params.escrowLongAccount),
-    maker: toAddress(params.maker) as any,
-    tokenProgram: params.tokenProgram ? toAddress(params.tokenProgram) : undefined,
-    amount: params.amount,
-  });
-}
-
-/**
- * Builds a pool withdraw instruction set for an LP maker position.
- */
-export async function buildWithdrawFromPoolTransaction(
-  params: BuildWithdrawFromPoolParams
-): Promise<BuiltTransaction> {
-  const instruction = await buildWithdrawFromPoolInstruction(params);
-  return { instructions: [instruction] };
-}
-
 export async function buildBorrowFromPoolInstruction(
   params: BuildBorrowFromPoolParams
 ): Promise<Instruction<string>> {