viem 0.0.1-sushi.26 → 0.1.0

package/dist/{chunk-SD5X7F4U.mjs → chunk-I7AINPMM.mjs}

@@ -5,11 +5,19 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
+// src/utils/abi/index.ts
+import {
+  parseAbi,
+  parseAbiItem,
+  parseAbiParameter,
+  parseAbiParameters
+} from "abitype";
+
 // package.json
 var package_default = {
   name: "viem",
   description: "TypeScript Interface for Ethereum",
-  version: "0.0.1-alpha.25",
+  version: "0.1.0",
   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,30 +26,47 @@ var package_default = {
     changeset: "changeset",
     "changeset:release": "pnpm build && changeset publish",
     "changeset:version": "changeset version && pnpm install --lockfile-only",
+    clean: "rimraf dist abi chains contract ens public test utils wallet window",
     "contracts:build": "wagmi generate",
     dev: "DEV=true tsup",
     "dev:docs": "pnpm -r --filter site dev",
-    format: "rome format src/ test/ --write",
+    format: "rome format src/ --write",
     lint: "rome check .",
     "lint:fix": "pnpm lint --apply-suggested",
-    playground: "pnpm --filter playground-dev dev",
+    playground: "pnpm --filter playground-browser dev",
     postinstall: "pnpm dev && pnpm contracts:build",
     preinstall: "npx only-allow pnpm",
-    prepublishOnly: "pnpm ts-node scripts/generate-package-json.ts",
+    prepublishOnly: "pnpm bun scripts/prepublishOnly.ts",
     prepare: "npx simple-git-hooks",
     test: "vitest dev --no-threads",
+    "test:cov": "vitest dev --coverage --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",
+    "ts-node": "bun",
     typecheck: "tsc --noEmit"
   },
+  tsup: {
+    entry: [
+      "src/index.ts",
+      "src/abi.ts",
+      "src/chains.ts",
+      "src/contract.ts",
+      "src/ens.ts",
+      "src/public.ts",
+      "src/test.ts",
+      "src/utils/index.ts",
+      "src/wallet.ts",
+      "src/window.ts"
+    ]
+  },
   files: [
+    "/abi",
+    "/dist",
     "/chains",
     "/contract",
-    "/dist",
     "/ens",
-    "/src",
-    "/types",
+    "/public",
+    "/test",
     "/utils",
     "/wallet",
     "/window"
@@ -49,47 +74,52 @@ var package_default = {
   exports: {
     ".": {
       types: "./dist/index.d.ts",
-      module: "./dist/index.mjs",
+      module: "./dist/index.mts",
       default: "./dist/index.js"
     },
+    "./abi": {
+      types: "./dist/abi.d.ts",
+      module: "./dist/abi.mts",
+      default: "./dist/abi.js"
+    },
     "./chains": {
       types: "./dist/chains.d.ts",
-      module: "./dist/chains.mjs",
+      module: "./dist/chains.mts",
       default: "./dist/chains.js"
     },
     "./contract": {
       types: "./dist/contract.d.ts",
-      module: "./dist/contract.mjs",
+      module: "./dist/contract.mts",
       default: "./dist/contract.js"
     },
     "./ens": {
       types: "./dist/ens.d.ts",
-      module: "./dist/ens.mjs",
+      module: "./dist/ens.mts",
       default: "./dist/ens.js"
     },
     "./public": {
       types: "./dist/public.d.ts",
-      module: "./dist/public.mjs",
+      module: "./dist/public.mts",
       default: "./dist/public.js"
     },
     "./test": {
       types: "./dist/test.d.ts",
-      module: "./dist/test.mjs",
+      module: "./dist/test.mts",
       default: "./dist/test.js"
     },
     "./utils": {
       types: "./dist/utils/index.d.ts",
-      module: "./dist/utils/index.mjs",
+      module: "./dist/utils/index.mts",
       default: "./dist/utils/index.js"
     },
     "./wallet": {
       types: "./dist/wallet.d.ts",
-      module: "./dist/wallet.mjs",
+      module: "./dist/wallet.mts",
       default: "./dist/wallet.js"
     },
     "./window": {
       types: "./dist/window.d.ts",
-      module: "./dist/window.mjs",
+      module: "./dist/window.mts",
       default: "./dist/window.js"
     },
     "./package.json": "./package.json"
@@ -101,9 +131,8 @@ var package_default = {
   dependencies: {
     "@noble/hashes": "^1.1.2",
     "@wagmi/chains": "~0.2.8",
-    abitype: "~0.3.0",
+    abitype: "~0.6.2",
     "idna-uts46-hx": "^4.1.2",
-    "isomorphic-unfetch": "^4.0.2",
     "isomorphic-ws": "^5.0.0",
     ws: "^8.12.0"
   },
@@ -117,24 +146,23 @@ var package_default = {
     "@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",
+    "@vitest/coverage-c8": "^0.29.2",
+    "@vitest/ui": "^0.29.2",
     "@wagmi/cli": "^0.1.6",
+    bun: "^0.5.5",
     bundlewatch: "^0.3.3",
     dedent: "^0.7.0",
-    esbuild: "^0.16.17",
-    "esbuild-register": "^3.4.2",
     ethers: "^5.7.2",
     "ethers@6": "npm:ethers@^6.0.2",
     execa: "^6.1.0",
     "fs-extra": "^10.1.0",
+    rimraf: "^4.1.2",
     rome: "^11.0.0",
     "simple-git-hooks": "^2.8.1",
     tsup: "^6.6.0",
     typescript: "^4.9.4",
-    vite: "^3.2.5",
-    vitest: "^0.25.8",
-    web3: "^1.8.1"
+    vite: "^4.1.4",
+    vitest: "~0.29.2"
   },
   license: "MIT",
   repository: "wagmi-dev/viem",
@@ -150,17 +178,21 @@ var package_default = {
     "web3"
   ],
   "simple-git-hooks": {
-    "pre-commit": "pnpm format & pnpm lint:fix"
+    "pre-commit": "pnpm format && pnpm lint:fix"
   },
   pnpm: {
     patchedDependencies: {
-      "vitepress@1.0.0-alpha.34": "patches/vitepress@1.0.0-alpha.34.patch"
+      "vitepress@1.0.0-alpha.49": "patches/vitepress@1.0.0-alpha.49.patch"
     }
   }
 };
 
+// src/errors/utils.ts
+var getContractAddress = (address) => address;
+var getUrl = (url) => url;
+var getVersion = () => `${package_default.name}@${package_default.version}`;
+
 // src/errors/base.ts
-var version = process.env.TEST ? "1.0.2" : package_default.version;
 var BaseError = class extends Error {
   constructor(shortMessage, args = {}) {
     const details = args.cause instanceof BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
@@ -171,7 +203,7 @@ var BaseError = class extends Error {
       ...args.metaMessages ? [...args.metaMessages, ""] : [],
       ...docsPath5 ? [`Docs: https://viem.sh${docsPath5}`] : [],
       ...details ? [`Details: ${details}`] : [],
-      `Version: viem@${version}`
+      `Version: ${getVersion()}`
     ].join("\n");
     super(message);
     __publicField(this, "details");
@@ -250,6 +282,16 @@ var AbiEncodingArrayLengthMismatchError = class extends BaseError {
     __publicField(this, "name", "AbiEncodingArrayLengthMismatchError");
   }
 };
+var AbiEncodingBytesSizeMismatchError = class extends BaseError {
+  constructor({ expectedSize, value }) {
+    super(
+      `Size of bytes "${value}" (bytes${size(
+        value
+      )}) does not match expected size (bytes${expectedSize}).`
+    );
+    __publicField(this, "name", "AbiEncodingBytesSizeMismatchError");
+  }
+};
 var AbiEncodingLengthMismatchError = class extends BaseError {
   constructor({
     expectedLength,
@@ -382,6 +424,15 @@ var AbiFunctionSignatureNotFoundError = class extends BaseError {
     __publicField(this, "name", "AbiFunctionSignatureNotFoundError");
   }
 };
+var BytesSizeMismatchError = class extends BaseError {
+  constructor({
+    expectedSize,
+    givenSize
+  }) {
+    super(`Expected bytes${expectedSize}, got bytes${givenSize}.`);
+    __publicField(this, "name", "BytesSizeMismatchError");
+  }
+};
 var InvalidAbiEncodingTypeError = class extends BaseError {
   constructor(type, { docsPath: docsPath5 }) {
     super(
@@ -423,6 +474,12 @@ var InvalidDefinitionTypeError = class extends BaseError {
     __publicField(this, "name", "InvalidDefinitionTypeError");
   }
 };
+var UnsupportedPackedAbiType = class extends BaseError {
+  constructor(type) {
+    super(`Type "${type}" is not supported for packed encoding.`);
+    __publicField(this, "name", "UnsupportedPackedAbiType");
+  }
+};
 
 // src/errors/address.ts
 var InvalidAddressError = class extends BaseError {
@@ -471,6 +528,23 @@ var ChainDoesNotSupportContract = class extends BaseError {
     __publicField(this, "name", "ChainDoesNotSupportContract");
   }
 };
+var ChainMismatchError = class extends BaseError {
+  constructor({
+    chain,
+    currentChainId
+  }) {
+    super(
+      `The current chain (id: ${currentChainId}) does not match the chain passed to the request (id: ${chain.id} \u2013 ${chain.name}).`,
+      {
+        metaMessages: [
+          `Current Chain ID:  ${currentChainId}`,
+          `Expected Chain ID: ${chain.id} \u2013 ${chain.name}`
+        ]
+      }
+    );
+    __publicField(this, "name", "ChainMismatchError");
+  }
+};
 
 // src/constants/abis.ts
 var multicall3Abi = [
@@ -550,7 +624,159 @@ var solidityPanic = {
   type: "error"
 };
 
+// src/constants/unit.ts
+var etherUnits = {
+  gwei: 9,
+  wei: 18
+};
+var gweiUnits = {
+  ether: -9,
+  wei: 9
+};
+var weiUnits = {
+  ether: -18,
+  gwei: -9
+};
+
+// src/errors/transaction.ts
+function prettyPrint(args) {
+  const entries = Object.entries(args).map(([key, value]) => {
+    if (value === void 0 || value === false)
+      return null;
+    return [key, value];
+  }).filter(Boolean);
+  const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
+  return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
+}
+var FeeConflictError = class extends BaseError {
+  constructor() {
+    super(
+      [
+        "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
+        "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
+      ].join("\n")
+    );
+    __publicField(this, "name", "FeeConflictError");
+  }
+};
+var TransactionExecutionError = class extends BaseError {
+  constructor(cause, {
+    account,
+    docsPath: docsPath5,
+    chain,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value
+  }) {
+    const prettyArgs = prettyPrint({
+      chain: chain && `${chain?.name} (id: ${chain?.id})`,
+      from: account.address,
+      to,
+      value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency.symbol || "ETH"}`,
+      data,
+      gas,
+      gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
+      maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
+      maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
+      nonce
+    });
+    super(cause.shortMessage, {
+      cause,
+      docsPath: docsPath5,
+      metaMessages: [
+        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+        "Request Arguments:",
+        prettyArgs
+      ].filter(Boolean)
+    });
+    __publicField(this, "cause");
+    __publicField(this, "name", "TransactionExecutionError");
+    this.cause = cause;
+  }
+};
+var TransactionNotFoundError = class extends BaseError {
+  constructor({
+    blockHash,
+    blockNumber,
+    blockTag,
+    hash: hash2,
+    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 (hash2)
+      identifier = `Transaction with hash "${hash2}"`;
+    super(`${identifier} could not be found.`);
+    __publicField(this, "name", "TransactionNotFoundError");
+  }
+};
+var TransactionReceiptNotFoundError = class extends BaseError {
+  constructor({ hash: hash2 }) {
+    super(
+      `Transaction receipt with hash "${hash2}" 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: hash2 }) {
+    super(
+      `Timed out while waiting for transaction with hash "${hash2}" to be confirmed.`
+    );
+    __publicField(this, "name", "WaitForTransactionReceiptTimeoutError");
+  }
+};
+
 // src/errors/contract.ts
+var CallExecutionError = class extends BaseError {
+  constructor(cause, {
+    account,
+    docsPath: docsPath5,
+    chain,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value
+  }) {
+    const prettyArgs = prettyPrint({
+      from: account?.address,
+      to,
+      value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency.symbol || "ETH"}`,
+      data,
+      gas,
+      gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
+      maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
+      maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
+      nonce
+    });
+    super(cause.shortMessage, {
+      cause,
+      docsPath: docsPath5,
+      metaMessages: [
+        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+        "Raw Call Arguments:",
+        prettyArgs
+      ].filter(Boolean)
+    });
+    __publicField(this, "cause");
+    __publicField(this, "name", "CallExecutionError");
+    this.cause = cause;
+  }
+};
 var ContractFunctionExecutionError = class extends BaseError {
   constructor(cause, {
     abi,
@@ -568,6 +794,12 @@ var ContractFunctionExecutionError = class extends BaseError {
       includeName: false
     }) : void 0;
     const functionWithParams = abiItem ? formatAbiItem(abiItem, { includeName: true }) : void 0;
+    const prettyArgs = prettyPrint({
+      address: contractAddress && getContractAddress(contractAddress),
+      function: functionWithParams,
+      args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
+      sender
+    });
     super(
       cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`,
       {
@@ -575,11 +807,8 @@ var ContractFunctionExecutionError = class extends BaseError {
         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}`
+          "Contract Call:",
+          prettyArgs
         ].filter(Boolean)
       }
     );
@@ -626,8 +855,8 @@ var ContractFunctionRevertedError = class extends BaseError {
           includeName: false
         }) : void 0;
         metaMessages = [
-          errorWithParams ? `Error:     ${errorWithParams}` : "",
-          formattedArgs && formattedArgs !== "()" ? `Arguments: ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
+          errorWithParams ? `Error: ${errorWithParams}` : "",
+          formattedArgs && formattedArgs !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
         ];
       }
     } else if (message)
@@ -653,9 +882,9 @@ var ContractFunctionZeroDataError = class extends BaseError {
     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."
+        `  - 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");
@@ -735,6 +964,47 @@ var OffsetOutOfBoundsError = class extends BaseError {
   }
 };
 
+// src/errors/estimateGas.ts
+var EstimateGasExecutionError = class extends BaseError {
+  constructor(cause, {
+    account,
+    docsPath: docsPath5,
+    chain,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value
+  }) {
+    const prettyArgs = prettyPrint({
+      from: account.address,
+      to,
+      value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency.symbol || "ETH"}`,
+      data,
+      gas,
+      gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
+      maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
+      maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
+      nonce
+    });
+    super(cause.shortMessage, {
+      cause,
+      docsPath: docsPath5,
+      metaMessages: [
+        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+        "Estimate Gas Arguments:",
+        prettyArgs
+      ].filter(Boolean)
+    });
+    __publicField(this, "cause");
+    __publicField(this, "name", "EstimateGasExecutionError");
+    this.cause = cause;
+  }
+};
+
 // src/errors/log.ts
 var FilterTypeNotSupportedError = class extends BaseError {
   constructor(type) {
@@ -743,19 +1013,189 @@ var FilterTypeNotSupportedError = class extends BaseError {
   }
 };
 
+// src/errors/node.ts
+var ExecutionRevertedError = class extends BaseError {
+  constructor({
+    cause,
+    message
+  } = {}) {
+    const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
+    super(
+      `Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`,
+      {
+        cause
+      }
+    );
+    __publicField(this, "name", "ExecutionRevertedError");
+  }
+};
+__publicField(ExecutionRevertedError, "code", 3);
+__publicField(ExecutionRevertedError, "nodeMessage", /execution reverted/);
+var FeeCapTooHighError = class extends BaseError {
+  constructor({
+    cause,
+    maxFeePerGas
+  } = {}) {
+    super(
+      `The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`,
+      {
+        cause
+      }
+    );
+    __publicField(this, "name", "FeeCapTooHigh");
+  }
+};
+__publicField(FeeCapTooHighError, "nodeMessage", /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/);
+var FeeCapTooLowError = class extends BaseError {
+  constructor({
+    cause,
+    maxFeePerGas
+  } = {}) {
+    super(
+      `The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`,
+      {
+        cause
+      }
+    );
+    __publicField(this, "name", "FeeCapTooLow");
+  }
+};
+__publicField(FeeCapTooLowError, "nodeMessage", /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/);
+var NonceTooHighError = class extends BaseError {
+  constructor({ cause, nonce } = {}) {
+    super(
+      `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`,
+      { cause }
+    );
+    __publicField(this, "name", "NonceTooHighError");
+  }
+};
+__publicField(NonceTooHighError, "nodeMessage", /nonce too high/);
+var NonceTooLowError = class extends BaseError {
+  constructor({ cause, nonce } = {}) {
+    super(
+      [
+        `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
+        "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
+      ].join("\n"),
+      { cause }
+    );
+    __publicField(this, "name", "NonceTooLowError");
+  }
+};
+__publicField(NonceTooLowError, "nodeMessage", /nonce too low|transaction already imported/);
+var NonceMaxValueError = class extends BaseError {
+  constructor({ cause, nonce } = {}) {
+    super(
+      `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`,
+      { cause }
+    );
+    __publicField(this, "name", "NonceMaxValueError");
+  }
+};
+__publicField(NonceMaxValueError, "nodeMessage", /nonce has max value/);
+var InsufficientFundsError = class extends BaseError {
+  constructor({ cause } = {}) {
+    super(
+      [
+        "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
+      ].join("\n"),
+      {
+        cause,
+        metaMessages: [
+          "This error could arise when the account does not have enough funds to:",
+          " - pay for the total gas fee,",
+          " - pay for the value to send.",
+          " ",
+          "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
+          " - `gas` is the amount of gas needed for transaction to execute,",
+          " - `gas fee` is the gas fee,",
+          " - `value` is the amount of ether to send to the recipient."
+        ]
+      }
+    );
+    __publicField(this, "name", "InsufficientFundsError");
+  }
+};
+__publicField(InsufficientFundsError, "nodeMessage", /insufficient funds/);
+var IntrinsicGasTooHighError = class extends BaseError {
+  constructor({ cause, gas } = {}) {
+    super(
+      `The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`,
+      {
+        cause
+      }
+    );
+    __publicField(this, "name", "IntrinsicGasTooHighError");
+  }
+};
+__publicField(IntrinsicGasTooHighError, "nodeMessage", /intrinsic gas too high|gas limit reached/);
+var IntrinsicGasTooLowError = class extends BaseError {
+  constructor({ cause, gas } = {}) {
+    super(
+      `The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`,
+      {
+        cause
+      }
+    );
+    __publicField(this, "name", "IntrinsicGasTooLowError");
+  }
+};
+__publicField(IntrinsicGasTooLowError, "nodeMessage", /intrinsic gas too low/);
+var TransactionTypeNotSupportedError = class extends BaseError {
+  constructor({ cause }) {
+    super("The transaction type is not supported for this chain.", {
+      cause
+    });
+    __publicField(this, "name", "TransactionTypeNotSupportedError");
+  }
+};
+__publicField(TransactionTypeNotSupportedError, "nodeMessage", /transaction type not valid/);
+var TipAboveFeeCapError = class extends BaseError {
+  constructor({
+    cause,
+    maxPriorityFeePerGas,
+    maxFeePerGas
+  } = {}) {
+    super(
+      [
+        `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
+      ].join("\n"),
+      {
+        cause
+      }
+    );
+    __publicField(this, "name", "TipAboveFeeCapError");
+  }
+};
+__publicField(TipAboveFeeCapError, "nodeMessage", /max priority fee per gas higher than max fee per gas|tip higher than fee cap/);
+var UnknownNodeError = class extends BaseError {
+  constructor({ cause }) {
+    super(`An error occurred while executing: ${cause?.message}`, {
+      cause
+    });
+    __publicField(this, "name", "UnknownNodeError");
+  }
+};
+
 // src/errors/request.ts
 var RequestError = class extends BaseError {
-  constructor(err, { docsPath: docsPath5, shortMessage }) {
+  constructor(err, {
+    docsPath: docsPath5,
+    metaMessages,
+    shortMessage
+  }) {
     super(shortMessage, {
       cause: err,
-      docsPath: docsPath5
+      docsPath: docsPath5,
+      metaMessages
     });
     this.name = err.name;
   }
 };
 var RpcRequestError = class extends RequestError {
   constructor(err, { docsPath: docsPath5, shortMessage }) {
-    super(err, { docsPath: docsPath5, shortMessage });
+    super(err, { docsPath: docsPath5, metaMessages: err.metaMessages, shortMessage });
     __publicField(this, "code");
     this.code = err.code;
     this.name = err.name;
@@ -861,6 +1301,24 @@ var JsonRpcVersionUnsupportedError = class extends RpcRequestError {
     __publicField(this, "code", -32006);
   }
 };
+var UserRejectedRequestError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      shortMessage: "User rejected the request."
+    });
+    __publicField(this, "name", "UserRejectedRequestError");
+    __publicField(this, "code", 4001);
+  }
+};
+var SwitchChainError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      shortMessage: "An error occurred when attempting to switch chain."
+    });
+    __publicField(this, "name", "SwitchChainError");
+    __publicField(this, "code", 4902);
+  }
+};
 var UnknownRpcError = class extends RequestError {
   constructor(err) {
     super(err, {
@@ -875,24 +1333,27 @@ var HttpRequestError = class extends BaseError {
   constructor({
     body,
     details,
+    headers,
     status,
     url
   }) {
-    super(
-      [
-        "HTTP request failed.",
-        "",
-        `Status: ${status}`,
-        `URL: ${url}`,
+    super("HTTP request failed.", {
+      details,
+      metaMessages: [
+        status && `Status: ${status}`,
+        `URL: ${getUrl(url)}`,
         `Request body: ${stringify(body)}`
-      ].join("\n"),
-      {
-        details
-      }
-    );
+      ].filter(Boolean)
+    });
     __publicField(this, "name", "HttpRequestError");
+    __publicField(this, "body");
+    __publicField(this, "headers");
     __publicField(this, "status");
+    __publicField(this, "url");
+    this.body = body;
+    this.headers = headers;
     this.status = status;
+    this.url = url;
   }
 };
 var WebSocketRequestError = class extends BaseError {
@@ -901,17 +1362,10 @@ var WebSocketRequestError = class extends BaseError {
     details,
     url
   }) {
-    super(
-      [
-        "WebSocket request failed.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${stringify(body)}`
-      ].join("\n"),
-      {
-        details
-      }
-    );
+    super("WebSocket request failed.", {
+      details,
+      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`]
+    });
     __publicField(this, "name", "WebSocketRequestError");
   }
 };
@@ -921,18 +1375,11 @@ var RpcError = class extends BaseError {
     error,
     url
   }) {
-    super(
-      [
-        "RPC Request failed.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${stringify(body)}`
-      ].join("\n"),
-      {
-        cause: error,
-        details: error.message
-      }
-    );
+    super("RPC Request failed.", {
+      cause: error,
+      details: error.message,
+      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`]
+    });
     __publicField(this, "code");
     __publicField(this, "name", "RpcError");
     this.code = error.code;
@@ -943,73 +1390,21 @@ var TimeoutError = class extends BaseError {
     body,
     url
   }) {
+    super("The request took too long to respond.", {
+      details: "The request timed out.",
+      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`]
+    });
+    __publicField(this, "name", "TimeoutError");
+  }
+};
+
+// src/errors/transport.ts
+var UrlRequiredError = class extends BaseError {
+  constructor() {
     super(
-      [
-        "The request took too long to respond.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${stringify(body)}`
-      ].join("\n"),
+      "No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.",
       {
-        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: hash2,
-    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 (hash2)
-      identifier = `Transaction with hash "${hash2}"`;
-    super(`${identifier} could not be found.`);
-    __publicField(this, "name", "TransactionNotFoundError");
-  }
-};
-var TransactionReceiptNotFoundError = class extends BaseError {
-  constructor({ hash: hash2 }) {
-    super(
-      `Transaction receipt with hash "${hash2}" 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: hash2 }) {
-    super(
-      `Timed out while waiting for transaction with hash "${hash2}" 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"
+        docsPath: "/docs/clients/intro"
       }
     );
   }
@@ -1047,6 +1442,8 @@ function isBytes(value) {
     return false;
   if (typeof value !== "object")
     return false;
+  if (!("BYTES_PER_ELEMENT" in value))
+    return false;
   return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
 }
 
@@ -1066,6 +1463,8 @@ function pad(hexOrBytes, { dir, size: size2 = 32 } = {}) {
   return padBytes(hexOrBytes, { dir, size: size2 });
 }
 function padHex(hex_, { dir, size: size2 = 32 } = {}) {
+  if (size2 === null)
+    return hex_;
   let hex = hex_.replace("0x", "");
   if (hex.length > size2 * 2)
     throw new SizeExceedsPaddingSizeError({
@@ -1079,6 +1478,8 @@ function padHex(hex_, { dir, size: size2 = 32 } = {}) {
   )}`;
 }
 function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
+  if (size2 === null)
+    return bytes;
   if (bytes.length > size2)
     throw new SizeExceedsPaddingSizeError({
       size: bytes.length,
@@ -1143,10 +1544,10 @@ function sliceHex(value_, start, end) {
   return `0x${value}`;
 }
 
-// src/utils/encoding/encodeHex.ts
+// src/utils/encoding/toHex.ts
 var hexes = Array.from(
   { length: 256 },
-  (v, i) => i.toString(16).padStart(2, "0")
+  (_v, i) => i.toString(16).padStart(2, "0")
 );
 function boolToHex(value) {
   return `0x${Number(value)}`;
@@ -1158,7 +1559,7 @@ function bytesToHex(value) {
   }
   return `0x${hex}`;
 }
-function encodeHex(value) {
+function toHex(value) {
   if (typeof value === "number" || typeof value === "bigint")
     return numberToHex(value);
   if (typeof value === "string") {
@@ -1200,14 +1601,9 @@ function stringToHex(value) {
   return `0x${hex}`;
 }
 
-// src/utils/encoding/encodeBytes.ts
+// src/utils/encoding/toBytes.ts
 var encoder = new TextEncoder();
-function boolToBytes(value) {
-  const bytes = new Uint8Array(1);
-  bytes[0] = Number(value);
-  return bytes;
-}
-function encodeBytes(value) {
+function toBytes(value) {
   if (typeof value === "number" || typeof value === "bigint")
     return numberToBytes(value);
   if (typeof value === "boolean")
@@ -1216,6 +1612,11 @@ function encodeBytes(value) {
     return hexToBytes(value);
   return stringToBytes(value);
 }
+function boolToBytes(value) {
+  const bytes = new Uint8Array(1);
+  bytes[0] = Number(value);
+  return bytes;
+}
 function hexToBytes(hex_) {
   let hex = hex_.slice(2);
   if (hex.length % 2)
@@ -1226,7 +1627,7 @@ function hexToBytes(hex_) {
     const hexByte = hex.slice(start, start + 2);
     const byte = Number.parseInt(hexByte, 16);
     if (Number.isNaN(byte) || byte < 0)
-      throw new Error("Invalid byte sequence");
+      throw new BaseError(`Invalid byte sequence ("${hexByte}" in "${hex}").`);
     bytes[index] = byte;
   }
   return bytes;
@@ -1239,15 +1640,15 @@ function stringToBytes(value) {
   return encoder.encode(value);
 }
 
-// src/utils/encoding/encodeRlp.ts
-function encodeRlp(hexOrBytes, to_) {
+// src/utils/encoding/toRlp.ts
+function toRlp(hexOrBytes, to_) {
   const to = to_ || "hex";
   return format(bytesToRlp(parse(hexOrBytes)), to);
 }
 function parse(hexOrBytes) {
   if (Array.isArray(hexOrBytes))
     return hexOrBytes.map(parse);
-  return typeof hexOrBytes === "string" ? encodeBytes(hexOrBytes) : hexOrBytes;
+  return typeof hexOrBytes === "string" ? toBytes(hexOrBytes) : hexOrBytes;
 }
 function format(bytes, type = "bytes") {
   return type === "hex" ? bytesToHex(bytes) : bytes;
@@ -1264,11 +1665,11 @@ function bytesToRlp(bytes) {
 function encodeLength(length, offset) {
   if (length < 56)
     return [offset + length];
-  return [encodeBytes(length).length + offset + 55, ...encodeBytes(length)];
+  return [toBytes(length).length + offset + 55, ...toBytes(length)];
 }
 
-// src/utils/encoding/decodeHex.ts
-function decodeHex(hex, to) {
+// src/utils/encoding/fromHex.ts
+function fromHex(hex, to) {
   if (to === "number")
     return hexToNumber(hex);
   if (to === "bigint")
@@ -1305,8 +1706,8 @@ function hexToString(hex) {
   return new TextDecoder().decode(bytes);
 }
 
-// src/utils/encoding/decodeBytes.ts
-function decodeBytes(bytes, to) {
+// src/utils/encoding/fromBytes.ts
+function fromBytes(bytes, to) {
   if (to === "number")
     return bytesToNumber(bytes);
   if (to === "bigint")
@@ -1334,8 +1735,8 @@ function bytesToString(bytes) {
   return new TextDecoder().decode(bytes);
 }
 
-// src/utils/encoding/decodeRlp.ts
-function decodeRlp(value, to) {
+// src/utils/encoding/fromRlp.ts
+function fromRlp(value, to) {
   const bytes = parse2(value);
   const [data, consumed] = rlpToBytes(bytes);
   if (consumed < bytes.length)
@@ -1440,50 +1841,18 @@ function extractFunctionType(def) {
   return extractFunctionParts(def).type;
 }
 
-// src/utils/contract/getContractError.ts
-var EXECUTION_REVERTED_ERROR_CODE = 3;
-function getContractError(err, {
-  abi,
-  address,
-  args,
-  docsPath: docsPath5,
-  functionName,
-  sender
-}) {
-  const { code, data, message } = err instanceof RawContractError ? err : err.cause || {};
-  let cause = err;
-  if (err instanceof AbiDecodingZeroDataError) {
-    cause = new ContractFunctionZeroDataError({ functionName });
-  } else if (code === EXECUTION_REVERTED_ERROR_CODE && (data || message)) {
-    cause = new ContractFunctionRevertedError({
-      abi,
-      data,
-      functionName,
-      message
-    });
-  }
-  return new ContractFunctionExecutionError(cause, {
-    abi,
-    args,
-    contractAddress: address,
-    docsPath: docsPath5,
-    functionName,
-    sender
-  });
-}
-
 // src/utils/hash/keccak256.ts
 import { keccak_256 } from "@noble/hashes/sha3";
 function keccak256(value, to_) {
   const to = to_ || "hex";
-  const bytes = keccak_256(value);
+  const bytes = keccak_256(isHex(value) ? toBytes(value) : value);
   if (to === "bytes")
     return bytes;
-  return encodeHex(bytes);
+  return toHex(bytes);
 }
 
 // src/utils/hash/hashFunction.ts
-var hash = (value) => keccak256(encodeBytes(value));
+var hash = (value) => keccak256(toBytes(value));
 function hashFunction(def) {
   const name = extractFunctionName(def);
   const params = extractFunctionParams(def);
@@ -1492,20 +1861,25 @@ function hashFunction(def) {
   return hash(`${name}(${params.map(({ type }) => type).join(",")})`);
 }
 
-// src/utils/hash/getEventSignature.ts
-var getEventSignature = (event) => hashFunction(event);
+// src/utils/hash/getEventSelector.ts
+var getEventSelector = (event) => hashFunction(event);
 
-// src/utils/hash/getFunctionSignature.ts
-var getFunctionSignature = (fn) => slice(hashFunction(fn), 0, 4);
+// src/utils/hash/getFunctionSelector.ts
+var getFunctionSelector = (fn) => slice(hashFunction(fn), 0, 4);
+
+// src/utils/address/isAddress.ts
+var addressRegex = /^0x[a-fA-F0-9]{40}$/;
+function isAddress(address) {
+  return addressRegex.test(address);
+}
 
 // src/utils/address/getAddress.ts
-var addressRegex = /^(0x)?[a-fA-F0-9]{40}$/;
 function checksumAddress(address_) {
   const hexAddress = address_.substring(2).toLowerCase();
   const hash2 = keccak256(stringToBytes(hexAddress), "bytes");
   let address = hexAddress.split("");
   for (let i = 0; i < 40; i += 2) {
-    if (hash2?.[i >> 1] >> 4 >= 8 && address[i]) {
+    if (hash2[i >> 1] >> 4 >= 8 && address[i]) {
       address[i] = address[i].toUpperCase();
     }
     if ((hash2[i >> 1] & 15) >= 8 && address[i + 1]) {
@@ -1515,61 +1889,52 @@ function checksumAddress(address_) {
   return `0x${address.join("")}`;
 }
 function getAddress(address) {
-  if (!addressRegex.test(address))
+  if (!isAddress(address))
     throw new InvalidAddressError({ address });
   return checksumAddress(address);
 }
 
 // src/utils/address/getContractAddress.ts
-function getContractAddress(opts) {
+function getContractAddress2(opts) {
   if (opts.opcode === "CREATE2")
     return getCreate2Address(opts);
   return getCreateAddress(opts);
 }
 function getCreateAddress(opts) {
-  const from = encodeBytes(getAddress(opts.from));
-  let nonce = encodeBytes(opts.nonce);
+  const from = toBytes(getAddress(opts.from));
+  let nonce = toBytes(opts.nonce);
   if (nonce[0] === 0)
     nonce = new Uint8Array([]);
   return getAddress(
-    `0x${keccak256(encodeRlp([from, nonce], "bytes")).slice(26)}`
+    `0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`
   );
 }
 function getCreate2Address(opts) {
-  const from = encodeBytes(getAddress(opts.from));
-  const salt = pad(
-    isBytes(opts.salt) ? opts.salt : encodeBytes(opts.salt),
-    { size: 32 }
-  );
-  const bytecodeHash = encodeBytes(
+  const from = toBytes(getAddress(opts.from));
+  const salt = pad(isBytes(opts.salt) ? opts.salt : toBytes(opts.salt), {
+    size: 32
+  });
+  const bytecodeHash = toBytes(
     keccak256(
-      isBytes(opts.bytecode) ? opts.bytecode : encodeBytes(opts.bytecode)
+      isBytes(opts.bytecode) ? opts.bytecode : toBytes(opts.bytecode)
     )
   );
   return getAddress(
-    slice(
-      keccak256(concat([encodeBytes("0xff"), from, salt, bytecodeHash])),
-      12
-    )
+    slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12)
   );
 }
 
-// src/utils/address/isAddress.ts
-function isAddress(address) {
-  try {
-    return Boolean(getAddress(address));
-  } catch {
-    return false;
-  }
-}
-
 // src/utils/address/isAddressEqual.ts
 function isAddressEqual(a, b) {
-  return getAddress(a) === getAddress(b);
+  if (!isAddress(a))
+    throw new InvalidAddressError({ address: a });
+  if (!isAddress(b))
+    throw new InvalidAddressError({ address: b });
+  return a.toLowerCase() === b.toLowerCase();
 }
 
-// src/utils/abi/encodeAbi.ts
-function encodeAbi({ params, values }) {
+// src/utils/abi/encodeAbiParameters.ts
+function encodeAbiParameters(params, values) {
   if (params.length !== values.length)
     throw new AbiEncodingLengthMismatchError({
       expectedLength: params.length,
@@ -1619,13 +1984,13 @@ function prepareParam({
     return encodeNumber(value, { signed });
   }
   if (param.type.startsWith("bytes")) {
-    return encodeBytes2(value, { param });
+    return encodeBytes(value, { param });
   }
   if (param.type === "string") {
     return encodeString(value);
   }
   throw new InvalidAbiEncodingTypeError(param.type, {
-    docsPath: "/docs/contract/encodeAbi"
+    docsPath: "/docs/contract/encodeAbiParameters"
   });
 }
 function encodeParams(preparedParams) {
@@ -1653,6 +2018,8 @@ function encodeParams(preparedParams) {
   return concat([...staticParams, ...dynamicParams]);
 }
 function encodeAddress(value) {
+  if (!isAddress(value))
+    throw new InvalidAddressError({ address: value });
   return { dynamic: false, encoded: padHex(value.toLowerCase()) };
 }
 function encodeArray(value, {
@@ -1693,13 +2060,17 @@ function encodeArray(value, {
     encoded: concat(preparedParams.map(({ encoded }) => encoded))
   };
 }
-function encodeBytes2(value, { param }) {
+function encodeBytes(value, { param }) {
   const [_, size_] = param.type.split("bytes");
   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" }));
+      parts.push(
+        padHex(slice(value, i * 32, (i + 1) * 32), {
+          dir: "right"
+        })
+      );
     }
     return {
       dynamic: true,
@@ -1709,6 +2080,11 @@ function encodeBytes2(value, { param }) {
       ])
     };
   }
+  if (size(value) !== parseInt(size_))
+    throw new AbiEncodingBytesSizeMismatchError({
+      expectedSize: parseInt(size_),
+      value
+    });
   return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
 }
 function encodeBool(value) {
@@ -1743,7 +2119,8 @@ function encodeTuple(value, { param }) {
       value: value[index]
     });
     preparedParams.push(preparedParam);
-    dynamic = preparedParam.dynamic;
+    if (preparedParam.dynamic)
+      dynamic = true;
   }
   return {
     dynamic,
@@ -1758,19 +2135,16 @@ function getArrayComponents(type) {
   ) : void 0;
 }
 
-// src/utils/abi/decodeAbi.ts
-function decodeAbi({ data, params }) {
+// src/utils/abi/decodeAbiParameters.ts
+function decodeAbiParameters(params, data) {
   if (data === "0x" && params.length > 0)
     throw new AbiDecodingZeroDataError();
   if (size(data) % 32 !== 0)
     throw new AbiDecodingDataSizeInvalidError(size(data));
-  const values = decodeParams({
+  return decodeParams({
     data,
     params
   });
-  if (values.length === 0)
-    return void 0;
-  return values;
 }
 function decodeParams({
   data,
@@ -1807,7 +2181,7 @@ function decodeParam({
     return decodeString(data, { position });
   }
   if (param.type.startsWith("bytes")) {
-    return decodeBytes2(data, { param, position });
+    return decodeBytes(data, { param, position });
   }
   let value = slice(data, position, position + 32);
   if (param.type.startsWith("uint") || param.type.startsWith("int")) {
@@ -1820,7 +2194,7 @@ function decodeParam({
     return decodeBool(value);
   }
   throw new InvalidAbiDecodingTypeError(param.type, {
-    docsPath: "/docs/contract/decodeAbi"
+    docsPath: "/docs/contract/decodeAbiParameters"
   });
 }
 function decodeAddress(value) {
@@ -1880,12 +2254,15 @@ function decodeArray(data, {
 function decodeBool(value) {
   return { consumed: 32, value: hexToBool(value) };
 }
-function decodeBytes2(data, { param, position }) {
+function decodeBytes(data, { param, position }) {
   const [_, size2] = param.type.split("bytes");
   if (!size2) {
     const offset = hexToNumber(slice(data, position, position + 32));
     const length = hexToNumber(slice(data, offset, offset + 32));
-    const value2 = slice(data, offset + 32, offset + 32 + length);
+    const value2 = (
+      // If there is no length, we have zero data.
+      length === 0 ? "0x" : slice(data, offset + 32, offset + 32 + length)
+    );
     return { consumed: 32, value: value2 };
   }
   const value = slice(data, position, position + parseInt(size2));
@@ -1984,7 +2361,7 @@ function decodeErrorResult({
     throw new AbiDecodingZeroDataError();
   const abi_ = [...abi || [], solidityError, solidityPanic];
   const abiItem = abi_.find(
-    (x) => x.type === "error" && signature === getFunctionSignature(formatAbiItem(x))
+    (x) => x.type === "error" && signature === getFunctionSelector(formatAbiItem(x))
   );
   if (!abiItem)
     throw new AbiErrorSignatureNotFoundError(signature, {
@@ -1992,7 +2369,7 @@ function decodeErrorResult({
     });
   return {
     abiItem,
-    args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbi({ data: slice(data, 4), params: abiItem.inputs }) : void 0,
+    args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice(data, 4)) : void 0,
     errorName: abiItem.name
   };
 }
@@ -2005,7 +2382,7 @@ function decodeEventLog({
 }) {
   const [signature, ...argTopics] = topics;
   const abiItem = abi.find(
-    (x) => signature === getEventSignature(formatAbiItem(x))
+    (x) => signature === getEventSelector(formatAbiItem(x))
   );
   if (!(abiItem && "name" in abiItem))
     throw new AbiEventSignatureNotFoundError(signature, {
@@ -2027,9 +2404,9 @@ function decodeEventLog({
       args[param.name || i] = decodeTopic({ param, value: topic });
     }
   }
-  if (data) {
+  if (data && data !== "0x") {
     const params = inputs.filter((x) => !("indexed" in x && x.indexed));
-    const decodedData = decodeAbi({ params, data });
+    const decodedData = decodeAbiParameters(params, data);
     if (decodedData) {
       if (isUnnamed)
         args = [...args, ...decodedData];
@@ -2048,15 +2425,18 @@ function decodeEventLog({
 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 }) || [];
+  const decodedArg = decodeAbiParameters([param], value) || [];
   return decodedArg[0];
 }
 
 // src/utils/abi/decodeFunctionData.ts
-function decodeFunctionData({ abi, data }) {
+function decodeFunctionData({
+  abi,
+  data
+}) {
   const signature = slice(data, 0, 4);
   const description = abi.find(
-    (x) => signature === getFunctionSignature(formatAbiItem(x))
+    (x) => signature === getFunctionSelector(formatAbiItem(x))
   );
   if (!description)
     throw new AbiFunctionSignatureNotFoundError(signature, {
@@ -2064,12 +2444,16 @@ function decodeFunctionData({ abi, data }) {
     });
   return {
     functionName: description.name,
-    args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbi({ data: slice(data, 4), params: description.inputs }) : void 0
+    args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : void 0
   };
 }
 
 // src/utils/abi/getAbiItem.ts
-function getAbiItem({ abi, args = [], name }) {
+function getAbiItem({
+  abi,
+  args = [],
+  name
+}) {
   const abiItems = abi.filter((x) => "name" in x && x.name === name);
   if (abiItems.length === 0)
     return void 0;
@@ -2157,7 +2541,7 @@ function decodeFunctionResult({
     throw new AbiFunctionNotFoundError(functionName, { docsPath });
   if (!("outputs" in description))
     throw new AbiFunctionOutputsNotFoundError(functionName, { docsPath });
-  const values = decodeAbi({ data, params: description.outputs });
+  const values = decodeAbiParameters(description.outputs, data);
   if (values && values.length > 1)
     return values;
   if (values && values.length === 1)
@@ -2183,10 +2567,10 @@ function encodeDeployData({
     throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath2 });
   if (!description.inputs || description.inputs.length === 0)
     throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath2 });
-  const data = encodeAbi({
-    params: description.inputs,
-    values: args
-  });
+  const data = encodeAbiParameters(
+    description.inputs,
+    args
+  );
   return concatHex([bytecode, data]);
 }
 
@@ -2201,25 +2585,29 @@ function encodeErrorResult({ abi, errorName, args }) {
   if (!description)
     throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath3 });
   const definition = formatAbiItem(description);
-  const signature = getFunctionSignature(definition);
+  const signature = getFunctionSelector(definition);
   let data = "0x";
   if (args && args.length > 0) {
     if (!("inputs" in description && description.inputs))
       throw new AbiErrorInputsNotFoundError(errorName, { docsPath: docsPath3 });
-    data = encodeAbi({ params: description.inputs, values: args });
+    data = encodeAbiParameters(description.inputs, args);
   }
   return concatHex([signature, data]);
 }
 
 // src/utils/abi/encodeEventTopics.ts
 function encodeEventTopics({ abi, eventName, args }) {
-  const abiItem = getAbiItem({ abi, args, name: eventName });
+  const abiItem = getAbiItem({
+    abi,
+    args,
+    name: eventName
+  });
   if (!abiItem)
     throw new AbiEventNotFoundError(eventName, {
       docsPath: "/docs/contract/encodeEventTopics"
     });
   const definition = formatAbiItem(abiItem);
-  const signature = getEventSignature(definition);
+  const signature = getEventSelector(definition);
   let topics = [];
   if (args && "inputs" in abiItem) {
     const args_ = Array.isArray(args) ? args : abiItem.inputs?.map((x) => args[x.name]) ?? [];
@@ -2236,14 +2624,18 @@ function encodeArg({
   value
 }) {
   if (param.type === "string" || param.type === "bytes")
-    return keccak256(encodeBytes(value));
+    return keccak256(toBytes(value));
   if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
     throw new FilterTypeNotSupportedError(param.type);
-  return encodeAbi({ params: [param], values: [value] });
+  return encodeAbiParameters([param], [value]);
 }
 
 // src/utils/abi/encodeFunctionData.ts
-function encodeFunctionData({ abi, args, functionName }) {
+function encodeFunctionData({
+  abi,
+  args,
+  functionName
+}) {
   const description = getAbiItem({
     abi,
     args,
@@ -2254,11 +2646,11 @@ function encodeFunctionData({ abi, args, functionName }) {
       docsPath: "/docs/contract/encodeFunctionData"
     });
   const definition = formatAbiItem(description);
-  const signature = getFunctionSignature(definition);
-  const data = "inputs" in description && description.inputs ? encodeAbi({
-    params: description.inputs,
-    values: args ?? []
-  }) : void 0;
+  const signature = getFunctionSelector(definition);
+  const data = "inputs" in description && description.inputs ? encodeAbiParameters(
+    description.inputs,
+    args ?? []
+  ) : void 0;
   return concatHex([signature, data ?? "0x"]);
 }
 
@@ -2279,7 +2671,73 @@ function encodeFunctionResult({
   let values = Array.isArray(result) ? result : [result];
   if (description.outputs.length === 0 && !values[0])
     values = [];
-  return encodeAbi({ params: description.outputs, values });
+  return encodeAbiParameters(description.outputs, values);
+}
+
+// src/utils/regex.ts
+var arrayRegex = /^(.*)\[([0-9]*)\]$/;
+var bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+var integerRegex = /^(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)?$/;
+
+// src/utils/abi/encodePacked.ts
+function encodePacked(types, values) {
+  if (types.length !== values.length)
+    throw new AbiEncodingLengthMismatchError({
+      expectedLength: types.length,
+      givenLength: values.length
+    });
+  let data = [];
+  for (let i = 0; i < types.length; i++) {
+    const type = types[i];
+    const value = values[i];
+    data.push(encode(type, value));
+  }
+  return concat(data);
+}
+function encode(type, value, isArray = false) {
+  if (type === "address") {
+    let address = value;
+    if (!isAddress(address))
+      throw new InvalidAddressError({ address });
+    return pad(address.toLowerCase(), {
+      size: isArray ? 32 : null
+    });
+  }
+  if (type === "string")
+    return stringToHex(value);
+  if (type === "bytes")
+    return value;
+  if (type === "bool")
+    return pad(boolToHex(value), { size: isArray ? 32 : 1 });
+  const intMatch = type.match(integerRegex);
+  if (intMatch) {
+    const [_type, baseType, bits = "256"] = intMatch;
+    const size2 = parseInt(bits) / 8;
+    return numberToHex(value, {
+      size: isArray ? 32 : size2,
+      signed: baseType === "int"
+    });
+  }
+  const bytesMatch = type.match(bytesRegex);
+  if (bytesMatch) {
+    const [_type, size2] = bytesMatch;
+    if (parseInt(size2) !== (value.length - 2) / 2)
+      throw new BytesSizeMismatchError({
+        expectedSize: parseInt(size2),
+        givenSize: (value.length - 2) / 2
+      });
+    return pad(value, { dir: "right", size: isArray ? 32 : null });
+  }
+  const arrayMatch = type.match(arrayRegex);
+  if (arrayMatch && Array.isArray(value)) {
+    const [_type, childType] = arrayMatch;
+    let data = [];
+    for (let i = 0; i < value.length; i++) {
+      data.push(encode(childType, value[i], true));
+    }
+    return concat(data);
+  }
+  throw new UnsupportedPackedAbiType(type);
 }
 
 // src/utils/abi/formatAbiItemWithArgs.ts
@@ -2300,18 +2758,33 @@ function formatAbiItemWithArgs({
   ).join(", ")})`;
 }
 
+// src/utils/account.ts
+function getAccount(account) {
+  if (typeof account === "string") {
+    if (!isAddress(account))
+      throw new InvalidAddressError({ address: account });
+    return { address: account, type: "json-rpc" };
+  }
+  if (!isAddress(account.address))
+    throw new InvalidAddressError({ address: account.address });
+  return {
+    ...account,
+    type: "local"
+  };
+}
+
 // 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)
+function getCache(cacheKey2) {
+  const buildCache = (cacheKey3, cache) => ({
+    clear: () => cache.delete(cacheKey3),
+    get: () => cache.get(cacheKey3),
+    set: (data) => cache.set(cacheKey3, data)
   });
-  const promise = buildCache(cacheKey, promiseCache);
+  const promise = buildCache(cacheKey2, promiseCache);
   const response = buildCache(
-    cacheKey,
+    cacheKey2,
     responseCache
   );
   return {
@@ -2323,8 +2796,8 @@ function getCache(cacheKey) {
     response
   };
 }
-async function withCache(fn, { cacheKey, maxAge = Infinity }) {
-  const cache = getCache(cacheKey);
+async function withCache(fn, { cacheKey: cacheKey2, maxAge = Infinity }) {
+  const cache = getCache(cacheKey2);
   const response = cache.response.get();
   if (response && maxAge > 0) {
     const age = (/* @__PURE__ */ new Date()).getTime() - response.created.getTime();
@@ -2351,25 +2824,22 @@ async function wait(time) {
 function withRetry(fn, {
   delay: delay_ = 100,
   retryCount = 2,
-  shouldRetryOnResponse = () => false,
-  shouldRetryOnError = () => false
+  shouldRetry = () => true
 } = {}) {
   return new Promise((resolve, reject) => {
     const attemptRetry = async ({ count = 0 } = {}) => {
-      const retry = async ({ data } = {}) => {
-        const delay = typeof delay_ === "function" ? delay_({ count, data }) : delay_;
+      const retry = async ({ error }) => {
+        const delay = typeof delay_ === "function" ? delay_({ count, error }) : 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();
+        if (count < retryCount && await shouldRetry({ count, error: err }))
+          return retry({ error: err });
         reject(err);
       }
     };
@@ -2411,11 +2881,11 @@ function withTimeout(fn, {
 }
 
 // src/utils/buildRequest.ts
-var isNonDeterministicError = (error) => {
-  if (error instanceof UnknownRpcError)
-    return true;
+var isDeterministicError = (error) => {
   if ("code" in error)
-    return error.code === -32603 || error.code === -32e3 || error.code === -32005;
+    return error.code !== -32603 && error.code !== -32005;
+  if (error instanceof HttpRequestError && error.status)
+    return error.status !== 408 && error.status !== 413 && error.status !== 429 && error.status !== 500 && error.status !== 502 && error.status !== 503 && error.status !== 504;
   return false;
 };
 function buildRequest(request, {
@@ -2427,7 +2897,7 @@ function buildRequest(request, {
       try {
         return await request(args);
       } catch (err_) {
-        let err = err_;
+        const err = err_;
         if (err.code === -32700)
           throw new ParseRpcError(err);
         if (err.code === -32600)
@@ -2452,15 +2922,26 @@ function buildRequest(request, {
           throw new LimitExceededRpcError(err);
         if (err.code === -32006)
           throw new JsonRpcVersionUnsupportedError(err);
+        if (err.code === 4001)
+          throw new UserRejectedRequestError(err);
+        if (err.code === 4902)
+          throw new SwitchChainError(err);
         if (err_ instanceof BaseError)
           throw err_;
         throw new UnknownRpcError(err);
       }
     },
     {
-      delay: ({ count }) => ~~(1 << count) * retryDelay,
+      delay: ({ count, error }) => {
+        if (error && error instanceof HttpRequestError) {
+          const retryAfter = error?.headers?.get("Retry-After");
+          if (retryAfter?.match(/\d/))
+            return parseInt(retryAfter) * 1e3;
+        }
+        return ~~(1 << count) * retryDelay;
+      },
       retryCount,
-      shouldRetryOnError: ({ error }) => isNonDeterministicError(error)
+      shouldRetry: ({ error }) => !isDeterministicError(error)
     }
   );
 }
@@ -2504,6 +2985,7 @@ function formatTransaction(transaction) {
   const transaction_ = {
     ...transaction,
     blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
+    chainId: transaction.chainId ? hexToNumber(transaction.chainId) : void 0,
     gas: transaction.gas ? BigInt(transaction.gas) : void 0,
     gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
     maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
@@ -2576,12 +3058,13 @@ function formatFeeHistory(feeHistory) {
 }
 
 // src/utils/formatters/log.ts
-function formatLog(log) {
+function formatLog(log, { args, eventName } = {}) {
   return {
     ...log,
     blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
     logIndex: log.logIndex ? BigInt(log.logIndex) : null,
-    transactionIndex: log.transactionIndex ? BigInt(log.transactionIndex) : null
+    transactionIndex: log.transactionIndex ? BigInt(log.transactionIndex) : null,
+    ...eventName ? { args, eventName } : {}
   };
 }
 
@@ -2597,7 +3080,7 @@ function formatTransactionReceipt(transactionReceipt) {
     cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
     effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
     gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
-    logs: transactionReceipt.logs ? transactionReceipt.logs.map(formatLog) : null,
+    logs: transactionReceipt.logs ? transactionReceipt.logs.map((log) => formatLog(log)) : null,
     transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
     status: transactionReceipt.status ? statuses[transactionReceipt.status] : null,
     type: transactionReceipt.type ? transactionType[transactionReceipt.type] : null
@@ -2623,36 +3106,155 @@ var defineTransactionRequest = defineFormatter({
   format: formatTransactionRequest
 });
 
+// src/utils/errors/getNodeError.ts
+function containsNodeError(err) {
+  return err instanceof TransactionRejectedRpcError || err instanceof InvalidInputRpcError || err instanceof RpcError && err.code === ExecutionRevertedError.code;
+}
+function getNodeError(err, args) {
+  const message = err.details.toLowerCase();
+  if (FeeCapTooHighError.nodeMessage.test(message))
+    return new FeeCapTooHighError({
+      cause: err,
+      maxFeePerGas: args?.maxFeePerGas
+    });
+  else if (FeeCapTooLowError.nodeMessage.test(message))
+    return new FeeCapTooLowError({
+      cause: err,
+      maxFeePerGas: args?.maxFeePerGas
+    });
+  else if (NonceTooHighError.nodeMessage.test(message))
+    return new NonceTooHighError({ cause: err, nonce: args?.nonce });
+  else if (NonceTooLowError.nodeMessage.test(message))
+    return new NonceTooLowError({ cause: err, nonce: args?.nonce });
+  else if (NonceMaxValueError.nodeMessage.test(message))
+    return new NonceMaxValueError({ cause: err, nonce: args?.nonce });
+  else if (InsufficientFundsError.nodeMessage.test(message))
+    return new InsufficientFundsError({ cause: err });
+  else if (IntrinsicGasTooHighError.nodeMessage.test(message))
+    return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas });
+  else if (IntrinsicGasTooLowError.nodeMessage.test(message))
+    return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas });
+  else if (TransactionTypeNotSupportedError.nodeMessage.test(message))
+    return new TransactionTypeNotSupportedError({ cause: err });
+  else if (TipAboveFeeCapError.nodeMessage.test(message))
+    return new TipAboveFeeCapError({
+      cause: err,
+      maxFeePerGas: args?.maxFeePerGas,
+      maxPriorityFeePerGas: args?.maxPriorityFeePerGas
+    });
+  else if (message.match(ExecutionRevertedError.nodeMessage) || "code" in err.cause && err.cause?.code === ExecutionRevertedError.code)
+    return new ExecutionRevertedError({
+      cause: err,
+      message: err.cause.details
+    });
+  return new UnknownNodeError({
+    cause: err.cause.cause
+  });
+}
+
+// src/utils/errors/getCallError.ts
+function getCallError(err, {
+  docsPath: docsPath5,
+  ...args
+}) {
+  let cause = err;
+  if (containsNodeError(err))
+    cause = getNodeError(err, args);
+  return new CallExecutionError(cause, {
+    docsPath: docsPath5,
+    ...args
+  });
+}
+
+// src/utils/errors/getContractError.ts
+var EXECUTION_REVERTED_ERROR_CODE = 3;
+function getContractError(err, {
+  abi,
+  address,
+  args,
+  docsPath: docsPath5,
+  functionName,
+  sender
+}) {
+  const { code, data, message } = err instanceof RawContractError ? err : err instanceof CallExecutionError || err instanceof EstimateGasExecutionError ? err.cause?.cause?.cause || {} : err.cause || {};
+  let cause = err;
+  if (err instanceof AbiDecodingZeroDataError) {
+    cause = new ContractFunctionZeroDataError({ functionName });
+  } else if (code === EXECUTION_REVERTED_ERROR_CODE && (data || message)) {
+    cause = new ContractFunctionRevertedError({
+      abi,
+      data,
+      functionName,
+      message
+    });
+  }
+  return new ContractFunctionExecutionError(cause, {
+    abi,
+    args,
+    contractAddress: address,
+    docsPath: docsPath5,
+    functionName,
+    sender
+  });
+}
+
+// src/utils/errors/getEstimateGasError.ts
+function getEstimateGasError(err, {
+  docsPath: docsPath5,
+  ...args
+}) {
+  let cause = err;
+  if (containsNodeError(err))
+    cause = getNodeError(err, args);
+  return new EstimateGasExecutionError(cause, {
+    docsPath: docsPath5,
+    ...args
+  });
+}
+
+// src/utils/errors/getTransactionError.ts
+function getTransactionError(err, {
+  docsPath: docsPath5,
+  ...args
+}) {
+  let cause = err;
+  if (containsNodeError(err))
+    cause = getNodeError(err, args);
+  return new TransactionExecutionError(cause, {
+    docsPath: docsPath5,
+    ...args
+  });
+}
+
 // src/utils/rpc.ts
-import fetch from "isomorphic-unfetch";
 import WebSocket from "isomorphic-ws";
 
 // src/utils/stringify.ts
-function stringify(value) {
-  return JSON.stringify(
-    value,
-    (_, value2) => typeof value2 === "bigint" ? value2.toString() : value2
-  );
-}
+var stringify = (value, replacer, space) => JSON.stringify(
+  value,
+  (key, value_) => {
+    const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
+    return typeof replacer === "function" ? replacer(key, value2) : value2;
+  },
+  space
+);
 
 // src/utils/rpc.ts
 var id = 0;
-async function http(url, {
-  body,
-  retryDelay = 150,
-  retryCount = 3,
-  timeout = 0
-}) {
-  const response = await withRetry(
-    () => withTimeout(
+async function http(url, { body, fetchOptions = {}, timeout = 1e4 }) {
+  const { headers, method, signal: signal_ } = fetchOptions;
+  try {
+    const response = await withTimeout(
       async ({ signal }) => {
         const response2 = await fetch(url, {
+          ...fetchOptions,
+          body: stringify({ jsonrpc: "2.0", id: id++, ...body }),
           headers: {
+            ...headers,
             "Content-Type": "application/json"
           },
-          method: "POST",
-          body: stringify({ jsonrpc: "2.0", id: id++, ...body }),
-          signal: timeout > 0 ? signal : void 0
+          method: method || "POST",
+          signal: signal_ || (timeout > 0 ? signal : void 0)
         });
         return response2;
       },
@@ -2661,42 +3263,39 @@ async function http(url, {
         timeout,
         signal: true
       }
-    ),
-    {
-      delay: ({ count, data: data2 }) => {
-        const retryAfter = data2?.headers.get("Retry-After");
-        if (retryAfter?.match(/\d/))
-          return parseInt(retryAfter) * 1e3;
-        return ~~(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();
     }
-  );
-  let data;
-  if (response.headers.get("Content-Type")?.startsWith("application/json")) {
-    data = await response.json();
-  } else {
-    data = await response.text();
-  }
-  if (!response.ok) {
+    if (!response.ok) {
+      throw new HttpRequestError({
+        body,
+        details: stringify(data.error) || response.statusText,
+        headers: response.headers,
+        status: response.status,
+        url
+      });
+    }
+    if (data.error) {
+      throw new RpcError({ body, error: data.error, url });
+    }
+    return data;
+  } catch (err) {
+    if (err instanceof HttpRequestError)
+      throw err;
+    if (err instanceof RpcError)
+      throw err;
+    if (err instanceof TimeoutError)
+      throw err;
     throw new HttpRequestError({
       body,
-      details: stringify(data.error) || response.statusText,
-      status: response.status,
+      details: err.message,
       url
     });
   }
-  if (data.error) {
-    throw new RpcError({ body, error: data.error, url });
-  }
-  return data;
 }
 var sockets = /* @__PURE__ */ new Map();
 async function getSocket(url_) {
@@ -2775,7 +3374,7 @@ function webSocket(socket, {
 }
 async function webSocketAsync(socket, {
   body,
-  timeout = 0
+  timeout = 1e4
 }) {
   return withTimeout(
     () => new Promise(
@@ -2797,47 +3396,1584 @@ 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/transaction/assertRequest.ts
+function assertRequest(args) {
+  const { account, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
+  if (account && !isAddress(account.address))
+    throw new InvalidAddressError({ address: account.address });
+  if (to && !isAddress(to))
+    throw new InvalidAddressError({ address: to });
+  if (typeof gasPrice !== "undefined" && (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined"))
+    throw new FeeConflictError();
+  if (maxFeePerGas && maxFeePerGas > 2n ** 256n - 1n)
+    throw new FeeCapTooHighError({ maxFeePerGas });
+  if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
+    throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
+}
+
+// src/actions/public/call.ts
+async function call(client, args) {
+  const {
+    account,
+    blockNumber,
+    blockTag = "latest",
+    accessList,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value,
+    ...rest
+  } = args;
+  try {
+    assertRequest(args);
+    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
+    const formatter = client.chain?.formatters?.transactionRequest;
+    const request_ = format3(
+      {
+        from: account?.address,
+        accessList,
+        data,
+        gas,
+        gasPrice,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        to,
+        value,
+        // Pick out extra data that might exist on the chain's transaction request type.
+        ...extract(rest, { formatter })
+      },
+      {
+        formatter: formatter || formatTransactionRequest
+      }
+    );
+    const response = await client.request({
+      method: "eth_call",
+      params: [request_, blockNumberHex || blockTag]
+    });
+    if (response === "0x")
+      return { data: void 0 };
+    return { data: response };
+  } catch (err) {
+    throw getCallError(err, {
+      ...args,
+      chain: client.chain
+    });
+  }
+}
+
+// src/actions/public/simulateContract.ts
+async function simulateContract(client, {
+  abi,
+  address,
+  args,
+  functionName,
+  ...callRequest
+}) {
+  const calldata = encodeFunctionData({
+    abi,
+    args,
+    functionName
+  });
+  try {
+    const { data } = await call(client, {
+      data: calldata,
+      to: address,
+      ...callRequest
+    });
+    const result = decodeFunctionResult({
+      abi,
+      args,
+      functionName,
+      data: data || "0x"
+    });
+    return {
+      result,
+      request: {
+        abi,
+        address,
+        args,
+        functionName,
+        ...callRequest
+      }
+    };
+  } catch (err) {
+    throw getContractError(err, {
+      abi,
+      address,
+      args,
+      docsPath: "/docs/contract/simulateContract",
+      functionName,
+      sender: callRequest.account?.address
+    });
+  }
+}
+
+// src/actions/public/createPendingTransactionFilter.ts
+async function createPendingTransactionFilter(client) {
+  const id2 = await client.request({
+    method: "eth_newPendingTransactionFilter"
+  });
+  return { id: id2, type: "transaction" };
+}
+
+// src/actions/public/createBlockFilter.ts
+async function createBlockFilter(client) {
+  const id2 = await client.request({
+    method: "eth_newBlockFilter"
+  });
+  return { id: id2, type: "block" };
+}
+
+// src/actions/public/createEventFilter.ts
+async function createEventFilter(client, {
+  address,
+  args,
+  event,
+  fromBlock,
+  toBlock
+} = {}) {
+  let topics = [];
+  if (event)
+    topics = encodeEventTopics({
+      abi: [event],
+      eventName: event.name,
+      args
+    });
+  const id2 = await client.request({
+    method: "eth_newFilter",
+    params: [
+      {
+        address,
+        fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
+        toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
+        ...topics.length ? { topics } : {}
+      }
+    ]
+  });
+  return {
+    abi: event ? [event] : void 0,
+    args,
+    eventName: event ? event.name : void 0,
+    id: id2,
+    type: "event"
+  };
+}
+
+// src/actions/public/createContractEventFilter.ts
+async function createContractEventFilter(client, {
+  address,
+  abi,
+  args,
+  eventName,
+  fromBlock,
+  toBlock
+}) {
+  const topics = eventName ? encodeEventTopics({
+    abi,
+    args,
+    eventName
+  }) : void 0;
+  const id2 = await client.request({
+    method: "eth_newFilter",
+    params: [
+      {
+        address,
+        fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
+        toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
+        topics
+      }
+    ]
+  });
+  return {
+    abi,
+    args,
+    eventName,
+    id: id2,
+    type: "event"
+  };
+}
+
+// src/actions/public/estimateGas.ts
+async function estimateGas(client, args) {
+  try {
+    const {
+      account,
+      accessList,
+      blockNumber,
+      blockTag = "latest",
+      data,
+      gas,
+      gasPrice,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      nonce,
+      to,
+      value,
+      ...rest
+    } = args.account.type === "local" ? await prepareRequest(client, args) : args;
+    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
+    assertRequest(args);
+    const formatter = client.chain?.formatters?.transactionRequest;
+    const request = format3(
+      {
+        from: account.address,
+        accessList,
+        data,
+        gas,
+        gasPrice,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        to,
+        value,
+        // Pick out extra data that might exist on the chain's transaction request type.
+        ...extract(rest, { formatter })
+      },
+      {
+        formatter: formatter || formatTransactionRequest
+      }
+    );
+    const balance = await client.request({
+      method: "eth_estimateGas",
+      params: [request, blockNumberHex || blockTag]
+    });
+    return BigInt(balance);
+  } catch (err) {
+    throw getEstimateGasError(err, {
+      ...args,
+      chain: client.chain
+    });
+  }
+}
+
+// src/actions/public/estimateContractGas.ts
+async function estimateContractGas(client, {
+  abi,
+  address,
+  args,
+  functionName,
+  ...request
+}) {
+  const data = encodeFunctionData({
+    abi,
+    args,
+    functionName
+  });
+  try {
+    const gas = await estimateGas(client, {
+      data,
+      to: address,
+      ...request
+    });
+    return gas;
+  } catch (err) {
+    throw getContractError(err, {
+      abi,
+      address,
+      args,
+      docsPath: "/docs/contract/simulateContract",
+      functionName,
+      sender: request.account?.address
+    });
+  }
+}
+
+// src/actions/public/getBalance.ts
+async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
+  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
+  const balance = await client.request({
+    method: "eth_getBalance",
+    params: [address, blockNumberHex || blockTag]
+  });
+  return BigInt(balance);
+}
+
+// src/actions/public/getBlock.ts
+async function getBlock(client, {
+  blockHash,
+  blockNumber,
+  blockTag = "latest",
+  includeTransactions = false
+} = {}) {
+  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
+  let block = null;
+  if (blockHash) {
+    block = await client.request({
+      method: "eth_getBlockByHash",
+      params: [blockHash, includeTransactions]
+    });
+  } else {
+    block = await client.request({
+      method: "eth_getBlockByNumber",
+      params: [blockNumberHex || blockTag, includeTransactions]
+    });
+  }
+  if (!block)
+    throw new BlockNotFoundError({ blockHash, blockNumber });
+  return format3(block, {
+    formatter: client.chain?.formatters?.block || formatBlock
+  });
+}
+
+// src/actions/public/getBlockNumber.ts
+var cacheKey = (id2) => `blockNumber.${id2}`;
+function getBlockNumberCache(id2) {
+  return getCache(cacheKey(id2));
+}
+async function getBlockNumber(client, { maxAge = client.pollingInterval } = {}) {
+  const blockNumberHex = await withCache(
+    () => client.request({
+      method: "eth_blockNumber"
+    }),
+    { cacheKey: cacheKey(client.uid), maxAge }
+  );
+  return BigInt(blockNumberHex);
+}
+
+// src/actions/public/getBlockTransactionCount.ts
+async function getBlockTransactionCount(client, {
+  blockHash,
+  blockNumber,
+  blockTag = "latest"
+} = {}) {
+  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
+  let count = null;
+  if (blockHash) {
+    count = await client.request({
+      method: "eth_getBlockTransactionCountByHash",
+      params: [blockHash]
+    });
+  } else {
+    count = await client.request({
+      method: "eth_getBlockTransactionCountByNumber",
+      params: [blockNumberHex || blockTag]
+    });
+  }
+  return hexToNumber(count);
+}
+
+// src/actions/public/getBytecode.ts
+async function getBytecode(client, { address, blockNumber, blockTag = "latest" }) {
+  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
+  const hex = await client.request({
+    method: "eth_getCode",
+    params: [address, blockNumberHex || blockTag]
+  });
+  if (hex === "0x")
+    return void 0;
+  return hex;
+}
+
+// src/actions/public/getChainId.ts
+async function getChainId(client) {
+  const chainIdHex = await client.request({ method: "eth_chainId" });
+  return hexToNumber(chainIdHex);
+}
+
+// src/actions/public/getFeeHistory.ts
+async function getFeeHistory(client, {
+  blockCount,
+  blockNumber,
+  blockTag = "latest",
+  rewardPercentiles
+}) {
+  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
+  const feeHistory = await client.request({
+    method: "eth_feeHistory",
+    params: [
+      numberToHex(blockCount),
+      blockNumberHex || blockTag,
+      rewardPercentiles
+    ]
+  });
+  return formatFeeHistory(feeHistory);
+}
+
+// src/actions/public/getFilterChanges.ts
+async function getFilterChanges(client, {
+  filter
+}) {
+  const logs = await client.request({
+    method: "eth_getFilterChanges",
+    params: [filter.id]
+  });
+  return logs.map((log) => {
+    if (typeof log === "string")
+      return log;
+    const { eventName, args } = "abi" in filter && filter.abi ? decodeEventLog({
+      abi: filter.abi,
+      data: log.data,
+      topics: log.topics
+    }) : { eventName: void 0, args: void 0 };
+    return formatLog(log, { args, eventName });
+  });
+}
+
+// src/actions/public/getFilterLogs.ts
+async function getFilterLogs(client, { filter }) {
+  const logs = await client.request({
+    method: "eth_getFilterLogs",
+    params: [filter.id]
+  });
+  return logs.map((log) => {
+    const { eventName, args } = "abi" in filter && filter.abi ? decodeEventLog({
+      abi: filter.abi,
+      data: log.data,
+      topics: log.topics
+    }) : { eventName: void 0, args: void 0 };
+    return formatLog(log, { args, eventName });
+  });
+}
+
+// src/actions/public/getGasPrice.ts
+async function getGasPrice(client) {
+  const gasPrice = await client.request({
+    method: "eth_gasPrice"
+  });
+  return BigInt(gasPrice);
+}
+
+// src/actions/public/getLogs.ts
+async function getLogs(client, {
+  address,
+  blockHash,
+  fromBlock,
+  toBlock,
+  event,
+  args
+} = {}) {
+  let topics = [];
+  if (event)
+    topics = encodeEventTopics({
+      abi: [event],
+      eventName: event.name,
+      args
+    });
+  let logs;
+  if (blockHash) {
+    logs = await client.request({
+      method: "eth_getLogs",
+      params: [{ address, topics, blockHash }]
+    });
+  } else {
+    logs = await client.request({
+      method: "eth_getLogs",
+      params: [
+        {
+          address,
+          topics,
+          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
+          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
+        }
+      ]
+    });
+  }
+  return logs.map((log) => {
+    const { eventName, args: args2 } = event ? decodeEventLog({
+      abi: [event],
+      data: log.data,
+      topics: log.topics
+    }) : { eventName: void 0, args: void 0 };
+    return formatLog(log, { args: args2, eventName });
+  });
+}
+
+// src/actions/public/getStorageAt.ts
+async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
+  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
+  const data = await client.request({
+    method: "eth_getStorageAt",
+    params: [address, slot, blockNumberHex || blockTag]
+  });
+  return data;
+}
+
+// src/actions/public/getTransaction.ts
+async function getTransaction(client, {
+  blockHash,
+  blockNumber,
+  blockTag = "latest",
+  hash: hash2,
+  index
+}) {
+  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
+  let transaction = null;
+  if (hash2) {
+    transaction = await client.request({
+      method: "eth_getTransactionByHash",
+      params: [hash2]
+    });
+  } else if (blockHash) {
+    transaction = await client.request({
+      method: "eth_getTransactionByBlockHashAndIndex",
+      params: [blockHash, numberToHex(index)]
+    });
+  } else if (blockNumberHex || blockTag) {
+    transaction = await client.request({
+      method: "eth_getTransactionByBlockNumberAndIndex",
+      params: [blockNumberHex || blockTag, numberToHex(index)]
+    });
+  }
+  if (!transaction)
+    throw new TransactionNotFoundError({
+      blockHash,
+      blockNumber,
+      blockTag,
+      hash: hash2,
+      index
+    });
+  return format3(transaction, {
+    formatter: client.chain?.formatters?.transaction || formatTransaction
+  });
+}
+
+// src/actions/public/getTransactionConfirmations.ts
+async function getTransactionConfirmations(client, { hash: hash2, transactionReceipt }) {
+  const [blockNumber, transaction] = await Promise.all([
+    getBlockNumber(client),
+    hash2 ? getTransaction(client, { hash: hash2 }) : void 0
+  ]);
+  const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
+  if (!transactionBlockNumber)
+    return 0n;
+  return blockNumber - transactionBlockNumber + 1n;
+}
+
+// src/actions/public/getTransactionCount.ts
+async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
+  const count = await client.request({
+    method: "eth_getTransactionCount",
+    params: [address, blockNumber ? numberToHex(blockNumber) : blockTag]
+  });
+  return hexToNumber(count);
+}
+
+// src/actions/public/getTransactionReceipt.ts
+async function getTransactionReceipt(client, { hash: hash2 }) {
+  const receipt = await client.request({
+    method: "eth_getTransactionReceipt",
+    params: [hash2]
+  });
+  if (!receipt)
+    throw new TransactionReceiptNotFoundError({ hash: hash2 });
+  return format3(receipt, {
+    formatter: client.chain?.formatters?.transactionReceipt || formatTransactionReceipt
+  });
+}
+
+// src/actions/public/readContract.ts
+async function readContract(client, {
+  abi,
+  address,
+  args,
+  functionName,
+  ...callRequest
+}) {
+  const calldata = encodeFunctionData({
+    abi,
+    args,
+    functionName
+  });
+  try {
+    const { data } = await call(client, {
+      data: calldata,
+      to: address,
+      ...callRequest
+    });
+    return decodeFunctionResult({
+      abi,
+      args,
+      functionName,
+      data: data || "0x"
+    });
+  } catch (err) {
+    throw getContractError(err, {
+      abi,
+      address,
+      args,
+      docsPath: "/docs/contract/readContract",
+      functionName
+    });
+  }
+}
+
+// src/actions/public/multicall.ts
+async function multicall(client, args) {
+  const {
+    allowFailure = true,
+    blockNumber,
+    blockTag,
+    contracts,
+    multicallAddress
+  } = args;
+  const calls = contracts.map(({ abi, address, args: args2, functionName }) => {
+    try {
+      const callData = encodeFunctionData({
+        abi,
+        args: args2,
+        functionName
+      });
+      return {
+        allowFailure: true,
+        callData,
+        target: address
+      };
+    } catch (err) {
+      const error = getContractError(err, {
+        abi,
+        address,
+        args: args2,
+        docsPath: "/docs/contract/multicall",
+        functionName
+      });
+      if (!allowFailure)
+        throw error;
+      return {
+        allowFailure: true,
+        callData: "0x",
+        target: address
+      };
+    }
+  });
+  const results = await readContract(client, {
+    abi: multicall3Abi,
+    address: multicallAddress,
+    args: [calls],
+    blockNumber,
+    blockTag,
+    functionName: "aggregate3"
+  });
+  return results.map(({ returnData, success }, i) => {
+    const { callData } = calls[i];
+    const { abi, address, functionName, args: args2 } = contracts[i];
+    try {
+      if (callData === "0x")
+        throw new AbiDecodingZeroDataError();
+      if (!success)
+        throw new RawContractError({ data: returnData });
+      const result = decodeFunctionResult({
+        abi,
+        data: returnData,
+        functionName
+      });
+      return { result, status: "success" };
+    } catch (err) {
+      const error = getContractError(err, {
+        abi,
+        address,
+        args: args2,
+        docsPath: "/docs/contract/multicall",
+        functionName
+      });
+      if (!allowFailure)
+        throw error;
+      return { error, result: void 0, status: "failure" };
+    }
+  });
+}
+
+// src/actions/public/uninstallFilter.ts
+async function uninstallFilter(client, { filter }) {
+  return client.request({
+    method: "eth_uninstallFilter",
+    params: [filter.id]
+  });
+}
+
+// src/utils/observe.ts
+var listenersCache = /* @__PURE__ */ new Map();
+var cleanupCache = /* @__PURE__ */ new Map();
+var callbackCount = 0;
+function observe(observerId, callbacks, fn) {
+  const callbackId = ++callbackCount;
+  const getListeners = () => listenersCache.get(observerId) || [];
+  const unsubscribe = () => {
+    const listeners2 = getListeners();
+    listenersCache.set(
+      observerId,
+      listeners2.filter((cb) => cb.id !== callbackId)
+    );
+  };
+  const unwatch = () => {
+    const cleanup2 = cleanupCache.get(observerId);
+    if (getListeners().length === 1 && cleanup2)
+      cleanup2();
+    unsubscribe();
+  };
+  const listeners = getListeners();
+  listenersCache.set(observerId, [
+    ...listeners,
+    { id: callbackId, fns: callbacks }
+  ]);
+  if (listeners && listeners.length > 0)
+    return unwatch;
+  let emit = {};
+  for (const key in callbacks) {
+    emit[key] = (...args) => {
+      const listeners2 = getListeners();
+      if (listeners2.length === 0)
+        return;
+      listeners2.forEach((listener) => listener.fns[key]?.(...args));
+    };
+  }
+  const cleanup = fn(emit);
+  if (typeof cleanup === "function")
+    cleanupCache.set(observerId, cleanup);
+  return unwatch;
+}
+
+// src/actions/public/waitForTransactionReceipt.ts
+async function waitForTransactionReceipt(client, {
+  confirmations = 1,
+  hash: hash2,
+  onReplaced,
+  pollingInterval = client.pollingInterval,
+  timeout
+}) {
+  const observerId = JSON.stringify([
+    "waitForTransactionReceipt",
+    client.uid,
+    hash2
+  ]);
+  let transaction;
+  let replacedTransaction;
+  let receipt;
+  return new Promise((resolve, reject) => {
+    if (timeout)
+      setTimeout(
+        () => reject(new WaitForTransactionReceiptTimeoutError({ hash: hash2 })),
+        timeout
+      );
+    const _unobserve = observe(
+      observerId,
+      { onReplaced, resolve, reject },
+      (emit) => {
+        const unwatch = watchBlockNumber(client, {
+          emitMissed: true,
+          emitOnBegin: true,
+          pollingInterval,
+          async onBlockNumber(blockNumber) {
+            const done = async (fn) => {
+              unwatch();
+              fn();
+              _unobserve();
+            };
+            try {
+              if (receipt) {
+                if (blockNumber - receipt.blockNumber + 1n < confirmations)
+                  return;
+                done(() => emit.resolve(receipt));
+                return;
+              }
+              transaction = await getTransaction(client, { hash: hash2 });
+              receipt = await getTransactionReceipt(client, { hash: hash2 });
+              if (blockNumber - receipt.blockNumber + 1n < confirmations)
+                return;
+              done(() => emit.resolve(receipt));
+            } catch (err) {
+              if (transaction && (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError)) {
+                replacedTransaction = transaction;
+                const block = await getBlock(client, {
+                  blockNumber,
+                  includeTransactions: true
+                });
+                const replacementTransaction = block.transactions.find(
+                  ({ from, nonce }) => from === replacedTransaction.from && nonce === replacedTransaction.nonce
+                );
+                if (!replacementTransaction)
+                  return;
+                receipt = await getTransactionReceipt(client, {
+                  hash: replacementTransaction.hash
+                });
+                if (blockNumber - receipt.blockNumber + 1n < confirmations)
+                  return;
+                let reason = "replaced";
+                if (replacementTransaction.to === replacedTransaction.to && replacementTransaction.value === replacedTransaction.value) {
+                  reason = "repriced";
+                } else if (replacementTransaction.from === replacementTransaction.to && replacementTransaction.value === 0n) {
+                  reason = "cancelled";
+                }
+                done(() => {
+                  emit.onReplaced?.({
+                    reason,
+                    replacedTransaction,
+                    transaction: replacementTransaction,
+                    transactionReceipt: receipt
+                  });
+                  emit.resolve(receipt);
+                });
+              } else {
+                done(() => emit.reject(err));
+              }
+            }
+          }
+        });
+        return unwatch;
+      }
+    );
+  });
+}
+
+// src/utils/poll.ts
+function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
+  let active = true;
+  const unwatch = () => active = false;
+  const watch = async () => {
+    let data;
+    if (emitOnBegin)
+      data = await fn({ unpoll: unwatch });
+    const initialWait = await initialWaitTime?.(data) ?? interval;
+    await wait(initialWait);
+    const poll2 = async () => {
+      if (!active)
+        return;
+      await fn({ unpoll: unwatch });
+      await wait(interval);
+      poll2();
+    };
+    poll2();
+  };
+  watch();
+  return unwatch;
+}
+
+// src/actions/public/watchBlockNumber.ts
+function watchBlockNumber(client, {
+  emitOnBegin = false,
+  emitMissed = false,
+  onBlockNumber,
+  onError,
+  pollingInterval = client.pollingInterval
+}) {
+  const observerId = JSON.stringify([
+    "watchBlockNumber",
+    client.uid,
+    emitOnBegin,
+    emitMissed,
+    pollingInterval
+  ]);
+  let prevBlockNumber;
+  return observe(
+    observerId,
+    { onBlockNumber, onError },
+    (emit) => poll(
+      async () => {
+        try {
+          const blockNumber = await getBlockNumber(client, { maxAge: 0 });
+          if (prevBlockNumber) {
+            if (blockNumber === prevBlockNumber)
+              return;
+            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
+              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
+                emit.onBlockNumber(i, prevBlockNumber);
+                prevBlockNumber = i;
+              }
+            }
+          }
+          prevBlockNumber = blockNumber;
+          emit.onBlockNumber(blockNumber, prevBlockNumber);
+        } catch (err) {
+          emit.onError?.(err);
+        }
+      },
+      {
+        emitOnBegin,
+        interval: pollingInterval
+      }
+    )
+  );
+}
+
+// src/actions/public/watchBlocks.ts
+function watchBlocks(client, {
+  blockTag = "latest",
+  emitMissed = false,
+  emitOnBegin = false,
+  onBlock,
+  onError,
+  includeTransactions = false,
+  pollingInterval = client.pollingInterval
+}) {
+  const observerId = JSON.stringify([
+    "watchBlocks",
+    client.uid,
+    emitMissed,
+    emitOnBegin,
+    includeTransactions,
+    pollingInterval
+  ]);
+  let prevBlock;
+  return observe(
+    observerId,
+    { onBlock, onError },
+    (emit) => poll(
+      async () => {
+        try {
+          const block = await getBlock(client, {
+            blockTag,
+            includeTransactions
+          });
+          if (block.number && prevBlock?.number) {
+            if (block.number === prevBlock.number)
+              return;
+            if (block.number - prevBlock.number > 1 && emitMissed) {
+              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
+                const block2 = await getBlock(client, {
+                  blockNumber: i,
+                  includeTransactions
+                });
+                emit.onBlock(block2, prevBlock);
+                prevBlock = block2;
+              }
+            }
+          }
+          emit.onBlock(block, prevBlock);
+          prevBlock = block;
+        } catch (err) {
+          emit.onError?.(err);
+        }
+      },
+      {
+        emitOnBegin,
+        interval: pollingInterval
+      }
+    )
+  );
+}
+
+// src/actions/public/watchContractEvent.ts
+function watchContractEvent(client, {
+  abi,
+  address,
+  args,
+  batch = true,
+  eventName,
+  onError,
+  onLogs,
+  pollingInterval = client.pollingInterval
+}) {
+  const observerId = JSON.stringify([
+    "watchContractEvent",
+    address,
+    args,
+    batch,
+    client.uid,
+    eventName,
+    pollingInterval
+  ]);
+  return observe(observerId, { onLogs, onError }, (emit) => {
+    let currentBlockNumber;
+    let filter;
+    let initialized = false;
+    const unwatch = poll(
+      async () => {
+        if (!initialized) {
+          try {
+            filter = await createContractEventFilter(client, {
+              abi,
+              address,
+              args,
+              eventName
+            });
+          } catch {
+          }
+          initialized = true;
+          return;
+        }
+        try {
+          let logs;
+          if (filter) {
+            logs = await getFilterChanges(client, { filter });
+          } else {
+            const blockNumber = await getBlockNumber(client);
+            if (currentBlockNumber && currentBlockNumber !== blockNumber) {
+              logs = await getLogs(client, {
+                address,
+                args,
+                fromBlock: blockNumber,
+                toBlock: blockNumber,
+                event: getAbiItem({
+                  abi,
+                  name: eventName
+                })
+              });
+            } else {
+              logs = [];
+            }
+            currentBlockNumber = blockNumber;
+          }
+          if (logs.length === 0)
+            return;
+          if (batch)
+            emit.onLogs(logs);
+          else
+            logs.forEach((log) => emit.onLogs([log]));
+        } catch (err) {
+          emit.onError?.(err);
+        }
+      },
+      {
+        emitOnBegin: true,
+        interval: pollingInterval
+      }
+    );
+    return async () => {
+      if (filter)
+        await uninstallFilter(client, { filter });
+      unwatch();
+    };
+  });
+}
+
+// src/actions/public/watchEvent.ts
+function watchEvent(client, {
+  address,
+  args,
+  batch = true,
+  event,
+  onError,
+  onLogs,
+  pollingInterval = client.pollingInterval
+}) {
+  const observerId = JSON.stringify([
+    "watchEvent",
+    address,
+    args,
+    batch,
+    client.uid,
+    event,
+    pollingInterval
+  ]);
+  return observe(observerId, { onLogs, onError }, (emit) => {
+    let currentBlockNumber;
+    let filter;
+    let initialized = false;
+    const unwatch = poll(
+      async () => {
+        if (!initialized) {
+          try {
+            filter = await createEventFilter(client, {
+              address,
+              args,
+              event
+            });
+          } catch {
+          }
+          initialized = true;
+          return;
+        }
+        try {
+          let logs;
+          if (filter) {
+            logs = await getFilterChanges(client, { filter });
+          } else {
+            const blockNumber = await getBlockNumber(client);
+            if (currentBlockNumber && currentBlockNumber !== blockNumber) {
+              logs = await getLogs(client, {
+                address,
+                args,
+                fromBlock: blockNumber,
+                toBlock: blockNumber,
+                event
+              });
+            } else {
+              logs = [];
+            }
+            currentBlockNumber = blockNumber;
+          }
+          if (logs.length === 0)
+            return;
+          if (batch)
+            emit.onLogs(logs);
+          else
+            logs.forEach((log) => emit.onLogs([log]));
+        } catch (err) {
+          emit.onError?.(err);
+        }
+      },
+      {
+        emitOnBegin: true,
+        interval: pollingInterval
+      }
+    );
+    return async () => {
+      if (filter)
+        await uninstallFilter(client, { filter });
+      unwatch();
+    };
+  });
+}
+
+// src/actions/public/watchPendingTransactions.ts
+function watchPendingTransactions(client, {
+  batch = true,
+  onError,
+  onTransactions,
+  pollingInterval = client.pollingInterval
+}) {
+  const observerId = JSON.stringify([
+    "watchPendingTransactions",
+    client.uid,
+    batch,
+    pollingInterval
+  ]);
+  return observe(observerId, { onTransactions, onError }, (emit) => {
+    let filter;
+    const unwatch = poll(
+      async () => {
+        try {
+          if (!filter) {
+            try {
+              filter = await createPendingTransactionFilter(client);
+              return;
+            } catch (err) {
+              unwatch();
+              throw err;
+            }
+          }
+          const hashes = await getFilterChanges(client, { filter });
+          if (hashes.length === 0)
+            return;
+          if (batch)
+            emit.onTransactions(hashes);
+          else
+            hashes.forEach((hash2) => emit.onTransactions([hash2]));
+        } catch (err) {
+          emit.onError?.(err);
+        }
+      },
+      {
+        emitOnBegin: true,
+        interval: pollingInterval
+      }
+    );
+    return async () => {
+      if (filter)
+        await uninstallFilter(client, { filter });
+      unwatch();
+    };
+  });
+}
+
+// src/actions/test/dropTransaction.ts
+async function dropTransaction(client, { hash: hash2 }) {
+  return await client.request({
+    method: `${client.mode}_dropTransaction`,
+    params: [hash2]
+  });
+}
+
+// src/actions/test/getAutomine.ts
+async function getAutomine(client) {
+  return await client.request({
+    method: `${client.mode}_getAutomine`
+  });
+}
+
+// src/actions/test/getTxpoolContent.ts
+async function getTxpoolContent(client) {
+  return await client.request({
+    method: "txpool_content"
+  });
+}
+
+// src/actions/test/getTxpoolStatus.ts
+async function getTxpoolStatus(client) {
+  const { pending, queued } = await client.request({
+    method: "txpool_status"
+  });
+  return {
+    pending: hexToNumber(pending),
+    queued: hexToNumber(queued)
+  };
+}
+
+// src/actions/test/impersonateAccount.ts
+async function impersonateAccount(client, { address }) {
+  return await client.request({
+    method: `${client.mode}_impersonateAccount`,
+    params: [address]
+  });
+}
 
-// src/utils/unit/formatUnit.ts
-function formatUnit(value, decimals) {
-  let display = value.toString();
-  const negative = display.startsWith("-");
-  if (negative)
-    display = display.slice(1);
-  let [integer, fraction] = [
-    display.slice(0, display.length - decimals),
-    display.slice(display.length - decimals)
-  ];
-  fraction = fraction.padStart(decimals, "0");
-  fraction = fraction.replace(/(0+)$/, "");
-  return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
+// src/actions/test/increaseTime.ts
+async function increaseTime(client, { seconds }) {
+  return await client.request({
+    method: "evm_increaseTime",
+    params: [numberToHex(seconds)]
+  });
 }
 
-// src/utils/unit/formatEther.ts
-function formatEther(wei, unit = "wei") {
-  return formatUnit(wei, etherUnits[unit]);
+// src/actions/test/inspectTxpool.ts
+async function inspectTxpool(client) {
+  return await client.request({
+    method: "txpool_inspect"
+  });
 }
 
-// src/utils/unit/formatGwei.ts
-function formatGwei(wei, unit = "wei") {
-  return formatUnit(wei, gweiUnits[unit]);
+// src/actions/test/mine.ts
+async function mine(client, { blocks, interval }) {
+  return await client.request({
+    method: `${client.mode}_mine`,
+    params: [numberToHex(blocks), numberToHex(interval || 0)]
+  });
+}
+
+// src/actions/test/removeBlockTimestampInterval.ts
+async function removeBlockTimestampInterval(client) {
+  return await client.request({
+    method: `${client.mode}_removeBlockTimestampInterval`
+  });
+}
+
+// src/actions/test/reset.ts
+async function reset(client, { blockNumber, jsonRpcUrl } = {}) {
+  return await client.request({
+    method: `${client.mode}_reset`,
+    params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }]
+  });
+}
+
+// src/actions/test/revert.ts
+async function revert(client, { id: id2 }) {
+  return await client.request({
+    method: "evm_revert",
+    params: [id2]
+  });
+}
+
+// src/actions/test/sendUnsignedTransaction.ts
+async function sendUnsignedTransaction(client, request) {
+  const request_ = formatTransactionRequest(request);
+  const hash2 = await client.request({
+    method: "eth_sendUnsignedTransaction",
+    params: [request_]
+  });
+  return hash2;
+}
+
+// src/actions/test/setAutomine.ts
+async function setAutomine(client, enabled) {
+  return await client.request({
+    method: "evm_setAutomine",
+    params: [enabled]
+  });
+}
+
+// src/actions/test/setBalance.ts
+async function setBalance(client, { address, value }) {
+  return await client.request({
+    method: `${client.mode}_setBalance`,
+    params: [address, numberToHex(value)]
+  });
+}
+
+// src/actions/test/setBlockGasLimit.ts
+async function setBlockGasLimit(client, { gasLimit }) {
+  return await client.request({
+    method: "evm_setBlockGasLimit",
+    params: [numberToHex(gasLimit)]
+  });
+}
+
+// src/actions/test/setBlockTimestampInterval.ts
+async function setBlockTimestampInterval(client, { interval }) {
+  return await client.request({
+    method: `${client.mode}_setBlockTimestampInterval`,
+    params: [interval]
+  });
+}
+
+// src/actions/test/setCode.ts
+async function setCode(client, { address, bytecode }) {
+  return await client.request({
+    method: `${client.mode}_setCode`,
+    params: [address, bytecode]
+  });
+}
+
+// src/actions/test/setCoinbase.ts
+async function setCoinbase(client, { address }) {
+  return await client.request({
+    method: `${client.mode}_setCoinbase`,
+    params: [address]
+  });
+}
+
+// src/actions/test/setIntervalMining.ts
+async function setIntervalMining(client, { interval }) {
+  return await client.request({
+    method: "evm_setIntervalMining",
+    params: [interval]
+  });
+}
+
+// src/actions/test/setLoggingEnabled.ts
+async function setLoggingEnabled(client, enabled) {
+  return await client.request({
+    method: `${client.mode}_setLoggingEnabled`,
+    params: [enabled]
+  });
+}
+
+// src/actions/test/setMinGasPrice.ts
+async function setMinGasPrice(client, { gasPrice }) {
+  return await client.request({
+    method: `${client.mode}_setMinGasPrice`,
+    params: [numberToHex(gasPrice)]
+  });
+}
+
+// src/actions/test/setNextBlockBaseFeePerGas.ts
+async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
+  return await client.request({
+    method: `${client.mode}_setNextBlockBaseFeePerGas`,
+    params: [numberToHex(baseFeePerGas)]
+  });
+}
+
+// src/actions/test/setNextBlockTimestamp.ts
+async function setNextBlockTimestamp(client, { timestamp }) {
+  return await client.request({
+    method: "evm_setNextBlockTimestamp",
+    params: [numberToHex(timestamp)]
+  });
+}
+
+// src/actions/test/setNonce.ts
+async function setNonce(client, { address, nonce }) {
+  return await client.request({
+    method: `${client.mode}_setNonce`,
+    params: [address, numberToHex(nonce)]
+  });
+}
+
+// src/actions/test/setRpcUrl.ts
+async function setRpcUrl(client, jsonRpcUrl) {
+  return await client.request({
+    method: `${client.mode}_setRpcUrl`,
+    params: [jsonRpcUrl]
+  });
+}
+
+// src/actions/test/setStorageAt.ts
+async function setStorageAt(client, { address, index, value }) {
+  return await client.request({
+    method: `${client.mode}_setStorageAt`,
+    params: [
+      address,
+      typeof index === "number" ? numberToHex(index) : index,
+      value
+    ]
+  });
+}
+
+// src/actions/test/snapshot.ts
+async function snapshot(client) {
+  return await client.request({
+    method: "evm_snapshot"
+  });
+}
+
+// src/actions/test/stopImpersonatingAccount.ts
+async function stopImpersonatingAccount(client, { address }) {
+  return await client.request({
+    method: `${client.mode}_stopImpersonatingAccount`,
+    params: [address]
+  });
+}
+
+// src/actions/wallet/addChain.ts
+async function addChain(client, { chain }) {
+  const { id: id2, name, nativeCurrency, rpcUrls, blockExplorers } = chain;
+  await client.request({
+    method: "wallet_addEthereumChain",
+    params: [
+      {
+        chainId: numberToHex(id2),
+        chainName: name,
+        nativeCurrency,
+        rpcUrls: rpcUrls.default.http,
+        blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
+      }
+    ]
+  });
+}
+
+// src/actions/wallet/deployContract.ts
+function deployContract(walletClient, { abi, args, bytecode, ...request }) {
+  const calldata = encodeDeployData({
+    abi,
+    args,
+    bytecode
+  });
+  return sendTransaction(walletClient, {
+    ...request,
+    data: calldata
+  });
+}
+
+// src/actions/wallet/getAddresses.ts
+async function getAddresses(client) {
+  const addresses = await client.request({ method: "eth_accounts" });
+  return addresses.map((address) => checksumAddress(address));
+}
+
+// src/actions/wallet/getPermissions.ts
+async function getPermissions(client) {
+  const permissions = await client.request({ method: "wallet_getPermissions" });
+  return permissions;
+}
+
+// src/actions/wallet/requestAddresses.ts
+async function requestAddresses(client) {
+  const addresses = await client.request({ method: "eth_requestAccounts" });
+  return addresses.map((address) => getAddress(address));
+}
+
+// src/actions/wallet/requestPermissions.ts
+async function requestPermissions(client, permissions) {
+  return client.request({
+    method: "wallet_requestPermissions",
+    params: [permissions]
+  });
+}
+
+// src/actions/wallet/sendTransaction.ts
+async function sendTransaction(client, args) {
+  const {
+    account,
+    chain,
+    accessList,
+    assertChain = true,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value,
+    ...rest
+  } = args;
+  try {
+    assertRequest(args);
+    const currentChainId = await getChainId(client);
+    if (assertChain && chain && currentChainId !== chain?.id)
+      throw new ChainMismatchError({ chain, currentChainId });
+    if (account.type === "local") {
+      const chainId = chain?.id ?? currentChainId;
+      const request2 = await prepareRequest(client, {
+        account,
+        accessList,
+        chain,
+        data,
+        gas,
+        gasPrice,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        to,
+        value,
+        ...rest
+      });
+      const signedRequest = await account.signTransaction({
+        chainId,
+        ...request2
+      });
+      return await client.request({
+        method: "eth_sendRawTransaction",
+        params: [signedRequest]
+      });
+    }
+    const formatter = chain?.formatters?.transactionRequest;
+    const request = format3(
+      {
+        accessList,
+        data,
+        from: account.address,
+        gas,
+        gasPrice,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        to,
+        value,
+        // Pick out extra data that might exist on the chain's transaction request type.
+        ...extract(rest, { formatter })
+      },
+      {
+        formatter: formatter || formatTransactionRequest
+      }
+    );
+    return await client.request({
+      method: "eth_sendTransaction",
+      params: [request]
+    });
+  } catch (err) {
+    throw getTransactionError(err, args);
+  }
+}
+
+// src/actions/wallet/signMessage.ts
+async function signMessage(client, { account, data }) {
+  if (account.type === "local")
+    return account.signMessage(data);
+  return client.request({
+    method: "personal_sign",
+    params: [toHex(data), account.address]
+  });
+}
+
+// src/actions/wallet/switchChain.ts
+async function switchChain(client, { id: id2 }) {
+  await client.request({
+    method: "wallet_switchEthereumChain",
+    params: [
+      {
+        chainId: numberToHex(id2)
+      }
+    ]
+  });
+}
+
+// src/actions/wallet/watchAsset.ts
+async function watchAsset(client, params) {
+  const added = await client.request({
+    method: "wallet_watchAsset",
+    params: [params]
+  });
+  return added;
+}
+
+// src/actions/wallet/writeContract.ts
+async function writeContract(client, {
+  abi,
+  address,
+  args,
+  functionName,
+  ...request
+}) {
+  const data = encodeFunctionData({
+    abi,
+    args,
+    functionName
+  });
+  const hash2 = await sendTransaction(client, {
+    data,
+    to: address,
+    ...request
+  });
+  return hash2;
 }
 
-// src/utils/unit/parseUnit.ts
-function parseUnit(value, decimals) {
+// src/utils/unit/parseUnits.ts
+function parseUnits(value, decimals) {
   let [integer, fraction = "0"] = value.split(".");
   const negative = integer.startsWith("-");
   if (negative)
@@ -2858,14 +4994,79 @@ function parseUnit(value, decimals) {
   return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
 }
 
-// src/utils/unit/parseEther.ts
-function parseEther(ether, unit = "wei") {
-  return parseUnit(ether, etherUnits[unit]);
-}
-
 // src/utils/unit/parseGwei.ts
 function parseGwei(ether, unit = "wei") {
-  return parseUnit(ether, gweiUnits[unit]);
+  return parseUnits(ether, gweiUnits[unit]);
+}
+
+// src/utils/transaction/prepareRequest.ts
+var defaultTip = parseGwei("1.5");
+async function prepareRequest(client, args) {
+  const { account, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce } = args;
+  const block = await getBlock(client, { blockTag: "latest" });
+  const request = { ...args, from: account.address };
+  if (typeof nonce === "undefined")
+    request.nonce = await getTransactionCount(client, {
+      address: account.address,
+      blockTag: "pending"
+    });
+  if (block.baseFeePerGas) {
+    if (typeof gasPrice !== "undefined")
+      throw new BaseError("Chain does not support legacy `gasPrice`.");
+    if (typeof maxFeePerGas === "undefined") {
+      request.maxPriorityFeePerGas = maxPriorityFeePerGas ?? defaultTip;
+      request.maxFeePerGas = block.baseFeePerGas * 120n / 100n + request.maxPriorityFeePerGas;
+    } else {
+      if (typeof maxPriorityFeePerGas === "undefined" && maxFeePerGas < defaultTip)
+        throw new BaseError(
+          "`maxFeePerGas` cannot be less than the default `maxPriorityFeePerGas` (1.5 gwei)."
+        );
+      request.maxFeePerGas = maxFeePerGas;
+      request.maxPriorityFeePerGas = maxPriorityFeePerGas ?? defaultTip;
+    }
+  } else {
+    if (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined")
+      throw new BaseError("Chain does not support EIP-1559 fees.");
+    if (typeof gasPrice === "undefined")
+      request.gasPrice = await getGasPrice(client) * 120n / 100n;
+  }
+  if (typeof gas === "undefined")
+    request.gas = await estimateGas(client, {
+      ...request,
+      account: { address: account.address, type: "json-rpc" }
+    });
+  assertRequest(request);
+  return request;
+}
+
+// src/utils/unit/formatUnits.ts
+function formatUnits(value, decimals) {
+  let display = value.toString();
+  const negative = display.startsWith("-");
+  if (negative)
+    display = display.slice(1);
+  display = display.padStart(decimals, "0");
+  let [integer, fraction] = [
+    display.slice(0, display.length - decimals),
+    display.slice(display.length - decimals)
+  ];
+  fraction = fraction.replace(/(0+)$/, "");
+  return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
+}
+
+// src/utils/unit/formatEther.ts
+function formatEther(wei, unit = "wei") {
+  return formatUnits(wei, etherUnits[unit]);
+}
+
+// src/utils/unit/formatGwei.ts
+function formatGwei(wei, unit = "wei") {
+  return formatUnits(wei, gweiUnits[unit]);
+}
+
+// src/utils/unit/parseEther.ts
+function parseEther(ether, unit = "wei") {
+  return parseUnits(ether, etherUnits[unit]);
 }
 
 export {
@@ -2879,6 +5080,7 @@ export {
   AbiErrorInputsNotFoundError,
   AbiErrorNotFoundError,
   AbiErrorSignatureNotFoundError,
+  AbiEventSignatureNotFoundError,
   AbiEventNotFoundError,
   AbiFunctionNotFoundError,
   AbiFunctionOutputsNotFoundError,
@@ -2892,6 +5094,61 @@ export {
   ChainDoesNotSupportContract,
   multicall3Abi,
   panicReasons,
+  etherUnits,
+  gweiUnits,
+  weiUnits,
+  TransactionExecutionError,
+  TransactionNotFoundError,
+  TransactionReceiptNotFoundError,
+  WaitForTransactionReceiptTimeoutError,
+  CallExecutionError,
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+  ContractFunctionZeroDataError,
+  RawContractError,
+  SizeExceedsPaddingSizeError,
+  DataLengthTooLongError,
+  DataLengthTooShortError,
+  InvalidBytesBooleanError,
+  InvalidHexBooleanError,
+  InvalidHexValueError,
+  OffsetOutOfBoundsError,
+  EstimateGasExecutionError,
+  FilterTypeNotSupportedError,
+  ExecutionRevertedError,
+  FeeCapTooHighError,
+  FeeCapTooLowError,
+  NonceTooHighError,
+  NonceTooLowError,
+  NonceMaxValueError,
+  InsufficientFundsError,
+  IntrinsicGasTooHighError,
+  IntrinsicGasTooLowError,
+  TransactionTypeNotSupportedError,
+  TipAboveFeeCapError,
+  UnknownNodeError,
+  RequestError,
+  RpcRequestError,
+  ParseRpcError,
+  InvalidRequestRpcError,
+  MethodNotFoundRpcError,
+  InvalidParamsRpcError,
+  InternalRpcError,
+  InvalidInputRpcError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  TransactionRejectedRpcError,
+  MethodNotSupportedRpcError,
+  LimitExceededRpcError,
+  JsonRpcVersionUnsupportedError,
+  UserRejectedRequestError,
+  SwitchChainError,
+  UnknownRpcError,
+  HttpRequestError,
+  WebSocketRequestError,
+  RpcError,
+  TimeoutError,
+  UrlRequiredError,
   concat,
   isBytes,
   isHex,
@@ -2905,43 +5162,41 @@ export {
   sliceHex,
   boolToHex,
   bytesToHex,
-  encodeHex,
+  toHex,
   numberToHex,
   stringToHex,
+  toBytes,
   boolToBytes,
-  encodeBytes,
   hexToBytes,
   numberToBytes,
   stringToBytes,
-  encodeRlp,
-  decodeHex,
+  toRlp,
+  fromHex,
   hexToBigInt,
   hexToBool,
   hexToNumber,
   hexToString,
-  decodeBytes,
+  fromBytes,
   bytesToBigint,
   bytesToBool,
   bytesToNumber,
   bytesToString,
-  decodeRlp,
+  fromRlp,
   extractFunctionParts,
   extractFunctionName,
   extractFunctionParams,
   extractFunctionType,
-  getContractError,
   keccak256,
-  getEventSignature,
-  getFunctionSignature,
-  checksumAddress,
+  getEventSelector,
+  getFunctionSelector,
+  isAddress,
   getAddress,
-  getContractAddress,
+  getContractAddress2 as getContractAddress,
   getCreateAddress,
   getCreate2Address,
-  isAddress,
   isAddressEqual,
-  encodeAbi,
-  decodeAbi,
+  encodeAbiParameters,
+  decodeAbiParameters,
   formatAbiItem,
   decodeErrorResult,
   decodeEventLog,
@@ -2953,11 +5208,17 @@ export {
   encodeEventTopics,
   encodeFunctionData,
   encodeFunctionResult,
+  arrayRegex,
+  bytesRegex,
+  integerRegex,
+  encodePacked,
   formatAbiItemWithArgs,
-  getCache,
-  withCache,
-  wait,
-  isNonDeterministicError,
+  parseAbi,
+  parseAbiItem,
+  parseAbiParameter,
+  parseAbiParameters,
+  getAccount,
+  isDeterministicError,
   buildRequest,
   defineChain,
   format3 as format,
@@ -2968,59 +5229,98 @@ export {
   formatBlock,
   defineBlock,
   extract,
-  formatFeeHistory,
-  formatLog,
-  formatTransactionReceipt,
   defineTransactionReceipt,
   formatTransactionRequest,
   defineTransactionRequest,
+  containsNodeError,
+  getNodeError,
+  getCallError,
+  getContractError,
+  getEstimateGasError,
+  getTransactionError,
   stringify,
   getSocket,
   rpc,
-  etherUnits,
-  gweiUnits,
-  weiUnits,
-  formatUnit,
+  assertRequest,
+  call,
+  simulateContract,
+  createPendingTransactionFilter,
+  createBlockFilter,
+  createEventFilter,
+  createContractEventFilter,
+  estimateGas,
+  estimateContractGas,
+  getBalance,
+  getBlock,
+  getBlockNumberCache,
+  getBlockNumber,
+  getBlockTransactionCount,
+  getBytecode,
+  getChainId,
+  getFeeHistory,
+  getFilterChanges,
+  getFilterLogs,
+  getGasPrice,
+  getLogs,
+  getStorageAt,
+  getTransaction,
+  getTransactionConfirmations,
+  getTransactionCount,
+  getTransactionReceipt,
+  readContract,
+  multicall,
+  uninstallFilter,
+  waitForTransactionReceipt,
+  watchBlockNumber,
+  watchBlocks,
+  watchContractEvent,
+  watchEvent,
+  watchPendingTransactions,
+  dropTransaction,
+  getAutomine,
+  getTxpoolContent,
+  getTxpoolStatus,
+  impersonateAccount,
+  increaseTime,
+  inspectTxpool,
+  mine,
+  removeBlockTimestampInterval,
+  reset,
+  revert,
+  sendUnsignedTransaction,
+  setAutomine,
+  setBalance,
+  setBlockGasLimit,
+  setBlockTimestampInterval,
+  setCode,
+  setCoinbase,
+  setIntervalMining,
+  setLoggingEnabled,
+  setMinGasPrice,
+  setNextBlockBaseFeePerGas,
+  setNextBlockTimestamp,
+  setNonce,
+  setRpcUrl,
+  setStorageAt,
+  snapshot,
+  stopImpersonatingAccount,
+  addChain,
+  deployContract,
+  getAddresses,
+  getPermissions,
+  requestAddresses,
+  requestPermissions,
+  sendTransaction,
+  signMessage,
+  switchChain,
+  watchAsset,
+  writeContract,
+  parseUnits,
+  parseGwei,
+  prepareRequest,
+  formatUnits,
   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,
-  TimeoutError,
-  InvalidGasArgumentsError,
-  TransactionNotFoundError,
-  TransactionReceiptNotFoundError,
-  WaitForTransactionReceiptTimeoutError,
-  UrlRequiredError
+  parseEther
 };
-//# sourceMappingURL=chunk-SD5X7F4U.mjs.map
+//# sourceMappingURL=chunk-I7AINPMM.mjs.map