@solana/web3.js 1.77.2 → 2.0.0-experimental.09348ce

package/dist/index.development.js

@@ -0,0 +1,710 @@
+this.globalThis = this.globalThis || {};
+this.globalThis.solanaWeb3 = (function (exports) {
+  'use strict';
+
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // ../build-scripts/env-shim.ts
+  var init_env_shim = __esm({
+    "../build-scripts/env-shim.ts"() {
+    }
+  });
+
+  // ../../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) {
+      init_env_shim();
+      function base(ALPHABET) {
+        if (ALPHABET.length >= 255) {
+          throw new TypeError("Alphabet too long");
+        }
+        var BASE_MAP = new Uint8Array(256);
+        for (var j = 0; j < BASE_MAP.length; j++) {
+          BASE_MAP[j] = 255;
+        }
+        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;
+        }
+        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;
+            }
+            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;
+        }
+        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;
+        }
+        function decode(string) {
+          var buffer = decodeUnsafe(string);
+          if (buffer) {
+            return buffer;
+          }
+          throw new Error("Non-base" + BASE + " character");
+        }
+        return {
+          encode,
+          decodeUnsafe,
+          decode
+        };
+      }
+      module.exports = base;
+    }
+  });
+
+  // ../../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/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();
+      var objToString = Object.prototype.toString;
+      var objKeys = Object.keys || function(obj) {
+        var keys = [];
+        for (var name in obj) {
+          keys.push(name);
+        }
+        return keys;
+      };
+      function stringify(val, isArrayProp) {
+        var i, max, str, keys, key, propVal, toStr;
+        if (val === true) {
+          return "true";
+        }
+        if (val === false) {
+          return "false";
+        }
+        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);
+              }
+            }
+          case "function":
+          case "undefined":
+            return isArrayProp ? null : void 0;
+          case "string":
+            return JSON.stringify(val);
+          default:
+            return isFinite(val) ? val : null;
+        }
+      }
+      module.exports = function(val) {
+        var returnVal = stringify(val, false);
+        if (returnVal !== void 0) {
+          return "" + returnVal;
+        }
+      };
+    }
+  });
+
+  // src/index.ts
+  init_env_shim();
+
+  // ../keys/dist/index.browser.js
+  init_env_shim();
+  var import_bs58 = __toESM(require_bs58(), 1);
+  function assertIsBase58EncodedAddress(putativeBase58EncodedAddress) {
+    try {
+      if (
+        // Lowest address (32 bytes of zeroes)
+        putativeBase58EncodedAddress.length < 32 || // Highest address (32 bytes of 255)
+        putativeBase58EncodedAddress.length > 44
+      ) {
+        throw new Error("Expected input string to decode to a byte array of length 32.");
+      }
+      const bytes = import_bs58.default.decode(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}`);
+      }
+    } catch (e2) {
+      throw new Error(`\`${putativeBase58EncodedAddress}\` is not a base-58 encoded address`, {
+        cause: e2
+      });
+    }
+  }
+
+  // src/rpc.ts
+  init_env_shim();
+
+  // ../rpc-core/dist/index.browser.js
+  init_env_shim();
+  __toESM(require_bs58(), 1);
+  function visitNode(value, keyPath, onIntegerOverflow) {
+    if (Array.isArray(value)) {
+      return value.map(
+        (element, ii) => visitNode(element, [...keyPath, ii], onIntegerOverflow)
+      );
+    } else if (typeof value === "object" && value !== null) {
+      const out = {};
+      for (const propName in value) {
+        if (Object.prototype.hasOwnProperty.call(value, propName)) {
+          out[propName] = visitNode(value[propName], [...keyPath, propName], onIntegerOverflow);
+        }
+      }
+      return out;
+    } else if (typeof value === "bigint") {
+      if (onIntegerOverflow && (value > Number.MAX_SAFE_INTEGER || value < -Number.MAX_SAFE_INTEGER)) {
+        onIntegerOverflow(keyPath, value);
+      }
+      return Number(value);
+    } else {
+      return value;
+    }
+  }
+  function patchParamsForSolanaLabsRpc(params, onIntegerOverflow) {
+    return visitNode(params, [], onIntegerOverflow);
+  }
+  var KEYPATH_WILDCARD = {};
+  var ALLOWED_NUMERIC_KEYPATHS = {
+    getBlockTime: [[]],
+    getInflationReward: [[KEYPATH_WILDCARD, "commission"]],
+    getRecentPerformanceSamples: [[KEYPATH_WILDCARD, "samplePeriodSecs"]],
+    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));
+  }
+  function visitNode2(value, allowedKeypaths) {
+    if (Array.isArray(value)) {
+      return value.map((element, ii) => {
+        const nextAllowedKeypaths = getNextAllowedKeypaths(allowedKeypaths, ii);
+        return visitNode2(element, nextAllowedKeypaths);
+      });
+    } else if (typeof value === "object" && value !== null) {
+      const out = {};
+      for (const [propName, innerValue] of Object.entries(value)) {
+        const nextAllowedKeypaths = getNextAllowedKeypaths(allowedKeypaths, propName);
+        out[propName] = visitNode2(innerValue, nextAllowedKeypaths);
+      }
+      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) {
+      return BigInt(value);
+    } else {
+      return value;
+    }
+  }
+  function patchResponseForSolanaLabsRpc(rawResponse, methodName) {
+    const allowedKeypaths = methodName ? ALLOWED_NUMERIC_KEYPATHS[methodName] : void 0;
+    return visitNode2(rawResponse, allowedKeypaths ?? []);
+  }
+  function createSolanaRpcApi(config) {
+    return new Proxy({}, {
+      defineProperty() {
+        return false;
+      },
+      deleteProperty() {
+        return false;
+      },
+      get(...args) {
+        const [_, p] = args;
+        const methodName = p.toString();
+        return function(...rawParams) {
+          const handleIntegerOverflow = config?.onIntegerOverflow;
+          const params = patchParamsForSolanaLabsRpc(
+            rawParams,
+            handleIntegerOverflow ? (keyPath, value) => handleIntegerOverflow(methodName, keyPath, value) : void 0
+          );
+          return {
+            methodName,
+            params,
+            responseProcessor: (rawResponse) => patchResponseForSolanaLabsRpc(rawResponse, methodName)
+          };
+        };
+      }
+    });
+  }
+
+  // ../rpc-transport/dist/index.browser.js
+  init_env_shim();
+  var SolanaJsonRpcError = class extends Error {
+    constructor(details) {
+      super(`JSON-RPC 2.0 error (${details.code}): ${details.message}`);
+      Error.captureStackTrace(this, this.constructor);
+      this.code = details.code;
+      this.data = details.data;
+    }
+    get name() {
+      return "SolanaJsonRpcError";
+    }
+  };
+  var _nextMessageId = 0;
+  function getNextMessageId() {
+    const id = _nextMessageId;
+    _nextMessageId = (_nextMessageId + 1) % Number.MAX_SAFE_INTEGER;
+    return id;
+  }
+  function createJsonRpcMessage(method, params) {
+    return {
+      id: getNextMessageId(),
+      jsonrpc: "2.0",
+      method,
+      params
+    };
+  }
+  function createPendingRpcRequest(rpcConfig, pendingRequest) {
+    return {
+      async send(options) {
+        const { methodName, params, responseProcessor } = pendingRequest;
+        const payload = createJsonRpcMessage(methodName, params);
+        const response = await rpcConfig.transport({
+          payload,
+          signal: options?.abortSignal
+        });
+        if ("error" in response) {
+          throw new SolanaJsonRpcError(response.error);
+        } else {
+          return responseProcessor ? responseProcessor(response.result) : response.result;
+        }
+      }
+    };
+  }
+  function makeProxy(rpcConfig) {
+    return new Proxy(rpcConfig.api, {
+      defineProperty() {
+        return false;
+      },
+      deleteProperty() {
+        return false;
+      },
+      get(target, p, receiver) {
+        return function(...rawParams) {
+          const methodName = p.toString();
+          const createRpcRequest = Reflect.get(target, methodName, receiver);
+          const newRequest = createRpcRequest ? createRpcRequest(...rawParams) : { methodName, params: rawParams };
+          return createPendingRpcRequest(rpcConfig, newRequest);
+        };
+      }
+    });
+  }
+  function createJsonRpc(rpcConfig) {
+    return makeProxy(rpcConfig);
+  }
+  var e = globalThis.fetch;
+  var SolanaHttpError = class extends Error {
+    constructor(details) {
+      super(`HTTP error (${details.statusCode}): ${details.message}`);
+      Error.captureStackTrace(this, this.constructor);
+      this.statusCode = details.statusCode;
+    }
+    get name() {
+      return "SolanaHttpError";
+    }
+  };
+  var DISALLOWED_HEADERS = {
+    accept: true,
+    "content-length": true,
+    "content-type": true
+  };
+  var FORBIDDEN_HEADERS = {
+    "accept-charset": true,
+    "accept-encoding": true,
+    "access-control-request-headers": true,
+    "access-control-request-method": true,
+    connection: true,
+    "content-length": true,
+    cookie: true,
+    date: true,
+    dnt: true,
+    expect: true,
+    host: true,
+    "keep-alive": true,
+    origin: true,
+    "permissions-policy": true,
+    // No currently available Typescript technique allows you to match on a prefix.
+    // 'proxy-':true,
+    // 'sec-':true,
+    referer: true,
+    te: true,
+    trailer: true,
+    "transfer-encoding": true,
+    upgrade: true,
+    via: true
+  };
+  function assertIsAllowedHttpRequestHeaders(headers) {
+    const badHeaders = Object.keys(headers).filter((headerName) => {
+      const lowercaseHeaderName = headerName.toLowerCase();
+      return DISALLOWED_HEADERS[headerName.toLowerCase()] === true || FORBIDDEN_HEADERS[headerName.toLowerCase()] === true || lowercaseHeaderName.startsWith("proxy-") || lowercaseHeaderName.startsWith("sec-");
+    });
+    if (badHeaders.length > 0) {
+      throw new Error(
+        `${badHeaders.length > 1 ? "These headers are" : "This header is"} forbidden: \`${badHeaders.join("`, `")}\`. Learn more at https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name.`
+      );
+    }
+  }
+  function normalizeHeaders(headers) {
+    const out = {};
+    for (const headerName in headers) {
+      out[headerName.toLowerCase()] = headers[headerName];
+    }
+    return out;
+  }
+  function createHttpTransport({ httpAgentNodeOnly, headers, url }) {
+    if (headers) {
+      assertIsAllowedHttpRequestHeaders(headers);
+    }
+    const agent = void 0;
+    if (httpAgentNodeOnly != null) {
+      console.warn(
+        "createHttpTransport(): The `httpAgentNodeOnly` config you supplied has been ignored; HTTP agents are only usable in Node environments."
+      );
+    }
+    const customHeaders = headers && normalizeHeaders(headers);
+    return async function makeHttpRequest({
+      payload,
+      signal
+    }) {
+      const body = JSON.stringify(payload);
+      const requestInfo = {
+        agent,
+        body,
+        headers: {
+          ...customHeaders,
+          // Keep these headers lowercase so they will override any user-supplied headers above.
+          accept: "application/json",
+          "content-length": body.length.toString(),
+          "content-type": "application/json; charset=utf-8"
+        },
+        method: "POST",
+        signal
+      };
+      const response = await e(url, requestInfo);
+      if (!response.ok) {
+        throw new SolanaHttpError({
+          message: response.statusText,
+          statusCode: response.status
+        });
+      }
+      return await response.json();
+    };
+  }
+
+  // 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({
+      ...config,
+      api: createSolanaRpcApi(DEFAULT_RPC_CONFIG)
+    });
+  }
+
+  // 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) {
+      out[headerName.toLowerCase()] = headers[headerName];
+    }
+    return out;
+  }
+  function createDefaultRpcTransport(config) {
+    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.assertIsBase58EncodedAddress = assertIsBase58EncodedAddress;
+  exports.createDefaultRpcTransport = createDefaultRpcTransport;
+  exports.createSolanaRpc = createSolanaRpc;
+
+  return exports;
+
+})({});
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.development.js.map