viem 0.0.1-alpha.0 → 0.0.1-alpha.10

package/dist/{chunk-GI67STNV.js → chunk-6GAKRM5P.js}

@@ -9,15 +9,29 @@ var __publicField = (obj, key, value) => {
 var package_default = {
   name: "viem",
   description: "TypeScript (& JavaScript) Interface for Ethereum",
-  version: "0.0.1-alpha.0",
+  version: "0.0.1-alpha.10",
   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",
-    dev: "DEV=true tsup"
-  },
-  dependencies: {
-    "@noble/hashes": "^1.1.2",
-    "@wagmi/chains": "^0.1.0",
-    abitype: "^0.2.5"
+    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",
@@ -59,43 +73,765 @@ var package_default = {
   main: "dist/index.js",
   types: "dist/index.d.ts",
   sideEffects: false,
-  license: "WAGMIT",
+  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",
-  author: "moxey.eth",
-  ethereum: "moxey.eth",
+  authors: [
+    "awkweb.eth",
+    "jxom.eth"
+  ],
   keywords: [
     "eth",
     "ethereum",
     "dapps",
     "wallet",
     "web3"
-  ]
+  ],
+  engines: {
+    node: ">=18"
+  },
+  "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/utils/BaseError.ts
-var version = process.env.TEST ? "1.0.2" : package_default.version;
-var BaseError = class extends Error {
-  constructor(humanMessage, args = {}) {
-    const details = args.cause instanceof BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
-    const docsPath = args.cause instanceof BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
-    const message = [
-      humanMessage,
-      ...docsPath ? ["", "Docs: https://viem.sh" + docsPath] : [],
-      "",
-      ...details ? ["Details: " + details] : [],
-      "Version: viem@" + version,
-      ...args.cause && !(args.cause instanceof BaseError) && Object.keys(args.cause).length > 0 ? ["Internal Error: " + JSON.stringify(args.cause)] : []
-    ].join("\n");
-    super(message);
-    __publicField(this, "humanMessage");
-    __publicField(this, "details");
-    __publicField(this, "docsPath");
-    __publicField(this, "name", "ViemError");
-    if (args.cause)
-      this.cause = args.cause;
-    this.details = details;
-    this.docsPath = docsPath;
-    this.humanMessage = humanMessage;
+// src/errors/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"
+      }
+    );
   }
 };
 
@@ -157,7 +893,10 @@ function padHex(hex_, { dir, size: size2 = 32 } = {}) {
       targetSize: size2,
       type: "hex"
     });
-  return "0x" + hex[dir === "right" ? "padEnd" : "padStart"](size2 * 2, "0");
+  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](
+    size2 * 2,
+    "0"
+  )}`;
 }
 function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
   if (bytes.length > size2)
@@ -173,18 +912,6 @@ function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
   }
   return paddedBytes;
 }
-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/utils/data/trim.ts
 function trim(hexOrBytes, { dir = "left" } = {}) {
@@ -199,7 +926,7 @@ function trim(hexOrBytes, { dir = "left" } = {}) {
   data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
   if (typeof hexOrBytes === "string") {
     if (data.length === 1 && dir === "right")
-      data = data + "0";
+      data = `${data}0`;
     return `0x${data}`;
   }
   return data;
@@ -312,7 +1039,7 @@ function encodeBytes(value) {
 function hexToBytes(hex_) {
   let hex = hex_.slice(2);
   if (hex.length % 2)
-    hex = "0" + hex;
+    hex = `0${hex}`;
   const bytes = new Uint8Array(hex.length / 2);
   for (let index = 0; index < bytes.length; index++) {
     const start = index * 2;
@@ -372,31 +1099,31 @@ function decodeHex(hex, to) {
     return hexToBool(hex);
   return hexToBytes(hex);
 }
-function hexToBigInt(hex) {
-  return BigInt(hex);
+function hexToBigInt(hex, opts = {}) {
+  const { signed } = opts;
+  const value = BigInt(hex);
+  if (!signed)
+    return value;
+  const size2 = (hex.length - 2) / 2;
+  const max = (1n << BigInt(size2) * 8n - 1n) - 1n;
+  if (value <= max)
+    return value;
+  return value - BigInt(`0x${"f".padStart(size2 * 2, "f")}`) - 1n;
 }
 function hexToBool(hex) {
-  if (hex === "0x0")
+  if (trim(hex) === "0x0")
     return false;
-  if (hex === "0x1")
+  if (trim(hex) === "0x1")
     return true;
   throw new InvalidHexBooleanError(hex);
 }
-function hexToNumber(hex) {
-  return Number(BigInt(hex));
+function hexToNumber(hex, opts = {}) {
+  return Number(hexToBigInt(hex, opts));
 }
 function hexToString(hex) {
   const bytes = hexToBytes(hex);
   return new TextDecoder().decode(bytes);
 }
-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");
-  }
-};
 
 // src/utils/encoding/decodeBytes.ts
 function decodeBytes(bytes, to) {
@@ -426,14 +1153,6 @@ function bytesToNumber(bytes) {
 function bytesToString(bytes) {
   return new TextDecoder().decode(bytes);
 }
-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");
-  }
-};
 
 // src/utils/encoding/decodeRlp.ts
 function decodeRlp(value, to) {
@@ -515,40 +1234,8 @@ function rlpToBytes(bytes, offset = 0) {
   }
   return [result, consumed];
 }
-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 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/utils/solidity.ts
+// src/utils/contract/extractFunctionParts.ts
 var paramsRegex = /((function|event)\s)?(.*)(\((.*)\))/;
 function extractFunctionParts(def) {
   const parts = def.match(paramsRegex);
@@ -573,6 +1260,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_) {
@@ -597,7 +1327,7 @@ function hashFunction(def) {
 var getEventSignature = (event) => hashFunction(event);
 
 // src/utils/hash/getFunctionSignature.ts
-var getFunctionSignature = (fn) => hashFunction(fn).slice(0, 10);
+var getFunctionSignature = (fn) => slice(hashFunction(fn), 0, 4);
 
 // src/utils/address/getAddress.ts
 var addressRegex = /^(0x)?[a-fA-F0-9]{40}$/;
@@ -606,10 +1336,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();
     }
   }
@@ -620,12 +1350,6 @@ function getAddress(address) {
     throw new InvalidAddressError({ address });
   return checksumAddress(address);
 }
-var InvalidAddressError = class extends BaseError {
-  constructor({ address }) {
-    super(`Address "${address}" is invalid.`);
-    __publicField(this, "name", "InvalidAddressError");
-  }
-};
 
 // src/utils/address/getContractAddress.ts
 function getContractAddress(opts) {
@@ -639,7 +1363,7 @@ function getCreateAddress(opts) {
   if (nonce[0] === 0)
     nonce = new Uint8Array([]);
   return getAddress(
-    "0x" + keccak256(encodeRlp([from, nonce], "bytes")).slice(26)
+    `0x${keccak256(encodeRlp([from, nonce], "bytes")).slice(26)}`
   );
 }
 function getCreate2Address(opts) {
@@ -661,18 +1385,600 @@ function getCreate2Address(opts) {
   );
 }
 
-// src/utils/address/isAddress.ts
-function isAddress(address) {
-  try {
-    return Boolean(getAddress(address));
-  } catch {
-    return false;
+// 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);
+}
+
+// src/utils/abi/encodeAbi.ts
+function encodeAbi({
+  params,
+  values
+}) {
+  if (params.length !== values.length)
+    throw new AbiEncodingLengthMismatchError({
+      expectedLength: params.length,
+      givenLength: values.length
+    });
+  const preparedParams = prepareParams({ params, values });
+  const data = encodeParams(preparedParams);
+  if (data.length === 0)
+    return "0x";
+  return data;
+}
+function prepareParams({
+  params,
+  values
+}) {
+  let preparedParams = [];
+  for (let i = 0; i < params.length; i++) {
+    preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
+  }
+  return preparedParams;
+}
+function prepareParam({
+  param,
+  value
+}) {
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents) {
+    const [length, type] = arrayComponents;
+    return encodeArray(value, { length, param: { ...param, type } });
+  }
+  if (param.type === "tuple") {
+    return encodeTuple(value, {
+      param
+    });
+  }
+  if (param.type === "address") {
+    return encodeAddress(value);
+  }
+  if (param.type === "bool") {
+    return encodeBool(value);
+  }
+  if (param.type.startsWith("uint") || param.type.startsWith("int")) {
+    const signed = param.type.startsWith("int");
+    return encodeNumber(value, { signed });
+  }
+  if (param.type.startsWith("bytes")) {
+    return encodeBytes2(value, { param });
+  }
+  if (param.type === "string") {
+    return encodeString(value);
+  }
+  throw new InvalidAbiEncodingTypeError(param.type, {
+    docsPath: "/docs/contract/encodeAbi"
+  });
+}
+function encodeParams(preparedParams) {
+  let staticSize = 0;
+  for (let i = 0; i < preparedParams.length; i++) {
+    const { dynamic, encoded } = preparedParams[i];
+    if (dynamic)
+      staticSize += 32;
+    else
+      staticSize += size(encoded);
+  }
+  let staticParams = [];
+  let dynamicParams = [];
+  let dynamicSize = 0;
+  for (let i = 0; i < preparedParams.length; i++) {
+    const { dynamic, encoded } = preparedParams[i];
+    if (dynamic) {
+      staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
+      dynamicParams.push(encoded);
+      dynamicSize += size(encoded);
+    } else {
+      staticParams.push(encoded);
+    }
+  }
+  return concat([...staticParams, ...dynamicParams]);
+}
+function encodeAddress(value) {
+  return { dynamic: false, encoded: padHex(value.toLowerCase()) };
+}
+function encodeArray(value, {
+  length,
+  param
+}) {
+  let dynamic = length === null;
+  if (!Array.isArray(value))
+    throw new InvalidArrayError(value);
+  if (!dynamic && value.length !== length)
+    throw new AbiEncodingArrayLengthMismatchError({
+      expectedLength: length,
+      givenLength: value.length,
+      type: `${param.type}[${length}]`
+    });
+  let dynamicChild = false;
+  let preparedParams = [];
+  for (let i = 0; i < value.length; i++) {
+    const preparedParam = prepareParam({ param, value: value[i] });
+    if (preparedParam.dynamic)
+      dynamicChild = true;
+    preparedParams.push(preparedParam);
+  }
+  if (dynamic || dynamicChild) {
+    const data = encodeParams(preparedParams);
+    if (dynamic) {
+      const length2 = numberToHex(preparedParams.length, { size: 32 });
+      return {
+        dynamic: true,
+        encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
+      };
+    }
+    if (dynamicChild)
+      return { dynamic: true, encoded: data };
+  }
+  return {
+    dynamic: false,
+    encoded: concat(preparedParams.map(({ encoded }) => encoded))
+  };
+}
+function encodeBytes2(value, { param }) {
+  const [_, size_] = param.type.split("bytes");
+  if (!size_)
+    return {
+      dynamic: true,
+      encoded: concat([
+        padHex(numberToHex(size(value), { size: 32 })),
+        padHex(value, { dir: "right" })
+      ])
+    };
+  return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
+}
+function encodeBool(value) {
+  return { dynamic: false, encoded: padHex(boolToHex(value)) };
+}
+function encodeNumber(value, { signed }) {
+  return {
+    dynamic: false,
+    encoded: numberToHex(value, {
+      size: 32,
+      signed
+    })
+  };
+}
+function encodeString(value) {
+  return {
+    dynamic: true,
+    encoded: concat([
+      padHex(numberToHex(value.length, { size: 32 })),
+      padHex(stringToHex(value), { dir: "right" })
+    ])
+  };
+}
+function encodeTuple(value, { param }) {
+  let dynamic = false;
+  let preparedParams = [];
+  for (let i = 0; i < param.components.length; i++) {
+    const param_ = param.components[i];
+    const index = Array.isArray(value) ? i : param_.name;
+    const preparedParam = prepareParam({
+      param: param_,
+      value: value[index]
+    });
+    preparedParams.push(preparedParam);
+    dynamic = preparedParam.dynamic;
+  }
+  return {
+    dynamic,
+    encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
+  };
+}
+function getArrayComponents(type) {
+  const matches = type.match(/^(.*)\[(\d+)?\]$/);
+  return matches ? [matches[2] ? Number(matches[2]) : null, matches[1]] : void 0;
+}
+
+// src/utils/abi/decodeAbi.ts
+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({
+    data,
+    params
+  });
+  if (values.length === 0)
+    return void 0;
+  return values;
+}
+function decodeParams({
+  data,
+  params
+}) {
+  let decodedValues = [];
+  let position = 0;
+  for (let i = 0; i < params.length; i++) {
+    const param = params[i];
+    const { consumed, value } = decodeParam({ data, param, position });
+    decodedValues.push(value);
+    position += consumed;
+  }
+  return decodedValues;
+}
+function decodeParam({
+  data,
+  param,
+  position
+}) {
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents) {
+    const [length, type] = arrayComponents;
+    return decodeArray(data, {
+      length,
+      param: { ...param, type },
+      position
+    });
+  }
+  if (param.type === "tuple") {
+    return decodeTuple(data, { param, position });
+  }
+  if (param.type === "string") {
+    return decodeString(data, { position });
+  }
+  if (param.type.startsWith("bytes")) {
+    return decodeBytes2(data, { param, position });
+  }
+  let value = slice(data, position, position + 32);
+  if (param.type.startsWith("uint") || param.type.startsWith("int")) {
+    return decodeNumber(value, { param });
+  }
+  if (param.type === "address") {
+    return decodeAddress(value);
+  }
+  if (param.type === "bool") {
+    return decodeBool(value);
+  }
+  throw new InvalidAbiDecodingTypeError(param.type, {
+    docsPath: "/docs/contract/decodeAbi"
+  });
+}
+function decodeAddress(value) {
+  return { consumed: 32, value: checksumAddress(slice(value, -20)) };
+}
+function decodeArray(data, {
+  param,
+  length,
+  position
+}) {
+  if (!length) {
+    const offset = hexToNumber(slice(data, position, position + 32));
+    const length2 = hexToNumber(slice(data, offset, offset + 32));
+    let consumed2 = 0;
+    let value2 = [];
+    for (let i = 0; i < length2; ++i) {
+      const decodedChild = decodeParam({
+        data: slice(data, offset + 32),
+        param,
+        position: consumed2
+      });
+      consumed2 += decodedChild.consumed;
+      value2.push(decodedChild.value);
+    }
+    return { value: value2, consumed: 32 };
+  }
+  if (hasDynamicChild(param)) {
+    const arrayComponents = getArrayComponents(param.type);
+    const dynamicChild = !arrayComponents?.[0];
+    let consumed2 = 0;
+    let value2 = [];
+    for (let i = 0; i < length; ++i) {
+      const offset = hexToNumber(slice(data, position, position + 32));
+      const decodedChild = decodeParam({
+        data: slice(data, offset),
+        param,
+        position: dynamicChild ? consumed2 : i * 32
+      });
+      consumed2 += decodedChild.consumed;
+      value2.push(decodedChild.value);
+    }
+    return { value: value2, consumed: consumed2 };
+  }
+  let consumed = 0;
+  let value = [];
+  for (let i = 0; i < length; ++i) {
+    const decodedChild = decodeParam({
+      data,
+      param,
+      position: position + consumed
+    });
+    consumed += decodedChild.consumed;
+    value.push(decodedChild.value);
+  }
+  return { value, consumed };
+}
+function decodeBool(value) {
+  return { consumed: 32, value: hexToBool(value) };
+}
+function decodeBytes2(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);
+    return { consumed: 32, value: value2 };
+  }
+  const value = slice(data, position, position + parseInt(size2));
+  return { consumed: 32, value };
+}
+function decodeNumber(value, { param }) {
+  const signed = param.type.startsWith("int");
+  const size2 = parseInt(param.type.split("int")[1] || "256");
+  return {
+    consumed: 32,
+    value: size2 > 48 ? hexToBigInt(value, { signed }) : hexToNumber(value, { signed })
+  };
+}
+function decodeString(data, { position }) {
+  const offset = hexToNumber(slice(data, position, position + 32));
+  const length = hexToNumber(slice(data, offset, offset + 32));
+  const value = hexToString(
+    trim(slice(data, offset + 32, offset + 32 + length))
+  );
+  return { consumed: 32, value };
+}
+function decodeTuple(data, { param, position }) {
+  const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
+  let value = hasUnnamedChild ? [] : {};
+  let consumed = 0;
+  if (hasDynamicChild(param)) {
+    const offset = hexToNumber(slice(data, position, position + 32));
+    for (let i = 0; i < param.components.length; ++i) {
+      const component = param.components[i];
+      const decodedChild = decodeParam({
+        data: slice(data, offset),
+        param: component,
+        position: consumed
+      });
+      consumed += decodedChild.consumed;
+      value[hasUnnamedChild ? i : component?.name] = decodedChild.value;
+    }
+    return { consumed: 32, value };
+  }
+  for (let i = 0; i < param.components.length; ++i) {
+    const component = param.components[i];
+    const decodedChild = decodeParam({
+      data,
+      param: component,
+      position: position + consumed
+    });
+    consumed += decodedChild.consumed;
+    value[hasUnnamedChild ? i : component?.name] = decodedChild.value;
+  }
+  return { consumed, value };
+}
+function hasDynamicChild(param) {
+  const { type } = param;
+  if (type === "string")
+    return true;
+  if (type === "bytes")
+    return true;
+  if (type.endsWith("[]"))
+    return true;
+  if (type === "tuple")
+    return param.components?.some(hasDynamicChild);
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
+    return true;
+  return false;
+}
+
+// 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, { includeName }) {
+  if (!params)
+    return "";
+  return params.map((param) => getParam(param, { includeName })).join(includeName ? ", " : ",");
+}
+function getParam(param, { includeName }) {
+  if (param.type.startsWith("tuple")) {
+    return `(${getParams(
+      param.components,
+      { includeName }
+    )})${param.type.slice("tuple".length)}`;
+  }
+  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(formatAbiItemWithParams(x))
+  );
+  if (!description)
+    throw new AbiErrorSignatureNotFoundError(signature, {
+      docsPath: "/docs/contract/decodeErrorResult"
+    });
+  return {
+    errorName: description.name,
+    args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbi({ data: slice(data, 4), params: description.inputs }) : void 0
+  };
+}
+
+// src/utils/abi/decodeFunctionData.ts
+function decodeFunctionData({ abi, data }) {
+  const signature = slice(data, 0, 4);
+  const description = abi.find(
+    (x) => signature === getFunctionSignature(formatAbiItemWithParams(x))
+  );
+  if (!description)
+    throw new AbiFunctionSignatureNotFoundError(signature, {
+      docsPath: "/docs/contract/decodeFunctionData"
+    });
+  return {
+    functionName: description.name,
+    args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbi({ data: slice(data, 4), params: description.inputs }) : void 0
+  };
+}
+
+// src/utils/abi/decodeFunctionResult.ts
+var docsPath = "/docs/contract/decodeFunctionResult";
+function decodeFunctionResult({
+  abi,
+  functionName,
+  data
+}) {
+  const description = abi.find(
+    (x) => "name" in x && x.name === functionName
+  );
+  if (!description)
+    throw new AbiFunctionNotFoundError(functionName, { docsPath });
+  if (!("outputs" in description))
+    throw new AbiFunctionOutputsNotFoundError(functionName, { docsPath });
+  const values = decodeAbi({ data, params: description.outputs });
+  if (values && values.length > 1)
+    return values;
+  if (values && values.length === 1)
+    return values[0];
+  return void 0;
+}
+
+// src/utils/abi/encodeDeployData.ts
+var docsPath2 = "/docs/contract/encodeDeployData";
+function encodeDeployData({
+  abi,
+  args,
+  bytecode
+}) {
+  if (!args || args.length === 0)
+    return bytecode;
+  const description = abi.find((x) => "type" in x && x.type === "constructor");
+  if (!description)
+    throw new AbiConstructorNotFoundError({ docsPath: docsPath2 });
+  if (!("inputs" in description))
+    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
+  });
+  return concatHex([bytecode, data]);
+}
+
+// src/utils/abi/getAbiItem.ts
+function getAbiItem({ abi, name }) {
+  return abi.find((x) => "name" in x && x.name === name);
+}
+
+// src/utils/abi/encodeErrorResult.ts
+var docsPath3 = "/docs/contract/encodeErrorResult";
+function encodeErrorResult({ abi, errorName, args }) {
+  const description = getAbiItem({ abi, name: errorName });
+  if (!description)
+    throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath3 });
+  const definition = formatAbiItemWithParams(description);
+  const signature = getFunctionSignature(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 });
+  }
+  return concatHex([signature, data]);
+}
+
+// src/utils/abi/encodeEventTopics.ts
+function encodeEventTopics({ abi, eventName, args }) {
+  const abiItem = getAbiItem({ abi, name: eventName });
+  if (!abiItem)
+    throw new AbiEventNotFoundError(eventName, {
+      docsPath: "/docs/contract/encodeEventTopics"
+    });
+  const definition = formatAbiItemWithParams(abiItem);
+  const signature = getEventSignature(definition);
+  let topics = [];
+  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
+    ) ?? [];
   }
+  return [signature, ...topics];
+}
+function encodeArg({
+  param,
+  value
+}) {
+  if (param.type === "string" || param.type === "bytes")
+    return keccak256(encodeBytes(value));
+  if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
+    throw new FilterTypeNotSupportedError(param.type);
+  return encodeAbi({ params: [param], values: [value] });
 }
 
-// src/utils/address/isAddressEqual.ts
-function isAddressEqual(a, b) {
-  return getAddress(a) === getAddress(b);
+// src/utils/abi/encodeFunctionData.ts
+function encodeFunctionData({ abi, args, functionName }) {
+  const description = getAbiItem({ abi, name: functionName });
+  if (!description)
+    throw new AbiFunctionNotFoundError(functionName, {
+      docsPath: "/docs/contract/encodeFunctionData"
+    });
+  const definition = formatAbiItemWithParams(description);
+  const signature = getFunctionSignature(definition);
+  const data = "inputs" in description && description.inputs ? encodeAbi({
+    params: description.inputs,
+    values: args ?? []
+  }) : void 0;
+  return concatHex([signature, data ?? "0x"]);
+}
+
+// src/utils/abi/encodeFunctionResult.ts
+var docsPath4 = "/docs/contract/encodeFunctionResult";
+function encodeFunctionResult({
+  abi,
+  functionName,
+  result
+}) {
+  const description = abi.find((x) => "name" in x && x.name === functionName);
+  if (!description)
+    throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
+  if (!("outputs" in description))
+    throw new AbiFunctionOutputsNotFoundError(functionName, { docsPath: docsPath4 });
+  let values = Array.isArray(result) ? result : [result];
+  if (description.outputs.length === 0 && !values[0])
+    values = [];
+  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
@@ -712,131 +2018,6 @@ function buildRequest(request) {
     }
   };
 }
-var RequestError = class extends BaseError {
-  constructor(err, { docsPath, humanMessage }) {
-    super(humanMessage, {
-      cause: err,
-      docsPath
-    });
-    this.name = err.name;
-  }
-};
-var RpcRequestError = class extends RequestError {
-  constructor(err, { docsPath, humanMessage }) {
-    super(err, { docsPath, humanMessage });
-    __publicField(this, "code");
-    this.code = err.code;
-    this.name = err.name;
-  }
-};
-var ParseRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
-    });
-    __publicField(this, "name", "ParseRpcError");
-    __publicField(this, "code", -32700);
-  }
-};
-var InvalidRequestRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "JSON is not a valid request object." });
-    __publicField(this, "name", "InvalidRequestRpcError");
-    __publicField(this, "code", -32600);
-  }
-};
-var MethodNotFoundRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: "The method does not exist / is not available."
-    });
-    __publicField(this, "name", "MethodNotFoundRpcError");
-    __publicField(this, "code", -32601);
-  }
-};
-var InvalidParamsRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: [
-        "Invalid parameters were provided to the RPC method.",
-        "Double check you have provided the correct parameters."
-      ].join("\n")
-    });
-    __publicField(this, "name", "InvalidParamsRpcError");
-    __publicField(this, "code", -32602);
-  }
-};
-var InternalRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "An internal error was received." });
-    __publicField(this, "name", "InternalRpcError");
-    __publicField(this, "code", -32603);
-  }
-};
-var InvalidInputRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: [
-        "Missing or invalid parameters.",
-        "Double check you have provided the correct parameters."
-      ].join("\n")
-    });
-    __publicField(this, "name", "InvalidInputRpcError");
-    __publicField(this, "code", -32e3);
-  }
-};
-var ResourceNotFoundRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "Requested resource not found." });
-    __publicField(this, "name", "ResourceNotFoundRpcError");
-    __publicField(this, "code", -32001);
-  }
-};
-var ResourceUnavailableRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "Requested resource not available." });
-    __publicField(this, "name", "ResourceUnavailableRpcError");
-    __publicField(this, "code", -32002);
-  }
-};
-var TransactionRejectedRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "Transaction creation failed." });
-    __publicField(this, "name", "TransactionRejectedRpcError");
-    __publicField(this, "code", -32003);
-  }
-};
-var MethodNotSupportedRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "Method is not implemented." });
-    __publicField(this, "name", "MethodNotSupportedRpcError");
-    __publicField(this, "code", -32004);
-  }
-};
-var LimitExceededRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { humanMessage: "Request exceeds defined limit." });
-    __publicField(this, "name", "LimitExceededRpcError");
-    __publicField(this, "code", -32005);
-  }
-};
-var JsonRpcVersionUnsupportedError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: "Version of JSON-RPC protocol is not supported."
-    });
-    __publicField(this, "name", "JsonRpcVersionUnsupportedError");
-    __publicField(this, "code", -32006);
-  }
-};
-var UnknownRpcError = class extends RequestError {
-  constructor(err) {
-    super(err, {
-      humanMessage: "An unknown RPC error occurred."
-    });
-    __publicField(this, "name", "UnknownRpcError");
-  }
-};
 
 // src/constants.ts
 var etherUnits = {
@@ -1090,7 +2271,7 @@ async function http(url, {
             "Content-Type": "application/json"
           },
           method: "POST",
-          body: JSON.stringify({ jsonrpc: "2.0", id: id++, ...body }),
+          body: stringify({ jsonrpc: "2.0", id: id++, ...body }),
           signal: timeout > 0 ? signal : void 0
         });
         return response2;
@@ -1127,7 +2308,7 @@ async function http(url, {
   if (!response.ok) {
     throw new HttpRequestError({
       body,
-      details: JSON.stringify(data.error) || response.statusText,
+      details: stringify(data.error) || response.statusText,
       status: response.status,
       url
     });
@@ -1235,92 +2416,6 @@ var rpc = {
   webSocket,
   webSocketAsync
 };
-var HttpRequestError = class extends BaseError {
-  constructor({
-    body,
-    details,
-    status,
-    url
-  }) {
-    super(
-      [
-        "HTTP request failed.",
-        "",
-        `Status: ${status}`,
-        `URL: ${url}`,
-        `Request body: ${JSON.stringify(body)}`
-      ].join("\n"),
-      {
-        details
-      }
-    );
-    __publicField(this, "name", "HttpRequestError");
-    __publicField(this, "status");
-    this.status = status;
-  }
-};
-var WebSocketRequestError = class extends BaseError {
-  constructor({
-    body,
-    details,
-    url
-  }) {
-    super(
-      [
-        "WebSocket request failed.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${JSON.stringify(body)}`
-      ].join("\n"),
-      {
-        details
-      }
-    );
-    __publicField(this, "name", "WebSocketRequestError");
-  }
-};
-var RpcError = class extends BaseError {
-  constructor({
-    body,
-    error,
-    url
-  }) {
-    super(
-      [
-        "RPC Request failed.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${JSON.stringify(body)}`
-      ].join("\n"),
-      {
-        cause: error,
-        details: error.message
-      }
-    );
-    __publicField(this, "code");
-    __publicField(this, "name", "RpcError");
-    this.code = error.code;
-  }
-};
-var TimeoutError = class extends BaseError {
-  constructor({
-    body,
-    url
-  }) {
-    super(
-      [
-        "The request took too long to respond.",
-        "",
-        `URL: ${url}`,
-        `Request body: ${JSON.stringify(body)}`
-      ].join("\n"),
-      {
-        details: "The request timed out."
-      }
-    );
-    __publicField(this, "name", "TimeoutError");
-  }
-};
 
 // src/utils/unit/formatUnit.ts
 function formatUnit(value, decimals) {
@@ -1380,8 +2475,49 @@ function parseGwei(ether, unit = "wei") {
 }
 
 export {
-  __publicField,
+  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,
@@ -1414,9 +2550,11 @@ export {
   bytesToNumber,
   bytesToString,
   decodeRlp,
+  extractFunctionParts,
   extractFunctionName,
   extractFunctionParams,
   extractFunctionType,
+  getContractError,
   keccak256,
   getEventSignature,
   getFunctionSignature,
@@ -1427,20 +2565,20 @@ export {
   getCreate2Address,
   isAddress,
   isAddressEqual,
+  encodeAbi,
+  decodeAbi,
+  formatAbiItemWithParams,
+  decodeErrorResult,
+  decodeFunctionData,
+  decodeFunctionResult,
+  encodeDeployData,
+  getAbiItem,
+  encodeErrorResult,
+  encodeEventTopics,
+  encodeFunctionData,
+  encodeFunctionResult,
+  formatAbiItemWithArgs,
   buildRequest,
-  RpcRequestError,
-  ParseRpcError,
-  InvalidRequestRpcError,
-  MethodNotFoundRpcError,
-  InvalidParamsRpcError,
-  InternalRpcError,
-  InvalidInputRpcError,
-  ResourceNotFoundRpcError,
-  ResourceUnavailableRpcError,
-  TransactionRejectedRpcError,
-  MethodNotSupportedRpcError,
-  LimitExceededRpcError,
-  JsonRpcVersionUnsupportedError,
   etherUnits,
   gweiUnits,
   weiUnits,
@@ -1457,13 +2595,19 @@ export {
   wait,
   getSocket,
   rpc,
-  HttpRequestError,
-  RpcError,
-  TimeoutError,
   formatUnit,
   formatEther,
   formatGwei,
   parseUnit,
   parseEther,
-  parseGwei
+  parseGwei,
+  HttpRequestError,
+  WebSocketRequestError,
+  RpcError,
+  TimeoutError,
+  InvalidGasArgumentsError,
+  TransactionNotFoundError,
+  TransactionReceiptNotFoundError,
+  WaitForTransactionReceiptTimeoutError,
+  UrlRequiredError
 };