essential-eth 0.11.1 → 0.13.0

package/dist/chunk-UXC5R4JE.js

@@ -0,0 +1,210 @@
+import Big from 'big.js';
+
+// src/shared/tiny-big/tiny-big.ts
+
+// 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/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/ether-to-gwei.ts
+function etherToGwei(etherQuantity) {
+  validateType(etherQuantity, ["string", "number", "object"]);
+  const result = tinyBig(etherQuantity).times("1000000000");
+  return tinyBig(result);
+}
+
+// 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/gwei-to-ether.ts
+function gweiToEther(gweiQuantity) {
+  validateType(gweiQuantity, ["string", "number", "object"]);
+  const result = tinyBig(gweiQuantity).div("1000000000");
+  return tinyBig(result);
+}
+
+// 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;
+  }
+}
+
+export { TinyBig, etherToGwei, etherToWei, gweiToEther, hexToDecimal, tinyBig, validateType, weiToEther };

package/dist/conversions.d.ts

@@ -0,0 +1,21 @@
+import Big from 'big.js';
+
+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 etherToGwei(etherQuantity: string | number | TinyBig | Big): TinyBig;
+
+declare function etherToWei(etherQuantity: string | number | TinyBig | Big): TinyBig;
+
+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 };

package/dist/conversions.js

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

package/dist/index-utils-D40THakY.d.ts

@@ -0,0 +1,63 @@
+import './conversions.js';
+
+type Bytes = ArrayLike<number>;
+type BytesLike = Bytes | string;
+type BytesLikeWithNumber = BytesLike | number;
+interface DataOptions {
+    allowMissingPrefix?: boolean;
+    hexPad?: 'left' | 'right' | null;
+}
+interface Hexable {
+    toHexString(): string;
+}
+type SignatureLike = {
+    r: string;
+    s?: string;
+    _vs?: string;
+    recoveryParam?: number;
+    v?: number;
+} | BytesLike;
+interface Signature {
+    r: string;
+    s: string;
+    _vs: string;
+    recoveryParam: number;
+    v: number;
+    yParityAndS: string;
+    compact: string;
+}
+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 concat(arrayOfBytesLike: ReadonlyArray<BytesLikeWithNumber>): Uint8Array;
+declare function stripZeros(value: BytesLike): Uint8Array;
+declare function zeroPad(value: BytesLike, length: number): Uint8Array;
+declare function isHexString(value: any, length?: number): boolean;
+declare function hexlify(value: BytesLike | Hexable | number | bigint, options?: DataOptions): string;
+declare function hexDataLength(data: BytesLike): number | null;
+declare function hexDataSlice(data: BytesLikeWithNumber, offset: number, endOffset?: number): string;
+declare function hexConcat(items: ReadonlyArray<BytesLike>): string;
+declare function hexValue(value: BytesLike | Hexable | number | bigint): string;
+declare function hexStripZeros(value: BytesLike): string;
+declare function hexZeroPad(value: BytesLikeWithNumber, length: number): string;
+
+declare function computeAddress(key: string): string;
+
+declare function computePublicKey(privKey: BytesLike): string;
+
+declare function hashMessage(message: Bytes | string): string;
+
+declare function isAddress(address: string): boolean;
+
+declare function keccak256(data: BytesLike): string;
+
+declare function pack(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;
+declare function solidityKeccak256(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;
+
+declare function splitSignature(signature: SignatureLike): Signature;
+
+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 };

package/dist/index.cjs

@@ -70,7 +70,8 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/classes/utils/encode-decode-transaction.ts
-var import_sha32 = require("sha3");
+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);
@@ -236,7 +237,8 @@ function tinyBig(value) {
 }
 
 // src/utils/to-checksum-address.ts
-var import_sha3 = require("sha3");
+var import_sha3 = require("@noble/hashes/sha3.js");
+var import_utils = require("@noble/hashes/utils.js");
 
 // src/shared/validate-type.ts
 var validateType = (value, allowedTypes) => {
@@ -254,8 +256,8 @@ function toChecksumAddress(address) {
     throw new Error(`Invalid Ethereum address "${address}"`);
   }
   const _address = address.toLowerCase().replace(/^0x/i, "");
-  const keccak = new import_sha3.Keccak(256);
-  const addressHash = keccak.update(_address).digest("hex").replace(/^0x/i, "");
+  const addressBytes = new TextEncoder().encode(_address);
+  const addressHash = (0, import_utils.bytesToHex)((0, import_sha3.keccak_256)(addressBytes));
   let checksumAddress = "0x";
   for (let i = 0; i < _address.length; i++) {
     if (parseInt(addressHash[i], 16) > 7) {
@@ -301,11 +303,12 @@ function expandType(type) {
   return type;
 }
 function encodeData(jsonABIArgument, args) {
-  const hash = new import_sha32.Keccak(256);
   const functionString = `${jsonABIArgument.name}(${jsonABIArgument.inputs.map(
     (input) => expandType(input.type)
   )})`;
-  const functionHash = hash.update(functionString).digest("hex");
+  const functionHash = (0, import_utils2.bytesToHex)(
+    (0, import_sha32.keccak_256)(new TextEncoder().encode(functionString))
+  );
   const jsonABIInputsLength = jsonABIArgument.inputs.length;
   let shouldValidateInputLength = true;
   if (jsonABIArgument.inputs.find((input) => input.type.includes("["))) {
@@ -662,7 +665,7 @@ function buildRPCPostBody(method, params) {
 var import_big2 = __toESM(require("big.js"), 1);
 
 // src/logger/package-version.ts
-var version = "0.11.1";
+var version = "0.13.0";
 
 // src/logger/logger.ts
 var Logger = class {
@@ -1652,17 +1655,20 @@ function computePublicKey(privKey) {
 }
 
 // src/utils/keccak256.ts
-var import_sha33 = require("sha3");
+var import_sha33 = require("@noble/hashes/sha3.js");
+var import_utils3 = require("@noble/hashes/utils.js");
 function keccak256(data) {
-  let bufferableData;
+  let bytes;
   if (typeof data === "string") {
-    bufferableData = Buffer.from(data.replace(/^0x/, ""), "hex");
+    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 {
-    bufferableData = Buffer.from(data);
+    bytes = new Uint8Array(data);
   }
-  const keccak = new import_sha33.Keccak(256);
-  const addressHash = "0x" + keccak.update(bufferableData).digest("hex");
-  return addressHash;
+  return "0x" + (0, import_utils3.bytesToHex)((0, import_sha33.keccak_256)(bytes));
 }
 
 // src/utils/compute-address.ts
@@ -1696,7 +1702,7 @@ function gweiToEther(gweiQuantity) {
 
 // src/utils/to-utf8-bytes.ts
 function toUtf8Bytes(data) {
-  return new Uint8Array(Buffer.from(data));
+  return new TextEncoder().encode(data);
 }
 
 // src/utils/hash-message.ts
@@ -1726,7 +1732,6 @@ function isAddress(address) {
 }
 
 // src/utils/solidity-keccak256.ts
-var import_buffer = require("buffer");
 var regexBytes = new RegExp("^bytes([0-9]+)$");
 var regexNumber = new RegExp("^(u?int)([0-9]*)$");
 var regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
@@ -1738,7 +1743,7 @@ function _pack(type, value, isArray) {
       }
       return arrayify(value);
     case "string":
-      return import_buffer.Buffer.from(value);
+      return new TextEncoder().encode(value);
     case "bytes":
       return arrayify(value);
     case "bool":

package/dist/index.d.ts

@@ -1,55 +1,8 @@
+import { TinyBig } from './conversions.js';
+export { etherToGwei, etherToWei, gweiToEther, tinyBig, weiToEther } from './conversions.js';
 import Big from 'big.js';
-
-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;
-
-type Bytes = ArrayLike<number>;
-type BytesLike = Bytes | string;
-type BytesLikeWithNumber = BytesLike | number;
-interface DataOptions {
-    allowMissingPrefix?: boolean;
-    hexPad?: 'left' | 'right' | null;
-}
-interface Hexable {
-    toHexString(): string;
-}
-type SignatureLike = {
-    r: string;
-    s?: string;
-    _vs?: string;
-    recoveryParam?: number;
-    v?: number;
-} | BytesLike;
-interface Signature {
-    r: string;
-    s: string;
-    _vs: string;
-    recoveryParam: number;
-    v: number;
-    yParityAndS: string;
-    compact: string;
-}
-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 concat(arrayOfBytesLike: ReadonlyArray<BytesLikeWithNumber>): Uint8Array;
-declare function stripZeros(value: BytesLike): Uint8Array;
-declare function zeroPad(value: BytesLike, length: number): Uint8Array;
-declare function isHexString(value: any, length?: number): boolean;
-declare function hexlify(value: BytesLike | Hexable | number | bigint, options?: DataOptions): string;
-declare function hexDataLength(data: BytesLike): number | null;
-declare function hexDataSlice(data: BytesLikeWithNumber, offset: number, endOffset?: number): string;
-declare function hexConcat(items: ReadonlyArray<BytesLike>): string;
-declare function hexValue(value: BytesLike | Hexable | number | bigint): string;
-declare function hexStripZeros(value: BytesLike): string;
-declare function hexZeroPad(value: BytesLikeWithNumber, length: number): string;
+import { B as BytesLike } from './index-utils-D40THakY.js';
+export { a as Bytes, b as BytesLikeWithNumber, D as DataOptions, H as Hexable, S as Signature, c as SignatureLike, d as arrayify, e as computeAddress, f as computePublicKey, g as concat, h as hashMessage, i as hexConcat, j as hexDataLength, k as hexDataSlice, l as hexStripZeros, m as hexValue, n as hexZeroPad, o as hexlify, p as isAddress, q as isBytes, r as isBytesLike, s as isHexString, t as keccak256, u as pack, v as solidityKeccak256, w as splitSignature, x as stripZeros, y as toChecksumAddress, z as toUtf8Bytes, A as zeroPad } from './index-utils-D40THakY.js';
 
 type Modify$1<T, R> = Omit<T, keyof R> & R;
 interface RPCTransaction extends RPCBlockTransaction {
@@ -300,31 +253,4 @@ declare class FallthroughProvider extends BaseProvider {
     post: (body: Record<string, unknown>) => Promise<any>;
 }
 
-declare function computeAddress(key: string): string;
-
-declare function computePublicKey(privKey: BytesLike): string;
-
-declare function etherToGwei(etherQuantity: string | number | TinyBig | Big): TinyBig;
-
-declare function etherToWei(etherQuantity: string | number | TinyBig | Big): TinyBig;
-
-declare function gweiToEther(gweiQuantity: string | number | TinyBig | Big): TinyBig;
-
-declare function hashMessage(message: Bytes | string): string;
-
-declare function isAddress(address: string): boolean;
-
-declare function keccak256(data: BytesLike): string;
-
-declare function pack(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;
-declare function solidityKeccak256(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;
-
-declare function splitSignature(signature: SignatureLike): Signature;
-
-declare function toChecksumAddress(address: string): string;
-
-declare function toUtf8Bytes(data: string): Uint8Array;
-
-declare function weiToEther(weiQuantity: string | number | TinyBig | Big): TinyBig;
-
-export { AlchemyProvider, BaseContract, type BlockResponse, type BlockTag, type BlockTransactionResponse, type Bytes, type BytesLike, type BytesLikeWithNumber, type ConstructorOptions, Contract, type ContractTypes, type DataOptions, FallthroughProvider, type Filter, type FilterByBlockHash, type Hexable, type JSONABI, type JSONABIArgument, JsonRpcProvider, type Log, type Network, type RPCBlock, type RPCLog, type RPCTransaction, type RPCTransactionReceipt, type RPCTransactionRequest, type Signature, type SignatureLike, TinyBig, type TransactionReceipt, type TransactionRequest, type TransactionResponse, 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 };
+export { AlchemyProvider, BaseContract, type BlockResponse, type BlockTag, type BlockTransactionResponse, BytesLike, type ConstructorOptions, Contract, type ContractTypes, FallthroughProvider, type Filter, type FilterByBlockHash, type JSONABI, type JSONABIArgument, JsonRpcProvider, type Log, type Network, type RPCBlock, type RPCLog, type RPCTransaction, type RPCTransactionReceipt, type RPCTransactionRequest, TinyBig, type TransactionReceipt, type TransactionRequest, type TransactionResponse, jsonRpcProvider };