@macalinao/clients-mpl-bubblegum 0.0.0 → 0.3.0

package/src/generated/programs/bubblegum.ts

@@ -0,0 +1,1509 @@
+/**
+ * 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 type {
+  Address,
+  ClientWithPayer,
+  ClientWithRpc,
+  ClientWithTransactionPlanning,
+  ClientWithTransactionSending,
+  GetAccountInfoApi,
+  GetMultipleAccountsApi,
+  Instruction,
+  InstructionWithData,
+  ReadonlyUint8Array,
+} from "@solana/kit";
+import type {
+  SelfFetchFunctions,
+  SelfPlanAndSendFunctions,
+} from "@solana/program-client-core";
+import type {
+  TreeConfig,
+  TreeConfigArgs,
+  Voucher,
+  VoucherArgs,
+} from "../accounts/index.js";
+import type {
+  BurnAsyncInput,
+  BurnV2AsyncInput,
+  CancelRedeemAsyncInput,
+  CloseTreeV2AsyncInput,
+  CollectV2Input,
+  CompressAsyncInput,
+  CreateTreeAsyncInput,
+  CreateTreeV2AsyncInput,
+  DecompressV1AsyncInput,
+  DelegateAndFreezeV2AsyncInput,
+  DelegateAsyncInput,
+  DelegateV2AsyncInput,
+  FreezeV2AsyncInput,
+  MintToCollectionV1AsyncInput,
+  MintV1AsyncInput,
+  MintV2AsyncInput,
+  ParsedBurnInstruction,
+  ParsedBurnV2Instruction,
+  ParsedCancelRedeemInstruction,
+  ParsedCloseTreeV2Instruction,
+  ParsedCollectV2Instruction,
+  ParsedCompressInstruction,
+  ParsedCreateTreeInstruction,
+  ParsedCreateTreeV2Instruction,
+  ParsedDecompressV1Instruction,
+  ParsedDelegateAndFreezeV2Instruction,
+  ParsedDelegateInstruction,
+  ParsedDelegateV2Instruction,
+  ParsedFreezeV2Instruction,
+  ParsedMintToCollectionV1Instruction,
+  ParsedMintV1Instruction,
+  ParsedMintV2Instruction,
+  ParsedRedeemInstruction,
+  ParsedSetAndVerifyCollectionInstruction,
+  ParsedSetCollectionV2Instruction,
+  ParsedSetDecompressableStateInstruction,
+  ParsedSetDecompressibleStateInstruction,
+  ParsedSetNonTransferableV2Instruction,
+  ParsedSetTreeDelegateInstruction,
+  ParsedThawAndRevokeV2Instruction,
+  ParsedThawV2Instruction,
+  ParsedTransferInstruction,
+  ParsedTransferV2Instruction,
+  ParsedUnverifyCollectionInstruction,
+  ParsedUnverifyCreatorInstruction,
+  ParsedUnverifyCreatorV2Instruction,
+  ParsedUpdateAssetDataV2Instruction,
+  ParsedUpdateMetadataInstruction,
+  ParsedUpdateMetadataV2Instruction,
+  ParsedVerifyCollectionInstruction,
+  ParsedVerifyCreatorInstruction,
+  ParsedVerifyCreatorV2Instruction,
+  RedeemAsyncInput,
+  SetAndVerifyCollectionAsyncInput,
+  SetCollectionV2AsyncInput,
+  SetDecompressableStateInput,
+  SetDecompressibleStateInput,
+  SetNonTransferableV2AsyncInput,
+  SetTreeDelegateAsyncInput,
+  ThawAndRevokeV2AsyncInput,
+  ThawV2AsyncInput,
+  TransferAsyncInput,
+  TransferV2AsyncInput,
+  UnverifyCollectionAsyncInput,
+  UnverifyCreatorAsyncInput,
+  UnverifyCreatorV2AsyncInput,
+  UpdateAssetDataV2AsyncInput,
+  UpdateMetadataAsyncInput,
+  UpdateMetadataV2AsyncInput,
+  VerifyCollectionAsyncInput,
+  VerifyCreatorAsyncInput,
+  VerifyCreatorV2AsyncInput,
+} from "../instructions/index.js";
+import {
+  assertIsInstructionWithAccounts,
+  containsBytes,
+  extendClient,
+  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,
+} from "@solana/kit";
+import {
+  addSelfFetchFunctions,
+  addSelfPlanAndSendFunctions,
+} from "@solana/program-client-core";
+import { getTreeConfigCodec, getVoucherCodec } from "../accounts/index.js";
+import {
+  getBurnInstructionAsync,
+  getBurnV2InstructionAsync,
+  getCancelRedeemInstructionAsync,
+  getCloseTreeV2InstructionAsync,
+  getCollectV2Instruction,
+  getCompressInstructionAsync,
+  getCreateTreeInstructionAsync,
+  getCreateTreeV2InstructionAsync,
+  getDecompressV1InstructionAsync,
+  getDelegateAndFreezeV2InstructionAsync,
+  getDelegateInstructionAsync,
+  getDelegateV2InstructionAsync,
+  getFreezeV2InstructionAsync,
+  getMintToCollectionV1InstructionAsync,
+  getMintV1InstructionAsync,
+  getMintV2InstructionAsync,
+  getRedeemInstructionAsync,
+  getSetAndVerifyCollectionInstructionAsync,
+  getSetCollectionV2InstructionAsync,
+  getSetDecompressableStateInstruction,
+  getSetDecompressibleStateInstruction,
+  getSetNonTransferableV2InstructionAsync,
+  getSetTreeDelegateInstructionAsync,
+  getThawAndRevokeV2InstructionAsync,
+  getThawV2InstructionAsync,
+  getTransferInstructionAsync,
+  getTransferV2InstructionAsync,
+  getUnverifyCollectionInstructionAsync,
+  getUnverifyCreatorInstructionAsync,
+  getUnverifyCreatorV2InstructionAsync,
+  getUpdateAssetDataV2InstructionAsync,
+  getUpdateMetadataInstructionAsync,
+  getUpdateMetadataV2InstructionAsync,
+  getVerifyCollectionInstructionAsync,
+  getVerifyCreatorInstructionAsync,
+  getVerifyCreatorV2InstructionAsync,
+  parseBurnInstruction,
+  parseBurnV2Instruction,
+  parseCancelRedeemInstruction,
+  parseCloseTreeV2Instruction,
+  parseCollectV2Instruction,
+  parseCompressInstruction,
+  parseCreateTreeInstruction,
+  parseCreateTreeV2Instruction,
+  parseDecompressV1Instruction,
+  parseDelegateAndFreezeV2Instruction,
+  parseDelegateInstruction,
+  parseDelegateV2Instruction,
+  parseFreezeV2Instruction,
+  parseMintToCollectionV1Instruction,
+  parseMintV1Instruction,
+  parseMintV2Instruction,
+  parseRedeemInstruction,
+  parseSetAndVerifyCollectionInstruction,
+  parseSetCollectionV2Instruction,
+  parseSetDecompressableStateInstruction,
+  parseSetDecompressibleStateInstruction,
+  parseSetNonTransferableV2Instruction,
+  parseSetTreeDelegateInstruction,
+  parseThawAndRevokeV2Instruction,
+  parseThawV2Instruction,
+  parseTransferInstruction,
+  parseTransferV2Instruction,
+  parseUnverifyCollectionInstruction,
+  parseUnverifyCreatorInstruction,
+  parseUnverifyCreatorV2Instruction,
+  parseUpdateAssetDataV2Instruction,
+  parseUpdateMetadataInstruction,
+  parseUpdateMetadataV2Instruction,
+  parseVerifyCollectionInstruction,
+  parseVerifyCreatorInstruction,
+  parseVerifyCreatorV2Instruction,
+} from "../instructions/index.js";
+import {
+  findAssetIdPda,
+  findBubblegumSignerPda,
+  findMintAuthorityPda,
+  findTreeConfigPda,
+  findVoucherPda,
+} from "../pdas/index.js";
+
+export const BUBBLEGUM_PROGRAM_ADDRESS =
+  "BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY" as Address<"BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY">;
+
+export enum BubblegumAccount {
+  TreeConfig = 0,
+  Voucher = 1,
+}
+
+export function identifyBubblegumAccount(
+  account: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+): BubblegumAccount {
+  const data = "data" in account ? account.data : account;
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([122, 245, 175, 248, 171, 34, 0, 207]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumAccount.TreeConfig;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([191, 204, 149, 234, 213, 165, 13, 65]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumAccount.Voucher;
+  }
+  throw new SolanaError(
+    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
+    { accountData: data, programName: "bubblegum" },
+  );
+}
+
+export enum BubblegumInstruction {
+  Burn = 0,
+  BurnV2 = 1,
+  CancelRedeem = 2,
+  CloseTreeV2 = 3,
+  CollectV2 = 4,
+  Compress = 5,
+  CreateTree = 6,
+  CreateTreeV2 = 7,
+  DecompressV1 = 8,
+  Delegate = 9,
+  DelegateAndFreezeV2 = 10,
+  DelegateV2 = 11,
+  FreezeV2 = 12,
+  MintToCollectionV1 = 13,
+  MintV1 = 14,
+  MintV2 = 15,
+  Redeem = 16,
+  SetAndVerifyCollection = 17,
+  SetCollectionV2 = 18,
+  SetDecompressableState = 19,
+  SetDecompressibleState = 20,
+  SetNonTransferableV2 = 21,
+  SetTreeDelegate = 22,
+  ThawAndRevokeV2 = 23,
+  ThawV2 = 24,
+  Transfer = 25,
+  TransferV2 = 26,
+  UnverifyCollection = 27,
+  UnverifyCreator = 28,
+  UnverifyCreatorV2 = 29,
+  UpdateAssetDataV2 = 30,
+  UpdateMetadata = 31,
+  UpdateMetadataV2 = 32,
+  VerifyCollection = 33,
+  VerifyCreator = 34,
+  VerifyCreatorV2 = 35,
+}
+
+export function identifyBubblegumInstruction(
+  instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+): BubblegumInstruction {
+  const data = "data" in instruction ? instruction.data : instruction;
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([116, 110, 29, 56, 107, 219, 42, 93]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.Burn;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([115, 210, 34, 240, 232, 143, 183, 16]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.BurnV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([111, 76, 232, 50, 39, 175, 48, 242]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.CancelRedeem;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([45, 172, 6, 94, 28, 90, 157, 70]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.CloseTreeV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([21, 11, 159, 47, 4, 195, 106, 56]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.CollectV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([82, 193, 176, 117, 176, 21, 115, 253]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.Compress;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([165, 83, 136, 142, 89, 202, 47, 220]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.CreateTree;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([55, 99, 95, 215, 142, 203, 227, 205]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.CreateTreeV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([54, 85, 76, 70, 228, 250, 164, 81]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.DecompressV1;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([90, 147, 75, 178, 85, 88, 4, 137]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.Delegate;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([17, 229, 35, 218, 190, 241, 250, 123]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.DelegateAndFreezeV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([95, 87, 125, 140, 181, 131, 128, 227]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.DelegateV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([200, 151, 244, 102, 16, 195, 255, 3]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.FreezeV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([153, 18, 178, 47, 197, 158, 86, 15]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.MintToCollectionV1;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([145, 98, 192, 118, 184, 147, 118, 104]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.MintV1;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([120, 121, 23, 146, 173, 110, 199, 205]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.MintV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([184, 12, 86, 149, 70, 196, 97, 225]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.Redeem;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([235, 242, 121, 216, 158, 234, 180, 234]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.SetAndVerifyCollection;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([229, 35, 61, 91, 15, 14, 99, 160]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.SetCollectionV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([18, 135, 238, 168, 246, 195, 61, 115]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.SetDecompressableState;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([82, 104, 152, 6, 149, 111, 100, 13]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.SetDecompressibleState;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([181, 141, 206, 58, 242, 199, 152, 168]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.SetNonTransferableV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([253, 118, 66, 37, 190, 49, 154, 102]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.SetTreeDelegate;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([86, 214, 190, 37, 167, 4, 28, 116]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.ThawAndRevokeV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([96, 133, 101, 93, 82, 220, 146, 191]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.ThawV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([163, 52, 200, 231, 140, 3, 69, 186]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.Transfer;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([119, 40, 6, 235, 234, 221, 248, 49]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.TransferV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([250, 251, 42, 106, 41, 137, 186, 168]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.UnverifyCollection;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([107, 178, 57, 39, 105, 115, 112, 152]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.UnverifyCreator;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([174, 112, 29, 142, 230, 100, 239, 7]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.UnverifyCreatorV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([59, 56, 111, 43, 95, 14, 11, 61]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.UpdateAssetDataV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([170, 182, 43, 239, 97, 78, 225, 186]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.UpdateMetadata;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([43, 103, 89, 42, 121, 242, 62, 72]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.UpdateMetadataV2;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([56, 113, 101, 253, 79, 55, 122, 169]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.VerifyCollection;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([52, 17, 96, 132, 71, 4, 85, 194]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.VerifyCreator;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(
+        new Uint8Array([85, 138, 140, 42, 22, 241, 118, 102]),
+      ),
+      0,
+    )
+  ) {
+    return BubblegumInstruction.VerifyCreatorV2;
+  }
+  throw new SolanaError(
+    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+    { instructionData: data, programName: "bubblegum" },
+  );
+}
+
+export type ParsedBubblegumInstruction<
+  TProgram extends string = "BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY",
+> =
+  | ({
+      instructionType: BubblegumInstruction.Burn;
+    } & ParsedBurnInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.BurnV2;
+    } & ParsedBurnV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.CancelRedeem;
+    } & ParsedCancelRedeemInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.CloseTreeV2;
+    } & ParsedCloseTreeV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.CollectV2;
+    } & ParsedCollectV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.Compress;
+    } & ParsedCompressInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.CreateTree;
+    } & ParsedCreateTreeInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.CreateTreeV2;
+    } & ParsedCreateTreeV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.DecompressV1;
+    } & ParsedDecompressV1Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.Delegate;
+    } & ParsedDelegateInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.DelegateAndFreezeV2;
+    } & ParsedDelegateAndFreezeV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.DelegateV2;
+    } & ParsedDelegateV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.FreezeV2;
+    } & ParsedFreezeV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.MintToCollectionV1;
+    } & ParsedMintToCollectionV1Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.MintV1;
+    } & ParsedMintV1Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.MintV2;
+    } & ParsedMintV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.Redeem;
+    } & ParsedRedeemInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.SetAndVerifyCollection;
+    } & ParsedSetAndVerifyCollectionInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.SetCollectionV2;
+    } & ParsedSetCollectionV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.SetDecompressableState;
+    } & ParsedSetDecompressableStateInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.SetDecompressibleState;
+    } & ParsedSetDecompressibleStateInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.SetNonTransferableV2;
+    } & ParsedSetNonTransferableV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.SetTreeDelegate;
+    } & ParsedSetTreeDelegateInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.ThawAndRevokeV2;
+    } & ParsedThawAndRevokeV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.ThawV2;
+    } & ParsedThawV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.Transfer;
+    } & ParsedTransferInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.TransferV2;
+    } & ParsedTransferV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.UnverifyCollection;
+    } & ParsedUnverifyCollectionInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.UnverifyCreator;
+    } & ParsedUnverifyCreatorInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.UnverifyCreatorV2;
+    } & ParsedUnverifyCreatorV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.UpdateAssetDataV2;
+    } & ParsedUpdateAssetDataV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.UpdateMetadata;
+    } & ParsedUpdateMetadataInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.UpdateMetadataV2;
+    } & ParsedUpdateMetadataV2Instruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.VerifyCollection;
+    } & ParsedVerifyCollectionInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.VerifyCreator;
+    } & ParsedVerifyCreatorInstruction<TProgram>)
+  | ({
+      instructionType: BubblegumInstruction.VerifyCreatorV2;
+    } & ParsedVerifyCreatorV2Instruction<TProgram>);
+
+export function parseBubblegumInstruction<TProgram extends string>(
+  instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedBubblegumInstruction<TProgram> {
+  const instructionType = identifyBubblegumInstruction(instruction);
+  switch (instructionType) {
+    case BubblegumInstruction.Burn: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.Burn,
+        ...parseBurnInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.BurnV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.BurnV2,
+        ...parseBurnV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.CancelRedeem: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.CancelRedeem,
+        ...parseCancelRedeemInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.CloseTreeV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.CloseTreeV2,
+        ...parseCloseTreeV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.CollectV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.CollectV2,
+        ...parseCollectV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.Compress: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.Compress,
+        ...parseCompressInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.CreateTree: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.CreateTree,
+        ...parseCreateTreeInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.CreateTreeV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.CreateTreeV2,
+        ...parseCreateTreeV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.DecompressV1: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.DecompressV1,
+        ...parseDecompressV1Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.Delegate: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.Delegate,
+        ...parseDelegateInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.DelegateAndFreezeV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.DelegateAndFreezeV2,
+        ...parseDelegateAndFreezeV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.DelegateV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.DelegateV2,
+        ...parseDelegateV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.FreezeV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.FreezeV2,
+        ...parseFreezeV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.MintToCollectionV1: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.MintToCollectionV1,
+        ...parseMintToCollectionV1Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.MintV1: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.MintV1,
+        ...parseMintV1Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.MintV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.MintV2,
+        ...parseMintV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.Redeem: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.Redeem,
+        ...parseRedeemInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.SetAndVerifyCollection: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.SetAndVerifyCollection,
+        ...parseSetAndVerifyCollectionInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.SetCollectionV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.SetCollectionV2,
+        ...parseSetCollectionV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.SetDecompressableState: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.SetDecompressableState,
+        ...parseSetDecompressableStateInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.SetDecompressibleState: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.SetDecompressibleState,
+        ...parseSetDecompressibleStateInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.SetNonTransferableV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.SetNonTransferableV2,
+        ...parseSetNonTransferableV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.SetTreeDelegate: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.SetTreeDelegate,
+        ...parseSetTreeDelegateInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.ThawAndRevokeV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.ThawAndRevokeV2,
+        ...parseThawAndRevokeV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.ThawV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.ThawV2,
+        ...parseThawV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.Transfer: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.Transfer,
+        ...parseTransferInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.TransferV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.TransferV2,
+        ...parseTransferV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.UnverifyCollection: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.UnverifyCollection,
+        ...parseUnverifyCollectionInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.UnverifyCreator: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.UnverifyCreator,
+        ...parseUnverifyCreatorInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.UnverifyCreatorV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.UnverifyCreatorV2,
+        ...parseUnverifyCreatorV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.UpdateAssetDataV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.UpdateAssetDataV2,
+        ...parseUpdateAssetDataV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.UpdateMetadata: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.UpdateMetadata,
+        ...parseUpdateMetadataInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.UpdateMetadataV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.UpdateMetadataV2,
+        ...parseUpdateMetadataV2Instruction(instruction),
+      };
+    }
+    case BubblegumInstruction.VerifyCollection: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.VerifyCollection,
+        ...parseVerifyCollectionInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.VerifyCreator: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.VerifyCreator,
+        ...parseVerifyCreatorInstruction(instruction),
+      };
+    }
+    case BubblegumInstruction.VerifyCreatorV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: BubblegumInstruction.VerifyCreatorV2,
+        ...parseVerifyCreatorV2Instruction(instruction),
+      };
+    }
+    default:
+      throw new SolanaError(
+        SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+        {
+          instructionType: instructionType as string,
+          programName: "bubblegum",
+        },
+      );
+  }
+}
+
+export interface BubblegumPlugin {
+  accounts: BubblegumPluginAccounts;
+  instructions: BubblegumPluginInstructions;
+  pdas: BubblegumPluginPdas;
+}
+
+export interface BubblegumPluginAccounts {
+  treeConfig: ReturnType<typeof getTreeConfigCodec> &
+    SelfFetchFunctions<TreeConfigArgs, TreeConfig>;
+  voucher: ReturnType<typeof getVoucherCodec> &
+    SelfFetchFunctions<VoucherArgs, Voucher>;
+}
+
+export interface BubblegumPluginInstructions {
+  burn: (
+    input: BurnAsyncInput,
+  ) => ReturnType<typeof getBurnInstructionAsync> & SelfPlanAndSendFunctions;
+  burnV2: (
+    input: MakeOptional<BurnV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getBurnV2InstructionAsync> & SelfPlanAndSendFunctions;
+  cancelRedeem: (
+    input: CancelRedeemAsyncInput,
+  ) => ReturnType<typeof getCancelRedeemInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  closeTreeV2: (
+    input: CloseTreeV2AsyncInput,
+  ) => ReturnType<typeof getCloseTreeV2InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  collectV2: (
+    input: CollectV2Input,
+  ) => ReturnType<typeof getCollectV2Instruction> & SelfPlanAndSendFunctions;
+  compress: (
+    input: MakeOptional<CompressAsyncInput, "payer">,
+  ) => ReturnType<typeof getCompressInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  createTree: (
+    input: MakeOptional<CreateTreeAsyncInput, "payer">,
+  ) => ReturnType<typeof getCreateTreeInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  createTreeV2: (
+    input: MakeOptional<CreateTreeV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getCreateTreeV2InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  decompressV1: (
+    input: DecompressV1AsyncInput,
+  ) => ReturnType<typeof getDecompressV1InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  delegate: (
+    input: DelegateAsyncInput,
+  ) => ReturnType<typeof getDelegateInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  delegateAndFreezeV2: (
+    input: MakeOptional<DelegateAndFreezeV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getDelegateAndFreezeV2InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  delegateV2: (
+    input: MakeOptional<DelegateV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getDelegateV2InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  freezeV2: (
+    input: MakeOptional<FreezeV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getFreezeV2InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  mintToCollectionV1: (
+    input: MakeOptional<MintToCollectionV1AsyncInput, "payer">,
+  ) => ReturnType<typeof getMintToCollectionV1InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  mintV1: (
+    input: MakeOptional<MintV1AsyncInput, "payer">,
+  ) => ReturnType<typeof getMintV1InstructionAsync> & SelfPlanAndSendFunctions;
+  mintV2: (
+    input: MakeOptional<MintV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getMintV2InstructionAsync> & SelfPlanAndSendFunctions;
+  redeem: (
+    input: RedeemAsyncInput,
+  ) => ReturnType<typeof getRedeemInstructionAsync> & SelfPlanAndSendFunctions;
+  setAndVerifyCollection: (
+    input: MakeOptional<SetAndVerifyCollectionAsyncInput, "payer">,
+  ) => ReturnType<typeof getSetAndVerifyCollectionInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  setCollectionV2: (
+    input: MakeOptional<SetCollectionV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getSetCollectionV2InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  setDecompressableState: (
+    input: SetDecompressableStateInput,
+  ) => ReturnType<typeof getSetDecompressableStateInstruction> &
+    SelfPlanAndSendFunctions;
+  setDecompressibleState: (
+    input: SetDecompressibleStateInput,
+  ) => ReturnType<typeof getSetDecompressibleStateInstruction> &
+    SelfPlanAndSendFunctions;
+  setNonTransferableV2: (
+    input: MakeOptional<SetNonTransferableV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getSetNonTransferableV2InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  setTreeDelegate: (
+    input: SetTreeDelegateAsyncInput,
+  ) => ReturnType<typeof getSetTreeDelegateInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  thawAndRevokeV2: (
+    input: MakeOptional<ThawAndRevokeV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getThawAndRevokeV2InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  thawV2: (
+    input: MakeOptional<ThawV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getThawV2InstructionAsync> & SelfPlanAndSendFunctions;
+  transfer: (
+    input: TransferAsyncInput,
+  ) => ReturnType<typeof getTransferInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  transferV2: (
+    input: MakeOptional<TransferV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getTransferV2InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  unverifyCollection: (
+    input: MakeOptional<UnverifyCollectionAsyncInput, "payer">,
+  ) => ReturnType<typeof getUnverifyCollectionInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  unverifyCreator: (
+    input: MakeOptional<UnverifyCreatorAsyncInput, "payer">,
+  ) => ReturnType<typeof getUnverifyCreatorInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  unverifyCreatorV2: (
+    input: MakeOptional<UnverifyCreatorV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getUnverifyCreatorV2InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  updateAssetDataV2: (
+    input: MakeOptional<UpdateAssetDataV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getUpdateAssetDataV2InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  updateMetadata: (
+    input: MakeOptional<UpdateMetadataAsyncInput, "payer">,
+  ) => ReturnType<typeof getUpdateMetadataInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  updateMetadataV2: (
+    input: MakeOptional<UpdateMetadataV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getUpdateMetadataV2InstructionAsync> &
+    SelfPlanAndSendFunctions;
+  verifyCollection: (
+    input: MakeOptional<VerifyCollectionAsyncInput, "payer">,
+  ) => ReturnType<typeof getVerifyCollectionInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  verifyCreator: (
+    input: MakeOptional<VerifyCreatorAsyncInput, "payer">,
+  ) => ReturnType<typeof getVerifyCreatorInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  verifyCreatorV2: (
+    input: MakeOptional<VerifyCreatorV2AsyncInput, "payer">,
+  ) => ReturnType<typeof getVerifyCreatorV2InstructionAsync> &
+    SelfPlanAndSendFunctions;
+}
+
+export interface BubblegumPluginPdas {
+  treeConfig: typeof findTreeConfigPda;
+  voucher: typeof findVoucherPda;
+  assetId: typeof findAssetIdPda;
+  bubblegumSigner: typeof findBubblegumSignerPda;
+  mintAuthority: typeof findMintAuthorityPda;
+}
+
+export type BubblegumPluginRequirements = ClientWithRpc<
+  GetAccountInfoApi & GetMultipleAccountsApi
+> &
+  ClientWithPayer &
+  ClientWithTransactionPlanning &
+  ClientWithTransactionSending;
+
+export function bubblegumProgram() {
+  return <T extends BubblegumPluginRequirements>(
+    client: T,
+  ): Omit<T, "bubblegum"> & { bubblegum: BubblegumPlugin } => {
+    return extendClient(client, {
+      bubblegum: <BubblegumPlugin>{
+        accounts: {
+          treeConfig: addSelfFetchFunctions(client, getTreeConfigCodec()),
+          voucher: addSelfFetchFunctions(client, getVoucherCodec()),
+        },
+        instructions: {
+          burn: (input) =>
+            addSelfPlanAndSendFunctions(client, getBurnInstructionAsync(input)),
+          burnV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getBurnV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          cancelRedeem: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getCancelRedeemInstructionAsync(input),
+            ),
+          closeTreeV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getCloseTreeV2InstructionAsync(input),
+            ),
+          collectV2: (input) =>
+            addSelfPlanAndSendFunctions(client, getCollectV2Instruction(input)),
+          compress: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getCompressInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          createTree: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getCreateTreeInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          createTreeV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getCreateTreeV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          decompressV1: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getDecompressV1InstructionAsync(input),
+            ),
+          delegate: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getDelegateInstructionAsync(input),
+            ),
+          delegateAndFreezeV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getDelegateAndFreezeV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          delegateV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getDelegateV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          freezeV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getFreezeV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          mintToCollectionV1: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getMintToCollectionV1InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          mintV1: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getMintV1InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          mintV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getMintV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          redeem: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getRedeemInstructionAsync(input),
+            ),
+          setAndVerifyCollection: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getSetAndVerifyCollectionInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          setCollectionV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getSetCollectionV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          setDecompressableState: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getSetDecompressableStateInstruction(input),
+            ),
+          setDecompressibleState: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getSetDecompressibleStateInstruction(input),
+            ),
+          setNonTransferableV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getSetNonTransferableV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          setTreeDelegate: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getSetTreeDelegateInstructionAsync(input),
+            ),
+          thawAndRevokeV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getThawAndRevokeV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          thawV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getThawV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          transfer: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getTransferInstructionAsync(input),
+            ),
+          transferV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getTransferV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          unverifyCollection: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getUnverifyCollectionInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          unverifyCreator: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getUnverifyCreatorInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          unverifyCreatorV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getUnverifyCreatorV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          updateAssetDataV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getUpdateAssetDataV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          updateMetadata: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getUpdateMetadataInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          updateMetadataV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getUpdateMetadataV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          verifyCollection: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getVerifyCollectionInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          verifyCreator: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getVerifyCreatorInstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+          verifyCreatorV2: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getVerifyCreatorV2InstructionAsync({
+                ...input,
+                payer: input.payer ?? client.payer,
+              }),
+            ),
+        },
+        pdas: {
+          treeConfig: findTreeConfigPda,
+          voucher: findVoucherPda,
+          assetId: findAssetIdPda,
+          bubblegumSigner: findBubblegumSignerPda,
+          mintAuthority: findMintAuthorityPda,
+        },
+      },
+    });
+  };
+}
+
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;