viem 0.0.1-cjs.10 → 0.0.1-sushi.26

package/dist/{chunk-2FDH6XP5.mjs → chunk-SD5X7F4U.mjs}

@@ -8,8 +8,8 @@ var __publicField = (obj, key, value) => {
 // package.json
 var package_default = {
   name: "viem",
-  description: "TypeScript (& JavaScript) Interface for Ethereum",
-  version: "0.0.1-alpha.9",
+  description: "TypeScript Interface for Ethereum",
+  version: "0.0.1-alpha.25",
   scripts: {
     anvil: "source .env && anvil --fork-url $VITE_ANVIL_FORK_URL --fork-block-number $VITE_ANVIL_BLOCK_NUMBER --block-time $VITE_ANVIL_BLOCK_TIME",
     bench: "vitest bench --no-threads",
@@ -18,28 +18,32 @@ var package_default = {
     changeset: "changeset",
     "changeset:release": "pnpm build && changeset publish",
     "changeset:version": "changeset version && pnpm install --lockfile-only",
+    "contracts:build": "wagmi generate",
     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",
+    postinstall: "pnpm dev && pnpm contracts:build",
     preinstall: "npx only-allow pnpm",
+    prepublishOnly: "pnpm ts-node scripts/generate-package-json.ts",
     prepare: "npx simple-git-hooks",
-    test: "vitest dev --coverage --no-threads",
+    test: "vitest dev --no-threads",
     "test:ci": "CI=true vitest --coverage --no-threads",
     "test:ui": "vitest dev --ui --no-threads",
+    "ts-node": "node --loader esbuild-register/loader -r esbuild-register",
     typecheck: "tsc --noEmit"
   },
   files: [
-    "/actions",
     "/chains",
+    "/contract",
     "/dist",
-    "/clients",
+    "/ens",
+    "/src",
     "/types",
     "/utils",
+    "/wallet",
     "/window"
   ],
   exports: {
@@ -48,26 +52,41 @@ var package_default = {
       module: "./dist/index.mjs",
       default: "./dist/index.js"
     },
-    "./actions": {
-      types: "./dist/actions/index.d.ts",
-      module: "./dist/actions/index.mjs",
-      default: "./dist/actions/index.js"
-    },
     "./chains": {
       types: "./dist/chains.d.ts",
       module: "./dist/chains.mjs",
       default: "./dist/chains.js"
     },
-    "./clients": {
-      types: "./dist/clients/index.d.ts",
-      module: "./dist/clients/index.mjs",
-      default: "./dist/clients/index.js"
+    "./contract": {
+      types: "./dist/contract.d.ts",
+      module: "./dist/contract.mjs",
+      default: "./dist/contract.js"
+    },
+    "./ens": {
+      types: "./dist/ens.d.ts",
+      module: "./dist/ens.mjs",
+      default: "./dist/ens.js"
+    },
+    "./public": {
+      types: "./dist/public.d.ts",
+      module: "./dist/public.mjs",
+      default: "./dist/public.js"
+    },
+    "./test": {
+      types: "./dist/test.d.ts",
+      module: "./dist/test.mjs",
+      default: "./dist/test.js"
     },
     "./utils": {
       types: "./dist/utils/index.d.ts",
       module: "./dist/utils/index.mjs",
       default: "./dist/utils/index.js"
     },
+    "./wallet": {
+      types: "./dist/wallet.d.ts",
+      module: "./dist/wallet.mjs",
+      default: "./dist/wallet.js"
+    },
     "./window": {
       types: "./dist/window.d.ts",
       module: "./dist/window.mjs",
@@ -81,35 +100,40 @@ var package_default = {
   sideEffects: false,
   dependencies: {
     "@noble/hashes": "^1.1.2",
-    "@wagmi/chains": "^0.1.0",
-    abitype: "^0.2.5"
+    "@wagmi/chains": "~0.2.8",
+    abitype: "~0.3.0",
+    "idna-uts46-hx": "^4.1.2",
+    "isomorphic-unfetch": "^4.0.2",
+    "isomorphic-ws": "^5.0.0",
+    ws: "^8.12.0"
   },
   devDependencies: {
     "@actions/core": "^1.10.0",
     "@actions/github": "^5.1.1",
+    "@adraffy/ens-normalize": "^1.8.9",
     "@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",
+    "@types/ws": "^8.5.4",
     "@vitest/coverage-c8": "^0.24.3",
     "@vitest/ui": "^0.19.1",
+    "@wagmi/cli": "^0.1.6",
     bundlewatch: "^0.3.3",
     dedent: "^0.7.0",
-    esbuild: "^0.16.12",
+    esbuild: "^0.16.17",
     "esbuild-register": "^3.4.2",
-    "essential-eth": "^0.6.2",
     ethers: "^5.7.2",
+    "ethers@6": "npm:ethers@^6.0.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",
+    tsup: "^6.6.0",
+    typescript: "^4.9.4",
+    vite: "^3.2.5",
+    vitest: "^0.25.8",
     web3: "^1.8.1"
   },
   license: "MIT",
@@ -135,38 +159,32 @@ var package_default = {
   }
 };
 
-// src/utils/stringify.ts
-function stringify(value) {
-  return JSON.stringify(
-    value,
-    (_, value2) => typeof value2 === "bigint" ? value2.toString() : value2
-  );
-}
-
 // src/errors/base.ts
 var version = process.env.TEST ? "1.0.2" : package_default.version;
 var BaseError = class extends Error {
-  constructor(humanMessage, args = {}) {
+  constructor(shortMessage, args = {}) {
     const details = args.cause instanceof BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
     const docsPath5 = args.cause instanceof BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
     const message = [
-      humanMessage,
-      ...docsPath5 ? ["", `Docs: https://viem.sh${docsPath5}`] : [],
+      shortMessage || "An error occurred.",
       "",
+      ...args.metaMessages ? [...args.metaMessages, ""] : [],
+      ...docsPath5 ? [`Docs: https://viem.sh${docsPath5}`] : [],
       ...details ? [`Details: ${details}`] : [],
-      `Version: viem@${version}`,
-      ...args.cause && !(args.cause instanceof BaseError) && Object.keys(args.cause).length > 0 ? [`Internal Error: ${stringify(args.cause)}`] : []
+      `Version: viem@${version}`
     ].join("\n");
     super(message);
-    __publicField(this, "humanMessage");
     __publicField(this, "details");
     __publicField(this, "docsPath");
+    __publicField(this, "metaMessages");
+    __publicField(this, "shortMessage");
     __publicField(this, "name", "ViemError");
     if (args.cause)
       this.cause = args.cause;
     this.details = details;
     this.docsPath = docsPath5;
-    this.humanMessage = humanMessage;
+    this.metaMessages = args.metaMessages;
+    this.shortMessage = shortMessage;
   }
 };
 
@@ -282,7 +300,7 @@ var AbiErrorSignatureNotFoundError = class extends BaseError {
       [
         `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/.`
+        `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
       ].join("\n"),
       {
         docsPath: docsPath5
@@ -291,6 +309,21 @@ var AbiErrorSignatureNotFoundError = class extends BaseError {
     __publicField(this, "name", "AbiErrorSignatureNotFoundError");
   }
 };
+var AbiEventSignatureNotFoundError = class extends BaseError {
+  constructor(signature, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Encoded event signature "${signature}" not found on ABI.`,
+        "Make sure you are using the correct ABI and that the event exists on it.",
+        `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiEventSignatureNotFoundError");
+  }
+};
 var AbiEventNotFoundError = class extends BaseError {
   constructor(eventName, { docsPath: docsPath5 }) {
     super(
@@ -340,7 +373,7 @@ var AbiFunctionSignatureNotFoundError = class extends BaseError {
       [
         `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/.`
+        `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`
       ].join("\n"),
       {
         docsPath: docsPath5
@@ -415,82 +448,226 @@ var BlockNotFoundError = class extends BaseError {
   }
 };
 
+// src/errors/chain.ts
+var ChainDoesNotSupportContract = class extends BaseError {
+  constructor({
+    blockNumber,
+    chain,
+    contract
+  }) {
+    super(
+      `Chain "${chain.name}" does not support contract "${contract.name}".`,
+      {
+        metaMessages: [
+          "This could be due to any of the following:",
+          ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
+            `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
+          ] : [
+            `- The chain does not have the contract "${contract.name}" configured.`
+          ]
+        ]
+      }
+    );
+    __publicField(this, "name", "ChainDoesNotSupportContract");
+  }
+};
+
+// src/constants/abis.ts
+var multicall3Abi = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            name: "target",
+            type: "address"
+          },
+          {
+            name: "allowFailure",
+            type: "bool"
+          },
+          {
+            name: "callData",
+            type: "bytes"
+          }
+        ],
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "aggregate3",
+    outputs: [
+      {
+        components: [
+          {
+            name: "success",
+            type: "bool"
+          },
+          {
+            name: "returnData",
+            type: "bytes"
+          }
+        ],
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/constants/solidity.ts
+var panicReasons = {
+  1: "An `assert` condition failed.",
+  17: "Arithmic operation resulted in underflow or overflow.",
+  18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
+  33: "Attempted to convert to an invalid type.",
+  34: "Attempted to access a storage byte array that is incorrectly encoded.",
+  49: "Performed `.pop()` on an empty array",
+  50: "Array index is out of bounds.",
+  65: "Allocated too much memory or created an array which is too large.",
+  81: "Attempted to call a zero-initialized variable of internal function type."
+};
+var solidityError = {
+  inputs: [
+    {
+      name: "message",
+      type: "string"
+    }
+  ],
+  name: "Error",
+  type: "error"
+};
+var solidityPanic = {
+  inputs: [
+    {
+      name: "reason",
+      type: "uint256"
+    }
+  ],
+  name: "Panic",
+  type: "error"
+};
+
 // src/errors/contract.ts
-var ContractMethodExecutionError = class extends BaseError {
-  constructor(message, {
+var ContractFunctionExecutionError = class extends BaseError {
+  constructor(cause, {
     abi,
     args,
-    cause,
     contractAddress,
-    formattedArgs,
+    docsPath: docsPath5,
     functionName,
-    functionWithParams,
     sender
-  } = {}) {
+  }) {
+    const abiItem = getAbiItem({ abi, args, name: functionName });
+    const formattedArgs = abiItem ? formatAbiItemWithArgs({
+      abiItem,
+      args,
+      includeFunctionName: false,
+      includeName: false
+    }) : void 0;
+    const functionWithParams = abiItem ? formatAbiItem(abiItem, { includeName: true }) : void 0;
     super(
-      [
-        message,
-        " ",
-        sender && `Sender:    ${sender}`,
-        contractAddress && `Contract:  ${process.env.TEST ? "0x0000000000000000000000000000000000000000" : contractAddress}`,
-        functionWithParams && `Function:  ${functionWithParams}`,
-        formattedArgs && `Arguments: ${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`
-      ].filter(Boolean).join("\n"),
+      cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`,
       {
-        cause
+        cause,
+        docsPath: docsPath5,
+        metaMessages: [
+          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+          contractAddress && `Contract:  ${/* c8 ignore start */
+          process.env.TEST ? "0x0000000000000000000000000000000000000000" : contractAddress}`,
+          functionWithParams && `Function:  ${functionWithParams}`,
+          formattedArgs && formattedArgs !== "()" && `Arguments: ${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
+          sender && `Sender:    ${sender}`
+        ].filter(Boolean)
       }
     );
     __publicField(this, "abi");
     __publicField(this, "args");
+    __publicField(this, "cause");
     __publicField(this, "contractAddress");
     __publicField(this, "formattedArgs");
     __publicField(this, "functionName");
-    __publicField(this, "reason");
     __publicField(this, "sender");
-    __publicField(this, "name", "ContractMethodExecutionError");
-    if (message)
-      this.reason = message;
+    __publicField(this, "name", "ContractFunctionExecutionError");
     this.abi = abi;
     this.args = args;
+    this.cause = cause;
     this.contractAddress = contractAddress;
     this.functionName = functionName;
     this.sender = sender;
   }
 };
-var ContractMethodZeroDataError = class extends BaseError {
+var ContractFunctionRevertedError = class extends BaseError {
   constructor({
     abi,
-    args,
-    cause,
-    contractAddress,
+    data,
     functionName,
-    functionWithParams
-  } = {}) {
+    message
+  }) {
+    let decodedData = void 0;
+    let metaMessages;
+    let reason;
+    if (data && data !== "0x") {
+      decodedData = decodeErrorResult({ abi, data });
+      const { abiItem, errorName, args: errorArgs } = decodedData;
+      if (errorName === "Error") {
+        reason = errorArgs[0];
+      } else if (errorName === "Panic") {
+        const [firstArg] = errorArgs;
+        reason = panicReasons[firstArg];
+      } else if (errorArgs) {
+        const errorWithParams = abiItem ? formatAbiItem(abiItem, { includeName: true }) : void 0;
+        const formattedArgs = abiItem ? formatAbiItemWithArgs({
+          abiItem,
+          args: errorArgs,
+          includeFunctionName: false,
+          includeName: false
+        }) : void 0;
+        metaMessages = [
+          errorWithParams ? `Error:     ${errorWithParams}` : "",
+          formattedArgs && formattedArgs !== "()" ? `Arguments: ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
+        ];
+      }
+    } else if (message)
+      reason = message;
     super(
-      [
-        `The contract method "${functionName}" returned no data ("0x"). This could be due to any of the following:`,
-        `- The contract does not have the function "${functionName}",`,
-        "- The parameters passed to the contract function may be invalid, or",
-        "- The address is not a contract.",
-        " ",
-        contractAddress && `Contract: ${process.env.TEST ? "0x0000000000000000000000000000000000000000" : contractAddress}`,
-        functionWithParams && `Function: ${functionWithParams}`,
-        functionWithParams && `        > "0x"`
-      ].filter(Boolean).join("\n"),
+      reason ? [
+        `The contract function "${functionName}" reverted with the following reason:`,
+        reason
+      ].join("\n") : `The contract function "${functionName}" reverted.`,
       {
-        cause
+        metaMessages
       }
     );
-    __publicField(this, "abi");
-    __publicField(this, "args");
-    __publicField(this, "contractAddress");
-    __publicField(this, "functionName");
-    __publicField(this, "functionWithParams");
-    __publicField(this, "name", "ContractMethodZeroDataError");
-    this.abi = abi;
-    this.args = args;
-    this.contractAddress = contractAddress;
-    this.functionName = functionName;
+    __publicField(this, "name", "ContractFunctionRevertedError");
+    __publicField(this, "data");
+    __publicField(this, "reason");
+    this.reason = reason;
+    this.data = decodedData;
+  }
+};
+var ContractFunctionZeroDataError = class extends BaseError {
+  constructor({ functionName }) {
+    super(`The contract function "${functionName}" returned no data ("0x").`, {
+      metaMessages: [
+        "This could be due to any of the following:",
+        `- The contract does not have the function "${functionName}",`,
+        "- The parameters passed to the contract function may be invalid, or",
+        "- The address is not a contract."
+      ]
+    });
+    __publicField(this, "name", "ContractFunctionZeroDataError");
+  }
+};
+var RawContractError = class extends BaseError {
+  constructor({ data, message }) {
+    super(message || "");
+    __publicField(this, "code", 3);
+    __publicField(this, "name", "RawContractError");
+    __publicField(this, "data");
+    this.data = data;
   }
 };
 
@@ -568,8 +745,8 @@ var FilterTypeNotSupportedError = class extends BaseError {
 
 // src/errors/request.ts
 var RequestError = class extends BaseError {
-  constructor(err, { docsPath: docsPath5, humanMessage }) {
-    super(humanMessage, {
+  constructor(err, { docsPath: docsPath5, shortMessage }) {
+    super(shortMessage, {
       cause: err,
       docsPath: docsPath5
     });
@@ -577,8 +754,8 @@ var RequestError = class extends BaseError {
   }
 };
 var RpcRequestError = class extends RequestError {
-  constructor(err, { docsPath: docsPath5, humanMessage }) {
-    super(err, { docsPath: docsPath5, humanMessage });
+  constructor(err, { docsPath: docsPath5, shortMessage }) {
+    super(err, { docsPath: docsPath5, shortMessage });
     __publicField(this, "code");
     this.code = err.code;
     this.name = err.name;
@@ -587,7 +764,7 @@ var RpcRequestError = class extends RequestError {
 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."
+      shortMessage: "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);
@@ -595,7 +772,7 @@ var ParseRpcError = class extends RpcRequestError {
 };
 var InvalidRequestRpcError = class extends RpcRequestError {
   constructor(err) {
-    super(err, { humanMessage: "JSON is not a valid request object." });
+    super(err, { shortMessage: "JSON is not a valid request object." });
     __publicField(this, "name", "InvalidRequestRpcError");
     __publicField(this, "code", -32600);
   }
@@ -603,7 +780,7 @@ var InvalidRequestRpcError = class extends RpcRequestError {
 var MethodNotFoundRpcError = class extends RpcRequestError {
   constructor(err) {
     super(err, {
-      humanMessage: "The method does not exist / is not available."
+      shortMessage: "The method does not exist / is not available."
     });
     __publicField(this, "name", "MethodNotFoundRpcError");
     __publicField(this, "code", -32601);
@@ -612,7 +789,7 @@ var MethodNotFoundRpcError = class extends RpcRequestError {
 var InvalidParamsRpcError = class extends RpcRequestError {
   constructor(err) {
     super(err, {
-      humanMessage: [
+      shortMessage: [
         "Invalid parameters were provided to the RPC method.",
         "Double check you have provided the correct parameters."
       ].join("\n")
@@ -623,7 +800,7 @@ var InvalidParamsRpcError = class extends RpcRequestError {
 };
 var InternalRpcError = class extends RpcRequestError {
   constructor(err) {
-    super(err, { humanMessage: "An internal error was received." });
+    super(err, { shortMessage: "An internal error was received." });
     __publicField(this, "name", "InternalRpcError");
     __publicField(this, "code", -32603);
   }
@@ -631,7 +808,7 @@ var InternalRpcError = class extends RpcRequestError {
 var InvalidInputRpcError = class extends RpcRequestError {
   constructor(err) {
     super(err, {
-      humanMessage: [
+      shortMessage: [
         "Missing or invalid parameters.",
         "Double check you have provided the correct parameters."
       ].join("\n")
@@ -642,35 +819,35 @@ var InvalidInputRpcError = class extends RpcRequestError {
 };
 var ResourceNotFoundRpcError = class extends RpcRequestError {
   constructor(err) {
-    super(err, { humanMessage: "Requested resource not found." });
+    super(err, { shortMessage: "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." });
+    super(err, { shortMessage: "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." });
+    super(err, { shortMessage: "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." });
+    super(err, { shortMessage: "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." });
+    super(err, { shortMessage: "Request exceeds defined limit." });
     __publicField(this, "name", "LimitExceededRpcError");
     __publicField(this, "code", -32005);
   }
@@ -678,7 +855,7 @@ var LimitExceededRpcError = class extends RpcRequestError {
 var JsonRpcVersionUnsupportedError = class extends RpcRequestError {
   constructor(err) {
     super(err, {
-      humanMessage: "Version of JSON-RPC protocol is not supported."
+      shortMessage: "Version of JSON-RPC protocol is not supported."
     });
     __publicField(this, "name", "JsonRpcVersionUnsupportedError");
     __publicField(this, "code", -32006);
@@ -687,7 +864,7 @@ var JsonRpcVersionUnsupportedError = class extends RpcRequestError {
 var UnknownRpcError = class extends RequestError {
   constructor(err) {
     super(err, {
-      humanMessage: "An unknown RPC error occurred."
+      shortMessage: "An unknown RPC error occurred."
     });
     __publicField(this, "name", "UnknownRpcError");
   }
@@ -1264,46 +1441,35 @@ function extractFunctionType(def) {
 }
 
 // src/utils/contract/getContractError.ts
+var EXECUTION_REVERTED_ERROR_CODE = 3;
 function getContractError(err, {
   abi,
   address,
   args,
+  docsPath: docsPath5,
   functionName,
   sender
 }) {
-  const { code, message } = err.cause || {};
-  const abiItem = getAbiItem({ abi, name: functionName });
-  const formattedArgs = abiItem ? formatAbiItemWithArgs({
-    abiItem,
-    args,
-    includeFunctionName: false,
-    includeName: false
-  }) : void 0;
-  const functionWithParams = abiItem ? formatAbiItemWithParams(abiItem, { includeName: true }) : void 0;
+  const { code, data, message } = err instanceof RawContractError ? err : err.cause || {};
+  let cause = err;
   if (err instanceof AbiDecodingZeroDataError) {
-    return new ContractMethodZeroDataError({
-      abi,
-      args,
-      cause: err,
-      contractAddress: address,
-      functionName,
-      functionWithParams
-    });
-  }
-  if (code === 3 || message?.includes("execution reverted")) {
-    const message_ = message?.replace("execution reverted: ", "");
-    return new ContractMethodExecutionError(message_, {
+    cause = new ContractFunctionZeroDataError({ functionName });
+  } else if (code === EXECUTION_REVERTED_ERROR_CODE && (data || message)) {
+    cause = new ContractFunctionRevertedError({
       abi,
-      args,
-      cause: err,
-      contractAddress: address,
-      formattedArgs,
+      data,
       functionName,
-      functionWithParams,
-      sender
+      message
     });
   }
-  return err;
+  return new ContractFunctionExecutionError(cause, {
+    abi,
+    args,
+    contractAddress: address,
+    docsPath: docsPath5,
+    functionName,
+    sender
+  });
 }
 
 // src/utils/hash/keccak256.ts
@@ -1403,16 +1569,16 @@ function isAddressEqual(a, b) {
 }
 
 // src/utils/abi/encodeAbi.ts
-function encodeAbi({
-  params,
-  values
-}) {
+function encodeAbi({ params, values }) {
   if (params.length !== values.length)
     throw new AbiEncodingLengthMismatchError({
       expectedLength: params.length,
       givenLength: values.length
     });
-  const preparedParams = prepareParams({ params, values });
+  const preparedParams = prepareParams({
+    params,
+    values
+  });
   const data = encodeParams(preparedParams);
   if (data.length === 0)
     return "0x";
@@ -1529,14 +1695,20 @@ function encodeArray(value, {
 }
 function encodeBytes2(value, { param }) {
   const [_, size_] = param.type.split("bytes");
-  if (!size_)
+  if (!size_) {
+    const partsLength = Math.floor(size(value) / 32);
+    const parts = [];
+    for (let i = 0; i < partsLength + 1; i++) {
+      parts.push(padHex(slice(value, i * 32, (i + 1) * 32), { dir: "right" }));
+    }
     return {
       dynamic: true,
       encoded: concat([
         padHex(numberToHex(size(value), { size: 32 })),
-        padHex(value, { dir: "right" })
+        ...parts
       ])
     };
+  }
   return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
 }
 function encodeBool(value) {
@@ -1580,14 +1752,14 @@ function encodeTuple(value, { param }) {
 }
 function getArrayComponents(type) {
   const matches = type.match(/^(.*)\[(\d+)?\]$/);
-  return matches ? [matches[2] ? Number(matches[2]) : null, matches[1]] : void 0;
+  return matches ? (
+    // Return `null` if the array is dynamic.
+    [matches[2] ? Number(matches[2]) : null, matches[1]]
+  ) : void 0;
 }
 
 // src/utils/abi/decodeAbi.ts
-function decodeAbi({
-  data,
-  params
-}) {
+function decodeAbi({ data, params }) {
   if (data === "0x" && params.length > 0)
     throw new AbiDecodingZeroDataError();
   if (size(data) % 32 !== 0)
@@ -1781,8 +1953,8 @@ function hasDynamicChild(param) {
   return false;
 }
 
-// src/utils/abi/formatAbiItemWithParams.ts
-function formatAbiItemWithParams(abiItem, { includeName = false } = {}) {
+// src/utils/abi/formatAbiItem.ts
+function formatAbiItem(abiItem, { includeName = false } = {}) {
   if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
     throw new InvalidDefinitionTypeError(abiItem.type);
   return `${abiItem.name}(${getParams(abiItem.inputs, { includeName })})`;
@@ -1803,26 +1975,88 @@ function getParam(param, { includeName }) {
 }
 
 // src/utils/abi/decodeErrorResult.ts
-function decodeErrorResult({ abi, data }) {
+function decodeErrorResult({
+  abi,
+  data
+}) {
   const signature = slice(data, 0, 4);
-  const description = abi.find(
-    (x) => signature === getFunctionSignature(formatAbiItemWithParams(x))
+  if (signature === "0x")
+    throw new AbiDecodingZeroDataError();
+  const abi_ = [...abi || [], solidityError, solidityPanic];
+  const abiItem = abi_.find(
+    (x) => x.type === "error" && signature === getFunctionSignature(formatAbiItem(x))
   );
-  if (!description)
+  if (!abiItem)
     throw new AbiErrorSignatureNotFoundError(signature, {
       docsPath: "/docs/contract/decodeErrorResult"
     });
   return {
-    errorName: description.name,
-    args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbi({ data: slice(data, 4), params: description.inputs }) : void 0
+    abiItem,
+    args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbi({ data: slice(data, 4), params: abiItem.inputs }) : void 0,
+    errorName: abiItem.name
   };
 }
 
+// src/utils/abi/decodeEventLog.ts
+function decodeEventLog({
+  abi,
+  data,
+  topics
+}) {
+  const [signature, ...argTopics] = topics;
+  const abiItem = abi.find(
+    (x) => signature === getEventSignature(formatAbiItem(x))
+  );
+  if (!(abiItem && "name" in abiItem))
+    throw new AbiEventSignatureNotFoundError(signature, {
+      docsPath: "/docs/contract/decodeEventLog"
+    });
+  const { name, inputs } = abiItem;
+  const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
+  let args = isUnnamed ? [] : {};
+  for (let i = 0; i < inputs.length; i++) {
+    const param = inputs[i];
+    const topic = argTopics[i];
+    if (topic === null)
+      args[param.name || i] = null;
+    if (!topic)
+      continue;
+    if (Array.isArray(topic)) {
+      args[param.name || i] = topic.map((t) => decodeTopic({ param, value: t }));
+    } else {
+      args[param.name || i] = decodeTopic({ param, value: topic });
+    }
+  }
+  if (data) {
+    const params = inputs.filter((x) => !("indexed" in x && x.indexed));
+    const decodedData = decodeAbi({ params, data });
+    if (decodedData) {
+      if (isUnnamed)
+        args = [...args, ...decodedData];
+      else {
+        for (let i = 0; i < params.length; i++) {
+          args[params[i].name] = decodedData[i];
+        }
+      }
+    }
+  }
+  return {
+    eventName: name,
+    args: Object.values(args).length > 0 ? args : void 0
+  };
+}
+function decodeTopic({ param, value }) {
+  if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
+    return value;
+  const decodedArg = decodeAbi({ params: [param], data: value }) || [];
+  return decodedArg[0];
+}
+
 // src/utils/abi/decodeFunctionData.ts
 function decodeFunctionData({ abi, data }) {
   const signature = slice(data, 0, 4);
   const description = abi.find(
-    (x) => signature === getFunctionSignature(formatAbiItemWithParams(x))
+    (x) => signature === getFunctionSignature(formatAbiItem(x))
   );
   if (!description)
     throw new AbiFunctionSignatureNotFoundError(signature, {
@@ -1834,16 +2068,91 @@ function decodeFunctionData({ abi, data }) {
   };
 }
 
+// src/utils/abi/getAbiItem.ts
+function getAbiItem({ abi, args = [], name }) {
+  const abiItems = abi.filter((x) => "name" in x && x.name === name);
+  if (abiItems.length === 0)
+    return void 0;
+  if (abiItems.length === 1)
+    return abiItems[0];
+  for (const abiItem of abiItems) {
+    if (!("inputs" in abiItem))
+      continue;
+    if (!args || args.length === 0) {
+      if (!abiItem.inputs || abiItem.inputs.length === 0)
+        return abiItem;
+      continue;
+    }
+    if (!abiItem.inputs)
+      continue;
+    if (abiItem.inputs.length === 0)
+      continue;
+    const matched = args.every((arg, index) => {
+      const abiParameter = "inputs" in abiItem && abiItem.inputs[index];
+      if (!abiParameter)
+        return false;
+      return isArgOfType(arg, abiParameter);
+    });
+    if (matched)
+      return abiItem;
+  }
+  return abiItems[0];
+}
+function isArgOfType(arg, abiParameter) {
+  const argType = typeof arg;
+  const abiParameterType = abiParameter.type;
+  switch (abiParameterType) {
+    case "address":
+      return isAddress(arg);
+    case "bool":
+      return argType === "boolean";
+    case "function":
+      return argType === "string";
+    case "string":
+      return argType === "string";
+    default: {
+      if (abiParameterType === "tuple" && "components" in abiParameter)
+        return Object.values(abiParameter.components).every(
+          (component, index) => {
+            return isArgOfType(
+              Object.values(arg)[index],
+              component
+            );
+          }
+        );
+      if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(
+        abiParameterType
+      ))
+        return argType === "number" || argType === "bigint";
+      if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
+        return argType === "string" || arg instanceof Uint8Array;
+      if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
+        return Array.isArray(arg) && arg.every(
+          (x) => isArgOfType(x, {
+            ...abiParameter,
+            // Pop off `[]` or `[M]` from end of type
+            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
+          })
+        );
+      }
+      return false;
+    }
+  }
+}
+
 // src/utils/abi/decodeFunctionResult.ts
 var docsPath = "/docs/contract/decodeFunctionResult";
 function decodeFunctionResult({
   abi,
+  args,
   functionName,
   data
 }) {
-  const description = abi.find(
-    (x) => "name" in x && x.name === functionName
-  );
+  const description = getAbiItem({
+    abi,
+    args,
+    name: functionName
+  });
   if (!description)
     throw new AbiFunctionNotFoundError(functionName, { docsPath });
   if (!("outputs" in description))
@@ -1865,7 +2174,9 @@ function encodeDeployData({
 }) {
   if (!args || args.length === 0)
     return bytecode;
-  const description = abi.find((x) => "type" in x && x.type === "constructor");
+  const description = abi.find(
+    (x) => "type" in x && x.type === "constructor"
+  );
   if (!description)
     throw new AbiConstructorNotFoundError({ docsPath: docsPath2 });
   if (!("inputs" in description))
@@ -1879,18 +2190,17 @@ function encodeDeployData({
   return concatHex([bytecode, data]);
 }
 
-// src/utils/abi/getAbiItem.ts
-function getAbiItem({ abi, name }) {
-  return abi.find((x) => "name" in x && x.name === name);
-}
-
 // src/utils/abi/encodeErrorResult.ts
 var docsPath3 = "/docs/contract/encodeErrorResult";
 function encodeErrorResult({ abi, errorName, args }) {
-  const description = getAbiItem({ abi, name: errorName });
+  const description = getAbiItem({
+    abi,
+    args,
+    name: errorName
+  });
   if (!description)
     throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath3 });
-  const definition = formatAbiItemWithParams(description);
+  const definition = formatAbiItem(description);
   const signature = getFunctionSignature(definition);
   let data = "0x";
   if (args && args.length > 0) {
@@ -1903,12 +2213,12 @@ function encodeErrorResult({ abi, errorName, args }) {
 
 // src/utils/abi/encodeEventTopics.ts
 function encodeEventTopics({ abi, eventName, args }) {
-  const abiItem = getAbiItem({ abi, name: eventName });
+  const abiItem = getAbiItem({ abi, args, name: eventName });
   if (!abiItem)
     throw new AbiEventNotFoundError(eventName, {
       docsPath: "/docs/contract/encodeEventTopics"
     });
-  const definition = formatAbiItemWithParams(abiItem);
+  const definition = formatAbiItem(abiItem);
   const signature = getEventSignature(definition);
   let topics = [];
   if (args && "inputs" in abiItem) {
@@ -1934,12 +2244,16 @@ function encodeArg({
 
 // src/utils/abi/encodeFunctionData.ts
 function encodeFunctionData({ abi, args, functionName }) {
-  const description = getAbiItem({ abi, name: functionName });
+  const description = getAbiItem({
+    abi,
+    args,
+    name: functionName
+  });
   if (!description)
     throw new AbiFunctionNotFoundError(functionName, {
       docsPath: "/docs/contract/encodeFunctionData"
     });
-  const definition = formatAbiItemWithParams(description);
+  const definition = formatAbiItem(description);
   const signature = getFunctionSignature(definition);
   const data = "inputs" in description && description.inputs ? encodeAbi({
     params: description.inputs,
@@ -1955,7 +2269,9 @@ function encodeFunctionResult({
   functionName,
   result
 }) {
-  const description = abi.find((x) => "name" in x && x.name === functionName);
+  const description = abi.find(
+    (x) => "name" in x && x.name === functionName
+  );
   if (!description)
     throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
   if (!("outputs" in description))
@@ -1984,64 +2300,206 @@ function formatAbiItemWithArgs({
   ).join(", ")})`;
 }
 
+// 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 = (/* @__PURE__ */ 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: /* @__PURE__ */ 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/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);
+var isNonDeterministicError = (error) => {
+  if (error instanceof UnknownRpcError)
+    return true;
+  if ("code" in error)
+    return error.code === -32603 || error.code === -32e3 || error.code === -32005;
+  return false;
+};
+function buildRequest(request, {
+  retryDelay = 150,
+  retryCount = 3
+} = {}) {
+  return async (args) => withRetry(
+    async () => {
+      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);
+      }
+    },
+    {
+      delay: ({ count }) => ~~(1 << count) * retryDelay,
+      retryCount,
+      shouldRetryOnError: ({ error }) => isNonDeterministicError(error)
     }
+  );
+}
+
+// src/utils/chain.ts
+function defineChain(chain) {
+  return chain;
+}
+
+// src/utils/formatters/format.ts
+function format3(data, { formatter }) {
+  return formatter(data);
+}
+function defineFormatter({
+  format: format4
+}) {
+  return ({
+    exclude,
+    format: formatOverride
+  }) => (data) => {
+    const formatted = format4(data);
+    if (exclude) {
+      for (const key of exclude) {
+        delete formatted[key];
+      }
+    }
+    return {
+      ...formatted,
+      ...formatOverride?.(data)
+    };
   };
 }
 
-// src/constants.ts
-var etherUnits = {
-  gwei: 9,
-  wei: 18
-};
-var gweiUnits = {
-  ether: -9,
-  wei: 9
-};
-var weiUnits = {
-  ether: -18,
-  gwei: -9
-};
+// src/utils/formatters/transaction.ts
 var transactionType = {
   "0x0": "legacy",
   "0x1": "eip2930",
   "0x2": "eip1559"
 };
-
-// src/utils/formatters/transaction.ts
 function formatTransaction(transaction) {
   const transaction_ = {
     ...transaction,
@@ -2067,6 +2525,7 @@ function formatTransaction(transaction) {
   }
   return transaction_;
 }
+var defineTransaction = defineFormatter({ format: formatTransaction });
 
 // src/utils/formatters/block.ts
 function formatBlock(block) {
@@ -2088,6 +2547,21 @@ function formatBlock(block) {
     totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
   };
 }
+var defineBlock = defineFormatter({ format: formatBlock });
+
+// src/utils/formatters/extract.ts
+function extract(value, { formatter }) {
+  if (!formatter)
+    return {};
+  const keys = Object.keys(formatter({}));
+  return keys.reduce((data, key) => {
+    if (value?.hasOwnProperty(key)) {
+      ;
+      data[key] = value[key];
+    }
+    return data;
+  }, {});
+}
 
 // src/utils/formatters/feeHistory.ts
 function formatFeeHistory(feeHistory) {
@@ -2101,11 +2575,6 @@ function formatFeeHistory(feeHistory) {
   };
 }
 
-// src/utils/formatters/format.ts
-function format3(data, { formatter }) {
-  return formatter(data);
-}
-
 // src/utils/formatters/log.ts
 function formatLog(log) {
   return {
@@ -2134,6 +2603,9 @@ function formatTransactionReceipt(transactionReceipt) {
     type: transactionReceipt.type ? transactionType[transactionReceipt.type] : null
   };
 }
+var defineTransactionReceipt = defineFormatter({
+  format: formatTransactionReceipt
+});
 
 // src/utils/formatters/transactionRequest.ts
 function formatTransactionRequest(transactionRequest) {
@@ -2147,123 +2619,28 @@ function formatTransactionRequest(transactionRequest) {
     value: typeof transactionRequest.value !== "undefined" ? numberToHex(transactionRequest.value) : void 0
   };
 }
+var defineTransactionRequest = defineFormatter({
+  format: formatTransactionRequest
+});
 
-// 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/rpc.ts
+import fetch from "isomorphic-unfetch";
+import WebSocket from "isomorphic-ws";
 
-// 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/stringify.ts
+function stringify(value) {
+  return JSON.stringify(
+    value,
+    (_, value2) => typeof value2 === "bigint" ? value2.toString() : value2
+  );
 }
 
 // src/utils/rpc.ts
 var id = 0;
 async function http(url, {
   body,
-  retryDelay = 100,
-  retryCount = 2,
+  retryDelay = 150,
+  retryCount = 3,
   timeout = 0
 }) {
   const response = await withRetry(
@@ -2290,7 +2667,7 @@ async function http(url, {
         const retryAfter = data2?.headers.get("Retry-After");
         if (retryAfter?.match(/\d/))
           return parseInt(retryAfter) * 1e3;
-        return ~~((Math.random() + 0.5) * (1 << count)) * retryDelay;
+        return ~~(1 << count) * retryDelay;
       },
       retryCount,
       shouldRetryOnResponse: async ({ data: data2 }) => {
@@ -2420,6 +2797,20 @@ var rpc = {
   webSocketAsync
 };
 
+// src/utils/unit/constants.ts
+var etherUnits = {
+  gwei: 9,
+  wei: 18
+};
+var gweiUnits = {
+  ether: -9,
+  wei: 9
+};
+var weiUnits = {
+  ether: -18,
+  gwei: -9
+};
+
 // src/utils/unit/formatUnit.ts
 function formatUnit(value, decimals) {
   let display = value.toString();
@@ -2478,11 +2869,11 @@ function parseGwei(ether, unit = "wei") {
 }
 
 export {
-  stringify,
   BaseError,
   AbiConstructorNotFoundError,
   AbiConstructorParamsNotFoundError,
   AbiDecodingDataSizeInvalidError,
+  AbiDecodingZeroDataError,
   AbiEncodingArrayLengthMismatchError,
   AbiEncodingLengthMismatchError,
   AbiErrorInputsNotFoundError,
@@ -2498,29 +2889,10 @@ export {
   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,
+  ChainDoesNotSupportContract,
+  multicall3Abi,
+  panicReasons,
+  concat,
   isBytes,
   isHex,
   pad,
@@ -2570,40 +2942,77 @@ export {
   isAddressEqual,
   encodeAbi,
   decodeAbi,
-  formatAbiItemWithParams,
+  formatAbiItem,
   decodeErrorResult,
+  decodeEventLog,
   decodeFunctionData,
+  getAbiItem,
   decodeFunctionResult,
   encodeDeployData,
-  getAbiItem,
   encodeErrorResult,
   encodeEventTopics,
   encodeFunctionData,
   encodeFunctionResult,
   formatAbiItemWithArgs,
+  getCache,
+  withCache,
+  wait,
+  isNonDeterministicError,
   buildRequest,
-  etherUnits,
-  gweiUnits,
-  weiUnits,
+  defineChain,
+  format3 as format,
+  defineFormatter,
   transactionType,
   formatTransaction,
+  defineTransaction,
   formatBlock,
+  defineBlock,
+  extract,
   formatFeeHistory,
-  format3 as format,
   formatLog,
   formatTransactionReceipt,
+  defineTransactionReceipt,
   formatTransactionRequest,
-  getCache,
-  withCache,
-  wait,
+  defineTransactionRequest,
+  stringify,
   getSocket,
   rpc,
+  etherUnits,
+  gweiUnits,
+  weiUnits,
   formatUnit,
   formatEther,
   formatGwei,
   parseUnit,
   parseEther,
   parseGwei,
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+  ContractFunctionZeroDataError,
+  RawContractError,
+  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,
@@ -2614,3 +3023,4 @@ export {
   WaitForTransactionReceiptTimeoutError,
   UrlRequiredError
 };
+//# sourceMappingURL=chunk-SD5X7F4U.mjs.map