viem 0.0.0 → 0.0.1-alpha.0

package/dist/chunk-GI67STNV.js

@@ -0,0 +1,1469 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// package.json
+var package_default = {
+  name: "viem",
+  description: "TypeScript (& JavaScript) Interface for Ethereum",
+  version: "0.0.1-alpha.0",
+  scripts: {
+    build: "tsup",
+    dev: "DEV=true tsup"
+  },
+  dependencies: {
+    "@noble/hashes": "^1.1.2",
+    "@wagmi/chains": "^0.1.0",
+    abitype: "^0.2.5"
+  },
+  files: [
+    "/actions",
+    "/chains",
+    "/dist",
+    "/clients",
+    "/types",
+    "/utils",
+    "/window"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./actions": {
+      types: "./dist/actions/index.d.ts",
+      default: "./dist/actions/index.js"
+    },
+    "./chains": {
+      types: "./dist/chains.d.ts",
+      default: "./dist/chains.js"
+    },
+    "./clients": {
+      types: "./dist/clients/index.d.ts",
+      default: "./dist/clients/index.js"
+    },
+    "./utils": {
+      types: "./dist/utils/index.d.ts",
+      default: "./dist/utils/index.js"
+    },
+    "./window": {
+      types: "./dist/window.d.ts",
+      default: "./dist/window.js"
+    },
+    "./package.json": "./package.json"
+  },
+  type: "module",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  sideEffects: false,
+  license: "WAGMIT",
+  repository: "wagmi-dev/viem",
+  author: "moxey.eth",
+  ethereum: "moxey.eth",
+  keywords: [
+    "eth",
+    "ethereum",
+    "dapps",
+    "wallet",
+    "web3"
+  ]
+};
+
+// src/utils/BaseError.ts
+var version = process.env.TEST ? "1.0.2" : package_default.version;
+var BaseError = class extends Error {
+  constructor(humanMessage, args = {}) {
+    const details = args.cause instanceof BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
+    const docsPath = args.cause instanceof BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
+    const message = [
+      humanMessage,
+      ...docsPath ? ["", "Docs: https://viem.sh" + docsPath] : [],
+      "",
+      ...details ? ["Details: " + details] : [],
+      "Version: viem@" + version,
+      ...args.cause && !(args.cause instanceof BaseError) && Object.keys(args.cause).length > 0 ? ["Internal Error: " + JSON.stringify(args.cause)] : []
+    ].join("\n");
+    super(message);
+    __publicField(this, "humanMessage");
+    __publicField(this, "details");
+    __publicField(this, "docsPath");
+    __publicField(this, "name", "ViemError");
+    if (args.cause)
+      this.cause = args.cause;
+    this.details = details;
+    this.docsPath = docsPath;
+    this.humanMessage = humanMessage;
+  }
+};
+
+// src/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;
+  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 } = {}) {
+  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 (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];
+  }
+  return paddedBytes;
+}
+var SizeExceedsPaddingSizeError = class extends BaseError {
+  constructor({
+    size: size2,
+    targetSize,
+    type
+  }) {
+    super(
+      `${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`
+    );
+    __publicField(this, "name", "SizeExceedsPaddingSizeError");
+  }
+};
+
+// src/utils/data/trim.ts
+function trim(hexOrBytes, { dir = "left" } = {}) {
+  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/encodeHex.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 encodeHex(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 Error(
+      `Number "${value_}${suffix}" is not in safe ${size2 ? `${size2 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${maxValue ? `(${minValue}${suffix} to ${maxValue}${suffix})` : `(above ${minValue})`}`
+    );
+  }
+  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size2 * 8)) + BigInt(value) : value).toString(16)}`;
+  if (size2)
+    return pad(hex, { size: size2 });
+  return hex;
+}
+function stringToHex(value) {
+  let hex = "";
+  for (let i = 0; i < value.length; i++) {
+    hex += value.charCodeAt(i).toString(16);
+  }
+  return `0x${hex}`;
+}
+
+// src/utils/encoding/encodeBytes.ts
+var encoder = new TextEncoder();
+function boolToBytes(value) {
+  const bytes = new Uint8Array(1);
+  bytes[0] = Number(value);
+  return bytes;
+}
+function encodeBytes(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 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 Error("Invalid byte sequence");
+    bytes[index] = byte;
+  }
+  return bytes;
+}
+function numberToBytes(value, opts) {
+  const hex = numberToHex(value, opts);
+  return hexToBytes(hex);
+}
+function stringToBytes(value) {
+  return encoder.encode(value);
+}
+
+// src/utils/encoding/encodeRlp.ts
+function encodeRlp(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" ? encodeBytes(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 [encodeBytes(length).length + offset + 55, ...encodeBytes(length)];
+}
+
+// src/utils/encoding/decodeHex.ts
+function decodeHex(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) {
+  return BigInt(hex);
+}
+function hexToBool(hex) {
+  if (hex === "0x0")
+    return false;
+  if (hex === "0x1")
+    return true;
+  throw new InvalidHexBooleanError(hex);
+}
+function hexToNumber(hex) {
+  return Number(BigInt(hex));
+}
+function hexToString(hex) {
+  const bytes = hexToBytes(hex);
+  return new TextDecoder().decode(bytes);
+}
+var InvalidHexBooleanError = class extends BaseError {
+  constructor(hex) {
+    super(
+      `Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`
+    );
+    __publicField(this, "name", "InvalidHexBooleanError");
+  }
+};
+
+// src/utils/encoding/decodeBytes.ts
+function decodeBytes(bytes, to) {
+  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);
+}
+var InvalidBytesBooleanError = class extends BaseError {
+  constructor(bytes) {
+    super(
+      `Bytes value "${bytes}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`
+    );
+    __publicField(this, "name", "InvalidBytesBooleanError");
+  }
+};
+
+// src/utils/encoding/decodeRlp.ts
+function decodeRlp(value, to) {
+  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];
+}
+var DataLengthTooLongError = class extends BaseError {
+  constructor({ consumed, length }) {
+    super(
+      `Consumed bytes (${consumed}) is shorter than data length (${length - 1}).`
+    );
+    __publicField(this, "name", "DataLengthTooLongError");
+  }
+};
+var DataLengthTooShortError = class extends BaseError {
+  constructor({ length, dataLength }) {
+    super(
+      `Data length (${dataLength - 1}) is shorter than prefix length (${length - 1}).`
+    );
+    __publicField(this, "name", "DataLengthTooShortError");
+  }
+};
+var InvalidHexValueError = class extends BaseError {
+  constructor(value) {
+    super(
+      `Hex value "${value}" is an odd length (${value.length}). It must be an even length.`
+    );
+    __publicField(this, "name", "InvalidHexValueError");
+  }
+};
+var OffsetOutOfBoundsError = class extends BaseError {
+  constructor({ nextOffset, offset }) {
+    super(
+      `Next offset (${nextOffset}) is greater than previous offset + consumed bytes (${offset})`
+    );
+    __publicField(this, "name", "OffsetOutOfBoundsError");
+  }
+};
+
+// src/utils/solidity.ts
+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(value);
+  if (to === "bytes")
+    return bytes;
+  return encodeHex(bytes);
+}
+
+// src/utils/hash/hashFunction.ts
+var hash = (value) => keccak256(encodeBytes(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/getEventSignature.ts
+var getEventSignature = (event) => hashFunction(event);
+
+// src/utils/hash/getFunctionSignature.ts
+var getFunctionSignature = (fn) => hashFunction(fn).slice(0, 10);
+
+// src/utils/address/getAddress.ts
+var addressRegex = /^(0x)?[a-fA-F0-9]{40}$/;
+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].toUpperCase();
+    }
+    if ((hash2[i >> 1] & 15) >= 8) {
+      address[i + 1] = address[i + 1].toUpperCase();
+    }
+  }
+  return `0x${address.join("")}`;
+}
+function getAddress(address) {
+  if (!addressRegex.test(address))
+    throw new InvalidAddressError({ address });
+  return checksumAddress(address);
+}
+var InvalidAddressError = class extends BaseError {
+  constructor({ address }) {
+    super(`Address "${address}" is invalid.`);
+    __publicField(this, "name", "InvalidAddressError");
+  }
+};
+
+// src/utils/address/getContractAddress.ts
+function getContractAddress(opts) {
+  if (opts.opcode === "CREATE2")
+    return getCreate2Address(opts);
+  return getCreateAddress(opts);
+}
+function getCreateAddress(opts) {
+  const from = encodeBytes(getAddress(opts.from));
+  let nonce = encodeBytes(opts.nonce);
+  if (nonce[0] === 0)
+    nonce = new Uint8Array([]);
+  return getAddress(
+    "0x" + keccak256(encodeRlp([from, nonce], "bytes")).slice(26)
+  );
+}
+function getCreate2Address(opts) {
+  const from = encodeBytes(getAddress(opts.from));
+  const salt = pad(
+    isBytes(opts.salt) ? opts.salt : encodeBytes(opts.salt),
+    { size: 32 }
+  );
+  const bytecodeHash = encodeBytes(
+    keccak256(
+      isBytes(opts.bytecode) ? opts.bytecode : encodeBytes(opts.bytecode)
+    )
+  );
+  return getAddress(
+    slice(
+      keccak256(concat([encodeBytes("0xff"), from, salt, bytecodeHash])),
+      12
+    )
+  );
+}
+
+// src/utils/address/isAddress.ts
+function isAddress(address) {
+  try {
+    return Boolean(getAddress(address));
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/address/isAddressEqual.ts
+function isAddressEqual(a, b) {
+  return getAddress(a) === getAddress(b);
+}
+
+// src/utils/buildRequest.ts
+function buildRequest(request) {
+  return async (args) => {
+    try {
+      return await request(args);
+    } catch (err_) {
+      let err = err_;
+      if (err.code === -32700)
+        throw new ParseRpcError(err);
+      if (err.code === -32600)
+        throw new InvalidRequestRpcError(err);
+      if (err.code === -32601)
+        throw new MethodNotFoundRpcError(err);
+      if (err.code === -32602)
+        throw new InvalidParamsRpcError(err);
+      if (err.code === -32603)
+        throw new InternalRpcError(err);
+      if (err.code === -32e3)
+        throw new InvalidInputRpcError(err);
+      if (err.code === -32001)
+        throw new ResourceNotFoundRpcError(err);
+      if (err.code === -32002)
+        throw new ResourceUnavailableRpcError(err);
+      if (err.code === -32003)
+        throw new TransactionRejectedRpcError(err);
+      if (err.code === -32004)
+        throw new MethodNotSupportedRpcError(err);
+      if (err.code === -32005)
+        throw new LimitExceededRpcError(err);
+      if (err.code === -32006)
+        throw new JsonRpcVersionUnsupportedError(err);
+      if (err_ instanceof BaseError)
+        throw err_;
+      throw new UnknownRpcError(err);
+    }
+  };
+}
+var RequestError = class extends BaseError {
+  constructor(err, { docsPath, humanMessage }) {
+    super(humanMessage, {
+      cause: err,
+      docsPath
+    });
+    this.name = err.name;
+  }
+};
+var RpcRequestError = class extends RequestError {
+  constructor(err, { docsPath, humanMessage }) {
+    super(err, { docsPath, humanMessage });
+    __publicField(this, "code");
+    this.code = err.code;
+    this.name = err.name;
+  }
+};
+var ParseRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
+    });
+    __publicField(this, "name", "ParseRpcError");
+    __publicField(this, "code", -32700);
+  }
+};
+var InvalidRequestRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "JSON is not a valid request object." });
+    __publicField(this, "name", "InvalidRequestRpcError");
+    __publicField(this, "code", -32600);
+  }
+};
+var MethodNotFoundRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: "The method does not exist / is not available."
+    });
+    __publicField(this, "name", "MethodNotFoundRpcError");
+    __publicField(this, "code", -32601);
+  }
+};
+var InvalidParamsRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: [
+        "Invalid parameters were provided to the RPC method.",
+        "Double check you have provided the correct parameters."
+      ].join("\n")
+    });
+    __publicField(this, "name", "InvalidParamsRpcError");
+    __publicField(this, "code", -32602);
+  }
+};
+var InternalRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "An internal error was received." });
+    __publicField(this, "name", "InternalRpcError");
+    __publicField(this, "code", -32603);
+  }
+};
+var InvalidInputRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: [
+        "Missing or invalid parameters.",
+        "Double check you have provided the correct parameters."
+      ].join("\n")
+    });
+    __publicField(this, "name", "InvalidInputRpcError");
+    __publicField(this, "code", -32e3);
+  }
+};
+var ResourceNotFoundRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Requested resource not found." });
+    __publicField(this, "name", "ResourceNotFoundRpcError");
+    __publicField(this, "code", -32001);
+  }
+};
+var ResourceUnavailableRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Requested resource not available." });
+    __publicField(this, "name", "ResourceUnavailableRpcError");
+    __publicField(this, "code", -32002);
+  }
+};
+var TransactionRejectedRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Transaction creation failed." });
+    __publicField(this, "name", "TransactionRejectedRpcError");
+    __publicField(this, "code", -32003);
+  }
+};
+var MethodNotSupportedRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Method is not implemented." });
+    __publicField(this, "name", "MethodNotSupportedRpcError");
+    __publicField(this, "code", -32004);
+  }
+};
+var LimitExceededRpcError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, { humanMessage: "Request exceeds defined limit." });
+    __publicField(this, "name", "LimitExceededRpcError");
+    __publicField(this, "code", -32005);
+  }
+};
+var JsonRpcVersionUnsupportedError = class extends RpcRequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: "Version of JSON-RPC protocol is not supported."
+    });
+    __publicField(this, "name", "JsonRpcVersionUnsupportedError");
+    __publicField(this, "code", -32006);
+  }
+};
+var UnknownRpcError = class extends RequestError {
+  constructor(err) {
+    super(err, {
+      humanMessage: "An unknown RPC error occurred."
+    });
+    __publicField(this, "name", "UnknownRpcError");
+  }
+};
+
+// src/constants.ts
+var etherUnits = {
+  gwei: 9,
+  wei: 18
+};
+var gweiUnits = {
+  ether: -9,
+  wei: 9
+};
+var weiUnits = {
+  ether: -18,
+  gwei: -9
+};
+var transactionType = {
+  "0x0": "legacy",
+  "0x1": "eip2930",
+  "0x2": "eip1559"
+};
+
+// src/utils/formatters/transaction.ts
+function formatTransaction(transaction) {
+  const transaction_ = {
+    ...transaction,
+    blockNumber: transaction.blockNumber ? BigInt(transaction.blockNumber) : null,
+    gas: transaction.gas ? BigInt(transaction.gas) : void 0,
+    gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : void 0,
+    maxFeePerGas: transaction.maxFeePerGas ? BigInt(transaction.maxFeePerGas) : void 0,
+    maxPriorityFeePerGas: transaction.maxPriorityFeePerGas ? BigInt(transaction.maxPriorityFeePerGas) : void 0,
+    nonce: transaction.nonce ? hexToNumber(transaction.nonce) : void 0,
+    transactionIndex: transaction.transactionIndex ? Number(transaction.transactionIndex) : null,
+    type: transaction.type ? transactionType[transaction.type] : void 0,
+    value: transaction.value ? BigInt(transaction.value) : void 0,
+    v: transaction.v ? BigInt(transaction.v) : void 0
+  };
+  if (transaction_.type === "legacy") {
+    delete transaction_["accessList"];
+    delete transaction_["maxFeePerGas"];
+    delete transaction_["maxPriorityFeePerGas"];
+  }
+  if (transaction_.type === "eip2930") {
+    delete transaction_["maxFeePerGas"];
+    delete transaction_["maxPriorityFeePerGas"];
+  }
+  return transaction_;
+}
+
+// src/utils/formatters/block.ts
+function formatBlock(block) {
+  const transactions = block.transactions?.map((transaction) => {
+    if (typeof transaction === "string")
+      return transaction;
+    return formatTransaction(transaction);
+  });
+  return {
+    ...block,
+    baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
+    difficulty: block.difficulty ? BigInt(block.difficulty) : void 0,
+    gasLimit: block.gasLimit ? BigInt(block.gasLimit) : void 0,
+    gasUsed: block.gasUsed ? BigInt(block.gasUsed) : void 0,
+    number: block.number ? BigInt(block.number) : null,
+    size: block.size ? BigInt(block.size) : void 0,
+    timestamp: block.timestamp ? BigInt(block.timestamp) : void 0,
+    transactions,
+    totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : null
+  };
+}
+
+// src/utils/formatters/feeHistory.ts
+function formatFeeHistory(feeHistory) {
+  return {
+    baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
+    gasUsedRatio: feeHistory.gasUsedRatio,
+    oldestBlock: BigInt(feeHistory.oldestBlock),
+    reward: feeHistory.reward?.map(
+      (reward) => reward.map((value) => BigInt(value))
+    )
+  };
+}
+
+// src/utils/formatters/format.ts
+function format3(data, { formatter }) {
+  return formatter(data);
+}
+
+// src/utils/formatters/log.ts
+function formatLog(log) {
+  return {
+    ...log,
+    blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
+    logIndex: log.logIndex ? BigInt(log.logIndex) : null,
+    transactionIndex: log.transactionIndex ? BigInt(log.transactionIndex) : null
+  };
+}
+
+// src/utils/formatters/transactionReceipt.ts
+var statuses = {
+  "0x0": "reverted",
+  "0x1": "success"
+};
+function formatTransactionReceipt(transactionReceipt) {
+  return {
+    ...transactionReceipt,
+    blockNumber: transactionReceipt.blockNumber ? BigInt(transactionReceipt.blockNumber) : null,
+    cumulativeGasUsed: transactionReceipt.cumulativeGasUsed ? BigInt(transactionReceipt.cumulativeGasUsed) : null,
+    effectiveGasPrice: transactionReceipt.effectiveGasPrice ? BigInt(transactionReceipt.effectiveGasPrice) : null,
+    gasUsed: transactionReceipt.gasUsed ? BigInt(transactionReceipt.gasUsed) : null,
+    logs: transactionReceipt.logs ? transactionReceipt.logs.map(formatLog) : null,
+    transactionIndex: transactionReceipt.transactionIndex ? hexToNumber(transactionReceipt.transactionIndex) : null,
+    status: transactionReceipt.status ? statuses[transactionReceipt.status] : null,
+    type: transactionReceipt.type ? transactionType[transactionReceipt.type] : null
+  };
+}
+
+// src/utils/formatters/transactionRequest.ts
+function formatTransactionRequest(transactionRequest) {
+  return {
+    ...transactionRequest,
+    gas: typeof transactionRequest.gas !== "undefined" ? numberToHex(transactionRequest.gas) : void 0,
+    gasPrice: typeof transactionRequest.gasPrice !== "undefined" ? numberToHex(transactionRequest.gasPrice) : void 0,
+    maxFeePerGas: typeof transactionRequest.maxFeePerGas !== "undefined" ? numberToHex(transactionRequest.maxFeePerGas) : void 0,
+    maxPriorityFeePerGas: typeof transactionRequest.maxPriorityFeePerGas !== "undefined" ? numberToHex(transactionRequest.maxPriorityFeePerGas) : void 0,
+    nonce: typeof transactionRequest.nonce !== "undefined" ? numberToHex(transactionRequest.nonce) : void 0,
+    value: typeof transactionRequest.value !== "undefined" ? numberToHex(transactionRequest.value) : void 0
+  };
+}
+
+// src/utils/promise/withCache.ts
+var promiseCache = /* @__PURE__ */ new Map();
+var responseCache = /* @__PURE__ */ new Map();
+function getCache(cacheKey) {
+  const buildCache = (cacheKey2, cache) => ({
+    clear: () => cache.delete(cacheKey2),
+    get: () => cache.get(cacheKey2),
+    set: (data) => cache.set(cacheKey2, data)
+  });
+  const promise = buildCache(cacheKey, promiseCache);
+  const response = buildCache(
+    cacheKey,
+    responseCache
+  );
+  return {
+    clear: () => {
+      promise.clear();
+      response.clear();
+    },
+    promise,
+    response
+  };
+}
+async function withCache(fn, { cacheKey, maxAge = Infinity }) {
+  const cache = getCache(cacheKey);
+  const response = cache.response.get();
+  if (response && maxAge > 0) {
+    const age = new Date().getTime() - response.created.getTime();
+    if (age < maxAge)
+      return response.data;
+  }
+  let promise = cache.promise.get();
+  if (!promise) {
+    promise = fn();
+    cache.promise.set(promise);
+  }
+  const data = await promise;
+  cache.promise.clear();
+  cache.response.set({ created: new Date(), data });
+  return data;
+}
+
+// src/utils/wait.ts
+async function wait(time) {
+  return new Promise((res) => setTimeout(res, time));
+}
+
+// src/utils/promise/withRetry.ts
+function withRetry(fn, {
+  delay: delay_ = 100,
+  retryCount = 2,
+  shouldRetryOnResponse = () => false,
+  shouldRetryOnError = () => false
+} = {}) {
+  return new Promise((resolve, reject) => {
+    const attemptRetry = async ({ count = 0 } = {}) => {
+      const retry = async ({ data } = {}) => {
+        const delay = typeof delay_ === "function" ? delay_({ count, data }) : delay_;
+        if (delay)
+          await wait(delay);
+        attemptRetry({ count: count + 1 });
+      };
+      try {
+        const data = await fn();
+        if (count < retryCount && await shouldRetryOnResponse({ count, data }))
+          return retry({ data });
+        resolve(data);
+      } catch (err) {
+        if (count < retryCount && await shouldRetryOnError({ count, error: err }))
+          return retry();
+        reject(err);
+      }
+    };
+    attemptRetry();
+  });
+}
+
+// src/utils/promise/withTimeout.ts
+function withTimeout(fn, {
+  errorInstance,
+  timeout,
+  signal
+}) {
+  return new Promise((resolve, reject) => {
+    ;
+    (async () => {
+      let timeoutId;
+      try {
+        const controller = new AbortController();
+        if (timeout > 0) {
+          timeoutId = setTimeout(() => {
+            if (signal) {
+              controller.abort();
+            } else {
+              reject(errorInstance);
+            }
+          }, timeout);
+        }
+        resolve(await fn({ signal: controller?.signal }));
+      } catch (err) {
+        if (err.name === "AbortError")
+          reject(errorInstance);
+        reject(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    })();
+  });
+}
+
+// src/utils/rpc.ts
+var id = 0;
+async function http(url, {
+  body,
+  retryDelay = 100,
+  retryCount = 2,
+  timeout = 0
+}) {
+  const response = await withRetry(
+    () => withTimeout(
+      async ({ signal }) => {
+        const response2 = await fetch(url, {
+          headers: {
+            "Content-Type": "application/json"
+          },
+          method: "POST",
+          body: JSON.stringify({ jsonrpc: "2.0", id: id++, ...body }),
+          signal: timeout > 0 ? signal : void 0
+        });
+        return response2;
+      },
+      {
+        errorInstance: new TimeoutError({ body, url }),
+        timeout,
+        signal: true
+      }
+    ),
+    {
+      delay: ({ count, data: data2 }) => {
+        const retryAfter = data2?.headers.get("Retry-After");
+        if (retryAfter?.match(/\d/))
+          return parseInt(retryAfter) * 1e3;
+        return ~~((Math.random() + 0.5) * (1 << count)) * retryDelay;
+      },
+      retryCount,
+      shouldRetryOnResponse: async ({ data: data2 }) => {
+        if (data2.status >= 500)
+          return true;
+        if ([408, 413, 429].includes(data2.status))
+          return true;
+        return false;
+      }
+    }
+  );
+  let data;
+  if (response.headers.get("Content-Type")?.startsWith("application/json")) {
+    data = await response.json();
+  } else {
+    data = await response.text();
+  }
+  if (!response.ok) {
+    throw new HttpRequestError({
+      body,
+      details: JSON.stringify(data.error) || response.statusText,
+      status: response.status,
+      url
+    });
+  }
+  if (data.error) {
+    throw new RpcError({ body, error: data.error, url });
+  }
+  return data;
+}
+var sockets = /* @__PURE__ */ new Map();
+async function getSocket(url_) {
+  const url = new URL(url_);
+  const urlKey = url.toString();
+  let socket = sockets.get(urlKey);
+  if (socket)
+    return socket;
+  const webSocket2 = new WebSocket(url);
+  const requests = /* @__PURE__ */ new Map();
+  const subscriptions = /* @__PURE__ */ new Map();
+  const onMessage = ({ data }) => {
+    const message = JSON.parse(data);
+    const isSubscription = message.method === "eth_subscription";
+    const id2 = isSubscription ? message.params.subscription : message.id;
+    const cache = isSubscription ? subscriptions : requests;
+    const callback = cache.get(id2);
+    if (callback)
+      callback({ data });
+    if (!isSubscription)
+      cache.delete(id2);
+  };
+  const onClose = () => {
+    sockets.delete(urlKey);
+    webSocket2.removeEventListener("close", onClose);
+    webSocket2.removeEventListener("message", onMessage);
+  };
+  webSocket2.addEventListener("close", onClose);
+  webSocket2.addEventListener("message", onMessage);
+  if (webSocket2.readyState === WebSocket.CONNECTING) {
+    await new Promise((resolve, reject) => {
+      if (!webSocket2)
+        return;
+      webSocket2.onopen = resolve;
+      webSocket2.onerror = reject;
+    });
+  }
+  socket = Object.assign(webSocket2, {
+    requests,
+    subscriptions
+  });
+  sockets.set(urlKey, socket);
+  return socket;
+}
+function webSocket(socket, {
+  body,
+  onData,
+  onError
+}) {
+  if (socket.readyState === socket.CLOSED || socket.readyState === socket.CLOSING)
+    throw new WebSocketRequestError({
+      body,
+      url: socket.url,
+      details: "Socket is closed."
+    });
+  const id_ = id++;
+  const callback = ({ data }) => {
+    const message = JSON.parse(data);
+    if (typeof message.id === "number" && id_ !== message.id)
+      return;
+    if (message.error) {
+      onError?.(new RpcError({ body, error: message.error, url: socket.url }));
+    } else {
+      onData?.(message);
+    }
+    if (body.method === "eth_subscribe" && typeof message.result === "string") {
+      socket.subscriptions.set(message.result, callback);
+    }
+    if (body.method === "eth_unsubscribe") {
+      socket.subscriptions.delete(body.params?.[0]);
+    }
+  };
+  socket.requests.set(id_, callback);
+  socket.send(JSON.stringify({ jsonrpc: "2.0", ...body, id: id_ }));
+  return socket;
+}
+async function webSocketAsync(socket, {
+  body,
+  timeout = 0
+}) {
+  return withTimeout(
+    () => new Promise(
+      (onData, onError) => rpc.webSocket(socket, {
+        body,
+        onData,
+        onError
+      })
+    ),
+    {
+      errorInstance: new TimeoutError({ body, url: socket.url }),
+      timeout
+    }
+  );
+}
+var rpc = {
+  http,
+  webSocket,
+  webSocketAsync
+};
+var HttpRequestError = class extends BaseError {
+  constructor({
+    body,
+    details,
+    status,
+    url
+  }) {
+    super(
+      [
+        "HTTP request failed.",
+        "",
+        `Status: ${status}`,
+        `URL: ${url}`,
+        `Request body: ${JSON.stringify(body)}`
+      ].join("\n"),
+      {
+        details
+      }
+    );
+    __publicField(this, "name", "HttpRequestError");
+    __publicField(this, "status");
+    this.status = status;
+  }
+};
+var WebSocketRequestError = class extends BaseError {
+  constructor({
+    body,
+    details,
+    url
+  }) {
+    super(
+      [
+        "WebSocket request failed.",
+        "",
+        `URL: ${url}`,
+        `Request body: ${JSON.stringify(body)}`
+      ].join("\n"),
+      {
+        details
+      }
+    );
+    __publicField(this, "name", "WebSocketRequestError");
+  }
+};
+var RpcError = class extends BaseError {
+  constructor({
+    body,
+    error,
+    url
+  }) {
+    super(
+      [
+        "RPC Request failed.",
+        "",
+        `URL: ${url}`,
+        `Request body: ${JSON.stringify(body)}`
+      ].join("\n"),
+      {
+        cause: error,
+        details: error.message
+      }
+    );
+    __publicField(this, "code");
+    __publicField(this, "name", "RpcError");
+    this.code = error.code;
+  }
+};
+var TimeoutError = class extends BaseError {
+  constructor({
+    body,
+    url
+  }) {
+    super(
+      [
+        "The request took too long to respond.",
+        "",
+        `URL: ${url}`,
+        `Request body: ${JSON.stringify(body)}`
+      ].join("\n"),
+      {
+        details: "The request timed out."
+      }
+    );
+    __publicField(this, "name", "TimeoutError");
+  }
+};
+
+// src/utils/unit/formatUnit.ts
+function formatUnit(value, decimals) {
+  let display = value.toString();
+  const negative = display.startsWith("-");
+  if (negative)
+    display = display.slice(1);
+  let [integer, fraction] = [
+    display.slice(0, display.length - decimals),
+    display.slice(display.length - decimals)
+  ];
+  fraction = fraction.padStart(decimals, "0");
+  fraction = fraction.replace(/(0+)$/, "");
+  return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
+}
+
+// src/utils/unit/formatEther.ts
+function formatEther(wei, unit = "wei") {
+  return formatUnit(wei, etherUnits[unit]);
+}
+
+// src/utils/unit/formatGwei.ts
+function formatGwei(wei, unit = "wei") {
+  return formatUnit(wei, gweiUnits[unit]);
+}
+
+// src/utils/unit/parseUnit.ts
+function parseUnit(value, decimals) {
+  let [integer, fraction = "0"] = value.split(".");
+  const negative = integer.startsWith("-");
+  if (negative)
+    integer = integer.slice(1);
+  fraction = fraction.replace(/(0+)$/, "");
+  if (decimals === 0) {
+    integer = `${Math.round(Number(`${integer}.${fraction}`))}`;
+    fraction = "";
+  } else if (fraction.length > decimals) {
+    const [before, after] = [
+      fraction.slice(0, decimals),
+      fraction.slice(decimals)
+    ];
+    fraction = `${/^0+$/.test(before) ? before.slice(0, before.length - 1) : ""}${Math.round(Number(`${before}.${after}`))}`;
+  } else {
+    fraction = fraction.padEnd(decimals, "0");
+  }
+  return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
+}
+
+// src/utils/unit/parseEther.ts
+function parseEther(ether, unit = "wei") {
+  return parseUnit(ether, etherUnits[unit]);
+}
+
+// src/utils/unit/parseGwei.ts
+function parseGwei(ether, unit = "wei") {
+  return parseUnit(ether, gweiUnits[unit]);
+}
+
+export {
+  __publicField,
+  BaseError,
+  isBytes,
+  isHex,
+  pad,
+  padHex,
+  padBytes,
+  trim,
+  size,
+  slice,
+  sliceBytes,
+  sliceHex,
+  boolToHex,
+  bytesToHex,
+  encodeHex,
+  numberToHex,
+  stringToHex,
+  boolToBytes,
+  encodeBytes,
+  hexToBytes,
+  numberToBytes,
+  stringToBytes,
+  encodeRlp,
+  decodeHex,
+  hexToBigInt,
+  hexToBool,
+  hexToNumber,
+  hexToString,
+  decodeBytes,
+  bytesToBigint,
+  bytesToBool,
+  bytesToNumber,
+  bytesToString,
+  decodeRlp,
+  extractFunctionName,
+  extractFunctionParams,
+  extractFunctionType,
+  keccak256,
+  getEventSignature,
+  getFunctionSignature,
+  checksumAddress,
+  getAddress,
+  getContractAddress,
+  getCreateAddress,
+  getCreate2Address,
+  isAddress,
+  isAddressEqual,
+  buildRequest,
+  RpcRequestError,
+  ParseRpcError,
+  InvalidRequestRpcError,
+  MethodNotFoundRpcError,
+  InvalidParamsRpcError,
+  InternalRpcError,
+  InvalidInputRpcError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  TransactionRejectedRpcError,
+  MethodNotSupportedRpcError,
+  LimitExceededRpcError,
+  JsonRpcVersionUnsupportedError,
+  etherUnits,
+  gweiUnits,
+  weiUnits,
+  transactionType,
+  formatTransaction,
+  formatBlock,
+  formatFeeHistory,
+  format3 as format,
+  formatLog,
+  formatTransactionReceipt,
+  formatTransactionRequest,
+  getCache,
+  withCache,
+  wait,
+  getSocket,
+  rpc,
+  HttpRequestError,
+  RpcError,
+  TimeoutError,
+  formatUnit,
+  formatEther,
+  formatGwei,
+  parseUnit,
+  parseEther,
+  parseGwei
+};