@solana/transactions 2.0.0-experimental.f07dced → 2.0.0-experimental.f27be12

package/dist/index.browser.js

@@ -1,8 +1,25 @@
 import { base58, struct, array, bytes, shortU16, mapSerializer, string, u8 } from '@metaplex-foundation/umi-serializers';
-import { getBase58EncodedAddressFromPublicKey, signBytes, getBase58EncodedAddressComparator, getBase58EncodedAddressCodec } from '@solana/keys';
+import { getAddressFromPublicKey, getAddressComparator, getAddressCodec } from '@solana/addresses';
+import { signBytes } from '@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 (
@@ -23,6 +40,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({
@@ -36,66 +64,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 */
@@ -118,6 +86,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 });
 }
@@ -170,7 +228,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 = getBase58EncodedAddressComparator()))(
+                  (addressComparator || (addressComparator = getAddressComparator()))(
                     accountMeta.lookupTableAddress,
                     entry.lookupTableAddress
                   ) < 0
@@ -276,7 +334,7 @@ function getOrderedAccountsFromAddressMap(addressMap) {
     if (leftIsWritable !== isWritableRole(rightEntry.role)) {
       return leftIsWritable ? -1 : 1;
     }
-    addressComparator || (addressComparator = getBase58EncodedAddressComparator());
+    addressComparator || (addressComparator = getAddressComparator());
     if (leftEntry[TYPE] === 1 /* LOOKUP_TABLE */ && rightEntry[TYPE] === 1 /* LOOKUP_TABLE */ && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
       return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
     } else {
@@ -305,7 +363,7 @@ function getCompiledAddressTableLookups(orderedAccounts) {
       entry.readableIndices.push(account.addressIndex);
     }
   }
-  return Object.keys(index).sort(getBase58EncodedAddressComparator()).map((lookupTableAddress) => ({
+  return Object.keys(index).sort(getAddressComparator()).map((lookupTableAddress) => ({
     lookupTableAddress,
     ...index[lookupTableAddress]
   }));
@@ -384,12 +442,30 @@ function compileMessage(transaction) {
     version: transaction.version
   };
 }
+
+// src/compile-transaction.ts
+function getCompiledTransaction(transaction) {
+  const compiledMessage = compileMessage(transaction);
+  let signatures;
+  if ("signatures" in transaction) {
+    signatures = [];
+    for (let ii = 0; ii < compiledMessage.header.numSignerAccounts; ii++) {
+      signatures[ii] = transaction.signatures[compiledMessage.staticAccounts[ii]] ?? new Uint8Array(Array(64).fill(0));
+    }
+  } else {
+    signatures = Array(compiledMessage.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));
+  }
+  return {
+    compiledMessage,
+    signatures
+  };
+}
 function getAddressTableLookupCodec() {
   return struct(
     [
       [
         "lookupTableAddress",
-        getBase58EncodedAddressCodec(
+        getAddressCodec(
           __DEV__ ? {
             description: "The address of the address lookup table account from which instruction addresses should be looked up"
           } : void 0
@@ -464,7 +540,7 @@ function getInstructionCodec() {
         )
       ],
       [
-        "addressIndices",
+        "accountIndices",
         array(
           u8({
             description: __DEV__ ? "The index of an account, according to the well-ordered accounts list for this transaction" : ""
@@ -484,23 +560,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
       };
     }
@@ -586,7 +662,7 @@ function getPreludeStructSerializerTuple() {
     ["header", getMessageHeaderCodec()],
     [
       "staticAccounts",
-      array(getBase58EncodedAddressCodec(), {
+      array(getAddressCodec(), {
         description: __DEV__ ? "A compact-array of static account addresses belonging to this transaction" : "",
         size: shortU16()
       })
@@ -622,48 +698,6 @@ function getCompiledMessageEncoder() {
   };
 }
 
-// src/signatures.ts
-async function getCompiledMessageSignature(message, secretKey) {
-  const wireMessageBytes = getCompiledMessageEncoder().serialize(message);
-  const signature = await signBytes(secretKey, wireMessageBytes);
-  return signature;
-}
-async function signTransaction(keyPair, transaction) {
-  const compiledMessage = compileMessage(transaction);
-  const [signerPublicKey, signature] = await Promise.all([
-    getBase58EncodedAddressFromPublicKey(keyPair.publicKey),
-    getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
-  ]);
-  const nextSignatures = {
-    ..."signatures" in transaction ? transaction.signatures : null,
-    ...{ [signerPublicKey]: signature }
-  };
-  const out = {
-    ...transaction,
-    signatures: nextSignatures
-  };
-  Object.freeze(out);
-  return out;
-}
-
-// src/compile-transaction.ts
-function getCompiledTransaction(transaction) {
-  const compiledMessage = compileMessage(transaction);
-  let signatures;
-  if ("signatures" in transaction) {
-    signatures = [];
-    for (let ii = 0; ii < compiledMessage.header.numSignerAccounts; ii++) {
-      signatures[ii] = transaction.signatures[compiledMessage.staticAccounts[ii]] ?? new Uint8Array(Array(64).fill(0));
-    }
-  } else {
-    signatures = Array(compiledMessage.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));
-  }
-  return {
-    compiledMessage,
-    signatures
-  };
-}
-
 // src/serializers/transaction.ts
 var BASE_CONFIG3 = {
   description: __DEV__ ? "The wire format of a Solana transaction" : "",
@@ -690,6 +724,80 @@ function getTransactionEncoder() {
     serialize: serialize3
   };
 }
+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 = 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 = 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 signBytes(secretKey, wireMessageBytes);
+  return signature;
+}
+function getSignatureFromTransaction(transaction) {
+  const signature = transaction.signatures[transaction.feePayer];
+  if (!signature) {
+    throw new Error(
+      "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer."
+    );
+  }
+  return signature;
+}
+async function signTransaction(keyPairs, transaction) {
+  const compiledMessage = compileMessage(transaction);
+  const nextSignatures = "signatures" in transaction ? { ...transaction.signatures } : {};
+  const publicKeySignaturePairs = await Promise.all(
+    keyPairs.map(
+      (keyPair) => Promise.all([
+        getAddressFromPublicKey(keyPair.publicKey),
+        getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
+      ])
+    )
+  );
+  for (const [signerPublicKey, signature] of publicKeySignaturePairs) {
+    nextSignatures[signerPublicKey] = signature;
+  }
+  const out = {
+    ...transaction,
+    signatures: nextSignatures
+  };
+  Object.freeze(out);
+  return out;
+}
+function transactionSignature(putativeTransactionSignature) {
+  assertIsTransactionSignature(putativeTransactionSignature);
+  return putativeTransactionSignature;
+}
 
 // src/wire-transaction.ts
 function getBase64EncodedWireTransaction(transaction) {
@@ -699,6 +807,6 @@ function getBase64EncodedWireTransaction(transaction) {
   }
 }
 
-export { appendTransactionInstruction, assertIsBlockhash, createTransaction, getBase64EncodedWireTransaction, prependTransactionInstruction, setTransactionFeePayer, signTransaction };
+export { appendTransactionInstruction, assertIsBlockhash, assertIsDurableNonceTransaction, assertIsTransactionSignature, createTransaction, getBase64EncodedWireTransaction, getSignatureFromTransaction, getTransactionEncoder, isTransactionSignature, prependTransactionInstruction, setTransactionFeePayer, setTransactionLifetimeUsingBlockhash, setTransactionLifetimeUsingDurableNonce, signTransaction, transactionSignature };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.browser.js.map