essential-eth 0.11.2 → 1.0.0

package/dist/index.js

@@ -1,354 +1,8 @@
-// src/classes/utils/encode-decode-transaction.ts
-import { Keccak as Keccak2 } from "sha3";
-
-// src/shared/tiny-big/tiny-big.ts
-import Big from "big.js";
-
-// src/classes/utils/hex-to-decimal.ts
-function hexToDecimal(hex) {
-  return BigInt(hex).toString();
-}
-
-// src/shared/tiny-big/helpers.ts
-function stripTrailingZeroes(numberString) {
-  const isNegative = numberString.startsWith("-");
-  numberString = numberString.replace("-", "");
-  numberString = numberString.replace(
-    /\.0*$/g,
-    ""
-  );
-  numberString = numberString.replace(/^0+/, "");
-  if (numberString.includes(".")) {
-    numberString = numberString.replace(/0+$/, "");
-  }
-  if (numberString.startsWith(".")) {
-    numberString = `0${numberString}`;
-  }
-  return `${isNegative ? "-" : ""}${numberString}`;
-}
-function scientificStrToDecimalStr(scientificString) {
-  if (!scientificString.match(
-    /e/i
-    /* lowercase and uppercase E */
-  )) {
-    return stripTrailingZeroes(scientificString);
-  }
-  let [base, power] = scientificString.split(
-    /e/i
-  );
-  const isNegative = Number(base) < 0;
-  base = base.replace("-", "");
-  base = stripTrailingZeroes(base);
-  const [wholeNumber, fraction = ""] = base.split(".");
-  if (Number(power) === 0) {
-    return `${isNegative ? "-" : ""}${stripTrailingZeroes(base)}`;
-  } else {
-    const includesDecimal = base.includes(".");
-    if (!includesDecimal) {
-      base = `${base}.`;
-    }
-    base = base.replace(".", "");
-    const baseLength = base.length;
-    let splitPaddedNumber;
-    if (Number(power) < 0) {
-      if (wholeNumber.length < Math.abs(Number(power))) {
-        base = base.padStart(
-          baseLength + Math.abs(Number(power)) - wholeNumber.length,
-          "0"
-        );
-      }
-      splitPaddedNumber = base.split("");
-      if (wholeNumber.length < Math.abs(Number(power))) {
-        splitPaddedNumber = [".", ...splitPaddedNumber];
-      } else {
-        splitPaddedNumber.splice(
-          splitPaddedNumber.length - Math.abs(Number(power)),
-          0,
-          "."
-        );
-      }
-    } else {
-      if (fraction.length < Math.abs(Number(power))) {
-        base = base.padEnd(
-          baseLength + Math.abs(Number(power)) - fraction.length,
-          "0"
-        );
-      }
-      splitPaddedNumber = base.split("");
-      if (fraction.length > Math.abs(Number(power))) {
-        splitPaddedNumber.splice(
-          splitPaddedNumber.length - Math.abs(Number(power)),
-          0,
-          "."
-        );
-      }
-    }
-    const toReturn = stripTrailingZeroes(splitPaddedNumber.join(""));
-    return `${isNegative ? "-" : ""}${toReturn}`;
-  }
-}
-
-// src/shared/tiny-big/tiny-big.ts
-var TinyBig = class extends Big {
-  constructor(value) {
-    if (typeof value === "string" && value.startsWith("0x")) {
-      value = hexToDecimal(value);
-    }
-    super(value);
-  }
-  /**
-   * Used anytime you're passing in "value" to ethers or web3
-   * For now, TypeScript will complain that `TinyBig` is not a `BigNumberish`. You can // @ts-ignore or call this
-   *
-   * @returns the TinyBig represented as a hex string
-   * @example
-   * ```javascript
-   * tinyBig(293).toHexString();
-   * // '0x125'
-   * ```
-   * @example
-   * ```javascript
-   * tinyBig(681365874).toHexString();
-   * // '0x289cd172'
-   */
-  toHexString() {
-    return `0x${BigInt(this.toString()).toString(16)}`;
-  }
-  toNumber() {
-    return Number(scientificStrToDecimalStr(super.toString()));
-  }
-  toString() {
-    if (this.toNumber() === 0) {
-      return "0";
-    }
-    return scientificStrToDecimalStr(super.toString());
-  }
-  /**
-   * Eithers pads or shortens a string to a specified length
-   *
-   * @param str the string to pad or chop
-   * @param padChar the character to pad the string with
-   * @param length the desired length of the given string
-   * @returns a string of the desired length, either padded with the specified padChar or with the beginning of the string chopped off
-   * @example
-   * ```javascript
-   * padAndChop('essential-eth', 'a', 8);
-   * // 'tial-eth'
-   * ```
-   * @example
-   * ```javascript
-   * padAndChop('essential-eth', 'A', 20);
-   * // 'AAAAAAAessential-eth'
-   * ```
-   */
-  padAndChop = (str, padChar, length) => {
-    return (Array(length).fill(padChar).join("") + str).slice(length * -1);
-  };
-  toTwos(bitCount) {
-    let binaryStr;
-    if (this.gte(0)) {
-      const twosComp = this.toNumber().toString(2);
-      binaryStr = this.padAndChop(twosComp, "0", bitCount || twosComp.length);
-    } else {
-      binaryStr = this.plus(Math.pow(2, bitCount)).toNumber().toString(2);
-      if (Number(binaryStr) < 0) {
-        throw new Error("Cannot calculate twos complement");
-      }
-    }
-    const binary = `0b${binaryStr}`;
-    const decimal = Number(binary);
-    return tinyBig(decimal);
-  }
-};
-function tinyBig(value) {
-  return new TinyBig(value);
-}
-
-// src/utils/to-checksum-address.ts
-import { Keccak } from "sha3";
-
-// src/shared/validate-type.ts
-var validateType = (value, allowedTypes) => {
-  if (!allowedTypes.includes(typeof value)) {
-    throw new Error(
-      `${allowedTypes.join(" or ")} required. Received ${typeof value}`
-    );
-  }
-};
-
-// src/utils/to-checksum-address.ts
-function toChecksumAddress(address) {
-  validateType(address, ["string"]);
-  if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
-    throw new Error(`Invalid Ethereum address "${address}"`);
-  }
-  const _address = address.toLowerCase().replace(/^0x/i, "");
-  const keccak = new Keccak(256);
-  const addressHash = keccak.update(_address).digest("hex").replace(/^0x/i, "");
-  let checksumAddress = "0x";
-  for (let i = 0; i < _address.length; i++) {
-    if (parseInt(addressHash[i], 16) > 7) {
-      checksumAddress += _address[i].toUpperCase();
-    } else {
-      checksumAddress += _address[i];
-    }
-  }
-  if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) && checksumAddress !== address) {
-    throw new Error(`Invalid Checksum address for "${address}"`);
-  }
-  return checksumAddress;
-}
-
-// src/classes/utils/encode-decode-transaction.ts
-var hexFalse = "0".repeat(64);
-var hexTrue = "0".repeat(63) + "1";
-function hexToUtf8(hex) {
-  let str = "";
-  let i = 0;
-  const l = hex.length;
-  if (hex.substring(0, 2) === "0x") {
-    i = 2;
-  }
-  for (; i < l; i += 2) {
-    const code = parseInt(hex.substr(i, 2), 16);
-    if (code === 0) continue;
-    str += String.fromCharCode(code);
-  }
-  try {
-    return decodeURIComponent(escape(str));
-  } catch (e) {
-    return str;
-  }
-}
-function expandType(type) {
-  if (type === "uint[]") {
-    return "uint256[]";
-  }
-  if (type === "int[]") {
-    return "int256[]";
-  }
-  return type;
-}
-function encodeData(jsonABIArgument, args) {
-  const hash = new Keccak2(256);
-  const functionString = `${jsonABIArgument.name}(${jsonABIArgument.inputs.map(
-    (input) => expandType(input.type)
-  )})`;
-  const functionHash = hash.update(functionString).digest("hex");
-  const jsonABIInputsLength = jsonABIArgument.inputs.length;
-  let shouldValidateInputLength = true;
-  if (jsonABIArgument.inputs.find((input) => input.type.includes("["))) {
-    shouldValidateInputLength = false;
-  }
-  if (shouldValidateInputLength && args.length !== jsonABIInputsLength) {
-    throw new Error(
-      `args inputs  of "${args.length}" does not match expected length of "${jsonABIArgument.inputs.length}"`
-    );
-  }
-  const argsWithTypes = (jsonABIArgument.inputs || []).reduce(
-    (acc, input, i) => {
-      if (input.type.includes("[")) {
-        const basicType = /([^[]*)\[.*$/g.exec(input.type)?.[1];
-        args.forEach((arg) => {
-          acc = acc.concat([[arg, basicType]]);
-        });
-        return acc;
-      } else {
-        return acc.concat([[args[i], input.type]]);
-      }
-    },
-    []
-  );
-  const encodedArgs = argsWithTypes.map(([arg, inputType]) => {
-    let rawArg = arg;
-    switch (inputType) {
-      case "bool":
-        return arg ? hexTrue : hexFalse;
-      case "address":
-        rawArg = arg.replace(/^0x/g, "").toLowerCase();
-        break;
-      default:
-        if (inputType.startsWith("bytes")) {
-          if (Array.isArray(arg)) {
-            throw new Error(
-              `essential-eth does not yet support "${inputType}[]" inputs. Make a PR today!"`
-            );
-          }
-          const argEncoded2 = BigInt(arg).toString(16);
-          const paddedEncodedArg2 = argEncoded2.padStart(64, "0");
-          return paddedEncodedArg2;
-        } else if (inputType === "uint256") {
-          const argEncoded2 = BigInt(arg).toString(16);
-          const paddedEncodedArg2 = argEncoded2.padStart(64, "0");
-          return paddedEncodedArg2;
-        } else if (inputType.startsWith("uint")) {
-          break;
-        } else {
-          throw new Error(
-            `essential-eth does not yet support "${inputType}" inputs. Make a PR today!"`
-          );
-        }
-    }
-    const argEncoded = rawArg.toString(16);
-    const paddedEncodedArg = argEncoded.padStart(64, "0");
-    return paddedEncodedArg;
-  });
-  const functionEncoded = functionHash.slice(0, 8);
-  const data = `0x${functionEncoded}${encodedArgs.join("")}`;
-  return data;
-}
-function decodeRPCResponse(jsonABIArgument, nodeResponse) {
-  const rawOutputs = jsonABIArgument.outputs || [];
-  const slicedResponse = nodeResponse.slice(2);
-  if (rawOutputs.length === 1 && rawOutputs[0].type === "string") {
-    const [hexOffset, responseData] = [
-      slicedResponse.slice(0, 64),
-      slicedResponse.slice(64)
-    ];
-    const decimalOffset = Number(hexToDecimal(`0x${hexOffset}`));
-    const hexLength = responseData.slice(0, decimalOffset * 2);
-    const decimalLength = Number(hexToDecimal(`0x${hexLength}`));
-    const hexToDecode = responseData.slice(
-      decimalOffset * 2,
-      decimalOffset * 2 + decimalLength * 2
-    );
-    return hexToUtf8(hexToDecode);
-  }
-  const encodedOutputs = slicedResponse.match(/.{1,64}/g) || [];
-  if (rawOutputs.length === 1 && rawOutputs[0].type === "address[]") {
-    const unformattedAddresses = encodedOutputs.slice(2);
-    return unformattedAddresses.map((unformattedAddress) => {
-      return toChecksumAddress(`0x${unformattedAddress.slice(24)}`);
-    });
-  }
-  if (rawOutputs?.length === 1 && rawOutputs[0].type === "uint256[]") {
-    const outputs2 = encodedOutputs.slice(2);
-    return outputs2.map((output) => {
-      return tinyBig(hexToDecimal(`0x${output}`));
-    });
-  }
-  const outputs = encodedOutputs.map((output, i) => {
-    const outputType = rawOutputs[i].type;
-    switch (outputType) {
-      case "bool":
-        return output === hexTrue;
-      case "address":
-        return toChecksumAddress(`0x${output.slice(24)}`);
-      case "uint256":
-      case "uint120":
-        return tinyBig(hexToDecimal(`0x${output}`));
-      case "bytes32":
-        return `0x${output}`;
-      case "uint8":
-        return Number(hexToDecimal(`0x${output}`));
-      default:
-        throw new Error(
-          `essential-eth does not yet support "${outputType}" outputs. Make a PR today!"`
-        );
-    }
-  });
-  return outputs.length === 1 ? outputs[0] : outputs;
-}
+import { keccak256, toUtf8Bytes, logger, encodeData, decodeRPCResponse, arrayify, hexlify, toChecksumAddress, hexToDecimal } from './chunk-CLIQ4S3P.js';
+export { arrayify, computeAddress, computePublicKey, concat, hashMessage, hexConcat, hexDataLength, hexDataSlice, hexStripZeros, hexValue, hexZeroPad, hexlify, isAddress, isBytes, isBytesLike, isHexString, keccak256, pack, solidityKeccak256, splitSignature, stripZeros, toChecksumAddress, toUtf8Bytes, zeroPad } from './chunk-CLIQ4S3P.js';
+import { formatFixed, toBigInt, parseFixed } from './chunk-GFWRB7PT.js';
+export { etherToGwei, etherToWei, gweiToEther, weiToEther } from './chunk-GFWRB7PT.js';
+import unfetch from 'isomorphic-unfetch';
 
 // src/classes/Contract.ts
 function estimateGas(txnData) {
@@ -423,7 +77,8 @@ function cleanTransaction(transaction) {
     ...transaction
   };
   Object.keys(transaction).forEach((key) => {
-    if (!transaction[key]) return;
+    if (!transaction[key])
+      return;
     switch (key) {
       case "blockNumber":
       case "chainId":
@@ -444,7 +99,7 @@ function cleanTransaction(transaction) {
       case "maxFeePerGas":
       case "maxPriorityFeePerGas":
       case "nonce":
-        cleanedTransaction[key] = tinyBig(hexToDecimal(transaction[key]));
+        cleanedTransaction[key] = BigInt(hexToDecimal(transaction[key]));
         break;
     }
   });
@@ -455,7 +110,8 @@ function cleanTransaction(transaction) {
 function cleanBlock(block, returnTransactionObjects) {
   const cleanedBlock = { ...block };
   Object.keys(block).forEach((key) => {
-    if (!block[key]) return;
+    if (!block[key])
+      return;
     switch (key) {
       case "difficulty":
       case "totalDifficulty":
@@ -464,7 +120,7 @@ function cleanBlock(block, returnTransactionObjects) {
       case "size":
       case "timestamp":
       case "baseFeePerGas":
-        cleanedBlock[key] = tinyBig(hexToDecimal(block[key]));
+        cleanedBlock[key] = BigInt(hexToDecimal(block[key]));
         break;
       case "number":
         cleanedBlock[key] = Number(hexToDecimal(block[key]));
@@ -517,7 +173,8 @@ function cleanTransactionReceipt(transactionReceipt) {
     ...cleanedTransaction
   };
   Object.keys(transactionReceipt).forEach((key) => {
-    if (!transactionReceipt[key]) return;
+    if (!transactionReceipt[key])
+      return;
     switch (key) {
       case "status":
         cleanedTransactionReceipt[key] = Number(
@@ -534,7 +191,7 @@ function cleanTransactionReceipt(transactionReceipt) {
       case "cumulativeGasUsed":
       case "effectiveGasPrice":
       case "gasUsed":
-        cleanedTransactionReceipt[key] = tinyBig(
+        cleanedTransactionReceipt[key] = BigInt(
           hexToDecimal(transactionReceipt[key])
         );
         break;
@@ -547,9 +204,6 @@ function cleanTransactionReceipt(transactionReceipt) {
   cleanedTransactionReceipt.byzantium = cleanedTransactionReceipt.blockNumber >= 437e4;
   return cleanedTransactionReceipt;
 }
-
-// src/classes/utils/fetchers.ts
-import unfetch from "isomorphic-unfetch";
 function buildFetchInit(body) {
   return {
     method: "POST",
@@ -587,288 +241,6 @@ function buildRPCPostBody(method, params) {
   };
 }
 
-// src/classes/utils/prepare-transaction.ts
-import Big2 from "big.js";
-
-// src/logger/package-version.ts
-var version = "0.11.2";
-
-// src/logger/logger.ts
-var Logger = class {
-  packageVersion;
-  constructor() {
-    this.packageVersion = version;
-  }
-  throwError(message, args) {
-    const argsLength = Object.keys(args).length;
-    throw new Error(
-      `${message} (${Object.entries(args).map(
-        ([key, value], index) => `${key}=${value}${index < argsLength - 1 && ", "}`
-      )}, version=essential-eth@${this.packageVersion})`
-    );
-  }
-  throwArgumentError(message, arg, value) {
-    throw new Error(
-      `${message} (argument="${arg}" value=${value}, version=essential-eth@${this.packageVersion})`
-    );
-  }
-  checkSafeUint53(value, message = "value not safe") {
-    if (typeof value !== "number") {
-      return;
-    }
-    if (value < 0 || value >= 9007199254740991) {
-      this.throwError(message, {
-        operation: "checkSafeInteger",
-        fault: "out-of-safe-range",
-        value
-      });
-    }
-    if (value % 1) {
-      this.throwError(message, {
-        operation: "checkSafeInteger",
-        fault: "non-integer",
-        value
-      });
-    }
-  }
-};
-var logger = new Logger();
-
-// src/utils/bytes.ts
-function isHexable(value) {
-  return !!value.toHexString;
-}
-function isBytesLike(value) {
-  return isHexString(value) && !(value.length % 2) || isBytes(value);
-}
-function isInteger(value) {
-  return typeof value === "number" && value == value && value % 1 === 0;
-}
-function isBytes(value) {
-  if (value == null) {
-    return false;
-  }
-  if (value.constructor === Uint8Array) {
-    return true;
-  }
-  if (typeof value === "string") {
-    return false;
-  }
-  if (!isInteger(value.length) || value.length < 0) {
-    return false;
-  }
-  for (let i = 0; i < value.length; i++) {
-    const v = value[i];
-    if (!isInteger(v) || v < 0 || v >= 256) {
-      return false;
-    }
-  }
-  return true;
-}
-function arrayify(value, options) {
-  if (!options) {
-    options = {};
-  }
-  if (typeof value === "number") {
-    logger.checkSafeUint53(value, "invalid arrayify value");
-    const result = [];
-    while (value) {
-      result.unshift(value & 255);
-      value = parseInt(String(value / 256));
-    }
-    if (result.length === 0) {
-      result.push(0);
-    }
-    return new Uint8Array(result);
-  }
-  if (options.allowMissingPrefix && typeof value === "string" && value.substring(0, 2) !== "0x") {
-    value = "0x" + value;
-  }
-  if (isHexable(value)) {
-    value = value.toHexString();
-  }
-  if (isHexString(value)) {
-    let hex = value.substring(2);
-    if (hex.length % 2) {
-      if (options.hexPad === "left") {
-        hex = "0" + hex;
-      } else if (options.hexPad === "right") {
-        hex += "0";
-      } else {
-        logger.throwArgumentError("hex data is odd-length", "value", value);
-      }
-    }
-    const result = [];
-    for (let i = 0; i < hex.length; i += 2) {
-      result.push(parseInt(hex.substring(i, i + 2), 16));
-    }
-    return new Uint8Array(result);
-  }
-  if (isBytes(value)) {
-    return new Uint8Array(value);
-  }
-  return logger.throwArgumentError("invalid arrayify value", "value", value);
-}
-function concat(arrayOfBytesLike) {
-  const objects = arrayOfBytesLike.map((item) => arrayify(item));
-  const length = objects.reduce((accum, item) => accum + item.length, 0);
-  const result = new Uint8Array(length);
-  objects.reduce((offset, object) => {
-    result.set(object, offset);
-    return offset + object.length;
-  }, 0);
-  return result;
-}
-function stripZeros(value) {
-  let result = arrayify(value);
-  if (result.length === 0) {
-    return result;
-  }
-  let start = 0;
-  while (start < result.length && result[start] === 0) {
-    start++;
-  }
-  if (start) {
-    result = result.slice(start);
-  }
-  return result;
-}
-function zeroPad(value, length) {
-  value = arrayify(value);
-  if (value.length > length) {
-    logger.throwArgumentError("value out of range", "value", value);
-  }
-  const result = new Uint8Array(length);
-  result.set(value, length - value.length);
-  return result;
-}
-function isHexString(value, length) {
-  if (typeof value !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
-    return false;
-  }
-  if (length && value.length !== 2 + 2 * length) {
-    return false;
-  }
-  return true;
-}
-var HexCharacters = "0123456789abcdef";
-function hexlify(value, options) {
-  if (!options) {
-    options = {};
-  }
-  if (typeof value === "number") {
-    logger.checkSafeUint53(value, "invalid hexlify value");
-    let hex = "";
-    while (value) {
-      hex = HexCharacters[value & 15] + hex;
-      value = Math.floor(value / 16);
-    }
-    if (hex.length) {
-      if (hex.length % 2) {
-        hex = "0" + hex;
-      }
-      return "0x" + hex;
-    }
-    return "0x00";
-  }
-  if (typeof value === "bigint") {
-    value = value.toString(16);
-    if (value.length % 2) {
-      return "0x0" + value;
-    }
-    return "0x" + value;
-  }
-  if (options.allowMissingPrefix && typeof value === "string" && value.substring(0, 2) !== "0x") {
-    value = "0x" + value;
-  }
-  if (isHexable(value)) {
-    return value.toHexString();
-  }
-  if (isHexString(value)) {
-    if (value.length % 2) {
-      if (options.hexPad === "left") {
-        value = "0x0" + value.substring(2);
-      } else if (options.hexPad === "right") {
-        value += "0";
-      } else {
-        logger.throwArgumentError("hex data is odd-length", "value", value);
-      }
-    }
-    return value.toLowerCase();
-  }
-  if (isBytes(value)) {
-    let result = "0x";
-    for (let i = 0; i < value.length; i++) {
-      const v = value[i];
-      result += HexCharacters[(v & 240) >> 4] + HexCharacters[v & 15];
-    }
-    return result;
-  }
-  return logger.throwArgumentError("invalid hexlify value", "value", value);
-}
-function hexDataLength(data) {
-  if (typeof data !== "string") {
-    data = hexlify(data);
-  } else if (!isHexString(data) || data.length % 2) {
-    return null;
-  }
-  return (data.length - 2) / 2;
-}
-function hexDataSlice(data, offset, endOffset) {
-  if (typeof data !== "string") {
-    data = hexlify(data);
-  } else if (!isHexString(data) || data.length % 2) {
-    logger.throwArgumentError("invalid hexData", "value", data);
-  }
-  offset = 2 + 2 * offset;
-  if (endOffset != null) {
-    return "0x" + data.substring(offset, 2 + 2 * endOffset);
-  }
-  return "0x" + data.substring(offset);
-}
-function hexConcat(items) {
-  let result = "0x";
-  items.forEach((item) => {
-    result += hexlify(item).substring(2);
-  });
-  return result;
-}
-function hexValue(value) {
-  const trimmed = hexStripZeros(hexlify(value, { hexPad: "left" }));
-  if (trimmed === "0x") {
-    return "0x0";
-  }
-  return trimmed;
-}
-function hexStripZeros(value) {
-  if (typeof value !== "string") {
-    value = hexlify(value);
-  }
-  if (!isHexString(value)) {
-    logger.throwArgumentError("invalid hex string", "value", value);
-  }
-  value = value.substring(2);
-  let offset = 0;
-  while (offset < value.length && value[offset] === "0") {
-    offset++;
-  }
-  return "0x" + value.substring(offset);
-}
-function hexZeroPad(value, length) {
-  if (typeof value !== "string") {
-    value = hexlify(value);
-  } else if (!isHexString(value)) {
-    logger.throwArgumentError("invalid hex string", "value", value);
-  }
-  if (value.length > 2 * length + 2) {
-    logger.throwError("value out of range", { value, length });
-  }
-  while (value.length < 2 * length + 2) {
-    value = "0x0" + value.substring(2);
-  }
-  return value;
-}
-
 // src/classes/utils/prepare-transaction.ts
 function prepareTransaction(transaction) {
   const preparedTransaction = {
@@ -884,15 +256,13 @@ function prepareTransaction(transaction) {
         case "maxPriorityFeePerGas":
         case "value": {
           const value = transaction[key];
-          if (value instanceof TinyBig) {
-            preparedTransaction[key] = value.toHexString();
-          } else if (value instanceof Big2) {
-            preparedTransaction[key] = `0x${BigInt(value.toString()).toString(
-              16
-            )}`;
-          } else if (typeof transaction[key] === "number")
-            preparedTransaction[key] = "0x" + transaction[key].toString(16);
-          else preparedTransaction[key] = transaction[key].toString();
+          if (typeof value === "bigint") {
+            preparedTransaction[key] = "0x" + value.toString(16);
+          } else if (typeof value === "number") {
+            preparedTransaction[key] = "0x" + value.toString(16);
+          } else {
+            preparedTransaction[key] = value.toString();
+          }
           break;
         }
         case "data":
@@ -904,6 +274,20 @@ function prepareTransaction(transaction) {
   return preparedTransaction;
 }
 
+// src/utils/namehash.ts
+function namehash(name) {
+  let node = "0x0000000000000000000000000000000000000000000000000000000000000000";
+  if (name === "") {
+    return node;
+  }
+  const labels = name.split(".");
+  for (let i = labels.length - 1; i >= 0; i--) {
+    const labelHash = keccak256(toUtf8Bytes(labels[i]));
+    node = keccak256("0x" + node.slice(2) + labelHash.slice(2));
+  }
+  return node;
+}
+
 // src/providers/utils/chains-info.ts
 var chains_info_default = {
   "1": [
@@ -975,7 +359,7 @@ var chains_info_default = {
 
 // src/providers/BaseProvider.ts
 function prepBlockTag(blockTag) {
-  return typeof blockTag === "number" ? tinyBig(blockTag).toHexString() : blockTag;
+  return typeof blockTag === "number" ? "0x" + blockTag.toString(16) : blockTag;
 }
 var BaseProvider = class {
   /**
@@ -1001,7 +385,6 @@ var BaseProvider = class {
    *
    * * [Identical](/docs/api#isd) to [`ethers.provider.getNetwork`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getNetwork) in ethers.js
    * * [Similar](/docs/api#isd) to [`web3.eth.getChainId`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getchainid) in web3.js, returns more than just the `chainId`
-   *
    * @returns information about the network this provider is currently connected to
    * @example
    * ```javascript
@@ -1032,7 +415,6 @@ var BaseProvider = class {
    *
    * * [Identical](/docs/api#isd) to [`ethers.provider.getBlockNumber`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getBlockNumber) in ethers.js
    * * [Identical](/docs/api#isd) to [`web3.eth.getBlockNumber`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getblocknumber) in web3.js
-   *
    * @returns the number of the most recently mined block
    * @example
    * ```javascript
@@ -1051,7 +433,6 @@ var BaseProvider = class {
    *
    * * [Similar](/docs/api#isd) to [`ethers.provider.getTransaction`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getTransaction) in ethers.js, does not have `wait` method that waits until the transaction has been mined
    * * [Similar](/docs/api#isd) to [`web3.eth.getTransaction`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#gettransaction) in web3.js, some information returned using different types
-   *
    * @param transactionHash the hash of the transaction to get information about
    * @returns information about the specified transaction
    * @example
@@ -1063,20 +444,20 @@ var BaseProvider = class {
    * //   blockNumber: 14578286,
    * //   chainId: 1,
    * //   from: "0xdfD9dE5f6FA60BD70636c0900752E93a6144AEd4",
-   * //   gas: { TinyBig: 112163 },
-   * //   gasPrice: { TinyBig: 48592426858 },
+   * //   gas: 112163n,
+   * //   gasPrice: 48592426858n,
    * //   hash: "0x9014ae6ef92464338355a79e5150e542ff9a83e2323318b21f40d6a3e65b4789",
    * //   input: "0x83259f17000000000000000000000000000000000000000000...",
-   * //   maxFeePerGas: { TinyBig: 67681261618 },
-   * //   maxPriorityFeePerGas: { TinyBig: 1500000000 },
-   * //   nonce: { TinyBig: 129 },
+   * //   maxFeePerGas: 67681261618n,
+   * //   maxPriorityFeePerGas: 1500000000n,
+   * //   nonce: 129n,
    * //   r: "0x59a7c15b12c18cd68d6c440963d959bff3e73831ffc938e75ecad07f7ee43fbc",
    * //   s: "0x1ebaf05f0d9273b16c2a7748b150a79d22533a8cd74552611cbe620fee3dcf1c",
    * //   to: "0x39B72d136ba3e4ceF35F48CD09587ffaB754DD8B",
    * //   transactionIndex: 29,
    * //   type: 2,
    * //   v: 0,
-   * //   value: { TinyBig: 0 },
+   * //   value: 0n,
    * //   confirmations: 298140,
    * // }
    * ```
@@ -1097,7 +478,6 @@ var BaseProvider = class {
    *
    * * [Identical](/docs/api#isd) to [`ethers.provider.getTransactionReceipt`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getTransactionReceipt) in ethers.js
    * * [Similar](/docs/api#isd) to [`web3.eth.getTransactionReceipt`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#gettransactionreceipt) in web3.js, some information returned using different types
-   *
    * @param transactionHash the hash of the transaction to get information about
    * @returns information about the specified transaction that has already been mined
    * @example
@@ -1107,10 +487,10 @@ var BaseProvider = class {
    * //   blockHash: "0x876810a013dbcd140f6fd6048c1dc33abbb901f1f96b394c2fa63aef3cb40b5d",
    * //   blockNumber: 14578286,
    * //   contractAddress: null,
-   * //   cumulativeGasUsed: { TinyBig: 3067973 },
-   * //   effectiveGasPrice: { TinyBig: 48592426858 },
+   * //   cumulativeGasUsed: 3067973n,
+   * //   effectiveGasPrice: 48592426858n,
    * //   from: "0xdfD9dE5f6FA60BD70636c0900752E93a6144AEd4",
-   * //   gasUsed: { TinyBig: 112163 },
+   * //   gasUsed: 112163n,
    * //   logs: [
    * //     {
    * //       address: "0x0eDF9bc41Bbc1354c70e2107F80C42caE7FBBcA8",
@@ -1168,7 +548,6 @@ var BaseProvider = class {
    *
    * * [Identical](/docs/api#isd) to [`ethers.provider.getTransactionCount`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getTransactionCount) in ethers.js
    * * [Identical](/docs/api#isd) to [`web3.eth.getTransactionCount`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#gettransactioncount) in web3.js
-   *
    * @param address the address to count number of sent transactions
    * @param blockTag the block to count transactions up to, inclusive
    * @returns the number of transactions sent by the specified address
@@ -1200,7 +579,6 @@ var BaseProvider = class {
    *
    * * [Similar](/docs/api#isd) to [`ethers.provider.getBlock`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getLogs) in ethers.js, includes some additional information. Can also return block with full transaction objects, similar to [`ethers.providers.getBlockWithTransactions`]
    * * [Identical](/docs/api#isd) to [`web3.eth.getBlock`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getpastlogs) in web3.js
-   *
    * @param timeFrame The number, hash, or text-based description ('latest', 'earliest', or 'pending') of the block to collect information on.
    * @param returnTransactionObjects Whether to also return data about the transactions on the block.
    * @returns A BlockResponse object with information about the specified block
@@ -1208,11 +586,11 @@ var BaseProvider = class {
    * ```javascript
    * await provider.getBlock(14879862);
    * // {
-   * //   baseFeePerGas: { TinyBig: 39095728776 },
-   * //   difficulty: { TinyBig: 14321294455359973 },
+   * //   baseFeePerGas: 39095728776n,
+   * //   difficulty: 14321294455359973n,
    * //   extraData: "0x486976656f6e2073672d6865617679",
-   * //   gasLimit: { TinyBig: 29970620 },
-   * //   gasUsed: { TinyBig: 20951384 },
+   * //   gasLimit: 29970620n,
+   * //   gasUsed: 20951384n,
    * //   hash: "0x563b458ec3c4f87393b53f70bdddc0058497109b784d8cacd9247ddf267049ab",
    * //   logsBloom:
    * //     "0x9f38794fe80b521794df6efad8b0d2e9582f9ec3959a3f9384bda0fa371cfa5fac5af9d515c6bdf1ec325f5b5f7ebdd6a3a9fae17b38a86d4dc4b0971afc68d8086640550f4c156e6f923f4a1bb94fb0bed6cdcc474c5c64bfeff7a4a906f72b9a7b94004ee58efc53d63ac66961acd3a431b2d896cc9fd75f6072960bced45f770587caf130f57504decfcb63c6ca8fbc5bdbd749edd5a99a7375d2b81872289adb775fb3c928259f4be39c6d3f4d5b6217822979bb88c1f1fb62429b1b6d41cf4e3f77f9e1db3f5723108f1e5b1255dd734ad8cdb11e7ea22487c788e67c83777b6f395e504ca59c64f52245ee6de3804cf809e5caa4f0ea6a9aa9eb6ed801",
@@ -1223,10 +601,10 @@ var BaseProvider = class {
    * //   parentHash: "0x95986ae14a71face8d9a6a379edd875b2e8bc73e4de0d9d460e7752bddb0f579",
    * //   receiptsRoot: "0x8e6ba2fd9bee602b653dae6e3132f16538c2c5df24f1df8c000392053f73defa",
    * //   sha3Uncles: "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
-   * //   size: { TinyBig: 134483 },
+   * //   size: 134483n,
    * //   stateRoot: "0xbf2bb67bd1c741f3d00904b8451d7c2cf4e3a2726f5a5884792ede2074747b85",
-   * //   timestamp: { TinyBig: 1654016186 },
-   * //   totalDifficulty: { TinyBig: 50478104614257705213748 },
+   * //   timestamp: 1654016186n,
+   * //   totalDifficulty: 50478104614257705213748n,
    * //   transactions: [
    * //     "0xb3326a9149809603a2c28545e50e4f7d16e194bf5ee9764e0544603854c4a8d2",
    * //     "0x8b42095f8d335404a4896b2817b8e5e3d86a5a87cb434a8eec295d5280a7f48e",
@@ -1257,8 +635,7 @@ var BaseProvider = class {
    * Gives an estimate of the current gas price in wei.
    *
    * * [Similar](/docs/api#isd) to [`ethers.provider.getGasPrice`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getGasPrice) in ethers.js, does not have a parameter specifying what unit you'd like to return. See also [`weiToEther`](/docs/api/modules#weitoether) and [`etherToGwei`](/docs/api/modules#ethertogwei)
-   * * [Identical](/docs/api#isd) to [`web3.eth.getGasPrice`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getgasprice) in web3.js, returns a number (TinyBig) instead of a string
-   *
+   * * [Identical](/docs/api#isd) to [`web3.eth.getGasPrice`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getgasprice) in web3.js, returns a number (bigint) instead of a string
    * @returns an estimate of the current gas price in wei
    * @example
    * ```javascript
@@ -1270,14 +647,13 @@ var BaseProvider = class {
     const hexGasPrice = await this.post(
       buildRPCPostBody("eth_gasPrice", [])
     );
-    return tinyBig(hexToDecimal(hexGasPrice));
+    return BigInt(hexToDecimal(hexGasPrice));
   }
   /**
    * Returns the balance of the account in wei.
    *
    * * [Identical](/docs/api#isd) to [`ethers.provider.getBalance`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getBalance) in ethers.js
-   * * [Identical](/docs/api#isd) to [`web3.eth.getBalance`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getbalance) in web3.js, returns a number (TinyBig) instead of a string
-   *
+   * * [Identical](/docs/api#isd) to [`web3.eth.getBalance`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getbalance) in web3.js, returns a number (bigint) instead of a string
    * @param address the address to check the balance of
    * @param blockTag the block to check the specified address' balance on
    * @returns the balance of the network's native token for the specified address on the specified block
@@ -1292,14 +668,13 @@ var BaseProvider = class {
     const hexBalance = await this.post(
       buildRPCPostBody("eth_getBalance", [address, blockTag])
     );
-    return tinyBig(hexToDecimal(hexBalance));
+    return BigInt(hexToDecimal(hexBalance));
   }
   /**
    * Gets the code of a contract on a specified block.
    *
    * * [Identical](/docs/api#isd) to [`ethers.provider.getCode`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getCode) in ethers.js
    * * [Identical](/docs/api#isd) to [`web3.eth.getCode`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getcode) in web3.js
-   *
    * @param address the contract address to get the contract code from
    * @param blockTag the block height to search for the contract code from. Contract code can change, so this allows for checking a specific block
    * @returns the contract creation code for the specified address at the specified block height
@@ -1322,7 +697,6 @@ var BaseProvider = class {
    *
    * * [Identical](/docs/api#isd) to [`ethers.provider.estimateGas`](https://docs.ethers.io/v5/api/providers/provider/#Provider-estimateGas) in ethers.js
    * * [Identical](/docs/api#isd) to [`web3.eth.estimateGas`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#estimateGas) in web3.js
-   *
    * @param transaction the transaction to check the estimated gas cost for
    * @returns the estimated amount of gas charged for submitting the specified transaction to the blockchain
    * @example
@@ -1333,7 +707,7 @@ var BaseProvider = class {
    *   data: "0xd0e30db0",
    *   value: etherToWei('1.0').toHexString(),
    * });
-   * // { TinyBig: "27938" }
+   * // 27938n
    * ```
    */
   async estimateGas(transaction) {
@@ -1341,7 +715,7 @@ var BaseProvider = class {
     const gasUsed = await this.post(
       buildRPCPostBody("eth_estimateGas", [rpcTransaction])
     );
-    return tinyBig(hexToDecimal(gasUsed));
+    return BigInt(hexToDecimal(gasUsed));
   }
   /**
    * Returns the current recommended FeeData to use in a transaction.
@@ -1349,16 +723,15 @@ var BaseProvider = class {
    * For legacy transactions and networks which do not support EIP-1559, the gasPrice should be used.Returns an estimate of the amount of gas that would be required to submit transaction to the network.
    *
    * * [Identical](/docs/api#isd) to [`ethers.provider.getFeeData`](https://docs.ethers.org/v5/api/providers/provider/#Provider-getFeeData) in ethers.js
-   *
    * @returns an object with gas estimates for the network currently
    * @example
    * ```javascript
    * await provider.getFeeData();
    * // {
-   * //   gasPrice: { TinyBig: "14184772639" },
-   * //   lastBaseFeePerGas: { TinyBig: "14038523098" },
-   * //   maxFeePerGas: { TinyBig: "29577046196" },
-   * //   maxPriorityFeePerGas: { TinyBig: "1500000000" }
+   * //   gasPrice: 14184772639n,
+   * //   lastBaseFeePerGas: 14038523098n,
+   * //   maxFeePerGas: 29577046196n,
+   * //   maxPriorityFeePerGas: 1500000000n
    * // }
    * ```
    */
@@ -1370,10 +743,8 @@ var BaseProvider = class {
     let lastBaseFeePerGas = null, maxFeePerGas = null, maxPriorityFeePerGas = null;
     if (block && block.baseFeePerGas) {
       lastBaseFeePerGas = block.baseFeePerGas;
-      maxPriorityFeePerGas = tinyBig("1500000000");
-      maxFeePerGas = tinyBig(
-        block.baseFeePerGas.mul(2).add(maxPriorityFeePerGas)
-      );
+      maxPriorityFeePerGas = BigInt("1500000000");
+      maxFeePerGas = block.baseFeePerGas * 2n + maxPriorityFeePerGas;
     }
     return { lastBaseFeePerGas, maxFeePerGas, maxPriorityFeePerGas, gasPrice };
   }
@@ -1383,7 +754,6 @@ var BaseProvider = class {
    *
    * * [Identical](/docs/api#isd) to [`ethers.provider.getLogs`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getLogs) in ethers.js
    * * [Identical](/docs/api#isd) to [`web3.eth.getPastLogs`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getpastlogs) in web3.js
-   *
    * @param filter parameters to filter the logs by
    * @returns an array of logs matching the specified filter
    * @example
@@ -1435,7 +805,6 @@ var BaseProvider = class {
    *
    * * [Identical](/docs/api#isd) to [`ethers.provider.call`](https://docs.ethers.io/v5/api/providers/provider/#Provider-call) in ethers.js
    * * [Identical](/docs/api#isd) to [`web3.eth.call`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#call) in web3.js
-   *
    * @param transaction the transaction object to, in theory, execute. Doesn't actually get added to the blockchain.
    * @param blockTag the block to execute this transaction on
    * @returns the result of executing the transaction on the specified block
@@ -1472,6 +841,61 @@ var BaseProvider = class {
     );
     return transactionRes;
   }
+  /**
+   * Resolves an ENS name to an Ethereum address.
+   *
+   * Performs the full ENS resolution process:
+   * 1. Computes the namehash of the ENS name
+   * 2. Queries the ENS Registry for the resolver contract
+   * 3. Queries the resolver for the address
+   *
+   * * [Identical](/docs/api#isd) to [`ethers.provider.resolveName`](https://docs.ethers.io/v5/api/providers/provider/#Provider-resolveName) in ethers.js
+   * @param name the ENS name to resolve (e.g. 'vitalik.eth')
+   * @returns the Ethereum address the name resolves to, or null if not found
+   * @example
+   * ```javascript
+   * await provider.resolveName('vitalik.eth');
+   * // '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'
+   * ```
+   * @example
+   * ```javascript
+   * await provider.resolveName('thisshouldnotexist12345.eth');
+   * // null
+   * ```
+   */
+  async resolveName(name) {
+    const ENS_REGISTRY = "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+    const RESOLVER_SELECTOR = "0x0178b8bf";
+    const ADDR_SELECTOR = "0x3b3b57de";
+    const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000000";
+    const node = namehash(name);
+    const nodeWithoutPrefix = node.slice(2);
+    const resolverData = RESOLVER_SELECTOR + nodeWithoutPrefix;
+    const resolverResult = await this.call({
+      to: ENS_REGISTRY,
+      data: resolverData
+    });
+    if (!resolverResult || resolverResult === ZERO_ADDRESS) {
+      return null;
+    }
+    const resolverAddress = "0x" + resolverResult.slice(26);
+    if (resolverAddress === "0x0000000000000000000000000000000000000000" || resolverAddress === "0x" + "0".repeat(resolverResult.length - 2)) {
+      return null;
+    }
+    const addrData = ADDR_SELECTOR + nodeWithoutPrefix;
+    const addrResult = await this.call({
+      to: resolverAddress,
+      data: addrData
+    });
+    if (!addrResult || addrResult === ZERO_ADDRESS) {
+      return null;
+    }
+    const rawAddress = "0x" + addrResult.slice(26);
+    if (rawAddress === "0x0000000000000000000000000000000000000000") {
+      return null;
+    }
+    return toChecksumAddress(rawAddress);
+  }
 };
 
 // src/providers/JsonRpcProvider.ts
@@ -1573,380 +997,149 @@ var FallthroughProvider = class extends BaseProvider {
   };
 };
 
-// src/utils/compute-public-key.ts
-import { Point } from "@noble/secp256k1";
-function computePublicKey(privKey) {
-  privKey = hexlify(privKey).slice(2);
-  return "0x" + Point.fromPrivateKey(privKey).toHex();
-}
-
-// src/utils/keccak256.ts
-import { Keccak as Keccak3 } from "sha3";
-function keccak256(data) {
-  let bufferableData;
-  if (typeof data === "string") {
-    bufferableData = Buffer.from(data.replace(/^0x/, ""), "hex");
-  } else {
-    bufferableData = Buffer.from(data);
+// src/utils/abi-encode-decode.ts
+function findFunctionABI(abi, functionName) {
+  const entry = abi.find(
+    (item) => item.type === "function" && item.name === functionName
+  );
+  if (!entry) {
+    throw new Error(`Function "${functionName}" not found in ABI`);
   }
-  const keccak = new Keccak3(256);
-  const addressHash = "0x" + keccak.update(bufferableData).digest("hex");
-  return addressHash;
+  return entry;
 }
-
-// src/utils/compute-address.ts
-function computeAddress(key) {
-  if (!key.startsWith("0x04") && !key.startsWith("0x03") && !key.startsWith("0x02")) {
-    key = computePublicKey(key);
-  }
-  return toChecksumAddress(hexDataSlice(keccak256(hexDataSlice(key, 1)), 12));
+function encodeFunctionData(abi, functionName, args = []) {
+  const abiEntry = findFunctionABI(abi, functionName);
+  return encodeData(abiEntry, args);
 }
-
-// src/utils/ether-to-gwei.ts
-function etherToGwei(etherQuantity) {
-  validateType(etherQuantity, ["string", "number", "object"]);
-  const result = tinyBig(etherQuantity).times("1000000000");
-  return tinyBig(result);
+function decodeFunctionResult(abi, functionName, data) {
+  const abiEntry = findFunctionABI(abi, functionName);
+  return decodeRPCResponse(abiEntry, data);
 }
 
-// src/utils/ether-to-wei.ts
-function etherToWei(etherQuantity) {
-  validateType(etherQuantity, ["string", "number", "object"]);
-  const result = tinyBig(etherQuantity).times("1000000000000000000");
-  return tinyBig(result);
+// src/utils/to-utf8-string.ts
+function toUtf8String(bytes) {
+  return new TextDecoder().decode(arrayify(bytes));
 }
 
-// src/utils/gwei-to-ether.ts
-function gweiToEther(gweiQuantity) {
-  validateType(gweiQuantity, ["string", "number", "object"]);
-  const result = tinyBig(gweiQuantity).div("1000000000");
-  return tinyBig(result);
+// src/utils/bytes32-string.ts
+function encodeBytes32String(text) {
+  const bytes = toUtf8Bytes(text);
+  if (bytes.length > 31) {
+    throw new Error("bytes32 string must be less than 32 bytes");
+  }
+  const padded = new Uint8Array(32);
+  padded.set(bytes);
+  return hexlify(padded);
 }
-
-// src/utils/to-utf8-bytes.ts
-function toUtf8Bytes(data) {
-  return new Uint8Array(Buffer.from(data));
+function decodeBytes32String(bytes32) {
+  let hex = bytes32;
+  if (hex.startsWith("0x") || hex.startsWith("0X")) {
+    hex = hex.slice(2);
+  }
+  hex = hex.replace(/(00)+$/, "");
+  if (hex.length === 0)
+    return "";
+  return toUtf8String("0x" + hex);
 }
 
-// src/utils/hash-message.ts
-var messagePrefix = "Ethereum Signed Message:\n";
-function hashMessage(message) {
-  if (typeof message === "string") {
-    message = toUtf8Bytes(message);
-  }
-  return keccak256(
-    concat([
-      toUtf8Bytes(messagePrefix),
-      toUtf8Bytes(String(message.length)),
-      message
-    ])
-  );
+// src/utils/decode-event-log.ts
+function computeEventTopic(event) {
+  const types = event.inputs.map((input) => input.type);
+  const signature = `${event.name}(${types.join(",")})`;
+  return keccak256(toUtf8Bytes(signature));
 }
-
-// src/utils/is-address.ts
-function isAddress(address) {
-  validateType(address, ["string"]);
-  try {
-    toChecksumAddress(address);
-    return true;
-  } catch (error) {
-    return false;
+function decodeValue(hexChunk, type) {
+  if (type === "bool") {
+    return hexChunk[hexChunk.length - 1] === "1";
   }
-}
-
-// src/utils/solidity-keccak256.ts
-import { Buffer as Buffer2 } from "buffer";
-var regexBytes = new RegExp("^bytes([0-9]+)$");
-var regexNumber = new RegExp("^(u?int)([0-9]*)$");
-var regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
-function _pack(type, value, isArray) {
-  switch (type) {
-    case "address":
-      if (isArray) {
-        return zeroPad(value, 32);
-      }
-      return arrayify(value);
-    case "string":
-      return Buffer2.from(value);
-    case "bytes":
-      return arrayify(value);
-    case "bool":
-      value = value ? "0x01" : "0x00";
-      if (isArray) {
-        return zeroPad(value, 32);
-      }
-      return arrayify(value);
+  if (type === "address") {
+    return toChecksumAddress(`0x${hexChunk.slice(24)}`);
   }
-  let match = type.match(regexNumber);
-  if (match) {
-    let size = parseInt(match[2] || "256");
-    if (match[2] && String(size) !== match[2] || size % 8 !== 0 || size === 0 || size > 256) {
-      logger.throwArgumentError("invalid number type", "type", type);
-    }
-    if (isArray) {
-      size = 256;
-    }
-    value = tinyBig(value).toTwos(size).toNumber();
-    const hexValue2 = hexlify(value);
-    return zeroPad(hexValue2, size / 8);
+  if (type === "bytes32") {
+    return `0x${hexChunk}`;
   }
-  match = type.match(regexBytes);
-  if (match) {
-    const size = parseInt(match[1]);
-    if (String(size) !== match[1] || size === 0 || size > 32) {
-      logger.throwArgumentError("invalid bytes type", "type", type);
-    }
-    if (arrayify(value).byteLength !== size) {
-      logger.throwArgumentError(`invalid value for ${type}`, "value", value);
-    }
-    if (isArray) {
-      return arrayify((value + hexFalse).substring(0, 66));
-    }
-    return value;
+  if (type === "uint8") {
+    return Number(BigInt(`0x${hexChunk}`));
   }
-  match = type.match(regexArray);
-  if (match && Array.isArray(value)) {
-    const baseType = match[1];
-    const count = parseInt(match[2] || String(value.length));
-    if (count != value.length) {
-      logger.throwArgumentError(
-        `invalid array length for ${type}`,
-        "value",
-        value
-      );
-    }
-    const result = [];
-    value.forEach(function(value2) {
-      result.push(_pack(baseType, value2, true));
-    });
-    return concat(result);
+  if (type.startsWith("uint")) {
+    return BigInt(`0x${hexChunk}`);
   }
-  return logger.throwArgumentError("invalid type", "type", type);
-}
-function pack(types, values) {
-  if (types.length != values.length) {
-    logger.throwArgumentError(
-      "wrong number of values; expected ${ types.length }",
-      "values",
-      values
-    );
+  if (type.startsWith("int")) {
+    return BigInt(`0x${hexChunk}`);
   }
-  const tight = [];
-  types.forEach(function(type, index) {
-    tight.push(_pack(type, values[index]));
-  });
-  return hexlify(concat(tight));
-}
-function solidityKeccak256(types, values) {
-  return keccak256(pack(types, values));
+  throw new Error(
+    `essential-eth does not yet support decoding "${type}" in event logs. Make a PR today!`
+  );
 }
-
-// src/utils/split-signature.ts
-function splitSignature(signature) {
-  const result = {
-    r: "0x",
-    s: "0x",
-    _vs: "0x",
-    recoveryParam: 0,
-    v: 0,
-    yParityAndS: "0x",
-    compact: "0x"
-  };
-  if (isBytesLike(signature)) {
-    const bytes = arrayify(signature);
-    if (bytes.length === 64) {
-      result.v = 27 + (bytes[32] >> 7);
-      bytes[32] &= 127;
-      result.r = hexlify(bytes.slice(0, 32));
-      result.s = hexlify(bytes.slice(32, 64));
-    } else if (bytes.length === 65) {
-      result.r = hexlify(bytes.slice(0, 32));
-      result.s = hexlify(bytes.slice(32, 64));
-      result.v = bytes[64];
-    } else {
-      logger.throwArgumentError(
-        "invalid signature string",
-        "signature",
-        signature
-      );
-    }
-    if (result.v < 27) {
-      if (result.v === 0 || result.v === 1) {
-        result.v += 27;
-      } else {
-        logger.throwArgumentError(
-          "signature invalid v byte",
-          "signature",
-          signature
-        );
-      }
-    }
-    result.recoveryParam = 1 - result.v % 2;
-    if (result.recoveryParam) {
-      bytes[32] |= 128;
+function decodeEventLog(abi, log) {
+  const topic0 = log.topics[0];
+  const events = abi.filter((entry) => entry.type === "event");
+  let matchedEvent;
+  for (const event of events) {
+    const hash = computeEventTopic(event);
+    if (hash === topic0) {
+      matchedEvent = event;
+      break;
     }
-    result._vs = hexlify(bytes.slice(32, 64));
-  } else {
-    result.r = signature.r;
-    result.s = signature.s;
-    result.v = signature.v;
-    result.recoveryParam = signature.recoveryParam;
-    result._vs = signature._vs;
-    if (result._vs != null) {
-      const vs_1 = zeroPad(arrayify(result._vs), 32);
-      result._vs = hexlify(vs_1);
-      const recoveryParam = vs_1[0] >= 128 ? 1 : 0;
-      if (result.recoveryParam == null) {
-        result.recoveryParam = recoveryParam;
-      } else if (result.recoveryParam !== recoveryParam) {
-        logger.throwArgumentError(
-          "signature recoveryParam mismatch _vs",
-          "signature",
-          signature
-        );
-      }
-      vs_1[0] &= 127;
-      const s = hexlify(vs_1);
-      if (result.s == null) {
-        result.s = s;
-      } else if (result.s !== s) {
-        logger.throwArgumentError(
-          "signature v mismatch _vs",
-          "signature",
-          signature
-        );
-      }
-    }
-    if (result.recoveryParam == null) {
-      if (result.v == null) {
-        logger.throwArgumentError(
-          "signature missing v and recoveryParam",
-          "signature",
-          signature
-        );
-      } else if (result.v === 0 || result.v === 1) {
-        result.recoveryParam = result.v;
-      } else {
-        result.recoveryParam = 1 - result.v % 2;
-      }
-    } else {
-      if (result.v == null) {
-        result.v = 27 + result.recoveryParam;
-      } else {
-        const recId = result.v === 0 || result.v === 1 ? result.v : 1 - result.v % 2;
-        if (result.recoveryParam !== recId) {
-          logger.throwArgumentError(
-            "signature recoveryParam mismatch v",
-            "signature",
-            signature
-          );
-        }
-      }
-    }
-    if (result.r == null || !isHexString(result.r)) {
-      logger.throwArgumentError(
-        "signature missing or invalid r",
-        "signature",
-        signature
-      );
-    } else {
-      result.r = hexZeroPad(result.r, 32);
-    }
-    if (result.s == null || !isHexString(result.s)) {
-      logger.throwArgumentError(
-        "signature missing or invalid s",
-        "signature",
-        signature
-      );
+  }
+  if (!matchedEvent) {
+    throw new Error(`No matching event found in ABI for topic0: ${topic0}`);
+  }
+  const args = {};
+  let topicIndex = 1;
+  let dataOffset = 0;
+  const rawData = log.data.startsWith("0x") ? log.data.slice(2) : log.data;
+  for (const input of matchedEvent.inputs) {
+    if (input.indexed) {
+      const topicHex = log.topics[topicIndex];
+      const hexChunk = topicHex.startsWith("0x") ? topicHex.slice(2) : topicHex;
+      args[input.name] = decodeValue(hexChunk, input.type);
+      topicIndex++;
     } else {
-      result.s = hexZeroPad(result.s, 32);
-    }
-    const vs = arrayify(result.s);
-    if (vs[0] >= 128) {
-      logger.throwArgumentError(
-        "signature s out of range",
-        "signature",
-        signature
-      );
-    }
-    if (result.recoveryParam) {
-      vs[0] |= 128;
-    }
-    const _vs = hexlify(vs);
-    if (result._vs) {
-      if (!isHexString(result._vs)) {
-        logger.throwArgumentError(
-          "signature invalid _vs",
-          "signature",
-          signature
-        );
-      }
-      result._vs = hexZeroPad(result._vs, 32);
-    }
-    if (result._vs == null) {
-      result._vs = _vs;
-    } else if (result._vs !== _vs) {
-      logger.throwArgumentError(
-        "signature _vs mismatch v and s",
-        "signature",
-        signature
-      );
+      const hexChunk = rawData.slice(dataOffset, dataOffset + 64);
+      args[input.name] = decodeValue(hexChunk, input.type);
+      dataOffset += 64;
     }
   }
-  result.yParityAndS = result._vs;
-  result.compact = result.r + result.yParityAndS.substring(2);
-  return result;
+  return {
+    eventName: matchedEvent.name,
+    args
+  };
 }
 
-// src/utils/wei-to-ether.ts
-function weiToEther(weiQuantity) {
-  validateType(weiQuantity, ["string", "number", "object"]);
-  try {
-    let _weiQuantity = weiQuantity;
-    if (typeof weiQuantity === "string" && weiQuantity.slice(0, 2) === "0x") {
-      _weiQuantity = BigInt(weiQuantity).toString();
-    }
-    const result = tinyBig(_weiQuantity).div("1000000000000000000");
-    return tinyBig(result);
-  } catch (error) {
-    throw error;
+// src/utils/event-topic.ts
+function getEventTopic(eventSignature) {
+  return keccak256(toUtf8Bytes(eventSignature));
+}
+function getEventSignature(abi, eventName) {
+  const event = abi.find(
+    (entry) => entry.type === "event" && entry.name === eventName
+  );
+  if (!event) {
+    throw new Error(`Event "${eventName}" not found in ABI`);
   }
+  const signature = `${event.name}(${event.inputs.map((input) => input.type).join(",")})`;
+  return getEventTopic(signature);
 }
-export {
-  AlchemyProvider,
-  BaseContract,
-  Contract,
-  FallthroughProvider,
-  JsonRpcProvider,
-  TinyBig,
-  arrayify,
-  computeAddress,
-  computePublicKey,
-  concat,
-  etherToGwei,
-  etherToWei,
-  gweiToEther,
-  hashMessage,
-  hexConcat,
-  hexDataLength,
-  hexDataSlice,
-  hexStripZeros,
-  hexValue,
-  hexZeroPad,
-  hexlify,
-  isAddress,
-  isBytes,
-  isBytesLike,
-  isHexString,
-  jsonRpcProvider,
-  keccak256,
-  pack,
-  solidityKeccak256,
-  splitSignature,
-  stripZeros,
-  tinyBig,
-  toChecksumAddress,
-  toUtf8Bytes,
-  weiToEther,
-  zeroPad
-};
+
+// src/utils/format-units.ts
+function formatUnits(value, decimals = 18) {
+  return formatFixed(toBigInt(value), decimals);
+}
+
+// src/utils/get-address.ts
+function getAddress(address) {
+  return toChecksumAddress(address);
+}
+
+// src/utils/id.ts
+function id(text) {
+  return keccak256(toUtf8Bytes(text));
+}
+
+// src/utils/parse-units.ts
+function parseUnits(value, decimals = 18) {
+  return parseFixed(value, decimals);
+}
+
+export { AlchemyProvider, BaseContract, Contract, FallthroughProvider, JsonRpcProvider, decodeBytes32String, decodeEventLog, decodeFunctionResult, encodeBytes32String, encodeFunctionData, formatUnits, getAddress, getEventSignature, getEventTopic, id, jsonRpcProvider, namehash, parseUnits, toUtf8String };