@solana/transactions 2.0.0-experimental.ba21818 → 2.0.0-experimental.ba9b4c7

package/dist/index.browser.cjs

@@ -3,6 +3,8 @@
 var umiSerializers = require('@metaplex-foundation/umi-serializers');
 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 keys = require('@solana/keys');
 
 // ../build-scripts/env-shim.ts
@@ -32,8 +34,8 @@ function assertIsBlockhash(putativeBlockhash) {
     ) {
       throw new Error("Expected input string to decode to a byte array of length 32.");
     }
-    const bytes3 = umiSerializers.base58.serialize(putativeBlockhash);
-    const numBytes = bytes3.byteLength;
+    const bytes2 = umiSerializers.base58.serialize(putativeBlockhash);
+    const numBytes = bytes2.byteLength;
     if (numBytes !== 32) {
       throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
     }
@@ -463,137 +465,161 @@ function getCompiledTransaction(transaction) {
     signatures
   };
 }
-function addressSerializerCompat(compat) {
-  const codec = addresses.getAddressCodec();
-  return {
-    description: compat?.description ?? codec.description,
-    deserialize: codec.decode,
-    fixedSize: codec.fixedSize,
-    maxSize: codec.maxSize,
-    serialize: codec.encode
-  };
-}
-function getAddressTableLookupCodec() {
-  return umiSerializers.struct(
-    [
+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 = codecsDataStructures.getStructEncoder(
       [
-        "lookupTableAddress",
-        addressSerializerCompat(
-          __DEV__ ? {
-            description: "The address of the address lookup table account from which instruction addresses should be looked up"
-          } : void 0
-        )
+        ["lookupTableAddress", addresses.getAddressEncoder({ description: lookupTableAddressDescription })],
+        [
+          "writableIndices",
+          codecsDataStructures.getArrayEncoder(codecsNumbers.getU8Encoder(), {
+            description: writableIndicesDescription,
+            size: codecsNumbers.getShortU16Encoder()
+          })
+        ],
+        [
+          "readableIndices",
+          codecsDataStructures.getArrayEncoder(codecsNumbers.getU8Encoder(), {
+            description: readableIndicesDescription,
+            size: codecsNumbers.getShortU16Encoder()
+          })
+        ]
       ],
+      { description: addressTableLookupDescription }
+    );
+  }
+  return memoizedAddressTableLookupEncoder;
+}
+var memoizedAddressTableLookupDecoder;
+function getAddressTableLookupDecoder() {
+  if (!memoizedAddressTableLookupDecoder) {
+    memoizedAddressTableLookupDecoder = codecsDataStructures.getStructDecoder(
       [
-        "writableIndices",
-        umiSerializers.array(umiSerializers.u8(), {
-          ...__DEV__ ? {
-            description: "The indices of the accounts in the lookup table that should be loaded as writeable"
-          } : null,
-          size: umiSerializers.shortU16()
-        })
+        ["lookupTableAddress", addresses.getAddressDecoder({ description: lookupTableAddressDescription })],
+        [
+          "writableIndices",
+          codecsDataStructures.getArrayDecoder(codecsNumbers.getU8Decoder(), {
+            description: writableIndicesDescription,
+            size: codecsNumbers.getShortU16Decoder()
+          })
+        ],
+        [
+          "readableIndices",
+          codecsDataStructures.getArrayDecoder(codecsNumbers.getU8Decoder(), {
+            description: readableIndicesDescription,
+            size: codecsNumbers.getShortU16Decoder()
+          })
+        ]
       ],
-      [
-        "readableIndices",
-        umiSerializers.array(umiSerializers.u8(), {
-          ...__DEV__ ? {
-            description: "The indices of the accounts in the lookup table that should be loaded as read-only"
-          } : void 0,
-          size: umiSerializers.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 memoizedAddressTableLookupDecoder;
+}
+function getAddressTableLookupCodec() {
+  return codecsCore.combineCodec(getAddressTableLookupEncoder(), getAddressTableLookupDecoder());
+}
+var memoizedU8Codec;
+function getMemoizedU8Codec() {
+  if (!memoizedU8Codec)
+    memoizedU8Codec = codecsNumbers.getU8Codec();
+  return memoizedU8Codec;
 }
+function getMemoizedU8CodecDescription(description) {
+  const codec = getMemoizedU8Codec();
+  return {
+    ...codec,
+    description: description ?? codec.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 getMessageHeaderCodec() {
-  return umiSerializers.struct(
+  return codecsDataStructures.getStructCodec(
     [
-      [
-        "numSignerAccounts",
-        umiSerializers.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",
-        umiSerializers.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",
-        umiSerializers.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", getMemoizedU8CodecDescription(numSignerAccountsDescription)],
+      ["numReadonlySignerAccounts", getMemoizedU8CodecDescription(numReadonlySignerAccountsDescription)],
+      ["numReadonlyNonSignerAccounts", getMemoizedU8CodecDescription(numReadonlyNonSignerAccountsDescription)]
     ],
-    __DEV__ ? {
-      description: "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses"
-    } : void 0
+    {
+      description: messageHeaderDescription
+    }
   );
 }
-function getInstructionCodec() {
-  return umiSerializers.mapSerializer(
-    umiSerializers.struct([
-      [
-        "programAddressIndex",
-        umiSerializers.u8(
-          __DEV__ ? {
-            description: "The index of the program being called, according to the well-ordered accounts list for this transaction"
-          } : void 0
-        )
-      ],
-      [
-        "accountIndices",
-        umiSerializers.array(
-          umiSerializers.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: umiSerializers.shortU16()
-          }
-        )
-      ],
-      [
-        "data",
-        umiSerializers.bytes({
-          description: __DEV__ ? "An optional buffer of data passed to the instruction" : "",
-          size: umiSerializers.shortU16()
-        })
-      ]
-    ]),
-    (value) => {
-      if (value.accountIndices !== void 0 && value.data !== void 0) {
-        return value;
+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 = codecsCore.mapEncoder(
+      codecsDataStructures.getStructEncoder([
+        ["programAddressIndex", codecsNumbers.getU8Encoder({ description: programAddressIndexDescription })],
+        [
+          "accountIndices",
+          codecsDataStructures.getArrayEncoder(codecsNumbers.getU8Encoder({ description: accountIndexDescription }), {
+            description: accountIndicesDescription,
+            size: codecsNumbers.getShortU16Encoder()
+          })
+        ],
+        ["data", codecsDataStructures.getBytesEncoder({ description: dataDescription, size: codecsNumbers.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 {
-        ...value,
-        accountIndices: value.accountIndices ?? [],
-        data: value.data ?? new Uint8Array(0)
-      };
-    },
-    (value) => {
-      if (value.accountIndices.length && value.data.byteLength) {
-        return value;
+    );
+  }
+  return memoizedGetInstructionEncoder;
+}
+var memoizedGetInstructionDecoder;
+function getInstructionDecoder() {
+  if (!memoizedGetInstructionDecoder) {
+    memoizedGetInstructionDecoder = codecsCore.mapDecoder(
+      codecsDataStructures.getStructDecoder([
+        ["programAddressIndex", codecsNumbers.getU8Decoder({ description: programAddressIndexDescription })],
+        [
+          "accountIndices",
+          codecsDataStructures.getArrayDecoder(codecsNumbers.getU8Decoder({ description: accountIndexDescription }), {
+            description: accountIndicesDescription,
+            size: codecsNumbers.getShortU16Decoder()
+          })
+        ],
+        ["data", codecsDataStructures.getBytesDecoder({ description: dataDescription, size: codecsNumbers.getShortU16Decoder() })]
+      ]),
+      // Convert an instruction to exclude optional fields if they are empty
+      (instruction) => {
+        if (instruction.accountIndices.length && instruction.data.byteLength) {
+          return instruction;
+        }
+        const { accountIndices, data, ...rest } = instruction;
+        return {
+          ...rest,
+          ...accountIndices.length ? { accountIndices } : null,
+          ...data.byteLength ? { data } : null
+        };
       }
-      const { accountIndices, data, ...rest } = value;
-      return {
-        ...rest,
-        ...accountIndices.length ? { accountIndices } : null,
-        ...data.byteLength ? { data } : null
-      };
-    }
-  );
+    );
+  }
+  return memoizedGetInstructionDecoder;
+}
+function getInstructionCodec() {
+  return codecsCore.combineCodec(getInstructionEncoder(), getInstructionDecoder());
 }
 var VERSION_FLAG_MASK = 128;
 var BASE_CONFIG = {
@@ -601,8 +627,8 @@ var BASE_CONFIG = {
   fixedSize: null,
   maxSize: 1
 };
-function decode(bytes3, offset = 0) {
-  const firstByte = bytes3[offset];
+function decode(bytes2, offset = 0) {
+  const firstByte = bytes2[offset];
   if ((firstByte & VERSION_FLAG_MASK) === 0) {
     return ["legacy", offset];
   } else {
@@ -675,18 +701,7 @@ function serialize(compiledMessage) {
     ).serialize(compiledMessage);
   }
 }
-function addressSerializerCompat2() {
-  const codec = addresses.getAddressCodec();
-  return {
-    description: codec.description,
-    deserialize: codec.decode,
-    fixedSize: codec.fixedSize,
-    maxSize: codec.maxSize,
-    serialize: codec.encode
-  };
-}
-function transactionVersionSerializerCompat() {
-  const codec = getTransactionVersionCodec();
+function toSerializer(codec) {
   return {
     description: codec.description,
     deserialize: codec.decode,
@@ -697,11 +712,11 @@ function transactionVersionSerializerCompat() {
 }
 function getPreludeStructSerializerTuple() {
   return [
-    ["version", transactionVersionSerializerCompat()],
-    ["header", getMessageHeaderCodec()],
+    ["version", toSerializer(getTransactionVersionCodec())],
+    ["header", toSerializer(getMessageHeaderCodec())],
     [
       "staticAccounts",
-      umiSerializers.array(addressSerializerCompat2(), {
+      umiSerializers.array(toSerializer(addresses.getAddressCodec()), {
         description: __DEV__ ? "A compact-array of static account addresses belonging to this transaction" : "",
         size: umiSerializers.shortU16()
       })
@@ -716,7 +731,7 @@ function getPreludeStructSerializerTuple() {
     ],
     [
       "instructions",
-      umiSerializers.array(getInstructionCodec(), {
+      umiSerializers.array(toSerializer(getInstructionCodec()), {
         description: __DEV__ ? "A compact-array of instructions belonging to this transaction" : "",
         size: umiSerializers.shortU16()
       })
@@ -724,7 +739,7 @@ function getPreludeStructSerializerTuple() {
   ];
 }
 function getAddressTableLookupsSerializer() {
-  return umiSerializers.array(getAddressTableLookupCodec(), {
+  return umiSerializers.array(toSerializer(getAddressTableLookupCodec()), {
     ...__DEV__ ? { description: "A compact array of address table lookups belonging to this transaction" } : null,
     size: umiSerializers.shortU16()
   });
@@ -772,8 +787,8 @@ function assertIsTransactionSignature(putativeTransactionSignature) {
     ) {
       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;
+    const bytes2 = umiSerializers.base58.serialize(putativeTransactionSignature);
+    const numBytes = bytes2.byteLength;
     if (numBytes !== 64) {
       throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
     }
@@ -791,8 +806,8 @@ function isTransactionSignature(putativeTransactionSignature) {
   ) {
     return false;
   }
-  const bytes3 = umiSerializers.base58.serialize(putativeTransactionSignature);
-  const numBytes = bytes3.byteLength;
+  const bytes2 = umiSerializers.base58.serialize(putativeTransactionSignature);
+  const numBytes = bytes2.byteLength;
   if (numBytes !== 64) {
     return false;
   }
@@ -804,13 +819,14 @@ async function getCompiledMessageSignature(message, secretKey) {
   return signature;
 }
 function getSignatureFromTransaction(transaction) {
-  const signature = transaction.signatures[transaction.feePayer];
-  if (!signature) {
+  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."
     );
   }
-  return signature;
+  const transactionSignature2 = umiSerializers.base58.deserialize(signatureBytes)[0];
+  return transactionSignature2;
 }
 async function signTransaction(keyPairs, transaction) {
   const compiledMessage = compileMessage(transaction);
@@ -854,6 +870,7 @@ exports.createTransaction = createTransaction;
 exports.getBase64EncodedWireTransaction = getBase64EncodedWireTransaction;
 exports.getSignatureFromTransaction = getSignatureFromTransaction;
 exports.getTransactionEncoder = getTransactionEncoder;
+exports.isAdvanceNonceAccountInstruction = isAdvanceNonceAccountInstruction;
 exports.isTransactionSignature = isTransactionSignature;
 exports.prependTransactionInstruction = prependTransactionInstruction;
 exports.setTransactionFeePayer = setTransactionFeePayer;
@@ -861,5 +878,3 @@ exports.setTransactionLifetimeUsingBlockhash = setTransactionLifetimeUsingBlockh
 exports.setTransactionLifetimeUsingDurableNonce = setTransactionLifetimeUsingDurableNonce;
 exports.signTransaction = signTransaction;
 exports.transactionSignature = transactionSignature;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.browser.cjs.map