@solana/transactions 2.0.0-experimental.d32897d → 2.0.0-experimental.d3af599

package/README.md

@@ -244,21 +244,11 @@ This type represents a transaction that is signed by all of its required signers
 
 Expect any function that modifies a transaction (eg. `setTransactionFeePayer`, `appendTransactionInstruction`, et cetera) to delete a transaction's `signatures` property and unset this type.
 
-#### `TransactionSignature`
-
-This type represents the base58-encoded signature of a transactions fee payer. This value uniquely identifies the transaction on the network.
-
 ### Functions
 
-#### `assertIsTransactionSignature()`
-
-From time to time you might acquire a string that you expect to be the base58-encoded signature of a transaction, from an untrusted network API or user input. To assert that such an arbitrary string is in fact a transaction signature, use the `assertIsTransactionSignature` function.
-
-See [`assertIsBlockhash()`](#assertisblockhash) for an example of how to use an assertion function.
-
 #### `getSignatureFromTransaction()`
 
-Given a transaction signed by its fee payer, this method will return the `TransactionSignature` that uniquely identifies it. This string can be used to look up transactions at a later date, for example on a Solana block explorer.
+Given a transaction signed by its fee payer, this method will return the `Signature` that uniquely identifies it. This string can be used to look up transactions at a later date, for example on a Solana block explorer.
 
 ```ts
 import { getSignatureFromTransaction } from '@solana/transactions';
@@ -267,25 +257,6 @@ const signature = getSignatureFromTransaction(tx);
 console.debug(`Inspect this transaction at https://explorer.solana.com/tx/${signature}`);
 ```
 
-#### `isTransactionSignature()`
-
-This is a type guard that accepts a string as input. It will both return `true` if the string conforms to the `TransactionSignature` type and will refine the type for use in your program.
-
-```ts
-import { isTransactionSignature } from '@solana/transactions';
-
-if (isTransactionSignature(signature)) {
-    // At this point, `signature` has been refined to a
-    // `TransactionSignature` that can be used with the RPC.
-    const {
-        value: [status],
-    } = await rpc.getSignatureStatuses([signature]).send();
-    setSignatureStatus(status);
-} else {
-    setError(`${signature} is not a transaction signature`);
-}
-```
-
 #### `signTransaction()`
 
 Given an array of `CryptoKey` objects which are private keys pertaining to addresses that are required to sign a transaction, this method will return a new signed transaction having the same type as the one supplied plus the `ITransactionWithSignatures` type.
@@ -297,19 +268,6 @@ import { signTransaction } from '@solana/transactions';
 const signedTransaction = await signTransaction([myPrivateKey], tx);
 ```
 
-#### `transactionSignature()`
-
-This helper combines _asserting_ that a string is a transaction signature with _coercing_ it to the `TransactionSignature` type. It's best used with untrusted input.
-
-```ts
-import { transactionSignature } from '@solana/transactions';
-
-const signature = transactionSignature(userSuppliedSignature);
-const {
-    value: [status],
-} = await rpc.getSignatureStatuses([signature]).send();
-```
-
 ## Serializing transactions
 
 Before sending a transaction to be landed on the network, you must serialize it in a particular way. You can use these types and functions to serialize a signed transaction into a binary format suitable for transit over the wire.

package/dist/index.browser.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
 var codecsStrings = require('@solana/codecs-strings');
+var addresses = require('@solana/addresses');
 var codecsCore = require('@solana/codecs-core');
 var codecsDataStructures = require('@solana/codecs-data-structures');
 var codecsNumbers = require('@solana/codecs-numbers');
-var addresses = require('@solana/addresses');
 var functional = require('@solana/functional');
 var keys = require('@solana/keys');
 
@@ -254,7 +254,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 = addresses.getAddressComparator()))(
+                  (addressComparator ||= addresses.getAddressComparator())(
                     accountMeta.lookupTableAddress,
                     entry.lookupTableAddress
                   ) < 0
@@ -360,7 +360,7 @@ function getOrderedAccountsFromAddressMap(addressMap) {
     if (leftIsWritable !== isWritableRole(rightEntry.role)) {
       return leftIsWritable ? -1 : 1;
     }
-    addressComparator || (addressComparator = addresses.getAddressComparator());
+    addressComparator ||= addresses.getAddressComparator();
     if (leftEntry[TYPE] === 1 /* LOOKUP_TABLE */ && rightEntry[TYPE] === 1 /* LOOKUP_TABLE */ && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
       return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
     } else {
@@ -373,16 +373,15 @@ function getOrderedAccountsFromAddressMap(addressMap) {
   return orderedAccounts;
 }
 function getCompiledAddressTableLookups(orderedAccounts) {
-  var _a;
   const index = {};
   for (const account of orderedAccounts) {
     if (!("lookupTableAddress" in account)) {
       continue;
     }
-    const entry = index[_a = account.lookupTableAddress] || (index[_a] = {
+    const entry = index[account.lookupTableAddress] ||= {
       readableIndices: [],
       writableIndices: []
-    });
+    };
     if (account.role === AccountRole.WRITABLE) {
       entry.writableIndices.push(account.addressIndex);
     } else {
@@ -468,134 +467,6 @@ 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 getAccountMetas(message) {
-  const { header } = message;
-  const numWritableSignerAccounts = header.numSignerAccounts - header.numReadonlySignerAccounts;
-  const numWritableNonSignerAccounts = message.staticAccounts.length - header.numSignerAccounts - header.numReadonlyNonSignerAccounts;
-  const accountMetas = [];
-  let accountIndex = 0;
-  for (let i = 0; i < numWritableSignerAccounts; i++) {
-    accountMetas.push({
-      address: message.staticAccounts[accountIndex],
-      role: AccountRole.WRITABLE_SIGNER
-    });
-    accountIndex++;
-  }
-  for (let i = 0; i < header.numReadonlySignerAccounts; i++) {
-    accountMetas.push({
-      address: message.staticAccounts[accountIndex],
-      role: AccountRole.READONLY_SIGNER
-    });
-    accountIndex++;
-  }
-  for (let i = 0; i < numWritableNonSignerAccounts; i++) {
-    accountMetas.push({
-      address: message.staticAccounts[accountIndex],
-      role: AccountRole.WRITABLE
-    });
-    accountIndex++;
-  }
-  for (let i = 0; i < header.numReadonlyNonSignerAccounts; i++) {
-    accountMetas.push({
-      address: message.staticAccounts[accountIndex],
-      role: AccountRole.READONLY
-    });
-    accountIndex++;
-  }
-  return accountMetas;
-}
-function convertInstruction(instruction, accountMetas) {
-  const programAddress = accountMetas[instruction.programAddressIndex]?.address;
-  if (!programAddress) {
-    throw new Error(`Could not find program address at index ${instruction.programAddressIndex}`);
-  }
-  const accounts = instruction.accountIndices?.map((accountIndex) => accountMetas[accountIndex]);
-  const { data } = instruction;
-  return {
-    programAddress,
-    ...accounts && accounts.length ? { accounts } : {},
-    ...data && data.length ? { data } : {}
-  };
-}
-function getLifetimeConstraint(messageLifetimeToken, firstInstruction, lastValidBlockHeight) {
-  if (!firstInstruction || !isAdvanceNonceAccountInstruction(firstInstruction)) {
-    return {
-      blockhash: messageLifetimeToken,
-      lastValidBlockHeight: lastValidBlockHeight ?? 2n ** 64n - 1n
-      // U64 MAX
-    };
-  } else {
-    const nonceAccountAddress = firstInstruction.accounts[0].address;
-    addresses.assertIsAddress(nonceAccountAddress);
-    const nonceAuthorityAddress = firstInstruction.accounts[2].address;
-    addresses.assertIsAddress(nonceAuthorityAddress);
-    return {
-      nonce: messageLifetimeToken,
-      nonceAccountAddress,
-      nonceAuthorityAddress
-    };
-  }
-}
-function convertSignatures(compiledTransaction) {
-  const {
-    compiledMessage: { staticAccounts },
-    signatures
-  } = compiledTransaction;
-  return signatures.reduce((acc, sig, index) => {
-    const allZeros = sig.every((byte) => byte === 0);
-    if (allZeros)
-      return acc;
-    const address = staticAccounts[index];
-    return { ...acc, [address]: sig };
-  }, {});
-}
-function decompileTransaction(compiledTransaction, lastValidBlockHeight) {
-  const { compiledMessage } = compiledTransaction;
-  if ("addressTableLookups" in compiledMessage && compiledMessage.addressTableLookups.length > 0) {
-    throw new Error("Cannot convert transaction with addressTableLookups");
-  }
-  const feePayer = compiledMessage.staticAccounts[0];
-  if (!feePayer)
-    throw new Error("No fee payer set in CompiledTransaction");
-  const accountMetas = getAccountMetas(compiledMessage);
-  const instructions = compiledMessage.instructions.map(
-    (compiledInstruction) => convertInstruction(compiledInstruction, accountMetas)
-  );
-  const firstInstruction = instructions[0];
-  const lifetimeConstraint = getLifetimeConstraint(
-    compiledMessage.lifetimeToken,
-    firstInstruction,
-    lastValidBlockHeight
-  );
-  const signatures = convertSignatures(compiledTransaction);
-  return functional.pipe(
-    createTransaction({ version: compiledMessage.version }),
-    (tx) => setTransactionFeePayer(feePayer, tx),
-    (tx) => instructions.reduce((acc, instruction) => {
-      return appendTransactionInstruction(instruction, acc);
-    }, tx),
-    (tx) => "blockhash" in lifetimeConstraint ? setTransactionLifetimeUsingBlockhash(lifetimeConstraint, tx) : setTransactionLifetimeUsingDurableNonce(lifetimeConstraint, tx),
-    (tx) => compiledTransaction.signatures.length ? { ...tx, signatures } : tx
-  );
-}
 var lookupTableAddressDescription = __DEV__ ? "The address of the address lookup table account from which instruction addresses should be looked up" : "lookupTableAddress";
 var writableIndicesDescription = __DEV__ ? "The indices of the accounts in the lookup table that should be loaded as writeable" : "writableIndices";
 var readableIndicesDescription = __DEV__ ? "The indices of the accounts in the lookup table that should be loaded as read-only" : "readableIndices";
@@ -930,6 +801,137 @@ function getCompiledMessageDecoder() {
     }
   );
 }
+function getCompiledMessageCodec() {
+  return codecsCore.combineCodec(getCompiledMessageEncoder(), getCompiledMessageDecoder());
+}
+
+// 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 getAccountMetas(message) {
+  const { header } = message;
+  const numWritableSignerAccounts = header.numSignerAccounts - header.numReadonlySignerAccounts;
+  const numWritableNonSignerAccounts = message.staticAccounts.length - header.numSignerAccounts - header.numReadonlyNonSignerAccounts;
+  const accountMetas = [];
+  let accountIndex = 0;
+  for (let i = 0; i < numWritableSignerAccounts; i++) {
+    accountMetas.push({
+      address: message.staticAccounts[accountIndex],
+      role: AccountRole.WRITABLE_SIGNER
+    });
+    accountIndex++;
+  }
+  for (let i = 0; i < header.numReadonlySignerAccounts; i++) {
+    accountMetas.push({
+      address: message.staticAccounts[accountIndex],
+      role: AccountRole.READONLY_SIGNER
+    });
+    accountIndex++;
+  }
+  for (let i = 0; i < numWritableNonSignerAccounts; i++) {
+    accountMetas.push({
+      address: message.staticAccounts[accountIndex],
+      role: AccountRole.WRITABLE
+    });
+    accountIndex++;
+  }
+  for (let i = 0; i < header.numReadonlyNonSignerAccounts; i++) {
+    accountMetas.push({
+      address: message.staticAccounts[accountIndex],
+      role: AccountRole.READONLY
+    });
+    accountIndex++;
+  }
+  return accountMetas;
+}
+function convertInstruction(instruction, accountMetas) {
+  const programAddress = accountMetas[instruction.programAddressIndex]?.address;
+  if (!programAddress) {
+    throw new Error(`Could not find program address at index ${instruction.programAddressIndex}`);
+  }
+  const accounts = instruction.accountIndices?.map((accountIndex) => accountMetas[accountIndex]);
+  const { data } = instruction;
+  return {
+    programAddress,
+    ...accounts && accounts.length ? { accounts } : {},
+    ...data && data.length ? { data } : {}
+  };
+}
+function getLifetimeConstraint(messageLifetimeToken, firstInstruction, lastValidBlockHeight) {
+  if (!firstInstruction || !isAdvanceNonceAccountInstruction(firstInstruction)) {
+    return {
+      blockhash: messageLifetimeToken,
+      lastValidBlockHeight: lastValidBlockHeight ?? 2n ** 64n - 1n
+      // U64 MAX
+    };
+  } else {
+    const nonceAccountAddress = firstInstruction.accounts[0].address;
+    addresses.assertIsAddress(nonceAccountAddress);
+    const nonceAuthorityAddress = firstInstruction.accounts[2].address;
+    addresses.assertIsAddress(nonceAuthorityAddress);
+    return {
+      nonce: messageLifetimeToken,
+      nonceAccountAddress,
+      nonceAuthorityAddress
+    };
+  }
+}
+function convertSignatures(compiledTransaction) {
+  const {
+    compiledMessage: { staticAccounts },
+    signatures
+  } = compiledTransaction;
+  return signatures.reduce((acc, sig, index) => {
+    const allZeros = sig.every((byte) => byte === 0);
+    if (allZeros)
+      return acc;
+    const address = staticAccounts[index];
+    return { ...acc, [address]: sig };
+  }, {});
+}
+function decompileTransaction(compiledTransaction, lastValidBlockHeight) {
+  const { compiledMessage } = compiledTransaction;
+  if ("addressTableLookups" in compiledMessage && compiledMessage.addressTableLookups.length > 0) {
+    throw new Error("Cannot convert transaction with addressTableLookups");
+  }
+  const feePayer = compiledMessage.staticAccounts[0];
+  if (!feePayer)
+    throw new Error("No fee payer set in CompiledTransaction");
+  const accountMetas = getAccountMetas(compiledMessage);
+  const instructions = compiledMessage.instructions.map(
+    (compiledInstruction) => convertInstruction(compiledInstruction, accountMetas)
+  );
+  const firstInstruction = instructions[0];
+  const lifetimeConstraint = getLifetimeConstraint(
+    compiledMessage.lifetimeToken,
+    firstInstruction,
+    lastValidBlockHeight
+  );
+  const signatures = convertSignatures(compiledTransaction);
+  return functional.pipe(
+    createTransaction({ version: compiledMessage.version }),
+    (tx) => setTransactionFeePayer(feePayer, tx),
+    (tx) => instructions.reduce((acc, instruction) => {
+      return appendTransactionInstruction(instruction, acc);
+    }, tx),
+    (tx) => "blockhash" in lifetimeConstraint ? setTransactionLifetimeUsingBlockhash(lifetimeConstraint, tx) : setTransactionLifetimeUsingDurableNonce(lifetimeConstraint, tx),
+    (tx) => compiledTransaction.signatures.length ? { ...tx, signatures } : tx
+  );
+}
 
 // src/serializers/transaction.ts
 var signaturesDescription = __DEV__ ? "A compact array of 64-byte, base-64 encoded Ed25519 signatures" : "signatures";
@@ -983,47 +985,7 @@ function getTransactionDecoder(lastValidBlockHeight) {
 function getTransactionCodec(lastValidBlockHeight) {
   return codecsCore.combineCodec(getTransactionEncoder(), getTransactionDecoder(lastValidBlockHeight));
 }
-var base58Encoder2;
 var base58Decoder;
-function assertIsTransactionSignature(putativeTransactionSignature) {
-  if (!base58Encoder2)
-    base58Encoder2 = codecsStrings.getBase58Encoder();
-  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 bytes = base58Encoder2.encode(putativeTransactionSignature);
-    const numBytes = bytes.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 (!base58Encoder2)
-    base58Encoder2 = codecsStrings.getBase58Encoder();
-  if (
-    // Lowest value (64 bytes of zeroes)
-    putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
-    putativeTransactionSignature.length > 88
-  ) {
-    return false;
-  }
-  const bytes = base58Encoder2.encode(putativeTransactionSignature);
-  const numBytes = bytes.byteLength;
-  if (numBytes !== 64) {
-    return false;
-  }
-  return true;
-}
 function getSignatureFromTransaction(transaction) {
   if (!base58Decoder)
     base58Decoder = codecsStrings.getBase58Decoder();
@@ -1033,10 +995,10 @@ function getSignatureFromTransaction(transaction) {
       "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer."
     );
   }
-  const transactionSignature2 = base58Decoder.decode(signatureBytes)[0];
-  return transactionSignature2;
+  const transactionSignature = base58Decoder.decode(signatureBytes)[0];
+  return transactionSignature;
 }
-async function signTransaction(keyPairs, transaction) {
+async function partiallySignTransaction(keyPairs, transaction) {
   const compiledMessage = compileMessage(transaction);
   const nextSignatures = "signatures" in transaction ? { ...transaction.signatures } : {};
   const wireMessageBytes = getCompiledMessageEncoder().encode(compiledMessage);
@@ -1055,9 +1017,11 @@ async function signTransaction(keyPairs, transaction) {
   Object.freeze(out);
   return out;
 }
-function transactionSignature(putativeTransactionSignature) {
-  assertIsTransactionSignature(putativeTransactionSignature);
-  return putativeTransactionSignature;
+async function signTransaction(keyPairs, transaction) {
+  const out = await partiallySignTransaction(keyPairs, transaction);
+  assertTransactionIsFullySigned(out);
+  Object.freeze(out);
+  return out;
 }
 function assertTransactionIsFullySigned(transaction) {
   const signerAddressesFromInstructions = transaction.instructions.flatMap((i) => i.accounts?.filter((a) => isSignerRole(a.role)) ?? []).map((a) => a.address);
@@ -1068,31 +1032,31 @@ function assertTransactionIsFullySigned(transaction) {
     }
   });
 }
-
-// src/wire-transaction.ts
 function getBase64EncodedWireTransaction(transaction) {
   const wireTransactionBytes = getTransactionEncoder().encode(transaction);
-  {
-    return btoa(String.fromCharCode(...wireTransactionBytes));
-  }
+  return codecsStrings.getBase64Decoder().decode(wireTransactionBytes)[0];
 }
 
 exports.appendTransactionInstruction = appendTransactionInstruction;
 exports.assertIsBlockhash = assertIsBlockhash;
 exports.assertIsDurableNonceTransaction = assertIsDurableNonceTransaction;
-exports.assertIsTransactionSignature = assertIsTransactionSignature;
 exports.assertTransactionIsFullySigned = assertTransactionIsFullySigned;
+exports.compileMessage = compileMessage;
 exports.createTransaction = createTransaction;
 exports.getBase64EncodedWireTransaction = getBase64EncodedWireTransaction;
+exports.getCompiledMessageCodec = getCompiledMessageCodec;
+exports.getCompiledMessageDecoder = getCompiledMessageDecoder;
+exports.getCompiledMessageEncoder = getCompiledMessageEncoder;
 exports.getSignatureFromTransaction = getSignatureFromTransaction;
 exports.getTransactionCodec = getTransactionCodec;
 exports.getTransactionDecoder = getTransactionDecoder;
 exports.getTransactionEncoder = getTransactionEncoder;
 exports.isAdvanceNonceAccountInstruction = isAdvanceNonceAccountInstruction;
-exports.isTransactionSignature = isTransactionSignature;
+exports.partiallySignTransaction = partiallySignTransaction;
 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