@epicentral/sos-sdk 0.9.0-beta

package/generated/programs/optionProgram.ts

@@ -0,0 +1,1144 @@
+/**
+ * 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 {
+  assertIsInstructionWithAccounts,
+  containsBytes,
+  fixEncoderSize,
+  getBytesEncoder,
+  type Address,
+  type Instruction,
+  type InstructionWithData,
+  type ReadonlyUint8Array,
+} from "@solana/kit";
+import {
+  parseAcceptAdminInstruction,
+  parseAutoExerciseAllExpiredInstruction,
+  parseAutoExerciseExpiredInstruction,
+  parseBorrowFromPoolInstruction,
+  parseBuyFromPoolInstruction,
+  parseCloseLongToPoolInstruction,
+  parseCloseOptionInstruction,
+  parseCreateEscrowV2Instruction,
+  parseDepositCollateralInstruction,
+  parseDepositToPositionInstruction,
+  parseInitCollateralPoolInstruction,
+  parseInitConfigInstruction,
+  parseInitializeMarketDataInstruction,
+  parseInitOptionPoolInstruction,
+  parseLiquidateWriterPositionInstruction,
+  parseLiquidateWriterPositionRescueInstruction,
+  parseOmlpCreateVaultInstruction,
+  parseOmlpUpdateFeeWalletInstruction,
+  parseOmlpUpdateInterestModelInstruction,
+  parseOmlpUpdateLiquidationThresholdInstruction,
+  parseOmlpUpdateMaintenanceBufferInstruction,
+  parseOmlpUpdateMaxBorrowCapInstruction,
+  parseOmlpUpdateMaxLeverageInstruction,
+  parseOmlpUpdateProtocolFeeInstruction,
+  parseOmlpUpdateSupplyLimitInstruction,
+  parseOptionExerciseInstruction,
+  parseOptionMintInstruction,
+  parseOptionValidateInstruction,
+  parseRepayPoolLoanFromCollateralInstruction,
+  parseRepayPoolLoanFromWalletInstruction,
+  parseRepayPoolLoanInstruction,
+  parseSettleMakerCollateralInstruction,
+  parseSyncWriterPositionInstruction,
+  parseTransferAdminInstruction,
+  parseUnwindWriterUnsoldInstruction,
+  parseUpdateImpliedVolatilityInstruction,
+  parseUpdateMarketDataInstruction,
+  parseWithdrawFromPositionInstruction,
+  parseWriteToPoolInstruction,
+  type ParsedAcceptAdminInstruction,
+  type ParsedAutoExerciseAllExpiredInstruction,
+  type ParsedAutoExerciseExpiredInstruction,
+  type ParsedBorrowFromPoolInstruction,
+  type ParsedBuyFromPoolInstruction,
+  type ParsedCloseLongToPoolInstruction,
+  type ParsedCloseOptionInstruction,
+  type ParsedCreateEscrowV2Instruction,
+  type ParsedDepositCollateralInstruction,
+  type ParsedDepositToPositionInstruction,
+  type ParsedInitCollateralPoolInstruction,
+  type ParsedInitConfigInstruction,
+  type ParsedInitializeMarketDataInstruction,
+  type ParsedInitOptionPoolInstruction,
+  type ParsedLiquidateWriterPositionInstruction,
+  type ParsedLiquidateWriterPositionRescueInstruction,
+  type ParsedOmlpCreateVaultInstruction,
+  type ParsedOmlpUpdateFeeWalletInstruction,
+  type ParsedOmlpUpdateInterestModelInstruction,
+  type ParsedOmlpUpdateLiquidationThresholdInstruction,
+  type ParsedOmlpUpdateMaintenanceBufferInstruction,
+  type ParsedOmlpUpdateMaxBorrowCapInstruction,
+  type ParsedOmlpUpdateMaxLeverageInstruction,
+  type ParsedOmlpUpdateProtocolFeeInstruction,
+  type ParsedOmlpUpdateSupplyLimitInstruction,
+  type ParsedOptionExerciseInstruction,
+  type ParsedOptionMintInstruction,
+  type ParsedOptionValidateInstruction,
+  type ParsedRepayPoolLoanFromCollateralInstruction,
+  type ParsedRepayPoolLoanFromWalletInstruction,
+  type ParsedRepayPoolLoanInstruction,
+  type ParsedSettleMakerCollateralInstruction,
+  type ParsedSyncWriterPositionInstruction,
+  type ParsedTransferAdminInstruction,
+  type ParsedUnwindWriterUnsoldInstruction,
+  type ParsedUpdateImpliedVolatilityInstruction,
+  type ParsedUpdateMarketDataInstruction,
+  type ParsedWithdrawFromPositionInstruction,
+  type ParsedWriteToPoolInstruction,
+} from "../instructions";
+
+export const OPTION_PROGRAM_PROGRAM_ADDRESS =
+  "AVJa9h5aEZ5F4nwJGeoy4kmmiPy1pijrapEspZC5pRYg" as Address<"AVJa9h5aEZ5F4nwJGeoy4kmmiPy1pijrapEspZC5pRYg">;
+
+export enum OptionProgramAccount {
+  CollateralPool,
+  Config,
+  EscrowState,
+  LenderPosition,
+  MakerCollateralShare,
+  MarketDataAccount,
+  OptionAccount,
+  OptionPool,
+  PoolLoan,
+  PositionAccount,
+  Vault,
+  WriterPosition,
+}
+
+export function identifyOptionProgramAccount(
+  account: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+): OptionProgramAccount {
+  const data = "data" in account ? account.data : account;
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([186, 4, 253, 240, 93, 243, 212, 195]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramAccount.CollateralPool;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([155, 12, 170, 224, 30, 250, 204, 130]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramAccount.Config;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([19, 90, 148, 111, 55, 130, 229, 108]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramAccount.EscrowState;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([165, 98, 244, 204, 209, 158, 88, 19]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramAccount.LenderPosition;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([44, 113, 163, 132, 92, 188, 13, 158]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramAccount.MakerCollateralShare;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([181, 15, 209, 146, 116, 22, 98, 208]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramAccount.MarketDataAccount;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([82, 44, 195, 42, 219, 57, 18, 92]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramAccount.OptionAccount;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([100, 175, 136, 125, 88, 244, 169, 209]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramAccount.OptionPool;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([31, 179, 93, 157, 68, 113, 2, 128]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramAccount.PoolLoan;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([60, 125, 250, 193, 181, 109, 238, 86]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramAccount.PositionAccount;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([211, 8, 232, 43, 2, 152, 117, 119]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramAccount.Vault;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([195, 252, 56, 77, 221, 13, 8, 69]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramAccount.WriterPosition;
+  }
+  throw new Error(
+    "The provided account could not be identified as a optionProgram account.",
+  );
+}
+
+export enum OptionProgramInstruction {
+  AcceptAdmin,
+  AutoExerciseAllExpired,
+  AutoExerciseExpired,
+  BorrowFromPool,
+  BuyFromPool,
+  CloseLongToPool,
+  CloseOption,
+  CreateEscrowV2,
+  DepositCollateral,
+  DepositToPosition,
+  InitCollateralPool,
+  InitConfig,
+  InitOptionPool,
+  InitializeMarketData,
+  LiquidateWriterPosition,
+  LiquidateWriterPositionRescue,
+  OmlpCreateVault,
+  OmlpUpdateFeeWallet,
+  OmlpUpdateInterestModel,
+  OmlpUpdateLiquidationThreshold,
+  OmlpUpdateMaintenanceBuffer,
+  OmlpUpdateMaxBorrowCap,
+  OmlpUpdateMaxLeverage,
+  OmlpUpdateProtocolFee,
+  OmlpUpdateSupplyLimit,
+  OptionExercise,
+  OptionMint,
+  OptionValidate,
+  RepayPoolLoan,
+  RepayPoolLoanFromCollateral,
+  RepayPoolLoanFromWallet,
+  SettleMakerCollateral,
+  SyncWriterPosition,
+  TransferAdmin,
+  UnwindWriterUnsold,
+  UpdateImpliedVolatility,
+  UpdateMarketData,
+  WithdrawFromPosition,
+  WriteToPool,
+}
+
+export function identifyOptionProgramInstruction(
+  instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+): OptionProgramInstruction {
+  const data = "data" in instruction ? instruction.data : instruction;
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([112, 42, 45, 90, 116, 181, 13, 170]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.AcceptAdmin;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([114, 241, 93, 137, 214, 147, 43, 57]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.AutoExerciseAllExpired;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([93, 222, 81, 8, 181, 25, 68, 25]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.AutoExerciseExpired;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([186, 246, 186, 247, 84, 17, 148, 182]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.BorrowFromPool;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([118, 108, 243, 198, 19, 184, 41, 246]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.BuyFromPool;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([72, 117, 94, 238, 111, 113, 243, 91]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.CloseLongToPool;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([138, 79, 53, 54, 221, 16, 109, 141]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.CloseOption;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([235, 71, 10, 36, 206, 55, 150, 187]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.CreateEscrowV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([156, 131, 142, 116, 146, 247, 162, 120]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.DepositCollateral;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([4, 236, 119, 21, 20, 228, 104, 139]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.DepositToPosition;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([76, 233, 1, 25, 52, 227, 208, 101]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.InitCollateralPool;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([23, 235, 115, 232, 168, 96, 1, 231]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.InitConfig;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([204, 113, 12, 141, 240, 219, 74, 220]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.InitOptionPool;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([250, 21, 97, 28, 194, 42, 173, 236]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.InitializeMarketData;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([184, 117, 16, 217, 120, 32, 16, 63]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.LiquidateWriterPosition;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([210, 74, 45, 13, 187, 151, 90, 190]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.LiquidateWriterPositionRescue;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([129, 63, 75, 202, 228, 221, 137, 221]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.OmlpCreateVault;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([94, 66, 39, 241, 66, 246, 217, 92]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.OmlpUpdateFeeWallet;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([193, 229, 132, 59, 147, 33, 181, 14]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.OmlpUpdateInterestModel;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([196, 59, 136, 47, 38, 158, 76, 232]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.OmlpUpdateLiquidationThreshold;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([101, 100, 162, 212, 169, 40, 40, 101]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.OmlpUpdateMaintenanceBuffer;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([156, 196, 135, 28, 127, 162, 101, 52]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.OmlpUpdateMaxBorrowCap;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([108, 142, 71, 44, 21, 120, 202, 28]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.OmlpUpdateMaxLeverage;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([41, 17, 189, 37, 78, 53, 240, 52]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.OmlpUpdateProtocolFee;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([38, 178, 193, 188, 127, 170, 122, 42]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.OmlpUpdateSupplyLimit;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([43, 86, 237, 78, 235, 74, 131, 206]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.OptionExercise;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([210, 192, 217, 89, 138, 0, 94, 90]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.OptionMint;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([67, 10, 20, 254, 66, 53, 251, 6]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.OptionValidate;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([166, 161, 84, 231, 244, 103, 63, 224]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.RepayPoolLoan;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([213, 59, 182, 125, 195, 39, 67, 33]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.RepayPoolLoanFromCollateral;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([78, 130, 135, 90, 211, 21, 247, 247]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.RepayPoolLoanFromWallet;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([47, 169, 97, 199, 29, 197, 115, 148]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.SettleMakerCollateral;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([57, 19, 103, 217, 187, 66, 3, 4]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.SyncWriterPosition;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([42, 242, 66, 106, 228, 10, 111, 156]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.TransferAdmin;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([48, 116, 34, 53, 22, 225, 22, 79]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.UnwindWriterUnsold;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([73, 16, 245, 77, 198, 16, 17, 11]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.UpdateImpliedVolatility;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([38, 27, 206, 55, 6, 151, 187, 10]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.UpdateMarketData;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([39, 178, 255, 108, 24, 150, 180, 238]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.WithdrawFromPosition;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([169, 94, 104, 228, 81, 205, 147, 71]),
+      ),
+      0,
+    )
+  ) {
+    return OptionProgramInstruction.WriteToPool;
+  }
+  throw new Error(
+    "The provided instruction could not be identified as a optionProgram instruction.",
+  );
+}
+
+export type ParsedOptionProgramInstruction<
+  TProgram extends string = "AVJa9h5aEZ5F4nwJGeoy4kmmiPy1pijrapEspZC5pRYg",
+> =
+  | ({
+      instructionType: OptionProgramInstruction.AcceptAdmin;
+    } & ParsedAcceptAdminInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.AutoExerciseAllExpired;
+    } & ParsedAutoExerciseAllExpiredInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.AutoExerciseExpired;
+    } & ParsedAutoExerciseExpiredInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.BorrowFromPool;
+    } & ParsedBorrowFromPoolInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.BuyFromPool;
+    } & ParsedBuyFromPoolInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.CloseLongToPool;
+    } & ParsedCloseLongToPoolInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.CloseOption;
+    } & ParsedCloseOptionInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.CreateEscrowV2;
+    } & ParsedCreateEscrowV2Instruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.DepositCollateral;
+    } & ParsedDepositCollateralInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.DepositToPosition;
+    } & ParsedDepositToPositionInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.InitCollateralPool;
+    } & ParsedInitCollateralPoolInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.InitConfig;
+    } & ParsedInitConfigInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.InitOptionPool;
+    } & ParsedInitOptionPoolInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.InitializeMarketData;
+    } & ParsedInitializeMarketDataInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.LiquidateWriterPosition;
+    } & ParsedLiquidateWriterPositionInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.LiquidateWriterPositionRescue;
+    } & ParsedLiquidateWriterPositionRescueInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.OmlpCreateVault;
+    } & ParsedOmlpCreateVaultInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.OmlpUpdateFeeWallet;
+    } & ParsedOmlpUpdateFeeWalletInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.OmlpUpdateInterestModel;
+    } & ParsedOmlpUpdateInterestModelInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.OmlpUpdateLiquidationThreshold;
+    } & ParsedOmlpUpdateLiquidationThresholdInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.OmlpUpdateMaintenanceBuffer;
+    } & ParsedOmlpUpdateMaintenanceBufferInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.OmlpUpdateMaxBorrowCap;
+    } & ParsedOmlpUpdateMaxBorrowCapInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.OmlpUpdateMaxLeverage;
+    } & ParsedOmlpUpdateMaxLeverageInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.OmlpUpdateProtocolFee;
+    } & ParsedOmlpUpdateProtocolFeeInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.OmlpUpdateSupplyLimit;
+    } & ParsedOmlpUpdateSupplyLimitInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.OptionExercise;
+    } & ParsedOptionExerciseInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.OptionMint;
+    } & ParsedOptionMintInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.OptionValidate;
+    } & ParsedOptionValidateInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.RepayPoolLoan;
+    } & ParsedRepayPoolLoanInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.RepayPoolLoanFromCollateral;
+    } & ParsedRepayPoolLoanFromCollateralInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.RepayPoolLoanFromWallet;
+    } & ParsedRepayPoolLoanFromWalletInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.SettleMakerCollateral;
+    } & ParsedSettleMakerCollateralInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.SyncWriterPosition;
+    } & ParsedSyncWriterPositionInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.TransferAdmin;
+    } & ParsedTransferAdminInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.UnwindWriterUnsold;
+    } & ParsedUnwindWriterUnsoldInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.UpdateImpliedVolatility;
+    } & ParsedUpdateImpliedVolatilityInstruction<TProgram>)
+  | ({
+      instructionType: OptionProgramInstruction.UpdateMarketData;
+    } & ParsedUpdateMarketDataInstruction<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.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.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.LiquidateWriterPositionRescue: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.LiquidateWriterPositionRescue,
+        ...parseLiquidateWriterPositionRescueInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpCreateVault: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpCreateVault,
+        ...parseOmlpCreateVaultInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateFeeWallet: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateFeeWallet,
+        ...parseOmlpUpdateFeeWalletInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateInterestModel: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateInterestModel,
+        ...parseOmlpUpdateInterestModelInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateLiquidationThreshold: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType:
+          OptionProgramInstruction.OmlpUpdateLiquidationThreshold,
+        ...parseOmlpUpdateLiquidationThresholdInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateMaintenanceBuffer: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateMaintenanceBuffer,
+        ...parseOmlpUpdateMaintenanceBufferInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateMaxBorrowCap: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateMaxBorrowCap,
+        ...parseOmlpUpdateMaxBorrowCapInstruction(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.RepayPoolLoanFromWallet: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.RepayPoolLoanFromWallet,
+        ...parseRepayPoolLoanFromWalletInstruction(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}`,
+      );
+  }
+}