@solana/web3.js 2.0.0-experimental.a77f814 → 2.0.0-experimental.a7f0f86

package/dist/index.development.js

@@ -8,6 +8,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __esm = (fn, res) => function __init() {
     return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
   };
@@ -30,6 +31,10 @@ this.globalThis.solanaWeb3 = (function (exports) {
     isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
     mod
   ));
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
 
   // ../build-scripts/env-shim.ts
   var init_env_shim = __esm({
@@ -37,153 +42,410 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   });
 
-  // ../../node_modules/.pnpm/base-x@4.0.0/node_modules/base-x/src/index.js
-  var require_src = __commonJS({
-    "../../node_modules/.pnpm/base-x@4.0.0/node_modules/base-x/src/index.js"(exports, module) {
+  // ../../node_modules/.pnpm/fast-stable-stringify@1.0.0/node_modules/fast-stable-stringify/index.js
+  var require_fast_stable_stringify = __commonJS({
+    "../../node_modules/.pnpm/fast-stable-stringify@1.0.0/node_modules/fast-stable-stringify/index.js"(exports, module) {
       init_env_shim();
-      function base(ALPHABET) {
-        if (ALPHABET.length >= 255) {
-          throw new TypeError("Alphabet too long");
+      var objToString = Object.prototype.toString;
+      var objKeys = Object.keys || function(obj) {
+        var keys = [];
+        for (var name in obj) {
+          keys.push(name);
         }
-        var BASE_MAP = new Uint8Array(256);
-        for (var j = 0; j < BASE_MAP.length; j++) {
-          BASE_MAP[j] = 255;
+        return keys;
+      };
+      function stringify(val, isArrayProp) {
+        var i, max, str, keys, key, propVal, toStr;
+        if (val === true) {
+          return "true";
         }
-        for (var i = 0; i < ALPHABET.length; i++) {
-          var x = ALPHABET.charAt(i);
-          var xc = x.charCodeAt(0);
-          if (BASE_MAP[xc] !== 255) {
-            throw new TypeError(x + " is ambiguous");
-          }
-          BASE_MAP[xc] = i;
+        if (val === false) {
+          return "false";
         }
-        var BASE = ALPHABET.length;
-        var LEADER = ALPHABET.charAt(0);
-        var FACTOR = Math.log(BASE) / Math.log(256);
-        var iFACTOR = Math.log(256) / Math.log(BASE);
-        function encode(source) {
-          if (source instanceof Uint8Array) ; else if (ArrayBuffer.isView(source)) {
-            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-          } else if (Array.isArray(source)) {
-            source = Uint8Array.from(source);
-          }
-          if (!(source instanceof Uint8Array)) {
-            throw new TypeError("Expected Uint8Array");
-          }
-          if (source.length === 0) {
-            return "";
-          }
-          var zeroes = 0;
-          var length = 0;
-          var pbegin = 0;
-          var pend = source.length;
-          while (pbegin !== pend && source[pbegin] === 0) {
-            pbegin++;
-            zeroes++;
-          }
-          var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
-          var b58 = new Uint8Array(size);
-          while (pbegin !== pend) {
-            var carry = source[pbegin];
-            var i2 = 0;
-            for (var it1 = size - 1; (carry !== 0 || i2 < length) && it1 !== -1; it1--, i2++) {
-              carry += 256 * b58[it1] >>> 0;
-              b58[it1] = carry % BASE >>> 0;
-              carry = carry / BASE >>> 0;
+        switch (typeof val) {
+          case "object":
+            if (val === null) {
+              return null;
+            } else if (val.toJSON && typeof val.toJSON === "function") {
+              return stringify(val.toJSON(), isArrayProp);
+            } else {
+              toStr = objToString.call(val);
+              if (toStr === "[object Array]") {
+                str = "[";
+                max = val.length - 1;
+                for (i = 0; i < max; i++) {
+                  str += stringify(val[i], true) + ",";
+                }
+                if (max > -1) {
+                  str += stringify(val[i], true);
+                }
+                return str + "]";
+              } else if (toStr === "[object Object]") {
+                keys = objKeys(val).sort();
+                max = keys.length;
+                str = "";
+                i = 0;
+                while (i < max) {
+                  key = keys[i];
+                  propVal = stringify(val[key], false);
+                  if (propVal !== void 0) {
+                    if (str) {
+                      str += ",";
+                    }
+                    str += JSON.stringify(key) + ":" + propVal;
+                  }
+                  i++;
+                }
+                return "{" + str + "}";
+              } else {
+                return JSON.stringify(val);
+              }
             }
-            if (carry !== 0) {
-              throw new Error("Non-zero carry");
-            }
-            length = i2;
-            pbegin++;
-          }
-          var it2 = size - length;
-          while (it2 !== size && b58[it2] === 0) {
-            it2++;
-          }
-          var str = LEADER.repeat(zeroes);
-          for (; it2 < size; ++it2) {
-            str += ALPHABET.charAt(b58[it2]);
-          }
-          return str;
+          case "function":
+          case "undefined":
+            return isArrayProp ? null : void 0;
+          case "string":
+            return JSON.stringify(val);
+          default:
+            return isFinite(val) ? val : null;
         }
-        function decodeUnsafe(source) {
-          if (typeof source !== "string") {
-            throw new TypeError("Expected String");
-          }
-          if (source.length === 0) {
-            return new Uint8Array();
-          }
-          var psz = 0;
-          var zeroes = 0;
-          var length = 0;
-          while (source[psz] === LEADER) {
-            zeroes++;
-            psz++;
-          }
-          var size = (source.length - psz) * FACTOR + 1 >>> 0;
-          var b256 = new Uint8Array(size);
-          while (source[psz]) {
-            var carry = BASE_MAP[source.charCodeAt(psz)];
-            if (carry === 255) {
-              return;
-            }
-            var i2 = 0;
-            for (var it3 = size - 1; (carry !== 0 || i2 < length) && it3 !== -1; it3--, i2++) {
-              carry += BASE * b256[it3] >>> 0;
-              b256[it3] = carry % 256 >>> 0;
-              carry = carry / 256 >>> 0;
-            }
-            if (carry !== 0) {
-              throw new Error("Non-zero carry");
-            }
-            length = i2;
-            psz++;
-          }
-          var it4 = size - length;
-          while (it4 !== size && b256[it4] === 0) {
-            it4++;
-          }
-          var vch = new Uint8Array(zeroes + (size - it4));
-          var j2 = zeroes;
-          while (it4 !== size) {
-            vch[j2++] = b256[it4++];
-          }
-          return vch;
+      }
+      module.exports = function(val) {
+        var returnVal = stringify(val, false);
+        if (returnVal !== void 0) {
+          return "" + returnVal;
         }
-        function decode(string) {
-          var buffer = decodeUnsafe(string);
-          if (buffer) {
-            return buffer;
-          }
-          throw new Error("Non-base" + BASE + " character");
+      };
+    }
+  });
+
+  // src/index.ts
+  init_env_shim();
+
+  // ../instructions/dist/index.browser.js
+  init_env_shim();
+  var AccountRole = /* @__PURE__ */ ((AccountRole2) => {
+    AccountRole2[AccountRole2["WRITABLE_SIGNER"] = /* 3 */
+    3] = "WRITABLE_SIGNER";
+    AccountRole2[AccountRole2["READONLY_SIGNER"] = /* 2 */
+    2] = "READONLY_SIGNER";
+    AccountRole2[AccountRole2["WRITABLE"] = /* 1 */
+    1] = "WRITABLE";
+    AccountRole2[AccountRole2["READONLY"] = /* 0 */
+    0] = "READONLY";
+    return AccountRole2;
+  })(AccountRole || {});
+  var IS_SIGNER_BITMASK = 2;
+  var IS_WRITABLE_BITMASK = 1;
+  function downgradeRoleToNonSigner(role) {
+    return role & ~IS_SIGNER_BITMASK;
+  }
+  function downgradeRoleToReadonly(role) {
+    return role & ~IS_WRITABLE_BITMASK;
+  }
+  function isSignerRole(role) {
+    return role >= 2;
+  }
+  function isWritableRole(role) {
+    return (role & IS_WRITABLE_BITMASK) !== 0;
+  }
+  function mergeRoles(roleA, roleB) {
+    return roleA | roleB;
+  }
+  function upgradeRoleToSigner(role) {
+    return role | IS_SIGNER_BITMASK;
+  }
+  function upgradeRoleToWritable(role) {
+    return role | IS_WRITABLE_BITMASK;
+  }
+
+  // ../keys/dist/index.browser.js
+  init_env_shim();
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/dist/esm/index.mjs
+  init_env_shim();
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/index.mjs
+  init_env_shim();
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/bytes.mjs
+  init_env_shim();
+  var mergeBytes = (bytesArr) => {
+    const totalLength = bytesArr.reduce((total, arr) => total + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    bytesArr.forEach((arr) => {
+      result.set(arr, offset);
+      offset += arr.length;
+    });
+    return result;
+  };
+  var padBytes = (bytes, length) => {
+    if (bytes.length >= length)
+      return bytes;
+    const paddedBytes = new Uint8Array(length).fill(0);
+    paddedBytes.set(bytes);
+    return paddedBytes;
+  };
+  var fixBytes = (bytes, length) => padBytes(bytes.slice(0, length), length);
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/errors.mjs
+  init_env_shim();
+  var DeserializingEmptyBufferError = class extends Error {
+    constructor(serializer) {
+      super(`Serializer [${serializer}] cannot deserialize empty buffers.`);
+      __publicField(this, "name", "DeserializingEmptyBufferError");
+    }
+  };
+  var NotEnoughBytesError = class extends Error {
+    constructor(serializer, expected, actual) {
+      super(`Serializer [${serializer}] expected ${expected} bytes, got ${actual}.`);
+      __publicField(this, "name", "NotEnoughBytesError");
+    }
+  };
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/fixSerializer.mjs
+  init_env_shim();
+  function fixSerializer(serializer, fixedBytes, description) {
+    return {
+      description: description ?? `fixed(${fixedBytes}, ${serializer.description})`,
+      fixedSize: fixedBytes,
+      maxSize: fixedBytes,
+      serialize: (value) => fixBytes(serializer.serialize(value), fixedBytes),
+      deserialize: (buffer, offset = 0) => {
+        buffer = buffer.slice(offset, offset + fixedBytes);
+        if (buffer.length < fixedBytes) {
+          throw new NotEnoughBytesError("fixSerializer", fixedBytes, buffer.length);
         }
-        return {
-          encode,
-          decodeUnsafe,
-          decode
-        };
+        if (serializer.fixedSize !== null) {
+          buffer = fixBytes(buffer, serializer.fixedSize);
+        }
+        const [value] = serializer.deserialize(buffer, 0);
+        return [value, offset + fixedBytes];
       }
-      module.exports = base;
+    };
+  }
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/index.mjs
+  init_env_shim();
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/baseX.mjs
+  init_env_shim();
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/errors.mjs
+  init_env_shim();
+  var InvalidBaseStringError = class extends Error {
+    constructor(value, base, cause) {
+      const message = `Expected a string of base ${base}, got [${value}].`;
+      super(message);
+      __publicField(this, "name", "InvalidBaseStringError");
+      this.cause = cause;
     }
-  });
+  };
 
-  // ../../node_modules/.pnpm/bs58@5.0.0/node_modules/bs58/index.js
-  var require_bs58 = __commonJS({
-    "../../node_modules/.pnpm/bs58@5.0.0/node_modules/bs58/index.js"(exports, module) {
-      init_env_shim();
-      var basex = require_src();
-      var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-      module.exports = basex(ALPHABET);
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/baseX.mjs
+  var baseX = (alphabet) => {
+    const base = alphabet.length;
+    const baseBigInt = BigInt(base);
+    return {
+      description: `base${base}`,
+      fixedSize: null,
+      maxSize: null,
+      serialize(value) {
+        if (!value.match(new RegExp(`^[${alphabet}]*$`))) {
+          throw new InvalidBaseStringError(value, base);
+        }
+        if (value === "")
+          return new Uint8Array();
+        const chars = [...value];
+        let trailIndex = chars.findIndex((c) => c !== alphabet[0]);
+        trailIndex = trailIndex === -1 ? chars.length : trailIndex;
+        const leadingZeroes = Array(trailIndex).fill(0);
+        if (trailIndex === chars.length)
+          return Uint8Array.from(leadingZeroes);
+        const tailChars = chars.slice(trailIndex);
+        let base10Number = 0n;
+        let baseXPower = 1n;
+        for (let i = tailChars.length - 1; i >= 0; i -= 1) {
+          base10Number += baseXPower * BigInt(alphabet.indexOf(tailChars[i]));
+          baseXPower *= baseBigInt;
+        }
+        const tailBytes = [];
+        while (base10Number > 0n) {
+          tailBytes.unshift(Number(base10Number % 256n));
+          base10Number /= 256n;
+        }
+        return Uint8Array.from(leadingZeroes.concat(tailBytes));
+      },
+      deserialize(buffer, offset = 0) {
+        if (buffer.length === 0)
+          return ["", 0];
+        const bytes = buffer.slice(offset);
+        let trailIndex = bytes.findIndex((n) => n !== 0);
+        trailIndex = trailIndex === -1 ? bytes.length : trailIndex;
+        const leadingZeroes = alphabet[0].repeat(trailIndex);
+        if (trailIndex === bytes.length)
+          return [leadingZeroes, buffer.length];
+        let base10Number = bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);
+        const tailChars = [];
+        while (base10Number > 0n) {
+          tailChars.unshift(alphabet[Number(base10Number % baseBigInt)]);
+          base10Number /= baseBigInt;
+        }
+        return [leadingZeroes + tailChars.join(""), buffer.length];
+      }
+    };
+  };
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/base58.mjs
+  init_env_shim();
+  var base58 = baseX("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/nullCharacters.mjs
+  init_env_shim();
+  var removeNullCharacters = (value) => (
+    // eslint-disable-next-line no-control-regex
+    value.replace(/\u0000/g, "")
+  );
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/utf8.mjs
+  init_env_shim();
+  var utf8 = {
+    description: "utf8",
+    fixedSize: null,
+    maxSize: null,
+    serialize(value) {
+      return new TextEncoder().encode(value);
+    },
+    deserialize(buffer, offset = 0) {
+      const value = new TextDecoder().decode(buffer.slice(offset));
+      return [removeNullCharacters(value), buffer.length];
+    }
+  };
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/index.mjs
+  init_env_shim();
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/common.mjs
+  init_env_shim();
+  var Endian;
+  (function(Endian2) {
+    Endian2["Little"] = "le";
+    Endian2["Big"] = "be";
+  })(Endian || (Endian = {}));
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/errors.mjs
+  init_env_shim();
+  var NumberOutOfRangeError = class extends RangeError {
+    constructor(serializer, min, max, actual) {
+      super(`Serializer [${serializer}] expected number to be between ${min} and ${max}, got ${actual}.`);
+      __publicField(this, "name", "NumberOutOfRangeError");
+    }
+  };
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/utils.mjs
+  init_env_shim();
+  function numberFactory(input) {
+    let littleEndian;
+    let defaultDescription = input.name;
+    if (input.size > 1) {
+      littleEndian = !("endian" in input.options) || input.options.endian === Endian.Little;
+      defaultDescription += littleEndian ? "(le)" : "(be)";
     }
+    return {
+      description: input.options.description ?? defaultDescription,
+      fixedSize: input.size,
+      maxSize: input.size,
+      serialize(value) {
+        if (input.range) {
+          assertRange(input.name, input.range[0], input.range[1], value);
+        }
+        const buffer = new ArrayBuffer(input.size);
+        input.set(new DataView(buffer), value, littleEndian);
+        return new Uint8Array(buffer);
+      },
+      deserialize(bytes, offset = 0) {
+        const slice = bytes.slice(offset, offset + input.size);
+        assertEnoughBytes("i8", slice, input.size);
+        const view = toDataView(slice);
+        return [input.get(view, littleEndian), offset + input.size];
+      }
+    };
+  }
+  var toArrayBuffer = (array) => array.buffer.slice(array.byteOffset, array.byteLength + array.byteOffset);
+  var toDataView = (array) => new DataView(toArrayBuffer(array));
+  var assertRange = (serializer, min, max, value) => {
+    if (value < min || value > max) {
+      throw new NumberOutOfRangeError(serializer, min, max, value);
+    }
+  };
+  var assertEnoughBytes = (serializer, bytes, expected) => {
+    if (bytes.length === 0) {
+      throw new DeserializingEmptyBufferError(serializer);
+    }
+    if (bytes.length < expected) {
+      throw new NotEnoughBytesError(serializer, expected, bytes.length);
+    }
+  };
+
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u32.mjs
+  init_env_shim();
+  var u32 = (options = {}) => numberFactory({
+    name: "u32",
+    size: 4,
+    range: [0, Number("0xffffffff")],
+    set: (view, value, le) => view.setUint32(0, Number(value), le),
+    get: (view, le) => view.getUint32(0, le),
+    options
   });
 
-  // src/index.ts
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/dist/esm/utils.mjs
   init_env_shim();
+  function getSizeDescription(size) {
+    return typeof size === "object" ? size.description : `${size}`;
+  }
 
-  // ../keys/dist/index.browser.js
+  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/dist/esm/string.mjs
   init_env_shim();
-  var import_bs58 = __toESM(require_bs58(), 1);
+  function string(options = {}) {
+    const size = options.size ?? u32();
+    const encoding = options.encoding ?? utf8;
+    const description = options.description ?? `string(${encoding.description}; ${getSizeDescription(size)})`;
+    if (size === "variable") {
+      return {
+        ...encoding,
+        description
+      };
+    }
+    if (typeof size === "number") {
+      return fixSerializer(encoding, size, description);
+    }
+    return {
+      description,
+      fixedSize: null,
+      maxSize: null,
+      serialize: (value) => {
+        const contentBytes = encoding.serialize(value);
+        const lengthBytes = size.serialize(contentBytes.length);
+        return mergeBytes([lengthBytes, contentBytes]);
+      },
+      deserialize: (buffer, offset = 0) => {
+        if (buffer.slice(offset).length === 0) {
+          throw new DeserializingEmptyBufferError("string");
+        }
+        const [lengthBigInt, lengthOffset] = size.deserialize(buffer, offset);
+        const length = Number(lengthBigInt);
+        offset = lengthOffset;
+        const contentBuffer = buffer.slice(offset, offset + length);
+        if (contentBuffer.length < length) {
+          throw new NotEnoughBytesError("string", length, contentBuffer.length);
+        }
+        const [value, contentOffset] = encoding.deserialize(contentBuffer);
+        offset += contentOffset;
+        return [value, offset];
+      }
+    };
+  }
   function assertIsBase58EncodedAddress(putativeBase58EncodedAddress) {
     try {
       if (
@@ -193,7 +455,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       ) {
         throw new Error("Expected input string to decode to a byte array of length 32.");
       }
-      const bytes = import_bs58.default.decode(putativeBase58EncodedAddress);
+      const bytes = base58.serialize(putativeBase58EncodedAddress);
       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}`);
@@ -204,6 +466,113 @@ this.globalThis.solanaWeb3 = (function (exports) {
       });
     }
   }
+  function getBase58EncodedAddressCodec(config) {
+    return string({
+      description: config?.description ?? ("A 32-byte account address" ),
+      encoding: base58,
+      size: 32
+    });
+  }
+  function getBase58EncodedAddressComparator() {
+    return new Intl.Collator("en", {
+      caseFirst: "lower",
+      ignorePunctuation: false,
+      localeMatcher: "best fit",
+      numeric: false,
+      sensitivity: "variant",
+      usage: "sort"
+    }).compare;
+  }
+  function assertIsSecureContext() {
+    if (!globalThis.isSecureContext) {
+      throw new Error(
+        "Cryptographic operations are only allowed in secure browser contexts. Read more here: https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts"
+      );
+    }
+  }
+  var cachedEd25519Decision;
+  async function isEd25519CurveSupported(subtle) {
+    if (cachedEd25519Decision === void 0) {
+      cachedEd25519Decision = new Promise((resolve) => {
+        subtle.generateKey(
+          "Ed25519",
+          /* extractable */
+          false,
+          ["sign", "verify"]
+        ).catch(() => {
+          resolve(cachedEd25519Decision = false);
+        }).then(() => {
+          resolve(cachedEd25519Decision = true);
+        });
+      });
+    }
+    if (typeof cachedEd25519Decision === "boolean") {
+      return cachedEd25519Decision;
+    } else {
+      return await cachedEd25519Decision;
+    }
+  }
+  async function assertKeyGenerationIsAvailable() {
+    assertIsSecureContext();
+    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.generateKey !== "function") {
+      throw new Error("No key generation implementation could be found");
+    }
+    if (!await isEd25519CurveSupported(globalThis.crypto.subtle)) {
+      throw new Error(
+        "This runtime does not support the generation of Ed25519 key pairs.\n\nInstall and import `@solana/webcrypto-ed25519-polyfill` before generating keys in environments that do not support Ed25519.\n\nFor a list of runtimes that currently support Ed25519 operations, visit https://github.com/WICG/webcrypto-secure-curves/issues/20"
+      );
+    }
+  }
+  async function assertKeyExporterIsAvailable() {
+    assertIsSecureContext();
+    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.exportKey !== "function") {
+      throw new Error("No key export implementation could be found");
+    }
+  }
+  async function assertSigningCapabilityIsAvailable() {
+    assertIsSecureContext();
+    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.sign !== "function") {
+      throw new Error("No signing implementation could be found");
+    }
+  }
+  async function assertVerificationCapabilityIsAvailable() {
+    assertIsSecureContext();
+    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.verify !== "function") {
+      throw new Error("No signature verification implementation could be found");
+    }
+  }
+  async function generateKeyPair() {
+    await assertKeyGenerationIsAvailable();
+    const keyPair = await crypto.subtle.generateKey(
+      /* algorithm */
+      "Ed25519",
+      // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20
+      /* extractable */
+      false,
+      // Prevents the bytes of the private key from being visible to JS.
+      /* allowed uses */
+      ["sign", "verify"]
+    );
+    return keyPair;
+  }
+  async function getBase58EncodedAddressFromPublicKey(publicKey) {
+    await assertKeyExporterIsAvailable();
+    if (publicKey.type !== "public" || publicKey.algorithm.name !== "Ed25519") {
+      throw new Error("The `CryptoKey` must be an `Ed25519` public key");
+    }
+    const publicKeyBytes = await crypto.subtle.exportKey("raw", publicKey);
+    const [base58EncodedAddress] = getBase58EncodedAddressCodec().deserialize(new Uint8Array(publicKeyBytes));
+    return base58EncodedAddress;
+  }
+  async function signBytes(key, data) {
+    await assertSigningCapabilityIsAvailable();
+    const signedData = await crypto.subtle.sign("Ed25519", key, data);
+    return new Uint8Array(signedData);
+  }
+  async function verifySignature(key, signature, data) {
+    await assertVerificationCapabilityIsAvailable();
+    return await crypto.subtle.verify("Ed25519", key, signature, data);
+  }
 
   // src/rpc.ts
   init_env_shim();
@@ -237,7 +606,83 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   var KEYPATH_WILDCARD = {};
   var ALLOWED_NUMERIC_KEYPATHS = {
-    getInflationReward: [[KEYPATH_WILDCARD, "commission"]]
+    getAccountInfo: [
+      // parsed AddressTableLookup account
+      ["value", "data", "parsed", "info", "lastExtendedSlotStartIndex"],
+      // parsed Config account
+      ["value", "data", "parsed", "info", "slashPenalty"],
+      ["value", "data", "parsed", "info", "warmupCooldownRate"],
+      // parsed Token/Token22 token account
+      ["value", "data", "parsed", "info", "tokenAmount", "decimals"],
+      ["value", "data", "parsed", "info", "tokenAmount", "uiAmount"],
+      ["value", "data", "parsed", "info", "rentExemptReserve", "decimals"],
+      ["value", "data", "parsed", "info", "delegatedAmount", "decimals"],
+      [
+        "value",
+        "data",
+        "parsed",
+        "info",
+        "extensions",
+        KEYPATH_WILDCARD,
+        "state",
+        "olderTransferFee",
+        "transferFeeBasisPoints"
+      ],
+      [
+        "value",
+        "data",
+        "parsed",
+        "info",
+        "extensions",
+        KEYPATH_WILDCARD,
+        "state",
+        "newerTransferFee",
+        "transferFeeBasisPoints"
+      ],
+      ["value", "data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "preUpdateAverageRate"],
+      ["value", "data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "currentRate"],
+      // parsed Token/Token22 mint account
+      ["value", "data", "parsed", "info", "decimals"],
+      // parsed Token/Token22 multisig account
+      ["value", "data", "parsed", "info", "numRequiredSigners"],
+      ["value", "data", "parsed", "info", "numValidSigners"],
+      // parsed Stake account
+      ["value", "data", "parsed", "info", "stake", "delegation", "warmupCooldownRate"],
+      // parsed Sysvar rent account
+      ["value", "data", "parsed", "info", "exemptionThreshold"],
+      ["value", "data", "parsed", "info", "burnPercent"],
+      // parsed Vote account
+      ["value", "data", "parsed", "info", "commission"],
+      ["value", "data", "parsed", "info", "votes", KEYPATH_WILDCARD, "confirmationCount"]
+    ],
+    getBlockTime: [[]],
+    getInflationReward: [[KEYPATH_WILDCARD, "commission"]],
+    getRecentPerformanceSamples: [[KEYPATH_WILDCARD, "samplePeriodSecs"]],
+    getTokenLargestAccounts: [
+      ["value", KEYPATH_WILDCARD, "decimals"],
+      ["value", KEYPATH_WILDCARD, "uiAmount"]
+    ],
+    getTransaction: [
+      ["meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+      ["meta", "preTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
+      ["meta", "postTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+      ["meta", "postTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
+      ["meta", "rewards", KEYPATH_WILDCARD, "commission"],
+      ["meta", "innerInstructions", KEYPATH_WILDCARD, "index"],
+      ["meta", "innerInstructions", KEYPATH_WILDCARD, "instructions", KEYPATH_WILDCARD, "programIdIndex"],
+      ["meta", "innerInstructions", KEYPATH_WILDCARD, "instructions", KEYPATH_WILDCARD, "accounts", KEYPATH_WILDCARD],
+      ["transaction", "message", "addressTableLookups", KEYPATH_WILDCARD, "writableIndexes", KEYPATH_WILDCARD],
+      ["transaction", "message", "addressTableLookups", KEYPATH_WILDCARD, "readonlyIndexes", KEYPATH_WILDCARD],
+      ["transaction", "message", "instructions", KEYPATH_WILDCARD, "programIdIndex"],
+      ["transaction", "message", "instructions", KEYPATH_WILDCARD, "accounts", KEYPATH_WILDCARD],
+      ["transaction", "message", "header", "numReadonlySignedAccounts"],
+      ["transaction", "message", "header", "numReadonlyUnsignedAccounts"],
+      ["transaction", "message", "header", "numRequiredSignatures"]
+    ],
+    getVoteAccounts: [
+      ["current", KEYPATH_WILDCARD, "commission"],
+      ["delinquent", KEYPATH_WILDCARD, "commission"]
+    ]
   };
   function getNextAllowedKeypaths(keyPaths, property) {
     return keyPaths.filter((keyPath) => keyPath[0] === KEYPATH_WILDCARD && typeof property === "number" || keyPath[0] === property).map((keyPath) => keyPath.slice(1));
@@ -257,7 +702,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
       return out;
     } else if (typeof value === "number" && // The presence of an allowed keypath on the route to this value implies it's allowlisted;
     // Upcast the value to `bigint` unless an allowed keypath is present.
-    allowedKeypaths.length === 0) {
+    allowedKeypaths.length === 0 && // Only try to upcast an Integer to `bigint`
+    Number.isInteger(value)) {
       return BigInt(value);
     } else {
       return value;
@@ -294,46 +740,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
     });
   }
 
-  // src/rpc-default-config.ts
-  init_env_shim();
-
-  // src/rpc-integer-overflow-error.ts
-  init_env_shim();
-  var SolanaJsonRpcIntegerOverflowError = class extends Error {
-    constructor(methodName, keyPath, value) {
-      const argPosition = (typeof keyPath[0] === "number" ? keyPath[0] : parseInt(keyPath[0], 10)) + 1;
-      let ordinal = "";
-      const lastDigit = argPosition % 10;
-      const lastTwoDigits = argPosition % 100;
-      if (lastDigit == 1 && lastTwoDigits != 11) {
-        ordinal = argPosition + "st";
-      } else if (lastDigit == 2 && lastTwoDigits != 12) {
-        ordinal = argPosition + "nd";
-      } else if (lastDigit == 3 && lastTwoDigits != 13) {
-        ordinal = argPosition + "rd";
-      } else {
-        ordinal = argPosition + "th";
-      }
-      const path = keyPath.length > 1 ? keyPath.slice(1).map((pathPart) => typeof pathPart === "number" ? `[${pathPart}]` : pathPart).join(".") : null;
-      super(
-        `The ${ordinal} argument to the \`${methodName}\` RPC method${path ? ` at path \`${path}\`` : ""} was \`${value}\`. This number is unsafe for use with the Solana JSON-RPC because it exceeds \`Number.MAX_SAFE_INTEGER\`.`
-      );
-      this.keyPath = keyPath;
-      this.methodName = methodName;
-      this.value = value;
-    }
-    get name() {
-      return "SolanaJsonRpcIntegerOverflowError";
-    }
-  };
-
-  // src/rpc-default-config.ts
-  var DEFAULT_RPC_CONFIG = {
-    onIntegerOverflow(methodName, keyPath, value) {
-      throw new SolanaJsonRpcIntegerOverflowError(methodName, keyPath, value);
-    }
-  };
-
   // ../rpc-transport/dist/index.browser.js
   init_env_shim();
   var SolanaJsonRpcError = class extends Error {
@@ -399,6 +805,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   function createJsonRpc(rpcConfig) {
     return makeProxy(rpcConfig);
   }
+  var e = globalThis.fetch;
   var SolanaHttpError = class extends Error {
     constructor(details) {
       super(`HTTP error (${details.statusCode}): ${details.message}`);
@@ -457,7 +864,6 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
     return out;
   }
-  var e = globalThis.fetch;
   function createHttpTransport({ httpAgentNodeOnly, headers, url }) {
     if (headers) {
       assertIsAllowedHttpRequestHeaders(headers);
@@ -498,6 +904,46 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
+  // src/rpc-default-config.ts
+  init_env_shim();
+
+  // src/rpc-integer-overflow-error.ts
+  init_env_shim();
+  var SolanaJsonRpcIntegerOverflowError = class extends Error {
+    constructor(methodName, keyPath, value) {
+      const argPosition = (typeof keyPath[0] === "number" ? keyPath[0] : parseInt(keyPath[0], 10)) + 1;
+      let ordinal = "";
+      const lastDigit = argPosition % 10;
+      const lastTwoDigits = argPosition % 100;
+      if (lastDigit == 1 && lastTwoDigits != 11) {
+        ordinal = argPosition + "st";
+      } else if (lastDigit == 2 && lastTwoDigits != 12) {
+        ordinal = argPosition + "nd";
+      } else if (lastDigit == 3 && lastTwoDigits != 13) {
+        ordinal = argPosition + "rd";
+      } else {
+        ordinal = argPosition + "th";
+      }
+      const path = keyPath.length > 1 ? keyPath.slice(1).map((pathPart) => typeof pathPart === "number" ? `[${pathPart}]` : pathPart).join(".") : null;
+      super(
+        `The ${ordinal} argument to the \`${methodName}\` RPC method${path ? ` at path \`${path}\`` : ""} was \`${value}\`. This number is unsafe for use with the Solana JSON-RPC because it exceeds \`Number.MAX_SAFE_INTEGER\`.`
+      );
+      this.keyPath = keyPath;
+      this.methodName = methodName;
+      this.value = value;
+    }
+    get name() {
+      return "SolanaJsonRpcIntegerOverflowError";
+    }
+  };
+
+  // src/rpc-default-config.ts
+  var DEFAULT_RPC_CONFIG = {
+    onIntegerOverflow(methodName, keyPath, value) {
+      throw new SolanaJsonRpcIntegerOverflowError(methodName, keyPath, value);
+    }
+  };
+
   // src/rpc.ts
   function createSolanaRpc(config) {
     return createJsonRpc({
@@ -508,6 +954,73 @@ this.globalThis.solanaWeb3 = (function (exports) {
 
   // src/rpc-transport.ts
   init_env_shim();
+
+  // src/rpc-request-coalescer.ts
+  init_env_shim();
+  function getRpcTransportWithRequestCoalescing(transport, getDeduplicationKey) {
+    let coalescedRequestsByDeduplicationKey;
+    return async function makeCoalescedHttpRequest(config) {
+      const { payload, signal } = config;
+      const deduplicationKey = getDeduplicationKey(payload);
+      if (deduplicationKey === void 0) {
+        return await transport(config);
+      }
+      if (!coalescedRequestsByDeduplicationKey) {
+        Promise.resolve().then(() => {
+          coalescedRequestsByDeduplicationKey = void 0;
+        });
+        coalescedRequestsByDeduplicationKey = {};
+      }
+      if (coalescedRequestsByDeduplicationKey[deduplicationKey] == null) {
+        const abortController = new AbortController();
+        coalescedRequestsByDeduplicationKey[deduplicationKey] = {
+          abortController,
+          numConsumers: 0,
+          responsePromise: transport({
+            ...config,
+            signal: abortController.signal
+          })
+        };
+      }
+      const coalescedRequest = coalescedRequestsByDeduplicationKey[deduplicationKey];
+      coalescedRequest.numConsumers++;
+      if (signal) {
+        const responsePromise = coalescedRequest.responsePromise;
+        return await new Promise((resolve, reject) => {
+          const handleAbort = (e2) => {
+            signal.removeEventListener("abort", handleAbort);
+            coalescedRequest.numConsumers -= 1;
+            if (coalescedRequest.numConsumers === 0) {
+              const abortController = coalescedRequest.abortController;
+              abortController.abort();
+            }
+            const abortError = new DOMException(e2.target.reason, "AbortError");
+            reject(abortError);
+          };
+          signal.addEventListener("abort", handleAbort);
+          responsePromise.then(resolve).finally(() => {
+            signal.removeEventListener("abort", handleAbort);
+          });
+        });
+      } else {
+        return await coalescedRequest.responsePromise;
+      }
+    };
+  }
+
+  // src/rpc-request-deduplication.ts
+  init_env_shim();
+  var import_fast_stable_stringify = __toESM(require_fast_stable_stringify(), 1);
+  function getSolanaRpcPayloadDeduplicationKey(payload) {
+    if (payload == null || typeof payload !== "object" || Array.isArray(payload)) {
+      return;
+    }
+    if ("jsonrpc" in payload && payload.jsonrpc === "2.0" && "method" in payload && "params" in payload) {
+      return (0, import_fast_stable_stringify.default)([payload.method, payload.params]);
+    }
+  }
+
+  // src/rpc-transport.ts
   function normalizeHeaders2(headers) {
     const out = {};
     for (const headerName in headers) {
@@ -516,21 +1029,38 @@ this.globalThis.solanaWeb3 = (function (exports) {
     return out;
   }
   function createDefaultRpcTransport(config) {
-    return createHttpTransport({
-      ...config,
-      headers: {
-        ...config.headers ? normalizeHeaders2(config.headers) : void 0,
-        ...{
-          // Keep these headers lowercase so they will override any user-supplied headers above.
-          "solana-client": `js/${"2.0.0-development"}` ?? "UNKNOWN"
+    return getRpcTransportWithRequestCoalescing(
+      createHttpTransport({
+        ...config,
+        headers: {
+          ...config.headers ? normalizeHeaders2(config.headers) : void 0,
+          ...{
+            // Keep these headers lowercase so they will override any user-supplied headers above.
+            "solana-client": `js/${"2.0.0-development"}` ?? "UNKNOWN"
+          }
         }
-      }
-    });
+      }),
+      getSolanaRpcPayloadDeduplicationKey
+    );
   }
 
+  exports.AccountRole = AccountRole;
   exports.assertIsBase58EncodedAddress = assertIsBase58EncodedAddress;
   exports.createDefaultRpcTransport = createDefaultRpcTransport;
   exports.createSolanaRpc = createSolanaRpc;
+  exports.downgradeRoleToNonSigner = downgradeRoleToNonSigner;
+  exports.downgradeRoleToReadonly = downgradeRoleToReadonly;
+  exports.generateKeyPair = generateKeyPair;
+  exports.getBase58EncodedAddressCodec = getBase58EncodedAddressCodec;
+  exports.getBase58EncodedAddressComparator = getBase58EncodedAddressComparator;
+  exports.getBase58EncodedAddressFromPublicKey = getBase58EncodedAddressFromPublicKey;
+  exports.isSignerRole = isSignerRole;
+  exports.isWritableRole = isWritableRole;
+  exports.mergeRoles = mergeRoles;
+  exports.signBytes = signBytes;
+  exports.upgradeRoleToSigner = upgradeRoleToSigner;
+  exports.upgradeRoleToWritable = upgradeRoleToWritable;
+  exports.verifySignature = verifySignature;
 
   return exports;