@solana-program/token-wrap 0.0.0 → 1.0.0

package/dist/src/index.js

@@ -0,0 +1,990 @@
+'use strict';
+
+var kit = require('@solana/kit');
+var token2022 = require('@solana-program/token-2022');
+var system = require('@solana-program/system');
+var token = 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";
+  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 */;
+  }
+  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 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_OWNER_MISMATCH]: `Unwrapped escrow token owner is not set to expected PDA`,
+    [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__MINT_AUTHORITY_MISMATCH]: `Wrapped mint authority does not match expected PDA`,
+    [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/createMint.ts
+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);
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.wrappedMint),
+      getAccountMeta(accounts.backpointer),
+      getAccountMeta(accounts.unwrappedMint),
+      getAccountMeta(accounts.systemProgram),
+      getAccountMeta(accounts.wrappedTokenProgram)
+    ],
+    programAddress,
+    data: getCreateMintInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
+}
+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 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);
+  const instruction = {
+    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
+    ],
+    programAddress,
+    data: getUnwrapInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
+}
+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);
+  const instruction = {
+    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
+    ],
+    programAddress,
+    data: getWrapInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
+}
+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)
+  };
+}
+async function createMintTx({
+  rpc,
+  blockhash,
+  unwrappedMint,
+  wrappedTokenProgram,
+  payer,
+  idempotent = false
+}) {
+  const [wrappedMint] = await findWrappedMintPda({
+    unwrappedMint,
+    wrappedTokenProgram
+  });
+  const [backpointer] = await findBackpointerPda({ wrappedMint });
+  const instructions = [];
+  let fundedWrappedMintLamports = 0n;
+  const mintSize = BigInt(token2022.getMintSize());
+  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
+    })
+  );
+  const tx = kit.pipe(
+    kit.createTransactionMessage({ version: 0 }),
+    (tx2) => kit.setTransactionMessageFeePayerSigner(payer, tx2),
+    (tx2) => kit.setTransactionMessageLifetimeUsingBlockhash(blockhash, tx2),
+    (tx2) => kit.appendTransactionMessageInstructions(instructions, tx2)
+  );
+  return {
+    wrappedMint,
+    backpointer,
+    tx,
+    fundedWrappedMintLamports,
+    fundedBackpointerLamports
+  };
+}
+function getInitializeTokenFn(tokenProgram) {
+  if (tokenProgram === token.TOKEN_PROGRAM_ADDRESS) return token.getInitializeAccountInstruction;
+  if (tokenProgram === token2022.TOKEN_2022_PROGRAM_ADDRESS) return token2022.getInitializeAccountInstruction;
+  throw new Error(`${tokenProgram} is not a valid token program.`);
+}
+async function createTokenAccountTx({
+  rpc,
+  blockhash,
+  payer,
+  mint,
+  owner,
+  tokenProgram
+}) {
+  const [keyPair, lamports] = await Promise.all([
+    kit.generateKeyPairSigner(),
+    rpc.getMinimumBalanceForRentExemption(165n).send()
+  ]);
+  const createAccountIx = system.getCreateAccountInstruction({
+    payer,
+    newAccount: keyPair,
+    lamports,
+    space: 165,
+    programAddress: tokenProgram
+  });
+  const initializeAccountIx = getInitializeTokenFn(tokenProgram)({
+    account: keyPair.address,
+    mint,
+    owner
+  });
+  const tx = kit.pipe(
+    kit.createTransactionMessage({ version: 0 }),
+    (tx2) => kit.setTransactionMessageFeePayerSigner(payer, tx2),
+    (tx2) => kit.setTransactionMessageLifetimeUsingBlockhash(blockhash, tx2),
+    (tx2) => kit.appendTransactionMessageInstructions([createAccountIx, initializeAccountIx], tx2)
+  );
+  return {
+    tx,
+    keyPair
+  };
+}
+async function createEscrowAccountTx({
+  rpc,
+  blockhash,
+  payer,
+  unwrappedMint,
+  wrappedTokenProgram
+}) {
+  const [wrappedMint] = await findWrappedMintPda({ unwrappedMint, wrappedTokenProgram });
+  const [wrappedMintAuthority] = await findWrappedMintAuthorityPda({ wrappedMint });
+  const unwrappedTokenProgram = await getOwnerFromAccount(rpc, unwrappedMint);
+  return createTokenAccountTx({
+    rpc,
+    blockhash,
+    payer,
+    mint: unwrappedMint,
+    owner: wrappedMintAuthority,
+    tokenProgram: unwrappedTokenProgram
+  });
+}
+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.assertTransactionIsFullySigned(tx);
+  return tx;
+}
+function multisigOfflineSignWrapTx(args) {
+  return buildWrapTransaction(args);
+}
+async function singleSignerWrapTx({
+  rpc,
+  blockhash,
+  payer,
+  unwrappedTokenAccount,
+  escrowAccount,
+  wrappedTokenProgram,
+  amount,
+  transferAuthority: inputTransferAuthority,
+  unwrappedMint: inputUnwrappedMint,
+  recipientWrappedTokenAccount: inputRecipientTokenAccount,
+  unwrappedTokenProgram: inputUnwrappedTokenProgram
+}) {
+  const {
+    unwrappedMint,
+    unwrappedTokenProgram,
+    wrappedMint,
+    wrappedMintAuthority,
+    recipientWrappedTokenAccount,
+    transferAuthority
+  } = await resolveAddrs({
+    rpc,
+    payer,
+    inputTransferAuthority,
+    inputUnwrappedMint,
+    unwrappedTokenAccount,
+    inputUnwrappedTokenProgram,
+    wrappedTokenProgram,
+    inputRecipientTokenAccount
+  });
+  const tx = buildWrapTransaction({
+    blockhash,
+    payer,
+    unwrappedTokenAccount,
+    escrowAccount,
+    wrappedTokenProgram,
+    amount,
+    transferAuthority,
+    unwrappedMint,
+    wrappedMint,
+    wrappedMintAuthority,
+    recipientWrappedTokenAccount,
+    unwrappedTokenProgram
+  });
+  return {
+    tx,
+    recipientWrappedTokenAccount,
+    escrowAccount,
+    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 transferAuthority = inputTransferAuthority ?? payer;
+  return {
+    transferAuthority,
+    unwrappedMint,
+    unwrappedTokenProgram,
+    wrappedMint,
+    wrappedMintAuthority,
+    recipientWrappedTokenAccount
+  };
+}
+function buildWrapTransaction({
+  payer,
+  unwrappedTokenAccount,
+  escrowAccount,
+  wrappedTokenProgram,
+  amount,
+  transferAuthority,
+  unwrappedMint,
+  recipientWrappedTokenAccount,
+  unwrappedTokenProgram,
+  wrappedMint,
+  wrappedMintAuthority,
+  blockhash,
+  multiSigners = []
+}) {
+  const wrapInstructionInput = {
+    recipientWrappedTokenAccount,
+    wrappedMint,
+    wrappedMintAuthority,
+    unwrappedTokenProgram,
+    wrappedTokenProgram,
+    unwrappedTokenAccount,
+    unwrappedMint,
+    unwrappedEscrow: escrowAccount,
+    transferAuthority,
+    amount: BigInt(amount),
+    multiSigners
+  };
+  const wrapInstruction = getWrapInstruction(wrapInstructionInput);
+  return kit.pipe(
+    kit.createTransactionMessage({ version: 0 }),
+    (tx) => kit.setTransactionMessageFeePayerSigner(payer, tx),
+    (tx) => kit.setTransactionMessageLifetimeUsingBlockhash(blockhash, tx),
+    (tx) => kit.appendTransactionMessageInstructions([wrapInstruction], tx)
+  );
+}
+async function resolveUnwrapAddrs({
+  rpc,
+  payer,
+  wrappedTokenAccount,
+  unwrappedEscrow,
+  inputUnwrappedMint,
+  inputTransferAuthority,
+  inputWrappedTokenProgram,
+  inputUnwrappedTokenProgram
+}) {
+  const wrappedTokenProgram = inputWrappedTokenProgram ?? await getOwnerFromAccount(rpc, wrappedTokenAccount);
+  const unwrappedTokenProgram = inputUnwrappedTokenProgram ?? await getOwnerFromAccount(rpc, unwrappedEscrow);
+  const unwrappedMint = inputUnwrappedMint ?? await getMintFromTokenAccount(rpc, unwrappedEscrow);
+  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
+  };
+}
+function buildUnwrapTransaction({
+  payer,
+  unwrappedEscrow,
+  recipientUnwrappedToken,
+  wrappedMintAuthority,
+  unwrappedMint,
+  wrappedTokenProgram,
+  unwrappedTokenProgram,
+  wrappedTokenAccount,
+  wrappedMint,
+  transferAuthority,
+  amount,
+  blockhash,
+  multiSigners = []
+}) {
+  const unwrapInstructionInput = {
+    unwrappedEscrow,
+    recipientUnwrappedToken,
+    wrappedMintAuthority,
+    unwrappedMint,
+    wrappedTokenProgram,
+    unwrappedTokenProgram,
+    wrappedTokenAccount,
+    wrappedMint,
+    transferAuthority,
+    amount: BigInt(amount),
+    multiSigners
+  };
+  const unwrapInstruction = getUnwrapInstruction(unwrapInstructionInput);
+  return kit.pipe(
+    kit.createTransactionMessage({ version: 0 }),
+    (tx) => kit.setTransactionMessageFeePayerSigner(payer, tx),
+    (tx) => kit.setTransactionMessageLifetimeUsingBlockhash(blockhash, tx),
+    (tx) => kit.appendTransactionMessageInstructions([unwrapInstruction], tx)
+  );
+}
+async function singleSignerUnwrapTx({
+  rpc,
+  blockhash,
+  payer,
+  wrappedTokenAccount,
+  unwrappedEscrow,
+  amount,
+  recipientUnwrappedToken,
+  transferAuthority: inputTransferAuthority,
+  unwrappedMint: inputUnwrappedMint,
+  wrappedTokenProgram: inputWrappedTokenProgram,
+  unwrappedTokenProgram: inputUnwrappedTokenProgram
+}) {
+  const {
+    wrappedMint,
+    wrappedMintAuthority,
+    transferAuthority,
+    unwrappedTokenProgram,
+    unwrappedMint,
+    wrappedTokenProgram
+  } = await resolveUnwrapAddrs({
+    rpc,
+    payer,
+    wrappedTokenAccount,
+    unwrappedEscrow,
+    inputUnwrappedMint,
+    inputTransferAuthority,
+    inputWrappedTokenProgram,
+    inputUnwrappedTokenProgram
+  });
+  const tx = buildUnwrapTransaction({
+    payer,
+    unwrappedEscrow,
+    recipientUnwrappedToken,
+    wrappedMintAuthority,
+    unwrappedMint,
+    wrappedTokenProgram,
+    unwrappedTokenProgram,
+    wrappedTokenAccount,
+    wrappedMint,
+    transferAuthority,
+    amount,
+    blockhash
+  });
+  return {
+    recipientUnwrappedToken,
+    amount: BigInt(amount),
+    tx
+  };
+}
+function multisigOfflineSignUnwrap(args) {
+  return buildUnwrapTransaction(args);
+}
+
+exports.CREATE_MINT_DISCRIMINATOR = CREATE_MINT_DISCRIMINATOR;
+exports.TOKEN_WRAP_ERROR__BACKPOINTER_MISMATCH = TOKEN_WRAP_ERROR__BACKPOINTER_MISMATCH;
+exports.TOKEN_WRAP_ERROR__ESCROW_OWNER_MISMATCH = TOKEN_WRAP_ERROR__ESCROW_OWNER_MISMATCH;
+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__MINT_AUTHORITY_MISMATCH = TOKEN_WRAP_ERROR__MINT_AUTHORITY_MISMATCH;
+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.createEscrowAccountTx = createEscrowAccountTx;
+exports.createMintTx = createMintTx;
+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.getCreateMintDiscriminatorBytes = getCreateMintDiscriminatorBytes;
+exports.getCreateMintInstruction = getCreateMintInstruction;
+exports.getCreateMintInstructionDataCodec = getCreateMintInstructionDataCodec;
+exports.getCreateMintInstructionDataDecoder = getCreateMintInstructionDataDecoder;
+exports.getCreateMintInstructionDataEncoder = getCreateMintInstructionDataEncoder;
+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.multisigOfflineSignWrapTx = multisigOfflineSignWrapTx;
+exports.parseCreateMintInstruction = parseCreateMintInstruction;
+exports.parseUnwrapInstruction = parseUnwrapInstruction;
+exports.parseWrapInstruction = parseWrapInstruction;
+exports.singleSignerUnwrapTx = singleSignerUnwrapTx;
+exports.singleSignerWrapTx = singleSignerWrapTx;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map