viem 0.2.0-canary.20230316T042447 → 0.2.0-jxom-local-accounts.20230321T210352

package/dist/{chunk-ISLCPEI2.mjs → chunk-PB263D6W.mjs}

@@ -20,7 +20,7 @@ import "abitype";
 var package_default = {
   name: "viem",
   description: "TypeScript Interface for Ethereum",
-  version: "0.1.20",
+  version: "0.1.21",
   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",
@@ -142,6 +142,8 @@ var package_default = {
   dependencies: {
     "@noble/hashes": "^1.1.2",
     "@noble/secp256k1": "^1.7.1",
+    "@scure/bip32": "^1.2.0",
+    "@scure/bip39": "^1.1.1",
     "@wagmi/chains": "~0.2.11",
     abitype: "~0.7.1",
     "idna-uts46-hx": "^4.1.2",
@@ -218,7 +220,9 @@ var BaseError = class extends Error {
       shortMessage || "An error occurred.",
       "",
       ...args.metaMessages ? [...args.metaMessages, ""] : [],
-      ...docsPath6 ? [`Docs: https://viem.sh${docsPath6}.html`] : [],
+      ...docsPath6 ? [
+        `Docs: https://viem.sh${docsPath6}.html${args.docsSlug ? `#${args.docsSlug}` : ""}`
+      ] : [],
       ...details ? [`Details: ${details}`] : [],
       `Version: ${getVersion()}`
     ].join("\n");
@@ -519,6 +523,23 @@ var UnsupportedPackedAbiType = class extends BaseError {
   }
 };
 
+// src/errors/account.ts
+var AccountNotFoundError = class extends BaseError {
+  constructor({ docsPath: docsPath6 } = {}) {
+    super(
+      [
+        "Could not find an Account to execute with this Action.",
+        "Please provide an Account with the `account` argument on the Action, or by supplying an `account` to the WalletClient."
+      ].join("\n"),
+      {
+        docsPath: docsPath6,
+        docsSlug: "account"
+      }
+    );
+    __publicField(this, "name", "AccountNotFoundError");
+  }
+};
+
 // src/errors/address.ts
 var InvalidAddressError = class extends BaseError {
   constructor({ address }) {
@@ -583,1409 +604,1453 @@ var ChainMismatchError = class extends BaseError {
     __publicField(this, "name", "ChainMismatchError");
   }
 };
-
-// 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/constants/unit.ts
-var etherUnits = {
-  gwei: 9,
-  wei: 18
-};
-var gweiUnits = {
-  ether: -9,
-  wei: 9
-};
-var weiUnits = {
-  ether: -18,
-  gwei: -9
-};
-
-// src/errors/transaction.ts
-function prettyPrint(args) {
-  const entries = Object.entries(args).map(([key, value]) => {
-    if (value === void 0 || value === false)
-      return null;
-    return [key, value];
-  }).filter(Boolean);
-  const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
-  return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
-}
-var FeeConflictError = class extends BaseError {
+var ChainNotFoundError = class extends BaseError {
   constructor() {
     super(
       [
-        "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
-        "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
+        "No chain was provided to the request.",
+        "Please provide a chain with the `chain` argument on the Action, or by supplying a `chain` to WalletClient."
       ].join("\n")
     );
-    __publicField(this, "name", "FeeConflictError");
-  }
-};
-var TransactionExecutionError = class extends BaseError {
-  constructor(cause, {
-    account,
-    docsPath: docsPath6,
-    chain,
-    data,
-    gas,
-    gasPrice,
-    maxFeePerGas,
-    maxPriorityFeePerGas,
-    nonce,
-    to,
-    value
-  }) {
-    const prettyArgs = prettyPrint({
-      chain: chain && `${chain?.name} (id: ${chain?.id})`,
-      from: account.address,
-      to,
-      value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency.symbol || "ETH"}`,
-      data,
-      gas,
-      gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
-      maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
-      maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
-      nonce
-    });
-    super(cause.shortMessage, {
-      cause,
-      docsPath: docsPath6,
-      metaMessages: [
-        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
-        "Request Arguments:",
-        prettyArgs
-      ].filter(Boolean)
-    });
-    __publicField(this, "cause");
-    __publicField(this, "name", "TransactionExecutionError");
-    this.cause = cause;
-  }
-};
-var TransactionNotFoundError = class extends BaseError {
-  constructor({
-    blockHash,
-    blockNumber,
-    blockTag,
-    hash: hash2,
-    index
-  }) {
-    let identifier = "Transaction";
-    if (blockTag && index !== void 0)
-      identifier = `Transaction at block time "${blockTag}" at index "${index}"`;
-    if (blockHash && index !== void 0)
-      identifier = `Transaction at block hash "${blockHash}" at index "${index}"`;
-    if (blockNumber && index !== void 0)
-      identifier = `Transaction at block number "${blockNumber}" at index "${index}"`;
-    if (hash2)
-      identifier = `Transaction with hash "${hash2}"`;
-    super(`${identifier} could not be found.`);
-    __publicField(this, "name", "TransactionNotFoundError");
+    __publicField(this, "name", "ChainNotFoundError");
   }
 };
-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");
+
+// src/accounts/index.ts
+import { HDKey } from "@scure/bip32";
+
+// src/accounts/utils/parseAccount.ts
+function parseAccount(account) {
+  if (typeof account === "string")
+    return { address: account, type: "json-rpc" };
+  return account;
+}
+
+// src/utils/data/concat.ts
+function concat(values) {
+  if (typeof values[0] === "string")
+    return concatHex(values);
+  return concatBytes(values);
+}
+function concatBytes(values) {
+  let length = 0;
+  for (const arr of values) {
+    length += arr.length;
   }
-};
-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");
+  const result = new Uint8Array(length);
+  let offset = 0;
+  for (const arr of values) {
+    result.set(arr, offset);
+    offset += arr.length;
   }
-};
+  return result;
+}
+function concatHex(values) {
+  return `0x${values.reduce(
+    (acc, x) => acc + x.replace("0x", ""),
+    ""
+  )}`;
+}
 
-// src/errors/contract.ts
-var CallExecutionError = class extends BaseError {
-  constructor(cause, {
-    account,
-    docsPath: docsPath6,
-    chain,
-    data,
-    gas,
-    gasPrice,
-    maxFeePerGas,
-    maxPriorityFeePerGas,
-    nonce,
-    to,
-    value
-  }) {
-    const prettyArgs = prettyPrint({
-      from: account?.address,
-      to,
-      value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency.symbol || "ETH"}`,
-      data,
-      gas,
-      gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
-      maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
-      maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
-      nonce
-    });
-    super(cause.shortMessage, {
-      cause,
-      docsPath: docsPath6,
-      metaMessages: [
-        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
-        "Raw Call Arguments:",
-        prettyArgs
-      ].filter(Boolean)
-    });
-    __publicField(this, "cause");
-    __publicField(this, "name", "CallExecutionError");
-    this.cause = cause;
-  }
-};
-var ContractFunctionExecutionError = class extends BaseError {
-  constructor(cause, {
-    abi,
-    args,
-    contractAddress,
-    docsPath: docsPath6,
-    functionName,
-    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;
-    const prettyArgs = prettyPrint({
-      address: contractAddress && getContractAddress(contractAddress),
-      function: functionWithParams,
-      args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
-      sender
+// src/utils/data/isBytes.ts
+function isBytes(value) {
+  if (!value)
+    return false;
+  if (typeof value !== "object")
+    return false;
+  if (!("BYTES_PER_ELEMENT" in value))
+    return false;
+  return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
+}
+
+// src/utils/data/isHex.ts
+function isHex(value) {
+  if (!value)
+    return false;
+  if (typeof value !== "string")
+    return false;
+  return /^0x[0-9a-fA-F]*$/.test(value);
+}
+
+// src/utils/data/pad.ts
+function pad(hexOrBytes, { dir, size: size2 = 32 } = {}) {
+  if (typeof hexOrBytes === "string")
+    return padHex(hexOrBytes, { dir, size: size2 });
+  return padBytes(hexOrBytes, { dir, size: size2 });
+}
+function padHex(hex_, { dir, size: size2 = 32 } = {}) {
+  if (size2 === null)
+    return hex_;
+  let hex = hex_.replace("0x", "");
+  if (hex.length > size2 * 2)
+    throw new SizeExceedsPaddingSizeError({
+      size: Math.ceil(hex.length / 2),
+      targetSize: size2,
+      type: "hex"
     });
-    super(
-      cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`,
-      {
-        cause,
-        docsPath: docsPath6,
-        metaMessages: [
-          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
-          "Contract Call:",
-          prettyArgs
-        ].filter(Boolean)
-      }
-    );
-    __publicField(this, "abi");
-    __publicField(this, "args");
-    __publicField(this, "cause");
-    __publicField(this, "contractAddress");
-    __publicField(this, "formattedArgs");
-    __publicField(this, "functionName");
-    __publicField(this, "sender");
-    __publicField(this, "name", "ContractFunctionExecutionError");
-    this.abi = abi;
-    this.args = args;
-    this.cause = cause;
-    this.contractAddress = contractAddress;
-    this.functionName = functionName;
-    this.sender = sender;
+  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](
+    size2 * 2,
+    "0"
+  )}`;
+}
+function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
+  if (size2 === null)
+    return bytes;
+  if (bytes.length > size2)
+    throw new SizeExceedsPaddingSizeError({
+      size: bytes.length,
+      targetSize: size2,
+      type: "bytes"
+    });
+  const paddedBytes = new Uint8Array(size2);
+  for (let i = 0; i < size2; i++) {
+    const padEnd = dir === "right";
+    paddedBytes[padEnd ? i : size2 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
   }
-};
-var ContractFunctionRevertedError = class extends BaseError {
-  constructor({
-    abi,
-    data,
-    functionName,
-    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 !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
-        ];
-      }
-    } else if (message)
-      reason = message;
-    super(
-      reason ? [
-        `The contract function "${functionName}" reverted with the following reason:`,
-        reason
-      ].join("\n") : `The contract function "${functionName}" reverted.`,
-      {
-        metaMessages
-      }
+  return paddedBytes;
+}
+
+// src/utils/data/trim.ts
+function trim(hexOrBytes, { dir = "left" } = {}) {
+  let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
+  let sliceLength = 0;
+  for (let i = 0; i < data.length - 1; i++) {
+    if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
+      sliceLength++;
+    else
+      break;
+  }
+  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`;
+    return `0x${data}`;
+  }
+  return data;
+}
+
+// src/utils/data/size.ts
+function size(value) {
+  if (isHex(value))
+    return Math.ceil((value.length - 2) / 2);
+  return value.length;
+}
+
+// src/utils/data/slice.ts
+function slice(value, start, end) {
+  if (isHex(value))
+    return sliceHex(value, start, end);
+  return sliceBytes(value, start, end);
+}
+function assertStartOffset(value, start) {
+  if (typeof start === "number" && start > 0 && start > size(value) - 1)
+    throw new Error(
+      `Slice starting at offset "${start}" is out-of-bounds (size: ${size(
+        value
+      )}).`
     );
-    __publicField(this, "name", "ContractFunctionRevertedError");
-    __publicField(this, "data");
-    __publicField(this, "reason");
-    this.reason = reason;
-    this.data = decodedData;
+}
+function sliceBytes(value, start, end) {
+  assertStartOffset(value, start);
+  return value.slice(start, end);
+}
+function sliceHex(value_, start, end) {
+  assertStartOffset(value_, start);
+  const value = value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2);
+  return `0x${value}`;
+}
+
+// src/utils/encoding/toHex.ts
+var hexes = Array.from(
+  { length: 256 },
+  (_v, i) => i.toString(16).padStart(2, "0")
+);
+function boolToHex(value) {
+  return `0x${Number(value)}`;
+}
+function bytesToHex(value) {
+  let hex = "";
+  for (let i = 0; i < value.length; i++) {
+    hex += hexes[value[i]];
   }
-};
-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."
-      ]
+  return `0x${hex}`;
+}
+function toHex(value) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToHex(value);
+  if (typeof value === "string") {
+    return stringToHex(value);
+  }
+  if (typeof value === "boolean")
+    return boolToHex(value);
+  return bytesToHex(value);
+}
+function numberToHex(value_, opts = {}) {
+  const { signed, size: size2 } = opts;
+  let value = BigInt(value_);
+  let maxValue;
+  if (size2) {
+    if (signed)
+      maxValue = (1n << BigInt(size2) * 8n - 1n) - 1n;
+    else
+      maxValue = 2n ** (BigInt(size2) * 8n) - 1n;
+  } else if (typeof value_ === "number") {
+    maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+  }
+  const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
+  if (maxValue && value > maxValue || value < minValue) {
+    const suffix = typeof value_ === "bigint" ? "n" : "";
+    throw new IntegerOutOfRangeError({
+      max: maxValue ? `${maxValue}${suffix}` : void 0,
+      min: `${minValue}${suffix}`,
+      signed,
+      size: size2,
+      value: `${value_}${suffix}`
     });
-    __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;
+  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size2 * 8)) + BigInt(value) : value).toString(16)}`;
+  if (size2)
+    return pad(hex, { size: size2 });
+  return hex;
+}
+var encoder = new TextEncoder();
+function stringToHex(value_) {
+  const value = encoder.encode(value_);
+  return toHex(value);
+}
+
+// src/utils/encoding/toBytes.ts
+var encoder2 = new TextEncoder();
+function toBytes(value) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToBytes(value);
+  if (typeof value === "boolean")
+    return boolToBytes(value);
+  if (value.startsWith("0x"))
+    return hexToBytes(value);
+  return stringToBytes(value);
+}
+function boolToBytes(value) {
+  const bytes = new Uint8Array(1);
+  bytes[0] = Number(value);
+  return bytes;
+}
+function hexToBytes(hex_) {
+  let hex = hex_.slice(2);
+  if (hex.length % 2)
+    hex = `0${hex}`;
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let index = 0; index < bytes.length; index++) {
+    const start = index * 2;
+    const hexByte = hex.slice(start, start + 2);
+    const byte = Number.parseInt(hexByte, 16);
+    if (Number.isNaN(byte) || byte < 0)
+      throw new BaseError(`Invalid byte sequence ("${hexByte}" in "${hex}").`);
+    bytes[index] = byte;
   }
-};
+  return bytes;
+}
+function numberToBytes(value, opts) {
+  const hex = numberToHex(value, opts);
+  return hexToBytes(hex);
+}
+function stringToBytes(value) {
+  return encoder2.encode(value);
+}
 
-// 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/utils/encoding/toRlp.ts
+function toRlp(hexOrBytes, to_) {
+  const to = to_ || "hex";
+  return format(bytesToRlp(parse(hexOrBytes)), to);
+}
+function parse(hexOrBytes) {
+  if (Array.isArray(hexOrBytes))
+    return hexOrBytes.map(parse);
+  return typeof hexOrBytes === "string" ? toBytes(hexOrBytes) : hexOrBytes;
+}
+function format(bytes, type = "bytes") {
+  return type === "hex" ? bytesToHex(bytes) : bytes;
+}
+function bytesToRlp(bytes) {
+  if (Array.isArray(bytes)) {
+    const encoded = concat(bytes.map(bytesToRlp));
+    return new Uint8Array([...encodeLength(encoded.length, 192), ...encoded]);
   }
-};
+  if (bytes.length === 1 && bytes[0] < 128)
+    return bytes;
+  return new Uint8Array([...encodeLength(bytes.length, 128), ...bytes]);
+}
+function encodeLength(length, offset) {
+  if (length < 56)
+    return [offset + length];
+  return [toBytes(length).length + offset + 55, ...toBytes(length)];
+}
+
+// src/utils/encoding/fromHex.ts
+function fromHex(hex, to) {
+  if (to === "number")
+    return hexToNumber(hex);
+  if (to === "bigint")
+    return hexToBigInt(hex);
+  if (to === "string")
+    return hexToString(hex);
+  if (to === "boolean")
+    return hexToBool(hex);
+  return hexToBytes(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 (trim(hex) === "0x0")
+    return false;
+  if (trim(hex) === "0x1")
+    return true;
+  throw new InvalidHexBooleanError(hex);
+}
+function hexToNumber(hex, opts = {}) {
+  return Number(hexToBigInt(hex, opts));
+}
+function hexToString(hex) {
+  const bytes = hexToBytes(hex);
+  return new TextDecoder().decode(bytes);
+}
+
+// src/utils/encoding/fromBytes.ts
+function fromBytes(bytes, to) {
+  if (to === "number")
+    return bytesToNumber(bytes);
+  if (to === "bigint")
+    return bytesToBigint(bytes);
+  if (to === "boolean")
+    return bytesToBool(bytes);
+  if (to === "string")
+    return bytesToString(bytes);
+  return bytesToHex(bytes);
+}
+function bytesToBigint(bytes) {
+  const hex = bytesToHex(bytes);
+  return hexToBigInt(hex);
+}
+function bytesToBool(bytes) {
+  if (bytes.length > 1 || bytes[0] > 1)
+    throw new InvalidBytesBooleanError(bytes);
+  return Boolean(bytes[0]);
+}
+function bytesToNumber(bytes) {
+  const hex = bytesToHex(bytes);
+  return hexToNumber(hex);
+}
+function bytesToString(bytes) {
+  return new TextDecoder().decode(bytes);
+}
 
-// 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 IntegerOutOfRangeError = class extends BaseError {
-  constructor({
-    max,
-    min,
-    signed,
-    size: size2,
-    value
-  }) {
-    super(
-      `Number "${value}" is not in safe ${size2 ? `${size2 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`
-    );
-    __publicField(this, "name", "IntegerOutOfRangeError");
+// src/utils/encoding/fromRlp.ts
+function fromRlp(value, to) {
+  const bytes = parse2(value);
+  const [data, consumed] = rlpToBytes(bytes);
+  if (consumed < bytes.length)
+    throw new DataLengthTooLongError({
+      consumed,
+      length: bytes.length
+    });
+  return format2(data, to);
+}
+function parse2(value) {
+  if (typeof value === "string") {
+    if (value.length > 3 && value.length % 2 !== 0)
+      throw new InvalidHexValueError(value);
+    return hexToBytes(value);
   }
-};
-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");
+  return value;
+}
+function format2(bytes, to) {
+  if (Array.isArray(bytes))
+    return bytes.map((b) => format2(b, to));
+  return to === "hex" ? trim(bytesToHex(bytes)) : bytes;
+}
+function rlpToBytes(bytes, offset = 0) {
+  if (bytes.length === 0)
+    return [new Uint8Array([]), 0];
+  const prefix = bytes[offset];
+  if (prefix <= 127)
+    return [new Uint8Array([bytes[offset]]), 1];
+  if (prefix <= 183) {
+    const length2 = prefix - 128;
+    const offset_ = offset + 1;
+    if (offset_ + length2 > bytes.length)
+      throw new DataLengthTooShortError({
+        length: offset_ + length2,
+        dataLength: bytes.length
+      });
+    return [bytes.slice(offset_, offset_ + length2), 1 + length2];
   }
-};
-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");
+  if (prefix <= 191) {
+    const lengthOfLength2 = prefix - 183;
+    const offset_ = offset + 1;
+    const length2 = bytesToNumber(bytes.slice(offset_, offset_ + lengthOfLength2));
+    if (offset_ + lengthOfLength2 + length2 > bytes.length)
+      throw new DataLengthTooShortError({
+        length: lengthOfLength2 + length2,
+        dataLength: bytes.length - lengthOfLength2
+      });
+    return [
+      bytes.slice(offset_ + lengthOfLength2, offset_ + lengthOfLength2 + length2),
+      1 + lengthOfLength2 + length2
+    ];
   }
-};
-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");
+  let lengthOfLength = 0;
+  let length = prefix - 192;
+  if (prefix > 247) {
+    lengthOfLength = prefix - 247;
+    length = bytesToNumber(bytes.slice(offset + 1, offset + 1 + lengthOfLength));
   }
-};
-var OffsetOutOfBoundsError = class extends BaseError {
-  constructor({ nextOffset, offset }) {
-    super(
-      `Next offset (${nextOffset}) is greater than previous offset + consumed bytes (${offset})`
-    );
-    __publicField(this, "name", "OffsetOutOfBoundsError");
+  let nextOffset = offset + 1 + lengthOfLength;
+  if (nextOffset > bytes.length)
+    throw new DataLengthTooShortError({
+      length: nextOffset,
+      dataLength: bytes.length
+    });
+  let consumed = 1 + lengthOfLength + length;
+  let result = [];
+  while (nextOffset < offset + consumed) {
+    const decoded = rlpToBytes(bytes, nextOffset);
+    result.push(decoded[0]);
+    nextOffset += decoded[1];
+    if (nextOffset > offset + consumed)
+      throw new OffsetOutOfBoundsError({
+        nextOffset,
+        offset: offset + consumed
+      });
   }
-};
+  return [result, consumed];
+}
 
-// src/errors/estimateGas.ts
-var EstimateGasExecutionError = class extends BaseError {
-  constructor(cause, {
-    account,
-    docsPath: docsPath6,
-    chain,
-    data,
-    gas,
-    gasPrice,
-    maxFeePerGas,
-    maxPriorityFeePerGas,
-    nonce,
-    to,
-    value
-  }) {
-    const prettyArgs = prettyPrint({
-      from: account.address,
-      to,
-      value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency.symbol || "ETH"}`,
-      data,
-      gas,
-      gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
-      maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
-      maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
-      nonce
-    });
-    super(cause.shortMessage, {
-      cause,
-      docsPath: docsPath6,
-      metaMessages: [
-        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
-        "Estimate Gas Arguments:",
-        prettyArgs
-      ].filter(Boolean)
-    });
-    __publicField(this, "cause");
-    __publicField(this, "name", "EstimateGasExecutionError");
-    this.cause = cause;
+// src/utils/contract/extractFunctionParts.ts
+var paramsRegex = /((function|event)\s)?(.*)(\((.*)\))/;
+function extractFunctionParts(def) {
+  const parts = def.match(paramsRegex);
+  const type = parts?.[2] || void 0;
+  const name = parts?.[3];
+  const params = parts?.[5] || void 0;
+  return { type, name, params };
+}
+function extractFunctionName(def) {
+  return extractFunctionParts(def).name;
+}
+function extractFunctionParams(def) {
+  const params = extractFunctionParts(def).params;
+  const splitParams = params?.split(",").map((x) => x.trim().split(" "));
+  return splitParams?.map((param) => ({
+    type: param[0],
+    name: param[1] === "indexed" ? param[2] : param[1],
+    ...param[1] === "indexed" ? { indexed: true } : {}
+  }));
+}
+function extractFunctionType(def) {
+  return extractFunctionParts(def).type;
+}
+
+// src/utils/hash/keccak256.ts
+import { keccak_256 } from "@noble/hashes/sha3";
+function keccak256(value, to_) {
+  const to = to_ || "hex";
+  const bytes = keccak_256(isHex(value) ? toBytes(value) : value);
+  if (to === "bytes")
+    return bytes;
+  return toHex(bytes);
+}
+
+// src/utils/hash/hashFunction.ts
+var hash = (value) => keccak256(toBytes(value));
+function hashFunction(def) {
+  const name = extractFunctionName(def);
+  const params = extractFunctionParams(def);
+  if (!params || params.length === 0)
+    return hash(def.replace(/ /g, ""));
+  return hash(`${name}(${params.map(({ type }) => type).join(",")})`);
+}
+
+// src/utils/hash/getEventSelector.ts
+var getEventSelector = (event) => hashFunction(event);
+
+// src/utils/hash/getFunctionSelector.ts
+var getFunctionSelector = (fn) => slice(hashFunction(fn), 0, 4);
+
+// src/utils/address/isAddress.ts
+var addressRegex = /^0x[a-fA-F0-9]{40}$/;
+function isAddress(address) {
+  return addressRegex.test(address);
+}
+
+// src/utils/address/getAddress.ts
+function checksumAddress(address_) {
+  const hexAddress = address_.substring(2).toLowerCase();
+  const hash2 = keccak256(stringToBytes(hexAddress), "bytes");
+  let address = hexAddress.split("");
+  for (let i = 0; i < 40; i += 2) {
+    if (hash2[i >> 1] >> 4 >= 8 && address[i]) {
+      address[i] = address[i].toUpperCase();
+    }
+    if ((hash2[i >> 1] & 15) >= 8 && address[i + 1]) {
+      address[i + 1] = address[i + 1].toUpperCase();
+    }
   }
-};
+  return `0x${address.join("")}`;
+}
+function getAddress(address) {
+  if (!isAddress(address))
+    throw new InvalidAddressError({ address });
+  return checksumAddress(address);
+}
+
+// src/utils/address/getContractAddress.ts
+function getContractAddress2(opts) {
+  if (opts.opcode === "CREATE2")
+    return getCreate2Address(opts);
+  return getCreateAddress(opts);
+}
+function getCreateAddress(opts) {
+  const from = toBytes(getAddress(opts.from));
+  let nonce = toBytes(opts.nonce);
+  if (nonce[0] === 0)
+    nonce = new Uint8Array([]);
+  return getAddress(
+    `0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`
+  );
+}
+function getCreate2Address(opts) {
+  const from = toBytes(getAddress(opts.from));
+  const salt = pad(isBytes(opts.salt) ? opts.salt : toBytes(opts.salt), {
+    size: 32
+  });
+  const bytecodeHash = toBytes(
+    keccak256(
+      isBytes(opts.bytecode) ? opts.bytecode : toBytes(opts.bytecode)
+    )
+  );
+  return getAddress(
+    slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12)
+  );
+}
 
-// src/errors/log.ts
-var FilterTypeNotSupportedError = class extends BaseError {
-  constructor(type) {
-    super(`Filter type "${type}" is not supported.`);
-    __publicField(this, "name", "FilterTypeNotSupportedError");
-  }
-};
+// src/utils/address/isAddressEqual.ts
+function isAddressEqual(a, b) {
+  if (!isAddress(a))
+    throw new InvalidAddressError({ address: a });
+  if (!isAddress(b))
+    throw new InvalidAddressError({ address: b });
+  return a.toLowerCase() === b.toLowerCase();
+}
 
-// src/errors/node.ts
-var ExecutionRevertedError = class extends BaseError {
-  constructor({
-    cause,
-    message
-  } = {}) {
-    const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
-    super(
-      `Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`,
-      {
-        cause
-      }
-    );
-    __publicField(this, "name", "ExecutionRevertedError");
+// src/accounts/toAccount.ts
+function toAccount(source) {
+  if (typeof source === "string") {
+    if (!isAddress(source))
+      throw new InvalidAddressError({ address: source });
+    return {
+      address: source,
+      type: "json-rpc"
+    };
   }
-};
-__publicField(ExecutionRevertedError, "code", 3);
-__publicField(ExecutionRevertedError, "nodeMessage", /execution reverted/);
-var FeeCapTooHighError = class extends BaseError {
-  constructor({
-    cause,
-    maxFeePerGas
-  } = {}) {
-    super(
-      `The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`,
+  if (!isAddress(source.address))
+    throw new InvalidAddressError({ address: source.address });
+  return {
+    address: source.address,
+    signMessage: source.signMessage,
+    signTransaction: source.signTransaction,
+    signTypedData: source.signTypedData,
+    source: "custom",
+    type: "local"
+  };
+}
+
+// src/constants/abis.ts
+var multicall3Abi = [
+  {
+    inputs: [
       {
-        cause
+        components: [
+          {
+            name: "target",
+            type: "address"
+          },
+          {
+            name: "allowFailure",
+            type: "bool"
+          },
+          {
+            name: "callData",
+            type: "bytes"
+          }
+        ],
+        name: "calls",
+        type: "tuple[]"
       }
-    );
-    __publicField(this, "name", "FeeCapTooHigh");
-  }
-};
-__publicField(FeeCapTooHighError, "nodeMessage", /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/);
-var FeeCapTooLowError = class extends BaseError {
-  constructor({
-    cause,
-    maxFeePerGas
-  } = {}) {
-    super(
-      `The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`,
+    ],
+    name: "aggregate3",
+    outputs: [
       {
-        cause
+        components: [
+          {
+            name: "success",
+            type: "bool"
+          },
+          {
+            name: "returnData",
+            type: "bytes"
+          }
+        ],
+        name: "returnData",
+        type: "tuple[]"
       }
-    );
-    __publicField(this, "name", "FeeCapTooLow");
-  }
-};
-__publicField(FeeCapTooLowError, "nodeMessage", /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/);
-var NonceTooHighError = class extends BaseError {
-  constructor({ cause, nonce } = {}) {
-    super(
-      `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`,
-      { cause }
-    );
-    __publicField(this, "name", "NonceTooHighError");
-  }
-};
-__publicField(NonceTooHighError, "nodeMessage", /nonce too high/);
-var NonceTooLowError = class extends BaseError {
-  constructor({ cause, nonce } = {}) {
-    super(
-      [
-        `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
-        "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
-      ].join("\n"),
-      { cause }
-    );
-    __publicField(this, "name", "NonceTooLowError");
+    ],
+    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."
 };
-__publicField(NonceTooLowError, "nodeMessage", /nonce too low|transaction already imported/);
-var NonceMaxValueError = class extends BaseError {
-  constructor({ cause, nonce } = {}) {
-    super(
-      `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`,
-      { cause }
-    );
-    __publicField(this, "name", "NonceMaxValueError");
-  }
+var solidityError = {
+  inputs: [
+    {
+      name: "message",
+      type: "string"
+    }
+  ],
+  name: "Error",
+  type: "error"
 };
-__publicField(NonceMaxValueError, "nodeMessage", /nonce has max value/);
-var InsufficientFundsError = class extends BaseError {
-  constructor({ cause } = {}) {
-    super(
-      [
-        "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
-      ].join("\n"),
-      {
-        cause,
-        metaMessages: [
-          "This error could arise when the account does not have enough funds to:",
-          " - pay for the total gas fee,",
-          " - pay for the value to send.",
-          " ",
-          "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
-          " - `gas` is the amount of gas needed for transaction to execute,",
-          " - `gas fee` is the gas fee,",
-          " - `value` is the amount of ether to send to the recipient."
-        ]
-      }
-    );
-    __publicField(this, "name", "InsufficientFundsError");
-  }
+var solidityPanic = {
+  inputs: [
+    {
+      name: "reason",
+      type: "uint256"
+    }
+  ],
+  name: "Panic",
+  type: "error"
 };
-__publicField(InsufficientFundsError, "nodeMessage", /insufficient funds/);
-var IntrinsicGasTooHighError = class extends BaseError {
-  constructor({ cause, gas } = {}) {
-    super(
-      `The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`,
-      {
-        cause
-      }
-    );
-    __publicField(this, "name", "IntrinsicGasTooHighError");
-  }
+
+// src/constants/unit.ts
+var etherUnits = {
+  gwei: 9,
+  wei: 18
 };
-__publicField(IntrinsicGasTooHighError, "nodeMessage", /intrinsic gas too high|gas limit reached/);
-var IntrinsicGasTooLowError = class extends BaseError {
-  constructor({ cause, gas } = {}) {
-    super(
-      `The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`,
-      {
-        cause
-      }
-    );
-    __publicField(this, "name", "IntrinsicGasTooLowError");
-  }
+var gweiUnits = {
+  ether: -9,
+  wei: 9
 };
-__publicField(IntrinsicGasTooLowError, "nodeMessage", /intrinsic gas too low/);
-var TransactionTypeNotSupportedError = class extends BaseError {
-  constructor({ cause }) {
-    super("The transaction type is not supported for this chain.", {
-      cause
-    });
-    __publicField(this, "name", "TransactionTypeNotSupportedError");
-  }
+var weiUnits = {
+  ether: -18,
+  gwei: -9
 };
-__publicField(TransactionTypeNotSupportedError, "nodeMessage", /transaction type not valid/);
-var TipAboveFeeCapError = class extends BaseError {
-  constructor({
-    cause,
-    maxPriorityFeePerGas,
-    maxFeePerGas
-  } = {}) {
+
+// src/errors/transaction.ts
+function prettyPrint(args) {
+  const entries = Object.entries(args).map(([key, value]) => {
+    if (value === void 0 || value === false)
+      return null;
+    return [key, value];
+  }).filter(Boolean);
+  const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
+  return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
+}
+var FeeConflictError = class extends BaseError {
+  constructor() {
     super(
       [
-        `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
-      ].join("\n"),
-      {
-        cause
-      }
+        "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
+        "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
+      ].join("\n")
     );
-    __publicField(this, "name", "TipAboveFeeCapError");
-  }
-};
-__publicField(TipAboveFeeCapError, "nodeMessage", /max priority fee per gas higher than max fee per gas|tip higher than fee cap/);
-var UnknownNodeError = class extends BaseError {
-  constructor({ cause }) {
-    super(`An error occurred while executing: ${cause?.message}`, {
-      cause
-    });
-    __publicField(this, "name", "UnknownNodeError");
+    __publicField(this, "name", "FeeConflictError");
   }
 };
-
-// src/errors/request.ts
-var RequestError = class extends BaseError {
-  constructor(err, {
+var TransactionExecutionError = class extends BaseError {
+  constructor(cause, {
+    account,
     docsPath: docsPath6,
-    metaMessages,
-    shortMessage
+    chain,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value
   }) {
-    super(shortMessage, {
-      cause: err,
+    const prettyArgs = prettyPrint({
+      chain: chain && `${chain?.name} (id: ${chain?.id})`,
+      from: account?.address,
+      to,
+      value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency.symbol || "ETH"}`,
+      data,
+      gas,
+      gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
+      maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
+      maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
+      nonce
+    });
+    super(cause.shortMessage, {
+      cause,
       docsPath: docsPath6,
-      metaMessages
+      metaMessages: [
+        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+        "Request Arguments:",
+        prettyArgs
+      ].filter(Boolean)
     });
-    this.name = err.name;
+    __publicField(this, "cause");
+    __publicField(this, "name", "TransactionExecutionError");
+    this.cause = cause;
   }
 };
-var RpcRequestError = class extends RequestError {
-  constructor(err, { docsPath: docsPath6, shortMessage }) {
-    super(err, { docsPath: docsPath6, metaMessages: err.metaMessages, shortMessage });
-    __publicField(this, "code");
-    this.code = err.code;
-    this.name = err.name;
+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 ParseRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      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);
+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 InvalidRequestRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { shortMessage: "JSON is not a valid request object." });
-    __publicField(this, "name", "InvalidRequestRpcError");
-    __publicField(this, "code", -32600);
+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");
   }
 };
-var MethodNotFoundRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      shortMessage: "The method does not exist / is not available."
+
+// src/errors/contract.ts
+var CallExecutionError = class extends BaseError {
+  constructor(cause, {
+    account: account_,
+    docsPath: docsPath6,
+    chain,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value
+  }) {
+    const account = account_ ? parseAccount(account_) : void 0;
+    const prettyArgs = prettyPrint({
+      from: account?.address,
+      to,
+      value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency.symbol || "ETH"}`,
+      data,
+      gas,
+      gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
+      maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
+      maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
+      nonce
     });
-    __publicField(this, "name", "MethodNotFoundRpcError");
-    __publicField(this, "code", -32601);
+    super(cause.shortMessage, {
+      cause,
+      docsPath: docsPath6,
+      metaMessages: [
+        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+        "Raw Call Arguments:",
+        prettyArgs
+      ].filter(Boolean)
+    });
+    __publicField(this, "cause");
+    __publicField(this, "name", "CallExecutionError");
+    this.cause = cause;
   }
 };
-var InvalidParamsRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      shortMessage: [
-        "Invalid parameters were provided to the RPC method.",
-        "Double check you have provided the correct parameters."
-      ].join("\n")
+var ContractFunctionExecutionError = class extends BaseError {
+  constructor(cause, {
+    abi,
+    args,
+    contractAddress,
+    docsPath: docsPath6,
+    functionName,
+    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;
+    const prettyArgs = prettyPrint({
+      address: contractAddress && getContractAddress(contractAddress),
+      function: functionWithParams,
+      args: formattedArgs && formattedArgs !== "()" && `${[...Array(functionName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}`,
+      sender
     });
-    __publicField(this, "name", "InvalidParamsRpcError");
-    __publicField(this, "code", -32602);
+    super(
+      cause.shortMessage || `An unknown error occurred while executing the contract function "${functionName}".`,
+      {
+        cause,
+        docsPath: docsPath6,
+        metaMessages: [
+          ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+          "Contract Call:",
+          prettyArgs
+        ].filter(Boolean)
+      }
+    );
+    __publicField(this, "abi");
+    __publicField(this, "args");
+    __publicField(this, "cause");
+    __publicField(this, "contractAddress");
+    __publicField(this, "formattedArgs");
+    __publicField(this, "functionName");
+    __publicField(this, "sender");
+    __publicField(this, "name", "ContractFunctionExecutionError");
+    this.abi = abi;
+    this.args = args;
+    this.cause = cause;
+    this.contractAddress = contractAddress;
+    this.functionName = functionName;
+    this.sender = sender;
   }
 };
-var InternalRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { shortMessage: "An internal error was received." });
-    __publicField(this, "name", "InternalRpcError");
-    __publicField(this, "code", -32603);
+var ContractFunctionRevertedError = class extends BaseError {
+  constructor({
+    abi,
+    data,
+    functionName,
+    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 !== "()" ? `       ${[...Array(errorName?.length ?? 0).keys()].map(() => " ").join("")}${formattedArgs}` : ""
+        ];
+      }
+    } else if (message)
+      reason = message;
+    super(
+      reason ? [
+        `The contract function "${functionName}" reverted with the following reason:`,
+        reason
+      ].join("\n") : `The contract function "${functionName}" reverted.`,
+      {
+        metaMessages
+      }
+    );
+    __publicField(this, "name", "ContractFunctionRevertedError");
+    __publicField(this, "data");
+    __publicField(this, "reason");
+    this.reason = reason;
+    this.data = decodedData;
   }
 };
-var InvalidInputRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      shortMessage: [
-        "Missing or invalid parameters.",
-        "Double check you have provided the correct parameters."
-      ].join("\n")
+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", "InvalidInputRpcError");
-    __publicField(this, "code", -32e3);
+    __publicField(this, "name", "ContractFunctionZeroDataError");
   }
 };
-var ResourceNotFoundRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { shortMessage: "Requested resource not found." });
-    __publicField(this, "name", "ResourceNotFoundRpcError");
-    __publicField(this, "code", -32001);
+var RawContractError = class extends BaseError {
+  constructor({ data, message }) {
+    super(message || "");
+    __publicField(this, "code", 3);
+    __publicField(this, "name", "RawContractError");
+    __publicField(this, "data");
+    this.data = data;
   }
 };
-var ResourceUnavailableRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { shortMessage: "Requested resource not available." });
-    __publicField(this, "name", "ResourceUnavailableRpcError");
-    __publicField(this, "code", -32002);
+
+// 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");
   }
 };
-var TransactionRejectedRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { shortMessage: "Transaction creation failed." });
-    __publicField(this, "name", "TransactionRejectedRpcError");
-    __publicField(this, "code", -32003);
+
+// 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 MethodNotSupportedRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { shortMessage: "Method is not implemented." });
-    __publicField(this, "name", "MethodNotSupportedRpcError");
-    __publicField(this, "code", -32004);
+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 LimitExceededRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { shortMessage: "Request exceeds defined limit." });
-    __publicField(this, "name", "LimitExceededRpcError");
-    __publicField(this, "code", -32005);
+var IntegerOutOfRangeError = class extends BaseError {
+  constructor({
+    max,
+    min,
+    signed,
+    size: size2,
+    value
+  }) {
+    super(
+      `Number "${value}" is not in safe ${size2 ? `${size2 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`
+    );
+    __publicField(this, "name", "IntegerOutOfRangeError");
   }
 };
-var JsonRpcVersionUnsupportedError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      shortMessage: "Version of JSON-RPC protocol is not supported."
-    });
-    __publicField(this, "name", "JsonRpcVersionUnsupportedError");
-    __publicField(this, "code", -32006);
+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 UserRejectedRequestError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      shortMessage: "User rejected the request."
-    });
-    __publicField(this, "name", "UserRejectedRequestError");
-    __publicField(this, "code", 4001);
+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 SwitchChainError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      shortMessage: "An error occurred when attempting to switch chain."
-    });
-    __publicField(this, "name", "SwitchChainError");
-    __publicField(this, "code", 4902);
+var 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 UnknownRpcError = class extends RequestError {
-  constructor(err) {
-    super(err, {
-      shortMessage: "An unknown RPC error occurred."
-    });
-    __publicField(this, "name", "UnknownRpcError");
+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/rpc.ts
-var HttpRequestError = class extends BaseError {
-  constructor({
-    body,
-    details,
-    headers,
-    status,
-    url
+// src/errors/estimateGas.ts
+var EstimateGasExecutionError = class extends BaseError {
+  constructor(cause, {
+    account,
+    docsPath: docsPath6,
+    chain,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value
   }) {
-    super("HTTP request failed.", {
-      details,
+    const prettyArgs = prettyPrint({
+      from: account?.address,
+      to,
+      value: typeof value !== "undefined" && `${formatEther(value)} ${chain?.nativeCurrency.symbol || "ETH"}`,
+      data,
+      gas,
+      gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
+      maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
+      maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
+      nonce
+    });
+    super(cause.shortMessage, {
+      cause,
+      docsPath: docsPath6,
       metaMessages: [
-        status && `Status: ${status}`,
-        `URL: ${getUrl(url)}`,
-        `Request body: ${stringify(body)}`
+        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+        "Estimate Gas Arguments:",
+        prettyArgs
       ].filter(Boolean)
     });
-    __publicField(this, "name", "HttpRequestError");
-    __publicField(this, "body");
-    __publicField(this, "headers");
-    __publicField(this, "status");
-    __publicField(this, "url");
-    this.body = body;
-    this.headers = headers;
-    this.status = status;
-    this.url = url;
+    __publicField(this, "cause");
+    __publicField(this, "name", "EstimateGasExecutionError");
+    this.cause = cause;
   }
 };
-var WebSocketRequestError = class extends BaseError {
+
+// src/errors/log.ts
+var FilterTypeNotSupportedError = class extends BaseError {
+  constructor(type) {
+    super(`Filter type "${type}" is not supported.`);
+    __publicField(this, "name", "FilterTypeNotSupportedError");
+  }
+};
+
+// src/errors/node.ts
+var ExecutionRevertedError = class extends BaseError {
   constructor({
-    body,
-    details,
-    url
-  }) {
-    super("WebSocket request failed.", {
-      details,
-      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`]
-    });
-    __publicField(this, "name", "WebSocketRequestError");
+    cause,
+    message
+  } = {}) {
+    const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
+    super(
+      `Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`,
+      {
+        cause
+      }
+    );
+    __publicField(this, "name", "ExecutionRevertedError");
   }
 };
-var RpcError = class extends BaseError {
+__publicField(ExecutionRevertedError, "code", 3);
+__publicField(ExecutionRevertedError, "nodeMessage", /execution reverted/);
+var FeeCapTooHighError = class extends BaseError {
   constructor({
-    body,
-    error,
-    url
-  }) {
-    super("RPC Request failed.", {
-      cause: error,
-      details: error.message,
-      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`]
-    });
-    __publicField(this, "code");
-    __publicField(this, "name", "RpcError");
-    this.code = error.code;
+    cause,
+    maxFeePerGas
+  } = {}) {
+    super(
+      `The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`,
+      {
+        cause
+      }
+    );
+    __publicField(this, "name", "FeeCapTooHigh");
   }
 };
-var TimeoutError = class extends BaseError {
+__publicField(FeeCapTooHighError, "nodeMessage", /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/);
+var FeeCapTooLowError = class extends BaseError {
   constructor({
-    body,
-    url
-  }) {
-    super("The request took too long to respond.", {
-      details: "The request timed out.",
-      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`]
-    });
-    __publicField(this, "name", "TimeoutError");
-  }
-};
-
-// src/errors/transport.ts
-var UrlRequiredError = class extends BaseError {
-  constructor() {
+    cause,
+    maxFeePerGas
+  } = {}) {
     super(
-      "No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.",
+      `The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`,
       {
-        docsPath: "/docs/clients/intro"
+        cause
       }
     );
+    __publicField(this, "name", "FeeCapTooLow");
   }
 };
-
-// src/utils/data/concat.ts
-function concat(values) {
-  if (typeof values[0] === "string")
-    return concatHex(values);
-  return concatBytes(values);
-}
-function concatBytes(values) {
-  let length = 0;
-  for (const arr of values) {
-    length += arr.length;
-  }
-  const result = new Uint8Array(length);
-  let offset = 0;
-  for (const arr of values) {
-    result.set(arr, offset);
-    offset += arr.length;
+__publicField(FeeCapTooLowError, "nodeMessage", /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/);
+var NonceTooHighError = class extends BaseError {
+  constructor({ cause, nonce } = {}) {
+    super(
+      `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`,
+      { cause }
+    );
+    __publicField(this, "name", "NonceTooHighError");
   }
-  return result;
-}
-function concatHex(values) {
-  return `0x${values.reduce(
-    (acc, x) => acc + x.replace("0x", ""),
-    ""
-  )}`;
-}
-
-// src/utils/data/isBytes.ts
-function isBytes(value) {
-  if (!value)
-    return false;
-  if (typeof value !== "object")
-    return false;
-  if (!("BYTES_PER_ELEMENT" in value))
-    return false;
-  return value.BYTES_PER_ELEMENT === 1 && value.constructor.name === "Uint8Array";
-}
-
-// src/utils/data/isHex.ts
-function isHex(value) {
-  if (!value)
-    return false;
-  if (typeof value !== "string")
-    return false;
-  return /^0x[0-9a-fA-F]*$/.test(value);
-}
-
-// src/utils/data/pad.ts
-function pad(hexOrBytes, { dir, size: size2 = 32 } = {}) {
-  if (typeof hexOrBytes === "string")
-    return padHex(hexOrBytes, { dir, size: size2 });
-  return padBytes(hexOrBytes, { dir, size: size2 });
-}
-function padHex(hex_, { dir, size: size2 = 32 } = {}) {
-  if (size2 === null)
-    return hex_;
-  let hex = hex_.replace("0x", "");
-  if (hex.length > size2 * 2)
-    throw new SizeExceedsPaddingSizeError({
-      size: Math.ceil(hex.length / 2),
-      targetSize: size2,
-      type: "hex"
-    });
-  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](
-    size2 * 2,
-    "0"
-  )}`;
-}
-function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
-  if (size2 === null)
-    return bytes;
-  if (bytes.length > size2)
-    throw new SizeExceedsPaddingSizeError({
-      size: bytes.length,
-      targetSize: size2,
-      type: "bytes"
-    });
-  const paddedBytes = new Uint8Array(size2);
-  for (let i = 0; i < size2; i++) {
-    const padEnd = dir === "right";
-    paddedBytes[padEnd ? i : size2 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+};
+__publicField(NonceTooHighError, "nodeMessage", /nonce too high/);
+var NonceTooLowError = class extends BaseError {
+  constructor({ cause, nonce } = {}) {
+    super(
+      [
+        `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
+        "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
+      ].join("\n"),
+      { cause }
+    );
+    __publicField(this, "name", "NonceTooLowError");
   }
-  return paddedBytes;
-}
-
-// src/utils/data/trim.ts
-function trim(hexOrBytes, { dir = "left" } = {}) {
-  let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
-  let sliceLength = 0;
-  for (let i = 0; i < data.length - 1; i++) {
-    if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
-      sliceLength++;
-    else
-      break;
+};
+__publicField(NonceTooLowError, "nodeMessage", /nonce too low|transaction already imported/);
+var NonceMaxValueError = class extends BaseError {
+  constructor({ cause, nonce } = {}) {
+    super(
+      `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`,
+      { cause }
+    );
+    __publicField(this, "name", "NonceMaxValueError");
   }
-  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`;
-    return `0x${data}`;
+};
+__publicField(NonceMaxValueError, "nodeMessage", /nonce has max value/);
+var InsufficientFundsError = class extends BaseError {
+  constructor({ cause } = {}) {
+    super(
+      [
+        "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
+      ].join("\n"),
+      {
+        cause,
+        metaMessages: [
+          "This error could arise when the account does not have enough funds to:",
+          " - pay for the total gas fee,",
+          " - pay for the value to send.",
+          " ",
+          "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
+          " - `gas` is the amount of gas needed for transaction to execute,",
+          " - `gas fee` is the gas fee,",
+          " - `value` is the amount of ether to send to the recipient."
+        ]
+      }
+    );
+    __publicField(this, "name", "InsufficientFundsError");
   }
-  return data;
-}
-
-// src/utils/data/size.ts
-function size(value) {
-  if (isHex(value))
-    return Math.ceil((value.length - 2) / 2);
-  return value.length;
-}
-
-// src/utils/data/slice.ts
-function slice(value, start, end) {
-  if (isHex(value))
-    return sliceHex(value, start, end);
-  return sliceBytes(value, start, end);
-}
-function assertStartOffset(value, start) {
-  if (typeof start === "number" && start > 0 && start > size(value) - 1)
-    throw new Error(
-      `Slice starting at offset "${start}" is out-of-bounds (size: ${size(
-        value
-      )}).`
+};
+__publicField(InsufficientFundsError, "nodeMessage", /insufficient funds/);
+var IntrinsicGasTooHighError = class extends BaseError {
+  constructor({ cause, gas } = {}) {
+    super(
+      `The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`,
+      {
+        cause
+      }
     );
-}
-function sliceBytes(value, start, end) {
-  assertStartOffset(value, start);
-  return value.slice(start, end);
-}
-function sliceHex(value_, start, end) {
-  assertStartOffset(value_, start);
-  const value = value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2);
-  return `0x${value}`;
-}
-
-// src/utils/encoding/toHex.ts
-var hexes = Array.from(
-  { length: 256 },
-  (_v, i) => i.toString(16).padStart(2, "0")
-);
-function boolToHex(value) {
-  return `0x${Number(value)}`;
-}
-function bytesToHex(value) {
-  let hex = "";
-  for (let i = 0; i < value.length; i++) {
-    hex += hexes[value[i]];
+    __publicField(this, "name", "IntrinsicGasTooHighError");
+  }
+};
+__publicField(IntrinsicGasTooHighError, "nodeMessage", /intrinsic gas too high|gas limit reached/);
+var IntrinsicGasTooLowError = class extends BaseError {
+  constructor({ cause, gas } = {}) {
+    super(
+      `The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`,
+      {
+        cause
+      }
+    );
+    __publicField(this, "name", "IntrinsicGasTooLowError");
   }
-  return `0x${hex}`;
-}
-function toHex(value) {
-  if (typeof value === "number" || typeof value === "bigint")
-    return numberToHex(value);
-  if (typeof value === "string") {
-    return stringToHex(value);
+};
+__publicField(IntrinsicGasTooLowError, "nodeMessage", /intrinsic gas too low/);
+var TransactionTypeNotSupportedError = class extends BaseError {
+  constructor({ cause }) {
+    super("The transaction type is not supported for this chain.", {
+      cause
+    });
+    __publicField(this, "name", "TransactionTypeNotSupportedError");
   }
-  if (typeof value === "boolean")
-    return boolToHex(value);
-  return bytesToHex(value);
-}
-function numberToHex(value_, opts = {}) {
-  const { signed, size: size2 } = opts;
-  let value = BigInt(value_);
-  let maxValue;
-  if (size2) {
-    if (signed)
-      maxValue = (1n << BigInt(size2) * 8n - 1n) - 1n;
-    else
-      maxValue = 2n ** (BigInt(size2) * 8n) - 1n;
-  } else if (typeof value_ === "number") {
-    maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+};
+__publicField(TransactionTypeNotSupportedError, "nodeMessage", /transaction type not valid/);
+var TipAboveFeeCapError = class extends BaseError {
+  constructor({
+    cause,
+    maxPriorityFeePerGas,
+    maxFeePerGas
+  } = {}) {
+    super(
+      [
+        `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
+      ].join("\n"),
+      {
+        cause
+      }
+    );
+    __publicField(this, "name", "TipAboveFeeCapError");
   }
-  const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
-  if (maxValue && value > maxValue || value < minValue) {
-    const suffix = typeof value_ === "bigint" ? "n" : "";
-    throw new IntegerOutOfRangeError({
-      max: maxValue ? `${maxValue}${suffix}` : void 0,
-      min: `${minValue}${suffix}`,
-      signed,
-      size: size2,
-      value: `${value_}${suffix}`
+};
+__publicField(TipAboveFeeCapError, "nodeMessage", /max priority fee per gas higher than max fee per gas|tip higher than fee cap/);
+var UnknownNodeError = class extends BaseError {
+  constructor({ cause }) {
+    super(`An error occurred while executing: ${cause?.message}`, {
+      cause
     });
+    __publicField(this, "name", "UnknownNodeError");
   }
-  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size2 * 8)) + BigInt(value) : value).toString(16)}`;
-  if (size2)
-    return pad(hex, { size: size2 });
-  return hex;
-}
-var encoder = new TextEncoder();
-function stringToHex(value_) {
-  const value = encoder.encode(value_);
-  return toHex(value);
-}
+};
 
-// src/utils/encoding/toBytes.ts
-var encoder2 = new TextEncoder();
-function toBytes(value) {
-  if (typeof value === "number" || typeof value === "bigint")
-    return numberToBytes(value);
-  if (typeof value === "boolean")
-    return boolToBytes(value);
-  if (value.startsWith("0x"))
-    return hexToBytes(value);
-  return stringToBytes(value);
-}
-function boolToBytes(value) {
-  const bytes = new Uint8Array(1);
-  bytes[0] = Number(value);
-  return bytes;
-}
-function hexToBytes(hex_) {
-  let hex = hex_.slice(2);
-  if (hex.length % 2)
-    hex = `0${hex}`;
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let index = 0; index < bytes.length; index++) {
-    const start = index * 2;
-    const hexByte = hex.slice(start, start + 2);
-    const byte = Number.parseInt(hexByte, 16);
-    if (Number.isNaN(byte) || byte < 0)
-      throw new BaseError(`Invalid byte sequence ("${hexByte}" in "${hex}").`);
-    bytes[index] = byte;
+// src/errors/request.ts
+var RequestError = class extends BaseError {
+  constructor(err, {
+    docsPath: docsPath6,
+    metaMessages,
+    shortMessage
+  }) {
+    super(shortMessage, {
+      cause: err,
+      docsPath: docsPath6,
+      metaMessages
+    });
+    this.name = err.name;
   }
-  return bytes;
-}
-function numberToBytes(value, opts) {
-  const hex = numberToHex(value, opts);
-  return hexToBytes(hex);
-}
-function stringToBytes(value) {
-  return encoder2.encode(value);
-}
-
-// src/utils/encoding/toRlp.ts
-function toRlp(hexOrBytes, to_) {
-  const to = to_ || "hex";
-  return format(bytesToRlp(parse(hexOrBytes)), to);
-}
-function parse(hexOrBytes) {
-  if (Array.isArray(hexOrBytes))
-    return hexOrBytes.map(parse);
-  return typeof hexOrBytes === "string" ? toBytes(hexOrBytes) : hexOrBytes;
-}
-function format(bytes, type = "bytes") {
-  return type === "hex" ? bytesToHex(bytes) : bytes;
-}
-function bytesToRlp(bytes) {
-  if (Array.isArray(bytes)) {
-    const encoded = concat(bytes.map(bytesToRlp));
-    return new Uint8Array([...encodeLength(encoded.length, 192), ...encoded]);
+};
+var RpcRequestError = class extends RequestError {
+  constructor(err, { docsPath: docsPath6, shortMessage }) {
+    super(err, { docsPath: docsPath6, metaMessages: err.metaMessages, shortMessage });
+    __publicField(this, "code");
+    this.code = err.code;
+    this.name = err.name;
   }
-  if (bytes.length === 1 && bytes[0] < 128)
-    return bytes;
-  return new Uint8Array([...encodeLength(bytes.length, 128), ...bytes]);
-}
-function encodeLength(length, offset) {
-  if (length < 56)
-    return [offset + length];
-  return [toBytes(length).length + offset + 55, ...toBytes(length)];
-}
-
-// src/utils/encoding/fromHex.ts
-function fromHex(hex, to) {
-  if (to === "number")
-    return hexToNumber(hex);
-  if (to === "bigint")
-    return hexToBigInt(hex);
-  if (to === "string")
-    return hexToString(hex);
-  if (to === "boolean")
-    return hexToBool(hex);
-  return hexToBytes(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 (trim(hex) === "0x0")
-    return false;
-  if (trim(hex) === "0x1")
-    return true;
-  throw new InvalidHexBooleanError(hex);
-}
-function hexToNumber(hex, opts = {}) {
-  return Number(hexToBigInt(hex, opts));
-}
-function hexToString(hex) {
-  const bytes = hexToBytes(hex);
-  return new TextDecoder().decode(bytes);
-}
-
-// src/utils/encoding/fromBytes.ts
-function fromBytes(bytes, to) {
-  if (to === "number")
-    return bytesToNumber(bytes);
-  if (to === "bigint")
-    return bytesToBigint(bytes);
-  if (to === "boolean")
-    return bytesToBool(bytes);
-  if (to === "string")
-    return bytesToString(bytes);
-  return bytesToHex(bytes);
-}
-function bytesToBigint(bytes) {
-  const hex = bytesToHex(bytes);
-  return hexToBigInt(hex);
-}
-function bytesToBool(bytes) {
-  if (bytes.length > 1 || bytes[0] > 1)
-    throw new InvalidBytesBooleanError(bytes);
-  return Boolean(bytes[0]);
-}
-function bytesToNumber(bytes) {
-  const hex = bytesToHex(bytes);
-  return hexToNumber(hex);
-}
-function bytesToString(bytes) {
-  return new TextDecoder().decode(bytes);
-}
-
-// src/utils/encoding/fromRlp.ts
-function fromRlp(value, to) {
-  const bytes = parse2(value);
-  const [data, consumed] = rlpToBytes(bytes);
-  if (consumed < bytes.length)
-    throw new DataLengthTooLongError({
-      consumed,
-      length: bytes.length
+};
+var ParseRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      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);
+  }
+};
+var InvalidRequestRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { shortMessage: "JSON is not a valid request object." });
+    __publicField(this, "name", "InvalidRequestRpcError");
+    __publicField(this, "code", -32600);
+  }
+};
+var MethodNotFoundRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      shortMessage: "The method does not exist / is not available."
     });
-  return format2(data, to);
-}
-function parse2(value) {
-  if (typeof value === "string") {
-    if (value.length > 3 && value.length % 2 !== 0)
-      throw new InvalidHexValueError(value);
-    return hexToBytes(value);
+    __publicField(this, "name", "MethodNotFoundRpcError");
+    __publicField(this, "code", -32601);
   }
-  return value;
-}
-function format2(bytes, to) {
-  if (Array.isArray(bytes))
-    return bytes.map((b) => format2(b, to));
-  return to === "hex" ? trim(bytesToHex(bytes)) : bytes;
-}
-function rlpToBytes(bytes, offset = 0) {
-  if (bytes.length === 0)
-    return [new Uint8Array([]), 0];
-  const prefix = bytes[offset];
-  if (prefix <= 127)
-    return [new Uint8Array([bytes[offset]]), 1];
-  if (prefix <= 183) {
-    const length2 = prefix - 128;
-    const offset_ = offset + 1;
-    if (offset_ + length2 > bytes.length)
-      throw new DataLengthTooShortError({
-        length: offset_ + length2,
-        dataLength: bytes.length
-      });
-    return [bytes.slice(offset_, offset_ + length2), 1 + length2];
+};
+var InvalidParamsRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      shortMessage: [
+        "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);
   }
-  if (prefix <= 191) {
-    const lengthOfLength2 = prefix - 183;
-    const offset_ = offset + 1;
-    const length2 = bytesToNumber(bytes.slice(offset_, offset_ + lengthOfLength2));
-    if (offset_ + lengthOfLength2 + length2 > bytes.length)
-      throw new DataLengthTooShortError({
-        length: lengthOfLength2 + length2,
-        dataLength: bytes.length - lengthOfLength2
-      });
-    return [
-      bytes.slice(offset_ + lengthOfLength2, offset_ + lengthOfLength2 + length2),
-      1 + lengthOfLength2 + length2
-    ];
+};
+var InternalRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { shortMessage: "An internal error was received." });
+    __publicField(this, "name", "InternalRpcError");
+    __publicField(this, "code", -32603);
   }
-  let lengthOfLength = 0;
-  let length = prefix - 192;
-  if (prefix > 247) {
-    lengthOfLength = prefix - 247;
-    length = bytesToNumber(bytes.slice(offset + 1, offset + 1 + lengthOfLength));
+};
+var InvalidInputRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      shortMessage: [
+        "Missing or invalid parameters.",
+        "Double check you have provided the correct parameters."
+      ].join("\n")
+    });
+    __publicField(this, "name", "InvalidInputRpcError");
+    __publicField(this, "code", -32e3);
   }
-  let nextOffset = offset + 1 + lengthOfLength;
-  if (nextOffset > bytes.length)
-    throw new DataLengthTooShortError({
-      length: nextOffset,
-      dataLength: bytes.length
+};
+var ResourceNotFoundRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { shortMessage: "Requested resource not found." });
+    __publicField(this, "name", "ResourceNotFoundRpcError");
+    __publicField(this, "code", -32001);
+  }
+};
+var ResourceUnavailableRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { shortMessage: "Requested resource not available." });
+    __publicField(this, "name", "ResourceUnavailableRpcError");
+    __publicField(this, "code", -32002);
+  }
+};
+var TransactionRejectedRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { shortMessage: "Transaction creation failed." });
+    __publicField(this, "name", "TransactionRejectedRpcError");
+    __publicField(this, "code", -32003);
+  }
+};
+var MethodNotSupportedRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { shortMessage: "Method is not implemented." });
+    __publicField(this, "name", "MethodNotSupportedRpcError");
+    __publicField(this, "code", -32004);
+  }
+};
+var LimitExceededRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { shortMessage: "Request exceeds defined limit." });
+    __publicField(this, "name", "LimitExceededRpcError");
+    __publicField(this, "code", -32005);
+  }
+};
+var JsonRpcVersionUnsupportedError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      shortMessage: "Version of JSON-RPC protocol is not supported."
     });
-  let consumed = 1 + lengthOfLength + length;
-  let result = [];
-  while (nextOffset < offset + consumed) {
-    const decoded = rlpToBytes(bytes, nextOffset);
-    result.push(decoded[0]);
-    nextOffset += decoded[1];
-    if (nextOffset > offset + consumed)
-      throw new OffsetOutOfBoundsError({
-        nextOffset,
-        offset: offset + consumed
-      });
+    __publicField(this, "name", "JsonRpcVersionUnsupportedError");
+    __publicField(this, "code", -32006);
   }
-  return [result, consumed];
-}
-
-// src/utils/contract/extractFunctionParts.ts
-var paramsRegex = /((function|event)\s)?(.*)(\((.*)\))/;
-function extractFunctionParts(def) {
-  const parts = def.match(paramsRegex);
-  const type = parts?.[2] || void 0;
-  const name = parts?.[3];
-  const params = parts?.[5] || void 0;
-  return { type, name, params };
-}
-function extractFunctionName(def) {
-  return extractFunctionParts(def).name;
-}
-function extractFunctionParams(def) {
-  const params = extractFunctionParts(def).params;
-  const splitParams = params?.split(",").map((x) => x.trim().split(" "));
-  return splitParams?.map((param) => ({
-    type: param[0],
-    name: param[1] === "indexed" ? param[2] : param[1],
-    ...param[1] === "indexed" ? { indexed: true } : {}
-  }));
-}
-function extractFunctionType(def) {
-  return extractFunctionParts(def).type;
-}
-
-// src/utils/hash/keccak256.ts
-import { keccak_256 } from "@noble/hashes/sha3";
-function keccak256(value, to_) {
-  const to = to_ || "hex";
-  const bytes = keccak_256(isHex(value) ? toBytes(value) : value);
-  if (to === "bytes")
-    return bytes;
-  return toHex(bytes);
-}
-
-// src/utils/hash/hashFunction.ts
-var hash = (value) => keccak256(toBytes(value));
-function hashFunction(def) {
-  const name = extractFunctionName(def);
-  const params = extractFunctionParams(def);
-  if (!params || params.length === 0)
-    return hash(def.replace(/ /g, ""));
-  return hash(`${name}(${params.map(({ type }) => type).join(",")})`);
-}
-
-// src/utils/hash/getEventSelector.ts
-var getEventSelector = (event) => hashFunction(event);
-
-// src/utils/hash/getFunctionSelector.ts
-var getFunctionSelector = (fn) => slice(hashFunction(fn), 0, 4);
-
-// src/utils/address/isAddress.ts
-var addressRegex = /^0x[a-fA-F0-9]{40}$/;
-function isAddress(address) {
-  return addressRegex.test(address);
-}
+};
+var UserRejectedRequestError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      shortMessage: "User rejected the request."
+    });
+    __publicField(this, "name", "UserRejectedRequestError");
+    __publicField(this, "code", 4001);
+  }
+};
+var SwitchChainError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      shortMessage: "An error occurred when attempting to switch chain."
+    });
+    __publicField(this, "name", "SwitchChainError");
+    __publicField(this, "code", 4902);
+  }
+};
+var UnknownRpcError = class extends RequestError {
+  constructor(err) {
+    super(err, {
+      shortMessage: "An unknown RPC error occurred."
+    });
+    __publicField(this, "name", "UnknownRpcError");
+  }
+};
 
-// src/utils/address/getAddress.ts
-function checksumAddress(address_) {
-  const hexAddress = address_.substring(2).toLowerCase();
-  const hash2 = keccak256(stringToBytes(hexAddress), "bytes");
-  let address = hexAddress.split("");
-  for (let i = 0; i < 40; i += 2) {
-    if (hash2[i >> 1] >> 4 >= 8 && address[i]) {
-      address[i] = address[i].toUpperCase();
-    }
-    if ((hash2[i >> 1] & 15) >= 8 && address[i + 1]) {
-      address[i + 1] = address[i + 1].toUpperCase();
-    }
+// src/errors/rpc.ts
+var HttpRequestError = class extends BaseError {
+  constructor({
+    body,
+    details,
+    headers,
+    status,
+    url
+  }) {
+    super("HTTP request failed.", {
+      details,
+      metaMessages: [
+        status && `Status: ${status}`,
+        `URL: ${getUrl(url)}`,
+        `Request body: ${stringify(body)}`
+      ].filter(Boolean)
+    });
+    __publicField(this, "name", "HttpRequestError");
+    __publicField(this, "body");
+    __publicField(this, "headers");
+    __publicField(this, "status");
+    __publicField(this, "url");
+    this.body = body;
+    this.headers = headers;
+    this.status = status;
+    this.url = url;
   }
-  return `0x${address.join("")}`;
-}
-function getAddress(address) {
-  if (!isAddress(address))
-    throw new InvalidAddressError({ address });
-  return checksumAddress(address);
-}
-
-// src/utils/address/getContractAddress.ts
-function getContractAddress2(opts) {
-  if (opts.opcode === "CREATE2")
-    return getCreate2Address(opts);
-  return getCreateAddress(opts);
-}
-function getCreateAddress(opts) {
-  const from = toBytes(getAddress(opts.from));
-  let nonce = toBytes(opts.nonce);
-  if (nonce[0] === 0)
-    nonce = new Uint8Array([]);
-  return getAddress(
-    `0x${keccak256(toRlp([from, nonce], "bytes")).slice(26)}`
-  );
-}
-function getCreate2Address(opts) {
-  const from = toBytes(getAddress(opts.from));
-  const salt = pad(isBytes(opts.salt) ? opts.salt : toBytes(opts.salt), {
-    size: 32
-  });
-  const bytecodeHash = toBytes(
-    keccak256(
-      isBytes(opts.bytecode) ? opts.bytecode : toBytes(opts.bytecode)
-    )
-  );
-  return getAddress(
-    slice(keccak256(concat([toBytes("0xff"), from, salt, bytecodeHash])), 12)
-  );
-}
+};
+var WebSocketRequestError = class extends BaseError {
+  constructor({
+    body,
+    details,
+    url
+  }) {
+    super("WebSocket request failed.", {
+      details,
+      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`]
+    });
+    __publicField(this, "name", "WebSocketRequestError");
+  }
+};
+var RpcError = class extends BaseError {
+  constructor({
+    body,
+    error,
+    url
+  }) {
+    super("RPC Request failed.", {
+      cause: error,
+      details: error.message,
+      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`]
+    });
+    __publicField(this, "code");
+    __publicField(this, "name", "RpcError");
+    this.code = error.code;
+  }
+};
+var TimeoutError = class extends BaseError {
+  constructor({
+    body,
+    url
+  }) {
+    super("The request took too long to respond.", {
+      details: "The request timed out.",
+      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`]
+    });
+    __publicField(this, "name", "TimeoutError");
+  }
+};
 
-// src/utils/address/isAddressEqual.ts
-function isAddressEqual(a, b) {
-  if (!isAddress(a))
-    throw new InvalidAddressError({ address: a });
-  if (!isAddress(b))
-    throw new InvalidAddressError({ address: b });
-  return a.toLowerCase() === b.toLowerCase();
-}
+// src/errors/transport.ts
+var UrlRequiredError = class extends BaseError {
+  constructor() {
+    super(
+      "No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.",
+      {
+        docsPath: "/docs/clients/intro"
+      }
+    );
+  }
+};
 
 // src/utils/abi/encodeAbiParameters.ts
 function encodeAbiParameters(params, values) {
@@ -2828,21 +2893,6 @@ function formatAbiItemWithArgs({
   ).join(", ")})`;
 }
 
-// src/utils/account.ts
-function getAccount(account) {
-  if (typeof account === "string") {
-    if (!isAddress(account))
-      throw new InvalidAddressError({ address: account });
-    return { address: account, type: "json-rpc" };
-  }
-  if (!isAddress(account.address))
-    throw new InvalidAddressError({ address: account.address });
-  return {
-    ...account,
-    type: "local"
-  };
-}
-
 // src/utils/promise/withCache.ts
 var promiseCache = /* @__PURE__ */ new Map();
 var responseCache = /* @__PURE__ */ new Map();
@@ -3452,59 +3502,268 @@ function webSocket(socket, {
       url: socket.url,
       details: "Socket is closed."
     });
-  const id_ = id++;
-  const callback = ({ data }) => {
-    const message = JSON.parse(data);
-    if (typeof message.id === "number" && id_ !== message.id)
-      return;
-    if (message.error) {
-      onError?.(new RpcError({ body, error: message.error, url: socket.url }));
-    } else {
-      onData?.(message);
-    }
-    if (body.method === "eth_subscribe" && typeof message.result === "string") {
-      socket.subscriptions.set(message.result, callback);
-    }
-    if (body.method === "eth_unsubscribe") {
-      socket.subscriptions.delete(body.params?.[0]);
-    }
-  };
-  socket.requests.set(id_, callback);
-  socket.send(JSON.stringify({ jsonrpc: "2.0", ...body, id: id_ }));
-  return socket;
+  const id_ = id++;
+  const callback = ({ data }) => {
+    const message = JSON.parse(data);
+    if (typeof message.id === "number" && id_ !== message.id)
+      return;
+    if (message.error) {
+      onError?.(new RpcError({ body, error: message.error, url: socket.url }));
+    } else {
+      onData?.(message);
+    }
+    if (body.method === "eth_subscribe" && typeof message.result === "string") {
+      socket.subscriptions.set(message.result, callback);
+    }
+    if (body.method === "eth_unsubscribe") {
+      socket.subscriptions.delete(body.params?.[0]);
+    }
+  };
+  socket.requests.set(id_, callback);
+  socket.send(JSON.stringify({ jsonrpc: "2.0", ...body, id: id_ }));
+  return socket;
+}
+async function webSocketAsync(socket, {
+  body,
+  timeout = 1e4
+}) {
+  return withTimeout(
+    () => new Promise(
+      (onData, onError) => rpc.webSocket(socket, {
+        body,
+        onData,
+        onError
+      })
+    ),
+    {
+      errorInstance: new TimeoutError({ body, url: socket.url }),
+      timeout
+    }
+  );
+}
+var rpc = {
+  http,
+  webSocket,
+  webSocketAsync
+};
+
+// src/utils/signature/hashMessage.ts
+function hashMessage(message, to_) {
+  const messageBytes = toBytes(message);
+  const prefixBytes = toBytes(
+    `Ethereum Signed Message:
+${messageBytes.length}`
+  );
+  return keccak256(concat([prefixBytes, messageBytes]), to_);
+}
+
+// src/utils/typedData.ts
+function validateTypedData({
+  domain,
+  message,
+  primaryType,
+  types: types_
+}) {
+  const types = types_;
+  const validateData = (struct, value_) => {
+    for (const param of struct) {
+      const { name, type: type_ } = param;
+      const type = type_;
+      const value = value_[name];
+      const integerMatch = type.match(integerRegex);
+      if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
+        const [_type, base, size_] = integerMatch;
+        numberToHex(value, {
+          signed: base === "int",
+          size: parseInt(size_) / 8
+        });
+      }
+      if (type === "address" && typeof value === "string" && !isAddress(value))
+        throw new InvalidAddressError({ address: value });
+      const bytesMatch = type.match(bytesRegex);
+      if (bytesMatch) {
+        const [_type, size_] = bytesMatch;
+        if (size_ && size(value) !== parseInt(size_))
+          throw new BytesSizeMismatchError({
+            expectedSize: parseInt(size_),
+            givenSize: size(value)
+          });
+      }
+      const struct2 = types[type];
+      if (struct2)
+        validateData(struct2, value);
+    }
+  };
+  if (types["EIP712Domain"] && domain)
+    validateData(types["EIP712Domain"], domain);
+  if (primaryType !== "EIP712Domain") {
+    const type = types[primaryType];
+    validateData(type, message);
+  }
+}
+
+// src/utils/signature/hashTypedData.ts
+function hashTypedData({
+  domain: domain_,
+  message,
+  primaryType,
+  types: types_
+}) {
+  const domain = typeof domain_ === "undefined" ? {} : domain_;
+  const types = {
+    EIP712Domain: [
+      domain?.name && { name: "name", type: "string" },
+      domain?.version && { name: "version", type: "string" },
+      domain?.chainId && { name: "chainId", type: "uint256" },
+      domain?.verifyingContract && {
+        name: "verifyingContract",
+        type: "address"
+      },
+      domain?.salt && { name: "salt", type: "bytes32" }
+    ].filter(Boolean),
+    ...types_
+  };
+  validateTypedData({
+    domain,
+    message,
+    primaryType,
+    types
+  });
+  let parts = ["0x1901"];
+  if (domain)
+    parts.push(
+      hashDomain({
+        domain,
+        types
+      })
+    );
+  if (primaryType !== "EIP712Domain") {
+    parts.push(
+      hashStruct({
+        data: message,
+        primaryType,
+        types
+      })
+    );
+  }
+  return keccak256(concat(parts));
+}
+function hashDomain({
+  domain,
+  types
+}) {
+  return hashStruct({
+    data: domain,
+    primaryType: "EIP712Domain",
+    types
+  });
+}
+function hashStruct({
+  data,
+  primaryType,
+  types
+}) {
+  const encoded = encodeData({
+    data,
+    primaryType,
+    types
+  });
+  return keccak256(encoded);
+}
+function encodeData({
+  data,
+  primaryType,
+  types
+}) {
+  let encodedTypes = [{ type: "bytes32" }];
+  const encodedValues = [hashType({ primaryType, types })];
+  for (const field of types[primaryType]) {
+    const [type, value] = encodeField({
+      types,
+      name: field.name,
+      type: field.type,
+      value: data[field.name]
+    });
+    encodedTypes.push(type);
+    encodedValues.push(value);
+  }
+  return encodeAbiParameters(encodedTypes, encodedValues);
 }
-async function webSocketAsync(socket, {
-  body,
-  timeout = 1e4
+function hashType({
+  primaryType,
+  types
 }) {
-  return withTimeout(
-    () => new Promise(
-      (onData, onError) => rpc.webSocket(socket, {
-        body,
-        onData,
-        onError
-      })
-    ),
-    {
-      errorInstance: new TimeoutError({ body, url: socket.url }),
-      timeout
-    }
-  );
+  const encodedHashType = toHex(encodeType({ primaryType, types }));
+  return keccak256(encodedHashType);
 }
-var rpc = {
-  http,
-  webSocket,
-  webSocketAsync
-};
-
-// src/utils/signature/hashMessage.ts
-function hashMessage(message, to_) {
-  const messageBytes = toBytes(message);
-  const prefixBytes = toBytes(
-    `Ethereum Signed Message:
-${messageBytes.length}`
-  );
-  return keccak256(concat([prefixBytes, messageBytes]), to_);
+function encodeType({
+  primaryType,
+  types
+}) {
+  let result = "";
+  const unsortedDeps = findTypeDependencies({ primaryType, types });
+  unsortedDeps.delete(primaryType);
+  const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
+  for (const type of deps) {
+    result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
+  }
+  return result;
+}
+function findTypeDependencies({
+  primaryType: primaryType_,
+  types
+}, results = /* @__PURE__ */ new Set()) {
+  const match = primaryType_.match(/^\w*/u);
+  const primaryType = match?.[0];
+  if (results.has(primaryType) || types[primaryType] === void 0) {
+    return results;
+  }
+  results.add(primaryType);
+  for (const field of types[primaryType]) {
+    findTypeDependencies({ primaryType: field.type, types }, results);
+  }
+  return results;
+}
+function encodeField({
+  types,
+  name,
+  type,
+  value
+}) {
+  if (types[type] !== void 0) {
+    return [
+      { type: "bytes32" },
+      keccak256(encodeData({ data: value, primaryType: type, types }))
+    ];
+  }
+  if (type === "bytes") {
+    const prepend = value.length % 2 ? "0" : "";
+    value = `0x${prepend + value.slice(2)}`;
+    return [{ type: "bytes32" }, keccak256(value)];
+  }
+  if (type === "string")
+    return [{ type: "bytes32" }, keccak256(toHex(value))];
+  if (type.lastIndexOf("]") === type.length - 1) {
+    const parsedType = type.slice(0, type.lastIndexOf("["));
+    const typeValuePairs = value.map(
+      (item) => encodeField({
+        name,
+        type: parsedType,
+        types,
+        value: item
+      })
+    );
+    return [
+      { type: "bytes32" },
+      keccak256(
+        encodeAbiParameters(
+          typeValuePairs.map(([t]) => t),
+          typeValuePairs.map(([, v]) => v)
+        )
+      )
+    ];
+  }
+  return [{ type }, value];
 }
 
 // src/utils/signature/recoverAddress.ts
@@ -3535,6 +3794,25 @@ function recoverMessageAddress({
   return recoverAddress({ hash: hashMessage(message), signature });
 }
 
+// src/utils/signature/recoverTypedDataAddress.ts
+function recoverTypedDataAddress({
+  domain,
+  message,
+  primaryType,
+  signature,
+  types
+}) {
+  return recoverAddress({
+    hash: hashTypedData({
+      domain,
+      message,
+      primaryType,
+      types
+    }),
+    signature
+  });
+}
+
 // src/utils/signature/verifyMessage.ts
 function verifyMessage({
   address,
@@ -3547,9 +3825,37 @@ function verifyMessage({
   );
 }
 
+// src/utils/signature/verifyTypedData.ts
+function verifyTypedData({
+  address,
+  domain,
+  message,
+  primaryType,
+  signature,
+  types
+}) {
+  return isAddressEqual(
+    getAddress(address),
+    recoverTypedDataAddress({
+      domain,
+      message,
+      primaryType,
+      signature,
+      types
+    })
+  );
+}
+
 // src/utils/transaction/assertRequest.ts
 function assertRequest(args) {
-  const { account, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
+  const {
+    account: account_,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    to
+  } = args;
+  const account = account_ ? parseAccount(account_) : void 0;
   if (account && !isAddress(account.address))
     throw new InvalidAddressError({ address: account.address });
   if (to && !isAddress(to))
@@ -3565,7 +3871,7 @@ function assertRequest(args) {
 // src/actions/public/call.ts
 async function call(client, args) {
   const {
-    account,
+    account: account_,
     blockNumber,
     blockTag = "latest",
     accessList,
@@ -3579,6 +3885,7 @@ async function call(client, args) {
     value,
     ...rest
   } = args;
+  const account = account_ ? parseAccount(account_) : void 0;
   try {
     assertRequest(args);
     const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
@@ -3612,6 +3919,7 @@ async function call(client, args) {
   } catch (err) {
     throw getCallError(err, {
       ...args,
+      account,
       chain: client.chain
     });
   }
@@ -3625,6 +3933,7 @@ async function simulateContract(client, {
   functionName,
   ...callRequest
 }) {
+  const account = callRequest.account ? parseAccount(callRequest.account) : void 0;
   const calldata = encodeFunctionData({
     abi,
     args,
@@ -3659,7 +3968,7 @@ async function simulateContract(client, {
       args,
       docsPath: "/docs/contract/simulateContract",
       functionName,
-      sender: callRequest.account?.address
+      sender: account?.address
     });
   }
 }
@@ -3751,9 +4060,13 @@ async function createContractEventFilter(client, {
 
 // src/actions/public/estimateGas.ts
 async function estimateGas(client, args) {
+  if (!args.account)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/public/estimateGas"
+    });
+  const account = parseAccount(args.account);
   try {
     const {
-      account,
       accessList,
       blockNumber,
       blockTag = "latest",
@@ -3766,7 +4079,7 @@ async function estimateGas(client, args) {
       to,
       value,
       ...rest
-    } = args.account.type === "local" ? await prepareRequest(client, args) : args;
+    } = account.type === "local" ? await prepareRequest(client, args) : args;
     const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
     assertRequest(args);
     const formatter = client.chain?.formatters?.transactionRequest;
@@ -3797,6 +4110,7 @@ async function estimateGas(client, args) {
   } catch (err) {
     throw getEstimateGasError(err, {
       ...args,
+      account,
       chain: client.chain
     });
   }
@@ -3810,6 +4124,7 @@ async function estimateContractGas(client, {
   functionName,
   ...request
 }) {
+  const account = parseAccount(request.account);
   const data = encodeFunctionData({
     abi,
     args,
@@ -3829,7 +4144,7 @@ async function estimateContractGas(client, {
       args,
       docsPath: "/docs/contract/simulateContract",
       functionName,
-      sender: request.account?.address
+      sender: account?.address
     });
   }
 }
@@ -4980,7 +5295,12 @@ async function addChain(client, { chain }) {
 }
 
 // src/actions/wallet/deployContract.ts
-function deployContract(walletClient, { abi, args, bytecode, ...request }) {
+function deployContract(walletClient, {
+  abi,
+  args,
+  bytecode,
+  ...request
+}) {
   const calldata = encodeDeployData({
     abi,
     args,
@@ -5021,10 +5341,9 @@ async function requestPermissions(client, permissions) {
 // src/actions/wallet/sendTransaction.ts
 async function sendTransaction(client, args) {
   const {
-    account,
+    account: account_ = client.account,
     chain = client.chain,
     accessList,
-    assertChain = true,
     data,
     gas,
     gasPrice,
@@ -5035,13 +5354,20 @@ async function sendTransaction(client, args) {
     value,
     ...rest
   } = args;
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/sendTransaction"
+    });
+  const account = parseAccount(account_);
   try {
     assertRequest(args);
-    const currentChainId = await getChainId(client);
-    if (assertChain && chain && currentChainId !== chain?.id)
-      throw new ChainMismatchError({ chain, currentChainId });
+    const chainId = await getChainId(client);
+    if (chain !== null && chainId !== chain?.id) {
+      if (!chain)
+        throw new ChainNotFoundError();
+      throw new ChainMismatchError({ chain, currentChainId: chainId });
+    }
     if (account.type === "local") {
-      const chainId = chain?.id ?? currentChainId;
       const request2 = await prepareRequest(client, {
         account,
         accessList,
@@ -5090,15 +5416,28 @@ async function sendTransaction(client, args) {
       params: [request]
     });
   } catch (err) {
-    throw getTransactionError(err, args);
+    throw getTransactionError(err, {
+      ...args,
+      account,
+      chain: args.chain || void 0
+    });
   }
 }
 
 // src/actions/wallet/signMessage.ts
-async function signMessage(client, { account, data, message }) {
+async function signMessage2(client, {
+  account: account_ = client.account,
+  data,
+  message
+}) {
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/signMessage"
+    });
+  const account = parseAccount(account_);
   const message_ = message || data;
   if (account.type === "local")
-    return account.signMessage(message_);
+    return account.signMessage({ message: message_ });
   return client.request({
     method: "personal_sign",
     params: [toHex(message_), account.address]
@@ -5107,12 +5446,17 @@ async function signMessage(client, { account, data, message }) {
 
 // src/actions/wallet/signTypedData.ts
 async function signTypedData(client, {
-  account,
+  account: account_ = client.account,
   domain,
   message,
   primaryType,
   types: types_
 }) {
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: "/docs/actions/wallet/signTypedData"
+    });
+  const account = parseAccount(account_);
   const types = {
     EIP712Domain: [
       domain?.name && { name: "name", type: "string" },
@@ -5148,47 +5492,6 @@ async function signTypedData(client, {
     params: [account.address, typedData]
   });
 }
-function validateTypedData({
-  domain,
-  message,
-  primaryType,
-  types: types_
-}) {
-  const types = types_;
-  const validateData = (struct, value_) => {
-    for (const param of struct) {
-      const { name, type: type_ } = param;
-      const type2 = type_;
-      const value = value_[name];
-      const integerMatch = type2.match(integerRegex);
-      if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
-        const [_type, base, size_] = integerMatch;
-        numberToHex(value, {
-          signed: base === "int",
-          size: parseInt(size_) / 8
-        });
-      }
-      if (type2 === "address" && typeof value === "string" && !isAddress(value))
-        throw new InvalidAddressError({ address: value });
-      const bytesMatch = type2.match(bytesRegex);
-      if (bytesMatch) {
-        const [_type, size_] = bytesMatch;
-        if (size_ && size(value) !== parseInt(size_))
-          throw new BytesSizeMismatchError({
-            expectedSize: parseInt(size_),
-            givenSize: size(value)
-          });
-      }
-      const struct2 = types[type2];
-      if (struct2)
-        validateData(struct2, value);
-    }
-  };
-  if (types["EIP712Domain"] && domain)
-    validateData(types["EIP712Domain"], domain);
-  const type = types[primaryType];
-  validateData(type, message);
-}
 
 // src/actions/wallet/switchChain.ts
 async function switchChain(client, { id: id2 }) {
@@ -5262,7 +5565,17 @@ function parseGwei(ether, unit = "wei") {
 // src/utils/transaction/prepareRequest.ts
 var defaultTip = parseGwei("1.5");
 async function prepareRequest(client, args) {
-  const { account, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce } = args;
+  const {
+    account: account_,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce
+  } = args;
+  if (!account_)
+    throw new AccountNotFoundError();
+  const account = parseAccount(account_);
   const block = await getBlock(client, { blockTag: "latest" });
   const request = { ...args, from: account.address };
   if (typeof nonce === "undefined")
@@ -5354,6 +5667,56 @@ export {
   InvalidAddressError,
   BlockNotFoundError,
   ChainDoesNotSupportContract,
+  parseAccount,
+  concat,
+  concatBytes,
+  concatHex,
+  isBytes,
+  isHex,
+  pad,
+  padHex,
+  padBytes,
+  trim,
+  size,
+  slice,
+  sliceBytes,
+  sliceHex,
+  boolToHex,
+  bytesToHex,
+  toHex,
+  numberToHex,
+  stringToHex,
+  toBytes,
+  boolToBytes,
+  hexToBytes,
+  numberToBytes,
+  stringToBytes,
+  toRlp,
+  fromHex,
+  hexToBigInt,
+  hexToBool,
+  hexToNumber,
+  hexToString,
+  fromBytes,
+  bytesToBigint,
+  bytesToBool,
+  bytesToNumber,
+  bytesToString,
+  fromRlp,
+  extractFunctionParts,
+  extractFunctionName,
+  extractFunctionParams,
+  extractFunctionType,
+  keccak256,
+  getEventSelector,
+  getFunctionSelector,
+  isAddress,
+  getAddress,
+  getContractAddress2 as getContractAddress,
+  getCreateAddress,
+  getCreate2Address,
+  isAddressEqual,
+  toAccount,
   multicall3Abi,
   panicReasons,
   etherUnits,
@@ -5411,54 +5774,6 @@ export {
   RpcError,
   TimeoutError,
   UrlRequiredError,
-  concat,
-  concatBytes,
-  concatHex,
-  isBytes,
-  isHex,
-  pad,
-  padHex,
-  padBytes,
-  trim,
-  size,
-  slice,
-  sliceBytes,
-  sliceHex,
-  boolToHex,
-  bytesToHex,
-  toHex,
-  numberToHex,
-  stringToHex,
-  toBytes,
-  boolToBytes,
-  hexToBytes,
-  numberToBytes,
-  stringToBytes,
-  toRlp,
-  fromHex,
-  hexToBigInt,
-  hexToBool,
-  hexToNumber,
-  hexToString,
-  fromBytes,
-  bytesToBigint,
-  bytesToBool,
-  bytesToNumber,
-  bytesToString,
-  fromRlp,
-  extractFunctionParts,
-  extractFunctionName,
-  extractFunctionParams,
-  extractFunctionType,
-  keccak256,
-  getEventSelector,
-  getFunctionSelector,
-  isAddress,
-  getAddress,
-  getContractAddress2 as getContractAddress,
-  getCreateAddress,
-  getCreate2Address,
-  isAddressEqual,
   encodeAbiParameters,
   decodeAbiParameters,
   formatAbiItem,
@@ -5481,7 +5796,6 @@ export {
   parseAbiItem,
   parseAbiParameter,
   parseAbiParameters,
-  getAccount,
   isDeterministicError,
   buildRequest,
   defineChain,
@@ -5507,9 +5821,13 @@ export {
   getSocket,
   rpc,
   hashMessage,
+  validateTypedData,
+  hashTypedData,
   recoverAddress,
   recoverMessageAddress,
+  recoverTypedDataAddress,
   verifyMessage,
+  verifyTypedData,
   assertRequest,
   call,
   simulateContract,
@@ -5580,7 +5898,7 @@ export {
   requestAddresses,
   requestPermissions,
   sendTransaction,
-  signMessage,
+  signMessage2 as signMessage,
   signTypedData,
   switchChain,
   watchAsset,
@@ -5593,4 +5911,4 @@ export {
   formatGwei,
   parseEther
 };
-//# sourceMappingURL=chunk-ISLCPEI2.mjs.map
+//# sourceMappingURL=chunk-PB263D6W.mjs.map