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

package/dist/{chunk-26WUARDL.js → chunk-2FDH6XP5.mjs}

@@ -1,30 +1,842 @@
-import {
-  AbiConstructorNotFoundError,
-  AbiConstructorParamsNotFoundError,
-  AbiDecodingDataSizeInvalidError,
-  AbiEncodingArrayLengthMismatchError,
-  AbiEncodingLengthMismatchError,
-  AbiErrorInputsNotFoundError,
-  AbiErrorNotFoundError,
-  AbiErrorSignatureNotFoundError,
-  AbiEventNotFoundError,
-  AbiFunctionNotFoundError,
-  AbiFunctionOutputsNotFoundError,
-  AbiFunctionSignatureNotFoundError,
-  DataLengthTooLongError,
-  DataLengthTooShortError,
-  FilterTypeNotSupportedError,
-  InvalidAbiDecodingTypeError,
-  InvalidAbiEncodingTypeError,
-  InvalidAddressError,
-  InvalidArrayError,
-  InvalidBytesBooleanError,
-  InvalidDefinitionTypeError,
-  InvalidHexBooleanError,
-  InvalidHexValueError,
-  OffsetOutOfBoundsError,
-  SizeExceedsPaddingSizeError
-} from "./chunk-7H5SPKXN.js";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// package.json
+var package_default = {
+  name: "viem",
+  description: "TypeScript (& JavaScript) Interface for Ethereum",
+  version: "0.0.1-alpha.9",
+  scripts: {
+    anvil: "source .env && anvil --fork-url $VITE_ANVIL_FORK_URL --fork-block-number $VITE_ANVIL_BLOCK_NUMBER --block-time $VITE_ANVIL_BLOCK_TIME",
+    bench: "vitest bench --no-threads",
+    "bench:ci": "CI=true vitest bench --no-threads",
+    build: "tsup",
+    changeset: "changeset",
+    "changeset:release": "pnpm build && changeset publish",
+    "changeset:version": "changeset version && pnpm install --lockfile-only",
+    dev: "DEV=true tsup",
+    "dev:docs": "pnpm -r --filter site dev",
+    format: "rome format src/ test/ --write",
+    lint: "rome check .",
+    "lint:fix": "pnpm lint --apply-suggested",
+    playground: "pnpm --filter playground-dev dev",
+    "playground:benchmark": "pnpm --filter playground-benchmark dev",
+    postinstall: "pnpm dev",
+    preinstall: "npx only-allow pnpm",
+    prepare: "npx simple-git-hooks",
+    test: "vitest dev --coverage --no-threads",
+    "test:ci": "CI=true vitest --coverage --no-threads",
+    "test:ui": "vitest dev --ui --no-threads",
+    typecheck: "tsc --noEmit"
+  },
+  files: [
+    "/actions",
+    "/chains",
+    "/dist",
+    "/clients",
+    "/types",
+    "/utils",
+    "/window"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      module: "./dist/index.mjs",
+      default: "./dist/index.js"
+    },
+    "./actions": {
+      types: "./dist/actions/index.d.ts",
+      module: "./dist/actions/index.mjs",
+      default: "./dist/actions/index.js"
+    },
+    "./chains": {
+      types: "./dist/chains.d.ts",
+      module: "./dist/chains.mjs",
+      default: "./dist/chains.js"
+    },
+    "./clients": {
+      types: "./dist/clients/index.d.ts",
+      module: "./dist/clients/index.mjs",
+      default: "./dist/clients/index.js"
+    },
+    "./utils": {
+      types: "./dist/utils/index.d.ts",
+      module: "./dist/utils/index.mjs",
+      default: "./dist/utils/index.js"
+    },
+    "./window": {
+      types: "./dist/window.d.ts",
+      module: "./dist/window.mjs",
+      default: "./dist/window.js"
+    },
+    "./package.json": "./package.json"
+  },
+  main: "dist/index.js",
+  module: "dist/index.mjs",
+  types: "dist/index.d.ts",
+  sideEffects: false,
+  dependencies: {
+    "@noble/hashes": "^1.1.2",
+    "@wagmi/chains": "^0.1.0",
+    abitype: "^0.2.5"
+  },
+  devDependencies: {
+    "@actions/core": "^1.10.0",
+    "@actions/github": "^5.1.1",
+    "@changesets/changelog-github": "^0.4.5",
+    "@changesets/cli": "^2.23.2",
+    "@testing-library/jest-dom": "^5.16.5",
+    "@types/dedent": "^0.7.0",
+    "@types/fs-extra": "^9.0.13",
+    "@types/node": "^17.0.45",
+    "@vitest/coverage-c8": "^0.24.3",
+    "@vitest/ui": "^0.19.1",
+    bundlewatch: "^0.3.3",
+    dedent: "^0.7.0",
+    esbuild: "^0.16.12",
+    "esbuild-register": "^3.4.2",
+    "essential-eth": "^0.6.2",
+    ethers: "^5.7.2",
+    execa: "^6.1.0",
+    "fs-extra": "^10.1.0",
+    jsdom: "^20.0.0",
+    rome: "^11.0.0",
+    "simple-git-hooks": "^2.8.1",
+    tsup: "^6.5.0",
+    typescript: "^4.9.3",
+    vite: "^3.0.4",
+    vitest: "^0.25.2",
+    web3: "^1.8.1"
+  },
+  license: "MIT",
+  repository: "wagmi-dev/viem",
+  authors: [
+    "awkweb.eth",
+    "jxom.eth"
+  ],
+  keywords: [
+    "eth",
+    "ethereum",
+    "dapps",
+    "wallet",
+    "web3"
+  ],
+  "simple-git-hooks": {
+    "pre-commit": "pnpm format & pnpm lint:fix"
+  },
+  pnpm: {
+    patchedDependencies: {
+      "vitepress@1.0.0-alpha.34": "patches/vitepress@1.0.0-alpha.34.patch"
+    }
+  }
+};
+
+// src/utils/stringify.ts
+function stringify(value) {
+  return JSON.stringify(
+    value,
+    (_, value2) => typeof value2 === "bigint" ? value2.toString() : value2
+  );
+}
+
+// src/errors/base.ts
+var version = process.env.TEST ? "1.0.2" : package_default.version;
+var BaseError = class extends Error {
+  constructor(humanMessage, args = {}) {
+    const details = args.cause instanceof BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
+    const docsPath5 = args.cause instanceof BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
+    const message = [
+      humanMessage,
+      ...docsPath5 ? ["", `Docs: https://viem.sh${docsPath5}`] : [],
+      "",
+      ...details ? [`Details: ${details}`] : [],
+      `Version: viem@${version}`,
+      ...args.cause && !(args.cause instanceof BaseError) && Object.keys(args.cause).length > 0 ? [`Internal Error: ${stringify(args.cause)}`] : []
+    ].join("\n");
+    super(message);
+    __publicField(this, "humanMessage");
+    __publicField(this, "details");
+    __publicField(this, "docsPath");
+    __publicField(this, "name", "ViemError");
+    if (args.cause)
+      this.cause = args.cause;
+    this.details = details;
+    this.docsPath = docsPath5;
+    this.humanMessage = humanMessage;
+  }
+};
+
+// src/errors/abi.ts
+var AbiConstructorNotFoundError = class extends BaseError {
+  constructor({ docsPath: docsPath5 }) {
+    super(
+      [
+        "A constructor was not found on the ABI.",
+        "Make sure you are using the correct ABI and that the constructor exists on it."
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiConstructorNotFoundError");
+  }
+};
+var AbiConstructorParamsNotFoundError = class extends BaseError {
+  constructor({ docsPath: docsPath5 }) {
+    super(
+      [
+        "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
+        "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiConstructorParamsNotFoundError");
+  }
+};
+var AbiDecodingDataSizeInvalidError = class extends BaseError {
+  constructor(size2) {
+    super(
+      [
+        `Data size of ${size2} bytes is invalid.`,
+        "Size must be in increments of 32 bytes (size % 32 === 0)."
+      ].join("\n")
+    );
+    __publicField(this, "name", "AbiDecodingDataSizeInvalidError");
+  }
+};
+var AbiDecodingZeroDataError = class extends BaseError {
+  constructor() {
+    super('Cannot decode zero data ("0x") with ABI parameters.');
+    __publicField(this, "name", "AbiDecodingZeroDataError");
+  }
+};
+var AbiEncodingArrayLengthMismatchError = class extends BaseError {
+  constructor({
+    expectedLength,
+    givenLength,
+    type
+  }) {
+    super(
+      [
+        `ABI encoding array length mismatch for type ${type}.`,
+        `Expected length: ${expectedLength}`,
+        `Given length: ${givenLength}`
+      ].join("\n")
+    );
+    __publicField(this, "name", "AbiEncodingArrayLengthMismatchError");
+  }
+};
+var AbiEncodingLengthMismatchError = class extends BaseError {
+  constructor({
+    expectedLength,
+    givenLength
+  }) {
+    super(
+      [
+        "ABI encoding params/values length mismatch.",
+        `Expected length (params): ${expectedLength}`,
+        `Given length (values): ${givenLength}`
+      ].join("\n")
+    );
+    __publicField(this, "name", "AbiEncodingLengthMismatchError");
+  }
+};
+var AbiErrorInputsNotFoundError = class extends BaseError {
+  constructor(errorName, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
+        "Cannot encode error result without knowing what the parameter types are.",
+        "Make sure you are using the correct ABI and that the inputs exist on it."
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiErrorInputsNotFoundError");
+  }
+};
+var AbiErrorNotFoundError = class extends BaseError {
+  constructor(errorName, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Error "${errorName}" not found on ABI.`,
+        "Make sure you are using the correct ABI and that the error exists on it."
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiErrorNotFoundError");
+  }
+};
+var AbiErrorSignatureNotFoundError = class extends BaseError {
+  constructor(signature, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Encoded error signature "${signature}" not found on ABI.`,
+        "Make sure you are using the correct ABI and that the error exists on it.",
+        `You can look up the signature "${signature}" here: https://sig.eth.samczsun.com/.`
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiErrorSignatureNotFoundError");
+  }
+};
+var AbiEventNotFoundError = class extends BaseError {
+  constructor(eventName, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Event "${eventName}" not found on ABI.`,
+        "Make sure you are using the correct ABI and that the event exists on it."
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiEventNotFoundError");
+  }
+};
+var AbiFunctionNotFoundError = class extends BaseError {
+  constructor(functionName, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Function "${functionName}" not found on ABI.`,
+        "Make sure you are using the correct ABI and that the function exists on it."
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiFunctionNotFoundError");
+  }
+};
+var AbiFunctionOutputsNotFoundError = class extends BaseError {
+  constructor(functionName, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
+        "Cannot decode function result without knowing what the parameter types are.",
+        "Make sure you are using the correct ABI and that the function exists on it."
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiFunctionOutputsNotFoundError");
+  }
+};
+var AbiFunctionSignatureNotFoundError = class extends BaseError {
+  constructor(signature, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Encoded function signature "${signature}" not found on ABI.`,
+        "Make sure you are using the correct ABI and that the function exists on it.",
+        `You can look up the signature "${signature}" here: https://sig.eth.samczsun.com/.`
+      ].join("\n"),
+      {
+        docsPath: docsPath5
+      }
+    );
+    __publicField(this, "name", "AbiFunctionSignatureNotFoundError");
+  }
+};
+var InvalidAbiEncodingTypeError = class extends BaseError {
+  constructor(type, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Type "${type}" is not a valid encoding type.`,
+        "Please provide a valid ABI type."
+      ].join("\n"),
+      { docsPath: docsPath5 }
+    );
+    __publicField(this, "name", "InvalidAbiEncodingType");
+  }
+};
+var InvalidAbiDecodingTypeError = class extends BaseError {
+  constructor(type, { docsPath: docsPath5 }) {
+    super(
+      [
+        `Type "${type}" is not a valid decoding type.`,
+        "Please provide a valid ABI type."
+      ].join("\n"),
+      { docsPath: docsPath5 }
+    );
+    __publicField(this, "name", "InvalidAbiDecodingType");
+  }
+};
+var InvalidArrayError = class extends BaseError {
+  constructor(value) {
+    super([`Value "${value}" is not a valid array.`].join("\n"));
+    __publicField(this, "name", "InvalidArrayError");
+  }
+};
+var InvalidDefinitionTypeError = class extends BaseError {
+  constructor(type) {
+    super(
+      [
+        `"${type}" is not a valid definition type.`,
+        'Valid types: "function", "event", "error"'
+      ].join("\n")
+    );
+    __publicField(this, "name", "InvalidDefinitionTypeError");
+  }
+};
+
+// src/errors/address.ts
+var InvalidAddressError = class extends BaseError {
+  constructor({ address }) {
+    super(`Address "${address}" is invalid.`);
+    __publicField(this, "name", "InvalidAddressError");
+  }
+};
+
+// src/errors/block.ts
+var BlockNotFoundError = class extends BaseError {
+  constructor({
+    blockHash,
+    blockNumber
+  }) {
+    let identifier = "Block";
+    if (blockHash)
+      identifier = `Block at hash "${blockHash}"`;
+    if (blockNumber)
+      identifier = `Block at number "${blockNumber}"`;
+    super(`${identifier} could not be found.`);
+    __publicField(this, "name", "BlockNotFoundError");
+  }
+};
+
+// src/errors/contract.ts
+var ContractMethodExecutionError = class extends BaseError {
+  constructor(message, {
+    abi,
+    args,
+    cause,
+    contractAddress,
+    formattedArgs,
+    functionName,
+    functionWithParams,
+    sender
+  } = {}) {
+    super(
+      [
+        message,
+        " ",
+        sender && `Sender:    ${sender}`,
+        contractAddress && `Contract:  ${process.env.TEST ? "0x0000000000000000000000000000000000000000" : contractAddress}`,
+        functionWithParams && `Function:  ${functionWithParams}`,
+        formattedArgs && `Arguments: ${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`
+      ].filter(Boolean).join("\n"),
+      {
+        cause
+      }
+    );
+    __publicField(this, "abi");
+    __publicField(this, "args");
+    __publicField(this, "contractAddress");
+    __publicField(this, "formattedArgs");
+    __publicField(this, "functionName");
+    __publicField(this, "reason");
+    __publicField(this, "sender");
+    __publicField(this, "name", "ContractMethodExecutionError");
+    if (message)
+      this.reason = message;
+    this.abi = abi;
+    this.args = args;
+    this.contractAddress = contractAddress;
+    this.functionName = functionName;
+    this.sender = sender;
+  }
+};
+var ContractMethodZeroDataError = class extends BaseError {
+  constructor({
+    abi,
+    args,
+    cause,
+    contractAddress,
+    functionName,
+    functionWithParams
+  } = {}) {
+    super(
+      [
+        `The contract method "${functionName}" returned no data ("0x"). This could be due to any of the following:`,
+        `- The contract does not have the function "${functionName}",`,
+        "- The parameters passed to the contract function may be invalid, or",
+        "- The address is not a contract.",
+        " ",
+        contractAddress && `Contract: ${process.env.TEST ? "0x0000000000000000000000000000000000000000" : contractAddress}`,
+        functionWithParams && `Function: ${functionWithParams}`,
+        functionWithParams && `        > "0x"`
+      ].filter(Boolean).join("\n"),
+      {
+        cause
+      }
+    );
+    __publicField(this, "abi");
+    __publicField(this, "args");
+    __publicField(this, "contractAddress");
+    __publicField(this, "functionName");
+    __publicField(this, "functionWithParams");
+    __publicField(this, "name", "ContractMethodZeroDataError");
+    this.abi = abi;
+    this.args = args;
+    this.contractAddress = contractAddress;
+    this.functionName = functionName;
+  }
+};
+
+// src/errors/data.ts
+var SizeExceedsPaddingSizeError = class extends BaseError {
+  constructor({
+    size: size2,
+    targetSize,
+    type
+  }) {
+    super(
+      `${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`
+    );
+    __publicField(this, "name", "SizeExceedsPaddingSizeError");
+  }
+};
+
+// src/errors/encoding.ts
+var DataLengthTooLongError = class extends BaseError {
+  constructor({ consumed, length }) {
+    super(
+      `Consumed bytes (${consumed}) is shorter than data length (${length - 1}).`
+    );
+    __publicField(this, "name", "DataLengthTooLongError");
+  }
+};
+var DataLengthTooShortError = class extends BaseError {
+  constructor({ length, dataLength }) {
+    super(
+      `Data length (${dataLength - 1}) is shorter than prefix length (${length - 1}).`
+    );
+    __publicField(this, "name", "DataLengthTooShortError");
+  }
+};
+var InvalidBytesBooleanError = class extends BaseError {
+  constructor(bytes) {
+    super(
+      `Bytes value "${bytes}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`
+    );
+    __publicField(this, "name", "InvalidBytesBooleanError");
+  }
+};
+var InvalidHexBooleanError = class extends BaseError {
+  constructor(hex) {
+    super(
+      `Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`
+    );
+    __publicField(this, "name", "InvalidHexBooleanError");
+  }
+};
+var InvalidHexValueError = class extends BaseError {
+  constructor(value) {
+    super(
+      `Hex value "${value}" is an odd length (${value.length}). It must be an even length.`
+    );
+    __publicField(this, "name", "InvalidHexValueError");
+  }
+};
+var OffsetOutOfBoundsError = class extends BaseError {
+  constructor({ nextOffset, offset }) {
+    super(
+      `Next offset (${nextOffset}) is greater than previous offset + consumed bytes (${offset})`
+    );
+    __publicField(this, "name", "OffsetOutOfBoundsError");
+  }
+};
+
+// src/errors/log.ts
+var FilterTypeNotSupportedError = class extends BaseError {
+  constructor(type) {
+    super(`Filter type "${type}" is not supported.`);
+    __publicField(this, "name", "FilterTypeNotSupportedError");
+  }
+};
+
+// src/errors/request.ts
+var RequestError = class extends BaseError {
+  constructor(err, { docsPath: docsPath5, humanMessage }) {
+    super(humanMessage, {
+      cause: err,
+      docsPath: docsPath5
+    });
+    this.name = err.name;
+  }
+};
+var RpcRequestError = class extends RequestError {
+  constructor(err, { docsPath: docsPath5, humanMessage }) {
+    super(err, { docsPath: docsPath5, humanMessage });
+    __publicField(this, "code");
+    this.code = err.code;
+    this.name = err.name;
+  }
+};
+var ParseRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
+    });
+    __publicField(this, "name", "ParseRpcError");
+    __publicField(this, "code", -32700);
+  }
+};
+var InvalidRequestRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "JSON is not a valid request object." });
+    __publicField(this, "name", "InvalidRequestRpcError");
+    __publicField(this, "code", -32600);
+  }
+};
+var MethodNotFoundRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: "The method does not exist / is not available."
+    });
+    __publicField(this, "name", "MethodNotFoundRpcError");
+    __publicField(this, "code", -32601);
+  }
+};
+var InvalidParamsRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: [
+        "Invalid parameters were provided to the RPC method.",
+        "Double check you have provided the correct parameters."
+      ].join("\n")
+    });
+    __publicField(this, "name", "InvalidParamsRpcError");
+    __publicField(this, "code", -32602);
+  }
+};
+var InternalRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "An internal error was received." });
+    __publicField(this, "name", "InternalRpcError");
+    __publicField(this, "code", -32603);
+  }
+};
+var InvalidInputRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: [
+        "Missing or invalid parameters.",
+        "Double check you have provided the correct parameters."
+      ].join("\n")
+    });
+    __publicField(this, "name", "InvalidInputRpcError");
+    __publicField(this, "code", -32e3);
+  }
+};
+var ResourceNotFoundRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Requested resource not found." });
+    __publicField(this, "name", "ResourceNotFoundRpcError");
+    __publicField(this, "code", -32001);
+  }
+};
+var ResourceUnavailableRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Requested resource not available." });
+    __publicField(this, "name", "ResourceUnavailableRpcError");
+    __publicField(this, "code", -32002);
+  }
+};
+var TransactionRejectedRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Transaction creation failed." });
+    __publicField(this, "name", "TransactionRejectedRpcError");
+    __publicField(this, "code", -32003);
+  }
+};
+var MethodNotSupportedRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Method is not implemented." });
+    __publicField(this, "name", "MethodNotSupportedRpcError");
+    __publicField(this, "code", -32004);
+  }
+};
+var LimitExceededRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Request exceeds defined limit." });
+    __publicField(this, "name", "LimitExceededRpcError");
+    __publicField(this, "code", -32005);
+  }
+};
+var JsonRpcVersionUnsupportedError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: "Version of JSON-RPC protocol is not supported."
+    });
+    __publicField(this, "name", "JsonRpcVersionUnsupportedError");
+    __publicField(this, "code", -32006);
+  }
+};
+var UnknownRpcError = class extends RequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: "An unknown RPC error occurred."
+    });
+    __publicField(this, "name", "UnknownRpcError");
+  }
+};
+
+// src/errors/rpc.ts
+var HttpRequestError = class extends BaseError {
+  constructor({
+    body,
+    details,
+    status,
+    url
+  }) {
+    super(
+      [
+        "HTTP request failed.",
+        "",
+        `Status: ${status}`,
+        `URL: ${url}`,
+        `Request body: ${stringify(body)}`
+      ].join("\n"),
+      {
+        details
+      }
+    );
+    __publicField(this, "name", "HttpRequestError");
+    __publicField(this, "status");
+    this.status = status;
+  }
+};
+var WebSocketRequestError = class extends BaseError {
+  constructor({
+    body,
+    details,
+    url
+  }) {
+    super(
+      [
+        "WebSocket request failed.",
+        "",
+        `URL: ${url}`,
+        `Request body: ${stringify(body)}`
+      ].join("\n"),
+      {
+        details
+      }
+    );
+    __publicField(this, "name", "WebSocketRequestError");
+  }
+};
+var RpcError = class extends BaseError {
+  constructor({
+    body,
+    error,
+    url
+  }) {
+    super(
+      [
+        "RPC Request failed.",
+        "",
+        `URL: ${url}`,
+        `Request body: ${stringify(body)}`
+      ].join("\n"),
+      {
+        cause: error,
+        details: error.message
+      }
+    );
+    __publicField(this, "code");
+    __publicField(this, "name", "RpcError");
+    this.code = error.code;
+  }
+};
+var TimeoutError = class extends BaseError {
+  constructor({
+    body,
+    url
+  }) {
+    super(
+      [
+        "The request took too long to respond.",
+        "",
+        `URL: ${url}`,
+        `Request body: ${stringify(body)}`
+      ].join("\n"),
+      {
+        details: "The request timed out."
+      }
+    );
+    __publicField(this, "name", "TimeoutError");
+  }
+};
+
+// src/errors/transaction.ts
+var InvalidGasArgumentsError = class extends BaseError {
+  constructor() {
+    super("`maxFeePerGas` cannot be less than `maxPriorityFeePerGas`");
+    __publicField(this, "name", "InvalidGasArgumentsError");
+  }
+};
+var TransactionNotFoundError = class extends BaseError {
+  constructor({
+    blockHash,
+    blockNumber,
+    blockTag,
+    hash: 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"
+      }
+    );
+  }
+};
 
 // src/utils/data/concat.ts
 function concat(values) {
@@ -426,7 +1238,7 @@ function rlpToBytes(bytes, offset = 0) {
   return [result, consumed];
 }
 
-// src/utils/solidity.ts
+// src/utils/contract/extractFunctionParts.ts
 var paramsRegex = /((function|event)\s)?(.*)(\((.*)\))/;
 function extractFunctionParts(def) {
   const parts = def.match(paramsRegex);
@@ -451,6 +1263,49 @@ function extractFunctionType(def) {
   return extractFunctionParts(def).type;
 }
 
+// src/utils/contract/getContractError.ts
+function getContractError(err, {
+  abi,
+  address,
+  args,
+  functionName,
+  sender
+}) {
+  const { code, message } = err.cause || {};
+  const abiItem = getAbiItem({ abi, name: functionName });
+  const formattedArgs = abiItem ? formatAbiItemWithArgs({
+    abiItem,
+    args,
+    includeFunctionName: false,
+    includeName: false
+  }) : void 0;
+  const functionWithParams = abiItem ? formatAbiItemWithParams(abiItem, { includeName: true }) : void 0;
+  if (err instanceof AbiDecodingZeroDataError) {
+    return new ContractMethodZeroDataError({
+      abi,
+      args,
+      cause: err,
+      contractAddress: address,
+      functionName,
+      functionWithParams
+    });
+  }
+  if (code === 3 || message?.includes("execution reverted")) {
+    const message_ = message?.replace("execution reverted: ", "");
+    return new ContractMethodExecutionError(message_, {
+      abi,
+      args,
+      cause: err,
+      contractAddress: address,
+      formattedArgs,
+      functionName,
+      functionWithParams,
+      sender
+    });
+  }
+  return err;
+}
+
 // src/utils/hash/keccak256.ts
 import { keccak_256 } from "@noble/hashes/sha3";
 function keccak256(value, to_) {
@@ -484,10 +1339,10 @@ function checksumAddress(address_) {
   const hash2 = keccak256(stringToBytes(hexAddress), "bytes");
   let address = hexAddress.split("");
   for (let i = 0; i < 40; i += 2) {
-    if (hash2?.[i >> 1] >> 4 >= 8) {
+    if (hash2?.[i >> 1] >> 4 >= 8 && address[i]) {
       address[i] = address[i].toUpperCase();
     }
-    if ((hash2[i >> 1] & 15) >= 8) {
+    if ((hash2[i >> 1] & 15) >= 8 && address[i + 1]) {
       address[i + 1] = address[i + 1].toUpperCase();
     }
   }
@@ -733,6 +1588,8 @@ function decodeAbi({
   data,
   params
 }) {
+  if (data === "0x" && params.length > 0)
+    throw new AbiDecodingZeroDataError();
   if (size(data) % 32 !== 0)
     throw new AbiDecodingDataSizeInvalidError(size(data));
   const values = decodeParams({
@@ -795,7 +1652,7 @@ function decodeParam({
   });
 }
 function decodeAddress(value) {
-  return { consumed: 32, value: checksumAddress(trim(value)) };
+  return { consumed: 32, value: checksumAddress(slice(value, -20)) };
 }
 function decodeArray(data, {
   param,
@@ -924,33 +1781,32 @@ function hasDynamicChild(param) {
   return false;
 }
 
-// src/utils/abi/getDefinition.ts
-function getDefinition(description) {
-  if (description.type !== "function" && description.type !== "event" && description.type !== "error")
-    throw new InvalidDefinitionTypeError(description.type, {
-      docsPath: "/docs/contract/getDefinition"
-    });
-  return `${description.name}(${getParams(description.inputs)})`;
+// src/utils/abi/formatAbiItemWithParams.ts
+function formatAbiItemWithParams(abiItem, { includeName = false } = {}) {
+  if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
+    throw new InvalidDefinitionTypeError(abiItem.type);
+  return `${abiItem.name}(${getParams(abiItem.inputs, { includeName })})`;
 }
-function getParams(params) {
+function getParams(params, { includeName }) {
   if (!params)
     return "";
-  return params.map(getParam).join(",");
+  return params.map((param) => getParam(param, { includeName })).join(includeName ? ", " : ",");
 }
-function getParam(param) {
+function getParam(param, { includeName }) {
   if (param.type.startsWith("tuple")) {
     return `(${getParams(
-      param.components
+      param.components,
+      { includeName }
     )})${param.type.slice("tuple".length)}`;
   }
-  return param.type;
+  return param.type + (includeName && param.name ? ` ${param.name}` : "");
 }
 
 // src/utils/abi/decodeErrorResult.ts
 function decodeErrorResult({ abi, data }) {
   const signature = slice(data, 0, 4);
   const description = abi.find(
-    (x) => signature === getFunctionSignature(getDefinition(x))
+    (x) => signature === getFunctionSignature(formatAbiItemWithParams(x))
   );
   if (!description)
     throw new AbiErrorSignatureNotFoundError(signature, {
@@ -966,7 +1822,7 @@ function decodeErrorResult({ abi, data }) {
 function decodeFunctionData({ abi, data }) {
   const signature = slice(data, 0, 4);
   const description = abi.find(
-    (x) => signature === getFunctionSignature(getDefinition(x))
+    (x) => signature === getFunctionSignature(formatAbiItemWithParams(x))
   );
   if (!description)
     throw new AbiFunctionSignatureNotFoundError(signature, {
@@ -985,7 +1841,9 @@ function decodeFunctionResult({
   functionName,
   data
 }) {
-  const description = abi.find((x) => "name" in x && x.name === functionName);
+  const description = abi.find(
+    (x) => "name" in x && x.name === functionName
+  );
   if (!description)
     throw new AbiFunctionNotFoundError(functionName, { docsPath });
   if (!("outputs" in description))
@@ -1021,17 +1879,18 @@ function encodeDeployData({
   return concatHex([bytecode, data]);
 }
 
+// src/utils/abi/getAbiItem.ts
+function getAbiItem({ abi, name }) {
+  return abi.find((x) => "name" in x && x.name === name);
+}
+
 // src/utils/abi/encodeErrorResult.ts
 var docsPath3 = "/docs/contract/encodeErrorResult";
-function encodeErrorResult({
-  abi,
-  errorName,
-  args
-}) {
-  const description = abi.find((x) => "name" in x && x.name === errorName);
+function encodeErrorResult({ abi, errorName, args }) {
+  const description = getAbiItem({ abi, name: errorName });
   if (!description)
     throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath3 });
-  const definition = getDefinition(description);
+  const definition = formatAbiItemWithParams(description);
   const signature = getFunctionSignature(definition);
   let data = "0x";
   if (args && args.length > 0) {
@@ -1043,22 +1902,18 @@ function encodeErrorResult({
 }
 
 // src/utils/abi/encodeEventTopics.ts
-function encodeEventTopics({
-  abi,
-  eventName,
-  args
-}) {
-  const description = abi.find((x) => "name" in x && x.name === eventName);
-  if (!description)
+function encodeEventTopics({ abi, eventName, args }) {
+  const abiItem = getAbiItem({ abi, name: eventName });
+  if (!abiItem)
     throw new AbiEventNotFoundError(eventName, {
       docsPath: "/docs/contract/encodeEventTopics"
     });
-  const definition = getDefinition(description);
+  const definition = formatAbiItemWithParams(abiItem);
   const signature = getEventSignature(definition);
   let topics = [];
-  if (args && "inputs" in description) {
-    const args_ = Array.isArray(args) ? args : description.inputs?.map((x) => args[x.name]) ?? [];
-    topics = description.inputs?.filter((param) => "indexed" in param && param.indexed).map(
+  if (args && "inputs" in abiItem) {
+    const args_ = Array.isArray(args) ? args : abiItem.inputs?.map((x) => args[x.name]) ?? [];
+    topics = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed).map(
       (param, i) => Array.isArray(args_[i]) ? args_[i].map(
         (_, j) => encodeArg({ param, value: args_[i][j] })
       ) : args_[i] ? encodeArg({ param, value: args_[i] }) : null
@@ -1078,17 +1933,13 @@ function encodeArg({
 }
 
 // src/utils/abi/encodeFunctionData.ts
-function encodeFunctionData({
-  abi,
-  args,
-  functionName
-}) {
-  const description = abi.find((x) => "name" in x && x.name === functionName);
+function encodeFunctionData({ abi, args, functionName }) {
+  const description = getAbiItem({ abi, name: functionName });
   if (!description)
     throw new AbiFunctionNotFoundError(functionName, {
       docsPath: "/docs/contract/encodeFunctionData"
     });
-  const definition = getDefinition(description);
+  const definition = formatAbiItemWithParams(description);
   const signature = getFunctionSignature(definition);
   const data = "inputs" in description && description.inputs ? encodeAbi({
     params: description.inputs,
@@ -1115,6 +1966,62 @@ function encodeFunctionResult({
   return encodeAbi({ params: description.outputs, values });
 }
 
+// src/utils/abi/formatAbiItemWithArgs.ts
+function formatAbiItemWithArgs({
+  abiItem,
+  args,
+  includeFunctionName = true,
+  includeName = false
+}) {
+  if (!("name" in abiItem))
+    return;
+  if (!("inputs" in abiItem))
+    return;
+  if (!abiItem.inputs)
+    return;
+  return `${includeFunctionName ? abiItem.name : ""}(${abiItem.inputs.map(
+    (input, i) => `${includeName && input.name ? `${input.name}: ` : ""}${typeof args[i] === "object" ? stringify(args[i]) : args[i]}`
+  ).join(", ")})`;
+}
+
+// src/utils/buildRequest.ts
+function buildRequest(request) {
+  return async (args) => {
+    try {
+      return await request(args);
+    } catch (err_) {
+      let err = err_;
+      if (err.code === -32700)
+        throw new ParseRpcError(err);
+      if (err.code === -32600)
+        throw new InvalidRequestRpcError(err);
+      if (err.code === -32601)
+        throw new MethodNotFoundRpcError(err);
+      if (err.code === -32602)
+        throw new InvalidParamsRpcError(err);
+      if (err.code === -32603)
+        throw new InternalRpcError(err);
+      if (err.code === -32e3)
+        throw new InvalidInputRpcError(err);
+      if (err.code === -32001)
+        throw new ResourceNotFoundRpcError(err);
+      if (err.code === -32002)
+        throw new ResourceUnavailableRpcError(err);
+      if (err.code === -32003)
+        throw new TransactionRejectedRpcError(err);
+      if (err.code === -32004)
+        throw new MethodNotSupportedRpcError(err);
+      if (err.code === -32005)
+        throw new LimitExceededRpcError(err);
+      if (err.code === -32006)
+        throw new JsonRpcVersionUnsupportedError(err);
+      if (err_ instanceof BaseError)
+        throw err_;
+      throw new UnknownRpcError(err);
+    }
+  };
+}
+
 // src/constants.ts
 var etherUnits = {
   gwei: 9,
@@ -1241,6 +2148,278 @@ function formatTransactionRequest(transactionRequest) {
   };
 }
 
+// src/utils/promise/withCache.ts
+var promiseCache = /* @__PURE__ */ new Map();
+var responseCache = /* @__PURE__ */ new Map();
+function getCache(cacheKey) {
+  const buildCache = (cacheKey2, cache) => ({
+    clear: () => cache.delete(cacheKey2),
+    get: () => cache.get(cacheKey2),
+    set: (data) => cache.set(cacheKey2, data)
+  });
+  const promise = buildCache(cacheKey, promiseCache);
+  const response = buildCache(
+    cacheKey,
+    responseCache
+  );
+  return {
+    clear: () => {
+      promise.clear();
+      response.clear();
+    },
+    promise,
+    response
+  };
+}
+async function withCache(fn, { cacheKey, maxAge = Infinity }) {
+  const cache = getCache(cacheKey);
+  const response = cache.response.get();
+  if (response && maxAge > 0) {
+    const age = new Date().getTime() - response.created.getTime();
+    if (age < maxAge)
+      return response.data;
+  }
+  let promise = cache.promise.get();
+  if (!promise) {
+    promise = fn();
+    cache.promise.set(promise);
+  }
+  const data = await promise;
+  cache.promise.clear();
+  cache.response.set({ created: new Date(), data });
+  return data;
+}
+
+// src/utils/wait.ts
+async function wait(time) {
+  return new Promise((res) => setTimeout(res, time));
+}
+
+// src/utils/promise/withRetry.ts
+function withRetry(fn, {
+  delay: delay_ = 100,
+  retryCount = 2,
+  shouldRetryOnResponse = () => false,
+  shouldRetryOnError = () => false
+} = {}) {
+  return new Promise((resolve, reject) => {
+    const attemptRetry = async ({ count = 0 } = {}) => {
+      const retry = async ({ data } = {}) => {
+        const delay = typeof delay_ === "function" ? delay_({ count, data }) : delay_;
+        if (delay)
+          await wait(delay);
+        attemptRetry({ count: count + 1 });
+      };
+      try {
+        const data = await fn();
+        if (count < retryCount && await shouldRetryOnResponse({ count, data }))
+          return retry({ data });
+        resolve(data);
+      } catch (err) {
+        if (count < retryCount && await shouldRetryOnError({ count, error: err }))
+          return retry();
+        reject(err);
+      }
+    };
+    attemptRetry();
+  });
+}
+
+// src/utils/promise/withTimeout.ts
+function withTimeout(fn, {
+  errorInstance,
+  timeout,
+  signal
+}) {
+  return new Promise((resolve, reject) => {
+    ;
+    (async () => {
+      let timeoutId;
+      try {
+        const controller = new AbortController();
+        if (timeout > 0) {
+          timeoutId = setTimeout(() => {
+            if (signal) {
+              controller.abort();
+            } else {
+              reject(errorInstance);
+            }
+          }, timeout);
+        }
+        resolve(await fn({ signal: controller?.signal }));
+      } catch (err) {
+        if (err.name === "AbortError")
+          reject(errorInstance);
+        reject(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    })();
+  });
+}
+
+// src/utils/rpc.ts
+var id = 0;
+async function http(url, {
+  body,
+  retryDelay = 100,
+  retryCount = 2,
+  timeout = 0
+}) {
+  const response = await withRetry(
+    () => withTimeout(
+      async ({ signal }) => {
+        const response2 = await fetch(url, {
+          headers: {
+            "Content-Type": "application/json"
+          },
+          method: "POST",
+          body: stringify({ jsonrpc: "2.0", id: id++, ...body }),
+          signal: timeout > 0 ? signal : void 0
+        });
+        return response2;
+      },
+      {
+        errorInstance: new TimeoutError({ body, url }),
+        timeout,
+        signal: true
+      }
+    ),
+    {
+      delay: ({ count, data: data2 }) => {
+        const retryAfter = data2?.headers.get("Retry-After");
+        if (retryAfter?.match(/\d/))
+          return parseInt(retryAfter) * 1e3;
+        return ~~((Math.random() + 0.5) * (1 << count)) * retryDelay;
+      },
+      retryCount,
+      shouldRetryOnResponse: async ({ data: data2 }) => {
+        if (data2.status >= 500)
+          return true;
+        if ([408, 413, 429].includes(data2.status))
+          return true;
+        return false;
+      }
+    }
+  );
+  let data;
+  if (response.headers.get("Content-Type")?.startsWith("application/json")) {
+    data = await response.json();
+  } else {
+    data = await response.text();
+  }
+  if (!response.ok) {
+    throw new HttpRequestError({
+      body,
+      details: stringify(data.error) || response.statusText,
+      status: response.status,
+      url
+    });
+  }
+  if (data.error) {
+    throw new RpcError({ body, error: data.error, url });
+  }
+  return data;
+}
+var sockets = /* @__PURE__ */ new Map();
+async function getSocket(url_) {
+  const url = new URL(url_);
+  const urlKey = url.toString();
+  let socket = sockets.get(urlKey);
+  if (socket)
+    return socket;
+  const webSocket2 = new WebSocket(url);
+  const requests = /* @__PURE__ */ new Map();
+  const subscriptions = /* @__PURE__ */ new Map();
+  const onMessage = ({ data }) => {
+    const message = JSON.parse(data);
+    const isSubscription = message.method === "eth_subscription";
+    const id2 = isSubscription ? message.params.subscription : message.id;
+    const cache = isSubscription ? subscriptions : requests;
+    const callback = cache.get(id2);
+    if (callback)
+      callback({ data });
+    if (!isSubscription)
+      cache.delete(id2);
+  };
+  const onClose = () => {
+    sockets.delete(urlKey);
+    webSocket2.removeEventListener("close", onClose);
+    webSocket2.removeEventListener("message", onMessage);
+  };
+  webSocket2.addEventListener("close", onClose);
+  webSocket2.addEventListener("message", onMessage);
+  if (webSocket2.readyState === WebSocket.CONNECTING) {
+    await new Promise((resolve, reject) => {
+      if (!webSocket2)
+        return;
+      webSocket2.onopen = resolve;
+      webSocket2.onerror = reject;
+    });
+  }
+  socket = Object.assign(webSocket2, {
+    requests,
+    subscriptions
+  });
+  sockets.set(urlKey, socket);
+  return socket;
+}
+function webSocket(socket, {
+  body,
+  onData,
+  onError
+}) {
+  if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
+    throw new WebSocketRequestError({
+      body,
+      url: socket.url,
+      details: "Socket is closed."
+    });
+  const id_ = id++;
+  const callback = ({ data }) => {
+    const message = JSON.parse(data);
+    if (typeof message.id === "number" && id_ !== message.id)
+      return;
+    if (message.error) {
+      onError?.(new RpcError({ body, error: message.error, url: socket.url }));
+    } else {
+      onData?.(message);
+    }
+    if (body.method === "eth_subscribe" && typeof message.result === "string") {
+      socket.subscriptions.set(message.result, callback);
+    }
+    if (body.method === "eth_unsubscribe") {
+      socket.subscriptions.delete(body.params?.[0]);
+    }
+  };
+  socket.requests.set(id_, callback);
+  socket.send(JSON.stringify({ jsonrpc: "2.0", ...body, id: id_ }));
+  return socket;
+}
+async function webSocketAsync(socket, {
+  body,
+  timeout = 0
+}) {
+  return withTimeout(
+    () => new Promise(
+      (onData, onError) => rpc.webSocket(socket, {
+        body,
+        onData,
+        onError
+      })
+    ),
+    {
+      errorInstance: new TimeoutError({ body, url: socket.url }),
+      timeout
+    }
+  );
+}
+var rpc = {
+  http,
+  webSocket,
+  webSocketAsync
+};
+
 // src/utils/unit/formatUnit.ts
 function formatUnit(value, decimals) {
   let display = value.toString();
@@ -1299,6 +2478,49 @@ function parseGwei(ether, unit = "wei") {
 }
 
 export {
+  stringify,
+  BaseError,
+  AbiConstructorNotFoundError,
+  AbiConstructorParamsNotFoundError,
+  AbiDecodingDataSizeInvalidError,
+  AbiEncodingArrayLengthMismatchError,
+  AbiEncodingLengthMismatchError,
+  AbiErrorInputsNotFoundError,
+  AbiErrorNotFoundError,
+  AbiErrorSignatureNotFoundError,
+  AbiEventNotFoundError,
+  AbiFunctionNotFoundError,
+  AbiFunctionOutputsNotFoundError,
+  AbiFunctionSignatureNotFoundError,
+  InvalidAbiEncodingTypeError,
+  InvalidAbiDecodingTypeError,
+  InvalidArrayError,
+  InvalidDefinitionTypeError,
+  InvalidAddressError,
+  BlockNotFoundError,
+  SizeExceedsPaddingSizeError,
+  DataLengthTooLongError,
+  DataLengthTooShortError,
+  InvalidBytesBooleanError,
+  InvalidHexBooleanError,
+  InvalidHexValueError,
+  OffsetOutOfBoundsError,
+  FilterTypeNotSupportedError,
+  RequestError,
+  RpcRequestError,
+  ParseRpcError,
+  InvalidRequestRpcError,
+  MethodNotFoundRpcError,
+  InvalidParamsRpcError,
+  InternalRpcError,
+  InvalidInputRpcError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  TransactionRejectedRpcError,
+  MethodNotSupportedRpcError,
+  LimitExceededRpcError,
+  JsonRpcVersionUnsupportedError,
+  UnknownRpcError,
   isBytes,
   isHex,
   pad,
@@ -1331,9 +2553,11 @@ export {
   bytesToNumber,
   bytesToString,
   decodeRlp,
+  extractFunctionParts,
   extractFunctionName,
   extractFunctionParams,
   extractFunctionType,
+  getContractError,
   keccak256,
   getEventSignature,
   getFunctionSignature,
@@ -1346,14 +2570,18 @@ export {
   isAddressEqual,
   encodeAbi,
   decodeAbi,
+  formatAbiItemWithParams,
   decodeErrorResult,
   decodeFunctionData,
   decodeFunctionResult,
   encodeDeployData,
+  getAbiItem,
   encodeErrorResult,
   encodeEventTopics,
   encodeFunctionData,
   encodeFunctionResult,
+  formatAbiItemWithArgs,
+  buildRequest,
   etherUnits,
   gweiUnits,
   weiUnits,
@@ -1365,10 +2593,24 @@ export {
   formatLog,
   formatTransactionReceipt,
   formatTransactionRequest,
+  getCache,
+  withCache,
+  wait,
+  getSocket,
+  rpc,
   formatUnit,
   formatEther,
   formatGwei,
   parseUnit,
   parseEther,
-  parseGwei
+  parseGwei,
+  HttpRequestError,
+  WebSocketRequestError,
+  RpcError,
+  TimeoutError,
+  InvalidGasArgumentsError,
+  TransactionNotFoundError,
+  TransactionReceiptNotFoundError,
+  WaitForTransactionReceiptTimeoutError,
+  UrlRequiredError
 };