@solana-program/token-wrap 2.3.0 → 2.5.0

package/dist/src/index.mjs

@@ -1,1206 +0,0 @@
-import { getProgramDerivedAddress, getUtf8Encoder, getAddressEncoder, getStructEncoder, getStructDecoder, getAddressDecoder, combineCodec, decodeAccount, assertAccountExists, fetchEncodedAccount, assertAccountsExist, fetchEncodedAccounts, containsBytes, getU8Encoder, isProgramError, transformEncoder, getU8Decoder, getBooleanEncoder, getBooleanDecoder, getU64Encoder, getU64Decoder, AccountRole, assertIsFullySignedTransaction, assertIsSendableTransaction, pipe, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, upgradeRoleToSigner, isTransactionSigner as isTransactionSigner$1 } from '@solana/kit';
-import { extension, getMintSize, TOKEN_2022_PROGRAM_ADDRESS, findAssociatedTokenPda, fetchMaybeToken, getCreateAssociatedTokenInstruction, getTokenDecoder } from '@solana-program/token-2022';
-import { getTransferSolInstruction } from '@solana-program/system';
-import '@solana-program/token';
-
-// src/generated/accounts/backpointer.ts
-async function findBackpointerPda(seeds, config = {}) {
-  const {
-    programAddress = "TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR"
-  } = config;
-  return await getProgramDerivedAddress({
-    programAddress,
-    seeds: [
-      getUtf8Encoder().encode("backpointer"),
-      getAddressEncoder().encode(seeds.wrappedMint)
-    ]
-  });
-}
-async function findWrappedMintPda(seeds, config = {}) {
-  const {
-    programAddress = "TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR"
-  } = config;
-  return await getProgramDerivedAddress({
-    programAddress,
-    seeds: [
-      getUtf8Encoder().encode("mint"),
-      getAddressEncoder().encode(seeds.unwrappedMint),
-      getAddressEncoder().encode(seeds.wrappedTokenProgram)
-    ]
-  });
-}
-async function findWrappedMintAuthorityPda(seeds, config = {}) {
-  const {
-    programAddress = "TwRapQCDhWkZRrDaHfZGuHxkZ91gHDRkyuzNqeU5MgR"
-  } = config;
-  return await getProgramDerivedAddress({
-    programAddress,
-    seeds: [
-      getUtf8Encoder().encode("authority"),
-      getAddressEncoder().encode(seeds.wrappedMint)
-    ]
-  });
-}
-
-// src/generated/accounts/backpointer.ts
-function getBackpointerEncoder() {
-  return getStructEncoder([["unwrappedMint", getAddressEncoder()]]);
-}
-function getBackpointerDecoder() {
-  return getStructDecoder([["unwrappedMint", getAddressDecoder()]]);
-}
-function getBackpointerCodec() {
-  return combineCodec(getBackpointerEncoder(), getBackpointerDecoder());
-}
-function decodeBackpointer(encodedAccount) {
-  return decodeAccount(
-    encodedAccount,
-    getBackpointerDecoder()
-  );
-}
-async function fetchBackpointer(rpc, address, config) {
-  const maybeAccount = await fetchMaybeBackpointer(rpc, address, config);
-  assertAccountExists(maybeAccount);
-  return maybeAccount;
-}
-async function fetchMaybeBackpointer(rpc, address, config) {
-  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
-  return decodeBackpointer(maybeAccount);
-}
-async function fetchAllBackpointer(rpc, addresses, config) {
-  const maybeAccounts = await fetchAllMaybeBackpointer(rpc, addresses, config);
-  assertAccountsExist(maybeAccounts);
-  return maybeAccounts;
-}
-async function fetchAllMaybeBackpointer(rpc, addresses, config) {
-  const maybeAccounts = await 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);
-  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 (containsBytes(data, getU8Encoder().encode(0), 0)) {
-    return 0 /* CreateMint */;
-  }
-  if (containsBytes(data, getU8Encoder().encode(1), 0)) {
-    return 1 /* Wrap */;
-  }
-  if (containsBytes(data, getU8Encoder().encode(2), 0)) {
-    return 2 /* Unwrap */;
-  }
-  if (containsBytes(data, getU8Encoder().encode(3), 0)) {
-    return 3 /* CloseStuckEscrow */;
-  }
-  if (containsBytes(data, getU8Encoder().encode(4), 0)) {
-    return 4 /* SyncMetadataToToken2022 */;
-  }
-  if (containsBytes(data, 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 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: AccountRole.READONLY
-      });
-    }
-    const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
-    return Object.freeze({
-      address: expectAddress(account.value),
-      role: isTransactionSigner(account.value) ? upgradeRoleToSigner(writableRole) : writableRole,
-      ...isTransactionSigner(account.value) ? { signer: account.value } : {}
-    });
-  };
-}
-function isTransactionSigner(value) {
-  return !!value && typeof value === "object" && "address" in value && isTransactionSigner$1(value);
-}
-
-// src/generated/instructions/closeStuckEscrow.ts
-var CLOSE_STUCK_ESCROW_DISCRIMINATOR = 3;
-function getCloseStuckEscrowDiscriminatorBytes() {
-  return getU8Encoder().encode(CLOSE_STUCK_ESCROW_DISCRIMINATOR);
-}
-function getCloseStuckEscrowInstructionDataEncoder() {
-  return transformEncoder(
-    getStructEncoder([["discriminator", getU8Encoder()]]),
-    (value) => ({ ...value, discriminator: CLOSE_STUCK_ESCROW_DISCRIMINATOR })
-  );
-}
-function getCloseStuckEscrowInstructionDataDecoder() {
-  return getStructDecoder([["discriminator", getU8Decoder()]]);
-}
-function getCloseStuckEscrowInstructionDataCodec() {
-  return 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 getU8Encoder().encode(CREATE_MINT_DISCRIMINATOR);
-}
-function getCreateMintInstructionDataEncoder() {
-  return transformEncoder(
-    getStructEncoder([
-      ["discriminator", getU8Encoder()],
-      ["idempotent", getBooleanEncoder()]
-    ]),
-    (value) => ({
-      ...value,
-      discriminator: CREATE_MINT_DISCRIMINATOR,
-      idempotent: value.idempotent ?? false
-    })
-  );
-}
-function getCreateMintInstructionDataDecoder() {
-  return getStructDecoder([
-    ["discriminator", getU8Decoder()],
-    ["idempotent", getBooleanDecoder()]
-  ]);
-}
-function getCreateMintInstructionDataCodec() {
-  return 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 getU8Encoder().encode(SYNC_METADATA_TO_SPL_TOKEN_DISCRIMINATOR);
-}
-function getSyncMetadataToSplTokenInstructionDataEncoder() {
-  return transformEncoder(
-    getStructEncoder([["discriminator", getU8Encoder()]]),
-    (value) => ({
-      ...value,
-      discriminator: SYNC_METADATA_TO_SPL_TOKEN_DISCRIMINATOR
-    })
-  );
-}
-function getSyncMetadataToSplTokenInstructionDataDecoder() {
-  return getStructDecoder([["discriminator", getU8Decoder()]]);
-}
-function getSyncMetadataToSplTokenInstructionDataCodec() {
-  return 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 getU8Encoder().encode(SYNC_METADATA_TO_TOKEN2022_DISCRIMINATOR);
-}
-function getSyncMetadataToToken2022InstructionDataEncoder() {
-  return transformEncoder(
-    getStructEncoder([["discriminator", getU8Encoder()]]),
-    (value) => ({
-      ...value,
-      discriminator: SYNC_METADATA_TO_TOKEN2022_DISCRIMINATOR
-    })
-  );
-}
-function getSyncMetadataToToken2022InstructionDataDecoder() {
-  return getStructDecoder([["discriminator", getU8Decoder()]]);
-}
-function getSyncMetadataToToken2022InstructionDataCodec() {
-  return 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 getU8Encoder().encode(UNWRAP_DISCRIMINATOR);
-}
-function getUnwrapInstructionDataEncoder() {
-  return transformEncoder(
-    getStructEncoder([
-      ["discriminator", getU8Encoder()],
-      ["amount", getU64Encoder()]
-    ]),
-    (value) => ({ ...value, discriminator: UNWRAP_DISCRIMINATOR })
-  );
-}
-function getUnwrapInstructionDataDecoder() {
-  return getStructDecoder([
-    ["discriminator", getU8Decoder()],
-    ["amount", getU64Decoder()]
-  ]);
-}
-function getUnwrapInstructionDataCodec() {
-  return 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: 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 getU8Encoder().encode(WRAP_DISCRIMINATOR);
-}
-function getWrapInstructionDataEncoder() {
-  return transformEncoder(
-    getStructEncoder([
-      ["discriminator", getU8Encoder()],
-      ["amount", getU64Encoder()]
-    ]),
-    (value) => ({ ...value, discriminator: WRAP_DISCRIMINATOR })
-  );
-}
-function getWrapInstructionDataDecoder() {
-  return getStructDecoder([
-    ["discriminator", getU8Decoder()],
-    ["amount", getU64Decoder()]
-  ]);
-}
-function getWrapInstructionDataCodec() {
-  return 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: 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 = [
-  extension("ConfidentialTransferMint", {
-    autoApproveNewAccounts: true,
-    authority: null,
-    auditorElgamalPubkey: null
-  }),
-  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(getMintSize());
-  if (wrappedTokenProgram === TOKEN_2022_PROGRAM_ADDRESS) {
-    mintSize = BigInt(getMintSize(DEFAULT_EXTENSIONS));
-  }
-  const [wrappedMintAccount, wrappedMintRent] = await Promise.all([
-    fetchEncodedAccount(rpc, wrappedMint),
-    rpc.getMinimumBalanceForRentExemption(mintSize).send()
-  ]);
-  const wrappedMintLamports = wrappedMintAccount.exists ? wrappedMintAccount.lamports : 0n;
-  if (wrappedMintLamports < wrappedMintRent) {
-    fundedWrappedMintLamports = wrappedMintRent - wrappedMintLamports;
-    instructions.push(
-      getTransferSolInstruction({
-        source: payer,
-        destination: wrappedMint,
-        amount: fundedWrappedMintLamports
-      })
-    );
-  }
-  let fundedBackpointerLamports = 0n;
-  const backpointerSize = BigInt(getBackpointerSize());
-  const [backpointerAccount, backpointerRent] = await Promise.all([
-    fetchEncodedAccount(rpc, backpointer),
-    rpc.getMinimumBalanceForRentExemption(backpointerSize).send()
-  ]);
-  const backpointerLamports = backpointerAccount.exists ? backpointerAccount.lamports : 0n;
-  if (backpointerLamports < backpointerRent) {
-    fundedBackpointerLamports = backpointerRent - backpointerLamports;
-    instructions.push(
-      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 findAssociatedTokenPda({
-    owner: wrappedMintAuthority,
-    mint: unwrappedMint,
-    tokenProgram: unwrappedTokenProgram
-  });
-  const escrowResult = await fetchMaybeToken(rpc, escrowAta);
-  if (escrowResult.exists) {
-    return { kind: "already_exists", account: escrowResult };
-  }
-  const ix = 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 fetchEncodedAccount(rpc, tokenAccountAddress);
-  if (!account.exists) {
-    throw new Error(`Unwrapped token account ${tokenAccountAddress} not found.`);
-  }
-  return 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 && 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
-  };
-  assertIsFullySignedTransaction(tx);
-  assertIsSendableTransaction(tx);
-  return tx;
-}
-async function multisigOfflineSignWrap(args) {
-  const wrapIx = await buildWrapIx(args);
-  return pipe(
-    createTransactionMessage({ version: 0 }),
-    (tx) => setTransactionMessageFeePayerSigner(args.payer, tx),
-    (tx) => setTransactionMessageLifetimeUsingBlockhash(args.blockhash, tx),
-    (tx) => 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 findAssociatedTokenPda({
-    owner: payer.address,
-    mint: wrappedMint,
-    tokenProgram: wrappedTokenProgram
-  }))[0];
-  const [unwrappedEscrow] = await 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 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 fetchEncodedAccount(rpc, wrappedTokenAccount);
-  if (!wrappedAccountInfo.exists) {
-    throw new Error(`Wrapped token account ${wrappedTokenAccount} not found.`);
-  }
-  const wrappedMint = 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 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 pipe(
-    createTransactionMessage({ version: 0 }),
-    (tx) => setTransactionMessageFeePayerSigner(args.payer, tx),
-    (tx) => setTransactionMessageLifetimeUsingBlockhash(args.blockhash, tx),
-    (tx) => appendTransactionMessageInstructions([unwrapIx], tx)
-  );
-}
-
-export { CLOSE_STUCK_ESCROW_DISCRIMINATOR, CREATE_MINT_DISCRIMINATOR, SYNC_METADATA_TO_SPL_TOKEN_DISCRIMINATOR, SYNC_METADATA_TO_TOKEN2022_DISCRIMINATOR, TOKEN_WRAP_ERROR__BACKPOINTER_MISMATCH, TOKEN_WRAP_ERROR__ESCROW_IN_GOOD_STATE, TOKEN_WRAP_ERROR__ESCROW_MISMATCH, TOKEN_WRAP_ERROR__ESCROW_OWNER_MISMATCH, TOKEN_WRAP_ERROR__EXTERNAL_PROGRAM_RETURNED_NO_DATA, TOKEN_WRAP_ERROR__INVALID_BACKPOINTER_OWNER, TOKEN_WRAP_ERROR__INVALID_WRAPPED_MINT_OWNER, TOKEN_WRAP_ERROR__METADATA_POINTER_MISMATCH, TOKEN_WRAP_ERROR__METADATA_POINTER_MISSING, TOKEN_WRAP_ERROR__METADATA_POINTER_UNSET, TOKEN_WRAP_ERROR__METAPLEX_METADATA_MISMATCH, TOKEN_WRAP_ERROR__MINT_AUTHORITY_MISMATCH, TOKEN_WRAP_ERROR__NO_SYNCING_TO_TOKEN2022, TOKEN_WRAP_ERROR__UNWRAPPED_MINT_HAS_NO_METADATA, TOKEN_WRAP_ERROR__WRAPPED_MINT_MISMATCH, TOKEN_WRAP_ERROR__ZERO_WRAP_AMOUNT, TOKEN_WRAP_PROGRAM_ADDRESS, TokenWrapAccount, TokenWrapInstruction, UNWRAP_DISCRIMINATOR, WRAP_DISCRIMINATOR, combinedMultisigTx, createEscrowAccount, createMint, decodeBackpointer, fetchAllBackpointer, fetchAllMaybeBackpointer, fetchBackpointer, fetchBackpointerFromSeeds, fetchMaybeBackpointer, fetchMaybeBackpointerFromSeeds, findBackpointerPda, findWrappedMintAuthorityPda, findWrappedMintPda, getBackpointerCodec, getBackpointerDecoder, getBackpointerEncoder, getBackpointerSize, getCloseStuckEscrowDiscriminatorBytes, getCloseStuckEscrowInstruction, getCloseStuckEscrowInstructionDataCodec, getCloseStuckEscrowInstructionDataDecoder, getCloseStuckEscrowInstructionDataEncoder, getCreateMintDiscriminatorBytes, getCreateMintInstruction, getCreateMintInstructionDataCodec, getCreateMintInstructionDataDecoder, getCreateMintInstructionDataEncoder, getSyncMetadataToSplTokenDiscriminatorBytes, getSyncMetadataToSplTokenInstruction, getSyncMetadataToSplTokenInstructionDataCodec, getSyncMetadataToSplTokenInstructionDataDecoder, getSyncMetadataToSplTokenInstructionDataEncoder, getSyncMetadataToToken2022DiscriminatorBytes, getSyncMetadataToToken2022Instruction, getSyncMetadataToToken2022InstructionDataCodec, getSyncMetadataToToken2022InstructionDataDecoder, getSyncMetadataToToken2022InstructionDataEncoder, getTokenWrapErrorMessage, getUnwrapDiscriminatorBytes, getUnwrapInstruction, getUnwrapInstructionDataCodec, getUnwrapInstructionDataDecoder, getUnwrapInstructionDataEncoder, getWrapDiscriminatorBytes, getWrapInstruction, getWrapInstructionDataCodec, getWrapInstructionDataDecoder, getWrapInstructionDataEncoder, identifyTokenWrapInstruction, isTokenWrapError, multisigOfflineSignUnwrap, multisigOfflineSignWrap, parseCloseStuckEscrowInstruction, parseCreateMintInstruction, parseSyncMetadataToSplTokenInstruction, parseSyncMetadataToToken2022Instruction, parseUnwrapInstruction, parseWrapInstruction, singleSignerUnwrap, singleSignerWrap };
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map