@solana/transactions 2.0.0-experimental.dc614af → 2.0.0-experimental.df45965

package/dist/index.browser.js

@@ -1,5 +1,9 @@
-import { base58, struct, array, bytes, shortU16, mapSerializer, string, u8 } from '@metaplex-foundation/umi-serializers';
-import { getAddressFromPublicKey, getBase58EncodedAddressComparator, getBase58EncodedAddressCodec } from '@solana/addresses';
+import { base58 } from '@metaplex-foundation/umi-serializers';
+import { mapEncoder } from '@solana/codecs-core';
+import { getStructEncoder, getArrayEncoder, getBytesEncoder } from '@solana/codecs-data-structures';
+import { getShortU16Encoder, getU8Encoder } from '@solana/codecs-numbers';
+import { getAddressFromPublicKey, getAddressComparator, getAddressEncoder } from '@solana/addresses';
+import { getStringEncoder, getBase58Encoder } from '@solana/codecs-strings';
 import { signBytes } from '@solana/keys';
 
 // ../build-scripts/env-shim.ts
@@ -29,8 +33,8 @@ function assertIsBlockhash(putativeBlockhash) {
     ) {
       throw new Error("Expected input string to decode to a byte array of length 32.");
     }
-    const bytes3 = base58.serialize(putativeBlockhash);
-    const numBytes = bytes3.byteLength;
+    const bytes = base58.serialize(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}`);
     }
@@ -228,7 +232,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
@@ -334,7 +338,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 {
@@ -363,7 +367,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]
   }));
@@ -442,159 +446,124 @@ function compileMessage(transaction) {
     version: transaction.version
   };
 }
-function getAddressTableLookupCodec() {
-  return struct(
-    [
-      [
-        "lookupTableAddress",
-        getBase58EncodedAddressCodec(
-          __DEV__ ? {
-            description: "The address of the address lookup table account from which instruction addresses should be looked up"
-          } : void 0
-        )
-      ],
+
+// 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
+  };
+}
+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";
+var addressTableLookupDescription = __DEV__ ? "A pointer to the address of an address lookup table, along with the readonly/writeable indices of the addresses that should be loaded from it" : "addressTableLookup";
+var memoizedAddressTableLookupEncoder;
+function getAddressTableLookupEncoder() {
+  if (!memoizedAddressTableLookupEncoder) {
+    memoizedAddressTableLookupEncoder = getStructEncoder(
       [
-        "writableIndices",
-        array(u8(), {
-          ...__DEV__ ? {
-            description: "The indices of the accounts in the lookup table that should be loaded as writeable"
-          } : null,
-          size: shortU16()
-        })
+        ["lookupTableAddress", getAddressEncoder({ description: lookupTableAddressDescription })],
+        [
+          "writableIndices",
+          getArrayEncoder(getU8Encoder(), {
+            description: writableIndicesDescription,
+            size: getShortU16Encoder()
+          })
+        ],
+        [
+          "readableIndices",
+          getArrayEncoder(getU8Encoder(), {
+            description: readableIndicesDescription,
+            size: getShortU16Encoder()
+          })
+        ]
       ],
-      [
-        "readableIndices",
-        array(u8(), {
-          ...__DEV__ ? {
-            description: "The indices of the accounts in the lookup table that should be loaded as read-only"
-          } : void 0,
-          size: shortU16()
-        })
-      ]
-    ],
-    __DEV__ ? {
-      description: "A pointer to the address of an address lookup table, along with the readonly/writeable indices of the addresses that should be loaded from it"
-    } : void 0
-  );
+      { description: addressTableLookupDescription }
+    );
+  }
+  return memoizedAddressTableLookupEncoder;
+}
+var memoizedU8Encoder;
+function getMemoizedU8Encoder() {
+  if (!memoizedU8Encoder)
+    memoizedU8Encoder = getU8Encoder();
+  return memoizedU8Encoder;
 }
-function getMessageHeaderCodec() {
-  return struct(
+function getMemoizedU8EncoderDescription(description) {
+  const encoder = getMemoizedU8Encoder();
+  return {
+    ...encoder,
+    description: description ?? encoder.description
+  };
+}
+var numSignerAccountsDescription = __DEV__ ? "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction" : void 0;
+var numReadonlySignerAccountsDescription = __DEV__ ? "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction, but may not be writable" : void 0;
+var numReadonlyNonSignerAccountsDescription = __DEV__ ? "The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable" : void 0;
+var messageHeaderDescription = __DEV__ ? "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses" : void 0;
+function getMessageHeaderEncoder() {
+  return getStructEncoder(
     [
-      [
-        "numSignerAccounts",
-        u8(
-          __DEV__ ? {
-            description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction"
-          } : void 0
-        )
-      ],
-      [
-        "numReadonlySignerAccounts",
-        u8(
-          __DEV__ ? {
-            description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction, but may not be writable"
-          } : void 0
-        )
-      ],
-      [
-        "numReadonlyNonSignerAccounts",
-        u8(
-          __DEV__ ? {
-            description: "The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable"
-          } : void 0
-        )
-      ]
+      ["numSignerAccounts", getMemoizedU8EncoderDescription(numSignerAccountsDescription)],
+      ["numReadonlySignerAccounts", getMemoizedU8EncoderDescription(numReadonlySignerAccountsDescription)],
+      ["numReadonlyNonSignerAccounts", getMemoizedU8EncoderDescription(numReadonlyNonSignerAccountsDescription)]
     ],
-    __DEV__ ? {
-      description: "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses"
-    } : void 0
-  );
-}
-function getInstructionCodec() {
-  return mapSerializer(
-    struct([
-      [
-        "programAddressIndex",
-        u8(
-          __DEV__ ? {
-            description: "The index of the program being called, according to the well-ordered accounts list for this transaction"
-          } : void 0
-        )
-      ],
-      [
-        "accountIndices",
-        array(
-          u8({
-            description: __DEV__ ? "The index of an account, according to the well-ordered accounts list for this transaction" : ""
-          }),
-          {
-            description: __DEV__ ? "An optional list of account indices, according to the well-ordered accounts list for this transaction, in the order in which the program being called expects them" : "",
-            size: shortU16()
-          }
-        )
-      ],
-      [
-        "data",
-        bytes({
-          description: __DEV__ ? "An optional buffer of data passed to the instruction" : "",
-          size: shortU16()
-        })
-      ]
-    ]),
-    (value) => {
-      if (value.accountIndices !== void 0 && value.data !== void 0) {
-        return value;
-      }
-      return {
-        ...value,
-        accountIndices: value.accountIndices ?? [],
-        data: value.data ?? new Uint8Array(0)
-      };
-    },
-    (value) => {
-      if (value.accountIndices.length && value.data.byteLength) {
-        return value;
-      }
-      const { accountIndices, data, ...rest } = value;
-      return {
-        ...rest,
-        ...accountIndices.length ? { accountIndices } : null,
-        ...data.byteLength ? { data } : null
-      };
+    {
+      description: messageHeaderDescription
     }
   );
 }
-
-// src/serializers/unimplemented.ts
-function getError(type, name) {
-  const functionSuffix = name + type[0].toUpperCase() + type.slice(1);
-  return new Error(
-    `No ${type} exists for ${name}. Use \`get${functionSuffix}()\` if you need a ${type}, and \`get${name}Codec()\` if you need to both encode and decode ${name}`
-  );
-}
-function getUnimplementedDecoder(name) {
-  return () => {
-    throw getError("decoder", name);
-  };
+var programAddressIndexDescription = __DEV__ ? "The index of the program being called, according to the well-ordered accounts list for this transaction" : "programAddressIndex";
+var accountIndexDescription = __DEV__ ? "The index of an account, according to the well-ordered accounts list for this transaction" : void 0;
+var accountIndicesDescription = __DEV__ ? "An optional list of account indices, according to the well-ordered accounts list for this transaction, in the order in which the program being called expects them" : "accountIndices";
+var dataDescription = __DEV__ ? "An optional buffer of data passed to the instruction" : "data";
+var memoizedGetInstructionEncoder;
+function getInstructionEncoder() {
+  if (!memoizedGetInstructionEncoder) {
+    memoizedGetInstructionEncoder = mapEncoder(
+      getStructEncoder([
+        ["programAddressIndex", getU8Encoder({ description: programAddressIndexDescription })],
+        [
+          "accountIndices",
+          getArrayEncoder(getU8Encoder({ description: accountIndexDescription }), {
+            description: accountIndicesDescription,
+            size: getShortU16Encoder()
+          })
+        ],
+        ["data", getBytesEncoder({ description: dataDescription, size: getShortU16Encoder() })]
+      ]),
+      // Convert an instruction to have all fields defined
+      (instruction) => {
+        if (instruction.accountIndices !== void 0 && instruction.data !== void 0) {
+          return instruction;
+        }
+        return {
+          ...instruction,
+          accountIndices: instruction.accountIndices ?? [],
+          data: instruction.data ?? new Uint8Array(0)
+        };
+      }
+    );
+  }
+  return memoizedGetInstructionEncoder;
 }
-
-// src/serializers/transaction-version.ts
 var VERSION_FLAG_MASK = 128;
 var BASE_CONFIG = {
   description: __DEV__ ? "A single byte that encodes the version of the transaction" : "",
   fixedSize: null,
   maxSize: 1
 };
-function deserialize(bytes3, offset = 0) {
-  const firstByte = bytes3[offset];
-  if ((firstByte & VERSION_FLAG_MASK) === 0) {
-    return ["legacy", offset];
-  } else {
-    const version = firstByte ^ VERSION_FLAG_MASK;
-    return [version, offset + 1];
-  }
-}
-function serialize(value) {
+function encode(value) {
   if (value === "legacy") {
     return new Uint8Array();
   }
@@ -603,99 +572,175 @@ function serialize(value) {
   }
   return new Uint8Array([value | VERSION_FLAG_MASK]);
 }
-function getTransactionVersionCodec() {
+function getTransactionVersionEncoder() {
   return {
     ...BASE_CONFIG,
-    deserialize,
-    serialize
+    encode
   };
 }
 
 // src/serializers/message.ts
-var BASE_CONFIG2 = {
-  description: __DEV__ ? "The wire format of a Solana transaction message" : "",
-  fixedSize: null,
-  maxSize: null
-};
-function serialize2(compiledMessage) {
-  if (compiledMessage.version === "legacy") {
-    return struct(getPreludeStructSerializerTuple()).serialize(compiledMessage);
-  } else {
-    return mapSerializer(
-      struct([
-        ...getPreludeStructSerializerTuple(),
-        ["addressTableLookups", getAddressTableLookupsSerializer()]
-      ]),
-      (value) => {
-        if (value.version === "legacy") {
-          return value;
-        }
-        return {
-          ...value,
-          addressTableLookups: value.addressTableLookups ?? []
-        };
+var staticAccountsDescription = __DEV__ ? "A compact-array of static account addresses belonging to this transaction" : "staticAccounts";
+var lifetimeTokenDescription = __DEV__ ? "A 32-byte token that specifies the lifetime of this transaction (eg. a recent blockhash, or a durable nonce)" : "lifetimeToken";
+var instructionsDescription = __DEV__ ? "A compact-array of instructions belonging to this transaction" : "instructions";
+var addressTableLookupsDescription = __DEV__ ? "A compact array of address table lookups belonging to this transaction" : "addressTableLookups";
+function getCompiledMessageLegacyEncoder() {
+  return getStructEncoder(getPreludeStructEncoderTuple());
+}
+function getCompiledMessageVersionedEncoder() {
+  return mapEncoder(
+    getStructEncoder([
+      ...getPreludeStructEncoderTuple(),
+      ["addressTableLookups", getAddressTableLookupArrayEncoder()]
+    ]),
+    (value) => {
+      if (value.version === "legacy") {
+        return value;
       }
-    ).serialize(compiledMessage);
-  }
+      return {
+        ...value,
+        addressTableLookups: value.addressTableLookups ?? []
+      };
+    }
+  );
 }
-function getPreludeStructSerializerTuple() {
+function getPreludeStructEncoderTuple() {
   return [
-    ["version", getTransactionVersionCodec()],
-    ["header", getMessageHeaderCodec()],
+    ["version", getTransactionVersionEncoder()],
+    ["header", getMessageHeaderEncoder()],
     [
       "staticAccounts",
-      array(getBase58EncodedAddressCodec(), {
-        description: __DEV__ ? "A compact-array of static account addresses belonging to this transaction" : "",
-        size: shortU16()
+      getArrayEncoder(getAddressEncoder(), {
+        description: staticAccountsDescription,
+        size: getShortU16Encoder()
       })
     ],
     [
       "lifetimeToken",
-      string({
-        description: __DEV__ ? "A 32-byte token that specifies the lifetime of this transaction (eg. a recent blockhash, or a durable nonce)" : "",
-        encoding: base58,
+      getStringEncoder({
+        description: lifetimeTokenDescription,
+        encoding: getBase58Encoder(),
         size: 32
       })
     ],
     [
       "instructions",
-      array(getInstructionCodec(), {
-        description: __DEV__ ? "A compact-array of instructions belonging to this transaction" : "",
-        size: shortU16()
+      getArrayEncoder(getInstructionEncoder(), {
+        description: instructionsDescription,
+        size: getShortU16Encoder()
       })
     ]
   ];
 }
-function getAddressTableLookupsSerializer() {
-  return array(getAddressTableLookupCodec(), {
-    ...__DEV__ ? { description: "A compact array of address table lookups belonging to this transaction" } : null,
-    size: shortU16()
+function getAddressTableLookupArrayEncoder() {
+  return getArrayEncoder(getAddressTableLookupEncoder(), {
+    description: addressTableLookupsDescription,
+    size: getShortU16Encoder()
   });
 }
+var messageDescription = __DEV__ ? "The wire format of a Solana transaction message" : "message";
 function getCompiledMessageEncoder() {
   return {
-    ...BASE_CONFIG2,
-    deserialize: getUnimplementedDecoder("CompiledMessage"),
-    serialize: serialize2
+    description: messageDescription,
+    encode: (compiledMessage) => {
+      if (compiledMessage.version === "legacy") {
+        return getCompiledMessageLegacyEncoder().encode(compiledMessage);
+      } else {
+        return getCompiledMessageVersionedEncoder().encode(compiledMessage);
+      }
+    },
+    fixedSize: null,
+    maxSize: null
   };
 }
 
-// src/signatures.ts
+// src/serializers/transaction.ts
+var transactionDescription = __DEV__ ? "The wire format of a Solana transaction" : "transaction";
+var signaturesDescription = __DEV__ ? "A compact array of 64-byte, base-64 encoded Ed25519 signatures" : "signatures";
+function getCompiledTransactionEncoder() {
+  return getStructEncoder(
+    [
+      [
+        "signatures",
+        getArrayEncoder(getBytesEncoder({ size: 64 }), {
+          description: signaturesDescription,
+          size: getShortU16Encoder()
+        })
+      ],
+      ["compiledMessage", getCompiledMessageEncoder()]
+    ],
+    {
+      description: transactionDescription
+    }
+  );
+}
+function getTransactionEncoder() {
+  return mapEncoder(getCompiledTransactionEncoder(), getCompiledTransaction);
+}
+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 = 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 = base58.serialize(putativeTransactionSignature);
+  const numBytes = bytes.byteLength;
+  if (numBytes !== 64) {
+    return false;
+  }
+  return true;
+}
 async function getCompiledMessageSignature(message, secretKey) {
-  const wireMessageBytes = getCompiledMessageEncoder().serialize(message);
+  const wireMessageBytes = getCompiledMessageEncoder().encode(message);
   const signature = await signBytes(secretKey, wireMessageBytes);
   return signature;
 }
-async function signTransaction(keyPair, transaction) {
+function getSignatureFromTransaction(transaction) {
+  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 = base58.deserialize(signatureBytes)[0];
+  return transactionSignature2;
+}
+async function signTransaction(keyPairs, transaction) {
   const compiledMessage = compileMessage(transaction);
-  const [signerPublicKey, signature] = await Promise.all([
-    getAddressFromPublicKey(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([
+        getAddressFromPublicKey(keyPair.publicKey),
+        getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
+      ])
+    )
+  );
+  for (const [signerPublicKey, signature] of publicKeySignaturePairs) {
+    nextSignatures[signerPublicKey] = signature;
+  }
   const out = {
     ...transaction,
     signatures: nextSignatures
@@ -703,60 +748,17 @@ async function signTransaction(keyPair, transaction) {
   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" : "",
-  fixedSize: null,
-  maxSize: null
-};
-function serialize3(transaction) {
-  const compiledTransaction = getCompiledTransaction(transaction);
-  return struct([
-    [
-      "signatures",
-      array(bytes({ size: 64 }), {
-        ...__DEV__ ? { description: "A compact array of 64-byte, base-64 encoded Ed25519 signatures" } : null,
-        size: shortU16()
-      })
-    ],
-    ["compiledMessage", getCompiledMessageEncoder()]
-  ]).serialize(compiledTransaction);
-}
-function getTransactionEncoder() {
-  return {
-    ...BASE_CONFIG3,
-    deserialize: getUnimplementedDecoder("CompiledMessage"),
-    serialize: serialize3
-  };
+function transactionSignature(putativeTransactionSignature) {
+  assertIsTransactionSignature(putativeTransactionSignature);
+  return putativeTransactionSignature;
 }
 
 // src/wire-transaction.ts
 function getBase64EncodedWireTransaction(transaction) {
-  const wireTransactionBytes = getTransactionEncoder().serialize(transaction);
+  const wireTransactionBytes = getTransactionEncoder().encode(transaction);
   {
     return btoa(String.fromCharCode(...wireTransactionBytes));
   }
 }
 
-export { appendTransactionInstruction, assertIsBlockhash, assertIsDurableNonceTransaction, createTransaction, getBase64EncodedWireTransaction, prependTransactionInstruction, setTransactionFeePayer, setTransactionLifetimeUsingBlockhash, setTransactionLifetimeUsingDurableNonce, signTransaction };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.browser.js.map
+export { appendTransactionInstruction, assertIsBlockhash, assertIsDurableNonceTransaction, assertIsTransactionSignature, createTransaction, getBase64EncodedWireTransaction, getSignatureFromTransaction, getTransactionEncoder, isAdvanceNonceAccountInstruction, isTransactionSignature, prependTransactionInstruction, setTransactionFeePayer, setTransactionLifetimeUsingBlockhash, setTransactionLifetimeUsingDurableNonce, signTransaction, transactionSignature };