essential-eth 0.11.2 → 1.0.0

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

@@ -0,0 +1,9 @@
+declare function etherToGwei(etherQuantity: string | number | bigint): bigint;
+
+declare function etherToWei(etherQuantity: string | number | bigint): bigint;
+
+declare function gweiToEther(gweiQuantity: string | number | bigint): string;
+
+declare function weiToEther(weiQuantity: string | number | bigint): string;
+
+export { etherToGwei, etherToWei, gweiToEther, weiToEther };

package/dist/conversions.js

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

package/dist/index-utils-e8a8adc8.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 | 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;
+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 { 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 };