@epicentral/sos-sdk 0.1.1 → 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/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/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),
+  };
+}