@solana-program/token-wrap 1.0.0 → 2.1.0

package/dist/src/index.js

@@ -3,7 +3,7 @@
 var kit = require('@solana/kit');
 var token2022 = require('@solana-program/token-2022');
 var system = require('@solana-program/system');
-var token = require('@solana-program/token');
+require('@solana-program/token');
 
 // src/generated/accounts/backpointer.ts
 async function findBackpointerPda(seeds, config = {}) {
@@ -100,6 +100,7 @@ var TokenWrapInstruction = /* @__PURE__ */ ((TokenWrapInstruction2) => {
   TokenWrapInstruction2[TokenWrapInstruction2["CreateMint"] = 0] = "CreateMint";
   TokenWrapInstruction2[TokenWrapInstruction2["Wrap"] = 1] = "Wrap";
   TokenWrapInstruction2[TokenWrapInstruction2["Unwrap"] = 2] = "Unwrap";
+  TokenWrapInstruction2[TokenWrapInstruction2["CloseStuckEscrow"] = 3] = "CloseStuckEscrow";
   return TokenWrapInstruction2;
 })(TokenWrapInstruction || {});
 function identifyTokenWrapInstruction(instruction) {
@@ -113,6 +114,9 @@ function identifyTokenWrapInstruction(instruction) {
   if (kit.containsBytes(data, kit.getU8Encoder().encode(2), 0)) {
     return 2 /* Unwrap */;
   }
+  if (kit.containsBytes(data, kit.getU8Encoder().encode(3), 0)) {
+    return 3 /* CloseStuckEscrow */;
+  }
   throw new Error(
     "The provided instruction could not be identified as a tokenWrap instruction."
   );
@@ -126,10 +130,14 @@ 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 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__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`,
@@ -184,7 +192,88 @@ function isTransactionSigner(value) {
   return !!value && typeof value === "object" && "address" in value && kit.isTransactionSigner(value);
 }
 
-// src/generated/instructions/createMint.ts
+// 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);
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.escrow),
+      getAccountMeta(accounts.destination),
+      getAccountMeta(accounts.unwrappedMint),
+      getAccountMeta(accounts.wrappedMint),
+      getAccountMeta(accounts.wrappedMintAuthority),
+      getAccountMeta(accounts.token2022Program)
+    ],
+    programAddress,
+    data: getCloseStuckEscrowInstructionDataEncoder().encode({})
+  };
+  return instruction;
+}
+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);
@@ -497,9 +586,8 @@ function parseWrapInstruction(instruction) {
     data: getWrapInstructionDataDecoder().decode(instruction.data)
   };
 }
-async function createMintTx({
+async function createMint({
   rpc,
-  blockhash,
   unwrappedMint,
   wrappedTokenProgram,
   payer,
@@ -554,63 +642,16 @@ async function createMintTx({
       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,
+    ixs: instructions,
     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({
+async function createEscrowAccount({
   rpc,
-  blockhash,
   payer,
   unwrappedMint,
   wrappedTokenProgram
@@ -618,14 +659,23 @@ async function createEscrowAccountTx({
   const [wrappedMint] = await findWrappedMintPda({ unwrappedMint, wrappedTokenProgram });
   const [wrappedMintAuthority] = await findWrappedMintAuthorityPda({ wrappedMint });
   const unwrappedTokenProgram = await getOwnerFromAccount(rpc, unwrappedMint);
-  return createTokenAccountTx({
-    rpc,
-    blockhash,
-    payer,
+  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();
@@ -693,15 +743,19 @@ function combinedMultisigTx({
   kit.assertTransactionIsFullySigned(tx);
   return tx;
 }
-function multisigOfflineSignWrapTx(args) {
-  return buildWrapTransaction(args);
+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 singleSignerWrapTx({
+async function singleSignerWrap({
   rpc,
-  blockhash,
   payer,
   unwrappedTokenAccount,
-  escrowAccount,
   wrappedTokenProgram,
   amount,
   transferAuthority: inputTransferAuthority,
@@ -715,7 +769,8 @@ async function singleSignerWrapTx({
     wrappedMint,
     wrappedMintAuthority,
     recipientWrappedTokenAccount,
-    transferAuthority
+    transferAuthority,
+    unwrappedEscrow
   } = await resolveAddrs({
     rpc,
     payer,
@@ -726,11 +781,8 @@ async function singleSignerWrapTx({
     wrappedTokenProgram,
     inputRecipientTokenAccount
   });
-  const tx = buildWrapTransaction({
-    blockhash,
-    payer,
+  const ix = await buildWrapIx({
     unwrappedTokenAccount,
-    escrowAccount,
     wrappedTokenProgram,
     amount,
     transferAuthority,
@@ -741,9 +793,9 @@ async function singleSignerWrapTx({
     unwrappedTokenProgram
   });
   return {
-    tx,
+    ixs: [ix],
     recipientWrappedTokenAccount,
-    escrowAccount,
+    escrowAccount: unwrappedEscrow,
     amount: BigInt(amount)
   };
 }
@@ -766,8 +818,14 @@ async function resolveAddrs({
     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,
@@ -776,10 +834,8 @@ async function resolveAddrs({
     recipientWrappedTokenAccount
   };
 }
-function buildWrapTransaction({
-  payer,
+async function buildWrapIx({
   unwrappedTokenAccount,
-  escrowAccount,
   wrappedTokenProgram,
   amount,
   transferAuthority,
@@ -788,9 +844,13 @@ function buildWrapTransaction({
   unwrappedTokenProgram,
   wrappedMint,
   wrappedMintAuthority,
-  blockhash,
   multiSigners = []
 }) {
+  const [unwrappedEscrow] = await token2022.findAssociatedTokenPda({
+    owner: wrappedMintAuthority,
+    mint: unwrappedMint,
+    tokenProgram: unwrappedTokenProgram
+  });
   const wrapInstructionInput = {
     recipientWrappedTokenAccount,
     wrappedMint,
@@ -799,32 +859,26 @@ function buildWrapTransaction({
     wrappedTokenProgram,
     unwrappedTokenAccount,
     unwrappedMint,
-    unwrappedEscrow: escrowAccount,
+    unwrappedEscrow,
     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)
-  );
+  return getWrapInstruction(wrapInstructionInput);
 }
 async function resolveUnwrapAddrs({
   rpc,
   payer,
   wrappedTokenAccount,
-  unwrappedEscrow,
+  recipientUnwrappedToken,
   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 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.`);
@@ -841,9 +895,7 @@ async function resolveUnwrapAddrs({
     unwrappedTokenProgram
   };
 }
-function buildUnwrapTransaction({
-  payer,
-  unwrappedEscrow,
+async function buildUnwrapTransaction({
   recipientUnwrappedToken,
   wrappedMintAuthority,
   unwrappedMint,
@@ -853,9 +905,13 @@ function buildUnwrapTransaction({
   wrappedMint,
   transferAuthority,
   amount,
-  blockhash,
   multiSigners = []
 }) {
+  const [unwrappedEscrow] = await token2022.findAssociatedTokenPda({
+    owner: wrappedMintAuthority,
+    mint: unwrappedMint,
+    tokenProgram: unwrappedTokenProgram
+  });
   const unwrapInstructionInput = {
     unwrappedEscrow,
     recipientUnwrappedToken,
@@ -869,20 +925,12 @@ function buildUnwrapTransaction({
     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)
-  );
+  return getUnwrapInstruction(unwrapInstructionInput);
 }
-async function singleSignerUnwrapTx({
+async function singleSignerUnwrap({
   rpc,
-  blockhash,
   payer,
   wrappedTokenAccount,
-  unwrappedEscrow,
   amount,
   recipientUnwrappedToken,
   transferAuthority: inputTransferAuthority,
@@ -901,15 +949,13 @@ async function singleSignerUnwrapTx({
     rpc,
     payer,
     wrappedTokenAccount,
-    unwrappedEscrow,
+    recipientUnwrappedToken,
     inputUnwrappedMint,
     inputTransferAuthority,
     inputWrappedTokenProgram,
     inputUnwrappedTokenProgram
   });
-  const tx = buildUnwrapTransaction({
-    payer,
-    unwrappedEscrow,
+  const ix = await buildUnwrapTransaction({
     recipientUnwrappedToken,
     wrappedMintAuthority,
     unwrappedMint,
@@ -918,21 +964,29 @@ async function singleSignerUnwrapTx({
     wrappedTokenAccount,
     wrappedMint,
     transferAuthority,
-    amount,
-    blockhash
+    amount
   });
   return {
     recipientUnwrappedToken,
     amount: BigInt(amount),
-    tx
+    ixs: [ix]
   };
 }
-function multisigOfflineSignUnwrap(args) {
-  return buildUnwrapTransaction(args);
+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.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__INVALID_BACKPOINTER_OWNER = TOKEN_WRAP_ERROR__INVALID_BACKPOINTER_OWNER;
 exports.TOKEN_WRAP_ERROR__INVALID_WRAPPED_MINT_OWNER = TOKEN_WRAP_ERROR__INVALID_WRAPPED_MINT_OWNER;
@@ -945,8 +999,8 @@ exports.TokenWrapInstruction = TokenWrapInstruction;
 exports.UNWRAP_DISCRIMINATOR = UNWRAP_DISCRIMINATOR;
 exports.WRAP_DISCRIMINATOR = WRAP_DISCRIMINATOR;
 exports.combinedMultisigTx = combinedMultisigTx;
-exports.createEscrowAccountTx = createEscrowAccountTx;
-exports.createMintTx = createMintTx;
+exports.createEscrowAccount = createEscrowAccount;
+exports.createMint = createMint;
 exports.decodeBackpointer = decodeBackpointer;
 exports.fetchAllBackpointer = fetchAllBackpointer;
 exports.fetchAllMaybeBackpointer = fetchAllMaybeBackpointer;
@@ -961,6 +1015,11 @@ 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;
@@ -980,11 +1039,12 @@ exports.getWrapInstructionDataEncoder = getWrapInstructionDataEncoder;
 exports.identifyTokenWrapInstruction = identifyTokenWrapInstruction;
 exports.isTokenWrapError = isTokenWrapError;
 exports.multisigOfflineSignUnwrap = multisigOfflineSignUnwrap;
-exports.multisigOfflineSignWrapTx = multisigOfflineSignWrapTx;
+exports.multisigOfflineSignWrap = multisigOfflineSignWrap;
+exports.parseCloseStuckEscrowInstruction = parseCloseStuckEscrowInstruction;
 exports.parseCreateMintInstruction = parseCreateMintInstruction;
 exports.parseUnwrapInstruction = parseUnwrapInstruction;
 exports.parseWrapInstruction = parseWrapInstruction;
-exports.singleSignerUnwrapTx = singleSignerUnwrapTx;
-exports.singleSignerWrapTx = singleSignerWrapTx;
+exports.singleSignerUnwrap = singleSignerUnwrap;
+exports.singleSignerWrap = singleSignerWrap;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map