viem 0.2.0-jxom-local-accounts.20230321T210352 → 0.2.0-jxom-local-accounts.20230321T212822

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

@@ -25,7 +25,7 @@ var package_default = {
     anvil: "source .env && anvil --fork-url $VITE_ANVIL_FORK_URL --fork-block-number $VITE_ANVIL_BLOCK_NUMBER --block-time $VITE_ANVIL_BLOCK_TIME",
     bench: "vitest bench --no-threads",
     "bench:ci": "CI=true vitest bench --no-threads",
-    build: "tsup",
+    build: "tsup && size-limit",
     changeset: "changeset",
     "changeset:release": "pnpm build && changeset publish",
     "changeset:version": "changeset version && pnpm install --lockfile-only",
@@ -53,6 +53,7 @@ var package_default = {
     entry: [
       "src/index.ts",
       "src/abi.ts",
+      "src/accounts/index.ts",
       "src/chains.ts",
       "src/contract.ts",
       "src/ens.ts",
@@ -66,6 +67,7 @@ var package_default = {
   },
   files: [
     "/abi",
+    "/accounts",
     "/dist",
     "/chains",
     "/contract",
@@ -88,6 +90,11 @@ var package_default = {
       module: "./dist/abi.mts",
       default: "./dist/abi.js"
     },
+    "./accounts": {
+      types: "./dist/accounts/index.d.ts",
+      module: "./dist/accounts/index.mts",
+      default: "./dist/accounts/index.js"
+    },
     "./chains": {
       types: "./dist/chains.d.ts",
       module: "./dist/chains.mts",
@@ -156,6 +163,7 @@ var package_default = {
     "@adraffy/ens-normalize": "^1.8.9",
     "@changesets/changelog-github": "^0.4.5",
     "@changesets/cli": "^2.23.2",
+    "@size-limit/preset-big-lib": "^8.2.4",
     "@types/dedent": "^0.7.0",
     "@types/fs-extra": "^9.0.13",
     "@types/node": "^17.0.45",
@@ -173,6 +181,7 @@ var package_default = {
     rimraf: "^4.1.2",
     rome: "^11.0.0",
     "simple-git-hooks": "^2.8.1",
+    "size-limit": "^8.2.4",
     tsup: "^6.6.0",
     typescript: "^4.9.4",
     vite: "^4.1.4",
@@ -191,6 +200,11 @@ var package_default = {
     "wallet",
     "web3"
   ],
+  "size-limit": [
+    {
+      path: "dist/index.js"
+    }
+  ],
   "simple-git-hooks": {
     "pre-commit": "pnpm format && pnpm lint:fix"
   },
@@ -616,714 +630,157 @@ var ChainNotFoundError = class extends BaseError {
   }
 };
 
-// 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;
+// 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"
   }
-  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/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/isHex.ts
-function isHex(value) {
-  if (!value)
-    return false;
-  if (typeof value !== "string")
-    return false;
-  return /^0x[0-9a-fA-F]*$/.test(value);
-}
+// 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/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 });
+// 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");
 }
-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"
+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
     });
-  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"
+    super(cause.shortMessage, {
+      cause,
+      docsPath: docsPath6,
+      metaMessages: [
+        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+        "Request Arguments:",
+        prettyArgs
+      ].filter(Boolean)
     });
-  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}`;
-  }
-  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;
+    __publicField(this, "cause");
+    __publicField(this, "name", "TransactionExecutionError");
+    this.cause = cause;
   }
 };
 var TransactionNotFoundError = class extends BaseError {
@@ -1913,144 +1370,669 @@ var ResourceUnavailableRpcError = class extends RpcRequestError {
     __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 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);
+  }
+};
+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/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 MethodNotSupportedRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { shortMessage: "Method is not implemented." });
-    __publicField(this, "name", "MethodNotSupportedRpcError");
-    __publicField(this, "code", -32004);
+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");
   }
 };
-var LimitExceededRpcError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, { shortMessage: "Request exceeds defined limit." });
-    __publicField(this, "name", "LimitExceededRpcError");
-    __publicField(this, "code", -32005);
+
+// 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"
+      }
+    );
   }
 };
-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);
+
+// 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 UserRejectedRequestError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      shortMessage: "User rejected the request."
+  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"
     });
-    __publicField(this, "name", "UserRejectedRequestError");
-    __publicField(this, "code", 4001);
+  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 SwitchChainError = class extends RpcRequestError {
-  constructor(err) {
-    super(err, {
-      shortMessage: "An error occurred when attempting to switch chain."
+  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}`
     });
-    __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");
+  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/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)
+// 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
     });
-    __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 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 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");
+  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 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;
+  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 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)}`]
+  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
     });
-    __publicField(this, "name", "TimeoutError");
+  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/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/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/utils/abi/encodeAbiParameters.ts
 function encodeAbiParameters(params, values) {
@@ -2893,6 +2875,13 @@ function formatAbiItemWithArgs({
   ).join(", ")})`;
 }
 
+// src/accounts/utils/parseAccount.ts
+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();
@@ -3767,14 +3756,14 @@ function encodeField({
 }
 
 // src/utils/signature/recoverAddress.ts
-import { recoverPublicKey } from "@noble/secp256k1";
-function recoverAddress({
+async 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),
@@ -3787,7 +3776,7 @@ function recoverAddress({
 }
 
 // src/utils/signature/recoverMessageAddress.ts
-function recoverMessageAddress({
+async function recoverMessageAddress({
   message,
   signature
 }) {
@@ -3795,7 +3784,7 @@ function recoverMessageAddress({
 }
 
 // src/utils/signature/recoverTypedDataAddress.ts
-function recoverTypedDataAddress({
+async function recoverTypedDataAddress({
   domain,
   message,
   primaryType,
@@ -3814,19 +3803,19 @@ function recoverTypedDataAddress({
 }
 
 // src/utils/signature/verifyMessage.ts
-function verifyMessage({
+async function verifyMessage({
   address,
   message,
   signature
 }) {
   return isAddressEqual(
     getAddress(address),
-    recoverMessageAddress({ message, signature })
+    await recoverMessageAddress({ message, signature })
   );
 }
 
 // src/utils/signature/verifyTypedData.ts
-function verifyTypedData({
+async function verifyTypedData({
   address,
   domain,
   message,
@@ -3836,7 +3825,7 @@ function verifyTypedData({
 }) {
   return isAddressEqual(
     getAddress(address),
-    recoverTypedDataAddress({
+    await recoverTypedDataAddress({
       domain,
       message,
       primaryType,
@@ -5425,7 +5414,7 @@ async function sendTransaction(client, args) {
 }
 
 // src/actions/wallet/signMessage.ts
-async function signMessage2(client, {
+async function signMessage(client, {
   account: account_ = client.account,
   data,
   message
@@ -5667,56 +5656,6 @@ 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,
@@ -5774,6 +5713,55 @@ 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,
+  checksumAddress,
+  getAddress,
+  getContractAddress2 as getContractAddress,
+  getCreateAddress,
+  getCreate2Address,
+  isAddressEqual,
   encodeAbiParameters,
   decodeAbiParameters,
   formatAbiItem,
@@ -5796,6 +5784,7 @@ export {
   parseAbiItem,
   parseAbiParameter,
   parseAbiParameters,
+  parseAccount,
   isDeterministicError,
   buildRequest,
   defineChain,
@@ -5898,7 +5887,7 @@ export {
   requestAddresses,
   requestPermissions,
   sendTransaction,
-  signMessage2 as signMessage,
+  signMessage,
   signTypedData,
   switchChain,
   watchAsset,
@@ -5911,4 +5900,4 @@ export {
   formatGwei,
   parseEther
 };
-//# sourceMappingURL=chunk-PB263D6W.mjs.map
+//# sourceMappingURL=chunk-IVRML3IK.mjs.map