@solana-program/token-wrap 2.3.0 → 2.5.0

package/dist/src/index.js

@@ -1,1292 +0,0 @@
-'use strict';
-
-var kit = require('@solana/kit');
-var token2022 = require('@solana-program/token-2022');
-var system = require('@solana-program/system');
-require('@solana-program/token');
-
-// src/generated/accounts/backpointer.ts
-async function findBackpointerPda(seeds, config = {}) {
-  const {
-    programAddress = "TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR"
-  } = config;
-  return await kit.getProgramDerivedAddress({
-    programAddress,
-    seeds: [
-      kit.getUtf8Encoder().encode("backpointer"),
-      kit.getAddressEncoder().encode(seeds.wrappedMint)
-    ]
-  });
-}
-async function findWrappedMintPda(seeds, config = {}) {
-  const {
-    programAddress = "TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR"
-  } = config;
-  return await kit.getProgramDerivedAddress({
-    programAddress,
-    seeds: [
-      kit.getUtf8Encoder().encode("mint"),
-      kit.getAddressEncoder().encode(seeds.unwrappedMint),
-      kit.getAddressEncoder().encode(seeds.wrappedTokenProgram)
-    ]
-  });
-}
-async function findWrappedMintAuthorityPda(seeds, config = {}) {
-  const {
-    programAddress = "TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR"
-  } = config;
-  return await kit.getProgramDerivedAddress({
-    programAddress,
-    seeds: [
-      kit.getUtf8Encoder().encode("authority"),
-      kit.getAddressEncoder().encode(seeds.wrappedMint)
-    ]
-  });
-}
-
-// src/generated/accounts/backpointer.ts
-function getBackpointerEncoder() {
-  return kit.getStructEncoder([["unwrappedMint", kit.getAddressEncoder()]]);
-}
-function getBackpointerDecoder() {
-  return kit.getStructDecoder([["unwrappedMint", kit.getAddressDecoder()]]);
-}
-function getBackpointerCodec() {
-  return kit.combineCodec(getBackpointerEncoder(), getBackpointerDecoder());
-}
-function decodeBackpointer(encodedAccount) {
-  return kit.decodeAccount(
-    encodedAccount,
-    getBackpointerDecoder()
-  );
-}
-async function fetchBackpointer(rpc, address, config) {
-  const maybeAccount = await fetchMaybeBackpointer(rpc, address, config);
-  kit.assertAccountExists(maybeAccount);
-  return maybeAccount;
-}
-async function fetchMaybeBackpointer(rpc, address, config) {
-  const maybeAccount = await kit.fetchEncodedAccount(rpc, address, config);
-  return decodeBackpointer(maybeAccount);
-}
-async function fetchAllBackpointer(rpc, addresses, config) {
-  const maybeAccounts = await fetchAllMaybeBackpointer(rpc, addresses, config);
-  kit.assertAccountsExist(maybeAccounts);
-  return maybeAccounts;
-}
-async function fetchAllMaybeBackpointer(rpc, addresses, config) {
-  const maybeAccounts = await kit.fetchEncodedAccounts(rpc, addresses, config);
-  return maybeAccounts.map((maybeAccount) => decodeBackpointer(maybeAccount));
-}
-function getBackpointerSize() {
-  return 32;
-}
-async function fetchBackpointerFromSeeds(rpc, seeds, config = {}) {
-  const maybeAccount = await fetchMaybeBackpointerFromSeeds(rpc, seeds, config);
-  kit.assertAccountExists(maybeAccount);
-  return maybeAccount;
-}
-async function fetchMaybeBackpointerFromSeeds(rpc, seeds, config = {}) {
-  const { programAddress, ...fetchConfig } = config;
-  const [address] = await findBackpointerPda(seeds, { programAddress });
-  return await fetchMaybeBackpointer(rpc, address, fetchConfig);
-}
-var TOKEN_WRAP_PROGRAM_ADDRESS = "TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR";
-var TokenWrapAccount = /* @__PURE__ */ ((TokenWrapAccount2) => {
-  TokenWrapAccount2[TokenWrapAccount2["Backpointer"] = 0] = "Backpointer";
-  return TokenWrapAccount2;
-})(TokenWrapAccount || {});
-var TokenWrapInstruction = /* @__PURE__ */ ((TokenWrapInstruction2) => {
-  TokenWrapInstruction2[TokenWrapInstruction2["CreateMint"] = 0] = "CreateMint";
-  TokenWrapInstruction2[TokenWrapInstruction2["Wrap"] = 1] = "Wrap";
-  TokenWrapInstruction2[TokenWrapInstruction2["Unwrap"] = 2] = "Unwrap";
-  TokenWrapInstruction2[TokenWrapInstruction2["CloseStuckEscrow"] = 3] = "CloseStuckEscrow";
-  TokenWrapInstruction2[TokenWrapInstruction2["SyncMetadataToToken2022"] = 4] = "SyncMetadataToToken2022";
-  TokenWrapInstruction2[TokenWrapInstruction2["SyncMetadataToSplToken"] = 5] = "SyncMetadataToSplToken";
-  return TokenWrapInstruction2;
-})(TokenWrapInstruction || {});
-function identifyTokenWrapInstruction(instruction) {
-  const data = "data" in instruction ? instruction.data : instruction;
-  if (kit.containsBytes(data, kit.getU8Encoder().encode(0), 0)) {
-    return 0 /* CreateMint */;
-  }
-  if (kit.containsBytes(data, kit.getU8Encoder().encode(1), 0)) {
-    return 1 /* Wrap */;
-  }
-  if (kit.containsBytes(data, kit.getU8Encoder().encode(2), 0)) {
-    return 2 /* Unwrap */;
-  }
-  if (kit.containsBytes(data, kit.getU8Encoder().encode(3), 0)) {
-    return 3 /* CloseStuckEscrow */;
-  }
-  if (kit.containsBytes(data, kit.getU8Encoder().encode(4), 0)) {
-    return 4 /* SyncMetadataToToken2022 */;
-  }
-  if (kit.containsBytes(data, kit.getU8Encoder().encode(5), 0)) {
-    return 5 /* SyncMetadataToSplToken */;
-  }
-  throw new Error(
-    "The provided instruction could not be identified as a tokenWrap instruction."
-  );
-}
-
-// src/generated/errors/tokenWrap.ts
-var TOKEN_WRAP_ERROR__WRAPPED_MINT_MISMATCH = 0;
-var TOKEN_WRAP_ERROR__BACKPOINTER_MISMATCH = 1;
-var TOKEN_WRAP_ERROR__ZERO_WRAP_AMOUNT = 2;
-var TOKEN_WRAP_ERROR__MINT_AUTHORITY_MISMATCH = 3;
-var TOKEN_WRAP_ERROR__ESCROW_OWNER_MISMATCH = 4;
-var TOKEN_WRAP_ERROR__INVALID_WRAPPED_MINT_OWNER = 5;
-var TOKEN_WRAP_ERROR__INVALID_BACKPOINTER_OWNER = 6;
-var TOKEN_WRAP_ERROR__ESCROW_MISMATCH = 7;
-var TOKEN_WRAP_ERROR__ESCROW_IN_GOOD_STATE = 8;
-var TOKEN_WRAP_ERROR__UNWRAPPED_MINT_HAS_NO_METADATA = 9;
-var TOKEN_WRAP_ERROR__METAPLEX_METADATA_MISMATCH = 10;
-var TOKEN_WRAP_ERROR__METADATA_POINTER_MISSING = 11;
-var TOKEN_WRAP_ERROR__METADATA_POINTER_UNSET = 12;
-var TOKEN_WRAP_ERROR__METADATA_POINTER_MISMATCH = 13;
-var TOKEN_WRAP_ERROR__EXTERNAL_PROGRAM_RETURNED_NO_DATA = 14;
-var TOKEN_WRAP_ERROR__NO_SYNCING_TO_TOKEN2022 = 15;
-var tokenWrapErrorMessages;
-if (process.env.NODE_ENV !== "production") {
-  tokenWrapErrorMessages = {
-    [TOKEN_WRAP_ERROR__BACKPOINTER_MISMATCH]: `Wrapped backpointer account address does not match expected PDA`,
-    [TOKEN_WRAP_ERROR__ESCROW_IN_GOOD_STATE]: `The escrow account is in a good state and cannot be recreated`,
-    [TOKEN_WRAP_ERROR__ESCROW_MISMATCH]: `Escrow account address does not match expected ATA`,
-    [TOKEN_WRAP_ERROR__ESCROW_OWNER_MISMATCH]: `Unwrapped escrow token owner is not set to expected PDA`,
-    [TOKEN_WRAP_ERROR__EXTERNAL_PROGRAM_RETURNED_NO_DATA]: `External metadata program returned no data`,
-    [TOKEN_WRAP_ERROR__INVALID_BACKPOINTER_OWNER]: `Wrapped backpointer account owner is not the expected token wrap program`,
-    [TOKEN_WRAP_ERROR__INVALID_WRAPPED_MINT_OWNER]: `Wrapped mint account owner is not the expected token program`,
-    [TOKEN_WRAP_ERROR__METADATA_POINTER_MISMATCH]: `Provided source metadata account does not match pointer`,
-    [TOKEN_WRAP_ERROR__METADATA_POINTER_MISSING]: `Metadata pointer extension missing on mint`,
-    [TOKEN_WRAP_ERROR__METADATA_POINTER_UNSET]: `Metadata pointer is unset (None)`,
-    [TOKEN_WRAP_ERROR__METAPLEX_METADATA_MISMATCH]: `Metaplex metadata account address does not match expected PDA`,
-    [TOKEN_WRAP_ERROR__MINT_AUTHORITY_MISMATCH]: `Wrapped mint authority does not match expected PDA`,
-    [TOKEN_WRAP_ERROR__NO_SYNCING_TO_TOKEN2022]: `Instruction can only be used with spl-token wrapped mints`,
-    [TOKEN_WRAP_ERROR__UNWRAPPED_MINT_HAS_NO_METADATA]: `Unwrapped mint does not have the TokenMetadata extension`,
-    [TOKEN_WRAP_ERROR__WRAPPED_MINT_MISMATCH]: `Wrapped mint account address does not match expected PDA`,
-    [TOKEN_WRAP_ERROR__ZERO_WRAP_AMOUNT]: `Wrap amount should be positive`
-  };
-}
-function getTokenWrapErrorMessage(code) {
-  if (process.env.NODE_ENV !== "production") {
-    return tokenWrapErrorMessages[code];
-  }
-  return "Error message not available in production bundles.";
-}
-function isTokenWrapError(error, transactionMessage, code) {
-  return kit.isProgramError(
-    error,
-    transactionMessage,
-    TOKEN_WRAP_PROGRAM_ADDRESS,
-    code
-  );
-}
-function expectAddress(value) {
-  if (!value) {
-    throw new Error("Expected a Address.");
-  }
-  if (typeof value === "object" && "address" in value) {
-    return value.address;
-  }
-  if (Array.isArray(value)) {
-    return value[0];
-  }
-  return value;
-}
-function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
-  return (account) => {
-    if (!account.value) {
-      return Object.freeze({
-        address: programAddress,
-        role: kit.AccountRole.READONLY
-      });
-    }
-    const writableRole = account.isWritable ? kit.AccountRole.WRITABLE : kit.AccountRole.READONLY;
-    return Object.freeze({
-      address: expectAddress(account.value),
-      role: isTransactionSigner(account.value) ? kit.upgradeRoleToSigner(writableRole) : writableRole,
-      ...isTransactionSigner(account.value) ? { signer: account.value } : {}
-    });
-  };
-}
-function isTransactionSigner(value) {
-  return !!value && typeof value === "object" && "address" in value && kit.isTransactionSigner(value);
-}
-
-// src/generated/instructions/closeStuckEscrow.ts
-var CLOSE_STUCK_ESCROW_DISCRIMINATOR = 3;
-function getCloseStuckEscrowDiscriminatorBytes() {
-  return kit.getU8Encoder().encode(CLOSE_STUCK_ESCROW_DISCRIMINATOR);
-}
-function getCloseStuckEscrowInstructionDataEncoder() {
-  return kit.transformEncoder(
-    kit.getStructEncoder([["discriminator", kit.getU8Encoder()]]),
-    (value) => ({ ...value, discriminator: CLOSE_STUCK_ESCROW_DISCRIMINATOR })
-  );
-}
-function getCloseStuckEscrowInstructionDataDecoder() {
-  return kit.getStructDecoder([["discriminator", kit.getU8Decoder()]]);
-}
-function getCloseStuckEscrowInstructionDataCodec() {
-  return kit.combineCodec(
-    getCloseStuckEscrowInstructionDataEncoder(),
-    getCloseStuckEscrowInstructionDataDecoder()
-  );
-}
-function getCloseStuckEscrowInstruction(input, config) {
-  const programAddress = config?.programAddress ?? TOKEN_WRAP_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    escrow: { value: input.escrow ?? null, isWritable: true },
-    destination: { value: input.destination ?? null, isWritable: true },
-    unwrappedMint: { value: input.unwrappedMint ?? null, isWritable: false },
-    wrappedMint: { value: input.wrappedMint ?? null, isWritable: false },
-    wrappedMintAuthority: {
-      value: input.wrappedMintAuthority ?? null,
-      isWritable: false
-    },
-    token2022Program: {
-      value: input.token2022Program ?? null,
-      isWritable: false
-    }
-  };
-  const accounts = originalAccounts;
-  if (!accounts.token2022Program.value) {
-    accounts.token2022Program.value = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress);
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.escrow),
-      getAccountMeta(accounts.destination),
-      getAccountMeta(accounts.unwrappedMint),
-      getAccountMeta(accounts.wrappedMint),
-      getAccountMeta(accounts.wrappedMintAuthority),
-      getAccountMeta(accounts.token2022Program)
-    ],
-    data: getCloseStuckEscrowInstructionDataEncoder().encode({}),
-    programAddress
-  });
-}
-function parseCloseStuckEscrowInstruction(instruction) {
-  if (instruction.accounts.length < 6) {
-    throw new Error("Not enough accounts");
-  }
-  let accountIndex = 0;
-  const getNextAccount = () => {
-    const accountMeta = instruction.accounts[accountIndex];
-    accountIndex += 1;
-    return accountMeta;
-  };
-  const getNextOptionalAccount = () => {
-    const accountMeta = getNextAccount();
-    return accountMeta.address === TOKEN_WRAP_PROGRAM_ADDRESS ? void 0 : accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      escrow: getNextAccount(),
-      destination: getNextAccount(),
-      unwrappedMint: getNextAccount(),
-      wrappedMint: getNextAccount(),
-      wrappedMintAuthority: getNextAccount(),
-      token2022Program: getNextOptionalAccount()
-    },
-    data: getCloseStuckEscrowInstructionDataDecoder().decode(instruction.data)
-  };
-}
-var CREATE_MINT_DISCRIMINATOR = 0;
-function getCreateMintDiscriminatorBytes() {
-  return kit.getU8Encoder().encode(CREATE_MINT_DISCRIMINATOR);
-}
-function getCreateMintInstructionDataEncoder() {
-  return kit.transformEncoder(
-    kit.getStructEncoder([
-      ["discriminator", kit.getU8Encoder()],
-      ["idempotent", kit.getBooleanEncoder()]
-    ]),
-    (value) => ({
-      ...value,
-      discriminator: CREATE_MINT_DISCRIMINATOR,
-      idempotent: value.idempotent ?? false
-    })
-  );
-}
-function getCreateMintInstructionDataDecoder() {
-  return kit.getStructDecoder([
-    ["discriminator", kit.getU8Decoder()],
-    ["idempotent", kit.getBooleanDecoder()]
-  ]);
-}
-function getCreateMintInstructionDataCodec() {
-  return kit.combineCodec(
-    getCreateMintInstructionDataEncoder(),
-    getCreateMintInstructionDataDecoder()
-  );
-}
-function getCreateMintInstruction(input, config) {
-  const programAddress = config?.programAddress ?? TOKEN_WRAP_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    wrappedMint: { value: input.wrappedMint ?? null, isWritable: true },
-    backpointer: { value: input.backpointer ?? null, isWritable: true },
-    unwrappedMint: { value: input.unwrappedMint ?? null, isWritable: false },
-    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
-    wrappedTokenProgram: {
-      value: input.wrappedTokenProgram ?? null,
-      isWritable: false
-    }
-  };
-  const accounts = originalAccounts;
-  const args = { ...input };
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress);
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.wrappedMint),
-      getAccountMeta(accounts.backpointer),
-      getAccountMeta(accounts.unwrappedMint),
-      getAccountMeta(accounts.systemProgram),
-      getAccountMeta(accounts.wrappedTokenProgram)
-    ],
-    data: getCreateMintInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function parseCreateMintInstruction(instruction) {
-  if (instruction.accounts.length < 5) {
-    throw new Error("Not enough accounts");
-  }
-  let accountIndex = 0;
-  const getNextAccount = () => {
-    const accountMeta = instruction.accounts[accountIndex];
-    accountIndex += 1;
-    return accountMeta;
-  };
-  const getNextOptionalAccount = () => {
-    const accountMeta = getNextAccount();
-    return accountMeta.address === TOKEN_WRAP_PROGRAM_ADDRESS ? void 0 : accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      wrappedMint: getNextAccount(),
-      backpointer: getNextAccount(),
-      unwrappedMint: getNextAccount(),
-      systemProgram: getNextOptionalAccount(),
-      wrappedTokenProgram: getNextAccount()
-    },
-    data: getCreateMintInstructionDataDecoder().decode(instruction.data)
-  };
-}
-var SYNC_METADATA_TO_SPL_TOKEN_DISCRIMINATOR = 5;
-function getSyncMetadataToSplTokenDiscriminatorBytes() {
-  return kit.getU8Encoder().encode(SYNC_METADATA_TO_SPL_TOKEN_DISCRIMINATOR);
-}
-function getSyncMetadataToSplTokenInstructionDataEncoder() {
-  return kit.transformEncoder(
-    kit.getStructEncoder([["discriminator", kit.getU8Encoder()]]),
-    (value) => ({
-      ...value,
-      discriminator: SYNC_METADATA_TO_SPL_TOKEN_DISCRIMINATOR
-    })
-  );
-}
-function getSyncMetadataToSplTokenInstructionDataDecoder() {
-  return kit.getStructDecoder([["discriminator", kit.getU8Decoder()]]);
-}
-function getSyncMetadataToSplTokenInstructionDataCodec() {
-  return kit.combineCodec(
-    getSyncMetadataToSplTokenInstructionDataEncoder(),
-    getSyncMetadataToSplTokenInstructionDataDecoder()
-  );
-}
-function getSyncMetadataToSplTokenInstruction(input, config) {
-  const programAddress = config?.programAddress ?? TOKEN_WRAP_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    metaplexMetadata: {
-      value: input.metaplexMetadata ?? null,
-      isWritable: true
-    },
-    wrappedMintAuthority: {
-      value: input.wrappedMintAuthority ?? null,
-      isWritable: true
-    },
-    wrappedMint: { value: input.wrappedMint ?? null, isWritable: false },
-    unwrappedMint: { value: input.unwrappedMint ?? null, isWritable: false },
-    metaplexProgram: {
-      value: input.metaplexProgram ?? null,
-      isWritable: false
-    },
-    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
-    rentSysvar: { value: input.rentSysvar ?? null, isWritable: false },
-    sourceMetadata: { value: input.sourceMetadata ?? null, isWritable: false },
-    ownerProgram: { value: input.ownerProgram ?? null, isWritable: false }
-  };
-  const accounts = originalAccounts;
-  if (!accounts.metaplexProgram.value) {
-    accounts.metaplexProgram.value = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  if (!accounts.rentSysvar.value) {
-    accounts.rentSysvar.value = "SysvarRent111111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress);
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.metaplexMetadata),
-      getAccountMeta(accounts.wrappedMintAuthority),
-      getAccountMeta(accounts.wrappedMint),
-      getAccountMeta(accounts.unwrappedMint),
-      getAccountMeta(accounts.metaplexProgram),
-      getAccountMeta(accounts.systemProgram),
-      getAccountMeta(accounts.rentSysvar),
-      getAccountMeta(accounts.sourceMetadata),
-      getAccountMeta(accounts.ownerProgram)
-    ],
-    data: getSyncMetadataToSplTokenInstructionDataEncoder().encode({}),
-    programAddress
-  });
-}
-function parseSyncMetadataToSplTokenInstruction(instruction) {
-  if (instruction.accounts.length < 9) {
-    throw new Error("Not enough accounts");
-  }
-  let accountIndex = 0;
-  const getNextAccount = () => {
-    const accountMeta = instruction.accounts[accountIndex];
-    accountIndex += 1;
-    return accountMeta;
-  };
-  const getNextOptionalAccount = () => {
-    const accountMeta = getNextAccount();
-    return accountMeta.address === TOKEN_WRAP_PROGRAM_ADDRESS ? void 0 : accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      metaplexMetadata: getNextAccount(),
-      wrappedMintAuthority: getNextAccount(),
-      wrappedMint: getNextAccount(),
-      unwrappedMint: getNextAccount(),
-      metaplexProgram: getNextAccount(),
-      systemProgram: getNextAccount(),
-      rentSysvar: getNextAccount(),
-      sourceMetadata: getNextOptionalAccount(),
-      ownerProgram: getNextOptionalAccount()
-    },
-    data: getSyncMetadataToSplTokenInstructionDataDecoder().decode(
-      instruction.data
-    )
-  };
-}
-var SYNC_METADATA_TO_TOKEN2022_DISCRIMINATOR = 4;
-function getSyncMetadataToToken2022DiscriminatorBytes() {
-  return kit.getU8Encoder().encode(SYNC_METADATA_TO_TOKEN2022_DISCRIMINATOR);
-}
-function getSyncMetadataToToken2022InstructionDataEncoder() {
-  return kit.transformEncoder(
-    kit.getStructEncoder([["discriminator", kit.getU8Encoder()]]),
-    (value) => ({
-      ...value,
-      discriminator: SYNC_METADATA_TO_TOKEN2022_DISCRIMINATOR
-    })
-  );
-}
-function getSyncMetadataToToken2022InstructionDataDecoder() {
-  return kit.getStructDecoder([["discriminator", kit.getU8Decoder()]]);
-}
-function getSyncMetadataToToken2022InstructionDataCodec() {
-  return kit.combineCodec(
-    getSyncMetadataToToken2022InstructionDataEncoder(),
-    getSyncMetadataToToken2022InstructionDataDecoder()
-  );
-}
-function getSyncMetadataToToken2022Instruction(input, config) {
-  const programAddress = config?.programAddress ?? TOKEN_WRAP_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    wrappedMint: { value: input.wrappedMint ?? null, isWritable: true },
-    wrappedMintAuthority: {
-      value: input.wrappedMintAuthority ?? null,
-      isWritable: false
-    },
-    unwrappedMint: { value: input.unwrappedMint ?? null, isWritable: false },
-    token2022Program: {
-      value: input.token2022Program ?? null,
-      isWritable: false
-    },
-    sourceMetadata: { value: input.sourceMetadata ?? null, isWritable: false },
-    ownerProgram: { value: input.ownerProgram ?? null, isWritable: false }
-  };
-  const accounts = originalAccounts;
-  if (!accounts.token2022Program.value) {
-    accounts.token2022Program.value = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress);
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.wrappedMint),
-      getAccountMeta(accounts.wrappedMintAuthority),
-      getAccountMeta(accounts.unwrappedMint),
-      getAccountMeta(accounts.token2022Program),
-      getAccountMeta(accounts.sourceMetadata),
-      getAccountMeta(accounts.ownerProgram)
-    ],
-    data: getSyncMetadataToToken2022InstructionDataEncoder().encode({}),
-    programAddress
-  });
-}
-function parseSyncMetadataToToken2022Instruction(instruction) {
-  if (instruction.accounts.length < 6) {
-    throw new Error("Not enough accounts");
-  }
-  let accountIndex = 0;
-  const getNextAccount = () => {
-    const accountMeta = instruction.accounts[accountIndex];
-    accountIndex += 1;
-    return accountMeta;
-  };
-  const getNextOptionalAccount = () => {
-    const accountMeta = getNextAccount();
-    return accountMeta.address === TOKEN_WRAP_PROGRAM_ADDRESS ? void 0 : accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      wrappedMint: getNextAccount(),
-      wrappedMintAuthority: getNextAccount(),
-      unwrappedMint: getNextAccount(),
-      token2022Program: getNextAccount(),
-      sourceMetadata: getNextOptionalAccount(),
-      ownerProgram: getNextOptionalAccount()
-    },
-    data: getSyncMetadataToToken2022InstructionDataDecoder().decode(
-      instruction.data
-    )
-  };
-}
-var UNWRAP_DISCRIMINATOR = 2;
-function getUnwrapDiscriminatorBytes() {
-  return kit.getU8Encoder().encode(UNWRAP_DISCRIMINATOR);
-}
-function getUnwrapInstructionDataEncoder() {
-  return kit.transformEncoder(
-    kit.getStructEncoder([
-      ["discriminator", kit.getU8Encoder()],
-      ["amount", kit.getU64Encoder()]
-    ]),
-    (value) => ({ ...value, discriminator: UNWRAP_DISCRIMINATOR })
-  );
-}
-function getUnwrapInstructionDataDecoder() {
-  return kit.getStructDecoder([
-    ["discriminator", kit.getU8Decoder()],
-    ["amount", kit.getU64Decoder()]
-  ]);
-}
-function getUnwrapInstructionDataCodec() {
-  return kit.combineCodec(
-    getUnwrapInstructionDataEncoder(),
-    getUnwrapInstructionDataDecoder()
-  );
-}
-function getUnwrapInstruction(input, config) {
-  const programAddress = config?.programAddress ?? TOKEN_WRAP_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    unwrappedEscrow: { value: input.unwrappedEscrow ?? null, isWritable: true },
-    recipientUnwrappedToken: {
-      value: input.recipientUnwrappedToken ?? null,
-      isWritable: true
-    },
-    wrappedMintAuthority: {
-      value: input.wrappedMintAuthority ?? null,
-      isWritable: false
-    },
-    unwrappedMint: { value: input.unwrappedMint ?? null, isWritable: false },
-    wrappedTokenProgram: {
-      value: input.wrappedTokenProgram ?? null,
-      isWritable: false
-    },
-    unwrappedTokenProgram: {
-      value: input.unwrappedTokenProgram ?? null,
-      isWritable: false
-    },
-    wrappedTokenAccount: {
-      value: input.wrappedTokenAccount ?? null,
-      isWritable: true
-    },
-    wrappedMint: { value: input.wrappedMint ?? null, isWritable: true },
-    transferAuthority: {
-      value: input.transferAuthority ?? null,
-      isWritable: false
-    }
-  };
-  const accounts = originalAccounts;
-  const args = { ...input };
-  const remainingAccounts = (args.multiSigners ?? []).map(
-    (signer) => ({
-      address: signer.address,
-      role: kit.AccountRole.READONLY_SIGNER,
-      signer
-    })
-  );
-  const getAccountMeta = getAccountMetaFactory(programAddress);
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.unwrappedEscrow),
-      getAccountMeta(accounts.recipientUnwrappedToken),
-      getAccountMeta(accounts.wrappedMintAuthority),
-      getAccountMeta(accounts.unwrappedMint),
-      getAccountMeta(accounts.wrappedTokenProgram),
-      getAccountMeta(accounts.unwrappedTokenProgram),
-      getAccountMeta(accounts.wrappedTokenAccount),
-      getAccountMeta(accounts.wrappedMint),
-      getAccountMeta(accounts.transferAuthority),
-      ...remainingAccounts
-    ],
-    data: getUnwrapInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function parseUnwrapInstruction(instruction) {
-  if (instruction.accounts.length < 9) {
-    throw new Error("Not enough accounts");
-  }
-  let accountIndex = 0;
-  const getNextAccount = () => {
-    const accountMeta = instruction.accounts[accountIndex];
-    accountIndex += 1;
-    return accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      unwrappedEscrow: getNextAccount(),
-      recipientUnwrappedToken: getNextAccount(),
-      wrappedMintAuthority: getNextAccount(),
-      unwrappedMint: getNextAccount(),
-      wrappedTokenProgram: getNextAccount(),
-      unwrappedTokenProgram: getNextAccount(),
-      wrappedTokenAccount: getNextAccount(),
-      wrappedMint: getNextAccount(),
-      transferAuthority: getNextAccount()
-    },
-    data: getUnwrapInstructionDataDecoder().decode(instruction.data)
-  };
-}
-var WRAP_DISCRIMINATOR = 1;
-function getWrapDiscriminatorBytes() {
-  return kit.getU8Encoder().encode(WRAP_DISCRIMINATOR);
-}
-function getWrapInstructionDataEncoder() {
-  return kit.transformEncoder(
-    kit.getStructEncoder([
-      ["discriminator", kit.getU8Encoder()],
-      ["amount", kit.getU64Encoder()]
-    ]),
-    (value) => ({ ...value, discriminator: WRAP_DISCRIMINATOR })
-  );
-}
-function getWrapInstructionDataDecoder() {
-  return kit.getStructDecoder([
-    ["discriminator", kit.getU8Decoder()],
-    ["amount", kit.getU64Decoder()]
-  ]);
-}
-function getWrapInstructionDataCodec() {
-  return kit.combineCodec(
-    getWrapInstructionDataEncoder(),
-    getWrapInstructionDataDecoder()
-  );
-}
-function getWrapInstruction(input, config) {
-  const programAddress = config?.programAddress ?? TOKEN_WRAP_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    recipientWrappedTokenAccount: {
-      value: input.recipientWrappedTokenAccount ?? null,
-      isWritable: true
-    },
-    wrappedMint: { value: input.wrappedMint ?? null, isWritable: true },
-    wrappedMintAuthority: {
-      value: input.wrappedMintAuthority ?? null,
-      isWritable: false
-    },
-    unwrappedTokenProgram: {
-      value: input.unwrappedTokenProgram ?? null,
-      isWritable: false
-    },
-    wrappedTokenProgram: {
-      value: input.wrappedTokenProgram ?? null,
-      isWritable: false
-    },
-    unwrappedTokenAccount: {
-      value: input.unwrappedTokenAccount ?? null,
-      isWritable: true
-    },
-    unwrappedMint: { value: input.unwrappedMint ?? null, isWritable: false },
-    unwrappedEscrow: { value: input.unwrappedEscrow ?? null, isWritable: true },
-    transferAuthority: {
-      value: input.transferAuthority ?? null,
-      isWritable: false
-    }
-  };
-  const accounts = originalAccounts;
-  const args = { ...input };
-  const remainingAccounts = (args.multiSigners ?? []).map(
-    (signer) => ({
-      address: signer.address,
-      role: kit.AccountRole.READONLY_SIGNER,
-      signer
-    })
-  );
-  const getAccountMeta = getAccountMetaFactory(programAddress);
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.recipientWrappedTokenAccount),
-      getAccountMeta(accounts.wrappedMint),
-      getAccountMeta(accounts.wrappedMintAuthority),
-      getAccountMeta(accounts.unwrappedTokenProgram),
-      getAccountMeta(accounts.wrappedTokenProgram),
-      getAccountMeta(accounts.unwrappedTokenAccount),
-      getAccountMeta(accounts.unwrappedMint),
-      getAccountMeta(accounts.unwrappedEscrow),
-      getAccountMeta(accounts.transferAuthority),
-      ...remainingAccounts
-    ],
-    data: getWrapInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function parseWrapInstruction(instruction) {
-  if (instruction.accounts.length < 9) {
-    throw new Error("Not enough accounts");
-  }
-  let accountIndex = 0;
-  const getNextAccount = () => {
-    const accountMeta = instruction.accounts[accountIndex];
-    accountIndex += 1;
-    return accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      recipientWrappedTokenAccount: getNextAccount(),
-      wrappedMint: getNextAccount(),
-      wrappedMintAuthority: getNextAccount(),
-      unwrappedTokenProgram: getNextAccount(),
-      wrappedTokenProgram: getNextAccount(),
-      unwrappedTokenAccount: getNextAccount(),
-      unwrappedMint: getNextAccount(),
-      unwrappedEscrow: getNextAccount(),
-      transferAuthority: getNextAccount()
-    },
-    data: getWrapInstructionDataDecoder().decode(instruction.data)
-  };
-}
-var DEFAULT_EXTENSIONS = [
-  token2022.extension("ConfidentialTransferMint", {
-    autoApproveNewAccounts: true,
-    authority: null,
-    auditorElgamalPubkey: null
-  }),
-  token2022.extension("MetadataPointer", {
-    authority: null,
-    metadataAddress: null
-  })
-];
-async function createMint({
-  rpc,
-  unwrappedMint,
-  wrappedTokenProgram,
-  payer,
-  idempotent = false
-}) {
-  const [wrappedMint] = await findWrappedMintPda({
-    unwrappedMint,
-    wrappedTokenProgram
-  });
-  const [backpointer] = await findBackpointerPda({ wrappedMint });
-  const instructions = [];
-  let fundedWrappedMintLamports = 0n;
-  let mintSize = BigInt(token2022.getMintSize());
-  if (wrappedTokenProgram === token2022.TOKEN_2022_PROGRAM_ADDRESS) {
-    mintSize = BigInt(token2022.getMintSize(DEFAULT_EXTENSIONS));
-  }
-  const [wrappedMintAccount, wrappedMintRent] = await Promise.all([
-    kit.fetchEncodedAccount(rpc, wrappedMint),
-    rpc.getMinimumBalanceForRentExemption(mintSize).send()
-  ]);
-  const wrappedMintLamports = wrappedMintAccount.exists ? wrappedMintAccount.lamports : 0n;
-  if (wrappedMintLamports < wrappedMintRent) {
-    fundedWrappedMintLamports = wrappedMintRent - wrappedMintLamports;
-    instructions.push(
-      system.getTransferSolInstruction({
-        source: payer,
-        destination: wrappedMint,
-        amount: fundedWrappedMintLamports
-      })
-    );
-  }
-  let fundedBackpointerLamports = 0n;
-  const backpointerSize = BigInt(getBackpointerSize());
-  const [backpointerAccount, backpointerRent] = await Promise.all([
-    kit.fetchEncodedAccount(rpc, backpointer),
-    rpc.getMinimumBalanceForRentExemption(backpointerSize).send()
-  ]);
-  const backpointerLamports = backpointerAccount.exists ? backpointerAccount.lamports : 0n;
-  if (backpointerLamports < backpointerRent) {
-    fundedBackpointerLamports = backpointerRent - backpointerLamports;
-    instructions.push(
-      system.getTransferSolInstruction({
-        source: payer,
-        destination: backpointer,
-        amount: fundedBackpointerLamports
-      })
-    );
-  }
-  instructions.push(
-    getCreateMintInstruction({
-      wrappedMint,
-      backpointer,
-      unwrappedMint,
-      wrappedTokenProgram,
-      idempotent
-    })
-  );
-  return {
-    wrappedMint,
-    backpointer,
-    ixs: instructions,
-    fundedWrappedMintLamports,
-    fundedBackpointerLamports
-  };
-}
-async function createEscrowAccount({
-  rpc,
-  payer,
-  unwrappedMint,
-  wrappedTokenProgram
-}) {
-  const [wrappedMint] = await findWrappedMintPda({ unwrappedMint, wrappedTokenProgram });
-  const [wrappedMintAuthority] = await findWrappedMintAuthorityPda({ wrappedMint });
-  const unwrappedTokenProgram = await getOwnerFromAccount(rpc, unwrappedMint);
-  const [escrowAta] = await token2022.findAssociatedTokenPda({
-    owner: wrappedMintAuthority,
-    mint: unwrappedMint,
-    tokenProgram: unwrappedTokenProgram
-  });
-  const escrowResult = await token2022.fetchMaybeToken(rpc, escrowAta);
-  if (escrowResult.exists) {
-    return { kind: "already_exists", account: escrowResult };
-  }
-  const ix = token2022.getCreateAssociatedTokenInstruction({
-    payer,
-    owner: wrappedMintAuthority,
-    mint: unwrappedMint,
-    ata: escrowAta,
-    tokenProgram: unwrappedTokenProgram
-  });
-  return { address: escrowAta, ixs: [ix], kind: "instructions_to_create" };
-}
-async function getOwnerFromAccount(rpc, accountAddress) {
-  const accountInfo = await rpc.getAccountInfo(accountAddress, { encoding: "base64" }).send();
-  if (!accountInfo.value) {
-    throw new Error(`Account ${accountAddress} not found.`);
-  }
-  return accountInfo.value.owner;
-}
-async function getMintFromTokenAccount(rpc, tokenAccountAddress) {
-  const account = await kit.fetchEncodedAccount(rpc, tokenAccountAddress);
-  if (!account.exists) {
-    throw new Error(`Unwrapped token account ${tokenAccountAddress} not found.`);
-  }
-  return token2022.getTokenDecoder().decode(account.data).mint;
-}
-function messageBytesEqual(results) {
-  if (results.length === 1) {
-    return true;
-  }
-  const reference = results[0];
-  if (!reference) throw new Error("No transactions in input");
-  return results.every(
-    (c) => reference.messageBytes.length === c.messageBytes.length && kit.containsBytes(reference.messageBytes, c.messageBytes, 0)
-  );
-}
-function combineSignatures(signedTxs) {
-  const firstSignedTx = signedTxs[0];
-  if (!firstSignedTx) {
-    throw new Error("No signed transactions provided");
-  }
-  const allSignatures = {};
-  for (const pubkey of Object.keys(firstSignedTx.signatures)) {
-    allSignatures[pubkey] = null;
-  }
-  for (const signedTx of signedTxs) {
-    for (const [address, signature] of Object.entries(signedTx.signatures)) {
-      if (signature) {
-        allSignatures[address] = signature;
-      }
-    }
-  }
-  const missingSigners = [];
-  for (const [pubkey, signature] of Object.entries(allSignatures)) {
-    if (signature === null) {
-      missingSigners.push(pubkey);
-    }
-  }
-  if (missingSigners.length > 0) {
-    throw new Error(`Missing signatures for: ${missingSigners.join(", ")}`);
-  }
-  return allSignatures;
-}
-function combinedMultisigTx({
-  signedTxs,
-  blockhash
-}) {
-  const messagesEqual = messageBytesEqual(signedTxs);
-  if (!messagesEqual) throw new Error("Messages are not all the same");
-  if (!signedTxs[0]) throw new Error("No signed transactions provided");
-  const tx = {
-    messageBytes: signedTxs[0].messageBytes,
-    signatures: combineSignatures(signedTxs),
-    lifetimeConstraint: blockhash
-  };
-  kit.assertIsFullySignedTransaction(tx);
-  kit.assertIsSendableTransaction(tx);
-  return tx;
-}
-async function multisigOfflineSignWrap(args) {
-  const wrapIx = await buildWrapIx(args);
-  return kit.pipe(
-    kit.createTransactionMessage({ version: 0 }),
-    (tx) => kit.setTransactionMessageFeePayerSigner(args.payer, tx),
-    (tx) => kit.setTransactionMessageLifetimeUsingBlockhash(args.blockhash, tx),
-    (tx) => kit.appendTransactionMessageInstructions([wrapIx], tx)
-  );
-}
-async function singleSignerWrap({
-  rpc,
-  payer,
-  unwrappedTokenAccount,
-  wrappedTokenProgram,
-  amount,
-  transferAuthority: inputTransferAuthority,
-  unwrappedMint: inputUnwrappedMint,
-  recipientWrappedTokenAccount: inputRecipientTokenAccount,
-  unwrappedTokenProgram: inputUnwrappedTokenProgram
-}) {
-  const {
-    unwrappedMint,
-    unwrappedTokenProgram,
-    wrappedMint,
-    wrappedMintAuthority,
-    recipientWrappedTokenAccount,
-    transferAuthority,
-    unwrappedEscrow
-  } = await resolveAddrs({
-    rpc,
-    payer,
-    inputTransferAuthority,
-    inputUnwrappedMint,
-    unwrappedTokenAccount,
-    inputUnwrappedTokenProgram,
-    wrappedTokenProgram,
-    inputRecipientTokenAccount
-  });
-  const ix = await buildWrapIx({
-    unwrappedTokenAccount,
-    wrappedTokenProgram,
-    amount,
-    transferAuthority,
-    unwrappedMint,
-    wrappedMint,
-    wrappedMintAuthority,
-    recipientWrappedTokenAccount,
-    unwrappedTokenProgram
-  });
-  return {
-    ixs: [ix],
-    recipientWrappedTokenAccount,
-    escrowAccount: unwrappedEscrow,
-    amount: BigInt(amount)
-  };
-}
-async function resolveAddrs({
-  rpc,
-  payer,
-  unwrappedTokenAccount,
-  wrappedTokenProgram,
-  inputTransferAuthority,
-  inputUnwrappedMint,
-  inputRecipientTokenAccount,
-  inputUnwrappedTokenProgram
-}) {
-  const unwrappedMint = inputUnwrappedMint ?? await getMintFromTokenAccount(rpc, unwrappedTokenAccount);
-  const unwrappedTokenProgram = inputUnwrappedTokenProgram ?? await getOwnerFromAccount(rpc, unwrappedTokenAccount);
-  const [wrappedMint] = await findWrappedMintPda({ unwrappedMint, wrappedTokenProgram });
-  const [wrappedMintAuthority] = await findWrappedMintAuthorityPda({ wrappedMint });
-  const recipientWrappedTokenAccount = inputRecipientTokenAccount ?? (await token2022.findAssociatedTokenPda({
-    owner: payer.address,
-    mint: wrappedMint,
-    tokenProgram: wrappedTokenProgram
-  }))[0];
-  const [unwrappedEscrow] = await token2022.findAssociatedTokenPda({
-    owner: wrappedMintAuthority,
-    mint: unwrappedMint,
-    tokenProgram: unwrappedTokenProgram
-  });
-  const transferAuthority = inputTransferAuthority ?? payer;
-  return {
-    unwrappedEscrow,
-    transferAuthority,
-    unwrappedMint,
-    unwrappedTokenProgram,
-    wrappedMint,
-    wrappedMintAuthority,
-    recipientWrappedTokenAccount
-  };
-}
-async function buildWrapIx({
-  unwrappedTokenAccount,
-  wrappedTokenProgram,
-  amount,
-  transferAuthority,
-  unwrappedMint,
-  recipientWrappedTokenAccount,
-  unwrappedTokenProgram,
-  wrappedMint,
-  wrappedMintAuthority,
-  multiSigners = []
-}) {
-  const [unwrappedEscrow] = await token2022.findAssociatedTokenPda({
-    owner: wrappedMintAuthority,
-    mint: unwrappedMint,
-    tokenProgram: unwrappedTokenProgram
-  });
-  const wrapInstructionInput = {
-    recipientWrappedTokenAccount,
-    wrappedMint,
-    wrappedMintAuthority,
-    unwrappedTokenProgram,
-    wrappedTokenProgram,
-    unwrappedTokenAccount,
-    unwrappedMint,
-    unwrappedEscrow,
-    transferAuthority,
-    amount: BigInt(amount),
-    multiSigners
-  };
-  return getWrapInstruction(wrapInstructionInput);
-}
-async function resolveUnwrapAddrs({
-  rpc,
-  payer,
-  wrappedTokenAccount,
-  recipientUnwrappedToken,
-  inputUnwrappedMint,
-  inputTransferAuthority,
-  inputWrappedTokenProgram,
-  inputUnwrappedTokenProgram
-}) {
-  const wrappedTokenProgram = inputWrappedTokenProgram ?? await getOwnerFromAccount(rpc, wrappedTokenAccount);
-  const unwrappedTokenProgram = inputUnwrappedTokenProgram ?? await getOwnerFromAccount(rpc, recipientUnwrappedToken);
-  const unwrappedMint = inputUnwrappedMint ?? await getMintFromTokenAccount(rpc, recipientUnwrappedToken);
-  const wrappedAccountInfo = await kit.fetchEncodedAccount(rpc, wrappedTokenAccount);
-  if (!wrappedAccountInfo.exists) {
-    throw new Error(`Wrapped token account ${wrappedTokenAccount} not found.`);
-  }
-  const wrappedMint = token2022.getTokenDecoder().decode(wrappedAccountInfo.data).mint;
-  const [wrappedMintAuthority] = await findWrappedMintAuthorityPda({ wrappedMint });
-  const transferAuthority = inputTransferAuthority ?? payer;
-  return {
-    unwrappedMint,
-    wrappedMint,
-    wrappedMintAuthority,
-    transferAuthority,
-    wrappedTokenProgram,
-    unwrappedTokenProgram
-  };
-}
-async function buildUnwrapTransaction({
-  recipientUnwrappedToken,
-  wrappedMintAuthority,
-  unwrappedMint,
-  wrappedTokenProgram,
-  unwrappedTokenProgram,
-  wrappedTokenAccount,
-  wrappedMint,
-  transferAuthority,
-  amount,
-  multiSigners = []
-}) {
-  const [unwrappedEscrow] = await token2022.findAssociatedTokenPda({
-    owner: wrappedMintAuthority,
-    mint: unwrappedMint,
-    tokenProgram: unwrappedTokenProgram
-  });
-  const unwrapInstructionInput = {
-    unwrappedEscrow,
-    recipientUnwrappedToken,
-    wrappedMintAuthority,
-    unwrappedMint,
-    wrappedTokenProgram,
-    unwrappedTokenProgram,
-    wrappedTokenAccount,
-    wrappedMint,
-    transferAuthority,
-    amount: BigInt(amount),
-    multiSigners
-  };
-  return getUnwrapInstruction(unwrapInstructionInput);
-}
-async function singleSignerUnwrap({
-  rpc,
-  payer,
-  wrappedTokenAccount,
-  amount,
-  recipientUnwrappedToken,
-  transferAuthority: inputTransferAuthority,
-  unwrappedMint: inputUnwrappedMint,
-  wrappedTokenProgram: inputWrappedTokenProgram,
-  unwrappedTokenProgram: inputUnwrappedTokenProgram
-}) {
-  const {
-    wrappedMint,
-    wrappedMintAuthority,
-    transferAuthority,
-    unwrappedTokenProgram,
-    unwrappedMint,
-    wrappedTokenProgram
-  } = await resolveUnwrapAddrs({
-    rpc,
-    payer,
-    wrappedTokenAccount,
-    recipientUnwrappedToken,
-    inputUnwrappedMint,
-    inputTransferAuthority,
-    inputWrappedTokenProgram,
-    inputUnwrappedTokenProgram
-  });
-  const ix = await buildUnwrapTransaction({
-    recipientUnwrappedToken,
-    wrappedMintAuthority,
-    unwrappedMint,
-    wrappedTokenProgram,
-    unwrappedTokenProgram,
-    wrappedTokenAccount,
-    wrappedMint,
-    transferAuthority,
-    amount
-  });
-  return {
-    recipientUnwrappedToken,
-    amount: BigInt(amount),
-    ixs: [ix]
-  };
-}
-async function multisigOfflineSignUnwrap(args) {
-  const unwrapIx = await buildUnwrapTransaction(args);
-  return kit.pipe(
-    kit.createTransactionMessage({ version: 0 }),
-    (tx) => kit.setTransactionMessageFeePayerSigner(args.payer, tx),
-    (tx) => kit.setTransactionMessageLifetimeUsingBlockhash(args.blockhash, tx),
-    (tx) => kit.appendTransactionMessageInstructions([unwrapIx], tx)
-  );
-}
-
-exports.CLOSE_STUCK_ESCROW_DISCRIMINATOR = CLOSE_STUCK_ESCROW_DISCRIMINATOR;
-exports.CREATE_MINT_DISCRIMINATOR = CREATE_MINT_DISCRIMINATOR;
-exports.SYNC_METADATA_TO_SPL_TOKEN_DISCRIMINATOR = SYNC_METADATA_TO_SPL_TOKEN_DISCRIMINATOR;
-exports.SYNC_METADATA_TO_TOKEN2022_DISCRIMINATOR = SYNC_METADATA_TO_TOKEN2022_DISCRIMINATOR;
-exports.TOKEN_WRAP_ERROR__BACKPOINTER_MISMATCH = TOKEN_WRAP_ERROR__BACKPOINTER_MISMATCH;
-exports.TOKEN_WRAP_ERROR__ESCROW_IN_GOOD_STATE = TOKEN_WRAP_ERROR__ESCROW_IN_GOOD_STATE;
-exports.TOKEN_WRAP_ERROR__ESCROW_MISMATCH = TOKEN_WRAP_ERROR__ESCROW_MISMATCH;
-exports.TOKEN_WRAP_ERROR__ESCROW_OWNER_MISMATCH = TOKEN_WRAP_ERROR__ESCROW_OWNER_MISMATCH;
-exports.TOKEN_WRAP_ERROR__EXTERNAL_PROGRAM_RETURNED_NO_DATA = TOKEN_WRAP_ERROR__EXTERNAL_PROGRAM_RETURNED_NO_DATA;
-exports.TOKEN_WRAP_ERROR__INVALID_BACKPOINTER_OWNER = TOKEN_WRAP_ERROR__INVALID_BACKPOINTER_OWNER;
-exports.TOKEN_WRAP_ERROR__INVALID_WRAPPED_MINT_OWNER = TOKEN_WRAP_ERROR__INVALID_WRAPPED_MINT_OWNER;
-exports.TOKEN_WRAP_ERROR__METADATA_POINTER_MISMATCH = TOKEN_WRAP_ERROR__METADATA_POINTER_MISMATCH;
-exports.TOKEN_WRAP_ERROR__METADATA_POINTER_MISSING = TOKEN_WRAP_ERROR__METADATA_POINTER_MISSING;
-exports.TOKEN_WRAP_ERROR__METADATA_POINTER_UNSET = TOKEN_WRAP_ERROR__METADATA_POINTER_UNSET;
-exports.TOKEN_WRAP_ERROR__METAPLEX_METADATA_MISMATCH = TOKEN_WRAP_ERROR__METAPLEX_METADATA_MISMATCH;
-exports.TOKEN_WRAP_ERROR__MINT_AUTHORITY_MISMATCH = TOKEN_WRAP_ERROR__MINT_AUTHORITY_MISMATCH;
-exports.TOKEN_WRAP_ERROR__NO_SYNCING_TO_TOKEN2022 = TOKEN_WRAP_ERROR__NO_SYNCING_TO_TOKEN2022;
-exports.TOKEN_WRAP_ERROR__UNWRAPPED_MINT_HAS_NO_METADATA = TOKEN_WRAP_ERROR__UNWRAPPED_MINT_HAS_NO_METADATA;
-exports.TOKEN_WRAP_ERROR__WRAPPED_MINT_MISMATCH = TOKEN_WRAP_ERROR__WRAPPED_MINT_MISMATCH;
-exports.TOKEN_WRAP_ERROR__ZERO_WRAP_AMOUNT = TOKEN_WRAP_ERROR__ZERO_WRAP_AMOUNT;
-exports.TOKEN_WRAP_PROGRAM_ADDRESS = TOKEN_WRAP_PROGRAM_ADDRESS;
-exports.TokenWrapAccount = TokenWrapAccount;
-exports.TokenWrapInstruction = TokenWrapInstruction;
-exports.UNWRAP_DISCRIMINATOR = UNWRAP_DISCRIMINATOR;
-exports.WRAP_DISCRIMINATOR = WRAP_DISCRIMINATOR;
-exports.combinedMultisigTx = combinedMultisigTx;
-exports.createEscrowAccount = createEscrowAccount;
-exports.createMint = createMint;
-exports.decodeBackpointer = decodeBackpointer;
-exports.fetchAllBackpointer = fetchAllBackpointer;
-exports.fetchAllMaybeBackpointer = fetchAllMaybeBackpointer;
-exports.fetchBackpointer = fetchBackpointer;
-exports.fetchBackpointerFromSeeds = fetchBackpointerFromSeeds;
-exports.fetchMaybeBackpointer = fetchMaybeBackpointer;
-exports.fetchMaybeBackpointerFromSeeds = fetchMaybeBackpointerFromSeeds;
-exports.findBackpointerPda = findBackpointerPda;
-exports.findWrappedMintAuthorityPda = findWrappedMintAuthorityPda;
-exports.findWrappedMintPda = findWrappedMintPda;
-exports.getBackpointerCodec = getBackpointerCodec;
-exports.getBackpointerDecoder = getBackpointerDecoder;
-exports.getBackpointerEncoder = getBackpointerEncoder;
-exports.getBackpointerSize = getBackpointerSize;
-exports.getCloseStuckEscrowDiscriminatorBytes = getCloseStuckEscrowDiscriminatorBytes;
-exports.getCloseStuckEscrowInstruction = getCloseStuckEscrowInstruction;
-exports.getCloseStuckEscrowInstructionDataCodec = getCloseStuckEscrowInstructionDataCodec;
-exports.getCloseStuckEscrowInstructionDataDecoder = getCloseStuckEscrowInstructionDataDecoder;
-exports.getCloseStuckEscrowInstructionDataEncoder = getCloseStuckEscrowInstructionDataEncoder;
-exports.getCreateMintDiscriminatorBytes = getCreateMintDiscriminatorBytes;
-exports.getCreateMintInstruction = getCreateMintInstruction;
-exports.getCreateMintInstructionDataCodec = getCreateMintInstructionDataCodec;
-exports.getCreateMintInstructionDataDecoder = getCreateMintInstructionDataDecoder;
-exports.getCreateMintInstructionDataEncoder = getCreateMintInstructionDataEncoder;
-exports.getSyncMetadataToSplTokenDiscriminatorBytes = getSyncMetadataToSplTokenDiscriminatorBytes;
-exports.getSyncMetadataToSplTokenInstruction = getSyncMetadataToSplTokenInstruction;
-exports.getSyncMetadataToSplTokenInstructionDataCodec = getSyncMetadataToSplTokenInstructionDataCodec;
-exports.getSyncMetadataToSplTokenInstructionDataDecoder = getSyncMetadataToSplTokenInstructionDataDecoder;
-exports.getSyncMetadataToSplTokenInstructionDataEncoder = getSyncMetadataToSplTokenInstructionDataEncoder;
-exports.getSyncMetadataToToken2022DiscriminatorBytes = getSyncMetadataToToken2022DiscriminatorBytes;
-exports.getSyncMetadataToToken2022Instruction = getSyncMetadataToToken2022Instruction;
-exports.getSyncMetadataToToken2022InstructionDataCodec = getSyncMetadataToToken2022InstructionDataCodec;
-exports.getSyncMetadataToToken2022InstructionDataDecoder = getSyncMetadataToToken2022InstructionDataDecoder;
-exports.getSyncMetadataToToken2022InstructionDataEncoder = getSyncMetadataToToken2022InstructionDataEncoder;
-exports.getTokenWrapErrorMessage = getTokenWrapErrorMessage;
-exports.getUnwrapDiscriminatorBytes = getUnwrapDiscriminatorBytes;
-exports.getUnwrapInstruction = getUnwrapInstruction;
-exports.getUnwrapInstructionDataCodec = getUnwrapInstructionDataCodec;
-exports.getUnwrapInstructionDataDecoder = getUnwrapInstructionDataDecoder;
-exports.getUnwrapInstructionDataEncoder = getUnwrapInstructionDataEncoder;
-exports.getWrapDiscriminatorBytes = getWrapDiscriminatorBytes;
-exports.getWrapInstruction = getWrapInstruction;
-exports.getWrapInstructionDataCodec = getWrapInstructionDataCodec;
-exports.getWrapInstructionDataDecoder = getWrapInstructionDataDecoder;
-exports.getWrapInstructionDataEncoder = getWrapInstructionDataEncoder;
-exports.identifyTokenWrapInstruction = identifyTokenWrapInstruction;
-exports.isTokenWrapError = isTokenWrapError;
-exports.multisigOfflineSignUnwrap = multisigOfflineSignUnwrap;
-exports.multisigOfflineSignWrap = multisigOfflineSignWrap;
-exports.parseCloseStuckEscrowInstruction = parseCloseStuckEscrowInstruction;
-exports.parseCreateMintInstruction = parseCreateMintInstruction;
-exports.parseSyncMetadataToSplTokenInstruction = parseSyncMetadataToSplTokenInstruction;
-exports.parseSyncMetadataToToken2022Instruction = parseSyncMetadataToToken2022Instruction;
-exports.parseUnwrapInstruction = parseUnwrapInstruction;
-exports.parseWrapInstruction = parseWrapInstruction;
-exports.singleSignerUnwrap = singleSignerUnwrap;
-exports.singleSignerWrap = singleSignerWrap;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map