viem 0.0.1-alpha.8 → 0.0.1-cjs.10

package/dist/chunk-4Z43OTO6.js

@@ -1,1349 +0,0 @@
-import {
-  AbiConstructorNotFoundError,
-  AbiConstructorParamsNotFoundError,
-  AbiDecodingDataSizeInvalidError,
-  AbiEncodingArrayLengthMismatchError,
-  AbiEncodingLengthMismatchError,
-  AbiErrorInputsNotFoundError,
-  AbiErrorNotFoundError,
-  AbiErrorSignatureNotFoundError,
-  AbiEventNotFoundError,
-  AbiFunctionNotFoundError,
-  AbiFunctionOutputsNotFoundError,
-  AbiFunctionSignatureNotFoundError,
-  DataLengthTooLongError,
-  DataLengthTooShortError,
-  FilterTypeNotSupportedError,
-  InvalidAbiDecodingTypeError,
-  InvalidAbiEncodingTypeError,
-  InvalidAddressError,
-  InvalidArrayError,
-  InvalidBytesBooleanError,
-  InvalidDefinitionTypeError,
-  InvalidHexBooleanError,
-  InvalidHexValueError,
-  OffsetOutOfBoundsError,
-  SizeExceedsPaddingSizeError
-} from "./chunk-ALVD6MNU.js";
-
-// 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;
-}
-
-// 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, 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/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);
-}
-
-// 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];
-}
-
-// 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) => slice(hashFunction(fn), 0, 4);
-
-// 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);
-}
-
-// 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/abi/encodeAbi.ts
-function encodeAbi({
-  params,
-  values
-}) {
-  if (params.length !== values.length)
-    throw new AbiEncodingLengthMismatchError({
-      expectedLength: params.length,
-      givenLength: values.length
-    });
-  const preparedParams = prepareParams({ params, values });
-  const data = encodeParams(preparedParams);
-  if (data.length === 0)
-    return "0x";
-  return data;
-}
-function prepareParams({
-  params,
-  values
-}) {
-  let preparedParams = [];
-  for (let i = 0; i < params.length; i++) {
-    preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
-  }
-  return preparedParams;
-}
-function prepareParam({
-  param,
-  value
-}) {
-  const arrayComponents = getArrayComponents(param.type);
-  if (arrayComponents) {
-    const [length, type] = arrayComponents;
-    return encodeArray(value, { length, param: { ...param, type } });
-  }
-  if (param.type === "tuple") {
-    return encodeTuple(value, {
-      param
-    });
-  }
-  if (param.type === "address") {
-    return encodeAddress(value);
-  }
-  if (param.type === "bool") {
-    return encodeBool(value);
-  }
-  if (param.type.startsWith("uint") || param.type.startsWith("int")) {
-    const signed = param.type.startsWith("int");
-    return encodeNumber(value, { signed });
-  }
-  if (param.type.startsWith("bytes")) {
-    return encodeBytes2(value, { param });
-  }
-  if (param.type === "string") {
-    return encodeString(value);
-  }
-  throw new InvalidAbiEncodingTypeError(param.type);
-}
-function encodeParams(preparedParams) {
-  let staticSize = 0;
-  for (let i = 0; i < preparedParams.length; i++) {
-    const { dynamic, encoded } = preparedParams[i];
-    if (dynamic)
-      staticSize += 32;
-    else
-      staticSize += size(encoded);
-  }
-  let staticParams = [];
-  let dynamicParams = [];
-  let dynamicSize = 0;
-  for (let i = 0; i < preparedParams.length; i++) {
-    const { dynamic, encoded } = preparedParams[i];
-    if (dynamic) {
-      staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
-      dynamicParams.push(encoded);
-      dynamicSize += size(encoded);
-    } else {
-      staticParams.push(encoded);
-    }
-  }
-  return concat([...staticParams, ...dynamicParams]);
-}
-function encodeAddress(value) {
-  return { dynamic: false, encoded: padHex(value.toLowerCase()) };
-}
-function encodeArray(value, {
-  length,
-  param
-}) {
-  let dynamic = length === null;
-  if (!Array.isArray(value))
-    throw new InvalidArrayError(value);
-  if (!dynamic && value.length !== length)
-    throw new AbiEncodingArrayLengthMismatchError({
-      expectedLength: length,
-      givenLength: value.length,
-      type: `${param.type}[${length}]`
-    });
-  let dynamicChild = false;
-  let preparedParams = [];
-  for (let i = 0; i < value.length; i++) {
-    const preparedParam = prepareParam({ param, value: value[i] });
-    if (preparedParam.dynamic)
-      dynamicChild = true;
-    preparedParams.push(preparedParam);
-  }
-  if (dynamic || dynamicChild) {
-    const data = encodeParams(preparedParams);
-    if (dynamic) {
-      const length2 = numberToHex(preparedParams.length, { size: 32 });
-      return {
-        dynamic: true,
-        encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
-      };
-    }
-    if (dynamicChild)
-      return { dynamic: true, encoded: data };
-  }
-  return {
-    dynamic: false,
-    encoded: concat(preparedParams.map(({ encoded }) => encoded))
-  };
-}
-function encodeBytes2(value, { param }) {
-  const [_, size_] = param.type.split("bytes");
-  if (!size_)
-    return {
-      dynamic: true,
-      encoded: concat([
-        padHex(numberToHex(size(value), { size: 32 })),
-        padHex(value, { dir: "right" })
-      ])
-    };
-  return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
-}
-function encodeBool(value) {
-  return { dynamic: false, encoded: padHex(boolToHex(value)) };
-}
-function encodeNumber(value, { signed }) {
-  return {
-    dynamic: false,
-    encoded: numberToHex(value, {
-      size: 32,
-      signed
-    })
-  };
-}
-function encodeString(value) {
-  return {
-    dynamic: true,
-    encoded: concat([
-      padHex(numberToHex(value.length, { size: 32 })),
-      padHex(stringToHex(value), { dir: "right" })
-    ])
-  };
-}
-function encodeTuple(value, { param }) {
-  let dynamic = false;
-  let preparedParams = [];
-  for (let i = 0; i < param.components.length; i++) {
-    const param_ = param.components[i];
-    const index = Array.isArray(value) ? i : param_.name;
-    const preparedParam = prepareParam({
-      param: param_,
-      value: value[index]
-    });
-    preparedParams.push(preparedParam);
-    dynamic = preparedParam.dynamic;
-  }
-  return {
-    dynamic,
-    encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
-  };
-}
-function getArrayComponents(type) {
-  const matches = type.match(/^(.*)\[(\d+)?\]$/);
-  return matches ? [matches[2] ? Number(matches[2]) : null, matches[1]] : void 0;
-}
-
-// src/utils/abi/decodeAbi.ts
-function decodeAbi({
-  data,
-  params
-}) {
-  if (size(data) % 32 !== 0)
-    throw new AbiDecodingDataSizeInvalidError(size(data));
-  return decodeParams({
-    data,
-    params
-  });
-}
-function decodeParams({
-  data,
-  params
-}) {
-  let decodedValues = [];
-  let position = 0;
-  for (let i = 0; i < params.length; i++) {
-    const param = params[i];
-    const { consumed, value } = decodeParam({ data, param, position });
-    decodedValues.push(value);
-    position += consumed;
-  }
-  return decodedValues;
-}
-function decodeParam({
-  data,
-  param,
-  position
-}) {
-  const arrayComponents = getArrayComponents(param.type);
-  if (arrayComponents) {
-    const [length, type] = arrayComponents;
-    return decodeArray(data, {
-      length,
-      param: { ...param, type },
-      position
-    });
-  }
-  if (param.type === "tuple") {
-    return decodeTuple(data, { param, position });
-  }
-  if (param.type === "string") {
-    return decodeString(data, { position });
-  }
-  if (param.type.startsWith("bytes")) {
-    return decodeBytes2(data, { param, position });
-  }
-  let value = slice(data, position, position + 32);
-  if (param.type.startsWith("uint") || param.type.startsWith("int")) {
-    return decodeNumber(value, { param });
-  }
-  if (param.type === "address") {
-    return decodeAddress(value);
-  }
-  if (param.type === "bool") {
-    return decodeBool(value);
-  }
-  throw new InvalidAbiDecodingTypeError(param.type);
-}
-function decodeAddress(value) {
-  return { consumed: 32, value: checksumAddress(trim(value)) };
-}
-function decodeArray(data, {
-  param,
-  length,
-  position
-}) {
-  if (!length) {
-    const offset = hexToNumber(slice(data, position, position + 32));
-    const length2 = hexToNumber(slice(data, offset, offset + 32));
-    let consumed2 = 0;
-    let value2 = [];
-    for (let i = 0; i < length2; ++i) {
-      const decodedChild = decodeParam({
-        data: slice(data, offset + 32),
-        param,
-        position: consumed2
-      });
-      consumed2 += decodedChild.consumed;
-      value2.push(decodedChild.value);
-    }
-    return { value: value2, consumed: 32 };
-  }
-  if (hasDynamicChild(param)) {
-    const arrayComponents = getArrayComponents(param.type);
-    const dynamicChild = !arrayComponents?.[0];
-    let consumed2 = 0;
-    let value2 = [];
-    for (let i = 0; i < length; ++i) {
-      const offset = hexToNumber(slice(data, position, position + 32));
-      const decodedChild = decodeParam({
-        data: slice(data, offset),
-        param,
-        position: dynamicChild ? consumed2 : i * 32
-      });
-      consumed2 += decodedChild.consumed;
-      value2.push(decodedChild.value);
-    }
-    return { value: value2, consumed: consumed2 };
-  }
-  let consumed = 0;
-  let value = [];
-  for (let i = 0; i < length; ++i) {
-    const decodedChild = decodeParam({
-      data,
-      param,
-      position: position + consumed
-    });
-    consumed += decodedChild.consumed;
-    value.push(decodedChild.value);
-  }
-  return { value, consumed };
-}
-function decodeBool(value) {
-  return { consumed: 32, value: hexToBool(value) };
-}
-function decodeBytes2(data, { param, position }) {
-  const [_, size2] = param.type.split("bytes");
-  if (!size2) {
-    const offset = hexToNumber(slice(data, position, position + 32));
-    const length = hexToNumber(slice(data, offset, offset + 32));
-    const value2 = slice(data, offset + 32, offset + 32 + length);
-    return { consumed: 32, value: value2 };
-  }
-  const value = slice(data, position, position + parseInt(size2));
-  return { consumed: 32, value };
-}
-function decodeNumber(value, { param }) {
-  const signed = param.type.startsWith("int");
-  const size2 = parseInt(param.type.split("int")[1] || "256");
-  return {
-    consumed: 32,
-    value: size2 > 48 ? hexToBigInt(value, { signed }) : hexToNumber(value, { signed })
-  };
-}
-function decodeString(data, { position }) {
-  const offset = hexToNumber(slice(data, position, position + 32));
-  const length = hexToNumber(slice(data, offset, offset + 32));
-  const value = hexToString(
-    trim(slice(data, offset + 32, offset + 32 + length))
-  );
-  return { consumed: 32, value };
-}
-function decodeTuple(data, { param, position }) {
-  const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
-  let value = hasUnnamedChild ? [] : {};
-  let consumed = 0;
-  if (hasDynamicChild(param)) {
-    const offset = hexToNumber(slice(data, position, position + 32));
-    for (let i = 0; i < param.components.length; ++i) {
-      const component = param.components[i];
-      const decodedChild = decodeParam({
-        data: slice(data, offset),
-        param: component,
-        position: consumed
-      });
-      consumed += decodedChild.consumed;
-      value[hasUnnamedChild ? i : component?.name] = decodedChild.value;
-    }
-    return { consumed: 32, value };
-  }
-  for (let i = 0; i < param.components.length; ++i) {
-    const component = param.components[i];
-    const decodedChild = decodeParam({
-      data,
-      param: component,
-      position: position + consumed
-    });
-    consumed += decodedChild.consumed;
-    value[hasUnnamedChild ? i : component?.name] = decodedChild.value;
-  }
-  return { consumed, value };
-}
-function hasDynamicChild(param) {
-  const { type } = param;
-  if (type === "string")
-    return true;
-  if (type === "bytes")
-    return true;
-  if (type.endsWith("[]"))
-    return true;
-  if (type === "tuple")
-    return param.components?.some(hasDynamicChild);
-  const arrayComponents = getArrayComponents(param.type);
-  if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
-    return true;
-  return false;
-}
-
-// src/utils/abi/getDefinition.ts
-function getDefinition(description) {
-  if (description.type !== "function" && description.type !== "event" && description.type !== "error")
-    throw new InvalidDefinitionTypeError(description.type);
-  return `${description.name}(${getParams(description.inputs)})`;
-}
-function getParams(params) {
-  if (!params)
-    return "";
-  return params.map(getParam).join(",");
-}
-function getParam(param) {
-  if (param.type.startsWith("tuple")) {
-    return `(${getParams(
-      param.components
-    )})${param.type.slice("tuple".length)}`;
-  }
-  return param.type;
-}
-
-// src/utils/abi/decodeErrorResult.ts
-function decodeErrorResult({ abi, data }) {
-  const signature = slice(data, 0, 4);
-  const description = abi.find(
-    (x) => signature === getFunctionSignature(getDefinition(x))
-  );
-  if (!description)
-    throw new AbiErrorSignatureNotFoundError(signature);
-  return {
-    errorName: description.name,
-    args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbi({ data: slice(data, 4), params: description.inputs }) : void 0
-  };
-}
-
-// src/utils/abi/decodeFunctionData.ts
-function decodeFunctionData({ abi, data }) {
-  const signature = slice(data, 0, 4);
-  const description = abi.find(
-    (x) => signature === getFunctionSignature(getDefinition(x))
-  );
-  if (!description)
-    throw new AbiFunctionSignatureNotFoundError(signature);
-  return {
-    functionName: description.name,
-    args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbi({ data: slice(data, 4), params: description.inputs }) : void 0
-  };
-}
-
-// src/utils/abi/decodeFunctionResult.ts
-function decodeFunctionResult({
-  abi,
-  functionName,
-  data
-}) {
-  const description = abi.find((x) => "name" in x && x.name === functionName);
-  if (!description)
-    throw new AbiFunctionNotFoundError(functionName);
-  if (!("outputs" in description))
-    throw new AbiFunctionOutputsNotFoundError(functionName);
-  const values = decodeAbi({ data, params: description.outputs });
-  return values.length > 1 ? values : values.length === 1 ? values[0] : void 0;
-}
-
-// src/utils/abi/encodeDeployData.ts
-function encodeDeployData({
-  abi,
-  args,
-  bytecode
-}) {
-  if (!args || args.length === 0)
-    return bytecode;
-  const description = abi.find((x) => "type" in x && x.type === "constructor");
-  if (!description)
-    throw new AbiConstructorNotFoundError();
-  if (!("inputs" in description))
-    throw new AbiConstructorParamsNotFoundError();
-  if (!description.inputs || description.inputs.length === 0)
-    throw new AbiConstructorParamsNotFoundError();
-  const data = encodeAbi({
-    params: description.inputs,
-    values: args
-  });
-  return concatHex([bytecode, data]);
-}
-
-// src/utils/abi/encodeErrorResult.ts
-function encodeErrorResult({
-  abi,
-  errorName,
-  args
-}) {
-  const description = abi.find((x) => "name" in x && x.name === errorName);
-  if (!description)
-    throw new AbiErrorNotFoundError(errorName);
-  const definition = getDefinition(description);
-  const signature = getFunctionSignature(definition);
-  let data = "0x";
-  if (args && args.length > 0) {
-    if (!("inputs" in description && description.inputs))
-      throw new AbiErrorInputsNotFoundError(errorName);
-    data = encodeAbi({ params: description.inputs, values: args });
-  }
-  return concatHex([signature, data]);
-}
-
-// src/utils/abi/encodeEventTopics.ts
-function encodeEventTopics({
-  abi,
-  eventName,
-  args
-}) {
-  const description = abi.find((x) => "name" in x && x.name === eventName);
-  if (!description)
-    throw new AbiEventNotFoundError(eventName);
-  const definition = getDefinition(description);
-  const signature = getEventSignature(definition);
-  let topics = [];
-  if (args && "inputs" in description) {
-    const args_ = Array.isArray(args) ? args : description.inputs?.map((x) => args[x.name]) ?? [];
-    topics = description.inputs?.filter((param) => "indexed" in param && param.indexed).map(
-      (param, i) => Array.isArray(args_[i]) ? args_[i].map(
-        (_, j) => encodeArg({ param, value: args_[i][j] })
-      ) : args_[i] ? encodeArg({ param, value: args_[i] }) : null
-    ) ?? [];
-  }
-  return [signature, ...topics];
-}
-function encodeArg({
-  param,
-  value
-}) {
-  if (param.type === "string" || param.type === "bytes")
-    return keccak256(encodeBytes(value));
-  if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
-    throw new FilterTypeNotSupportedError(param.type);
-  return encodeAbi({ params: [param], values: [value] });
-}
-
-// src/utils/abi/encodeFunctionData.ts
-function encodeFunctionData({
-  abi,
-  args,
-  functionName
-}) {
-  const description = abi.find((x) => "name" in x && x.name === functionName);
-  if (!description)
-    throw new AbiFunctionNotFoundError(functionName);
-  const definition = getDefinition(description);
-  const signature = getFunctionSignature(definition);
-  const data = "inputs" in description && description.inputs ? encodeAbi({
-    params: description.inputs,
-    values: args ?? []
-  }) : void 0;
-  return concatHex([signature, data ?? "0x"]);
-}
-
-// src/utils/abi/encodeFunctionResult.ts
-function encodeFunctionResult({
-  abi,
-  functionName,
-  result
-}) {
-  const description = abi.find((x) => "name" in x && x.name === functionName);
-  if (!description)
-    throw new AbiFunctionNotFoundError(functionName);
-  if (!("outputs" in description))
-    throw new AbiFunctionOutputsNotFoundError(functionName);
-  let values = Array.isArray(result) ? result : [result];
-  if (description.outputs.length === 0 && !values[0])
-    values = [];
-  return encodeAbi({ params: description.outputs, values });
-}
-
-// 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/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 {
-  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,
-  encodeAbi,
-  decodeAbi,
-  decodeErrorResult,
-  decodeFunctionData,
-  decodeFunctionResult,
-  encodeDeployData,
-  encodeErrorResult,
-  encodeEventTopics,
-  encodeFunctionData,
-  encodeFunctionResult,
-  etherUnits,
-  gweiUnits,
-  weiUnits,
-  transactionType,
-  formatTransaction,
-  formatBlock,
-  formatFeeHistory,
-  format3 as format,
-  formatLog,
-  formatTransactionReceipt,
-  formatTransactionRequest,
-  formatUnit,
-  formatEther,
-  formatGwei,
-  parseUnit,
-  parseEther,
-  parseGwei
-};