@solana/web3.js 2.0.0-experimental.ba21818 → 2.0.0-experimental.ba9b4c7

package/dist/index.development.js

@@ -224,6 +224,17 @@ this.globalThis.solanaWeb3 = (function (exports) {
       maxSize: encoder.maxSize
     };
   }
+  function mapDecoder(decoder, map) {
+    return {
+      decode: (bytes2, offset = 0) => {
+        const [value, length] = decoder.decode(bytes2, offset);
+        return [map(value, bytes2, offset), length];
+      },
+      description: decoder.description,
+      fixedSize: decoder.fixedSize,
+      maxSize: decoder.maxSize
+    };
+  }
 
   // ../codecs-strings/dist/index.browser.js
   init_env_shim();
@@ -286,6 +297,46 @@ this.globalThis.solanaWeb3 = (function (exports) {
     const bytesLength = length ?? bytes2.byteLength;
     return bytes2.buffer.slice(bytesOffset, bytesOffset + bytesLength);
   }
+  var getShortU16Encoder = (options = {}) => ({
+    description: options.description ?? "shortU16",
+    encode: (value) => {
+      assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
+      const bytes2 = [0];
+      for (let ii = 0; ; ii += 1) {
+        const alignedValue = value >> ii * 7;
+        if (alignedValue === 0) {
+          break;
+        }
+        const nextSevenBits = 127 & alignedValue;
+        bytes2[ii] = nextSevenBits;
+        if (ii > 0) {
+          bytes2[ii - 1] |= 128;
+        }
+      }
+      return new Uint8Array(bytes2);
+    },
+    fixedSize: null,
+    maxSize: 3
+  });
+  var getShortU16Decoder = (options = {}) => ({
+    decode: (bytes2, offset = 0) => {
+      let value = 0;
+      let byteCount = 0;
+      while (++byteCount) {
+        const byteIndex = byteCount - 1;
+        const currentByte = bytes2[offset + byteIndex];
+        const nextSevenBits = 127 & currentByte;
+        value |= nextSevenBits << byteIndex * 7;
+        if ((currentByte & 128) === 0) {
+          break;
+        }
+      }
+      return [value, offset + byteCount];
+    },
+    description: options.description ?? "shortU16",
+    fixedSize: null,
+    maxSize: 3
+  });
   var getU32Encoder = (options = {}) => numberEncoderFactory({
     name: "u32",
     options,
@@ -299,6 +350,20 @@ this.globalThis.solanaWeb3 = (function (exports) {
     options,
     size: 4
   });
+  var getU8Encoder = (options = {}) => numberEncoderFactory({
+    name: "u8",
+    options,
+    range: [0, Number("0xff")],
+    set: (view, value) => view.setUint8(0, value),
+    size: 1
+  });
+  var getU8Decoder = (options = {}) => numberDecoderFactory({
+    get: (view) => view.getUint8(0),
+    name: "u8",
+    options,
+    size: 1
+  });
+  var getU8Codec = (options = {}) => combineCodec(getU8Encoder(options), getU8Decoder(options));
 
   // ../codecs-strings/dist/index.browser.js
   function assertValidBaseString(alphabet4, testValue, givenValue = testValue) {
@@ -1175,17 +1240,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   };
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u8.mjs
-  init_env_shim();
-  var u8 = (options = {}) => numberFactory({
-    name: "u8",
-    size: 1,
-    range: [0, Number("0xff")],
-    set: (view, value) => view.setUint8(0, Number(value)),
-    get: (view) => view.getUint8(0),
-    options
-  });
-
   // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.9/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u32.mjs
   init_env_shim();
   var u32 = (options = {}) => numberFactory({
@@ -1450,6 +1504,188 @@ this.globalThis.solanaWeb3 = (function (exports) {
       }
     };
   }
+
+  // ../codecs-data-structures/dist/index.browser.js
+  init_env_shim();
+  function sumCodecSizes(sizes) {
+    return sizes.reduce((all, size) => all === null || size === null ? null : all + size, 0);
+  }
+  function decodeArrayLikeCodecSize(size, childrenSizes, bytes2, offset) {
+    if (typeof size === "number") {
+      return [size, offset];
+    }
+    if (typeof size === "object") {
+      return size.decode(bytes2, offset);
+    }
+    if (size === "remainder") {
+      const childrenSize = sumCodecSizes(childrenSizes);
+      if (childrenSize === null) {
+        throw new Error('Codecs of "remainder" size must have fixed-size items.');
+      }
+      const remainder = bytes2.slice(offset).length;
+      if (remainder % childrenSize !== 0) {
+        throw new Error(
+          `The remainder of the byte array (${remainder} bytes) cannot be split into chunks of ${childrenSize} bytes. Codecs of "remainder" size must have a remainder that is a multiple of its item size. In other words, ${remainder} modulo ${childrenSize} should be equal to zero.`
+        );
+      }
+      return [remainder / childrenSize, offset];
+    }
+    throw new Error(`Unrecognized array-like codec size: ${JSON.stringify(size)}`);
+  }
+  function getArrayLikeCodecSizeDescription(size) {
+    return typeof size === "object" ? size.description : `${size}`;
+  }
+  function getArrayLikeCodecSizeFromChildren(size, childrenSizes) {
+    if (typeof size !== "number")
+      return null;
+    if (size === 0)
+      return 0;
+    const childrenSize = sumCodecSizes(childrenSizes);
+    return childrenSize === null ? null : childrenSize * size;
+  }
+  function getArrayLikeCodecSizePrefix(size, realSize) {
+    return typeof size === "object" ? size.encode(realSize) : new Uint8Array();
+  }
+  function assertValidNumberOfItemsForCodec(codecDescription, expected, actual) {
+    if (expected !== actual) {
+      throw new Error(`Expected [${codecDescription}] to have ${expected} items, got ${actual}.`);
+    }
+  }
+  function arrayCodecHelper(item, size, description) {
+    if (size === "remainder" && item.fixedSize === null) {
+      throw new Error('Codecs of "remainder" size must have fixed-size items.');
+    }
+    return {
+      description: description ?? `array(${item.description}; ${getArrayLikeCodecSizeDescription(size)})`,
+      fixedSize: getArrayLikeCodecSizeFromChildren(size, [item.fixedSize]),
+      maxSize: getArrayLikeCodecSizeFromChildren(size, [item.maxSize])
+    };
+  }
+  function getArrayEncoder(item, options = {}) {
+    const size = options.size ?? getU32Encoder();
+    return {
+      ...arrayCodecHelper(item, size, options.description),
+      encode: (value) => {
+        if (typeof size === "number") {
+          assertValidNumberOfItemsForCodec("array", size, value.length);
+        }
+        return mergeBytes([getArrayLikeCodecSizePrefix(size, value.length), ...value.map((v) => item.encode(v))]);
+      }
+    };
+  }
+  function getArrayDecoder(item, options = {}) {
+    const size = options.size ?? getU32Decoder();
+    return {
+      ...arrayCodecHelper(item, size, options.description),
+      decode: (bytes2, offset = 0) => {
+        if (typeof size === "object" && bytes2.slice(offset).length === 0) {
+          return [[], offset];
+        }
+        const [resolvedSize, newOffset] = decodeArrayLikeCodecSize(size, [item.fixedSize], bytes2, offset);
+        offset = newOffset;
+        const values = [];
+        for (let i = 0; i < resolvedSize; i += 1) {
+          const [value, newOffset2] = item.decode(bytes2, offset);
+          values.push(value);
+          offset = newOffset2;
+        }
+        return [values, offset];
+      }
+    };
+  }
+  function getBytesEncoder(options = {}) {
+    const size = options.size ?? "variable";
+    const sizeDescription = typeof size === "object" ? size.description : `${size}`;
+    const description = options.description ?? `bytes(${sizeDescription})`;
+    const byteEncoder = {
+      description,
+      encode: (value) => value,
+      fixedSize: null,
+      maxSize: null
+    };
+    if (size === "variable") {
+      return byteEncoder;
+    }
+    if (typeof size === "number") {
+      return fixEncoder(byteEncoder, size, description);
+    }
+    return {
+      ...byteEncoder,
+      encode: (value) => {
+        const contentBytes = byteEncoder.encode(value);
+        const lengthBytes = size.encode(contentBytes.length);
+        return mergeBytes([lengthBytes, contentBytes]);
+      }
+    };
+  }
+  function getBytesDecoder(options = {}) {
+    const size = options.size ?? "variable";
+    const sizeDescription = typeof size === "object" ? size.description : `${size}`;
+    const description = options.description ?? `bytes(${sizeDescription})`;
+    const byteDecoder = {
+      decode: (bytes2, offset = 0) => {
+        const slice = bytes2.slice(offset);
+        return [slice, offset + slice.length];
+      },
+      description,
+      fixedSize: null,
+      maxSize: null
+    };
+    if (size === "variable") {
+      return byteDecoder;
+    }
+    if (typeof size === "number") {
+      return fixDecoder(byteDecoder, size, description);
+    }
+    return {
+      ...byteDecoder,
+      decode: (bytes2, offset = 0) => {
+        assertByteArrayIsNotEmptyForCodec("bytes", bytes2, offset);
+        const [lengthBigInt, lengthOffset] = size.decode(bytes2, offset);
+        const length = Number(lengthBigInt);
+        offset = lengthOffset;
+        const contentBytes = bytes2.slice(offset, offset + length);
+        assertByteArrayHasEnoughBytesForCodec("bytes", length, contentBytes);
+        const [value, contentOffset] = byteDecoder.decode(contentBytes);
+        offset += contentOffset;
+        return [value, offset];
+      }
+    };
+  }
+  function structCodecHelper(fields, description) {
+    const fieldDescriptions = fields.map(([name, codec]) => `${String(name)}: ${codec.description}`).join(", ");
+    return {
+      description: description ?? `struct(${fieldDescriptions})`,
+      fixedSize: sumCodecSizes(fields.map(([, field]) => field.fixedSize)),
+      maxSize: sumCodecSizes(fields.map(([, field]) => field.maxSize))
+    };
+  }
+  function getStructEncoder(fields, options = {}) {
+    return {
+      ...structCodecHelper(fields, options.description),
+      encode: (struct2) => {
+        const fieldBytes = fields.map(([key, codec]) => codec.encode(struct2[key]));
+        return mergeBytes(fieldBytes);
+      }
+    };
+  }
+  function getStructDecoder(fields, options = {}) {
+    return {
+      ...structCodecHelper(fields, options.description),
+      decode: (bytes2, offset = 0) => {
+        const struct2 = {};
+        fields.forEach(([key, codec]) => {
+          const [value, newOffset] = codec.decode(bytes2, offset);
+          offset = newOffset;
+          struct2[key] = value;
+        });
+        return [struct2, offset];
+      }
+    };
+  }
+  function getStructCodec(fields, options = {}) {
+    return combineCodec(getStructEncoder(fields, options), getStructDecoder(fields, options));
+  }
   function getUnsignedTransaction(transaction) {
     if ("signatures" in transaction) {
       const {
@@ -1471,8 +1707,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
       ) {
         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 bytes2 = 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}`);
       }
@@ -1882,137 +2118,161 @@ this.globalThis.solanaWeb3 = (function (exports) {
       signatures
     };
   }
-  function addressSerializerCompat(compat) {
-    const codec = getAddressCodec();
-    return {
-      description: compat?.description ?? codec.description,
-      deserialize: codec.decode,
-      fixedSize: codec.fixedSize,
-      maxSize: codec.maxSize,
-      serialize: codec.encode
-    };
-  }
-  function getAddressTableLookupCodec() {
-    return struct(
-      [
+  var lookupTableAddressDescription = "The address of the address lookup table account from which instruction addresses should be looked up" ;
+  var writableIndicesDescription = "The indices of the accounts in the lookup table that should be loaded as writeable" ;
+  var readableIndicesDescription = "The indices of the accounts in the lookup table that should be loaded as read-only" ;
+  var addressTableLookupDescription = "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" ;
+  var memoizedAddressTableLookupEncoder;
+  function getAddressTableLookupEncoder() {
+    if (!memoizedAddressTableLookupEncoder) {
+      memoizedAddressTableLookupEncoder = getStructEncoder(
         [
-          "lookupTableAddress",
-          addressSerializerCompat(
-            {
-              description: "The address of the address lookup table account from which instruction addresses should be looked up"
-            } 
-          )
+          ["lookupTableAddress", getAddressEncoder({ description: lookupTableAddressDescription })],
+          [
+            "writableIndices",
+            getArrayEncoder(getU8Encoder(), {
+              description: writableIndicesDescription,
+              size: getShortU16Encoder()
+            })
+          ],
+          [
+            "readableIndices",
+            getArrayEncoder(getU8Encoder(), {
+              description: readableIndicesDescription,
+              size: getShortU16Encoder()
+            })
+          ]
         ],
+        { description: addressTableLookupDescription }
+      );
+    }
+    return memoizedAddressTableLookupEncoder;
+  }
+  var memoizedAddressTableLookupDecoder;
+  function getAddressTableLookupDecoder() {
+    if (!memoizedAddressTableLookupDecoder) {
+      memoizedAddressTableLookupDecoder = getStructDecoder(
         [
-          "writableIndices",
-          array(u8(), {
-            ...{
-              description: "The indices of the accounts in the lookup table that should be loaded as writeable"
-            } ,
-            size: shortU16()
-          })
+          ["lookupTableAddress", getAddressDecoder({ description: lookupTableAddressDescription })],
+          [
+            "writableIndices",
+            getArrayDecoder(getU8Decoder(), {
+              description: writableIndicesDescription,
+              size: getShortU16Decoder()
+            })
+          ],
+          [
+            "readableIndices",
+            getArrayDecoder(getU8Decoder(), {
+              description: readableIndicesDescription,
+              size: getShortU16Decoder()
+            })
+          ]
         ],
-        [
-          "readableIndices",
-          array(u8(), {
-            ...{
-              description: "The indices of the accounts in the lookup table that should be loaded as read-only"
-            } ,
-            size: shortU16()
-          })
-        ]
-      ],
-      {
-        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"
-      } 
-    );
+        { description: addressTableLookupDescription }
+      );
+    }
+    return memoizedAddressTableLookupDecoder;
+  }
+  function getAddressTableLookupCodec() {
+    return combineCodec(getAddressTableLookupEncoder(), getAddressTableLookupDecoder());
+  }
+  var memoizedU8Codec;
+  function getMemoizedU8Codec() {
+    if (!memoizedU8Codec)
+      memoizedU8Codec = getU8Codec();
+    return memoizedU8Codec;
   }
+  function getMemoizedU8CodecDescription(description) {
+    const codec = getMemoizedU8Codec();
+    return {
+      ...codec,
+      description: description ?? codec.description
+    };
+  }
+  var numSignerAccountsDescription = "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction" ;
+  var numReadonlySignerAccountsDescription = "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" ;
+  var numReadonlyNonSignerAccountsDescription = "The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable" ;
+  var messageHeaderDescription = "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses" ;
   function getMessageHeaderCodec() {
-    return struct(
+    return getStructCodec(
       [
-        [
-          "numSignerAccounts",
-          u8(
-            {
-              description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction"
-            } 
-          )
-        ],
-        [
-          "numReadonlySignerAccounts",
-          u8(
-            {
-              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"
-            } 
-          )
-        ],
-        [
-          "numReadonlyNonSignerAccounts",
-          u8(
-            {
-              description: "The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable"
-            } 
-          )
-        ]
+        ["numSignerAccounts", getMemoizedU8CodecDescription(numSignerAccountsDescription)],
+        ["numReadonlySignerAccounts", getMemoizedU8CodecDescription(numReadonlySignerAccountsDescription)],
+        ["numReadonlyNonSignerAccounts", getMemoizedU8CodecDescription(numReadonlyNonSignerAccountsDescription)]
       ],
       {
-        description: "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses"
-      } 
+        description: messageHeaderDescription
+      }
     );
   }
-  function getInstructionCodec() {
-    return mapSerializer(
-      struct([
-        [
-          "programAddressIndex",
-          u8(
-            {
-              description: "The index of the program being called, according to the well-ordered accounts list for this transaction"
-            } 
-          )
-        ],
-        [
-          "accountIndices",
-          array(
-            u8({
-              description: "The index of an account, according to the well-ordered accounts list for this transaction" 
-            }),
-            {
-              description: "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: "An optional buffer of data passed to the instruction" ,
-            size: shortU16()
-          })
-        ]
-      ]),
-      (value) => {
-        if (value.accountIndices !== void 0 && value.data !== void 0) {
-          return value;
+  var programAddressIndexDescription = "The index of the program being called, according to the well-ordered accounts list for this transaction" ;
+  var accountIndexDescription = "The index of an account, according to the well-ordered accounts list for this transaction" ;
+  var accountIndicesDescription = "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" ;
+  var dataDescription = "An optional buffer of data passed to the instruction" ;
+  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 {
-          ...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 = mapDecoder(
+        getStructDecoder([
+          ["programAddressIndex", getU8Decoder({ description: programAddressIndexDescription })],
+          [
+            "accountIndices",
+            getArrayDecoder(getU8Decoder({ description: accountIndexDescription }), {
+              description: accountIndicesDescription,
+              size: getShortU16Decoder()
+            })
+          ],
+          ["data", getBytesDecoder({ description: dataDescription, size: 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 combineCodec(getInstructionEncoder(), getInstructionDecoder());
   }
   var VERSION_FLAG_MASK = 128;
   var BASE_CONFIG = {
@@ -2020,8 +2280,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
     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 {
@@ -2090,18 +2350,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       ).serialize(compiledMessage);
     }
   }
-  function addressSerializerCompat2() {
-    const codec = 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,
@@ -2112,11 +2361,11 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function getPreludeStructSerializerTuple() {
     return [
-      ["version", transactionVersionSerializerCompat()],
-      ["header", getMessageHeaderCodec()],
+      ["version", toSerializer(getTransactionVersionCodec())],
+      ["header", toSerializer(getMessageHeaderCodec())],
       [
         "staticAccounts",
-        array(addressSerializerCompat2(), {
+        array(toSerializer(getAddressCodec()), {
           description: "A compact-array of static account addresses belonging to this transaction" ,
           size: shortU16()
         })
@@ -2131,7 +2380,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       ],
       [
         "instructions",
-        array(getInstructionCodec(), {
+        array(toSerializer(getInstructionCodec()), {
           description: "A compact-array of instructions belonging to this transaction" ,
           size: shortU16()
         })
@@ -2139,7 +2388,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     ];
   }
   function getAddressTableLookupsSerializer() {
-    return array(getAddressTableLookupCodec(), {
+    return array(toSerializer(getAddressTableLookupCodec()), {
       ...{ description: "A compact array of address table lookups belonging to this transaction" } ,
       size: shortU16()
     });
@@ -2185,8 +2434,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
       ) {
         throw new Error("Expected input string to decode to a byte array of length 64.");
       }
-      const bytes3 = base58.serialize(putativeTransactionSignature);
-      const numBytes = bytes3.byteLength;
+      const bytes2 = 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}`);
       }
@@ -2204,8 +2453,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
     ) {
       return false;
     }
-    const bytes3 = base58.serialize(putativeTransactionSignature);
-    const numBytes = bytes3.byteLength;
+    const bytes2 = base58.serialize(putativeTransactionSignature);
+    const numBytes = bytes2.byteLength;
     if (numBytes !== 64) {
       return false;
     }
@@ -2217,13 +2466,14 @@ this.globalThis.solanaWeb3 = (function (exports) {
     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 = base58.deserialize(signatureBytes)[0];
+    return transactionSignature2;
   }
   async function signTransaction(keyPairs, transaction) {
     const compiledMessage = compileMessage(transaction);
@@ -2257,15 +2507,43 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   }
 
-  // src/rpc.ts
+  // src/airdrop.ts
   init_env_shim();
 
-  // ../functional/dist/index.browser.js
+  // src/airdrop-confirmer.ts
   init_env_shim();
-  function pipe(init, ...fns) {
-    return fns.reduce((acc, fn) => fn(acc), init);
+
+  // src/transaction-confirmation-strategy-racer.ts
+  init_env_shim();
+  async function raceStrategies(signature, config, getSpecificStrategiesForRace) {
+    const { abortSignal: callerAbortSignal, commitment, getRecentSignatureConfirmationPromise } = config;
+    callerAbortSignal.throwIfAborted();
+    const abortController = new AbortController();
+    function handleAbort() {
+      abortController.abort();
+    }
+    callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
+    try {
+      const specificStrategies = getSpecificStrategiesForRace({
+        ...config,
+        abortSignal: abortController.signal
+      });
+      return await Promise.race([
+        getRecentSignatureConfirmationPromise({
+          abortSignal: abortController.signal,
+          commitment,
+          signature
+        }),
+        ...specificStrategies
+      ]);
+    } finally {
+      abortController.abort();
+    }
   }
 
+  // src/transaction-confirmation-strategy-recent-signature.ts
+  init_env_shim();
+
   // ../rpc-core/dist/index.browser.js
   init_env_shim();
   function getCommitmentScore(commitment) {
@@ -2791,6 +3069,144 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return createSolanaRpcSubscriptionsApi(config);
   }
 
+  // src/transaction-confirmation-strategy-recent-signature.ts
+  function createRecentSignatureConfirmationPromiseFactory(rpc, rpcSubscriptions) {
+    return async function getRecentSignatureConfirmationPromise({
+      abortSignal: callerAbortSignal,
+      commitment,
+      signature
+    }) {
+      const abortController = new AbortController();
+      function handleAbort() {
+        abortController.abort();
+      }
+      callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
+      const signatureStatusNotifications = await rpcSubscriptions.signatureNotifications(signature, { commitment }).subscribe({ abortSignal: abortController.signal });
+      const signatureDidCommitPromise = (async () => {
+        for await (const signatureStatusNotification of signatureStatusNotifications) {
+          if (signatureStatusNotification.value.err) {
+            throw new Error(`The transaction with signature \`${signature}\` failed.`, {
+              cause: signatureStatusNotification.value.err
+            });
+          } else {
+            return;
+          }
+        }
+      })();
+      const signatureStatusLookupPromise = (async () => {
+        const { value: signatureStatusResults } = await rpc.getSignatureStatuses([signature]).send({ abortSignal: abortController.signal });
+        const signatureStatus = signatureStatusResults[0];
+        if (signatureStatus && signatureStatus.confirmationStatus && commitmentComparator(signatureStatus.confirmationStatus, commitment) >= 0) {
+          return;
+        } else {
+          await new Promise(() => {
+          });
+        }
+      })();
+      try {
+        return await Promise.race([signatureDidCommitPromise, signatureStatusLookupPromise]);
+      } finally {
+        abortController.abort();
+      }
+    };
+  }
+
+  // src/transaction-confirmation-strategy-timeout.ts
+  init_env_shim();
+  async function getTimeoutPromise({ abortSignal: callerAbortSignal, commitment }) {
+    return await new Promise((_, reject) => {
+      const handleAbort = (e3) => {
+        clearTimeout(timeoutId);
+        const abortError = new DOMException(e3.target.reason, "AbortError");
+        reject(abortError);
+      };
+      callerAbortSignal.addEventListener("abort", handleAbort);
+      const timeoutMs = commitment === "processed" ? 3e4 : 6e4;
+      const startMs = performance.now();
+      const timeoutId = (
+        // We use `setTimeout` instead of `AbortSignal.timeout()` because we want to measure
+        // elapsed time instead of active time.
+        // See https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout_static
+        setTimeout(() => {
+          const elapsedMs = performance.now() - startMs;
+          reject(new DOMException(`Timeout elapsed after ${elapsedMs} ms`, "TimeoutError"));
+        }, timeoutMs)
+      );
+    });
+  }
+
+  // src/airdrop-confirmer.ts
+  function createDefaultSignatureOnlyRecentTransactionConfirmer({
+    rpc,
+    rpcSubscriptions
+  }) {
+    const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory(
+      rpc,
+      rpcSubscriptions
+    );
+    return async function confirmSignatureOnlyRecentTransaction(config) {
+      await waitForRecentTransactionConfirmationUntilTimeout({
+        ...config,
+        getRecentSignatureConfirmationPromise,
+        getTimeoutPromise
+      });
+    };
+  }
+  async function waitForRecentTransactionConfirmationUntilTimeout(config) {
+    await raceStrategies(
+      config.signature,
+      config,
+      function getSpecificStrategiesForRace({ abortSignal, commitment, getTimeoutPromise: getTimeoutPromise2 }) {
+        return [
+          getTimeoutPromise2({
+            abortSignal,
+            commitment
+          })
+        ];
+      }
+    );
+  }
+
+  // src/airdrop.ts
+  function createDefaultAirdropRequester({ rpc, rpcSubscriptions }) {
+    const confirmSignatureOnlyTransaction = createDefaultSignatureOnlyRecentTransactionConfirmer({
+      rpc,
+      rpcSubscriptions
+    });
+    return async function requestAirdrop(config) {
+      return await requestAndConfirmAirdrop({
+        ...config,
+        confirmSignatureOnlyTransaction,
+        rpc
+      });
+    };
+  }
+  async function requestAndConfirmAirdrop({
+    abortSignal,
+    commitment,
+    confirmSignatureOnlyTransaction,
+    lamports,
+    recipientAddress,
+    rpc
+  }) {
+    const airdropTransactionSignature = await rpc.requestAirdrop(recipientAddress, lamports, { commitment }).send({ abortSignal });
+    await confirmSignatureOnlyTransaction({
+      abortSignal,
+      commitment,
+      signature: airdropTransactionSignature
+    });
+    return airdropTransactionSignature;
+  }
+
+  // src/rpc.ts
+  init_env_shim();
+
+  // ../functional/dist/index.browser.js
+  init_env_shim();
+  function pipe(init, ...fns) {
+    return fns.reduce((acc, fn) => fn(acc), init);
+  }
+
   // ../rpc-transport/dist/index.browser.js
   init_env_shim();
   var SolanaJsonRpcError = class extends Error {
@@ -3675,6 +4091,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
     );
   }
 
+  // src/send-transaction.ts
+  init_env_shim();
+
   // src/transaction-confirmation.ts
   init_env_shim();
 
@@ -3766,99 +4185,44 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
-  // src/transaction-confirmation-strategy-signature.ts
-  init_env_shim();
-  function createSignatureConfirmationPromiseFactory(rpc, rpcSubscriptions) {
-    return async function getSignatureConfirmationPromise({ abortSignal: callerAbortSignal, commitment, signature }) {
-      const abortController = new AbortController();
-      function handleAbort() {
-        abortController.abort();
-      }
-      callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
-      const signatureStatusNotifications = await rpcSubscriptions.signatureNotifications(signature, { commitment }).subscribe({ abortSignal: abortController.signal });
-      const signatureDidCommitPromise = (async () => {
-        for await (const signatureStatusNotification of signatureStatusNotifications) {
-          if (signatureStatusNotification.value.err) {
-            throw new Error(`The transaction with signature \`${signature}\` failed.`, {
-              cause: signatureStatusNotification.value.err
-            });
-          } else {
-            return;
-          }
-        }
-      })();
-      const signatureStatusLookupPromise = (async () => {
-        const { value: signatureStatusResults } = await rpc.getSignatureStatuses([signature]).send({ abortSignal: abortController.signal });
-        const signatureStatus = signatureStatusResults[0];
-        if (signatureStatus && signatureStatus.confirmationStatus && commitmentComparator(signatureStatus.confirmationStatus, commitment) >= 0) {
-          return;
-        } else {
-          await new Promise(() => {
-          });
-        }
-      })();
-      try {
-        return await Promise.race([signatureDidCommitPromise, signatureStatusLookupPromise]);
-      } finally {
-        abortController.abort();
-      }
-    };
-  }
-
   // src/transaction-confirmation.ts
-  async function raceStrategies(config, getSpecificStrategiesForRace) {
-    const { abortSignal: callerAbortSignal, commitment, getSignatureConfirmationPromise, transaction } = config;
-    callerAbortSignal.throwIfAborted();
-    const signature = getSignatureFromTransaction(transaction);
-    const abortController = new AbortController();
-    function handleAbort() {
-      abortController.abort();
-    }
-    callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
-    try {
-      const specificStrategies = getSpecificStrategiesForRace({
-        ...config,
-        abortSignal: abortController.signal
-      });
-      return await Promise.race([
-        getSignatureConfirmationPromise({
-          abortSignal: abortController.signal,
-          commitment,
-          signature
-        }),
-        ...specificStrategies
-      ]);
-    } finally {
-      abortController.abort();
-    }
-  }
   function createDefaultDurableNonceTransactionConfirmer({
     rpc,
     rpcSubscriptions
   }) {
     const getNonceInvalidationPromise = createNonceInvalidationPromiseFactory(rpc, rpcSubscriptions);
-    const getSignatureConfirmationPromise = createSignatureConfirmationPromiseFactory(rpc, rpcSubscriptions);
-    return async function confirmTransaction(config) {
+    const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory(
+      rpc,
+      rpcSubscriptions
+    );
+    return async function confirmDurableNonceTransaction(config) {
       await waitForDurableNonceTransactionConfirmation({
         ...config,
         getNonceInvalidationPromise,
-        getSignatureConfirmationPromise
+        getRecentSignatureConfirmationPromise
       });
     };
   }
-  function createDefaultTransactionConfirmer({ rpc, rpcSubscriptions }) {
+  function createDefaultRecentTransactionConfirmer({
+    rpc,
+    rpcSubscriptions
+  }) {
     const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory(rpcSubscriptions);
-    const getSignatureConfirmationPromise = createSignatureConfirmationPromiseFactory(rpc, rpcSubscriptions);
-    return async function confirmTransaction(config) {
-      await waitForTransactionConfirmation({
+    const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory(
+      rpc,
+      rpcSubscriptions
+    );
+    return async function confirmRecentTransaction(config) {
+      await waitForRecentTransactionConfirmation({
         ...config,
         getBlockHeightExceedencePromise,
-        getSignatureConfirmationPromise
+        getRecentSignatureConfirmationPromise
       });
     };
   }
   async function waitForDurableNonceTransactionConfirmation(config) {
     await raceStrategies(
+      getSignatureFromTransaction(config.transaction),
       config,
       function getSpecificStrategiesForRace({ abortSignal, commitment, getNonceInvalidationPromise, transaction }) {
         return [
@@ -3872,8 +4236,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
       }
     );
   }
-  async function waitForTransactionConfirmation(config) {
+  async function waitForRecentTransactionConfirmation(config) {
     await raceStrategies(
+      getSignatureFromTransaction(config.transaction),
       config,
       function getSpecificStrategiesForRace({ abortSignal, getBlockHeightExceedencePromise, transaction }) {
         return [
@@ -3886,6 +4251,117 @@ this.globalThis.solanaWeb3 = (function (exports) {
     );
   }
 
+  // src/send-transaction.ts
+  function getSendTransactionConfigWithAdjustedPreflightCommitment(commitment, config) {
+    if (
+      // The developer has supplied no value for `preflightCommitment`.
+      !config?.preflightCommitment && // The value of `commitment` is lower than the server default of `preflightCommitment`.
+      commitmentComparator(
+        commitment,
+        "finalized"
+        /* default value of `preflightCommitment` */
+      ) < 0
+    ) {
+      return {
+        ...config,
+        // In the common case, it is unlikely that you want to simulate a transaction at
+        // `finalized` commitment when your standard of commitment for confirming the
+        // transaction is lower. Cap the simulation commitment level to the level of the
+        // confirmation commitment.
+        preflightCommitment: commitment
+      };
+    }
+    return config;
+  }
+  async function sendTransaction_INTERNAL({
+    abortSignal,
+    commitment,
+    rpc,
+    transaction,
+    sendTransactionConfig
+  }) {
+    const base64EncodedWireTransaction = getBase64EncodedWireTransaction(transaction);
+    return await rpc.sendTransaction(base64EncodedWireTransaction, {
+      ...getSendTransactionConfigWithAdjustedPreflightCommitment(commitment, sendTransactionConfig),
+      encoding: "base64"
+    }).send({ abortSignal });
+  }
+  function createDefaultDurableNonceTransactionSender({
+    rpc,
+    rpcSubscriptions
+  }) {
+    const confirmDurableNonceTransaction = createDefaultDurableNonceTransactionConfirmer({
+      rpc,
+      rpcSubscriptions
+    });
+    return async function sendDurableNonceTransaction(transaction, config) {
+      await sendAndConfirmDurableNonceTransaction({
+        ...config,
+        confirmDurableNonceTransaction,
+        rpc,
+        transaction
+      });
+    };
+  }
+  function createDefaultTransactionSender({ rpc, rpcSubscriptions }) {
+    const confirmRecentTransaction = createDefaultRecentTransactionConfirmer({
+      rpc,
+      rpcSubscriptions
+    });
+    return async function sendTransaction(transaction, config) {
+      await sendAndConfirmTransaction({
+        ...config,
+        confirmRecentTransaction,
+        rpc,
+        transaction
+      });
+    };
+  }
+  async function sendAndConfirmDurableNonceTransaction({
+    abortSignal,
+    commitment,
+    confirmDurableNonceTransaction,
+    rpc,
+    transaction,
+    ...sendTransactionConfig
+  }) {
+    const transactionSignature2 = await sendTransaction_INTERNAL({
+      abortSignal,
+      commitment,
+      rpc,
+      sendTransactionConfig,
+      transaction
+    });
+    await confirmDurableNonceTransaction({
+      abortSignal,
+      commitment,
+      transaction
+    });
+    return transactionSignature2;
+  }
+  async function sendAndConfirmTransaction({
+    abortSignal,
+    commitment,
+    confirmRecentTransaction,
+    rpc,
+    transaction,
+    ...sendTransactionConfig
+  }) {
+    const transactionSignature2 = await sendTransaction_INTERNAL({
+      abortSignal,
+      commitment,
+      rpc,
+      sendTransactionConfig,
+      transaction
+    });
+    await confirmRecentTransaction({
+      abortSignal,
+      commitment,
+      transaction
+    });
+    return transactionSignature2;
+  }
+
   exports.AccountRole = AccountRole;
   exports.address = address;
   exports.appendTransactionInstruction = appendTransactionInstruction;
@@ -3896,12 +4372,15 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.assertIsTransactionSignature = assertIsTransactionSignature;
   exports.createAddressWithSeed = createAddressWithSeed;
   exports.createBlockHeightExceedencePromiseFactory = createBlockHeightExceedencePromiseFactory;
+  exports.createDefaultAirdropRequester = createDefaultAirdropRequester;
   exports.createDefaultDurableNonceTransactionConfirmer = createDefaultDurableNonceTransactionConfirmer;
+  exports.createDefaultDurableNonceTransactionSender = createDefaultDurableNonceTransactionSender;
+  exports.createDefaultRecentTransactionConfirmer = createDefaultRecentTransactionConfirmer;
   exports.createDefaultRpcSubscriptionsTransport = createDefaultRpcSubscriptionsTransport;
   exports.createDefaultRpcTransport = createDefaultRpcTransport;
-  exports.createDefaultTransactionConfirmer = createDefaultTransactionConfirmer;
+  exports.createDefaultTransactionSender = createDefaultTransactionSender;
   exports.createNonceInvalidationPromiseFactory = createNonceInvalidationPromiseFactory;
-  exports.createSignatureConfirmationPromiseFactory = createSignatureConfirmationPromiseFactory;
+  exports.createRecentSignatureConfirmationPromiseFactory = createRecentSignatureConfirmationPromiseFactory;
   exports.createSolanaRpc = createSolanaRpc;
   exports.createSolanaRpcSubscriptions = createSolanaRpcSubscriptions;
   exports.createSolanaRpcSubscriptions_UNSTABLE = createSolanaRpcSubscriptions_UNSTABLE;
@@ -3919,12 +4398,16 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.getSignatureFromTransaction = getSignatureFromTransaction;
   exports.getTransactionEncoder = getTransactionEncoder;
   exports.isAddress = isAddress;
+  exports.isAdvanceNonceAccountInstruction = isAdvanceNonceAccountInstruction;
   exports.isProgramDerivedAddress = isProgramDerivedAddress;
   exports.isSignerRole = isSignerRole;
   exports.isTransactionSignature = isTransactionSignature;
   exports.isWritableRole = isWritableRole;
   exports.mergeRoles = mergeRoles;
   exports.prependTransactionInstruction = prependTransactionInstruction;
+  exports.requestAndConfirmAirdrop = requestAndConfirmAirdrop;
+  exports.sendAndConfirmDurableNonceTransaction = sendAndConfirmDurableNonceTransaction;
+  exports.sendAndConfirmTransaction = sendAndConfirmTransaction;
   exports.setTransactionFeePayer = setTransactionFeePayer;
   exports.setTransactionLifetimeUsingBlockhash = setTransactionLifetimeUsingBlockhash;
   exports.setTransactionLifetimeUsingDurableNonce = setTransactionLifetimeUsingDurableNonce;
@@ -3935,7 +4418,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   exports.upgradeRoleToWritable = upgradeRoleToWritable;
   exports.verifySignature = verifySignature;
   exports.waitForDurableNonceTransactionConfirmation = waitForDurableNonceTransactionConfirmation;
-  exports.waitForTransactionConfirmation = waitForTransactionConfirmation;
+  exports.waitForRecentTransactionConfirmation = waitForRecentTransactionConfirmation;
 
   return exports;