essential-eth 0.13.0 → 1.1.0

package/dist/{chunk-C4VOKUKQ.js → chunk-4V2QY6OK.js}

@@ -1,4 +1,4 @@
-import { validateType, hexToDecimal, tinyBig } from './chunk-UXC5R4JE.js';
+import { validateType } from './chunk-GFWRB7PT.js';
 import { keccak_256 } from '@noble/hashes/sha3.js';
 import { bytesToHex } from '@noble/hashes/utils.js';
 import { Point } from '@noble/secp256k1';
@@ -26,7 +26,7 @@ function toChecksumAddress(address) {
 }
 
 // src/logger/package-version.ts
-var version = "0.13.0";
+var version = "1.1.0";
 
 // src/logger/logger.ts
 var Logger = class {
@@ -116,6 +116,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;
   }
@@ -303,10 +312,6 @@ function hexZeroPad(value, length) {
   }
   return value;
 }
-function computePublicKey(privKey) {
-  privKey = hexlify(privKey).slice(2);
-  return "0x" + Point.fromPrivateKey(privKey).toHex();
-}
 function keccak256(data) {
   let bytes;
   if (typeof data === "string") {
@@ -321,6 +326,15 @@ function keccak256(data) {
   return "0x" + bytesToHex(keccak_256(bytes));
 }
 
+// src/utils/to-utf8-bytes.ts
+function toUtf8Bytes(data) {
+  return new TextEncoder().encode(data);
+}
+function computePublicKey(privKey) {
+  privKey = hexlify(privKey).slice(2);
+  return "0x" + Point.fromPrivateKey(privKey).toHex();
+}
+
 // src/utils/compute-address.ts
 function computeAddress(key) {
   if (!key.startsWith("0x04") && !key.startsWith("0x03") && !key.startsWith("0x02")) {
@@ -329,11 +343,6 @@ function computeAddress(key) {
   return toChecksumAddress(hexDataSlice(keccak256(hexDataSlice(key, 1)), 12));
 }
 
-// src/utils/to-utf8-bytes.ts
-function toUtf8Bytes(data) {
-  return new TextEncoder().encode(data);
-}
-
 // src/utils/hash-message.ts
 var messagePrefix = "Ethereum Signed Message:\n";
 function hashMessage(message) {
@@ -359,6 +368,13 @@ function isAddress(address) {
     return false;
   }
 }
+
+// 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";
 function hexToUtf8(hex) {
@@ -370,7 +386,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 {
@@ -484,7 +501,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) => {
@@ -494,14 +511,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!"`
         );
@@ -541,7 +561,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);
   }
@@ -753,4 +777,4 @@ function splitSignature(signature) {
   return result;
 }
 
-export { arrayify, computeAddress, computePublicKey, concat, decodeRPCResponse, encodeData, hashMessage, hexConcat, hexDataLength, hexDataSlice, hexStripZeros, hexValue, hexZeroPad, hexlify, isAddress, isBytes, isBytesLike, isHexString, keccak256, logger, pack, solidityKeccak256, splitSignature, stripZeros, toChecksumAddress, toUtf8Bytes, zeroPad };
+export { arrayify, computeAddress, computePublicKey, concat, decodeRPCResponse, encodeData, hashMessage, hexConcat, hexDataLength, hexDataSlice, hexStripZeros, hexToDecimal, hexValue, hexZeroPad, hexlify, isAddress, isBytes, isBytesLike, isHexString, keccak256, logger, pack, solidityKeccak256, splitSignature, stripZeros, toChecksumAddress, toUtf8Bytes, zeroPad };

package/dist/chunk-GFWRB7PT.js

@@ -0,0 +1,96 @@
+// 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/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", "bigint"]);
+  return parseFixed(String(etherQuantity), 9);
+}
+
+// src/utils/ether-to-wei.ts
+function etherToWei(etherQuantity) {
+  validateType(etherQuantity, ["string", "number", "bigint"]);
+  return parseFixed(String(etherQuantity), 18);
+}
+
+// src/utils/gwei-to-ether.ts
+function gweiToEther(gweiQuantity) {
+  validateType(gweiQuantity, ["string", "number", "bigint"]);
+  return formatFixed(toBigInt(gweiQuantity), 9);
+}
+
+// src/utils/wei-to-ether.ts
+function weiToEther(weiQuantity) {
+  validateType(weiQuantity, ["string", "number", "bigint"]);
+  return formatFixed(toBigInt(weiQuantity), 18);
+}
+
+export { etherToGwei, etherToWei, formatFixed, gweiToEther, parseFixed, toBigInt, validateType, weiToEther };

package/dist/conversions.d.ts

@@ -1,21 +1,9 @@
-import Big from 'big.js';
+declare function etherToGwei(etherQuantity: string | number | bigint): bigint;
 
-declare class TinyBig extends Big {
-    constructor(value: string | number | TinyBig | Big);
-    toHexString(): string;
-    toNumber(): number;
-    toString(): string;
-    private padAndChop;
-    toTwos(bitCount: number): Big;
-}
-declare function tinyBig(value: string | number | TinyBig | Big): TinyBig;
+declare function etherToWei(etherQuantity: string | number | bigint): bigint;
 
-declare function etherToGwei(etherQuantity: string | number | TinyBig | Big): TinyBig;
+declare function gweiToEther(gweiQuantity: string | number | bigint): string;
 
-declare function etherToWei(etherQuantity: string | number | TinyBig | Big): TinyBig;
+declare function weiToEther(weiQuantity: string | number | bigint): string;
 
-declare function gweiToEther(gweiQuantity: string | number | TinyBig | Big): TinyBig;
-
-declare function weiToEther(weiQuantity: string | number | TinyBig | Big): TinyBig;
-
-export { TinyBig, etherToGwei, etherToWei, gweiToEther, tinyBig, weiToEther };
+export { etherToGwei, etherToWei, gweiToEther, weiToEther };

package/dist/conversions.js

@@ -1 +1 @@
-export { TinyBig, etherToGwei, etherToWei, gweiToEther, tinyBig, weiToEther } from './chunk-UXC5R4JE.js';
+export { etherToGwei, etherToWei, gweiToEther, weiToEther } from './chunk-GFWRB7PT.js';

package/dist/{index-utils-D40THakY.d.ts → index-utils-e8a8adc8.d.ts}

@@ -28,7 +28,7 @@ interface Signature {
 }
 declare function isBytesLike(value: any): value is BytesLike;
 declare function isBytes(value: any): value is Bytes;
-declare function arrayify(value: BytesLike | Hexable | number, options?: DataOptions): Uint8Array;
+declare function arrayify(value: BytesLike | Hexable | number | bigint, options?: DataOptions): Uint8Array;
 declare function concat(arrayOfBytesLike: ReadonlyArray<BytesLikeWithNumber>): Uint8Array;
 declare function stripZeros(value: BytesLike): Uint8Array;
 declare function zeroPad(value: BytesLike, length: number): Uint8Array;
@@ -60,4 +60,4 @@ declare function toChecksumAddress(address: string): string;
 
 declare function toUtf8Bytes(data: string): Uint8Array;
 
-export { zeroPad as A, type BytesLike as B, type DataOptions as D, type Hexable as H, type Signature as S, type Bytes as a, type BytesLikeWithNumber as b, type SignatureLike as c, arrayify as d, computeAddress as e, computePublicKey as f, concat as g, hashMessage as h, hexConcat as i, hexDataLength as j, hexDataSlice as k, hexStripZeros as l, hexValue as m, hexZeroPad as n, hexlify as o, isAddress as p, isBytes as q, isBytesLike as r, isHexString as s, keccak256 as t, pack as u, solidityKeccak256 as v, splitSignature as w, stripZeros as x, toChecksumAddress as y, toUtf8Bytes as z };
+export { toUtf8Bytes as A, BytesLike as B, DataOptions as D, Hexable as H, Signature as S, arrayify as a, Bytes as b, BytesLikeWithNumber as c, concat as d, hexDataLength as e, hexDataSlice as f, hexlify as g, hexConcat as h, hexStripZeros as i, hexValue as j, hexZeroPad as k, isBytes as l, isBytesLike as m, isHexString as n, SignatureLike as o, computeAddress as p, computePublicKey as q, hashMessage as r, stripZeros as s, isAddress as t, keccak256 as u, pack as v, solidityKeccak256 as w, splitSignature as x, toChecksumAddress as y, zeroPad as z };