@epicentral/sos-sdk 0.10.4-beta → 0.11.0-beta

package/README.md

@@ -63,8 +63,12 @@ Additional modules:
 | `buildUnwindWriterUnsoldTransactionWithDerivation` | Builds unwind unsold transaction. |
 | `buildUnwindWriterUnsoldWithLoanRepayment` | **Unwind + repay pool loans in one tx.** Use when closing unsold shorts that borrowed from OMLP. |
 | `buildSyncWriterPositionTransaction` | Syncs writer position with pool accumulators. |
-| `buildSettleMakerCollateralTransaction` | Expiry Phase A: keeper-signed lender repayment and maker-share snapshot. Repays one active loan's principal + accrued interest to OMLP from collateral vault, and initializes the maker settlement share from `WriterPosition` when older mints do not yet have one. Writers with multiple loans for the expired option call it once per loan; maker residual is claimed separately. |
-| `getClaimMakerRemainingInstructionAsync` | Expiry Phase C generated instruction: returns remaining maker collateral after Phase B buyer payouts complete. |
+| `buildSettleMakerCollateralTransaction` | Expiry Phase A: keeper-signed lender repayment and maker-share snapshot. Repays one active loan's principal + accrued interest to OMLP from collateral vault, and initializes the maker settlement share from `WriterPosition` when older mints do not yet have one. Writers with multiple loans for the expired option call it once per loan; maker residual is prepared/claimed separately. |
+| `buildPrepareBuyerSettlementInstruction` | Expiry Phase B (prepare): keeper snapshots a buyer’s capped expiry claim into `BuyerSettlementClaim` PDAs; **does not** transfer to the buyer’s wallet (non-custodial OPX path). |
+| `buildClaimBuyerSettlementInstruction` | Expiry Phase B (claim): **buyer-signed** instruction that transfers the prepared payout from the collateral vault to the buyer’s ATA and closes the position. |
+| `buildPrepareMakerSettlementInstruction` | Expiry Phase C (prepare): keeper snapshots maker residual into `MakerSettlementClaim` after Phase B completes. |
+| `buildClaimMakerSettlementInstruction` | Expiry Phase C (claim): **maker-signed** instruction that transfers prepared residual collateral to the maker. |
+| `getClaimMakerRemainingInstructionAsync` | **Legacy** Phase C: direct vault → maker transfer in one keeper call (still on-chain). Prefer prepare/claim for user-controlled settlement. |
 | `buildCloseOptionTransaction` | Closes option token account. |
 | `buildClaimThetaTransaction` | Claims theta (time-decay share) for writer. |
 | `buildRepayPoolLoanFromCollateralInstruction` | Repays pool loan from collateral (short/pool). |
@@ -81,17 +85,17 @@ Additional modules:
   - No maker transaction signer is required by this instruction format.
   - On-chain repayment (`collateral_vault` -> `omlp_vault`) is signed by the `collateral_pool` PDA.
   - Lender repayment is sourced from collateral vault funds, not maker wallet funds.
-  - Expiry residual maker collateral is returned later by `claim_maker_remaining` after buyer payout Phase B.
+  - After Phase B, maker residual is returned via **prepare/claim** (`prepare_maker_settlement` → `claim_maker_settlement`) or the legacy **`claim_maker_remaining`** instruction.
 
 ### Expiry Settlement
 
-Expiry settlement is lender-first and split across three instructions:
+Expiry settlement is **lender-first**, then buyer phase, then maker phase. **OPX uses a non-custodial prepare/claim path:** keepers only **prepare** snapshots and phase progress; **users sign** claim transactions to receive tokens.
 
-1. `settle_maker_collateral` (Phase A) for every non-liquidated maker. Lender repayment is paid to the loan vault's ATA for the pool collateral mint, so devnet fake SOL/USDC pools and mainnet WSOL pools use the same mint-safe path. The keeper pays rent to create the maker settlement share if the writer was opened through `option_mint` before that share existed. If a writer has multiple active `PoolLoan` accounts for that expired option, keepers submit one Phase A transaction per loan; the maker share is not marked Phase A settled until all are repaid.
-2. `auto_exercise_expired` / `auto_exercise_all_expired` (Phase B) for buyers, capped by `eligible_maker_pot`; options with zero buyer positions are considered buyer-settled so maker claims do not stall. The single and batch paths take the collateral/settlement mint so cash-settled payouts use the correct token decimals; batch remaining accounts must pair each position with that buyer's token account for the same mint.
-3. `claim_maker_remaining` (Phase C) for makers after `phase_b_complete`, returning residual collateral in the pool collateral mint.
+1. **`settle_maker_collateral` (Phase A)** — For every non-liquidated maker: repay OMLP principal + interest from the collateral vault; snapshot `eligible_maker_pot` / `post_debt_collateral`. One transaction per active `PoolLoan` when a writer has multiple loans.
+2. **Phase B (buyers)** — **Recommended:** `prepare_buyer_settlement` (keeper, per position) records capped payouts on `BuyerSettlementClaim` and advances `phase_b_complete` when all buyer rows are processed; then **`claim_buyer_settlement` (buyer signer)** performs the vault → buyer ATA transfer. Payouts are capped by `eligible_maker_pot` with the same pro-rata scaling as before. **Legacy:** `auto_exercise_expired` / `auto_exercise_all_expired` still exist and can transfer directly from the vault to buyer ATAs in the same instruction when invoked (custodial keeper pattern).
+3. **Phase C (makers)** — **Recommended:** `prepare_maker_settlement` (keeper) then **`claim_maker_settlement` (maker signer)**. **Legacy:** `claim_maker_remaining` still performs a direct residual transfer when called.
 
-New program errors exposed in the IDL: `LenderRepaymentNotComplete`, `BuyerPayoutNotComplete`, and `MakerLiquidated`.
+New / related program errors include `LenderRepaymentNotComplete`, `BuyerPayoutNotComplete`, `MakerLiquidated`, and claim-state errors such as `SettlementClaimNotPrepared` / `SettlementClaimAlreadyClaimed` (see IDL).
 
 ### OMLP (Lending)
 

package/accounts/fetchers.ts

@@ -1,8 +1,10 @@
 import {
+  getBuyerSettlementClaimDecoder,
   COLLATERAL_POOL_DISCRIMINATOR,
   OPTION_POOL_DISCRIMINATOR,
   getCollateralPoolDecoder,
   getLenderPositionDecoder,
+  getMakerSettlementClaimDecoder,
   getMarketDataAccountDecoder,
   getOptionAccountDecoder,
   getOptionPoolDecoder,
@@ -10,8 +12,10 @@ import {
   getPositionAccountDecoder,
   getVaultDecoder,
   getWriterPositionDecoder,
+  type BuyerSettlementClaim,
   type CollateralPool,
   type LenderPosition,
+  type MakerSettlementClaim,
   type MarketDataAccount,
   type OptionAccount,
   type OptionPool,
@@ -158,6 +162,20 @@ export async function fetchBuyerPosition(
   return decodeAccount(rpc, buyerPosition, getPositionAccountDecoder());
 }
 
+export async function fetchBuyerSettlementClaim(
+  rpc: KitRpc,
+  buyerSettlementClaim: AddressLike
+): Promise<BuyerSettlementClaim | null> {
+  return decodeAccount(rpc, buyerSettlementClaim, getBuyerSettlementClaimDecoder());
+}
+
+export async function fetchMakerSettlementClaim(
+  rpc: KitRpc,
+  makerSettlementClaim: AddressLike
+): Promise<MakerSettlementClaim | null> {
+  return decodeAccount(rpc, makerSettlementClaim, getMakerSettlementClaimDecoder());
+}
+
 export async function fetchVault(
   rpc: KitRpc,
   vault: AddressLike

package/accounts/pdas.ts

@@ -159,6 +159,34 @@ export async function deriveMakerCollateralSharePda(
   });
 }
 
+export async function deriveBuyerSettlementClaimPda(
+  positionAccount: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("buyer_settlement_claim"),
+      addressEncoder.encode(toAddress(positionAccount)),
+    ],
+  });
+}
+
+export async function deriveMakerSettlementClaimPda(
+  makerCollateralShare: AddressLike,
+  programId: AddressLike = PROGRAM_ID
+): Promise<readonly [Address, number]> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    programAddress: toAddress(programId),
+    seeds: [
+      new TextEncoder().encode("maker_settlement_claim"),
+      addressEncoder.encode(toAddress(makerCollateralShare)),
+    ],
+  });
+}
+
 export async function deriveBuyerPositionPda(
   buyer: AddressLike,
   optionAccount: AddressLike,

package/generated/accounts/buyerSettlementClaim.ts

@@ -0,0 +1,227 @@
+/**
+ * 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 {
+  assertAccountExists,
+  assertAccountsExist,
+  combineCodec,
+  decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  fixDecoderSize,
+  fixEncoderSize,
+  getAddressDecoder,
+  getAddressEncoder,
+  getBooleanDecoder,
+  getBooleanEncoder,
+  getBytesDecoder,
+  getBytesEncoder,
+  getF64Decoder,
+  getF64Encoder,
+  getI64Decoder,
+  getI64Encoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU64Decoder,
+  getU64Encoder,
+  getU8Decoder,
+  getU8Encoder,
+  transformEncoder,
+  type Account,
+  type Address,
+  type EncodedAccount,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
+  type MaybeAccount,
+  type MaybeEncodedAccount,
+  type ReadonlyUint8Array,
+} from "@solana/kit";
+
+export const BUYER_SETTLEMENT_CLAIM_DISCRIMINATOR = new Uint8Array([
+  225, 103, 137, 75, 32, 42, 45, 106,
+]);
+
+export function getBuyerSettlementClaimDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    BUYER_SETTLEMENT_CLAIM_DISCRIMINATOR,
+  );
+}
+
+export type BuyerSettlementClaim = {
+  discriminator: ReadonlyUint8Array;
+  buyer: Address;
+  optionAccount: Address;
+  positionAccount: Address;
+  collateralPool: Address;
+  settlementMint: Address;
+  quantity: bigint;
+  premiumPaid: bigint;
+  intrinsicOwed: bigint;
+  claimAmount: bigint;
+  claimablePnl: bigint;
+  oraclePriceAtExpiry: number;
+  snapshotAt: bigint;
+  claimedAt: bigint;
+  isClaimed: boolean;
+  bump: number;
+};
+
+export type BuyerSettlementClaimArgs = {
+  buyer: Address;
+  optionAccount: Address;
+  positionAccount: Address;
+  collateralPool: Address;
+  settlementMint: Address;
+  quantity: number | bigint;
+  premiumPaid: number | bigint;
+  intrinsicOwed: number | bigint;
+  claimAmount: number | bigint;
+  claimablePnl: number | bigint;
+  oraclePriceAtExpiry: number;
+  snapshotAt: number | bigint;
+  claimedAt: number | bigint;
+  isClaimed: boolean;
+  bump: number;
+};
+
+/** Gets the encoder for {@link BuyerSettlementClaimArgs} account data. */
+export function getBuyerSettlementClaimEncoder(): FixedSizeEncoder<BuyerSettlementClaimArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["buyer", getAddressEncoder()],
+      ["optionAccount", getAddressEncoder()],
+      ["positionAccount", getAddressEncoder()],
+      ["collateralPool", getAddressEncoder()],
+      ["settlementMint", getAddressEncoder()],
+      ["quantity", getU64Encoder()],
+      ["premiumPaid", getU64Encoder()],
+      ["intrinsicOwed", getU64Encoder()],
+      ["claimAmount", getU64Encoder()],
+      ["claimablePnl", getI64Encoder()],
+      ["oraclePriceAtExpiry", getF64Encoder()],
+      ["snapshotAt", getI64Encoder()],
+      ["claimedAt", getI64Encoder()],
+      ["isClaimed", getBooleanEncoder()],
+      ["bump", getU8Encoder()],
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: BUYER_SETTLEMENT_CLAIM_DISCRIMINATOR,
+    }),
+  );
+}
+
+/** Gets the decoder for {@link BuyerSettlementClaim} account data. */
+export function getBuyerSettlementClaimDecoder(): FixedSizeDecoder<BuyerSettlementClaim> {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["buyer", getAddressDecoder()],
+    ["optionAccount", getAddressDecoder()],
+    ["positionAccount", getAddressDecoder()],
+    ["collateralPool", getAddressDecoder()],
+    ["settlementMint", getAddressDecoder()],
+    ["quantity", getU64Decoder()],
+    ["premiumPaid", getU64Decoder()],
+    ["intrinsicOwed", getU64Decoder()],
+    ["claimAmount", getU64Decoder()],
+    ["claimablePnl", getI64Decoder()],
+    ["oraclePriceAtExpiry", getF64Decoder()],
+    ["snapshotAt", getI64Decoder()],
+    ["claimedAt", getI64Decoder()],
+    ["isClaimed", getBooleanDecoder()],
+    ["bump", getU8Decoder()],
+  ]);
+}
+
+/** Gets the codec for {@link BuyerSettlementClaim} account data. */
+export function getBuyerSettlementClaimCodec(): FixedSizeCodec<
+  BuyerSettlementClaimArgs,
+  BuyerSettlementClaim
+> {
+  return combineCodec(
+    getBuyerSettlementClaimEncoder(),
+    getBuyerSettlementClaimDecoder(),
+  );
+}
+
+export function decodeBuyerSettlementClaim<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress>,
+): Account<BuyerSettlementClaim, TAddress>;
+export function decodeBuyerSettlementClaim<TAddress extends string = string>(
+  encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<BuyerSettlementClaim, TAddress>;
+export function decodeBuyerSettlementClaim<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+):
+  | Account<BuyerSettlementClaim, TAddress>
+  | MaybeAccount<BuyerSettlementClaim, TAddress> {
+  return decodeAccount(
+    encodedAccount as MaybeEncodedAccount<TAddress>,
+    getBuyerSettlementClaimDecoder(),
+  );
+}
+
+export async function fetchBuyerSettlementClaim<
+  TAddress extends string = string,
+>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<BuyerSettlementClaim, TAddress>> {
+  const maybeAccount = await fetchMaybeBuyerSettlementClaim(
+    rpc,
+    address,
+    config,
+  );
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeBuyerSettlementClaim<
+  TAddress extends string = string,
+>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<BuyerSettlementClaim, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeBuyerSettlementClaim(maybeAccount);
+}
+
+export async function fetchAllBuyerSettlementClaim(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<BuyerSettlementClaim>[]> {
+  const maybeAccounts = await fetchAllMaybeBuyerSettlementClaim(
+    rpc,
+    addresses,
+    config,
+  );
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeBuyerSettlementClaim(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<BuyerSettlementClaim>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) =>
+    decodeBuyerSettlementClaim(maybeAccount),
+  );
+}
+
+export function getBuyerSettlementClaimSize(): number {
+  return 234;
+}

package/generated/accounts/index.ts

@@ -6,11 +6,13 @@
  * @see https://github.com/codama-idl/codama
  */
 
+export * from "./buyerSettlementClaim";
 export * from "./collateralPool";
 export * from "./config";
 export * from "./escrowState";
 export * from "./lenderPosition";
 export * from "./makerCollateralShare";
+export * from "./makerSettlementClaim";
 export * from "./marketDataAccount";
 export * from "./optionAccount";
 export * from "./optionPool";

package/generated/accounts/makerSettlementClaim.ts

@@ -0,0 +1,233 @@
+/**
+ * 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 {
+  assertAccountExists,
+  assertAccountsExist,
+  combineCodec,
+  decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  fixDecoderSize,
+  fixEncoderSize,
+  getAddressDecoder,
+  getAddressEncoder,
+  getBooleanDecoder,
+  getBooleanEncoder,
+  getBytesDecoder,
+  getBytesEncoder,
+  getI64Decoder,
+  getI64Encoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU64Decoder,
+  getU64Encoder,
+  getU8Decoder,
+  getU8Encoder,
+  transformEncoder,
+  type Account,
+  type Address,
+  type EncodedAccount,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
+  type MaybeAccount,
+  type MaybeEncodedAccount,
+  type ReadonlyUint8Array,
+} from "@solana/kit";
+
+export const MAKER_SETTLEMENT_CLAIM_DISCRIMINATOR = new Uint8Array([
+  195, 112, 137, 189, 12, 182, 197, 194,
+]);
+
+export function getMakerSettlementClaimDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    MAKER_SETTLEMENT_CLAIM_DISCRIMINATOR,
+  );
+}
+
+export type MakerSettlementClaim = {
+  discriminator: ReadonlyUint8Array;
+  maker: Address;
+  optionAccount: Address;
+  makerCollateralShare: Address;
+  writerPosition: Address;
+  collateralPool: Address;
+  settlementMint: Address;
+  quantityBacked: bigint;
+  ownMakerBasis: bigint;
+  makerReturn: bigint;
+  exercisePayout: bigint;
+  premiumCollected: bigint;
+  lenderRepayment: bigint;
+  claimablePnl: bigint;
+  snapshotAt: bigint;
+  claimedAt: bigint;
+  isClaimed: boolean;
+  bump: number;
+};
+
+export type MakerSettlementClaimArgs = {
+  maker: Address;
+  optionAccount: Address;
+  makerCollateralShare: Address;
+  writerPosition: Address;
+  collateralPool: Address;
+  settlementMint: Address;
+  quantityBacked: number | bigint;
+  ownMakerBasis: number | bigint;
+  makerReturn: number | bigint;
+  exercisePayout: number | bigint;
+  premiumCollected: number | bigint;
+  lenderRepayment: number | bigint;
+  claimablePnl: number | bigint;
+  snapshotAt: number | bigint;
+  claimedAt: number | bigint;
+  isClaimed: boolean;
+  bump: number;
+};
+
+/** Gets the encoder for {@link MakerSettlementClaimArgs} account data. */
+export function getMakerSettlementClaimEncoder(): FixedSizeEncoder<MakerSettlementClaimArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["maker", getAddressEncoder()],
+      ["optionAccount", getAddressEncoder()],
+      ["makerCollateralShare", getAddressEncoder()],
+      ["writerPosition", getAddressEncoder()],
+      ["collateralPool", getAddressEncoder()],
+      ["settlementMint", getAddressEncoder()],
+      ["quantityBacked", getU64Encoder()],
+      ["ownMakerBasis", getU64Encoder()],
+      ["makerReturn", getU64Encoder()],
+      ["exercisePayout", getU64Encoder()],
+      ["premiumCollected", getU64Encoder()],
+      ["lenderRepayment", getU64Encoder()],
+      ["claimablePnl", getI64Encoder()],
+      ["snapshotAt", getI64Encoder()],
+      ["claimedAt", getI64Encoder()],
+      ["isClaimed", getBooleanEncoder()],
+      ["bump", getU8Encoder()],
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: MAKER_SETTLEMENT_CLAIM_DISCRIMINATOR,
+    }),
+  );
+}
+
+/** Gets the decoder for {@link MakerSettlementClaim} account data. */
+export function getMakerSettlementClaimDecoder(): FixedSizeDecoder<MakerSettlementClaim> {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["maker", getAddressDecoder()],
+    ["optionAccount", getAddressDecoder()],
+    ["makerCollateralShare", getAddressDecoder()],
+    ["writerPosition", getAddressDecoder()],
+    ["collateralPool", getAddressDecoder()],
+    ["settlementMint", getAddressDecoder()],
+    ["quantityBacked", getU64Decoder()],
+    ["ownMakerBasis", getU64Decoder()],
+    ["makerReturn", getU64Decoder()],
+    ["exercisePayout", getU64Decoder()],
+    ["premiumCollected", getU64Decoder()],
+    ["lenderRepayment", getU64Decoder()],
+    ["claimablePnl", getI64Decoder()],
+    ["snapshotAt", getI64Decoder()],
+    ["claimedAt", getI64Decoder()],
+    ["isClaimed", getBooleanDecoder()],
+    ["bump", getU8Decoder()],
+  ]);
+}
+
+/** Gets the codec for {@link MakerSettlementClaim} account data. */
+export function getMakerSettlementClaimCodec(): FixedSizeCodec<
+  MakerSettlementClaimArgs,
+  MakerSettlementClaim
+> {
+  return combineCodec(
+    getMakerSettlementClaimEncoder(),
+    getMakerSettlementClaimDecoder(),
+  );
+}
+
+export function decodeMakerSettlementClaim<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress>,
+): Account<MakerSettlementClaim, TAddress>;
+export function decodeMakerSettlementClaim<TAddress extends string = string>(
+  encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<MakerSettlementClaim, TAddress>;
+export function decodeMakerSettlementClaim<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+):
+  | Account<MakerSettlementClaim, TAddress>
+  | MaybeAccount<MakerSettlementClaim, TAddress> {
+  return decodeAccount(
+    encodedAccount as MaybeEncodedAccount<TAddress>,
+    getMakerSettlementClaimDecoder(),
+  );
+}
+
+export async function fetchMakerSettlementClaim<
+  TAddress extends string = string,
+>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<MakerSettlementClaim, TAddress>> {
+  const maybeAccount = await fetchMaybeMakerSettlementClaim(
+    rpc,
+    address,
+    config,
+  );
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeMakerSettlementClaim<
+  TAddress extends string = string,
+>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<MakerSettlementClaim, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeMakerSettlementClaim(maybeAccount);
+}
+
+export async function fetchAllMakerSettlementClaim(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<MakerSettlementClaim>[]> {
+  const maybeAccounts = await fetchAllMaybeMakerSettlementClaim(
+    rpc,
+    addresses,
+    config,
+  );
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeMakerSettlementClaim(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<MakerSettlementClaim>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) =>
+    decodeMakerSettlementClaim(maybeAccount),
+  );
+}
+
+export function getMakerSettlementClaimSize(): number {
+  return 274;
+}