viem 0.0.1-alpha.9 → 0.0.1-cjs.10

package/dist/chunk-7H5SPKXN.js

@@ -1,1113 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-
-// package.json
-var package_default = {
-  name: "viem",
-  description: "TypeScript (& JavaScript) Interface for Ethereum",
-  version: "0.0.1-alpha.9",
-  scripts: {
-    anvil: "source .env && anvil --fork-url $ANVIL_FORK_URL --fork-block-number $VITE_ANVIL_BLOCK_NUMBER --block-time $VITE_ANVIL_BLOCK_TIME",
-    bench: "vitest bench --no-threads",
-    "bench:ci": "CI=true vitest bench --no-threads",
-    build: "tsup",
-    changeset: "changeset",
-    "changeset:release": "pnpm build && changeset publish",
-    "changeset:version": "changeset version && pnpm install --lockfile-only",
-    dev: "DEV=true tsup",
-    "dev:docs": "pnpm -r --filter site dev",
-    format: "rome format src/ test/ --write",
-    lint: "rome check .",
-    "lint:fix": "pnpm lint --apply-suggested",
-    playground: "pnpm --filter playground-dev dev",
-    "playground:benchmark": "pnpm --filter playground-benchmark dev",
-    postinstall: "pnpm dev",
-    preinstall: "npx only-allow pnpm",
-    prepare: "npx simple-git-hooks",
-    test: "vitest dev --coverage --no-threads",
-    "test:ci": "CI=true vitest --coverage --no-threads",
-    "test:ui": "vitest dev --ui --no-threads",
-    typecheck: "tsc --noEmit"
-  },
-  files: [
-    "/actions",
-    "/chains",
-    "/dist",
-    "/clients",
-    "/types",
-    "/utils",
-    "/window"
-  ],
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      default: "./dist/index.js"
-    },
-    "./actions": {
-      types: "./dist/actions/index.d.ts",
-      default: "./dist/actions/index.js"
-    },
-    "./chains": {
-      types: "./dist/chains.d.ts",
-      default: "./dist/chains.js"
-    },
-    "./clients": {
-      types: "./dist/clients/index.d.ts",
-      default: "./dist/clients/index.js"
-    },
-    "./utils": {
-      types: "./dist/utils/index.d.ts",
-      default: "./dist/utils/index.js"
-    },
-    "./window": {
-      types: "./dist/window.d.ts",
-      default: "./dist/window.js"
-    },
-    "./package.json": "./package.json"
-  },
-  type: "module",
-  main: "dist/index.js",
-  types: "dist/index.d.ts",
-  sideEffects: false,
-  dependencies: {
-    "@noble/hashes": "^1.1.2",
-    "@wagmi/chains": "^0.1.0",
-    abitype: "^0.2.5"
-  },
-  devDependencies: {
-    "@actions/core": "^1.10.0",
-    "@actions/github": "^5.1.1",
-    "@changesets/changelog-github": "^0.4.5",
-    "@changesets/cli": "^2.23.2",
-    "@testing-library/jest-dom": "^5.16.5",
-    "@types/dedent": "^0.7.0",
-    "@types/fs-extra": "^9.0.13",
-    "@types/node": "^17.0.45",
-    "@vitest/coverage-c8": "^0.24.3",
-    "@vitest/ui": "^0.19.1",
-    bundlewatch: "^0.3.3",
-    dedent: "^0.7.0",
-    esbuild: "^0.16.12",
-    "esbuild-register": "^3.4.2",
-    "essential-eth": "^0.6.2",
-    ethers: "^5.7.2",
-    execa: "^6.1.0",
-    "fs-extra": "^10.1.0",
-    jsdom: "^20.0.0",
-    rome: "^11.0.0",
-    "simple-git-hooks": "^2.8.1",
-    tsup: "^6.5.0",
-    typescript: "^4.9.3",
-    vite: "^3.0.4",
-    vitest: "^0.25.2",
-    web3: "^1.8.1"
-  },
-  license: "MIT",
-  repository: "wagmi-dev/viem",
-  authors: [
-    "awkweb.eth",
-    "jxom.eth"
-  ],
-  keywords: [
-    "eth",
-    "ethereum",
-    "dapps",
-    "wallet",
-    "web3"
-  ],
-  "simple-git-hooks": {
-    "pre-commit": "pnpm format & pnpm lint:fix"
-  },
-  pnpm: {
-    patchedDependencies: {
-      "vitepress@1.0.0-alpha.34": "patches/vitepress@1.0.0-alpha.34.patch"
-    }
-  }
-};
-
-// src/errors/base.ts
-var version = process.env.TEST ? "1.0.2" : package_default.version;
-var BaseError = class extends Error {
-  constructor(humanMessage, args = {}) {
-    const details = args.cause instanceof BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
-    const docsPath = args.cause instanceof BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
-    const message = [
-      humanMessage,
-      ...docsPath ? ["", `Docs: https://viem.sh${docsPath}`] : [],
-      "",
-      ...details ? [`Details: ${details}`] : [],
-      `Version: viem@${version}`,
-      ...args.cause && !(args.cause instanceof BaseError) && Object.keys(args.cause).length > 0 ? [`Internal Error: ${JSON.stringify(args.cause)}`] : []
-    ].join("\n");
-    super(message);
-    __publicField(this, "humanMessage");
-    __publicField(this, "details");
-    __publicField(this, "docsPath");
-    __publicField(this, "name", "ViemError");
-    if (args.cause)
-      this.cause = args.cause;
-    this.details = details;
-    this.docsPath = docsPath;
-    this.humanMessage = humanMessage;
-  }
-};
-
-// src/errors/abi.ts
-var AbiConstructorNotFoundError = class extends BaseError {
-  constructor({ docsPath }) {
-    super(
-      [
-        "A constructor was not found on the ABI.",
-        "Make sure you are using the correct ABI and that the constructor exists on it."
-      ].join("\n"),
-      {
-        docsPath
-      }
-    );
-    __publicField(this, "name", "AbiConstructorNotFoundError");
-  }
-};
-var AbiConstructorParamsNotFoundError = class extends BaseError {
-  constructor({ docsPath }) {
-    super(
-      [
-        "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
-        "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
-      ].join("\n"),
-      {
-        docsPath
-      }
-    );
-    __publicField(this, "name", "AbiConstructorParamsNotFoundError");
-  }
-};
-var AbiDecodingDataSizeInvalidError = class extends BaseError {
-  constructor(size) {
-    super(
-      [
-        `Data size of ${size} bytes is invalid.`,
-        "Size must be in increments of 32 bytes (size % 32 === 0)."
-      ].join("\n")
-    );
-    __publicField(this, "name", "AbiDecodingDataSizeInvalidError");
-  }
-};
-var AbiEncodingArrayLengthMismatchError = class extends BaseError {
-  constructor({
-    expectedLength,
-    givenLength,
-    type
-  }) {
-    super(
-      [
-        `ABI encoding array length mismatch for type ${type}.`,
-        `Expected length: ${expectedLength}`,
-        `Given length: ${givenLength}`
-      ].join("\n")
-    );
-    __publicField(this, "name", "AbiEncodingArrayLengthMismatchError");
-  }
-};
-var AbiEncodingLengthMismatchError = class extends BaseError {
-  constructor({
-    expectedLength,
-    givenLength
-  }) {
-    super(
-      [
-        "ABI encoding params/values length mismatch.",
-        `Expected length (params): ${expectedLength}`,
-        `Given length (values): ${givenLength}`
-      ].join("\n")
-    );
-    __publicField(this, "name", "AbiEncodingLengthMismatchError");
-  }
-};
-var AbiErrorInputsNotFoundError = class extends BaseError {
-  constructor(errorName, { docsPath }) {
-    super(
-      [
-        `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
-        "Cannot encode error result without knowing what the parameter types are.",
-        "Make sure you are using the correct ABI and that the inputs exist on it."
-      ].join("\n"),
-      {
-        docsPath
-      }
-    );
-    __publicField(this, "name", "AbiErrorInputsNotFoundError");
-  }
-};
-var AbiErrorNotFoundError = class extends BaseError {
-  constructor(errorName, { docsPath }) {
-    super(
-      [
-        `Error "${errorName}" not found on ABI.`,
-        "Make sure you are using the correct ABI and that the error exists on it."
-      ].join("\n"),
-      {
-        docsPath
-      }
-    );
-    __publicField(this, "name", "AbiErrorNotFoundError");
-  }
-};
-var AbiErrorSignatureNotFoundError = class extends BaseError {
-  constructor(signature, { docsPath }) {
-    super(
-      [
-        `Encoded error signature "${signature}" not found on ABI.`,
-        "Make sure you are using the correct ABI and that the error exists on it.",
-        `You can look up the signature "${signature}" here: https://sig.eth.samczsun.com/.`
-      ].join("\n"),
-      {
-        docsPath
-      }
-    );
-    __publicField(this, "name", "AbiErrorSignatureNotFoundError");
-  }
-};
-var AbiEventNotFoundError = class extends BaseError {
-  constructor(eventName, { docsPath }) {
-    super(
-      [
-        `Event "${eventName}" not found on ABI.`,
-        "Make sure you are using the correct ABI and that the event exists on it."
-      ].join("\n"),
-      {
-        docsPath
-      }
-    );
-    __publicField(this, "name", "AbiEventNotFoundError");
-  }
-};
-var AbiFunctionNotFoundError = class extends BaseError {
-  constructor(functionName, { docsPath }) {
-    super(
-      [
-        `Function "${functionName}" not found on ABI.`,
-        "Make sure you are using the correct ABI and that the function exists on it."
-      ].join("\n"),
-      {
-        docsPath
-      }
-    );
-    __publicField(this, "name", "AbiFunctionNotFoundError");
-  }
-};
-var AbiFunctionOutputsNotFoundError = class extends BaseError {
-  constructor(functionName, { docsPath }) {
-    super(
-      [
-        `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
-        "Cannot decode function result without knowing what the parameter types are.",
-        "Make sure you are using the correct ABI and that the function exists on it."
-      ].join("\n"),
-      {
-        docsPath
-      }
-    );
-    __publicField(this, "name", "AbiFunctionOutputsNotFoundError");
-  }
-};
-var AbiFunctionSignatureNotFoundError = class extends BaseError {
-  constructor(signature, { docsPath }) {
-    super(
-      [
-        `Encoded function signature "${signature}" not found on ABI.`,
-        "Make sure you are using the correct ABI and that the function exists on it.",
-        `You can look up the signature "${signature}" here: https://sig.eth.samczsun.com/.`
-      ].join("\n"),
-      {
-        docsPath
-      }
-    );
-    __publicField(this, "name", "AbiFunctionSignatureNotFoundError");
-  }
-};
-var InvalidAbiEncodingTypeError = class extends BaseError {
-  constructor(type, { docsPath }) {
-    super(
-      [
-        `Type "${type}" is not a valid encoding type.`,
-        "Please provide a valid ABI type."
-      ].join("\n"),
-      { docsPath }
-    );
-    __publicField(this, "name", "InvalidAbiEncodingType");
-  }
-};
-var InvalidAbiDecodingTypeError = class extends BaseError {
-  constructor(type, { docsPath }) {
-    super(
-      [
-        `Type "${type}" is not a valid decoding type.`,
-        "Please provide a valid ABI type."
-      ].join("\n"),
-      { docsPath }
-    );
-    __publicField(this, "name", "InvalidAbiDecodingType");
-  }
-};
-var InvalidArrayError = class extends BaseError {
-  constructor(value) {
-    super([`Value "${value}" is not a valid array.`].join("\n"));
-    __publicField(this, "name", "InvalidArrayError");
-  }
-};
-var InvalidDefinitionTypeError = class extends BaseError {
-  constructor(type, { docsPath }) {
-    super(
-      [
-        `"${type}" is not a valid definition type.`,
-        'Valid types: "function", "event", "error"'
-      ].join("\n"),
-      {
-        docsPath
-      }
-    );
-    __publicField(this, "name", "InvalidDefinitionTypeError");
-  }
-};
-
-// src/errors/address.ts
-var InvalidAddressError = class extends BaseError {
-  constructor({ address }) {
-    super(`Address "${address}" is invalid.`);
-    __publicField(this, "name", "InvalidAddressError");
-  }
-};
-
-// src/errors/block.ts
-var BlockNotFoundError = class extends BaseError {
-  constructor({
-    blockHash,
-    blockNumber
-  }) {
-    let identifier = "Block";
-    if (blockHash)
-      identifier = `Block at hash "${blockHash}"`;
-    if (blockNumber)
-      identifier = `Block at number "${blockNumber}"`;
-    super(`${identifier} could not be found.`);
-    __publicField(this, "name", "BlockNotFoundError");
-  }
-};
-
-// src/errors/data.ts
-var SizeExceedsPaddingSizeError = class extends BaseError {
-  constructor({
-    size,
-    targetSize,
-    type
-  }) {
-    super(
-      `${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size}) exceeds padding size (${targetSize}).`
-    );
-    __publicField(this, "name", "SizeExceedsPaddingSizeError");
-  }
-};
-
-// src/errors/encoding.ts
-var DataLengthTooLongError = class extends BaseError {
-  constructor({ consumed, length }) {
-    super(
-      `Consumed bytes (${consumed}) is shorter than data length (${length - 1}).`
-    );
-    __publicField(this, "name", "DataLengthTooLongError");
-  }
-};
-var DataLengthTooShortError = class extends BaseError {
-  constructor({ length, dataLength }) {
-    super(
-      `Data length (${dataLength - 1}) is shorter than prefix length (${length - 1}).`
-    );
-    __publicField(this, "name", "DataLengthTooShortError");
-  }
-};
-var InvalidBytesBooleanError = class extends BaseError {
-  constructor(bytes) {
-    super(
-      `Bytes value "${bytes}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`
-    );
-    __publicField(this, "name", "InvalidBytesBooleanError");
-  }
-};
-var InvalidHexBooleanError = class extends BaseError {
-  constructor(hex) {
-    super(
-      `Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`
-    );
-    __publicField(this, "name", "InvalidHexBooleanError");
-  }
-};
-var InvalidHexValueError = class extends BaseError {
-  constructor(value) {
-    super(
-      `Hex value "${value}" is an odd length (${value.length}). It must be an even length.`
-    );
-    __publicField(this, "name", "InvalidHexValueError");
-  }
-};
-var OffsetOutOfBoundsError = class extends BaseError {
-  constructor({ nextOffset, offset }) {
-    super(
-      `Next offset (${nextOffset}) is greater than previous offset + consumed bytes (${offset})`
-    );
-    __publicField(this, "name", "OffsetOutOfBoundsError");
-  }
-};
-
-// src/errors/log.ts
-var FilterTypeNotSupportedError = class extends BaseError {
-  constructor(type) {
-    super(`Filter type "${type}" is not supported.`);
-    __publicField(this, "name", "FilterTypeNotSupportedError");
-  }
-};
-
-// src/errors/request.ts
-var RequestError = class extends BaseError {
-  constructor(err, { docsPath, humanMessage }) {
-    super(humanMessage, {
-      cause: err,
-      docsPath
-    });
-    this.name = err.name;
-  }
-};
-var RpcRequestError = class extends RequestError {
-  constructor(err, { docsPath, humanMessage }) {
-    super(err, { docsPath, humanMessage });
-    __publicField(this, "code");
-    this.code = err.code;
-    this.name = err.name;
-  }
-};
-var ParseRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
-    });
-    __publicField(this, "name", "ParseRpcError");
-    __publicField(this, "code", -32700);
-  }
-};
-var InvalidRequestRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "JSON is not a valid request object." });
-    __publicField(this, "name", "InvalidRequestRpcError");
-    __publicField(this, "code", -32600);
-  }
-};
-var MethodNotFoundRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: "The method does not exist / is not available."
-    });
-    __publicField(this, "name", "MethodNotFoundRpcError");
-    __publicField(this, "code", -32601);
-  }
-};
-var InvalidParamsRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: [
-        "Invalid parameters were provided to the RPC method.",
-        "Double check you have provided the correct parameters."
-      ].join("\n")
-    });
-    __publicField(this, "name", "InvalidParamsRpcError");
-    __publicField(this, "code", -32602);
-  }
-};
-var InternalRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "An internal error was received." });
-    __publicField(this, "name", "InternalRpcError");
-    __publicField(this, "code", -32603);
-  }
-};
-var InvalidInputRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: [
-        "Missing or invalid parameters.",
-        "Double check you have provided the correct parameters."
-      ].join("\n")
-    });
-    __publicField(this, "name", "InvalidInputRpcError");
-    __publicField(this, "code", -32e3);
-  }
-};
-var ResourceNotFoundRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "Requested resource not found." });
-    __publicField(this, "name", "ResourceNotFoundRpcError");
-    __publicField(this, "code", -32001);
-  }
-};
-var ResourceUnavailableRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "Requested resource not available." });
-    __publicField(this, "name", "ResourceUnavailableRpcError");
-    __publicField(this, "code", -32002);
-  }
-};
-var TransactionRejectedRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "Transaction creation failed." });
-    __publicField(this, "name", "TransactionRejectedRpcError");
-    __publicField(this, "code", -32003);
-  }
-};
-var MethodNotSupportedRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "Method is not implemented." });
-    __publicField(this, "name", "MethodNotSupportedRpcError");
-    __publicField(this, "code", -32004);
-  }
-};
-var LimitExceededRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "Request exceeds defined limit." });
-    __publicField(this, "name", "LimitExceededRpcError");
-    __publicField(this, "code", -32005);
-  }
-};
-var JsonRpcVersionUnsupportedError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: "Version of JSON-RPC protocol is not supported."
-    });
-    __publicField(this, "name", "JsonRpcVersionUnsupportedError");
-    __publicField(this, "code", -32006);
-  }
-};
-var UnknownRpcError = class extends RequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: "An unknown RPC error occurred."
-    });
-    __publicField(this, "name", "UnknownRpcError");
-  }
-};
-
-// src/errors/rpc.ts
-var HttpRequestError = class extends BaseError {
-  constructor({
-    body,
-    details,
-    status,
-    url
-  }) {
-    super(
-      [
-        "HTTP request failed.",
-        "",
-        `Status: ${status}`,
-        `URL: ${url}`,
-        `Request body: ${JSON.stringify(body)}`
-      ].join("\n"),
-      {
-        details
-      }
-    );
-    __publicField(this, "name", "HttpRequestError");
-    __publicField(this, "status");
-    this.status = status;
-  }
-};
-var WebSocketRequestError = class extends BaseError {
-  constructor({
-    body,
-    details,
-    url
-  }) {
-    super(
-      [
-        "WebSocket request failed.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${JSON.stringify(body)}`
-      ].join("\n"),
-      {
-        details
-      }
-    );
-    __publicField(this, "name", "WebSocketRequestError");
-  }
-};
-var RpcError = class extends BaseError {
-  constructor({
-    body,
-    error,
-    url
-  }) {
-    super(
-      [
-        "RPC Request failed.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${JSON.stringify(body)}`
-      ].join("\n"),
-      {
-        cause: error,
-        details: error.message
-      }
-    );
-    __publicField(this, "code");
-    __publicField(this, "name", "RpcError");
-    this.code = error.code;
-  }
-};
-var TimeoutError = class extends BaseError {
-  constructor({
-    body,
-    url
-  }) {
-    super(
-      [
-        "The request took too long to respond.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${JSON.stringify(body)}`
-      ].join("\n"),
-      {
-        details: "The request timed out."
-      }
-    );
-    __publicField(this, "name", "TimeoutError");
-  }
-};
-
-// src/errors/transaction.ts
-var InvalidGasArgumentsError = class extends BaseError {
-  constructor() {
-    super("`maxFeePerGas` cannot be less than `maxPriorityFeePerGas`");
-    __publicField(this, "name", "InvalidGasArgumentsError");
-  }
-};
-var TransactionNotFoundError = class extends BaseError {
-  constructor({
-    blockHash,
-    blockNumber,
-    blockTag,
-    hash,
-    index
-  }) {
-    let identifier = "Transaction";
-    if (blockTag && index !== void 0)
-      identifier = `Transaction at block time "${blockTag}" at index "${index}"`;
-    if (blockHash && index !== void 0)
-      identifier = `Transaction at block hash "${blockHash}" at index "${index}"`;
-    if (blockNumber && index !== void 0)
-      identifier = `Transaction at block number "${blockNumber}" at index "${index}"`;
-    if (hash)
-      identifier = `Transaction with hash "${hash}"`;
-    super(`${identifier} could not be found.`);
-    __publicField(this, "name", "TransactionNotFoundError");
-  }
-};
-var TransactionReceiptNotFoundError = class extends BaseError {
-  constructor({ hash }) {
-    super(
-      `Transaction receipt with hash "${hash}" could not be found. The Transaction may not be processed on a block yet.`
-    );
-    __publicField(this, "name", "TransactionReceiptNotFoundError");
-  }
-};
-var WaitForTransactionReceiptTimeoutError = class extends BaseError {
-  constructor({ hash }) {
-    super(
-      `Timed out while waiting for transaction with hash "${hash}" to be confirmed.`
-    );
-    __publicField(this, "name", "WaitForTransactionReceiptTimeoutError");
-  }
-};
-
-// src/errors/transport.ts
-var UrlRequiredError = class extends BaseError {
-  constructor() {
-    super(
-      "No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.",
-      {
-        docsPath: "/docs/clients/intro"
-      }
-    );
-  }
-};
-
-// src/utils/buildRequest.ts
-function buildRequest(request) {
-  return async (args) => {
-    try {
-      return await request(args);
-    } catch (err_) {
-      let err = err_;
-      if (err.code === -32700)
-        throw new ParseRpcError(err);
-      if (err.code === -32600)
-        throw new InvalidRequestRpcError(err);
-      if (err.code === -32601)
-        throw new MethodNotFoundRpcError(err);
-      if (err.code === -32602)
-        throw new InvalidParamsRpcError(err);
-      if (err.code === -32603)
-        throw new InternalRpcError(err);
-      if (err.code === -32e3)
-        throw new InvalidInputRpcError(err);
-      if (err.code === -32001)
-        throw new ResourceNotFoundRpcError(err);
-      if (err.code === -32002)
-        throw new ResourceUnavailableRpcError(err);
-      if (err.code === -32003)
-        throw new TransactionRejectedRpcError(err);
-      if (err.code === -32004)
-        throw new MethodNotSupportedRpcError(err);
-      if (err.code === -32005)
-        throw new LimitExceededRpcError(err);
-      if (err.code === -32006)
-        throw new JsonRpcVersionUnsupportedError(err);
-      if (err_ instanceof BaseError)
-        throw err_;
-      throw new UnknownRpcError(err);
-    }
-  };
-}
-
-// src/utils/promise/withCache.ts
-var promiseCache = /* @__PURE__ */ new Map();
-var responseCache = /* @__PURE__ */ new Map();
-function getCache(cacheKey) {
-  const buildCache = (cacheKey2, cache) => ({
-    clear: () => cache.delete(cacheKey2),
-    get: () => cache.get(cacheKey2),
-    set: (data) => cache.set(cacheKey2, data)
-  });
-  const promise = buildCache(cacheKey, promiseCache);
-  const response = buildCache(
-    cacheKey,
-    responseCache
-  );
-  return {
-    clear: () => {
-      promise.clear();
-      response.clear();
-    },
-    promise,
-    response
-  };
-}
-async function withCache(fn, { cacheKey, maxAge = Infinity }) {
-  const cache = getCache(cacheKey);
-  const response = cache.response.get();
-  if (response && maxAge > 0) {
-    const age = new Date().getTime() - response.created.getTime();
-    if (age < maxAge)
-      return response.data;
-  }
-  let promise = cache.promise.get();
-  if (!promise) {
-    promise = fn();
-    cache.promise.set(promise);
-  }
-  const data = await promise;
-  cache.promise.clear();
-  cache.response.set({ created: new Date(), data });
-  return data;
-}
-
-// src/utils/wait.ts
-async function wait(time) {
-  return new Promise((res) => setTimeout(res, time));
-}
-
-// src/utils/promise/withRetry.ts
-function withRetry(fn, {
-  delay: delay_ = 100,
-  retryCount = 2,
-  shouldRetryOnResponse = () => false,
-  shouldRetryOnError = () => false
-} = {}) {
-  return new Promise((resolve, reject) => {
-    const attemptRetry = async ({ count = 0 } = {}) => {
-      const retry = async ({ data } = {}) => {
-        const delay = typeof delay_ === "function" ? delay_({ count, data }) : delay_;
-        if (delay)
-          await wait(delay);
-        attemptRetry({ count: count + 1 });
-      };
-      try {
-        const data = await fn();
-        if (count < retryCount && await shouldRetryOnResponse({ count, data }))
-          return retry({ data });
-        resolve(data);
-      } catch (err) {
-        if (count < retryCount && await shouldRetryOnError({ count, error: err }))
-          return retry();
-        reject(err);
-      }
-    };
-    attemptRetry();
-  });
-}
-
-// src/utils/promise/withTimeout.ts
-function withTimeout(fn, {
-  errorInstance,
-  timeout,
-  signal
-}) {
-  return new Promise((resolve, reject) => {
-    ;
-    (async () => {
-      let timeoutId;
-      try {
-        const controller = new AbortController();
-        if (timeout > 0) {
-          timeoutId = setTimeout(() => {
-            if (signal) {
-              controller.abort();
-            } else {
-              reject(errorInstance);
-            }
-          }, timeout);
-        }
-        resolve(await fn({ signal: controller?.signal }));
-      } catch (err) {
-        if (err.name === "AbortError")
-          reject(errorInstance);
-        reject(err);
-      } finally {
-        clearTimeout(timeoutId);
-      }
-    })();
-  });
-}
-
-// src/utils/rpc.ts
-var id = 0;
-async function http(url, {
-  body,
-  retryDelay = 100,
-  retryCount = 2,
-  timeout = 0
-}) {
-  const response = await withRetry(
-    () => withTimeout(
-      async ({ signal }) => {
-        const response2 = await fetch(url, {
-          headers: {
-            "Content-Type": "application/json"
-          },
-          method: "POST",
-          body: JSON.stringify({ jsonrpc: "2.0", id: id++, ...body }),
-          signal: timeout > 0 ? signal : void 0
-        });
-        return response2;
-      },
-      {
-        errorInstance: new TimeoutError({ body, url }),
-        timeout,
-        signal: true
-      }
-    ),
-    {
-      delay: ({ count, data: data2 }) => {
-        const retryAfter = data2?.headers.get("Retry-After");
-        if (retryAfter?.match(/\d/))
-          return parseInt(retryAfter) * 1e3;
-        return ~~((Math.random() + 0.5) * (1 << count)) * retryDelay;
-      },
-      retryCount,
-      shouldRetryOnResponse: async ({ data: data2 }) => {
-        if (data2.status >= 500)
-          return true;
-        if ([408, 413, 429].includes(data2.status))
-          return true;
-        return false;
-      }
-    }
-  );
-  let data;
-  if (response.headers.get("Content-Type")?.startsWith("application/json")) {
-    data = await response.json();
-  } else {
-    data = await response.text();
-  }
-  if (!response.ok) {
-    throw new HttpRequestError({
-      body,
-      details: JSON.stringify(data.error) || response.statusText,
-      status: response.status,
-      url
-    });
-  }
-  if (data.error) {
-    throw new RpcError({ body, error: data.error, url });
-  }
-  return data;
-}
-var sockets = /* @__PURE__ */ new Map();
-async function getSocket(url_) {
-  const url = new URL(url_);
-  const urlKey = url.toString();
-  let socket = sockets.get(urlKey);
-  if (socket)
-    return socket;
-  const webSocket2 = new WebSocket(url);
-  const requests = /* @__PURE__ */ new Map();
-  const subscriptions = /* @__PURE__ */ new Map();
-  const onMessage = ({ data }) => {
-    const message = JSON.parse(data);
-    const isSubscription = message.method === "eth_subscription";
-    const id2 = isSubscription ? message.params.subscription : message.id;
-    const cache = isSubscription ? subscriptions : requests;
-    const callback = cache.get(id2);
-    if (callback)
-      callback({ data });
-    if (!isSubscription)
-      cache.delete(id2);
-  };
-  const onClose = () => {
-    sockets.delete(urlKey);
-    webSocket2.removeEventListener("close", onClose);
-    webSocket2.removeEventListener("message", onMessage);
-  };
-  webSocket2.addEventListener("close", onClose);
-  webSocket2.addEventListener("message", onMessage);
-  if (webSocket2.readyState === WebSocket.CONNECTING) {
-    await new Promise((resolve, reject) => {
-      if (!webSocket2)
-        return;
-      webSocket2.onopen = resolve;
-      webSocket2.onerror = reject;
-    });
-  }
-  socket = Object.assign(webSocket2, {
-    requests,
-    subscriptions
-  });
-  sockets.set(urlKey, socket);
-  return socket;
-}
-function webSocket(socket, {
-  body,
-  onData,
-  onError
-}) {
-  if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
-    throw new WebSocketRequestError({
-      body,
-      url: socket.url,
-      details: "Socket is closed."
-    });
-  const id_ = id++;
-  const callback = ({ data }) => {
-    const message = JSON.parse(data);
-    if (typeof message.id === "number" && id_ !== message.id)
-      return;
-    if (message.error) {
-      onError?.(new RpcError({ body, error: message.error, url: socket.url }));
-    } else {
-      onData?.(message);
-    }
-    if (body.method === "eth_subscribe" && typeof message.result === "string") {
-      socket.subscriptions.set(message.result, callback);
-    }
-    if (body.method === "eth_unsubscribe") {
-      socket.subscriptions.delete(body.params?.[0]);
-    }
-  };
-  socket.requests.set(id_, callback);
-  socket.send(JSON.stringify({ jsonrpc: "2.0", ...body, id: id_ }));
-  return socket;
-}
-async function webSocketAsync(socket, {
-  body,
-  timeout = 0
-}) {
-  return withTimeout(
-    () => new Promise(
-      (onData, onError) => rpc.webSocket(socket, {
-        body,
-        onData,
-        onError
-      })
-    ),
-    {
-      errorInstance: new TimeoutError({ body, url: socket.url }),
-      timeout
-    }
-  );
-}
-var rpc = {
-  http,
-  webSocket,
-  webSocketAsync
-};
-
-export {
-  BaseError,
-  AbiConstructorNotFoundError,
-  AbiConstructorParamsNotFoundError,
-  AbiDecodingDataSizeInvalidError,
-  AbiEncodingArrayLengthMismatchError,
-  AbiEncodingLengthMismatchError,
-  AbiErrorInputsNotFoundError,
-  AbiErrorNotFoundError,
-  AbiErrorSignatureNotFoundError,
-  AbiEventNotFoundError,
-  AbiFunctionNotFoundError,
-  AbiFunctionOutputsNotFoundError,
-  AbiFunctionSignatureNotFoundError,
-  InvalidAbiEncodingTypeError,
-  InvalidAbiDecodingTypeError,
-  InvalidArrayError,
-  InvalidDefinitionTypeError,
-  InvalidAddressError,
-  BlockNotFoundError,
-  SizeExceedsPaddingSizeError,
-  DataLengthTooLongError,
-  DataLengthTooShortError,
-  InvalidBytesBooleanError,
-  InvalidHexBooleanError,
-  InvalidHexValueError,
-  OffsetOutOfBoundsError,
-  FilterTypeNotSupportedError,
-  RequestError,
-  RpcRequestError,
-  ParseRpcError,
-  InvalidRequestRpcError,
-  MethodNotFoundRpcError,
-  InvalidParamsRpcError,
-  InternalRpcError,
-  InvalidInputRpcError,
-  ResourceNotFoundRpcError,
-  ResourceUnavailableRpcError,
-  TransactionRejectedRpcError,
-  MethodNotSupportedRpcError,
-  LimitExceededRpcError,
-  JsonRpcVersionUnsupportedError,
-  UnknownRpcError,
-  HttpRequestError,
-  WebSocketRequestError,
-  RpcError,
-  TimeoutError,
-  InvalidGasArgumentsError,
-  TransactionNotFoundError,
-  TransactionReceiptNotFoundError,
-  WaitForTransactionReceiptTimeoutError,
-  UrlRequiredError,
-  buildRequest,
-  getCache,
-  withCache,
-  wait,
-  getSocket,
-  rpc
-};