@solana-program/token-wrap 2.1.0 → 2.2.0

package/dist/src/index.js

@@ -101,6 +101,8 @@ var TokenWrapInstruction = /* @__PURE__ */ ((TokenWrapInstruction2) => {
   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) {
@@ -117,6 +119,12 @@ function identifyTokenWrapInstruction(instruction) {
   if (kit.containsBytes(data, kit.getU8Encoder().encode(3), 0)) {
     return 3 /* CloseStuckEscrow */;
   }
+  if (kit.containsBytes(data, kit.getU8Encoder().encode(4), 0)) {
+    return 4 /* SyncMetadataToToken2022 */;
+  }
+  if (kit.containsBytes(data, kit.getU8Encoder().encode(5), 0)) {
+    return 5 /* SyncMetadataToSplToken */;
+  }
   throw new Error(
     "The provided instruction could not be identified as a tokenWrap instruction."
   );
@@ -132,6 +140,13 @@ 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 = {
@@ -139,9 +154,16 @@ if (process.env.NODE_ENV !== "production") {
     [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`
   };
@@ -362,6 +384,196 @@ function parseCreateMintInstruction(instruction) {
     data: getCreateMintInstructionDataDecoder().decode(instruction.data)
   };
 }
+var SYNC_METADATA_TO_SPL_TOKEN_DISCRIMINATOR = 5;
+function getSyncMetadataToSplTokenDiscriminatorBytes() {
+  return kit.getU8Encoder().encode(SYNC_METADATA_TO_SPL_TOKEN_DISCRIMINATOR);
+}
+function getSyncMetadataToSplTokenInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.getU8Encoder()]]),
+    (value) => ({
+      ...value,
+      discriminator: SYNC_METADATA_TO_SPL_TOKEN_DISCRIMINATOR
+    })
+  );
+}
+function getSyncMetadataToSplTokenInstructionDataDecoder() {
+  return kit.getStructDecoder([["discriminator", kit.getU8Decoder()]]);
+}
+function getSyncMetadataToSplTokenInstructionDataCodec() {
+  return kit.combineCodec(
+    getSyncMetadataToSplTokenInstructionDataEncoder(),
+    getSyncMetadataToSplTokenInstructionDataDecoder()
+  );
+}
+function getSyncMetadataToSplTokenInstruction(input, config) {
+  const programAddress = config?.programAddress ?? TOKEN_WRAP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    metaplexMetadata: {
+      value: input.metaplexMetadata ?? null,
+      isWritable: true
+    },
+    wrappedMintAuthority: {
+      value: input.wrappedMintAuthority ?? null,
+      isWritable: true
+    },
+    wrappedMint: { value: input.wrappedMint ?? null, isWritable: false },
+    unwrappedMint: { value: input.unwrappedMint ?? null, isWritable: false },
+    metaplexProgram: {
+      value: input.metaplexProgram ?? null,
+      isWritable: false
+    },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    rentSysvar: { value: input.rentSysvar ?? null, isWritable: false },
+    sourceMetadata: { value: input.sourceMetadata ?? null, isWritable: false },
+    ownerProgram: { value: input.ownerProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.metaplexProgram.value) {
+    accounts.metaplexProgram.value = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.rentSysvar.value) {
+    accounts.rentSysvar.value = "SysvarRent111111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
+    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)
+    ],
+    programAddress,
+    data: getSyncMetadataToSplTokenInstructionDataEncoder().encode({})
+  };
+  return instruction;
+}
+function parseSyncMetadataToSplTokenInstruction(instruction) {
+  if (instruction.accounts.length < 9) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  const getNextOptionalAccount = () => {
+    const accountMeta = getNextAccount();
+    return accountMeta.address === TOKEN_WRAP_PROGRAM_ADDRESS ? void 0 : accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      metaplexMetadata: getNextAccount(),
+      wrappedMintAuthority: getNextAccount(),
+      wrappedMint: getNextAccount(),
+      unwrappedMint: getNextAccount(),
+      metaplexProgram: getNextAccount(),
+      systemProgram: getNextAccount(),
+      rentSysvar: getNextAccount(),
+      sourceMetadata: getNextOptionalAccount(),
+      ownerProgram: getNextOptionalAccount()
+    },
+    data: getSyncMetadataToSplTokenInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+var SYNC_METADATA_TO_TOKEN2022_DISCRIMINATOR = 4;
+function getSyncMetadataToToken2022DiscriminatorBytes() {
+  return kit.getU8Encoder().encode(SYNC_METADATA_TO_TOKEN2022_DISCRIMINATOR);
+}
+function getSyncMetadataToToken2022InstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([["discriminator", kit.getU8Encoder()]]),
+    (value) => ({
+      ...value,
+      discriminator: SYNC_METADATA_TO_TOKEN2022_DISCRIMINATOR
+    })
+  );
+}
+function getSyncMetadataToToken2022InstructionDataDecoder() {
+  return kit.getStructDecoder([["discriminator", kit.getU8Decoder()]]);
+}
+function getSyncMetadataToToken2022InstructionDataCodec() {
+  return kit.combineCodec(
+    getSyncMetadataToToken2022InstructionDataEncoder(),
+    getSyncMetadataToToken2022InstructionDataDecoder()
+  );
+}
+function getSyncMetadataToToken2022Instruction(input, config) {
+  const programAddress = config?.programAddress ?? TOKEN_WRAP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    wrappedMint: { value: input.wrappedMint ?? null, isWritable: true },
+    wrappedMintAuthority: {
+      value: input.wrappedMintAuthority ?? null,
+      isWritable: false
+    },
+    unwrappedMint: { value: input.unwrappedMint ?? null, isWritable: false },
+    token2022Program: {
+      value: input.token2022Program ?? null,
+      isWritable: false
+    },
+    sourceMetadata: { value: input.sourceMetadata ?? null, isWritable: false },
+    ownerProgram: { value: input.ownerProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.token2022Program.value) {
+    accounts.token2022Program.value = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress);
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.wrappedMint),
+      getAccountMeta(accounts.wrappedMintAuthority),
+      getAccountMeta(accounts.unwrappedMint),
+      getAccountMeta(accounts.token2022Program),
+      getAccountMeta(accounts.sourceMetadata),
+      getAccountMeta(accounts.ownerProgram)
+    ],
+    programAddress,
+    data: getSyncMetadataToToken2022InstructionDataEncoder().encode({})
+  };
+  return instruction;
+}
+function parseSyncMetadataToToken2022Instruction(instruction) {
+  if (instruction.accounts.length < 6) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  const getNextOptionalAccount = () => {
+    const accountMeta = getNextAccount();
+    return accountMeta.address === TOKEN_WRAP_PROGRAM_ADDRESS ? void 0 : accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      wrappedMint: getNextAccount(),
+      wrappedMintAuthority: getNextAccount(),
+      unwrappedMint: getNextAccount(),
+      token2022Program: getNextAccount(),
+      sourceMetadata: getNextOptionalAccount(),
+      ownerProgram: getNextOptionalAccount()
+    },
+    data: getSyncMetadataToToken2022InstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
 var UNWRAP_DISCRIMINATOR = 2;
 function getUnwrapDiscriminatorBytes() {
   return kit.getU8Encoder().encode(UNWRAP_DISCRIMINATOR);
@@ -586,6 +798,17 @@ function parseWrapInstruction(instruction) {
     data: getWrapInstructionDataDecoder().decode(instruction.data)
   };
 }
+var DEFAULT_EXTENSIONS = [
+  token2022.extension("ConfidentialTransferMint", {
+    autoApproveNewAccounts: true,
+    authority: null,
+    auditorElgamalPubkey: null
+  }),
+  token2022.extension("MetadataPointer", {
+    authority: null,
+    metadataAddress: null
+  })
+];
 async function createMint({
   rpc,
   unwrappedMint,
@@ -600,7 +823,10 @@ async function createMint({
   const [backpointer] = await findBackpointerPda({ wrappedMint });
   const instructions = [];
   let fundedWrappedMintLamports = 0n;
-  const mintSize = BigInt(token2022.getMintSize());
+  let mintSize = BigInt(token2022.getMintSize());
+  if (wrappedTokenProgram === token2022.TOKEN_2022_PROGRAM_ADDRESS) {
+    mintSize = BigInt(token2022.getMintSize(DEFAULT_EXTENSIONS));
+  }
   const [wrappedMintAccount, wrappedMintRent] = await Promise.all([
     kit.fetchEncodedAccount(rpc, wrappedMint),
     rpc.getMinimumBalanceForRentExemption(mintSize).send()
@@ -740,7 +966,8 @@ function combinedMultisigTx({
     signatures: combineSignatures(signedTxs),
     lifetimeConstraint: blockhash
   };
-  kit.assertTransactionIsFullySigned(tx);
+  kit.assertIsFullySignedTransaction(tx);
+  kit.assertIsSendableTransaction(tx);
   return tx;
 }
 async function multisigOfflineSignWrap(args) {
@@ -984,13 +1211,22 @@ async function multisigOfflineSignUnwrap(args) {
 
 exports.CLOSE_STUCK_ESCROW_DISCRIMINATOR = CLOSE_STUCK_ESCROW_DISCRIMINATOR;
 exports.CREATE_MINT_DISCRIMINATOR = CREATE_MINT_DISCRIMINATOR;
+exports.SYNC_METADATA_TO_SPL_TOKEN_DISCRIMINATOR = SYNC_METADATA_TO_SPL_TOKEN_DISCRIMINATOR;
+exports.SYNC_METADATA_TO_TOKEN2022_DISCRIMINATOR = SYNC_METADATA_TO_TOKEN2022_DISCRIMINATOR;
 exports.TOKEN_WRAP_ERROR__BACKPOINTER_MISMATCH = TOKEN_WRAP_ERROR__BACKPOINTER_MISMATCH;
 exports.TOKEN_WRAP_ERROR__ESCROW_IN_GOOD_STATE = TOKEN_WRAP_ERROR__ESCROW_IN_GOOD_STATE;
 exports.TOKEN_WRAP_ERROR__ESCROW_MISMATCH = TOKEN_WRAP_ERROR__ESCROW_MISMATCH;
 exports.TOKEN_WRAP_ERROR__ESCROW_OWNER_MISMATCH = TOKEN_WRAP_ERROR__ESCROW_OWNER_MISMATCH;
+exports.TOKEN_WRAP_ERROR__EXTERNAL_PROGRAM_RETURNED_NO_DATA = TOKEN_WRAP_ERROR__EXTERNAL_PROGRAM_RETURNED_NO_DATA;
 exports.TOKEN_WRAP_ERROR__INVALID_BACKPOINTER_OWNER = TOKEN_WRAP_ERROR__INVALID_BACKPOINTER_OWNER;
 exports.TOKEN_WRAP_ERROR__INVALID_WRAPPED_MINT_OWNER = TOKEN_WRAP_ERROR__INVALID_WRAPPED_MINT_OWNER;
+exports.TOKEN_WRAP_ERROR__METADATA_POINTER_MISMATCH = TOKEN_WRAP_ERROR__METADATA_POINTER_MISMATCH;
+exports.TOKEN_WRAP_ERROR__METADATA_POINTER_MISSING = TOKEN_WRAP_ERROR__METADATA_POINTER_MISSING;
+exports.TOKEN_WRAP_ERROR__METADATA_POINTER_UNSET = TOKEN_WRAP_ERROR__METADATA_POINTER_UNSET;
+exports.TOKEN_WRAP_ERROR__METAPLEX_METADATA_MISMATCH = TOKEN_WRAP_ERROR__METAPLEX_METADATA_MISMATCH;
 exports.TOKEN_WRAP_ERROR__MINT_AUTHORITY_MISMATCH = TOKEN_WRAP_ERROR__MINT_AUTHORITY_MISMATCH;
+exports.TOKEN_WRAP_ERROR__NO_SYNCING_TO_TOKEN2022 = TOKEN_WRAP_ERROR__NO_SYNCING_TO_TOKEN2022;
+exports.TOKEN_WRAP_ERROR__UNWRAPPED_MINT_HAS_NO_METADATA = TOKEN_WRAP_ERROR__UNWRAPPED_MINT_HAS_NO_METADATA;
 exports.TOKEN_WRAP_ERROR__WRAPPED_MINT_MISMATCH = TOKEN_WRAP_ERROR__WRAPPED_MINT_MISMATCH;
 exports.TOKEN_WRAP_ERROR__ZERO_WRAP_AMOUNT = TOKEN_WRAP_ERROR__ZERO_WRAP_AMOUNT;
 exports.TOKEN_WRAP_PROGRAM_ADDRESS = TOKEN_WRAP_PROGRAM_ADDRESS;
@@ -1025,6 +1261,16 @@ exports.getCreateMintInstruction = getCreateMintInstruction;
 exports.getCreateMintInstructionDataCodec = getCreateMintInstructionDataCodec;
 exports.getCreateMintInstructionDataDecoder = getCreateMintInstructionDataDecoder;
 exports.getCreateMintInstructionDataEncoder = getCreateMintInstructionDataEncoder;
+exports.getSyncMetadataToSplTokenDiscriminatorBytes = getSyncMetadataToSplTokenDiscriminatorBytes;
+exports.getSyncMetadataToSplTokenInstruction = getSyncMetadataToSplTokenInstruction;
+exports.getSyncMetadataToSplTokenInstructionDataCodec = getSyncMetadataToSplTokenInstructionDataCodec;
+exports.getSyncMetadataToSplTokenInstructionDataDecoder = getSyncMetadataToSplTokenInstructionDataDecoder;
+exports.getSyncMetadataToSplTokenInstructionDataEncoder = getSyncMetadataToSplTokenInstructionDataEncoder;
+exports.getSyncMetadataToToken2022DiscriminatorBytes = getSyncMetadataToToken2022DiscriminatorBytes;
+exports.getSyncMetadataToToken2022Instruction = getSyncMetadataToToken2022Instruction;
+exports.getSyncMetadataToToken2022InstructionDataCodec = getSyncMetadataToToken2022InstructionDataCodec;
+exports.getSyncMetadataToToken2022InstructionDataDecoder = getSyncMetadataToToken2022InstructionDataDecoder;
+exports.getSyncMetadataToToken2022InstructionDataEncoder = getSyncMetadataToToken2022InstructionDataEncoder;
 exports.getTokenWrapErrorMessage = getTokenWrapErrorMessage;
 exports.getUnwrapDiscriminatorBytes = getUnwrapDiscriminatorBytes;
 exports.getUnwrapInstruction = getUnwrapInstruction;
@@ -1042,6 +1288,8 @@ exports.multisigOfflineSignUnwrap = multisigOfflineSignUnwrap;
 exports.multisigOfflineSignWrap = multisigOfflineSignWrap;
 exports.parseCloseStuckEscrowInstruction = parseCloseStuckEscrowInstruction;
 exports.parseCreateMintInstruction = parseCreateMintInstruction;
+exports.parseSyncMetadataToSplTokenInstruction = parseSyncMetadataToSplTokenInstruction;
+exports.parseSyncMetadataToToken2022Instruction = parseSyncMetadataToToken2022Instruction;
 exports.parseUnwrapInstruction = parseUnwrapInstruction;
 exports.parseWrapInstruction = parseWrapInstruction;
 exports.singleSignerUnwrap = singleSignerUnwrap;