essential-eth 0.13.0 → 1.1.0

package/dist/index.cjs

@@ -28,20 +28,28 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
   AlchemyProvider: () => AlchemyProvider,
   BaseContract: () => BaseContract,
   Contract: () => Contract,
   FallthroughProvider: () => FallthroughProvider,
   JsonRpcProvider: () => JsonRpcProvider,
-  TinyBig: () => TinyBig,
   arrayify: () => arrayify,
   computeAddress: () => computeAddress,
   computePublicKey: () => computePublicKey,
   concat: () => concat,
+  decodeBytes32String: () => decodeBytes32String,
+  decodeEventLog: () => decodeEventLog,
+  decodeFunctionResult: () => decodeFunctionResult,
+  encodeBytes32String: () => encodeBytes32String,
+  encodeFunctionData: () => encodeFunctionData,
   etherToGwei: () => etherToGwei,
   etherToWei: () => etherToWei,
+  formatUnits: () => formatUnits,
+  getAddress: () => getAddress,
+  getEventSignature: () => getEventSignature,
+  getEventTopic: () => getEventTopic,
   gweiToEther: () => gweiToEther,
   hashMessage: () => hashMessage,
   hexConcat: () => hexConcat,
@@ -51,191 +59,31 @@ __export(index_exports, {
   hexValue: () => hexValue,
   hexZeroPad: () => hexZeroPad,
   hexlify: () => hexlify,
+  id: () => id,
   isAddress: () => isAddress,
   isBytes: () => isBytes,
   isBytesLike: () => isBytesLike,
   isHexString: () => isHexString,
   jsonRpcProvider: () => jsonRpcProvider,
   keccak256: () => keccak256,
+  namehash: () => namehash,
   pack: () => pack,
+  parseUnits: () => parseUnits,
   solidityKeccak256: () => solidityKeccak256,
   splitSignature: () => splitSignature,
   stripZeros: () => stripZeros,
-  tinyBig: () => tinyBig,
   toChecksumAddress: () => toChecksumAddress,
   toUtf8Bytes: () => toUtf8Bytes,
+  toUtf8String: () => toUtf8String,
   weiToEther: () => weiToEther,
   zeroPad: () => zeroPad
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // src/classes/utils/encode-decode-transaction.ts
 var import_sha32 = require("@noble/hashes/sha3.js");
 var import_utils2 = require("@noble/hashes/utils.js");
 
-// src/shared/tiny-big/tiny-big.ts
-var import_big = __toESM(require("big.js"), 1);
-
-// 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 import_big.default {
-  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
 var import_sha3 = require("@noble/hashes/sha3.js");
 var import_utils = require("@noble/hashes/utils.js");
@@ -272,6 +120,11 @@ function toChecksumAddress(address) {
   return checksumAddress;
 }
 
+// src/classes/utils/hex-to-decimal.ts
+function hexToDecimal(hex) {
+  return BigInt(hex).toString();
+}
+
 // src/classes/utils/encode-decode-transaction.ts
 var hexFalse = "0".repeat(64);
 var hexTrue = "0".repeat(63) + "1";
@@ -284,7 +137,8 @@ function hexToUtf8(hex) {
   }
   for (; i < l; i += 2) {
     const code = parseInt(hex.substr(i, 2), 16);
-    if (code === 0) continue;
+    if (code === 0)
+      continue;
     str += String.fromCharCode(code);
   }
   try {
@@ -398,7 +252,7 @@ function decodeRPCResponse(jsonABIArgument, nodeResponse) {
   if (rawOutputs?.length === 1 && rawOutputs[0].type === "uint256[]") {
     const outputs2 = encodedOutputs.slice(2);
     return outputs2.map((output) => {
-      return tinyBig(hexToDecimal(`0x${output}`));
+      return BigInt(hexToDecimal(`0x${output}`));
     });
   }
   const outputs = encodedOutputs.map((output, i) => {
@@ -408,14 +262,17 @@ function decodeRPCResponse(jsonABIArgument, nodeResponse) {
         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:
+        if (outputType.startsWith("uint")) {
+          return BigInt(hexToDecimal(`0x${output}`));
+        }
+        if (outputType.startsWith("int")) {
+          return BigInt(hexToDecimal(`0x${output}`));
+        }
         throw new Error(
           `essential-eth does not yet support "${outputType}" outputs. Make a PR today!"`
         );
@@ -497,7 +354,8 @@ function cleanTransaction(transaction) {
     ...transaction
   };
   Object.keys(transaction).forEach((key) => {
-    if (!transaction[key]) return;
+    if (!transaction[key])
+      return;
     switch (key) {
       case "blockNumber":
       case "chainId":
@@ -518,7 +376,7 @@ function cleanTransaction(transaction) {
       case "maxFeePerGas":
       case "maxPriorityFeePerGas":
       case "nonce":
-        cleanedTransaction[key] = tinyBig(hexToDecimal(transaction[key]));
+        cleanedTransaction[key] = BigInt(hexToDecimal(transaction[key]));
         break;
     }
   });
@@ -529,7 +387,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":
@@ -538,7 +397,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]));
@@ -591,7 +450,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(
@@ -608,7 +468,7 @@ function cleanTransactionReceipt(transactionReceipt) {
       case "cumulativeGasUsed":
       case "effectiveGasPrice":
       case "gasUsed":
-        cleanedTransactionReceipt[key] = tinyBig(
+        cleanedTransactionReceipt[key] = BigInt(
           hexToDecimal(transactionReceipt[key])
         );
         break;
@@ -661,11 +521,8 @@ function buildRPCPostBody(method, params) {
   };
 }
 
-// src/classes/utils/prepare-transaction.ts
-var import_big2 = __toESM(require("big.js"), 1);
-
 // src/logger/package-version.ts
-var version = "0.13.0";
+var version = "1.1.0";
 
 // src/logger/logger.ts
 var Logger = class {
@@ -755,6 +612,15 @@ function arrayify(value, options) {
     }
     return new Uint8Array(result);
   }
+  if (typeof value === "bigint") {
+    const hex = value.toString(16).padStart(2, "0");
+    const padded = hex.length % 2 ? "0" + hex : hex;
+    const result = new Uint8Array(padded.length / 2);
+    for (let i = 0; i < result.length; i++) {
+      result[i] = parseInt(padded.substring(i * 2, i * 2 + 2), 16);
+    }
+    return result;
+  }
   if (options.allowMissingPrefix && typeof value === "string" && value.substring(0, 2) !== "0x") {
     value = "0x" + value;
   }
@@ -958,15 +824,13 @@ function prepareTransaction(transaction) {
         case "maxPriorityFeePerGas":
         case "value": {
           const value = transaction[key];
-          if (value instanceof TinyBig) {
-            preparedTransaction[key] = value.toHexString();
-          } else if (value instanceof import_big2.default) {
-            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":
@@ -978,6 +842,42 @@ function prepareTransaction(transaction) {
   return preparedTransaction;
 }
 
+// src/utils/keccak256.ts
+var import_sha33 = require("@noble/hashes/sha3.js");
+var import_utils3 = require("@noble/hashes/utils.js");
+function keccak256(data) {
+  let bytes;
+  if (typeof data === "string") {
+    const hex = data.replace(/^0x/, "");
+    bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+    }
+  } else {
+    bytes = new Uint8Array(data);
+  }
+  return "0x" + (0, import_utils3.bytesToHex)((0, import_sha33.keccak_256)(bytes));
+}
+
+// src/utils/to-utf8-bytes.ts
+function toUtf8Bytes(data) {
+  return new TextEncoder().encode(data);
+}
+
+// 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": [
@@ -1049,7 +949,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 {
   /**
@@ -1075,7 +975,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
@@ -1106,7 +1005,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
@@ -1125,7 +1023,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
@@ -1137,20 +1034,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,
    * // }
    * ```
@@ -1171,7 +1068,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
@@ -1181,10 +1077,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",
@@ -1242,7 +1138,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
@@ -1274,7 +1169,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
@@ -1282,11 +1176,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",
@@ -1297,10 +1191,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",
@@ -1331,8 +1225,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
@@ -1344,14 +1237,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
@@ -1366,14 +1258,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
@@ -1396,7 +1287,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
@@ -1407,7 +1297,7 @@ var BaseProvider = class {
    *   data: "0xd0e30db0",
    *   value: etherToWei('1.0').toHexString(),
    * });
-   * // { TinyBig: "27938" }
+   * // 27938n
    * ```
    */
   async estimateGas(transaction) {
@@ -1415,7 +1305,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.
@@ -1423,16 +1313,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
    * // }
    * ```
    */
@@ -1444,10 +1333,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 };
   }
@@ -1457,7 +1344,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
@@ -1509,7 +1395,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
@@ -1546,6 +1431,137 @@ 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);
+  }
+  /**
+   * Performs reverse ENS resolution to get the ENS name associated with an address.
+   *
+   * Performs the full ENS reverse resolution process:
+   * 1. Formats the address as a reverse lookup: `{address}.addr.reverse`
+   * 2. Computes the namehash of the reverse name
+   * 3. Queries the ENS Registry for the resolver contract
+   * 4. Queries the resolver for the name
+   * 5. Verifies the name resolves back to the original address (per ENSIP-3)
+   *
+   * * [Identical](/docs/api#isd) to [`viem.getEnsName`](https://viem.sh/docs/ens/actions/getEnsName) in viem
+   * @param address the Ethereum address to look up (e.g. '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045')
+   * @returns the ENS name the address resolves to, or null if not found or verification fails
+   * @example
+   * ```javascript
+   * await provider.lookupAddress('0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045');
+   * // 'vitalik.eth'
+   * ```
+   * @example
+   * ```javascript
+   * await provider.lookupAddress('0x0000000000000000000000000000000000000000');
+   * // null
+   * ```
+   */
+  async lookupAddress(address) {
+    const ENS_REGISTRY = "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+    const RESOLVER_SELECTOR = "0x0178b8bf";
+    const NAME_SELECTOR = "0x691f3431";
+    const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000000";
+    const addressLower = address.toLowerCase();
+    const addressWithoutPrefix = addressLower.startsWith("0x") ? addressLower.slice(2) : addressLower;
+    const reverseName = `${addressWithoutPrefix}.addr.reverse`;
+    const node = namehash(reverseName);
+    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 nameData = NAME_SELECTOR + nodeWithoutPrefix;
+    const nameResult = await this.call({
+      to: resolverAddress,
+      data: nameData
+    });
+    if (!nameResult || nameResult === ZERO_ADDRESS) {
+      return null;
+    }
+    const lengthHex = nameResult.slice(2 + 64, 2 + 128);
+    const length = parseInt(lengthHex, 16);
+    if (length === 0) {
+      return null;
+    }
+    const dataHex = nameResult.slice(2 + 128);
+    const name = dataHex.slice(0, length * 2).match(/.{1,2}/g)?.map((byte) => String.fromCharCode(parseInt(byte, 16))).join("");
+    if (!name) {
+      return null;
+    }
+    try {
+      const verifyAddress = await this.resolveName(name);
+      const normalizedAddress = addressLower.startsWith("0x") ? addressLower : "0x" + addressLower;
+      const normalizedVerifyAddress = verifyAddress?.toLowerCase();
+      if (normalizedVerifyAddress !== normalizedAddress) {
+        return null;
+      }
+    } catch {
+      return null;
+    }
+    return name;
+  }
 };
 
 // src/providers/JsonRpcProvider.ts
@@ -1580,7 +1596,7 @@ function jsonRpcProvider(rpcUrl) {
 // src/providers/AlchemyProvider.ts
 var AlchemyProvider = class extends JsonRpcProvider {
   constructor(apiKey, network = "mainnet") {
-    const alchemyUrl = `https://eth-${network}.alchemyapi.io/v2/${apiKey}`;
+    const alchemyUrl = `https://eth-${network}.g.alchemy.com/v2/${apiKey}`;
     super(alchemyUrl);
   }
 };
@@ -1647,6 +1663,51 @@ var FallthroughProvider = class extends BaseProvider {
   };
 };
 
+// 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`);
+  }
+  return entry;
+}
+function encodeFunctionData(abi, functionName, args = []) {
+  const abiEntry = findFunctionABI(abi, functionName);
+  return encodeData(abiEntry, args);
+}
+function decodeFunctionResult(abi, functionName, data) {
+  const abiEntry = findFunctionABI(abi, functionName);
+  return decodeRPCResponse(abiEntry, data);
+}
+
+// src/utils/to-utf8-string.ts
+function toUtf8String(bytes) {
+  return new TextDecoder().decode(arrayify(bytes));
+}
+
+// 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);
+}
+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/compute-public-key.ts
 var import_secp256k1 = require("@noble/secp256k1");
 function computePublicKey(privKey) {
@@ -1654,23 +1715,6 @@ function computePublicKey(privKey) {
   return "0x" + import_secp256k1.Point.fromPrivateKey(privKey).toHex();
 }
 
-// src/utils/keccak256.ts
-var import_sha33 = require("@noble/hashes/sha3.js");
-var import_utils3 = require("@noble/hashes/utils.js");
-function keccak256(data) {
-  let bytes;
-  if (typeof data === "string") {
-    const hex = data.replace(/^0x/, "");
-    bytes = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < bytes.length; i++) {
-      bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
-    }
-  } else {
-    bytes = new Uint8Array(data);
-  }
-  return "0x" + (0, import_utils3.bytesToHex)((0, import_sha33.keccak_256)(bytes));
-}
-
 // src/utils/compute-address.ts
 function computeAddress(key) {
   if (!key.startsWith("0x04") && !key.startsWith("0x03") && !key.startsWith("0x02")) {
@@ -1679,30 +1723,174 @@ function computeAddress(key) {
   return toChecksumAddress(hexDataSlice(keccak256(hexDataSlice(key, 1)), 12));
 }
 
+// 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));
+}
+function decodeValue(hexChunk, type) {
+  if (type === "bool") {
+    return hexChunk[hexChunk.length - 1] === "1";
+  }
+  if (type === "address") {
+    return toChecksumAddress(`0x${hexChunk.slice(24)}`);
+  }
+  if (type === "bytes32") {
+    return `0x${hexChunk}`;
+  }
+  if (type === "uint8") {
+    return Number(BigInt(`0x${hexChunk}`));
+  }
+  if (type.startsWith("uint")) {
+    return BigInt(`0x${hexChunk}`);
+  }
+  if (type.startsWith("int")) {
+    return BigInt(`0x${hexChunk}`);
+  }
+  throw new Error(
+    `essential-eth does not yet support decoding "${type}" in event logs. Make a PR today!`
+  );
+}
+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;
+    }
+  }
+  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 {
+      const hexChunk = rawData.slice(dataOffset, dataOffset + 64);
+      args[input.name] = decodeValue(hexChunk, input.type);
+      dataOffset += 64;
+    }
+  }
+  return {
+    eventName: matchedEvent.name,
+    args
+  };
+}
+
+// src/utils/fixed-point.ts
+function parseFixed(value, decimals) {
+  let negative = false;
+  if (value.startsWith("-")) {
+    negative = true;
+    value = value.substring(1);
+  }
+  if (value === "") {
+    throw new Error("invalid decimal value");
+  }
+  const parts = value.split(".");
+  if (parts.length > 2) {
+    throw new Error("too many decimal points");
+  }
+  const integer = parts[0] || "0";
+  let fraction = parts[1] || "";
+  if (fraction.length > decimals) {
+    const extra = fraction.substring(decimals);
+    if (extra.match(/[^0]/)) {
+      throw new Error("fractional component exceeds decimals");
+    }
+    fraction = fraction.substring(0, decimals);
+  }
+  while (fraction.length < decimals) {
+    fraction += "0";
+  }
+  const result = BigInt(integer + fraction);
+  return negative ? -result : result;
+}
+function formatFixed(value, decimals) {
+  let negative = "";
+  if (value < 0n) {
+    negative = "-";
+    value = -value;
+  }
+  let str = value.toString();
+  while (str.length <= decimals) {
+    str = "0" + str;
+  }
+  const integerPart = str.substring(0, str.length - decimals);
+  const fractionPart = str.substring(str.length - decimals);
+  const trimmedFraction = fractionPart.replace(/0+$/, "");
+  if (trimmedFraction) {
+    return `${negative}${integerPart}.${trimmedFraction}`;
+  }
+  return `${negative}${integerPart}`;
+}
+function toBigInt(value) {
+  if (typeof value === "bigint")
+    return value;
+  if (typeof value === "string") {
+    if (value.startsWith("0x")) {
+      return BigInt(value);
+    }
+    if (value.includes(".")) {
+      return BigInt(value.split(".")[0] || "0");
+    }
+    return BigInt(value);
+  }
+  return BigInt(value);
+}
+
 // src/utils/ether-to-gwei.ts
 function etherToGwei(etherQuantity) {
-  validateType(etherQuantity, ["string", "number", "object"]);
-  const result = tinyBig(etherQuantity).times("1000000000");
-  return tinyBig(result);
+  validateType(etherQuantity, ["string", "number", "bigint"]);
+  return parseFixed(String(etherQuantity), 9);
 }
 
 // src/utils/ether-to-wei.ts
 function etherToWei(etherQuantity) {
-  validateType(etherQuantity, ["string", "number", "object"]);
-  const result = tinyBig(etherQuantity).times("1000000000000000000");
-  return tinyBig(result);
+  validateType(etherQuantity, ["string", "number", "bigint"]);
+  return parseFixed(String(etherQuantity), 18);
 }
 
-// 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/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);
 }
 
-// src/utils/to-utf8-bytes.ts
-function toUtf8Bytes(data) {
-  return new TextEncoder().encode(data);
+// 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/gwei-to-ether.ts
+function gweiToEther(gweiQuantity) {
+  validateType(gweiQuantity, ["string", "number", "bigint"]);
+  return formatFixed(toBigInt(gweiQuantity), 9);
 }
 
 // src/utils/hash-message.ts
@@ -1720,6 +1908,11 @@ function hashMessage(message) {
   );
 }
 
+// src/utils/id.ts
+function id(text) {
+  return keccak256(toUtf8Bytes(text));
+}
+
 // src/utils/is-address.ts
 function isAddress(address) {
   validateType(address, ["string"]);
@@ -1731,6 +1924,11 @@ function isAddress(address) {
   }
 }
 
+// src/utils/parse-units.ts
+function parseUnits(value, decimals = 18) {
+  return parseFixed(value, decimals);
+}
+
 // src/utils/solidity-keccak256.ts
 var regexBytes = new RegExp("^bytes([0-9]+)$");
 var regexNumber = new RegExp("^(u?int)([0-9]*)$");
@@ -1762,7 +1960,11 @@ function _pack(type, value, isArray) {
     if (isArray) {
       size = 256;
     }
-    value = tinyBig(value).toTwos(size).toNumber();
+    let bigVal = BigInt(value);
+    if (bigVal < 0n) {
+      bigVal = bigVal + (1n << BigInt(size));
+    }
+    value = Number(bigVal);
     const hexValue2 = hexlify(value);
     return zeroPad(hexValue2, size / 8);
   }
@@ -1976,17 +2178,8 @@ function splitSignature(signature) {
 
 // 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;
-  }
+  validateType(weiQuantity, ["string", "number", "bigint"]);
+  return formatFixed(toBigInt(weiQuantity), 18);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1995,13 +2188,21 @@ function weiToEther(weiQuantity) {
   Contract,
   FallthroughProvider,
   JsonRpcProvider,
-  TinyBig,
   arrayify,
   computeAddress,
   computePublicKey,
   concat,
+  decodeBytes32String,
+  decodeEventLog,
+  decodeFunctionResult,
+  encodeBytes32String,
+  encodeFunctionData,
   etherToGwei,
   etherToWei,
+  formatUnits,
+  getAddress,
+  getEventSignature,
+  getEventTopic,
   gweiToEther,
   hashMessage,
   hexConcat,
@@ -2011,19 +2212,22 @@ function weiToEther(weiQuantity) {
   hexValue,
   hexZeroPad,
   hexlify,
+  id,
   isAddress,
   isBytes,
   isBytesLike,
   isHexString,
   jsonRpcProvider,
   keccak256,
+  namehash,
   pack,
+  parseUnits,
   solidityKeccak256,
   splitSignature,
   stripZeros,
-  tinyBig,
   toChecksumAddress,
   toUtf8Bytes,
+  toUtf8String,
   weiToEther,
   zeroPad
 });