@solana/transactions 2.0.0-experimental.10bfcd8 → 2.0.0-experimental.13ef878

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,12 +1,11 @@
 'use strict';
 
-var umiSerializers = require('@metaplex-foundation/umi-serializers');
+var codecsStrings = require('@solana/codecs-strings');
 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 codecsStrings = require('@solana/codecs-strings');
 var keys = require('@solana/keys');
 
 // ../build-scripts/env-shim.ts
@@ -27,7 +26,10 @@ function getUnsignedTransaction(transaction) {
 }
 
 // src/blockhash.ts
+var base58Encoder;
 function assertIsBlockhash(putativeBlockhash) {
+  if (!base58Encoder)
+    base58Encoder = codecsStrings.getBase58Encoder();
   try {
     if (
       // Lowest value (32 bytes of zeroes)
@@ -36,7 +38,7 @@ function assertIsBlockhash(putativeBlockhash) {
     ) {
       throw new Error("Expected input string to decode to a byte array of length 32.");
     }
-    const bytes = umiSerializers.base58.serialize(putativeBlockhash);
+    const bytes = base58Encoder.encode(putativeBlockhash);
     const numBytes = bytes.byteLength;
     if (numBytes !== 32) {
       throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
@@ -981,52 +983,20 @@ function getTransactionDecoder(lastValidBlockHeight) {
 function getTransactionCodec(lastValidBlockHeight) {
   return codecsCore.combineCodec(getTransactionEncoder(), getTransactionDecoder(lastValidBlockHeight));
 }
-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 bytes = umiSerializers.base58.serialize(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 (
-    // Lowest value (64 bytes of zeroes)
-    putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
-    putativeTransactionSignature.length > 88
-  ) {
-    return false;
-  }
-  const bytes = umiSerializers.base58.serialize(putativeTransactionSignature);
-  const numBytes = bytes.byteLength;
-  if (numBytes !== 64) {
-    return false;
-  }
-  return true;
-}
+var base58Decoder;
 function getSignatureFromTransaction(transaction) {
+  if (!base58Decoder)
+    base58Decoder = codecsStrings.getBase58Decoder();
   const signatureBytes = transaction.signatures[transaction.feePayer];
   if (!signatureBytes) {
     throw new Error(
       "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer."
     );
   }
-  const transactionSignature2 = umiSerializers.base58.deserialize(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);
@@ -1045,9 +1015,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);
@@ -1070,7 +1042,6 @@ function getBase64EncodedWireTransaction(transaction) {
 exports.appendTransactionInstruction = appendTransactionInstruction;
 exports.assertIsBlockhash = assertIsBlockhash;
 exports.assertIsDurableNonceTransaction = assertIsDurableNonceTransaction;
-exports.assertIsTransactionSignature = assertIsTransactionSignature;
 exports.assertTransactionIsFullySigned = assertTransactionIsFullySigned;
 exports.createTransaction = createTransaction;
 exports.getBase64EncodedWireTransaction = getBase64EncodedWireTransaction;
@@ -1079,12 +1050,11 @@ 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