@solana/transactions 2.0.0-experimental.87c9652 → 2.0.0-experimental.8894dc1

package/dist/index.browser.cjs

@@ -1,10 +1,27 @@
 'use strict';
 
 var umiSerializers = require('@metaplex-foundation/umi-serializers');
+var addresses = require('@solana/addresses');
 var keys = require('@solana/keys');
 
 // ../build-scripts/env-shim.ts
 var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
+
+// src/unsigned-transaction.ts
+function getUnsignedTransaction(transaction) {
+  if ("signatures" in transaction) {
+    const {
+      signatures: _,
+      // eslint-disable-line @typescript-eslint/no-unused-vars
+      ...unsignedTransaction
+    } = transaction;
+    return unsignedTransaction;
+  } else {
+    return transaction;
+  }
+}
+
+// src/blockhash.ts
 function assertIsBlockhash(putativeBlockhash) {
   try {
     if (
@@ -25,6 +42,17 @@ function assertIsBlockhash(putativeBlockhash) {
     });
   }
 }
+function setTransactionLifetimeUsingBlockhash(blockhashLifetimeConstraint, transaction) {
+  if ("lifetimeConstraint" in transaction && transaction.lifetimeConstraint.blockhash === blockhashLifetimeConstraint.blockhash && transaction.lifetimeConstraint.lastValidBlockHeight === blockhashLifetimeConstraint.lastValidBlockHeight) {
+    return transaction;
+  }
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    lifetimeConstraint: blockhashLifetimeConstraint
+  };
+  Object.freeze(out);
+  return out;
+}
 
 // src/create-transaction.ts
 function createTransaction({
@@ -38,66 +66,6 @@ function createTransaction({
   return out;
 }
 
-// src/fee-payer.ts
-function setTransactionFeePayer(feePayer, transaction) {
-  if ("feePayer" in transaction && feePayer === transaction.feePayer) {
-    return transaction;
-  }
-  let out;
-  if ("signatures" in transaction) {
-    const {
-      signatures: _,
-      // eslint-disable-line @typescript-eslint/no-unused-vars
-      ...unsignedTransaction
-    } = transaction;
-    out = {
-      ...unsignedTransaction,
-      feePayer
-    };
-  } else {
-    out = {
-      ...transaction,
-      feePayer
-    };
-  }
-  Object.freeze(out);
-  return out;
-}
-
-// src/instructions.ts
-function replaceInstructions(transaction, nextInstructions) {
-  let out;
-  if ("signatures" in transaction) {
-    const {
-      signatures: _,
-      // eslint-disable-line @typescript-eslint/no-unused-vars
-      ...unsignedTransaction
-    } = transaction;
-    out = {
-      ...unsignedTransaction,
-      instructions: nextInstructions
-    };
-  } else {
-    out = {
-      ...transaction,
-      instructions: nextInstructions
-    };
-  }
-  return out;
-}
-function appendTransactionInstruction(instruction, transaction) {
-  const nextInstructions = [...transaction.instructions, instruction];
-  const out = replaceInstructions(transaction, nextInstructions);
-  Object.freeze(out);
-  return out;
-}
-function prependTransactionInstruction(instruction, transaction) {
-  const nextInstructions = [instruction, ...transaction.instructions];
-  const out = replaceInstructions(transaction, nextInstructions);
-  Object.freeze(out);
-  return out;
-}
-
 // ../instructions/dist/index.browser.js
 var AccountRole = /* @__PURE__ */ ((AccountRole2) => {
   AccountRole2[AccountRole2["WRITABLE_SIGNER"] = /* 3 */
@@ -120,6 +88,96 @@ function isWritableRole(role) {
 function mergeRoles(roleA, roleB) {
   return roleA | roleB;
 }
+
+// src/durable-nonce.ts
+var RECENT_BLOCKHASHES_SYSVAR_ADDRESS = "SysvarRecentB1ockHashes11111111111111111111";
+var SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
+function assertIsDurableNonceTransaction(transaction) {
+  if (!isDurableNonceTransaction(transaction)) {
+    throw new Error("Transaction is not a durable nonce transaction");
+  }
+}
+function createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress) {
+  return {
+    accounts: [
+      { address: nonceAccountAddress, role: AccountRole.WRITABLE },
+      {
+        address: RECENT_BLOCKHASHES_SYSVAR_ADDRESS,
+        role: AccountRole.READONLY
+      },
+      { address: nonceAuthorityAddress, role: AccountRole.READONLY_SIGNER }
+    ],
+    data: new Uint8Array([4, 0, 0, 0]),
+    programAddress: SYSTEM_PROGRAM_ADDRESS
+  };
+}
+function isAdvanceNonceAccountInstruction(instruction) {
+  return instruction.programAddress === SYSTEM_PROGRAM_ADDRESS && // Test for `AdvanceNonceAccount` instruction data
+  instruction.data != null && isAdvanceNonceAccountInstructionData(instruction.data) && // Test for exactly 3 accounts
+  instruction.accounts?.length === 3 && // First account is nonce account address
+  instruction.accounts[0].address != null && instruction.accounts[0].role === AccountRole.WRITABLE && // Second account is recent blockhashes sysvar
+  instruction.accounts[1].address === RECENT_BLOCKHASHES_SYSVAR_ADDRESS && instruction.accounts[1].role === AccountRole.READONLY && // Third account is nonce authority account
+  instruction.accounts[2].address != null && instruction.accounts[2].role === AccountRole.READONLY_SIGNER;
+}
+function isAdvanceNonceAccountInstructionData(data) {
+  return data.byteLength === 4 && data[0] === 4 && data[1] === 0 && data[2] === 0 && data[3] === 0;
+}
+function isDurableNonceTransaction(transaction) {
+  return "lifetimeConstraint" in transaction && typeof transaction.lifetimeConstraint.nonce === "string" && transaction.instructions[0] != null && isAdvanceNonceAccountInstruction(transaction.instructions[0]);
+}
+function setTransactionLifetimeUsingDurableNonce({
+  nonce,
+  nonceAccountAddress,
+  nonceAuthorityAddress
+}, transaction) {
+  const isAlreadyDurableNonceTransaction = isDurableNonceTransaction(transaction);
+  if (isAlreadyDurableNonceTransaction && transaction.lifetimeConstraint.nonce === nonce && transaction.instructions[0].accounts[0].address === nonceAccountAddress && transaction.instructions[0].accounts[2].address === nonceAuthorityAddress) {
+    return transaction;
+  }
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    instructions: [
+      createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress),
+      ...isAlreadyDurableNonceTransaction ? transaction.instructions.slice(1) : transaction.instructions
+    ],
+    lifetimeConstraint: {
+      nonce
+    }
+  };
+  Object.freeze(out);
+  return out;
+}
+
+// src/fee-payer.ts
+function setTransactionFeePayer(feePayer, transaction) {
+  if ("feePayer" in transaction && feePayer === transaction.feePayer) {
+    return transaction;
+  }
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    feePayer
+  };
+  Object.freeze(out);
+  return out;
+}
+
+// src/instructions.ts
+function appendTransactionInstruction(instruction, transaction) {
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    instructions: [...transaction.instructions, instruction]
+  };
+  Object.freeze(out);
+  return out;
+}
+function prependTransactionInstruction(instruction, transaction) {
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    instructions: [instruction, ...transaction.instructions]
+  };
+  Object.freeze(out);
+  return out;
+}
 function upsert(addressMap, address, update) {
   addressMap[address] = update(addressMap[address] ?? { role: AccountRole.READONLY });
 }
@@ -172,7 +230,7 @@ function getAddressMapFromInstructions(feePayer, instructions) {
                 const shouldReplaceEntry = (
                   // Consider using the new LOOKUP_TABLE if its address is different...
                   entry.lookupTableAddress !== accountMeta.lookupTableAddress && // ...and sorts before the existing one.
-                  (addressComparator || (addressComparator = keys.getBase58EncodedAddressComparator()))(
+                  (addressComparator || (addressComparator = addresses.getBase58EncodedAddressComparator()))(
                     accountMeta.lookupTableAddress,
                     entry.lookupTableAddress
                   ) < 0
@@ -278,7 +336,7 @@ function getOrderedAccountsFromAddressMap(addressMap) {
     if (leftIsWritable !== isWritableRole(rightEntry.role)) {
       return leftIsWritable ? -1 : 1;
     }
-    addressComparator || (addressComparator = keys.getBase58EncodedAddressComparator());
+    addressComparator || (addressComparator = addresses.getBase58EncodedAddressComparator());
     if (leftEntry[TYPE] === 1 /* LOOKUP_TABLE */ && rightEntry[TYPE] === 1 /* LOOKUP_TABLE */ && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
       return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
     } else {
@@ -307,7 +365,7 @@ function getCompiledAddressTableLookups(orderedAccounts) {
       entry.readableIndices.push(account.addressIndex);
     }
   }
-  return Object.keys(index).sort(keys.getBase58EncodedAddressComparator()).map((lookupTableAddress) => ({
+  return Object.keys(index).sort(addresses.getBase58EncodedAddressComparator()).map((lookupTableAddress) => ({
     lookupTableAddress,
     ...index[lookupTableAddress]
   }));
@@ -391,7 +449,7 @@ function getAddressTableLookupCodec() {
     [
       [
         "lookupTableAddress",
-        keys.getBase58EncodedAddressCodec(
+        addresses.getBase58EncodedAddressCodec(
           __DEV__ ? {
             description: "The address of the address lookup table account from which instruction addresses should be looked up"
           } : void 0
@@ -466,7 +524,7 @@ function getInstructionCodec() {
         )
       ],
       [
-        "addressIndices",
+        "accountIndices",
         umiSerializers.array(
           umiSerializers.u8({
             description: __DEV__ ? "The index of an account, according to the well-ordered accounts list for this transaction" : ""
@@ -486,23 +544,23 @@ function getInstructionCodec() {
       ]
     ]),
     (value) => {
-      if (value.addressIndices !== void 0 && value.data !== void 0) {
+      if (value.accountIndices !== void 0 && value.data !== void 0) {
         return value;
       }
       return {
         ...value,
-        addressIndices: value.addressIndices ?? [],
+        accountIndices: value.accountIndices ?? [],
         data: value.data ?? new Uint8Array(0)
       };
     },
     (value) => {
-      if (value.addressIndices.length && value.data.byteLength) {
+      if (value.accountIndices.length && value.data.byteLength) {
         return value;
       }
-      const { addressIndices, data, ...rest } = value;
+      const { accountIndices, data, ...rest } = value;
       return {
         ...rest,
-        ...addressIndices.length ? { addressIndices } : null,
+        ...accountIndices.length ? { accountIndices } : null,
         ...data.byteLength ? { data } : null
       };
     }
@@ -588,7 +646,7 @@ function getPreludeStructSerializerTuple() {
     ["header", getMessageHeaderCodec()],
     [
       "staticAccounts",
-      umiSerializers.array(keys.getBase58EncodedAddressCodec(), {
+      umiSerializers.array(addresses.getBase58EncodedAddressCodec(), {
         description: __DEV__ ? "A compact-array of static account addresses belonging to this transaction" : "",
         size: umiSerializers.shortU16()
       })
@@ -625,21 +683,60 @@ function getCompiledMessageEncoder() {
 }
 
 // src/signatures.ts
+function assertIsTransactionSignature(putativeTransactionSignature) {
+  try {
+    if (
+      // Lowest value (64 bytes of zeroes)
+      putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
+      putativeTransactionSignature.length > 88
+    ) {
+      throw new Error("Expected input string to decode to a byte array of length 64.");
+    }
+    const bytes3 = umiSerializers.base58.serialize(putativeTransactionSignature);
+    const numBytes = bytes3.byteLength;
+    if (numBytes !== 64) {
+      throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
+    }
+  } catch (e) {
+    throw new Error(`\`${putativeTransactionSignature}\` is not a transaction signature`, {
+      cause: e
+    });
+  }
+}
+function isTransactionSignature(putativeTransactionSignature) {
+  if (
+    // Lowest value (64 bytes of zeroes)
+    putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
+    putativeTransactionSignature.length > 88
+  ) {
+    return false;
+  }
+  const bytes3 = umiSerializers.base58.serialize(putativeTransactionSignature);
+  const numBytes = bytes3.byteLength;
+  if (numBytes !== 64) {
+    return false;
+  }
+  return true;
+}
 async function getCompiledMessageSignature(message, secretKey) {
   const wireMessageBytes = getCompiledMessageEncoder().serialize(message);
   const signature = await keys.signBytes(secretKey, wireMessageBytes);
   return signature;
 }
-async function signTransaction(keyPair, transaction) {
+async function signTransaction(keyPairs, transaction) {
   const compiledMessage = compileMessage(transaction);
-  const [signerPublicKey, signature] = await Promise.all([
-    keys.getBase58EncodedAddressFromPublicKey(keyPair.publicKey),
-    getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
-  ]);
-  const nextSignatures = {
-    ..."signatures" in transaction ? transaction.signatures : null,
-    ...{ [signerPublicKey]: signature }
-  };
+  const nextSignatures = "signatures" in transaction ? { ...transaction.signatures } : {};
+  const publicKeySignaturePairs = await Promise.all(
+    keyPairs.map(
+      (keyPair) => Promise.all([
+        addresses.getAddressFromPublicKey(keyPair.publicKey),
+        getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
+      ])
+    )
+  );
+  for (const [signerPublicKey, signature] of publicKeySignaturePairs) {
+    nextSignatures[signerPublicKey] = signature;
+  }
   const out = {
     ...transaction,
     signatures: nextSignatures
@@ -647,6 +744,10 @@ async function signTransaction(keyPair, transaction) {
   Object.freeze(out);
   return out;
 }
+function transactionSignature(putativeTransactionSignature) {
+  assertIsTransactionSignature(putativeTransactionSignature);
+  return putativeTransactionSignature;
+}
 
 // src/compile-transaction.ts
 function getCompiledTransaction(transaction) {
@@ -703,10 +804,16 @@ function getBase64EncodedWireTransaction(transaction) {
 
 exports.appendTransactionInstruction = appendTransactionInstruction;
 exports.assertIsBlockhash = assertIsBlockhash;
+exports.assertIsDurableNonceTransaction = assertIsDurableNonceTransaction;
+exports.assertIsTransactionSignature = assertIsTransactionSignature;
 exports.createTransaction = createTransaction;
 exports.getBase64EncodedWireTransaction = getBase64EncodedWireTransaction;
+exports.isTransactionSignature = isTransactionSignature;
 exports.prependTransactionInstruction = prependTransactionInstruction;
 exports.setTransactionFeePayer = setTransactionFeePayer;
+exports.setTransactionLifetimeUsingBlockhash = setTransactionLifetimeUsingBlockhash;
+exports.setTransactionLifetimeUsingDurableNonce = setTransactionLifetimeUsingDurableNonce;
 exports.signTransaction = signTransaction;
+exports.transactionSignature = transactionSignature;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.browser.cjs.map