@solana/web3.js 1.75.0 → 2.0.0-experimental.20762e0

package/dist/index.development.js

@@ -0,0 +1,539 @@
+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);
+    }
+  });
+
+  // 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();
+  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 = {
+    getInflationReward: [[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)
+          };
+        };
+      }
+    });
+  }
+
+  // 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 {
+    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 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;
+  }
+  var e = globalThis.fetch;
+  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.ts
+  function createSolanaRpc(config) {
+    return createJsonRpc({
+      ...config,
+      api: createSolanaRpcApi(DEFAULT_RPC_CONFIG)
+    });
+  }
+
+  // src/rpc-transport.ts
+  init_env_shim();
+  function normalizeHeaders2(headers) {
+    const out = {};
+    for (const headerName in headers) {
+      out[headerName.toLowerCase()] = headers[headerName];
+    }
+    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"
+        }
+      }
+    });
+  }
+
+  exports.assertIsBase58EncodedAddress = assertIsBase58EncodedAddress;
+  exports.createDefaultRpcTransport = createDefaultRpcTransport;
+  exports.createSolanaRpc = createSolanaRpc;
+
+  return exports;
+
+})({});
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.development.js.map

package/dist/index.development.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../build-scripts/env-shim.ts","../../../node_modules/.pnpm/base-x@4.0.0/node_modules/base-x/src/index.js","../../../node_modules/.pnpm/bs58@5.0.0/node_modules/bs58/index.js","../src/index.ts","../../keys/src/base58.ts","../src/rpc.ts","../../rpc-core/src/params-patcher.ts","../../rpc-core/src/response-patcher-types.ts","../../rpc-core/src/response-patcher-allowed-numeric-values.ts","../../rpc-core/src/response-patcher.ts","../../rpc-core/src/index.ts","../src/rpc-default-config.ts","../src/rpc-integer-overflow-error.ts","../../rpc-transport/src/json-rpc-errors.ts","../../rpc-transport/src/json-rpc-message-id.ts","../../rpc-transport/src/json-rpc-message.ts","../../rpc-transport/src/json-rpc.ts","../../rpc-transport/src/transports/http/http-transport-errors.ts","../../rpc-transport/src/transports/http/http-transport-headers.ts","../../fetch-impl/src/index.browser.ts","../../rpc-transport/src/transports/http/http-transport.ts","../src/rpc-transport.ts"],"names":["i","j","bs58","e","visitNode","__DEV__","index_browser_default","normalizeHeaders"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA;AAAA;AAAA;AAAA;AAMA,aAAS,KAAM,UAAU;AACvB,UAAI,SAAS,UAAU,KAAK;AAAE,cAAM,IAAI,UAAU,mBAAmB;AAAA,MAAE;AACvE,UAAI,WAAW,IAAI,WAAW,GAAG;AACjC,eAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACxC,iBAAS,CAAC,IAAI;AAAA,MAChB;AACA,eAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACxC,YAAI,IAAI,SAAS,OAAO,CAAC;AACzB,YAAI,KAAK,EAAE,WAAW,CAAC;AACvB,YAAI,SAAS,EAAE,MAAM,KAAK;AAAE,gBAAM,IAAI,UAAU,IAAI,eAAe;AAAA,QAAE;AACrE,iBAAS,EAAE,IAAI;AAAA,MACjB;AACA,UAAI,OAAO,SAAS;AACpB,UAAI,SAAS,SAAS,OAAO,CAAC;AAC9B,UAAI,SAAS,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI,GAAG;AAC1C,UAAI,UAAU,KAAK,IAAI,GAAG,IAAI,KAAK,IAAI,IAAI;AAC3C,eAAS,OAAQ,QAAQ;AACvB,YAAI,kBAAkB,YAAY;AAAA,QAClC,WAAW,YAAY,OAAO,MAAM,GAAG;AACrC,mBAAS,IAAI,WAAW,OAAO,QAAQ,OAAO,YAAY,OAAO,UAAU;AAAA,QAC7E,WAAW,MAAM,QAAQ,MAAM,GAAG;AAChC,mBAAS,WAAW,KAAK,MAAM;AAAA,QACjC;AACA,YAAI,EAAE,kBAAkB,aAAa;AAAE,gBAAM,IAAI,UAAU,qBAAqB;AAAA,QAAE;AAClF,YAAI,OAAO,WAAW,GAAG;AAAE,iBAAO;AAAA,QAAG;AAErC,YAAI,SAAS;AACb,YAAI,SAAS;AACb,YAAI,SAAS;AACb,YAAI,OAAO,OAAO;AAClB,eAAO,WAAW,QAAQ,OAAO,MAAM,MAAM,GAAG;AAC9C;AACA;AAAA,QACF;AAEA,YAAI,QAAS,OAAO,UAAU,UAAU,MAAO;AAC/C,YAAI,MAAM,IAAI,WAAW,IAAI;AAE7B,eAAO,WAAW,MAAM;AACtB,cAAI,QAAQ,OAAO,MAAM;AAEzB,cAAIA,KAAI;AACR,mBAAS,MAAM,OAAO,IAAI,UAAU,KAAKA,KAAI,WAAY,QAAQ,IAAK,OAAOA,MAAK;AAChF,qBAAU,MAAM,IAAI,GAAG,MAAO;AAC9B,gBAAI,GAAG,IAAK,QAAQ,SAAU;AAC9B,oBAAS,QAAQ,SAAU;AAAA,UAC7B;AACA,cAAI,UAAU,GAAG;AAAE,kBAAM,IAAI,MAAM,gBAAgB;AAAA,UAAE;AACrD,mBAASA;AACT;AAAA,QACF;AAEA,YAAI,MAAM,OAAO;AACjB,eAAO,QAAQ,QAAQ,IAAI,GAAG,MAAM,GAAG;AACrC;AAAA,QACF;AAEA,YAAI,MAAM,OAAO,OAAO,MAAM;AAC9B,eAAO,MAAM,MAAM,EAAE,KAAK;AAAE,iBAAO,SAAS,OAAO,IAAI,GAAG,CAAC;AAAA,QAAE;AAC7D,eAAO;AAAA,MACT;AACA,eAAS,aAAc,QAAQ;AAC7B,YAAI,OAAO,WAAW,UAAU;AAAE,gBAAM,IAAI,UAAU,iBAAiB;AAAA,QAAE;AACzE,YAAI,OAAO,WAAW,GAAG;AAAE,iBAAO,IAAI,WAAW;AAAA,QAAE;AACnD,YAAI,MAAM;AAEV,YAAI,SAAS;AACb,YAAI,SAAS;AACb,eAAO,OAAO,GAAG,MAAM,QAAQ;AAC7B;AACA;AAAA,QACF;AAEA,YAAI,QAAU,OAAO,SAAS,OAAO,SAAU,MAAO;AACtD,YAAI,OAAO,IAAI,WAAW,IAAI;AAE9B,eAAO,OAAO,GAAG,GAAG;AAElB,cAAI,QAAQ,SAAS,OAAO,WAAW,GAAG,CAAC;AAE3C,cAAI,UAAU,KAAK;AAAE;AAAA,UAAO;AAC5B,cAAIA,KAAI;AACR,mBAAS,MAAM,OAAO,IAAI,UAAU,KAAKA,KAAI,WAAY,QAAQ,IAAK,OAAOA,MAAK;AAChF,qBAAU,OAAO,KAAK,GAAG,MAAO;AAChC,iBAAK,GAAG,IAAK,QAAQ,QAAS;AAC9B,oBAAS,QAAQ,QAAS;AAAA,UAC5B;AACA,cAAI,UAAU,GAAG;AAAE,kBAAM,IAAI,MAAM,gBAAgB;AAAA,UAAE;AACrD,mBAASA;AACT;AAAA,QACF;AAEA,YAAI,MAAM,OAAO;AACjB,eAAO,QAAQ,QAAQ,KAAK,GAAG,MAAM,GAAG;AACtC;AAAA,QACF;AACA,YAAI,MAAM,IAAI,WAAW,UAAU,OAAO,IAAI;AAC9C,YAAIC,KAAI;AACR,eAAO,QAAQ,MAAM;AACnB,cAAIA,IAAG,IAAI,KAAK,KAAK;AAAA,QACvB;AACA,eAAO;AAAA,MACT;AACA,eAAS,OAAQ,QAAQ;AACvB,YAAI,SAAS,aAAa,MAAM;AAChC,YAAI,QAAQ;AAAE,iBAAO;AAAA,QAAO;AAC5B,cAAM,IAAI,MAAM,aAAa,OAAO,YAAY;AAAA,MAClD;AACA,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF;AACA,WAAO,UAAU;AAAA;AAAA;;;ACxHjB;AAAA;AAAA;AAAA,QAAM,QAAQ;AACd,QAAM,WAAW;AAEjB,WAAO,UAAU,MAAM,QAAQ;AAAA;AAAA;;;ACH/B;;;;;ACOI,SAAI,6BAAA,8BAAA;AAEA,MAAA;AAAA;;MAII,6BAA6B,SAAS;MACxC,6BAAA,SAAA;MACE;AACJ,YAAA,IAAA,MAAA,+DAAA;IAEA;AACA,UAAM,QAAA,YAAAC,QAAW,OAAM,4BAAA;AACvB,UAAI,WAAa,MAAI;AACjB,QAAA,aAAU,IAAM;AACpB,YAAA,IAAA,MAAA,gFAAA,UAAA;IACJ;EACI,SAAMC,IAAN;AAAwF,UACpF,IAAO,MAAA,KAAA,mEAAA;MACV,OAAAA;IACL,CAAA;EACJ;;;;AC5BA;;;;ACMA,SAAS,UAAa,OAAU,SAA8B,mBAAwD;AAClH,MAAI,MAAM,QAAQ,KAAK,GAAG;AACtB,WAAO,MAAM;MAAI,CAAC,SAAS,OACvB,UAAU,SAAS,CAAC,GAAG,SAAS,EAAE,GAAG,iBAAiB;IAC1D;EACJ,WAAW,OAAO,UAAU,YAAY,UAAU,MAAM;AACpD,UAAM,MAAM,CAAC;AACb,eAAW,YAAY,OAAO;AAC1B,UAAI,OAAO,UAAU,eAAe,KAAK,OAAO,QAAQ,GAAG;AACvD,YAAI,QAAQ,IAAI,UAAU,MAAM,QAAQ,GAAG,CAAC,GAAG,SAAS,QAAQ,GAAG,iBAAiB;MACxF;IACJ;AACA,WAAO;EACX,WAAW,OAAO,UAAU,UAAU;AAIlC,QAAI,sBAAsB,QAAQ,OAAO,oBAAoB,QAAQ,CAAC,OAAO,mBAAmB;AAC5F,wBAAkB,SAAS,KAAK;IACpC;AACA,WAAO,OAAO,KAAK;EACvB,OAAO;AACH,WAAO;EACX;AACJ;AAEO,SAAS,4BAA+B,QAAW,mBAAwD;AAC9G,SAAO,UAAU,QAAQ,CAAC,GAAG,iBAAiB;AAClD;AChCO,IAAM,mBAAmB,CAAC;ACM1B,IAAM,2BAET;EACA,oBAAoB,CAAC,CAAC,kBAAkB,YAAY,CAAC;AACzD;ACHA,SAAS,uBAAuB,UAA8B,UAA2B;AACrF,SAAO,SACF,OAAO,CAAA,YAAY,QAAQ,CAAC,MAAM,oBAAoB,OAAO,aAAa,YAAa,QAAQ,CAAC,MAAM,QAAQ,EAC9G,IAAI,CAAA,YAAW,QAAQ,MAAM,CAAC,CAAC;AACxC;AAEA,SAASC,WAAa,OAAgB,iBAAwC;AAC1E,MAAI,MAAM,QAAQ,KAAK,GAAG;AACtB,WAAO,MAAM,IAAI,CAAC,SAAS,OAAO;AAC9B,YAAM,sBAAsB,uBAAuB,iBAAiB,EAAE;AACtE,aAAOA,WAAU,SAAS,mBAAmB;IACjD,CAAC;EACL,WAAW,OAAO,UAAU,YAAY,UAAU,MAAM;AACpD,UAAM,MAAM,CAAC;AACb,eAAW,CAAC,UAAU,UAAU,KAAK,OAAO,QAAQ,KAAK,GAAG;AACxD,YAAM,sBAAsB,uBAAuB,iBAAiB,QAAQ;AAC5E,UAAI,QAAQ,IAAIA,WAAU,YAAY,mBAAmB;IAC7D;AACA,WAAO;EACX,WACI,OAAO,UAAU;;EAGjB,gBAAgB,WAAW,GAC7B;AAIE,WAAO,OAAO,KAAK;EACvB,OAAO;AACH,WAAO;EACX;AACJ;AAEO,SAAS,8BACZ,aACA,YACC;AACD,QAAM,kBAAkB,aAAa,yBAAyB,UAAU,IAAI;AAC5E,SAAOA,WAAU,aAAa,mBAAmB,CAAC,CAAC;AACvD;AC9BO,SAAS,mBAAmB,QAA4C;AAC3E,SAAO,IAAI,MAAM,CAAC,GAAgC;IAC9C,iBAAiB;AACb,aAAO;IACX;IACA,iBAAiB;AACb,aAAO;IACX;IACA,OACO,MACL;AACE,YAAM,CAAC,GAAG,CAAC,IAAI;AACf,YAAM,aAAa,EAAE,SAAS;AAC9B,aAAO,YACA,WAGkD;AACrD,cAAM,wBAAwB,QAAQ;AACtC,cAAM,SAAS;UACX;UACA,wBACM,CAAC,SAAS,UAAU,sBAAsB,YAAY,SAAS,KAAK,IACpE;QACV;AACA,eAAO;UACH;UACA;UACA,mBAAmB,CAAA,gBAAe,8BAA8B,aAAa,UAAU;QAC3F;MACJ;IACJ;EACJ,CAAC;AACL;;;ACpDA;;;ACAA;AAAO,IAAM,oCAAN,cAAgD,MAAM;AAAA,EAIzD,YAAY,YAAoB,SAA8B,OAAe;AACzE,UAAM,eAAe,OAAO,QAAQ,CAAC,MAAM,WAAW,QAAQ,CAAC,IAAI,SAAS,QAAQ,CAAC,GAAG,EAAE,KAAK;AAC/F,QAAI,UAAU;AACd,UAAM,YAAY,cAAc;AAChC,UAAM,gBAAgB,cAAc;AACpC,QAAI,aAAa,KAAK,iBAAiB,IAAI;AACvC,gBAAU,cAAc;AAAA,IAC5B,WAAW,aAAa,KAAK,iBAAiB,IAAI;AAC9C,gBAAU,cAAc;AAAA,IAC5B,WAAW,aAAa,KAAK,iBAAiB,IAAI;AAC9C,gBAAU,cAAc;AAAA,IAC5B,OAAO;AACH,gBAAU,cAAc;AAAA,IAC5B;AACA,UAAM,OACF,QAAQ,SAAS,IACX,QACK,MAAM,CAAC,EACP,IAAI,cAAa,OAAO,aAAa,WAAW,IAAI,cAAc,QAAS,EAC3E,KAAK,GAAG,IACb;AACV;AAAA,MACI,OAAO,6BAA6B,0BAC7B,OAAO,cAAc,WAAW,YAAY;AAAA,IAGvD;AACA,SAAK,UAAU;AACf,SAAK,aAAa;AAClB,SAAK,QAAQ;AAAA,EACjB;AAAA,EACA,IAAI,OAAO;AACP,WAAO;AAAA,EACX;AACJ;;;ADnCO,IAAM,qBAAwE;AAAA,EACjF,kBAAkB,YAAY,SAAS,OAAO;AAC1C,UAAM,IAAI,kCAAkC,YAAY,SAAS,KAAK;AAAA,EAC1E;AACJ;;;;AXNO,IAAMC,WAA2B,uBAAO,MAAwD;Aa2BhG,IAAM,qBAAN,cAAiC,MAAM;EAG1C,YAAY,SAAoC;AAC5C,UAAM,uBAAuB,QAAQ,UAAU,QAAQ,SAAS;AAChE,UAAM,kBAAkB,MAAM,KAAK,WAAW;AAC9C,SAAK,OAAO,QAAQ;AACpB,SAAK,OAAO,QAAQ;EACxB;EACA,IAAI,OAAO;AACP,WAAO;EACX;AACJ;ACxCA,IAAI,iBAAiB;AACd,SAAS,mBAAmB;AAC/B,QAAM,KAAK;AACX,oBAAkB,iBAAiB,KAAK,OAAO;AAC/C,SAAO;AACX;ACHO,SAAS,qBAA8B,QAAgB,QAAiB;AAC3E,SAAO;IACH,IAAI,iBAAiB;IACrB,SAAS;IACT;IACA;EACJ;AACJ;ACCA,SAAS,wBACL,WACA,gBAC4B;AAC5B,SAAO;IACH,MAAM,KAAK,SAA2C;AAClD,YAAM,EAAE,YAAY,QAAQ,kBAAkB,IAAI;AAClD,YAAM,UAAU,qBAAqB,YAAY,MAAM;AACvD,YAAM,WAAW,MAAM,UAAU,UAAoC;QACjE;QACA,QAAQ,SAAS;MACrB,CAAC;AACD,UAAI,WAAW,UAAU;AACrB,cAAM,IAAI,mBAAmB,SAAS,KAAK;MAC/C,OAAO;AACH,eAAQ,oBAAoB,kBAAkB,SAAS,MAAM,IAAI,SAAS;MAC9E;IACJ;EACJ;AACJ;AAEA,SAAS,UAAuB,WAAqD;AACjF,SAAO,IAAI,MAAM,UAAU,KAAK;IAC5B,iBAAiB;AACb,aAAO;IACX;IACA,iBAAiB;AACb,aAAO;IACX;IACA,IAAI,QAAQ,GAAG,UAAU;AACrB,aAAO,YAAa,WAAsB;AACtC,cAAM,aAAa,EAAE,SAAS;AAC9B,cAAM,mBAAmB,QAAQ,IAAI,QAAQ,YAAY,QAAQ;AACjE,cAAM,aAAa,mBACb,iBAAiB,GAAG,SAAS,IAC7B,EAAE,YAAY,QAAQ,UAAU;AACtC,eAAO,wBAAwB,WAAW,UAAU;MACxD;IACJ;EACJ,CAAC;AACL;AAEO,SAAS,cAA2B,WAAqD;AAC5F,SAAO,UAAU,SAAS;AAC9B;ACjDO,IAAM,kBAAN,cAA8B,MAAM;EAEvC,YAAY,SAAiC;AACzC,UAAM,eAAe,QAAQ,gBAAgB,QAAQ,SAAS;AAC9D,UAAM,kBAAkB,MAAM,KAAK,WAAW;AAC9C,SAAK,aAAa,QAAQ;EAC9B;EACA,IAAI,OAAO;AACP,WAAO;EACX;AACJ;AC2BA,IAAM,qBAA8C;EAChD,QAAQ;EACR,kBAAkB;EAClB,gBAAgB;AACpB;AAEA,IAAM,oBAA6C;EAC/C,kBAAkB;EAClB,mBAAmB;EACnB,kCAAkC;EAClC,iCAAiC;EACjC,YAAY;EACZ,kBAAkB;EAClB,QAAQ;EACR,MAAM;EACN,KAAK;EACL,QAAQ;EACR,MAAM;EACN,cAAc;EACd,QAAQ;EACR,sBAAsB;;;;EAItB,SAAS;EACT,IAAI;EACJ,SAAS;EACT,qBAAqB;EACrB,SAAS;EACT,KAAK;AACT;AAEO,SAAS,kCACZ,SAC4C;AAC5C,QAAM,aAAa,OAAO,KAAK,OAAO,EAAE,OAAO,CAAA,eAAc;AACzD,UAAM,sBAAsB,WAAW,YAAY;AACnD,WACI,mBAAmB,WAAW,YAAY,CAAC,MAAM,QACjD,kBAAkB,WAAW,YAAY,CAAC,MAAM,QAChD,oBAAoB,WAAW,QAAQ,KACvC,oBAAoB,WAAW,MAAM;EAE7C,CAAC;AACD,MAAI,WAAW,SAAS,GAAG;AACvB,UAAM,IAAI;MACN,GAAG,WAAW,SAAS,IAAI,sBAAsB,iCACxC,WAAW,KAAK,MAAM;IAEnC;EACJ;AACJ;AAMO,SAAS,iBACZ,SACiD;AACjD,QAAM,MAA8B,CAAC;AACrC,aAAW,cAAc,SAAS;AAC9B,QAAI,WAAW,YAAY,CAAC,IAAI,QAAQ,UAAU;EACtD;AACA,SAAO;AACX;AC3GA,IAAOC,IAAQ,WAAW;ACkBnB,SAAS,oBAAoB,EAAE,mBAAmB,SAAS,IAAI,GAA0B;AAC5F,MAAID,YAAW,SAAS;AACpB,sCAAkC,OAAO;EAC7C;AACA,QAAM,QAAQ;AACd,MAAIA,YAAW,qBAAqB,MAAM;AACtC,YAAQ;MACJ;IAEJ;EACJ;AACA,QAAM,gBAAgB,WAAW,iBAAiB,OAAO;AACzD,SAAO,eAAe,gBAA2B;IAC7C;IACA;EACJ,GAAqD;AACjD,UAAM,OAAO,KAAK,UAAU,OAAO;AACnC,UAAM,cAAc;MAChB;MACA;MACA,SAAS;QACL,GAAG;;QAEH,QAAQ;QACR,kBAAkB,KAAK,OAAO,SAAS;QACvC,gBAAgB;MACpB;MACA,QAAQ;MACR;IACJ;AACA,UAAM,WAAW,MAAM,EAAU,KAAK,WAAW;AACjD,QAAI,CAAC,SAAS,IAAI;AACd,YAAM,IAAI,gBAAgB;QACtB,SAAS,SAAS;QAClB,YAAY,SAAS;MACzB,CAAC;IACL;AACA,WAAQ,MAAM,SAAS,KAAK;EAChC;AACJ;;;AfnDO,SAAS,gBAAgB,QAAiF;AAC7G,SAAO,cAAgC;AAAA,IACnC,GAAG;AAAA,IACH,KAAK,mBAAmB,kBAAkB;AAAA,EAC9C,CAAC;AACL;;;AgBXA;AAMA,SAASE,kBACL,SACiD;AACjD,QAAM,MAA8B,CAAC;AACrC,aAAW,cAAc,SAAS;AAC9B,QAAI,WAAW,YAAY,CAAC,IAAI,QAAQ,UAAU;AAAA,EACtD;AACA,SAAO;AACX;AAEO,SAAS,0BAA0B,QAAkE;AACxG,SAAO,oBAAoB;AAAA,IACvB,GAAG;AAAA,IACH,SAAS;AAAA,MACL,GAAI,OAAO,UAAUA,kBAAiB,OAAO,OAAO,IAAI;AAAA,MACxD,GAAI;AAAA;AAAA,QAEA,iBAAiB,MAAM,yBAAiB;AAAA,MAC5C;AAAA,IACJ;AAAA,EACJ,CAAC;AACL","sourcesContent":["// Clever obfuscation to prevent the build system from inlining the value of `NODE_ENV`\nexport const __DEV__ = /* @__PURE__ */ (() => (process as any)['en' + 'v'].NODE_ENV === 'development')();\n","'use strict'\n// base-x encoding / decoding\n// Copyright (c) 2018 base-x contributors\n// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)\n// Distributed under the MIT software license, see the accompanying\n// file LICENSE or http://www.opensource.org/licenses/mit-license.php.\nfunction base (ALPHABET) {\n  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }\n  var BASE_MAP = new Uint8Array(256)\n  for (var j = 0; j < BASE_MAP.length; j++) {\n    BASE_MAP[j] = 255\n  }\n  for (var i = 0; i < ALPHABET.length; i++) {\n    var x = ALPHABET.charAt(i)\n    var xc = x.charCodeAt(0)\n    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }\n    BASE_MAP[xc] = i\n  }\n  var BASE = ALPHABET.length\n  var LEADER = ALPHABET.charAt(0)\n  var FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up\n  var iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up\n  function encode (source) {\n    if (source instanceof Uint8Array) {\n    } else if (ArrayBuffer.isView(source)) {\n      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength)\n    } else if (Array.isArray(source)) {\n      source = Uint8Array.from(source)\n    }\n    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }\n    if (source.length === 0) { return '' }\n        // Skip & count leading zeroes.\n    var zeroes = 0\n    var length = 0\n    var pbegin = 0\n    var pend = source.length\n    while (pbegin !== pend && source[pbegin] === 0) {\n      pbegin++\n      zeroes++\n    }\n        // Allocate enough space in big-endian base58 representation.\n    var size = ((pend - pbegin) * iFACTOR + 1) >>> 0\n    var b58 = new Uint8Array(size)\n        // Process the bytes.\n    while (pbegin !== pend) {\n      var carry = source[pbegin]\n            // Apply \"b58 = b58 * 256 + ch\".\n      var i = 0\n      for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {\n        carry += (256 * b58[it1]) >>> 0\n        b58[it1] = (carry % BASE) >>> 0\n        carry = (carry / BASE) >>> 0\n      }\n      if (carry !== 0) { throw new Error('Non-zero carry') }\n      length = i\n      pbegin++\n    }\n        // Skip leading zeroes in base58 result.\n    var it2 = size - length\n    while (it2 !== size && b58[it2] === 0) {\n      it2++\n    }\n        // Translate the result into a string.\n    var str = LEADER.repeat(zeroes)\n    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]) }\n    return str\n  }\n  function decodeUnsafe (source) {\n    if (typeof source !== 'string') { throw new TypeError('Expected String') }\n    if (source.length === 0) { return new Uint8Array() }\n    var psz = 0\n        // Skip and count leading '1's.\n    var zeroes = 0\n    var length = 0\n    while (source[psz] === LEADER) {\n      zeroes++\n      psz++\n    }\n        // Allocate enough space in big-endian base256 representation.\n    var size = (((source.length - psz) * FACTOR) + 1) >>> 0 // log(58) / log(256), rounded up.\n    var b256 = new Uint8Array(size)\n        // Process the characters.\n    while (source[psz]) {\n            // Decode character\n      var carry = BASE_MAP[source.charCodeAt(psz)]\n            // Invalid character\n      if (carry === 255) { return }\n      var i = 0\n      for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {\n        carry += (BASE * b256[it3]) >>> 0\n        b256[it3] = (carry % 256) >>> 0\n        carry = (carry / 256) >>> 0\n      }\n      if (carry !== 0) { throw new Error('Non-zero carry') }\n      length = i\n      psz++\n    }\n        // Skip leading zeroes in b256.\n    var it4 = size - length\n    while (it4 !== size && b256[it4] === 0) {\n      it4++\n    }\n    var vch = new Uint8Array(zeroes + (size - it4))\n    var j = zeroes\n    while (it4 !== size) {\n      vch[j++] = b256[it4++]\n    }\n    return vch\n  }\n  function decode (string) {\n    var buffer = decodeUnsafe(string)\n    if (buffer) { return buffer }\n    throw new Error('Non-base' + BASE + ' character')\n  }\n  return {\n    encode: encode,\n    decodeUnsafe: decodeUnsafe,\n    decode: decode\n  }\n}\nmodule.exports = base\n","const basex = require('base-x')\nconst ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n\nmodule.exports = basex(ALPHABET)\n","export * from '@solana/keys';\nexport * from './rpc';\nexport * from './rpc-transport';\n","import bs58 from 'bs58';\n\nexport type Base58EncodedAddress = string & { readonly __base58EncodedAddress: unique symbol };\n\nexport function assertIsBase58EncodedAddress(\n    putativeBase58EncodedAddress: string\n): asserts putativeBase58EncodedAddress is Base58EncodedAddress {\n    try {\n        // Fast-path; see if the input string is of an acceptable length.\n        if (\n            // Lowest address (32 bytes of zeroes)\n            putativeBase58EncodedAddress.length < 32 ||\n            // Highest address (32 bytes of 255)\n            putativeBase58EncodedAddress.length > 44\n        ) {\n            throw new Error('Expected input string to decode to a byte array of length 32.');\n        }\n        // Slow-path; actually attempt to decode the input string.\n        const bytes = bs58.decode(putativeBase58EncodedAddress);\n        const numBytes = bytes.byteLength;\n        if (numBytes !== 32) {\n            throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);\n        }\n    } catch (e) {\n        throw new Error(`\\`${putativeBase58EncodedAddress}\\` is not a base-58 encoded address`, {\n            cause: e,\n        });\n    }\n}\n","import { SolanaRpcMethods, createSolanaRpcApi } from '@solana/rpc-core';\nimport { DEFAULT_RPC_CONFIG } from './rpc-default-config';\n\nimport { createJsonRpc } from '@solana/rpc-transport';\nimport type { Rpc } from '@solana/rpc-transport/dist/types/json-rpc-types';\n\nexport function createSolanaRpc(config: Omit<Parameters<typeof createJsonRpc>[0], 'api'>): Rpc<SolanaRpcMethods> {\n    return createJsonRpc<SolanaRpcMethods>({\n        ...config,\n        api: createSolanaRpcApi(DEFAULT_RPC_CONFIG),\n    });\n}\n","type IntegerOverflowHandler = (keyPath: (number | string)[], value: bigint) => void;\ntype Patched<T> = T extends object ? { [Property in keyof T]: Patched<T[Property]> } : T extends bigint ? number : T;\n// FIXME(https://github.com/microsoft/TypeScript/issues/33014)\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype TypescriptBug33014 = any;\n\nfunction visitNode<T>(value: T, keyPath: (number | string)[], onIntegerOverflow?: IntegerOverflowHandler): Patched<T> {\n    if (Array.isArray(value)) {\n        return value.map((element, ii) =>\n            visitNode(element, [...keyPath, ii], onIntegerOverflow)\n        ) as TypescriptBug33014;\n    } else if (typeof value === 'object' && value !== null) {\n        const out = {} as TypescriptBug33014;\n        for (const propName in value) {\n            if (Object.prototype.hasOwnProperty.call(value, propName)) {\n                out[propName] = visitNode(value[propName], [...keyPath, propName], onIntegerOverflow);\n            }\n        }\n        return out as TypescriptBug33014;\n    } else if (typeof value === 'bigint') {\n        // FIXME(solana-labs/solana/issues/30341) Create a data type to represent u64 in the Solana\n        // JSON RPC implementation so that we can throw away this entire patcher instead of unsafely\n        // downcasting `bigints` to `numbers`.\n        if (onIntegerOverflow && (value > Number.MAX_SAFE_INTEGER || value < -Number.MAX_SAFE_INTEGER)) {\n            onIntegerOverflow(keyPath, value);\n        }\n        return Number(value) as TypescriptBug33014;\n    } else {\n        return value as TypescriptBug33014;\n    }\n}\n\nexport function patchParamsForSolanaLabsRpc<T>(params: T, onIntegerOverflow?: IntegerOverflowHandler): Patched<T> {\n    return visitNode(params, [], onIntegerOverflow);\n}\n","export type KeyPathWildcard = { readonly __keyPathWildcard: unique symbol };\n\nexport const KEYPATH_WILDCARD = {} as KeyPathWildcard;\n","import { createSolanaRpcApi } from './index';\nimport { KeyPath } from './response-patcher';\nimport { KEYPATH_WILDCARD } from './response-patcher-types';\n\n/**\n * These are keypaths at the end of which you will find a numeric value that should *not* be upcast\n * to a `bigint`. These are values that are legitimately defined as `u8` or `usize` on the backend.\n */\nexport const ALLOWED_NUMERIC_KEYPATHS: Partial<\n    Record<keyof ReturnType<typeof createSolanaRpcApi>, readonly KeyPath[]>\n> = {\n    getInflationReward: [[KEYPATH_WILDCARD, 'commission']],\n};\n","import { createSolanaRpcApi } from './index';\nimport { ALLOWED_NUMERIC_KEYPATHS } from './response-patcher-allowed-numeric-values';\nimport { KEYPATH_WILDCARD, KeyPathWildcard } from './response-patcher-types';\n\nexport type KeyPath = ReadonlyArray<KeyPathWildcard | number | string | KeyPath>;\n// FIXME(https://github.com/microsoft/TypeScript/issues/33014)\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype TypescriptBug33014 = any;\n\nfunction getNextAllowedKeypaths(keyPaths: readonly KeyPath[], property: number | string) {\n    return keyPaths\n        .filter(keyPath => (keyPath[0] === KEYPATH_WILDCARD && typeof property === 'number') || keyPath[0] === property)\n        .map(keyPath => keyPath.slice(1));\n}\n\nfunction visitNode<T>(value: unknown, allowedKeypaths: readonly KeyPath[]): T {\n    if (Array.isArray(value)) {\n        return value.map((element, ii) => {\n            const nextAllowedKeypaths = getNextAllowedKeypaths(allowedKeypaths, ii);\n            return visitNode(element, nextAllowedKeypaths);\n        }) as TypescriptBug33014;\n    } else if (typeof value === 'object' && value !== null) {\n        const out = {} as TypescriptBug33014;\n        for (const [propName, innerValue] of Object.entries(value)) {\n            const nextAllowedKeypaths = getNextAllowedKeypaths(allowedKeypaths, propName);\n            out[propName] = visitNode(innerValue, nextAllowedKeypaths);\n        }\n        return out as TypescriptBug33014;\n    } else if (\n        typeof value === 'number' &&\n        // The presence of an allowed keypath on the route to this value implies it's allowlisted;\n        // Upcast the value to `bigint` unless an allowed keypath is present.\n        allowedKeypaths.length === 0\n    ) {\n        // FIXME(solana-labs/solana/issues/30341) Create a data type to represent u64 in the Solana\n        // JSON RPC implementation so that we can throw away this entire patcher instead of unsafely\n        // upcasting `numbers` to `bigints`.\n        return BigInt(value) as TypescriptBug33014;\n    } else {\n        return value as TypescriptBug33014;\n    }\n}\n\nexport function patchResponseForSolanaLabsRpc<T>(\n    rawResponse: unknown,\n    methodName?: keyof ReturnType<typeof createSolanaRpcApi>\n): T {\n    const allowedKeypaths = methodName ? ALLOWED_NUMERIC_KEYPATHS[methodName] : undefined;\n    return visitNode(rawResponse, allowedKeypaths ?? []);\n}\n","import { IRpcApi, RpcRequest } from '@solana/rpc-transport/dist/types/json-rpc-types';\nimport { patchParamsForSolanaLabsRpc } from './params-patcher';\nimport { patchResponseForSolanaLabsRpc } from './response-patcher';\nimport { GetAccountInfoApi } from './rpc-methods/getAccountInfo';\nimport { GetBlockHeightApi } from './rpc-methods/getBlockHeight';\nimport { GetBlocksApi } from './rpc-methods/getBlocks';\nimport { GetInflationRewardApi } from './rpc-methods/getInflationReward';\nimport { GetBalanceApi } from './rpc-methods/getBalance';\n\ntype Config = Readonly<{\n    onIntegerOverflow?: (methodName: string, keyPath: (number | string)[], value: bigint) => void;\n}>;\n\nexport type SolanaRpcMethods = GetAccountInfoApi &\n    GetBalanceApi &\n    GetBlockHeightApi &\n    GetBlocksApi &\n    GetInflationRewardApi;\n\nexport function createSolanaRpcApi(config?: Config): IRpcApi<SolanaRpcMethods> {\n    return new Proxy({} as IRpcApi<SolanaRpcMethods>, {\n        defineProperty() {\n            return false;\n        },\n        deleteProperty() {\n            return false;\n        },\n        get<TMethodName extends keyof IRpcApi<SolanaRpcMethods>>(\n            ...args: Parameters<NonNullable<ProxyHandler<IRpcApi<SolanaRpcMethods>>['get']>>\n        ) {\n            const [_, p] = args;\n            const methodName = p.toString() as keyof SolanaRpcMethods;\n            return function (\n                ...rawParams: Parameters<\n                    SolanaRpcMethods[TMethodName] extends CallableFunction ? SolanaRpcMethods[TMethodName] : never\n                >\n            ): RpcRequest<ReturnType<SolanaRpcMethods[TMethodName]>> {\n                const handleIntegerOverflow = config?.onIntegerOverflow;\n                const params = patchParamsForSolanaLabsRpc(\n                    rawParams,\n                    handleIntegerOverflow\n                        ? (keyPath, value) => handleIntegerOverflow(methodName, keyPath, value)\n                        : undefined\n                );\n                return {\n                    methodName,\n                    params,\n                    responseProcessor: rawResponse => patchResponseForSolanaLabsRpc(rawResponse, methodName),\n                };\n            };\n        },\n    });\n}\n","import { createSolanaRpcApi } from '@solana/rpc-core';\nimport { SolanaJsonRpcIntegerOverflowError } from './rpc-integer-overflow-error';\n\nexport const DEFAULT_RPC_CONFIG: Partial<Parameters<typeof createSolanaRpcApi>[0]> = {\n    onIntegerOverflow(methodName, keyPath, value) {\n        throw new SolanaJsonRpcIntegerOverflowError(methodName, keyPath, value);\n    },\n};\n","export class SolanaJsonRpcIntegerOverflowError extends Error {\n    readonly methodName: string;\n    readonly keyPath: (number | string)[];\n    readonly value: bigint;\n    constructor(methodName: string, keyPath: (number | string)[], value: bigint) {\n        const argPosition = (typeof keyPath[0] === 'number' ? keyPath[0] : parseInt(keyPath[0], 10)) + 1;\n        let ordinal = '';\n        const lastDigit = argPosition % 10;\n        const lastTwoDigits = argPosition % 100;\n        if (lastDigit == 1 && lastTwoDigits != 11) {\n            ordinal = argPosition + 'st';\n        } else if (lastDigit == 2 && lastTwoDigits != 12) {\n            ordinal = argPosition + 'nd';\n        } else if (lastDigit == 3 && lastTwoDigits != 13) {\n            ordinal = argPosition + 'rd';\n        } else {\n            ordinal = argPosition + 'th';\n        }\n        const path =\n            keyPath.length > 1\n                ? keyPath\n                      .slice(1)\n                      .map(pathPart => (typeof pathPart === 'number' ? `[${pathPart}]` : pathPart))\n                      .join('.')\n                : null;\n        super(\n            `The ${ordinal} argument to the \\`${methodName}\\` RPC method` +\n                `${path ? ` at path \\`${path}\\`` : ''} was \\`${value}\\`. This number is ` +\n                'unsafe for use with the Solana JSON-RPC because it exceeds ' +\n                '`Number.MAX_SAFE_INTEGER`.'\n        );\n        this.keyPath = keyPath;\n        this.methodName = methodName;\n        this.value = value;\n    }\n    get name() {\n        return 'SolanaJsonRpcIntegerOverflowError';\n    }\n}\n","// Keep in sync with https://github.com/solana-labs/solana/blob/master/rpc-client-api/src/custom_error.rs\n// Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/\nexport const SolanaJsonRpcErrorCode = {\n    JSON_RPC_SCAN_ERROR: -32012,\n    JSON_RPC_SERVER_ERROR_BLOCK_CLEANED_UP: -32001,\n    JSON_RPC_SERVER_ERROR_BLOCK_NOT_AVAILABLE: -32004,\n    JSON_RPC_SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET: -32014,\n    JSON_RPC_SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX: -32010,\n    JSON_RPC_SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED: -32009,\n    JSON_RPC_SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED: -32016,\n    JSON_RPC_SERVER_ERROR_NODE_UNHEALTHY: -32005,\n    JSON_RPC_SERVER_ERROR_NO_SNAPSHOT: -32008,\n    JSON_RPC_SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE: -32002,\n    JSON_RPC_SERVER_ERROR_SLOT_SKIPPED: -32007,\n    JSON_RPC_SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE: -32011,\n    JSON_RPC_SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE: -32006,\n    JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH: -32013,\n    JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE: -32003,\n    JSON_RPC_SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION: -32015,\n} as const;\ntype SolanaJsonRpcErrorCodeEnum = (typeof SolanaJsonRpcErrorCode)[keyof typeof SolanaJsonRpcErrorCode];\n\ntype SolanaJsonRpcErrorDetails = Readonly<{\n    code: number;\n    data?: unknown;\n    message: string;\n}>;\n\nexport class SolanaJsonRpcError extends Error {\n    readonly code: SolanaJsonRpcErrorCodeEnum;\n    readonly data: unknown;\n    constructor(details: SolanaJsonRpcErrorDetails) {\n        super(`JSON-RPC 2.0 error (${details.code}): ${details.message}`);\n        Error.captureStackTrace(this, this.constructor);\n        this.code = details.code as SolanaJsonRpcErrorCodeEnum;\n        this.data = details.data;\n    }\n    get name() {\n        return 'SolanaJsonRpcError';\n    }\n}\n","let _nextMessageId = 0;\nexport function getNextMessageId() {\n    const id = _nextMessageId;\n    _nextMessageId = (_nextMessageId + 1) % Number.MAX_SAFE_INTEGER;\n    return id;\n}\n","import { getNextMessageId } from './json-rpc-message-id';\n\nexport function createJsonRpcMessage<TParams>(method: string, params: TParams) {\n    return {\n        id: getNextMessageId(),\n        jsonrpc: '2.0',\n        method,\n        params,\n    };\n}\n","import { SolanaJsonRpcError } from './json-rpc-errors';\nimport { createJsonRpcMessage } from './json-rpc-message';\nimport { PendingRpcRequest, SendOptions, Rpc, RpcConfig, RpcRequest } from './json-rpc-types';\n\ninterface IHasIdentifier {\n    readonly id: number;\n}\ntype JsonRpcResponse<TResponse> = IHasIdentifier &\n    Readonly<{ result: TResponse } | { error: { code: number; message: string; data?: unknown } }>;\n\nfunction createPendingRpcRequest<TRpcMethods, TResponse>(\n    rpcConfig: RpcConfig<TRpcMethods>,\n    pendingRequest: RpcRequest<TResponse>\n): PendingRpcRequest<TResponse> {\n    return {\n        async send(options?: SendOptions): Promise<TResponse> {\n            const { methodName, params, responseProcessor } = pendingRequest;\n            const payload = createJsonRpcMessage(methodName, params);\n            const response = await rpcConfig.transport<JsonRpcResponse<unknown>>({\n                payload,\n                signal: options?.abortSignal,\n            });\n            if ('error' in response) {\n                throw new SolanaJsonRpcError(response.error);\n            } else {\n                return (responseProcessor ? responseProcessor(response.result) : response.result) as TResponse;\n            }\n        },\n    };\n}\n\nfunction makeProxy<TRpcMethods>(rpcConfig: RpcConfig<TRpcMethods>): Rpc<TRpcMethods> {\n    return new Proxy(rpcConfig.api, {\n        defineProperty() {\n            return false;\n        },\n        deleteProperty() {\n            return false;\n        },\n        get(target, p, receiver) {\n            return function (...rawParams: unknown[]) {\n                const methodName = p.toString();\n                const createRpcRequest = Reflect.get(target, methodName, receiver);\n                const newRequest = createRpcRequest\n                    ? createRpcRequest(...rawParams)\n                    : { methodName, params: rawParams };\n                return createPendingRpcRequest(rpcConfig, newRequest);\n            };\n        },\n    }) as Rpc<TRpcMethods>;\n}\n\nexport function createJsonRpc<TRpcMethods>(rpcConfig: RpcConfig<TRpcMethods>): Rpc<TRpcMethods> {\n    return makeProxy(rpcConfig);\n}\n","type SolanaHttpErrorDetails = Readonly<{\n    statusCode: number;\n    message: string;\n}>;\n\nexport class SolanaHttpError extends Error {\n    readonly statusCode: number;\n    constructor(details: SolanaHttpErrorDetails) {\n        super(`HTTP error (${details.statusCode}): ${details.message}`);\n        Error.captureStackTrace(this, this.constructor);\n        this.statusCode = details.statusCode;\n    }\n    get name() {\n        return 'SolanaHttpError';\n    }\n}\n","export type AllowedHttpRequestHeaders = Readonly<\n    { [headerName: string]: string } & {\n        // Someone can still sneak a forbidden header past Typescript if they do something like\n        // fOo-BaR, but at that point they deserve the runtime failure.\n        [K in DisallowedHeaders | ForbiddenHeaders as\n            | K // `Foo-Bar`\n            | Capitalize<Lowercase<K>> // `Foo-bar`\n            | Lowercase<K> // `foo-bar`\n            | Uncapitalize<K> // `foo-Bar`\n            // `FOO-BAR`\n            | Uppercase<K>]?: never;\n    }\n>;\n// These are headers that we simply don't allow the developer to override because they're\n// fundamental to the operation of the JSON-RPC transport.\ntype DisallowedHeaders = 'Accept' | 'Content-Length' | 'Content-Type' | 'Solana-Client';\ntype ForbiddenHeaders =\n    | 'Accept-Charset'\n    | 'Accept-Encoding'\n    | 'Access-Control-Request-Headers'\n    | 'Access-Control-Request-Method'\n    | 'Connection'\n    | 'Content-Length'\n    | 'Cookie'\n    | 'Date'\n    | 'DNT'\n    | 'Expect'\n    | 'Host'\n    | 'Keep-Alive'\n    | 'Origin'\n    | 'Permissions-Policy'\n    // No currently available Typescript technique allows you to match on a prefix.\n    // | 'Proxy-'\n    // | 'Sec-'\n    | 'Referer'\n    | 'TE'\n    | 'Trailer'\n    | 'Transfer-Encoding'\n    | 'Upgrade'\n    | 'Via';\n\n// These are headers which are fundamental to the JSON-RPC transport, and must not be modified.\nconst DISALLOWED_HEADERS: Record<string, boolean> = {\n    accept: true,\n    'content-length': true,\n    'content-type': true,\n};\n// https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name\nconst FORBIDDEN_HEADERS: Record<string, boolean> = {\n    'accept-charset': true,\n    'accept-encoding': true,\n    'access-control-request-headers': true,\n    'access-control-request-method': true,\n    connection: true,\n    'content-length': true,\n    cookie: true,\n    date: true,\n    dnt: true,\n    expect: true,\n    host: true,\n    'keep-alive': true,\n    origin: true,\n    'permissions-policy': true,\n    // No currently available Typescript technique allows you to match on a prefix.\n    // 'proxy-':true,\n    // 'sec-':true,\n    referer: true,\n    te: true,\n    trailer: true,\n    'transfer-encoding': true,\n    upgrade: true,\n    via: true,\n};\n\nexport function assertIsAllowedHttpRequestHeaders(\n    headers: Record<string, string>\n): asserts headers is AllowedHttpRequestHeaders {\n    const badHeaders = Object.keys(headers).filter(headerName => {\n        const lowercaseHeaderName = headerName.toLowerCase();\n        return (\n            DISALLOWED_HEADERS[headerName.toLowerCase()] === true ||\n            FORBIDDEN_HEADERS[headerName.toLowerCase()] === true ||\n            lowercaseHeaderName.startsWith('proxy-') ||\n            lowercaseHeaderName.startsWith('sec-')\n        );\n    });\n    if (badHeaders.length > 0) {\n        throw new Error(\n            `${badHeaders.length > 1 ? 'These headers are' : 'This header is'} forbidden: ` +\n                `\\`${badHeaders.join('`, `')}\\`. Learn more at ` +\n                'https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name.'\n        );\n    }\n}\n\n/**\n * Lowercasing header names makes it easier to override user-supplied headers, such as those defined\n * in the `DisallowedHeaders` type.\n */\nexport function normalizeHeaders<T extends Record<string, string>>(\n    headers: T\n): { [K in keyof T & string as Lowercase<K>]: T[K] } {\n    const out: Record<string, string> = {};\n    for (const headerName in headers) {\n        out[headerName.toLowerCase()] = headers[headerName];\n    }\n    return out as { [K in keyof T & string as Lowercase<K>]: T[K] };\n}\n","export default globalThis.fetch;\n","import { SolanaHttpError } from './http-transport-errors';\nimport {\n    AllowedHttpRequestHeaders,\n    assertIsAllowedHttpRequestHeaders,\n    normalizeHeaders,\n} from './http-transport-headers';\nimport { IRpcTransport } from '../transport-types';\n\nimport fetchImpl from 'fetch-impl';\nimport type { Agent as NodeHttpAgent } from 'node:http';\nimport type { Agent as NodeHttpsAgent } from 'node:https';\n\ntype Config = Readonly<{\n    headers?: AllowedHttpRequestHeaders;\n    httpAgentNodeOnly?: NodeHttpAgent | NodeHttpsAgent | ((parsedUrl: URL) => NodeHttpAgent | NodeHttpsAgent);\n    url: string;\n}>;\n\nexport function createHttpTransport({ httpAgentNodeOnly, headers, url }: Config): IRpcTransport {\n    if (__DEV__ && headers) {\n        assertIsAllowedHttpRequestHeaders(headers);\n    }\n    const agent = __NODEJS__ ? httpAgentNodeOnly : undefined;\n    if (__DEV__ && httpAgentNodeOnly != null) {\n        console.warn(\n            'createHttpTransport(): The `httpAgentNodeOnly` config you supplied has been ' +\n                'ignored; HTTP agents are only usable in Node environments.'\n        );\n    }\n    const customHeaders = headers && normalizeHeaders(headers);\n    return async function makeHttpRequest<TResponse>({\n        payload,\n        signal,\n    }: Parameters<IRpcTransport>[0]): Promise<TResponse> {\n        const body = JSON.stringify(payload);\n        const requestInfo = {\n            agent,\n            body,\n            headers: {\n                ...customHeaders,\n                // Keep these headers lowercase so they will override any user-supplied headers above.\n                accept: 'application/json',\n                'content-length': body.length.toString(),\n                'content-type': 'application/json; charset=utf-8',\n            },\n            method: 'POST',\n            signal,\n        };\n        const response = await fetchImpl(url, requestInfo);\n        if (!response.ok) {\n            throw new SolanaHttpError({\n                message: response.statusText,\n                statusCode: response.status,\n            });\n        }\n        return (await response.json()) as TResponse;\n    };\n}\n","import { createHttpTransport } from '@solana/rpc-transport';\nimport { IRpcTransport } from '@solana/rpc-transport/dist/types/transports/transport-types';\n\n/**\n * Lowercasing header names makes it easier to override user-supplied headers.\n */\nfunction normalizeHeaders<T extends Record<string, string>>(\n    headers: T\n): { [K in keyof T & string as Lowercase<K>]: T[K] } {\n    const out: Record<string, string> = {};\n    for (const headerName in headers) {\n        out[headerName.toLowerCase()] = headers[headerName];\n    }\n    return out as { [K in keyof T & string as Lowercase<K>]: T[K] };\n}\n\nexport function createDefaultRpcTransport(config: Parameters<typeof createHttpTransport>[0]): IRpcTransport {\n    return createHttpTransport({\n        ...config,\n        headers: {\n            ...(config.headers ? normalizeHeaders(config.headers) : undefined),\n            ...({\n                // Keep these headers lowercase so they will override any user-supplied headers above.\n                'solana-client': `js/${__VERSION__}` ?? 'UNKNOWN',\n            } as { [overrideHeader: string]: string }),\n        },\n    });\n}\n"]}