viem 0.2.0-jxom-async-verify-message.20230321T000803 → 0.2.0-jxom-local-accounts.20230321T210352

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

@@ -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",
@@ -614,178 +616,735 @@ var ChainNotFoundError = class extends BaseError {
   }
 };
 
-// src/constants/abis.ts
-var multicall3Abi = [
-  {
-    inputs: [
-      {
-        components: [
-          {
-            name: "target",
-            type: "address"
-          },
-          {
-            name: "allowFailure",
-            type: "bool"
-          },
-          {
-            name: "callData",
-            type: "bytes"
-          }
-        ],
-        name: "calls",
-        type: "tuple[]"
-      }
-    ],
-    name: "aggregate3",
-    outputs: [
-      {
-        components: [
-          {
-            name: "success",
-            type: "bool"
-          },
-          {
-            name: "returnData",
-            type: "bytes"
-          }
-        ],
-        name: "returnData",
-        type: "tuple[]"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
+// src/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;
   }
-];
+  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/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/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/constants/unit.ts
-var etherUnits = {
-  gwei: 9,
-  wei: 18
-};
-var gweiUnits = {
-  ether: -9,
-  wei: 9
-};
-var weiUnits = {
-  ether: -18,
-  gwei: -9
-};
+// 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/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");
+// 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 });
 }
-var FeeConflictError = class extends BaseError {
-  constructor() {
-    super(
-      [
-        "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
-        "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
-      ].join("\n")
-    );
-    __publicField(this, "name", "FeeConflictError");
-  }
-};
-var TransactionExecutionError = class extends BaseError {
-  constructor(cause, {
-    account,
-    docsPath: 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
+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, {
-      cause,
-      docsPath: docsPath6,
-      metaMessages: [
-        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
-        "Request Arguments:",
-        prettyArgs
-      ].filter(Boolean)
+  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"
     });
-    __publicField(this, "cause");
-    __publicField(this, "name", "TransactionExecutionError");
-    this.cause = cause;
+  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 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");
+  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
+      )}).`
+    );
+}
+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]];
+  }
+  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}`
+    });
+  }
+  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/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/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);
+  }
+  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];
+  }
+  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
+    ];
+  }
+  let lengthOfLength = 0;
+  let length = prefix - 192;
+  if (prefix > 247) {
+    lengthOfLength = prefix - 247;
+    length = bytesToNumber(bytes.slice(offset + 1, offset + 1 + lengthOfLength));
+  }
+  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/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/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/accounts/toAccount.ts
+function toAccount(source) {
+  if (typeof source === "string") {
+    if (!isAddress(source))
+      throw new InvalidAddressError({ address: source });
+    return {
+      address: source,
+      type: "json-rpc"
+    };
+  }
+  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: [
+      {
+        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 {
+  constructor() {
+    super(
+      [
+        "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
+        "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
+      ].join("\n")
+    );
+    __publicField(this, "name", "FeeConflictError");
+  }
+};
+var TransactionExecutionError = class extends BaseError {
+  constructor(cause, {
+    account,
+    docsPath: 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");
   }
 };
 var TransactionReceiptNotFoundError = class extends BaseError {
@@ -1094,929 +1653,404 @@ var FilterTypeNotSupportedError = class extends BaseError {
     super(`Filter type "${type}" is not supported.`);
     __publicField(this, "name", "FilterTypeNotSupportedError");
   }
-};
-
-// src/errors/node.ts
-var ExecutionRevertedError = class extends BaseError {
-  constructor({
-    cause,
-    message
-  } = {}) {
-    const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
-    super(
-      `Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`,
-      {
-        cause
-      }
-    );
-    __publicField(this, "name", "ExecutionRevertedError");
-  }
-};
-__publicField(ExecutionRevertedError, "code", 3);
-__publicField(ExecutionRevertedError, "nodeMessage", /execution reverted/);
-var FeeCapTooHighError = class extends BaseError {
-  constructor({
-    cause,
-    maxFeePerGas
-  } = {}) {
-    super(
-      `The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`,
-      {
-        cause
-      }
-    );
-    __publicField(this, "name", "FeeCapTooHigh");
-  }
-};
-__publicField(FeeCapTooHighError, "nodeMessage", /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/);
-var FeeCapTooLowError = class extends BaseError {
-  constructor({
-    cause,
-    maxFeePerGas
-  } = {}) {
-    super(
-      `The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`,
-      {
-        cause
-      }
-    );
-    __publicField(this, "name", "FeeCapTooLow");
-  }
-};
-__publicField(FeeCapTooLowError, "nodeMessage", /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/);
-var NonceTooHighError = class extends BaseError {
-  constructor({ cause, nonce } = {}) {
-    super(
-      `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`,
-      { cause }
-    );
-    __publicField(this, "name", "NonceTooHighError");
-  }
-};
-__publicField(NonceTooHighError, "nodeMessage", /nonce too high/);
-var NonceTooLowError = class extends BaseError {
-  constructor({ cause, nonce } = {}) {
-    super(
-      [
-        `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
-        "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
-      ].join("\n"),
-      { cause }
-    );
-    __publicField(this, "name", "NonceTooLowError");
-  }
-};
-__publicField(NonceTooLowError, "nodeMessage", /nonce too low|transaction already imported/);
-var NonceMaxValueError = class extends BaseError {
-  constructor({ cause, nonce } = {}) {
-    super(
-      `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`,
-      { cause }
-    );
-    __publicField(this, "name", "NonceMaxValueError");
-  }
-};
-__publicField(NonceMaxValueError, "nodeMessage", /nonce has max value/);
-var InsufficientFundsError = class extends BaseError {
-  constructor({ cause } = {}) {
-    super(
-      [
-        "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
-      ].join("\n"),
-      {
-        cause,
-        metaMessages: [
-          "This error could arise when the account does not have enough funds to:",
-          " - pay for the total gas fee,",
-          " - pay for the value to send.",
-          " ",
-          "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
-          " - `gas` is the amount of gas needed for transaction to execute,",
-          " - `gas fee` is the gas fee,",
-          " - `value` is the amount of ether to send to the recipient."
-        ]
-      }
-    );
-    __publicField(this, "name", "InsufficientFundsError");
-  }
-};
-__publicField(InsufficientFundsError, "nodeMessage", /insufficient funds/);
-var IntrinsicGasTooHighError = class extends BaseError {
-  constructor({ cause, gas } = {}) {
+};
+
+// src/errors/node.ts
+var ExecutionRevertedError = class extends BaseError {
+  constructor({
+    cause,
+    message
+  } = {}) {
+    const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
     super(
-      `The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`,
+      `Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`,
       {
         cause
       }
     );
-    __publicField(this, "name", "IntrinsicGasTooHighError");
+    __publicField(this, "name", "ExecutionRevertedError");
   }
 };
-__publicField(IntrinsicGasTooHighError, "nodeMessage", /intrinsic gas too high|gas limit reached/);
-var IntrinsicGasTooLowError = class extends BaseError {
-  constructor({ cause, gas } = {}) {
+__publicField(ExecutionRevertedError, "code", 3);
+__publicField(ExecutionRevertedError, "nodeMessage", /execution reverted/);
+var FeeCapTooHighError = class extends BaseError {
+  constructor({
+    cause,
+    maxFeePerGas
+  } = {}) {
     super(
-      `The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`,
+      `The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`,
       {
         cause
       }
     );
-    __publicField(this, "name", "IntrinsicGasTooLowError");
-  }
-};
-__publicField(IntrinsicGasTooLowError, "nodeMessage", /intrinsic gas too low/);
-var TransactionTypeNotSupportedError = class extends BaseError {
-  constructor({ cause }) {
-    super("The transaction type is not supported for this chain.", {
-      cause
-    });
-    __publicField(this, "name", "TransactionTypeNotSupportedError");
+    __publicField(this, "name", "FeeCapTooHigh");
   }
 };
-__publicField(TransactionTypeNotSupportedError, "nodeMessage", /transaction type not valid/);
-var TipAboveFeeCapError = 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({
     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"),
+      `The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`,
       {
         cause
       }
     );
-    __publicField(this, "name", "TipAboveFeeCapError");
-  }
-};
-__publicField(TipAboveFeeCapError, "nodeMessage", /max priority fee per gas higher than max fee per gas|tip higher than fee cap/);
-var UnknownNodeError = class extends BaseError {
-  constructor({ cause }) {
-    super(`An error occurred while executing: ${cause?.message}`, {
-      cause
-    });
-    __publicField(this, "name", "UnknownNodeError");
-  }
-};
-
-// src/errors/request.ts
-var RequestError = class extends BaseError {
-  constructor(err, {
-    docsPath: docsPath6,
-    metaMessages,
-    shortMessage
-  }) {
-    super(shortMessage, {
-      cause: err,
-      docsPath: docsPath6,
-      metaMessages
-    });
-    this.name = err.name;
-  }
-};
-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 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."
-    });
-    __publicField(this, "name", "MethodNotFoundRpcError");
-    __publicField(this, "code", -32601);
-  }
-};
-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);
-  }
-};
-var InternalRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { shortMessage: "An internal error was received." });
-    __publicField(this, "name", "InternalRpcError");
-    __publicField(this, "code", -32603);
-  }
-};
-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);
-  }
-};
-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."
-    });
-    __publicField(this, "name", "JsonRpcVersionUnsupportedError");
-    __publicField(this, "code", -32006);
+    __publicField(this, "name", "FeeCapTooLow");
   }
 };
-var UserRejectedRequestError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      shortMessage: "User rejected the request."
-    });
-    __publicField(this, "name", "UserRejectedRequestError");
-    __publicField(this, "code", 4001);
+__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");
   }
 };
-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);
+__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");
   }
 };
-var UnknownRpcError = class extends RequestError {
-  constructor(err) {
-    super(err, {
-      shortMessage: "An unknown RPC error occurred."
-    });
-    __publicField(this, "name", "UnknownRpcError");
+__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");
   }
 };
-
-// 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;
+__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 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");
+__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");
   }
 };
-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;
+__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 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(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", "TimeoutError");
+    __publicField(this, "name", "TransactionTypeNotSupportedError");
   }
 };
-
-// src/errors/transport.ts
-var UrlRequiredError = class extends BaseError {
-  constructor() {
+__publicField(TransactionTypeNotSupportedError, "nodeMessage", /transaction type not valid/);
+var TipAboveFeeCapError = class extends BaseError {
+  constructor({
+    cause,
+    maxPriorityFeePerGas,
+    maxFeePerGas
+  } = {}) {
     super(
-      "No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.",
+      [
+        `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
+      ].join("\n"),
       {
-        docsPath: "/docs/clients/intro"
+        cause
       }
     );
+    __publicField(this, "name", "TipAboveFeeCapError");
   }
 };
-
-// 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;
-  }
-  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"
+__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
     });
-  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];
-  }
-  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}`;
+    __publicField(this, "name", "UnknownNodeError");
   }
-  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
-      )}).`
-    );
-}
-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]];
+// 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 `0x${hex}`;
-}
-function toHex(value) {
-  if (typeof value === "number" || typeof value === "bigint")
-    return numberToHex(value);
-  if (typeof value === "string") {
-    return stringToHex(value);
+};
+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 (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);
+};
+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);
   }
-  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}`
+};
+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."
     });
+    __publicField(this, "name", "MethodNotFoundRpcError");
+    __publicField(this, "code", -32601);
   }
-  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;
+};
+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);
   }
-  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 InternalRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { shortMessage: "An internal error was received." });
+    __publicField(this, "name", "InternalRpcError");
+    __publicField(this, "code", -32603);
   }
-  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 InvalidInputRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      shortMessage: [
+        "Missing or invalid parameters.",
+        "Double check you have provided the correct parameters."
+      ].join("\n")
     });
-  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", "InvalidInputRpcError");
+    __publicField(this, "code", -32e3);
+  }
+};
+var ResourceNotFoundRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { shortMessage: "Requested resource not found." });
+    __publicField(this, "name", "ResourceNotFoundRpcError");
+    __publicField(this, "code", -32001);
   }
-  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 ResourceUnavailableRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { shortMessage: "Requested resource not available." });
+    __publicField(this, "name", "ResourceUnavailableRpcError");
+    __publicField(this, "code", -32002);
   }
-  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 TransactionRejectedRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { shortMessage: "Transaction creation failed." });
+    __publicField(this, "name", "TransactionRejectedRpcError");
+    __publicField(this, "code", -32003);
   }
-  let lengthOfLength = 0;
-  let length = prefix - 192;
-  if (prefix > 247) {
-    lengthOfLength = prefix - 247;
-    length = bytesToNumber(bytes.slice(offset + 1, offset + 1 + lengthOfLength));
+};
+var MethodNotSupportedRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { shortMessage: "Method is not implemented." });
+    __publicField(this, "name", "MethodNotSupportedRpcError");
+    __publicField(this, "code", -32004);
   }
-  let nextOffset = offset + 1 + lengthOfLength;
-  if (nextOffset > bytes.length)
-    throw new DataLengthTooShortError({
-      length: nextOffset,
-      dataLength: bytes.length
+};
+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);
-}
-
-// 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();
-    }
+};
+var UserRejectedRequestError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      shortMessage: "User rejected the request."
+    });
+    __publicField(this, "name", "UserRejectedRequestError");
+    __publicField(this, "code", 4001);
   }
-  return `0x${address.join("")}`;
-}
-function getAddress(address) {
-  if (!isAddress(address))
-    throw new InvalidAddressError({ address });
-  return checksumAddress(address);
-}
+};
+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/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/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;
+  }
+};
+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) {
@@ -2859,32 +2893,6 @@ function formatAbiItemWithArgs({
   ).join(", ")})`;
 }
 
-// src/utils/account.ts
-function getAccount(source) {
-  if (typeof source === "string") {
-    if (!isAddress(source))
-      throw new InvalidAddressError({ address: source });
-    return {
-      address: source,
-      type: "json-rpc"
-    };
-  }
-  if (!isAddress(source.address))
-    throw new InvalidAddressError({ address: source.address });
-  return {
-    address: source.address,
-    signMessage: source.signMessage,
-    signTransaction: source.signTransaction,
-    signTypedData: source.signTypedData,
-    type: "local"
-  };
-}
-function parseAccount(account) {
-  if (typeof account === "string")
-    return { address: account, type: "json-rpc" };
-  return account;
-}
-
 // src/utils/promise/withCache.ts
 var promiseCache = /* @__PURE__ */ new Map();
 var responseCache = /* @__PURE__ */ new Map();
@@ -3549,13 +3557,59 @@ ${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: domain_,
   message,
   primaryType,
   types: types_
 }) {
+  const domain = typeof domain_ === "undefined" ? {} : domain_;
   const types = {
     EIP712Domain: [
       domain?.name && { name: "name", type: "string" },
@@ -3569,6 +3623,12 @@ function hashTypedData({
     ].filter(Boolean),
     ...types_
   };
+  validateTypedData({
+    domain,
+    message,
+    primaryType,
+    types
+  });
   let parts = ["0x1901"];
   if (domain)
     parts.push(
@@ -3707,14 +3767,14 @@ function encodeField({
 }
 
 // src/utils/signature/recoverAddress.ts
-async function recoverAddress({
+import { recoverPublicKey } from "@noble/secp256k1";
+function recoverAddress({
   hash: hash2,
   signature
 }) {
   const signatureHex = isHex(signature) ? signature : toHex(signature);
   const hashHex = isHex(hash2) ? hash2 : toHex(hash2);
   const v = hexToNumber(`0x${signatureHex.slice(130)}`);
-  const { recoverPublicKey } = await import("@noble/secp256k1");
   const publicKey = toHex(
     recoverPublicKey(
       hashHex.substring(2),
@@ -3727,7 +3787,7 @@ async function recoverAddress({
 }
 
 // src/utils/signature/recoverMessageAddress.ts
-async function recoverMessageAddress({
+function recoverMessageAddress({
   message,
   signature
 }) {
@@ -3735,7 +3795,7 @@ async function recoverMessageAddress({
 }
 
 // src/utils/signature/recoverTypedDataAddress.ts
-async function recoverTypedDataAddress({
+function recoverTypedDataAddress({
   domain,
   message,
   primaryType,
@@ -3754,19 +3814,19 @@ async function recoverTypedDataAddress({
 }
 
 // src/utils/signature/verifyMessage.ts
-async function verifyMessage({
+function verifyMessage({
   address,
   message,
   signature
 }) {
   return isAddressEqual(
     getAddress(address),
-    await recoverMessageAddress({ message, signature })
+    recoverMessageAddress({ message, signature })
   );
 }
 
 // src/utils/signature/verifyTypedData.ts
-async function verifyTypedData({
+function verifyTypedData({
   address,
   domain,
   message,
@@ -3776,7 +3836,7 @@ async function verifyTypedData({
 }) {
   return isAddressEqual(
     getAddress(address),
-    await recoverTypedDataAddress({
+    recoverTypedDataAddress({
       domain,
       message,
       primaryType,
@@ -5365,7 +5425,7 @@ async function sendTransaction(client, args) {
 }
 
 // src/actions/wallet/signMessage.ts
-async function signMessage(client, {
+async function signMessage2(client, {
   account: account_ = client.account,
   data,
   message
@@ -5377,7 +5437,7 @@ async function signMessage(client, {
   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]
@@ -5432,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 }) {
@@ -5648,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,
@@ -5705,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,
@@ -5775,8 +5796,6 @@ export {
   parseAbiItem,
   parseAbiParameter,
   parseAbiParameters,
-  getAccount,
-  parseAccount,
   isDeterministicError,
   buildRequest,
   defineChain,
@@ -5802,6 +5821,7 @@ export {
   getSocket,
   rpc,
   hashMessage,
+  validateTypedData,
   hashTypedData,
   recoverAddress,
   recoverMessageAddress,
@@ -5878,7 +5898,7 @@ export {
   requestAddresses,
   requestPermissions,
   sendTransaction,
-  signMessage,
+  signMessage2 as signMessage,
   signTypedData,
   switchChain,
   watchAsset,
@@ -5891,4 +5911,4 @@ export {
   formatGwei,
   parseEther
 };
-//# sourceMappingURL=chunk-FEPL5HFW.mjs.map
+//# sourceMappingURL=chunk-PB263D6W.mjs.map