@voltr/vault-sdk 1.0.21 → 2.0.0

package/src/generated/programs/voltrVault.ts

@@ -0,0 +1,1261 @@
+/**
+ * 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,
+  SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
+  SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+  SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+  SolanaError,
+  type Address,
+  type ClientWithPayer,
+  type ClientWithRpc,
+  type ClientWithTransactionPlanning,
+  type ClientWithTransactionSending,
+  type GetAccountInfoApi,
+  type GetMultipleAccountsApi,
+  type Instruction,
+  type InstructionWithData,
+  type ReadonlyUint8Array,
+} from "@solana/kit";
+import {
+  addSelfFetchFunctions,
+  addSelfPlanAndSendFunctions,
+  type SelfFetchFunctions,
+  type SelfPlanAndSendFunctions,
+} from "@solana/program-client-core";
+import {
+  getAdaptorAddReceiptCodec,
+  getDirectWithdrawInitReceiptCodec,
+  getProtocolCodec,
+  getRequestWithdrawVaultReceiptCodec,
+  getStrategyInitReceiptCodec,
+  getVaultCodec,
+  type AdaptorAddReceipt,
+  type AdaptorAddReceiptArgs,
+  type DirectWithdrawInitReceipt,
+  type DirectWithdrawInitReceiptArgs,
+  type Protocol,
+  type ProtocolArgs,
+  type RequestWithdrawVaultReceipt,
+  type RequestWithdrawVaultReceiptArgs,
+  type StrategyInitReceipt,
+  type StrategyInitReceiptArgs,
+  type Vault,
+  type VaultArgs,
+} from "../accounts";
+import {
+  getAcceptProtocolAdminInstructionAsync,
+  getAcceptVaultAdminInstruction,
+  getAddAdaptorInstructionAsync,
+  getCalibrateHighWaterMarkInstructionAsync,
+  getCalibrateHighWaterMarkUnsafeInstructionAsync,
+  getCancelRequestWithdrawVaultInstructionAsync,
+  getCloseStrategyInstructionAsync,
+  getCreateLpMetadataInstructionAsync,
+  getDepositStrategyInstructionAsync,
+  getDepositVaultInstructionAsync,
+  getDirectWithdrawStrategyInstructionAsync,
+  getDirectWithdrawStrategyWithToleranceInstructionAsync,
+  getHarvestFeeInstructionAsync,
+  getInitializeDirectWithdrawStrategyInstructionAsync,
+  getInitializeStrategyInstructionAsync,
+  getInitializeVaultInstructionAsync,
+  getInitProtocolInstructionAsync,
+  getInstantWithdrawStrategyInstructionAsync,
+  getInstantWithdrawStrategyWithToleranceInstructionAsync,
+  getInstantWithdrawVaultInstructionAsync,
+  getRemoveAdaptorInstructionAsync,
+  getRequestWithdrawVaultInstructionAsync,
+  getUpdateProtocolInstructionAsync,
+  getUpdateVaultConfigInstructionAsync,
+  getUpdateVaultProtocolFeeInstructionAsync,
+  getWithdrawStrategyInstructionAsync,
+  getWithdrawVaultInstructionAsync,
+  parseAcceptProtocolAdminInstruction,
+  parseAcceptVaultAdminInstruction,
+  parseAddAdaptorInstruction,
+  parseCalibrateHighWaterMarkInstruction,
+  parseCalibrateHighWaterMarkUnsafeInstruction,
+  parseCancelRequestWithdrawVaultInstruction,
+  parseCloseStrategyInstruction,
+  parseCreateLpMetadataInstruction,
+  parseDepositStrategyInstruction,
+  parseDepositVaultInstruction,
+  parseDirectWithdrawStrategyInstruction,
+  parseDirectWithdrawStrategyWithToleranceInstruction,
+  parseHarvestFeeInstruction,
+  parseInitializeDirectWithdrawStrategyInstruction,
+  parseInitializeStrategyInstruction,
+  parseInitializeVaultInstruction,
+  parseInitProtocolInstruction,
+  parseInstantWithdrawStrategyInstruction,
+  parseInstantWithdrawStrategyWithToleranceInstruction,
+  parseInstantWithdrawVaultInstruction,
+  parseRemoveAdaptorInstruction,
+  parseRequestWithdrawVaultInstruction,
+  parseUpdateProtocolInstruction,
+  parseUpdateVaultConfigInstruction,
+  parseUpdateVaultProtocolFeeInstruction,
+  parseWithdrawStrategyInstruction,
+  parseWithdrawVaultInstruction,
+  type AcceptProtocolAdminAsyncInput,
+  type AcceptVaultAdminInput,
+  type AddAdaptorAsyncInput,
+  type CalibrateHighWaterMarkAsyncInput,
+  type CalibrateHighWaterMarkUnsafeAsyncInput,
+  type CancelRequestWithdrawVaultAsyncInput,
+  type CloseStrategyAsyncInput,
+  type CreateLpMetadataAsyncInput,
+  type DepositStrategyAsyncInput,
+  type DepositVaultAsyncInput,
+  type DirectWithdrawStrategyAsyncInput,
+  type DirectWithdrawStrategyWithToleranceAsyncInput,
+  type HarvestFeeAsyncInput,
+  type InitializeDirectWithdrawStrategyAsyncInput,
+  type InitializeStrategyAsyncInput,
+  type InitializeVaultAsyncInput,
+  type InitProtocolAsyncInput,
+  type InstantWithdrawStrategyAsyncInput,
+  type InstantWithdrawStrategyWithToleranceAsyncInput,
+  type InstantWithdrawVaultAsyncInput,
+  type ParsedAcceptProtocolAdminInstruction,
+  type ParsedAcceptVaultAdminInstruction,
+  type ParsedAddAdaptorInstruction,
+  type ParsedCalibrateHighWaterMarkInstruction,
+  type ParsedCalibrateHighWaterMarkUnsafeInstruction,
+  type ParsedCancelRequestWithdrawVaultInstruction,
+  type ParsedCloseStrategyInstruction,
+  type ParsedCreateLpMetadataInstruction,
+  type ParsedDepositStrategyInstruction,
+  type ParsedDepositVaultInstruction,
+  type ParsedDirectWithdrawStrategyInstruction,
+  type ParsedDirectWithdrawStrategyWithToleranceInstruction,
+  type ParsedHarvestFeeInstruction,
+  type ParsedInitializeDirectWithdrawStrategyInstruction,
+  type ParsedInitializeStrategyInstruction,
+  type ParsedInitializeVaultInstruction,
+  type ParsedInitProtocolInstruction,
+  type ParsedInstantWithdrawStrategyInstruction,
+  type ParsedInstantWithdrawStrategyWithToleranceInstruction,
+  type ParsedInstantWithdrawVaultInstruction,
+  type ParsedRemoveAdaptorInstruction,
+  type ParsedRequestWithdrawVaultInstruction,
+  type ParsedUpdateProtocolInstruction,
+  type ParsedUpdateVaultConfigInstruction,
+  type ParsedUpdateVaultProtocolFeeInstruction,
+  type ParsedWithdrawStrategyInstruction,
+  type ParsedWithdrawVaultInstruction,
+  type RemoveAdaptorAsyncInput,
+  type RequestWithdrawVaultAsyncInput,
+  type UpdateProtocolAsyncInput,
+  type UpdateVaultConfigAsyncInput,
+  type UpdateVaultProtocolFeeAsyncInput,
+  type WithdrawStrategyAsyncInput,
+  type WithdrawVaultAsyncInput,
+} from "../instructions";
+import {
+  findAdaptorAddReceiptPda,
+  findDirectWithdrawInitReceiptPda,
+  findProtocolPda,
+  findRequestWithdrawVaultReceiptPda,
+  findStrategyInitReceiptPda,
+  findVaultAssetIdleAuthPda,
+  findVaultLpMintAuthPda,
+  findVaultLpMintPda,
+  findVaultStrategyAuthPda,
+} from "../pdas";
+
+export const VOLTR_VAULT_PROGRAM_ADDRESS =
+  "vVoLTRjQmtFpiYoegx285Ze4gsLJ8ZxgFKVcuvmG1a8" as Address<"vVoLTRjQmtFpiYoegx285Ze4gsLJ8ZxgFKVcuvmG1a8">;
+
+export enum VoltrVaultAccount {
+  AdaptorAddReceipt,
+  DirectWithdrawInitReceipt,
+  Protocol,
+  RequestWithdrawVaultReceipt,
+  StrategyInitReceipt,
+  Vault,
+}
+
+export function identifyVoltrVaultAccount(
+  account: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+): VoltrVaultAccount {
+  const data = "data" in account ? account.data : account;
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([105, 99, 219, 155, 77, 241, 7, 119]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultAccount.AdaptorAddReceipt;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([206, 77, 207, 208, 25, 244, 81, 172]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultAccount.DirectWithdrawInitReceipt;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([45, 39, 101, 43, 115, 72, 131, 40]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultAccount.Protocol;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([203, 81, 223, 141, 175, 108, 101, 114]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultAccount.RequestWithdrawVaultReceipt;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([51, 8, 192, 253, 115, 78, 112, 214]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultAccount.StrategyInitReceipt;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([211, 8, 232, 43, 2, 152, 117, 119]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultAccount.Vault;
+  }
+  throw new SolanaError(
+    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
+    { accountData: data, programName: "voltrVault" },
+  );
+}
+
+export enum VoltrVaultInstruction {
+  AcceptProtocolAdmin,
+  AcceptVaultAdmin,
+  AddAdaptor,
+  CalibrateHighWaterMark,
+  CalibrateHighWaterMarkUnsafe,
+  CancelRequestWithdrawVault,
+  CloseStrategy,
+  CreateLpMetadata,
+  DepositStrategy,
+  DepositVault,
+  DirectWithdrawStrategy,
+  DirectWithdrawStrategyWithTolerance,
+  HarvestFee,
+  InitProtocol,
+  InitializeDirectWithdrawStrategy,
+  InitializeStrategy,
+  InitializeVault,
+  InstantWithdrawStrategy,
+  InstantWithdrawStrategyWithTolerance,
+  InstantWithdrawVault,
+  RemoveAdaptor,
+  RequestWithdrawVault,
+  UpdateProtocol,
+  UpdateVaultConfig,
+  UpdateVaultProtocolFee,
+  WithdrawStrategy,
+  WithdrawVault,
+}
+
+export function identifyVoltrVaultInstruction(
+  instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+): VoltrVaultInstruction {
+  const data = "data" in instruction ? instruction.data : instruction;
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([76, 35, 211, 183, 82, 72, 131, 36]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.AcceptProtocolAdmin;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([214, 137, 204, 56, 78, 214, 90, 125]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.AcceptVaultAdmin;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([161, 145, 203, 248, 211, 202, 203, 67]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.AddAdaptor;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([178, 116, 38, 9, 23, 20, 91, 154]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.CalibrateHighWaterMark;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([162, 16, 96, 202, 178, 8, 187, 235]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.CalibrateHighWaterMarkUnsafe;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([231, 54, 14, 6, 223, 124, 127, 238]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.CancelRequestWithdrawVault;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([56, 247, 170, 246, 89, 221, 134, 200]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.CloseStrategy;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([148, 193, 160, 116, 87, 25, 123, 103]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.CreateLpMetadata;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([246, 82, 57, 226, 131, 222, 253, 249]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.DepositStrategy;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([126, 224, 21, 255, 228, 53, 117, 33]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.DepositVault;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([119, 33, 54, 52, 194, 8, 211, 239]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.DirectWithdrawStrategy;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([207, 51, 234, 8, 76, 164, 10, 250]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.DirectWithdrawStrategyWithTolerance;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([32, 59, 42, 128, 246, 73, 255, 47]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.HarvestFee;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([3, 188, 141, 237, 225, 226, 232, 210]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.InitProtocol;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([248, 207, 228, 15, 13, 191, 43, 58]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.InitializeDirectWithdrawStrategy;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([208, 119, 144, 145, 178, 57, 105, 252]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.InitializeStrategy;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([48, 191, 163, 44, 71, 129, 63, 164]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.InitializeVault;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([105, 57, 166, 130, 147, 221, 250, 189]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.InstantWithdrawStrategy;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([91, 21, 70, 163, 84, 67, 106, 181]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.InstantWithdrawStrategyWithTolerance;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([221, 56, 115, 168, 128, 220, 235, 245]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.InstantWithdrawVault;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([161, 199, 99, 22, 25, 193, 61, 193]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.RemoveAdaptor;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([248, 225, 47, 22, 116, 144, 23, 143]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.RequestWithdrawVault;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([206, 25, 218, 114, 109, 41, 74, 173]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.UpdateProtocol;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([122, 3, 21, 222, 158, 255, 238, 157]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.UpdateVaultConfig;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([62, 83, 22, 192, 137, 86, 74, 18]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.UpdateVaultProtocolFee;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([31, 45, 162, 5, 193, 217, 134, 188]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.WithdrawStrategy;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([135, 7, 237, 120, 149, 94, 95, 7]),
+      ),
+      0,
+    )
+  ) {
+    return VoltrVaultInstruction.WithdrawVault;
+  }
+  throw new SolanaError(
+    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+    { instructionData: data, programName: "voltrVault" },
+  );
+}
+
+export type ParsedVoltrVaultInstruction<
+  TProgram extends string = "vVoLTRjQmtFpiYoegx285Ze4gsLJ8ZxgFKVcuvmG1a8",
+> =
+  | ({
+      instructionType: VoltrVaultInstruction.AcceptProtocolAdmin;
+    } & ParsedAcceptProtocolAdminInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.AcceptVaultAdmin;
+    } & ParsedAcceptVaultAdminInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.AddAdaptor;
+    } & ParsedAddAdaptorInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.CalibrateHighWaterMark;
+    } & ParsedCalibrateHighWaterMarkInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.CalibrateHighWaterMarkUnsafe;
+    } & ParsedCalibrateHighWaterMarkUnsafeInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.CancelRequestWithdrawVault;
+    } & ParsedCancelRequestWithdrawVaultInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.CloseStrategy;
+    } & ParsedCloseStrategyInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.CreateLpMetadata;
+    } & ParsedCreateLpMetadataInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.DepositStrategy;
+    } & ParsedDepositStrategyInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.DepositVault;
+    } & ParsedDepositVaultInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.DirectWithdrawStrategy;
+    } & ParsedDirectWithdrawStrategyInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.DirectWithdrawStrategyWithTolerance;
+    } & ParsedDirectWithdrawStrategyWithToleranceInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.HarvestFee;
+    } & ParsedHarvestFeeInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.InitProtocol;
+    } & ParsedInitProtocolInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.InitializeDirectWithdrawStrategy;
+    } & ParsedInitializeDirectWithdrawStrategyInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.InitializeStrategy;
+    } & ParsedInitializeStrategyInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.InitializeVault;
+    } & ParsedInitializeVaultInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.InstantWithdrawStrategy;
+    } & ParsedInstantWithdrawStrategyInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.InstantWithdrawStrategyWithTolerance;
+    } & ParsedInstantWithdrawStrategyWithToleranceInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.InstantWithdrawVault;
+    } & ParsedInstantWithdrawVaultInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.RemoveAdaptor;
+    } & ParsedRemoveAdaptorInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.RequestWithdrawVault;
+    } & ParsedRequestWithdrawVaultInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.UpdateProtocol;
+    } & ParsedUpdateProtocolInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.UpdateVaultConfig;
+    } & ParsedUpdateVaultConfigInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.UpdateVaultProtocolFee;
+    } & ParsedUpdateVaultProtocolFeeInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.WithdrawStrategy;
+    } & ParsedWithdrawStrategyInstruction<TProgram>)
+  | ({
+      instructionType: VoltrVaultInstruction.WithdrawVault;
+    } & ParsedWithdrawVaultInstruction<TProgram>);
+
+export function parseVoltrVaultInstruction<TProgram extends string>(
+  instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedVoltrVaultInstruction<TProgram> {
+  const instructionType = identifyVoltrVaultInstruction(instruction);
+  switch (instructionType) {
+    case VoltrVaultInstruction.AcceptProtocolAdmin: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.AcceptProtocolAdmin,
+        ...parseAcceptProtocolAdminInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.AcceptVaultAdmin: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.AcceptVaultAdmin,
+        ...parseAcceptVaultAdminInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.AddAdaptor: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.AddAdaptor,
+        ...parseAddAdaptorInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.CalibrateHighWaterMark: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.CalibrateHighWaterMark,
+        ...parseCalibrateHighWaterMarkInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.CalibrateHighWaterMarkUnsafe: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.CalibrateHighWaterMarkUnsafe,
+        ...parseCalibrateHighWaterMarkUnsafeInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.CancelRequestWithdrawVault: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.CancelRequestWithdrawVault,
+        ...parseCancelRequestWithdrawVaultInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.CloseStrategy: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.CloseStrategy,
+        ...parseCloseStrategyInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.CreateLpMetadata: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.CreateLpMetadata,
+        ...parseCreateLpMetadataInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.DepositStrategy: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.DepositStrategy,
+        ...parseDepositStrategyInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.DepositVault: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.DepositVault,
+        ...parseDepositVaultInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.DirectWithdrawStrategy: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.DirectWithdrawStrategy,
+        ...parseDirectWithdrawStrategyInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.DirectWithdrawStrategyWithTolerance: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType:
+          VoltrVaultInstruction.DirectWithdrawStrategyWithTolerance,
+        ...parseDirectWithdrawStrategyWithToleranceInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.HarvestFee: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.HarvestFee,
+        ...parseHarvestFeeInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.InitProtocol: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.InitProtocol,
+        ...parseInitProtocolInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.InitializeDirectWithdrawStrategy: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.InitializeDirectWithdrawStrategy,
+        ...parseInitializeDirectWithdrawStrategyInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.InitializeStrategy: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.InitializeStrategy,
+        ...parseInitializeStrategyInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.InitializeVault: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.InitializeVault,
+        ...parseInitializeVaultInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.InstantWithdrawStrategy: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.InstantWithdrawStrategy,
+        ...parseInstantWithdrawStrategyInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.InstantWithdrawStrategyWithTolerance: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType:
+          VoltrVaultInstruction.InstantWithdrawStrategyWithTolerance,
+        ...parseInstantWithdrawStrategyWithToleranceInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.InstantWithdrawVault: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.InstantWithdrawVault,
+        ...parseInstantWithdrawVaultInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.RemoveAdaptor: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.RemoveAdaptor,
+        ...parseRemoveAdaptorInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.RequestWithdrawVault: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.RequestWithdrawVault,
+        ...parseRequestWithdrawVaultInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.UpdateProtocol: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.UpdateProtocol,
+        ...parseUpdateProtocolInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.UpdateVaultConfig: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.UpdateVaultConfig,
+        ...parseUpdateVaultConfigInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.UpdateVaultProtocolFee: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.UpdateVaultProtocolFee,
+        ...parseUpdateVaultProtocolFeeInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.WithdrawStrategy: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.WithdrawStrategy,
+        ...parseWithdrawStrategyInstruction(instruction),
+      };
+    }
+    case VoltrVaultInstruction.WithdrawVault: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: VoltrVaultInstruction.WithdrawVault,
+        ...parseWithdrawVaultInstruction(instruction),
+      };
+    }
+    default:
+      throw new SolanaError(
+        SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+        {
+          instructionType: instructionType as string,
+          programName: "voltrVault",
+        },
+      );
+  }
+}
+
+export type VoltrVaultPlugin = {
+  accounts: VoltrVaultPluginAccounts;
+  instructions: VoltrVaultPluginInstructions;
+  pdas: VoltrVaultPluginPdas;
+};
+
+export type VoltrVaultPluginAccounts = {
+  adaptorAddReceipt: ReturnType<typeof getAdaptorAddReceiptCodec> &
+    SelfFetchFunctions<AdaptorAddReceiptArgs, AdaptorAddReceipt>;
+  directWithdrawInitReceipt: ReturnType<
+    typeof getDirectWithdrawInitReceiptCodec
+  > &
+    SelfFetchFunctions<
+      DirectWithdrawInitReceiptArgs,
+      DirectWithdrawInitReceipt
+    >;
+  protocol: ReturnType<typeof getProtocolCodec> &
+    SelfFetchFunctions<ProtocolArgs, Protocol>;
+  requestWithdrawVaultReceipt: ReturnType<
+    typeof getRequestWithdrawVaultReceiptCodec
+  > &
+    SelfFetchFunctions<
+      RequestWithdrawVaultReceiptArgs,
+      RequestWithdrawVaultReceipt
+    >;
+  strategyInitReceipt: ReturnType<typeof getStrategyInitReceiptCodec> &
+    SelfFetchFunctions<StrategyInitReceiptArgs, StrategyInitReceipt>;
+  vault: ReturnType<typeof getVaultCodec> &
+    SelfFetchFunctions<VaultArgs, Vault>;
+};
+
+export type VoltrVaultPluginInstructions = {
+  acceptProtocolAdmin: (
+    input: AcceptProtocolAdminAsyncInput,
+  ) => ReturnType<typeof getAcceptProtocolAdminInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  acceptVaultAdmin: (
+    input: AcceptVaultAdminInput,
+  ) => ReturnType<typeof getAcceptVaultAdminInstruction> &
+    SelfPlanAndSendFunctions;
+  addAdaptor: (
+    input: MakeOptional<AddAdaptorAsyncInput, "payer">,
+  ) => ReturnType<typeof getAddAdaptorInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  calibrateHighWaterMark: (
+    input: CalibrateHighWaterMarkAsyncInput,
+  ) => ReturnType<typeof getCalibrateHighWaterMarkInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  calibrateHighWaterMarkUnsafe: (
+    input: CalibrateHighWaterMarkUnsafeAsyncInput,
+  ) => ReturnType<typeof getCalibrateHighWaterMarkUnsafeInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  cancelRequestWithdrawVault: (
+    input: CancelRequestWithdrawVaultAsyncInput,
+  ) => ReturnType<typeof getCancelRequestWithdrawVaultInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  closeStrategy: (
+    input: MakeOptional<CloseStrategyAsyncInput, "payer">,
+  ) => ReturnType<typeof getCloseStrategyInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  createLpMetadata: (
+    input: MakeOptional<CreateLpMetadataAsyncInput, "payer">,
+  ) => ReturnType<typeof getCreateLpMetadataInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  depositStrategy: (
+    input: DepositStrategyAsyncInput,
+  ) => ReturnType<typeof getDepositStrategyInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  depositVault: (
+    input: DepositVaultAsyncInput,
+  ) => ReturnType<typeof getDepositVaultInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  directWithdrawStrategy: (
+    input: DirectWithdrawStrategyAsyncInput,
+  ) => ReturnType<typeof getDirectWithdrawStrategyInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  directWithdrawStrategyWithTolerance: (
+    input: DirectWithdrawStrategyWithToleranceAsyncInput,
+  ) => ReturnType<
+    typeof getDirectWithdrawStrategyWithToleranceInstructionAsync
+  > &
+    SelfPlanAndSendFunctions;
+  harvestFee: (
+    input: HarvestFeeAsyncInput,
+  ) => ReturnType<typeof getHarvestFeeInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  initProtocol: (
+    input: MakeOptional<InitProtocolAsyncInput, "payer">,
+  ) => ReturnType<typeof getInitProtocolInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  initializeDirectWithdrawStrategy: (
+    input: MakeOptional<InitializeDirectWithdrawStrategyAsyncInput, "payer">,
+  ) => ReturnType<typeof getInitializeDirectWithdrawStrategyInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  initializeStrategy: (
+    input: MakeOptional<InitializeStrategyAsyncInput, "payer">,
+  ) => ReturnType<typeof getInitializeStrategyInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  initializeVault: (
+    input: MakeOptional<InitializeVaultAsyncInput, "payer">,
+  ) => ReturnType<typeof getInitializeVaultInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  instantWithdrawStrategy: (
+    input: InstantWithdrawStrategyAsyncInput,
+  ) => ReturnType<typeof getInstantWithdrawStrategyInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  instantWithdrawStrategyWithTolerance: (
+    input: InstantWithdrawStrategyWithToleranceAsyncInput,
+  ) => ReturnType<
+    typeof getInstantWithdrawStrategyWithToleranceInstructionAsync
+  > &
+    SelfPlanAndSendFunctions;
+  instantWithdrawVault: (
+    input: InstantWithdrawVaultAsyncInput,
+  ) => ReturnType<typeof getInstantWithdrawVaultInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  removeAdaptor: (
+    input: RemoveAdaptorAsyncInput,
+  ) => ReturnType<typeof getRemoveAdaptorInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  requestWithdrawVault: (
+    input: MakeOptional<RequestWithdrawVaultAsyncInput, "payer">,
+  ) => ReturnType<typeof getRequestWithdrawVaultInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  updateProtocol: (
+    input: UpdateProtocolAsyncInput,
+  ) => ReturnType<typeof getUpdateProtocolInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  updateVaultConfig: (
+    input: UpdateVaultConfigAsyncInput,
+  ) => ReturnType<typeof getUpdateVaultConfigInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  updateVaultProtocolFee: (
+    input: UpdateVaultProtocolFeeAsyncInput,
+  ) => ReturnType<typeof getUpdateVaultProtocolFeeInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  withdrawStrategy: (
+    input: WithdrawStrategyAsyncInput,
+  ) => ReturnType<typeof getWithdrawStrategyInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  withdrawVault: (
+    input: WithdrawVaultAsyncInput,
+  ) => ReturnType<typeof getWithdrawVaultInstructionAsync> &
+    SelfPlanAndSendFunctions;
+};
+
+export type VoltrVaultPluginPdas = {
+  protocol: typeof findProtocolPda;
+  adaptorAddReceipt: typeof findAdaptorAddReceiptPda;
+  vaultLpMint: typeof findVaultLpMintPda;
+  requestWithdrawVaultReceipt: typeof findRequestWithdrawVaultReceiptPda;
+  strategyInitReceipt: typeof findStrategyInitReceiptPda;
+  vaultLpMintAuth: typeof findVaultLpMintAuthPda;
+  vaultAssetIdleAuth: typeof findVaultAssetIdleAuthPda;
+  vaultStrategyAuth: typeof findVaultStrategyAuthPda;
+  directWithdrawInitReceipt: typeof findDirectWithdrawInitReceiptPda;
+};
+
+export type VoltrVaultPluginRequirements = ClientWithRpc<
+  GetAccountInfoApi & GetMultipleAccountsApi
+> &
+  ClientWithPayer &
+  ClientWithTransactionPlanning &
+  ClientWithTransactionSending;
+
+export function voltrVaultProgram() {
+  return <T extends VoltrVaultPluginRequirements>(client: T) => {
+    return {
+      ...client,
+      voltrVault: <VoltrVaultPlugin>{
+        accounts: {
+          adaptorAddReceipt: addSelfFetchFunctions(
+            client,
+            getAdaptorAddReceiptCodec(),
+          ),
+          directWithdrawInitReceipt: addSelfFetchFunctions(
+            client,
+            getDirectWithdrawInitReceiptCodec(),
+          ),
+          protocol: addSelfFetchFunctions(client, getProtocolCodec()),
+          requestWithdrawVaultReceipt: addSelfFetchFunctions(
+            client,
+            getRequestWithdrawVaultReceiptCodec(),
+          ),
+          strategyInitReceipt: addSelfFetchFunctions(
+            client,
+            getStrategyInitReceiptCodec(),
+          ),
+          vault: addSelfFetchFunctions(client, getVaultCodec()),
+        },
+        instructions: {
+          acceptProtocolAdmin: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getAcceptProtocolAdminInstructionAsync(input),
+            ),
+          acceptVaultAdmin: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getAcceptVaultAdminInstruction(input),
+            ),
+          addAdaptor: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getAddAdaptorInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          calibrateHighWaterMark: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getCalibrateHighWaterMarkInstructionAsync(input),
+            ),
+          calibrateHighWaterMarkUnsafe: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getCalibrateHighWaterMarkUnsafeInstructionAsync(input),
+            ),
+          cancelRequestWithdrawVault: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getCancelRequestWithdrawVaultInstructionAsync(input),
+            ),
+          closeStrategy: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getCloseStrategyInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          createLpMetadata: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getCreateLpMetadataInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          depositStrategy: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getDepositStrategyInstructionAsync(input),
+            ),
+          depositVault: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getDepositVaultInstructionAsync(input),
+            ),
+          directWithdrawStrategy: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getDirectWithdrawStrategyInstructionAsync(input),
+            ),
+          directWithdrawStrategyWithTolerance: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getDirectWithdrawStrategyWithToleranceInstructionAsync(input),
+            ),
+          harvestFee: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getHarvestFeeInstructionAsync(input),
+            ),
+          initProtocol: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getInitProtocolInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          initializeDirectWithdrawStrategy: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getInitializeDirectWithdrawStrategyInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          initializeStrategy: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getInitializeStrategyInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          initializeVault: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getInitializeVaultInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          instantWithdrawStrategy: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getInstantWithdrawStrategyInstructionAsync(input),
+            ),
+          instantWithdrawStrategyWithTolerance: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getInstantWithdrawStrategyWithToleranceInstructionAsync(input),
+            ),
+          instantWithdrawVault: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getInstantWithdrawVaultInstructionAsync(input),
+            ),
+          removeAdaptor: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getRemoveAdaptorInstructionAsync(input),
+            ),
+          requestWithdrawVault: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getRequestWithdrawVaultInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          updateProtocol: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getUpdateProtocolInstructionAsync(input),
+            ),
+          updateVaultConfig: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getUpdateVaultConfigInstructionAsync(input),
+            ),
+          updateVaultProtocolFee: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getUpdateVaultProtocolFeeInstructionAsync(input),
+            ),
+          withdrawStrategy: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getWithdrawStrategyInstructionAsync(input),
+            ),
+          withdrawVault: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getWithdrawVaultInstructionAsync(input),
+            ),
+        },
+        pdas: {
+          protocol: findProtocolPda,
+          adaptorAddReceipt: findAdaptorAddReceiptPda,
+          vaultLpMint: findVaultLpMintPda,
+          requestWithdrawVaultReceipt: findRequestWithdrawVaultReceiptPda,
+          strategyInitReceipt: findStrategyInitReceiptPda,
+          vaultLpMintAuth: findVaultLpMintAuthPda,
+          vaultAssetIdleAuth: findVaultAssetIdleAuthPda,
+          vaultStrategyAuth: findVaultStrategyAuthPda,
+          directWithdrawInitReceipt: findDirectWithdrawInitReceiptPda,
+        },
+      },
+    };
+  };
+}
+
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;