viem 0.0.1-alpha.21 → 0.0.1-alpha.23

package/dist/{chunk-62VTYU2V.mjs → chunk-XBUH66KN.mjs}

@@ -9,7 +9,7 @@ var __publicField = (obj, key, value) => {
 var package_default = {
   name: "viem",
   description: "TypeScript Interface for Ethereum",
-  version: "0.0.1-alpha.21",
+  version: "0.0.1-alpha.23",
   scripts: {
     anvil: "source .env && anvil --fork-url $VITE_ANVIL_FORK_URL --fork-block-number $VITE_ANVIL_BLOCK_NUMBER --block-time $VITE_ANVIL_BLOCK_TIME",
     bench: "vitest bench --no-threads",
@@ -18,6 +18,7 @@ var package_default = {
     changeset: "changeset",
     "changeset:release": "pnpm build && changeset publish",
     "changeset:version": "changeset version && pnpm install --lockfile-only",
+    "contracts:build": "wagmi generate",
     dev: "DEV=true tsup",
     "dev:docs": "pnpm -r --filter site dev",
     format: "rome format src/ test/ --write",
@@ -25,11 +26,11 @@ var package_default = {
     "lint:fix": "pnpm lint --apply-suggested",
     playground: "pnpm --filter playground-dev dev",
     "playground:benchmark": "pnpm --filter playground-benchmark dev",
-    postinstall: "pnpm dev",
+    postinstall: "pnpm dev && pnpm contracts:build",
     preinstall: "npx only-allow pnpm",
     prepublishOnly: "pnpm ts-node scripts/generate-package-json.ts",
     prepare: "npx simple-git-hooks",
-    test: "vitest dev --coverage --no-threads",
+    test: "vitest dev --no-threads",
     "test:ci": "CI=true vitest --coverage --no-threads",
     "test:ui": "vitest dev --ui --no-threads",
     "ts-node": "node --loader esbuild-register/loader -r esbuild-register",
@@ -61,6 +62,11 @@ var package_default = {
       module: "./dist/clients/index.mjs",
       default: "./dist/clients/index.js"
     },
+    "./ens": {
+      types: "./dist/ens.d.ts",
+      module: "./dist/ens.mjs",
+      default: "./dist/ens.js"
+    },
     "./public": {
       types: "./dist/public.d.ts",
       module: "./dist/public.mjs",
@@ -95,11 +101,13 @@ var package_default = {
   dependencies: {
     "@noble/hashes": "^1.1.2",
     "@wagmi/chains": "~0.2.6",
-    abitype: "~0.2.5"
+    abitype: "~0.3.0",
+    "idna-uts46-hx": "^4.1.2"
   },
   devDependencies: {
     "@actions/core": "^1.10.0",
     "@actions/github": "^5.1.1",
+    "@adraffy/ens-normalize": "^1.8.9",
     "@changesets/changelog-github": "^0.4.5",
     "@changesets/cli": "^2.23.2",
     "@testing-library/jest-dom": "^5.16.5",
@@ -108,19 +116,20 @@ var package_default = {
     "@types/node": "^17.0.45",
     "@vitest/coverage-c8": "^0.24.3",
     "@vitest/ui": "^0.19.1",
+    "@wagmi/cli": "^0.1.5",
     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",
+    "ethers@6": "npm:ethers@^6.0.2",
     execa: "^6.1.0",
     "fs-extra": "^10.1.0",
     jsdom: "^20.0.0",
     rome: "^11.0.0",
     "simple-git-hooks": "^2.8.1",
     tsup: "^6.5.0",
-    typescript: "^4.9.3",
+    typescript: "^4.9.4",
     vite: "^3.0.4",
     vitest: "^0.25.2",
     web3: "^1.8.1"
@@ -148,38 +157,32 @@ var package_default = {
   }
 };
 
-// src/utils/stringify.ts
-function stringify(value) {
-  return JSON.stringify(
-    value,
-    (_, value2) => typeof value2 === "bigint" ? value2.toString() : value2
-  );
-}
-
 // src/errors/base.ts
 var version = process.env.TEST ? "1.0.2" : package_default.version;
 var BaseError = class extends Error {
-  constructor(humanMessage, args = {}) {
+  constructor(shortMessage, args = {}) {
     const details = args.cause instanceof BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
     const docsPath5 = args.cause instanceof BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
     const message = [
-      humanMessage,
-      ...docsPath5 ? ["", `Docs: https://viem.sh${docsPath5}`] : [],
+      shortMessage || "An error occurred.",
       "",
+      ...args.metaMessages ? [...args.metaMessages, ""] : [],
+      ...docsPath5 ? [`Docs: https://viem.sh${docsPath5}`] : [],
       ...details ? [`Details: ${details}`] : [],
-      `Version: viem@${version}`,
-      ...args.cause && !(args.cause instanceof BaseError) && Object.keys(args.cause).length > 0 ? [`Internal Error: ${stringify(args.cause)}`] : []
+      `Version: viem@${version}`
     ].join("\n");
     super(message);
-    __publicField(this, "humanMessage");
     __publicField(this, "details");
     __publicField(this, "docsPath");
+    __publicField(this, "metaMessages");
+    __publicField(this, "shortMessage");
     __publicField(this, "name", "ViemError");
     if (args.cause)
       this.cause = args.cause;
     this.details = details;
     this.docsPath = docsPath5;
-    this.humanMessage = humanMessage;
+    this.metaMessages = args.metaMessages;
+    this.shortMessage = shortMessage;
   }
 };
 
@@ -428,82 +431,201 @@ var BlockNotFoundError = class extends BaseError {
   }
 };
 
+// src/constants/abis.ts
+var multicall3Abi = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            name: "target",
+            type: "address"
+          },
+          {
+            name: "allowFailure",
+            type: "bool"
+          },
+          {
+            name: "callData",
+            type: "bytes"
+          }
+        ],
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "aggregate3",
+    outputs: [
+      {
+        components: [
+          {
+            name: "success",
+            type: "bool"
+          },
+          {
+            name: "returnData",
+            type: "bytes"
+          }
+        ],
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/constants/solidity.ts
+var panicReasons = {
+  1: "An `assert` condition failed.",
+  17: "Arithmic operation resulted in underflow or overflow.",
+  18: "Division or modulo by zero (e.g. `5 / 0` or `23 % 0`).",
+  33: "Attempted to convert to an invalid type.",
+  34: "Attempted to access a storage byte array that is incorrectly encoded.",
+  49: "Performed `.pop()` on an empty array",
+  50: "Array index is out of bounds.",
+  65: "Allocated too much memory or created an array which is too large.",
+  81: "Attempted to call a zero-initialized variable of internal function type."
+};
+var solidityError = {
+  inputs: [
+    {
+      name: "message",
+      type: "string"
+    }
+  ],
+  name: "Error",
+  type: "error"
+};
+var solidityPanic = {
+  inputs: [
+    {
+      name: "reason",
+      type: "uint256"
+    }
+  ],
+  name: "Panic",
+  type: "error"
+};
+
 // src/errors/contract.ts
-var ContractMethodExecutionError = class extends BaseError {
-  constructor(message, {
+var ContractFunctionExecutionError = class extends BaseError {
+  constructor(cause, {
     abi,
     args,
-    cause,
     contractAddress,
-    formattedArgs,
+    docsPath: docsPath5,
     functionName,
-    functionWithParams,
     sender
-  } = {}) {
+  }) {
+    const abiItem = getAbiItem({ abi, args, name: functionName });
+    const formattedArgs = abiItem ? formatAbiItemWithArgs({
+      abiItem,
+      args,
+      includeFunctionName: false,
+      includeName: false
+    }) : void 0;
+    const functionWithParams = abiItem ? formatAbiItem(abiItem, { includeName: true }) : void 0;
     super(
-      [
-        message,
-        " ",
-        sender && `Sender:    ${sender}`,
-        contractAddress && `Contract:  ${process.env.TEST ? "0x0000000000000000000000000000000000000000" : contractAddress}`,
-        functionWithParams && `Function:  ${functionWithParams}`,
-        formattedArgs && `Arguments: ${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`
-      ].filter(Boolean).join("\n"),
+      cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`,
       {
-        cause
+        cause,
+        docsPath: docsPath5,
+        metaMessages: [
+          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+          contractAddress && `Contract:  ${process.env.TEST ? "0x0000000000000000000000000000000000000000" : contractAddress}`,
+          functionWithParams && `Function:  ${functionWithParams}`,
+          formattedArgs && formattedArgs !== "()" && `Arguments: ${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
+          sender && `Sender:    ${sender}`
+        ].filter(Boolean)
       }
     );
     __publicField(this, "abi");
     __publicField(this, "args");
+    __publicField(this, "cause");
     __publicField(this, "contractAddress");
     __publicField(this, "formattedArgs");
     __publicField(this, "functionName");
-    __publicField(this, "reason");
     __publicField(this, "sender");
-    __publicField(this, "name", "ContractMethodExecutionError");
-    if (message)
-      this.reason = message;
+    __publicField(this, "name", "ContractFunctionExecutionError");
     this.abi = abi;
     this.args = args;
+    this.cause = cause;
     this.contractAddress = contractAddress;
     this.functionName = functionName;
     this.sender = sender;
   }
 };
-var ContractMethodZeroDataError = class extends BaseError {
+var ContractFunctionRevertedError = class extends BaseError {
   constructor({
     abi,
-    args,
-    cause,
-    contractAddress,
+    data,
     functionName,
-    functionWithParams
-  } = {}) {
+    message
+  }) {
+    let decodedData = void 0;
+    let metaMessages;
+    let reason;
+    if (data && data !== "0x") {
+      decodedData = decodeErrorResult({ abi, data });
+      const { abiItem, errorName, args: errorArgs } = decodedData;
+      if (errorName === "Error") {
+        reason = errorArgs[0];
+      } else if (errorName === "Panic") {
+        const [firstArg] = errorArgs;
+        reason = panicReasons[firstArg];
+      } else if (errorArgs) {
+        const errorWithParams = abiItem ? formatAbiItem(abiItem, { includeName: true }) : void 0;
+        const formattedArgs = abiItem ? formatAbiItemWithArgs({
+          abiItem,
+          args: errorArgs,
+          includeFunctionName: false,
+          includeName: false
+        }) : void 0;
+        metaMessages = [
+          errorWithParams ? `Error:     ${errorWithParams}` : "",
+          formattedArgs && formattedArgs !== "()" ? `Arguments: ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
+        ];
+      }
+    } else if (message)
+      reason = message;
     super(
-      [
-        `The contract method "${functionName}" returned no data ("0x"). This could be due to any of the following:`,
-        `- The contract does not have the function "${functionName}",`,
-        "- The parameters passed to the contract function may be invalid, or",
-        "- The address is not a contract.",
-        " ",
-        contractAddress && `Contract: ${process.env.TEST ? "0x0000000000000000000000000000000000000000" : contractAddress}`,
-        functionWithParams && `Function: ${functionWithParams}`,
-        functionWithParams && `        > "0x"`
-      ].filter(Boolean).join("\n"),
+      reason ? [
+        `The contract function "${functionName}" reverted with the following reason:`,
+        reason
+      ].join("\n") : `The contract function "${functionName}" reverted.`,
       {
-        cause
+        metaMessages
       }
     );
-    __publicField(this, "abi");
-    __publicField(this, "args");
-    __publicField(this, "contractAddress");
-    __publicField(this, "functionName");
-    __publicField(this, "functionWithParams");
-    __publicField(this, "name", "ContractMethodZeroDataError");
-    this.abi = abi;
-    this.args = args;
-    this.contractAddress = contractAddress;
-    this.functionName = functionName;
+    __publicField(this, "name", "ContractFunctionRevertedError");
+    __publicField(this, "data");
+    __publicField(this, "reason");
+    this.reason = reason;
+    this.data = decodedData;
+  }
+};
+var ContractFunctionZeroDataError = class extends BaseError {
+  constructor({ functionName }) {
+    super(`The contract function "${functionName}" returned no data ("0x").`, {
+      metaMessages: [
+        "This could be due to any of the following:",
+        `- The contract does not have the function "${functionName}",`,
+        "- The parameters passed to the contract function may be invalid, or",
+        "- The address is not a contract."
+      ]
+    });
+    __publicField(this, "name", "ContractFunctionZeroDataError");
+  }
+};
+var RawContractError = class extends BaseError {
+  constructor({ data, message }) {
+    super(message || "");
+    __publicField(this, "code", 3);
+    __publicField(this, "name", "RawContractError");
+    __publicField(this, "data");
+    this.data = data;
   }
 };
 
@@ -581,8 +703,8 @@ var FilterTypeNotSupportedError = class extends BaseError {
 
 // src/errors/request.ts
 var RequestError = class extends BaseError {
-  constructor(err, { docsPath: docsPath5, humanMessage }) {
-    super(humanMessage, {
+  constructor(err, { docsPath: docsPath5, shortMessage }) {
+    super(shortMessage, {
       cause: err,
       docsPath: docsPath5
     });
@@ -590,8 +712,8 @@ var RequestError = class extends BaseError {
   }
 };
 var RpcRequestError = class extends RequestError {
-  constructor(err, { docsPath: docsPath5, humanMessage }) {
-    super(err, { docsPath: docsPath5, humanMessage });
+  constructor(err, { docsPath: docsPath5, shortMessage }) {
+    super(err, { docsPath: docsPath5, shortMessage });
     __publicField(this, "code");
     this.code = err.code;
     this.name = err.name;
@@ -600,7 +722,7 @@ var RpcRequestError = class extends RequestError {
 var ParseRpcError = class extends RpcRequestError {
   constructor(err) {
     super(err, {
-      humanMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
+      shortMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
     });
     __publicField(this, "name", "ParseRpcError");
     __publicField(this, "code", -32700);
@@ -608,7 +730,7 @@ var ParseRpcError = class extends RpcRequestError {
 };
 var InvalidRequestRpcError = class extends RpcRequestError {
   constructor(err) {
-    super(err, { humanMessage: "JSON is not a valid request object." });
+    super(err, { shortMessage: "JSON is not a valid request object." });
     __publicField(this, "name", "InvalidRequestRpcError");
     __publicField(this, "code", -32600);
   }
@@ -616,7 +738,7 @@ var InvalidRequestRpcError = class extends RpcRequestError {
 var MethodNotFoundRpcError = class extends RpcRequestError {
   constructor(err) {
     super(err, {
-      humanMessage: "The method does not exist / is not available."
+      shortMessage: "The method does not exist / is not available."
     });
     __publicField(this, "name", "MethodNotFoundRpcError");
     __publicField(this, "code", -32601);
@@ -625,7 +747,7 @@ var MethodNotFoundRpcError = class extends RpcRequestError {
 var InvalidParamsRpcError = class extends RpcRequestError {
   constructor(err) {
     super(err, {
-      humanMessage: [
+      shortMessage: [
         "Invalid parameters were provided to the RPC method.",
         "Double check you have provided the correct parameters."
       ].join("\n")
@@ -636,7 +758,7 @@ var InvalidParamsRpcError = class extends RpcRequestError {
 };
 var InternalRpcError = class extends RpcRequestError {
   constructor(err) {
-    super(err, { humanMessage: "An internal error was received." });
+    super(err, { shortMessage: "An internal error was received." });
     __publicField(this, "name", "InternalRpcError");
     __publicField(this, "code", -32603);
   }
@@ -644,7 +766,7 @@ var InternalRpcError = class extends RpcRequestError {
 var InvalidInputRpcError = class extends RpcRequestError {
   constructor(err) {
     super(err, {
-      humanMessage: [
+      shortMessage: [
         "Missing or invalid parameters.",
         "Double check you have provided the correct parameters."
       ].join("\n")
@@ -655,35 +777,35 @@ var InvalidInputRpcError = class extends RpcRequestError {
 };
 var ResourceNotFoundRpcError = class extends RpcRequestError {
   constructor(err) {
-    super(err, { humanMessage: "Requested resource not found." });
+    super(err, { shortMessage: "Requested resource not found." });
     __publicField(this, "name", "ResourceNotFoundRpcError");
     __publicField(this, "code", -32001);
   }
 };
 var ResourceUnavailableRpcError = class extends RpcRequestError {
   constructor(err) {
-    super(err, { humanMessage: "Requested resource not available." });
+    super(err, { shortMessage: "Requested resource not available." });
     __publicField(this, "name", "ResourceUnavailableRpcError");
     __publicField(this, "code", -32002);
   }
 };
 var TransactionRejectedRpcError = class extends RpcRequestError {
   constructor(err) {
-    super(err, { humanMessage: "Transaction creation failed." });
+    super(err, { shortMessage: "Transaction creation failed." });
     __publicField(this, "name", "TransactionRejectedRpcError");
     __publicField(this, "code", -32003);
   }
 };
 var MethodNotSupportedRpcError = class extends RpcRequestError {
   constructor(err) {
-    super(err, { humanMessage: "Method is not implemented." });
+    super(err, { shortMessage: "Method is not implemented." });
     __publicField(this, "name", "MethodNotSupportedRpcError");
     __publicField(this, "code", -32004);
   }
 };
 var LimitExceededRpcError = class extends RpcRequestError {
   constructor(err) {
-    super(err, { humanMessage: "Request exceeds defined limit." });
+    super(err, { shortMessage: "Request exceeds defined limit." });
     __publicField(this, "name", "LimitExceededRpcError");
     __publicField(this, "code", -32005);
   }
@@ -691,7 +813,7 @@ var LimitExceededRpcError = class extends RpcRequestError {
 var JsonRpcVersionUnsupportedError = class extends RpcRequestError {
   constructor(err) {
     super(err, {
-      humanMessage: "Version of JSON-RPC protocol is not supported."
+      shortMessage: "Version of JSON-RPC protocol is not supported."
     });
     __publicField(this, "name", "JsonRpcVersionUnsupportedError");
     __publicField(this, "code", -32006);
@@ -700,7 +822,7 @@ var JsonRpcVersionUnsupportedError = class extends RpcRequestError {
 var UnknownRpcError = class extends RequestError {
   constructor(err) {
     super(err, {
-      humanMessage: "An unknown RPC error occurred."
+      shortMessage: "An unknown RPC error occurred."
     });
     __publicField(this, "name", "UnknownRpcError");
   }
@@ -1277,46 +1399,35 @@ function extractFunctionType(def) {
 }
 
 // src/utils/contract/getContractError.ts
+var EXECUTION_REVERTED_ERROR_CODE = 3;
 function getContractError(err, {
   abi,
   address,
   args,
+  docsPath: docsPath5,
   functionName,
   sender
 }) {
-  const { code, message } = err.cause || {};
-  const abiItem = getAbiItem({ abi, name: functionName });
-  const formattedArgs = abiItem ? formatAbiItemWithArgs({
-    abiItem,
-    args,
-    includeFunctionName: false,
-    includeName: false
-  }) : void 0;
-  const functionWithParams = abiItem ? formatAbiItem(abiItem, { includeName: true }) : void 0;
+  const { code, data, message } = err instanceof RawContractError ? err : err.cause || {};
+  let cause = err;
   if (err instanceof AbiDecodingZeroDataError) {
-    return new ContractMethodZeroDataError({
+    cause = new ContractFunctionZeroDataError({ functionName });
+  } else if (code === EXECUTION_REVERTED_ERROR_CODE && (data || message)) {
+    cause = new ContractFunctionRevertedError({
       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,
+      data,
       functionName,
-      functionWithParams,
-      sender
+      message
     });
   }
-  return err;
+  return new ContractFunctionExecutionError(cause, {
+    abi,
+    args,
+    contractAddress: address,
+    docsPath: docsPath5,
+    functionName,
+    sender
+  });
 }
 
 // src/utils/hash/keccak256.ts
@@ -1416,16 +1527,16 @@ function isAddressEqual(a, b) {
 }
 
 // src/utils/abi/encodeAbi.ts
-function encodeAbi({
-  params,
-  values
-}) {
+function encodeAbi({ params, values }) {
   if (params.length !== values.length)
     throw new AbiEncodingLengthMismatchError({
       expectedLength: params.length,
       givenLength: values.length
     });
-  const preparedParams = prepareParams({ params, values });
+  const preparedParams = prepareParams({
+    params,
+    values
+  });
   const data = encodeParams(preparedParams);
   if (data.length === 0)
     return "0x";
@@ -1603,10 +1714,7 @@ function getArrayComponents(type) {
 }
 
 // src/utils/abi/decodeAbi.ts
-function decodeAbi({
-  data,
-  params
-}) {
+function decodeAbi({ data, params }) {
   if (data === "0x" && params.length > 0)
     throw new AbiDecodingZeroDataError();
   if (size(data) % 32 !== 0)
@@ -1822,18 +1930,25 @@ function getParam(param, { includeName }) {
 }
 
 // src/utils/abi/decodeErrorResult.ts
-function decodeErrorResult({ abi, data }) {
+function decodeErrorResult({
+  abi,
+  data
+}) {
   const signature = slice(data, 0, 4);
-  const description = abi.find(
-    (x) => signature === getFunctionSignature(formatAbiItem(x))
+  if (signature === "0x")
+    throw new AbiDecodingZeroDataError();
+  const abi_ = [...abi || [], solidityError, solidityPanic];
+  const abiItem = abi_.find(
+    (x) => x.type === "error" && signature === getFunctionSignature(formatAbiItem(x))
   );
-  if (!description)
+  if (!abiItem)
     throw new AbiErrorSignatureNotFoundError(signature, {
       docsPath: "/docs/contract/decodeErrorResult"
     });
   return {
-    errorName: description.name,
-    args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbi({ data: slice(data, 4), params: description.inputs }) : void 0
+    abiItem,
+    args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbi({ data: slice(data, 4), params: abiItem.inputs }) : void 0,
+    errorName: abiItem.name
   };
 }
 
@@ -1853,16 +1968,90 @@ function decodeFunctionData({ abi, data }) {
   };
 }
 
+// src/utils/abi/getAbiItem.ts
+function getAbiItem({ abi, args = [], name }) {
+  const abiItems = abi.filter((x) => "name" in x && x.name === name);
+  if (abiItems.length === 0)
+    return void 0;
+  if (abiItems.length === 1)
+    return abiItems[0];
+  for (const abiItem of abiItems) {
+    if (!("inputs" in abiItem))
+      continue;
+    if (!args || args.length === 0) {
+      if (!abiItem.inputs || abiItem.inputs.length === 0)
+        return abiItem;
+      continue;
+    }
+    if (!abiItem.inputs)
+      continue;
+    if (abiItem.inputs.length === 0)
+      continue;
+    const matched = args.every((arg, index) => {
+      const abiParameter = "inputs" in abiItem && abiItem.inputs[index];
+      if (!abiParameter)
+        return false;
+      return isArgOfType(arg, abiParameter);
+    });
+    if (matched)
+      return abiItem;
+  }
+  return abiItems[0];
+}
+function isArgOfType(arg, abiParameter) {
+  const argType = typeof arg;
+  const abiParameterType = abiParameter.type;
+  switch (abiParameterType) {
+    case "address":
+      return isAddress(arg);
+    case "bool":
+      return argType === "boolean";
+    case "function":
+      return argType === "string";
+    case "string":
+      return argType === "string";
+    default: {
+      if (abiParameterType === "tuple" && "components" in abiParameter)
+        return Object.values(abiParameter.components).every(
+          (component, index) => {
+            return isArgOfType(
+              Object.values(arg)[index],
+              component
+            );
+          }
+        );
+      if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(
+        abiParameterType
+      ))
+        return argType === "number" || argType === "bigint";
+      if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
+        return argType === "string" || arg instanceof Uint8Array;
+      if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
+        return Array.isArray(arg) && arg.every(
+          (x) => isArgOfType(x, {
+            ...abiParameter,
+            type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
+          })
+        );
+      }
+      return false;
+    }
+  }
+}
+
 // src/utils/abi/decodeFunctionResult.ts
 var docsPath = "/docs/contract/decodeFunctionResult";
 function decodeFunctionResult({
   abi,
+  args,
   functionName,
   data
 }) {
-  const description = abi.find(
-    (x) => "name" in x && x.name === functionName
-  );
+  const description = getAbiItem({
+    abi,
+    args,
+    name: functionName
+  });
   if (!description)
     throw new AbiFunctionNotFoundError(functionName, { docsPath });
   if (!("outputs" in description))
@@ -1884,7 +2073,9 @@ function encodeDeployData({
 }) {
   if (!args || args.length === 0)
     return bytecode;
-  const description = abi.find((x) => "type" in x && x.type === "constructor");
+  const description = abi.find(
+    (x) => "type" in x && x.type === "constructor"
+  );
   if (!description)
     throw new AbiConstructorNotFoundError({ docsPath: docsPath2 });
   if (!("inputs" in description))
@@ -1898,15 +2089,14 @@ function encodeDeployData({
   return concatHex([bytecode, data]);
 }
 
-// src/utils/abi/getAbiItem.ts
-function getAbiItem({ abi, name }) {
-  return abi.find((x) => "name" in x && x.name === name);
-}
-
 // src/utils/abi/encodeErrorResult.ts
 var docsPath3 = "/docs/contract/encodeErrorResult";
 function encodeErrorResult({ abi, errorName, args }) {
-  const description = getAbiItem({ abi, name: errorName });
+  const description = getAbiItem({
+    abi,
+    args,
+    name: errorName
+  });
   if (!description)
     throw new AbiErrorNotFoundError(errorName, { docsPath: docsPath3 });
   const definition = formatAbiItem(description);
@@ -1922,7 +2112,7 @@ function encodeErrorResult({ abi, errorName, args }) {
 
 // src/utils/abi/encodeEventTopics.ts
 function encodeEventTopics({ abi, eventName, args }) {
-  const abiItem = getAbiItem({ abi, name: eventName });
+  const abiItem = getAbiItem({ abi, args, name: eventName });
   if (!abiItem)
     throw new AbiEventNotFoundError(eventName, {
       docsPath: "/docs/contract/encodeEventTopics"
@@ -1953,7 +2143,11 @@ function encodeArg({
 
 // src/utils/abi/encodeFunctionData.ts
 function encodeFunctionData({ abi, args, functionName }) {
-  const description = getAbiItem({ abi, name: functionName });
+  const description = getAbiItem({
+    abi,
+    args,
+    name: functionName
+  });
   if (!description)
     throw new AbiFunctionNotFoundError(functionName, {
       docsPath: "/docs/contract/encodeFunctionData"
@@ -1974,7 +2168,9 @@ function encodeFunctionResult({
   functionName,
   result
 }) {
-  const description = abi.find((x) => "name" in x && x.name === functionName);
+  const description = abi.find(
+    (x) => "name" in x && x.name === functionName
+  );
   if (!description)
     throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath4 });
   if (!("outputs" in description))
@@ -2046,6 +2242,33 @@ function defineChain(chain) {
   return chain;
 }
 
+// src/utils/ens/normalize.ts
+import { toUnicode } from "idna-uts46-hx";
+function normalize(name) {
+  return toUnicode(name, { useStd3ASCII: true });
+}
+
+// src/utils/ens/labelhash.ts
+function labelhash(label) {
+  let result = new Uint8Array(32).fill(0);
+  if (!label)
+    return bytesToHex(result);
+  return keccak256(stringToBytes(normalize(label)));
+}
+
+// src/utils/ens/namehash.ts
+function namehash(name) {
+  let result = new Uint8Array(32).fill(0);
+  if (!name)
+    return bytesToHex(result);
+  const labels = normalize(name).split(".");
+  for (let i = labels.length - 1; i >= 0; i -= 1) {
+    const hashed = keccak256(stringToBytes(labels[i]), "bytes");
+    result = keccak256(concat([result, hashed]), "bytes");
+  }
+  return bytesToHex(result);
+}
+
 // src/utils/formatters/format.ts
 function format3(data, { formatter }) {
   return formatter(data);
@@ -2309,6 +2532,14 @@ function withTimeout(fn, {
   });
 }
 
+// src/utils/stringify.ts
+function stringify(value) {
+  return JSON.stringify(
+    value,
+    (_, value2) => typeof value2 === "bigint" ? value2.toString() : value2
+  );
+}
+
 // src/utils/rpc.ts
 var id = 0;
 async function http(url, {
@@ -2543,11 +2774,11 @@ function parseGwei(ether, unit = "wei") {
 }
 
 export {
-  stringify,
   BaseError,
   AbiConstructorNotFoundError,
   AbiConstructorParamsNotFoundError,
   AbiDecodingDataSizeInvalidError,
+  AbiDecodingZeroDataError,
   AbiEncodingArrayLengthMismatchError,
   AbiEncodingLengthMismatchError,
   AbiErrorInputsNotFoundError,
@@ -2563,29 +2794,7 @@ export {
   InvalidDefinitionTypeError,
   InvalidAddressError,
   BlockNotFoundError,
-  SizeExceedsPaddingSizeError,
-  DataLengthTooLongError,
-  DataLengthTooShortError,
-  InvalidBytesBooleanError,
-  InvalidHexBooleanError,
-  InvalidHexValueError,
-  OffsetOutOfBoundsError,
-  FilterTypeNotSupportedError,
-  RequestError,
-  RpcRequestError,
-  ParseRpcError,
-  InvalidRequestRpcError,
-  MethodNotFoundRpcError,
-  InvalidParamsRpcError,
-  InternalRpcError,
-  InvalidInputRpcError,
-  ResourceNotFoundRpcError,
-  ResourceUnavailableRpcError,
-  TransactionRejectedRpcError,
-  MethodNotSupportedRpcError,
-  LimitExceededRpcError,
-  JsonRpcVersionUnsupportedError,
-  UnknownRpcError,
+  multicall3Abi,
   isBytes,
   isHex,
   pad,
@@ -2638,9 +2847,9 @@ export {
   formatAbiItem,
   decodeErrorResult,
   decodeFunctionData,
+  getAbiItem,
   decodeFunctionResult,
   encodeDeployData,
-  getAbiItem,
   encodeErrorResult,
   encodeEventTopics,
   encodeFunctionData,
@@ -2648,6 +2857,9 @@ export {
   formatAbiItemWithArgs,
   buildRequest,
   defineChain,
+  normalize,
+  labelhash,
+  namehash,
   format3 as format,
   defineFormatter,
   transactionType,
@@ -2665,6 +2877,7 @@ export {
   getCache,
   withCache,
   wait,
+  stringify,
   getSocket,
   rpc,
   etherUnits,
@@ -2676,6 +2889,33 @@ export {
   parseUnit,
   parseEther,
   parseGwei,
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+  ContractFunctionZeroDataError,
+  RawContractError,
+  SizeExceedsPaddingSizeError,
+  DataLengthTooLongError,
+  DataLengthTooShortError,
+  InvalidBytesBooleanError,
+  InvalidHexBooleanError,
+  InvalidHexValueError,
+  OffsetOutOfBoundsError,
+  FilterTypeNotSupportedError,
+  RequestError,
+  RpcRequestError,
+  ParseRpcError,
+  InvalidRequestRpcError,
+  MethodNotFoundRpcError,
+  InvalidParamsRpcError,
+  InternalRpcError,
+  InvalidInputRpcError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  TransactionRejectedRpcError,
+  MethodNotSupportedRpcError,
+  LimitExceededRpcError,
+  JsonRpcVersionUnsupportedError,
+  UnknownRpcError,
   HttpRequestError,
   WebSocketRequestError,
   RpcError,
@@ -2686,4 +2926,4 @@ export {
   WaitForTransactionReceiptTimeoutError,
   UrlRequiredError
 };
-//# sourceMappingURL=chunk-62VTYU2V.mjs.map
+//# sourceMappingURL=chunk-XBUH66KN.mjs.map