quantumcoin 7.0.2 → 7.0.4

package/src/utils/index.d.ts

@@ -1,55 +1,65 @@
-declare const _exports: {
-    formatUnits: typeof import("./units").formatUnits;
-    parseUnits: typeof import("./units").parseUnits;
-    formatEther: typeof import("./units").formatEther;
-    parseEther: typeof import("./units").parseEther;
-    WeiPerEther: bigint;
-    Result: typeof import("./result").Result;
-    checkResultErrors: typeof import("./result").checkResultErrors;
-    encodeRlp: typeof import("./rlp").encodeRlp;
-    decodeRlp: typeof import("./rlp").decodeRlp;
-    keccak256: typeof import("./hashing").keccak256;
-    sha256: typeof import("./hashing").sha256;
-    sha512: typeof import("./hashing").sha512;
-    ripemd160: typeof import("./hashing").ripemd160;
-    id: typeof import("./hashing").id;
-    randomBytes: typeof import("./hashing").randomBytes;
-    computeHmac: typeof import("./hashing").computeHmac;
-    pbkdf2: typeof import("./hashing").pbkdf2;
-    scrypt: typeof import("./hashing").scrypt;
-    scryptSync: typeof import("./hashing").scryptSync;
-    toUtf8String: typeof import("./encoding").toUtf8String;
-    toUtf8Bytes: typeof import("./encoding").toUtf8Bytes;
-    toHex: typeof import("./encoding").toHex;
-    hexlify: typeof import("./encoding").hexlify;
-    arrayify: typeof import("./encoding").arrayify;
-    concat: typeof import("./encoding").concat;
-    stripZerosLeft: typeof import("./encoding").stripZerosLeft;
-    encodeBytes32String: typeof import("./encoding").encodeBytes32String;
-    decodeBytes32String: typeof import("./encoding").decodeBytes32String;
-    decodeBase58: typeof import("./encoding").decodeBase58;
-    decodeBase64: typeof import("./encoding").decodeBase64;
-    encodeBase58: typeof import("./encoding").encodeBase58;
-    encodeBase64: typeof import("./encoding").encodeBase64;
-    toUtf8CodePoints: typeof import("./encoding").toUtf8CodePoints;
-    isHexString: typeof import("./encoding").isHexString;
-    isBytesLike: typeof import("./encoding").isBytesLike;
-    zeroPad: typeof import("./encoding").zeroPad;
-    zeroPadValue: typeof import("./encoding").zeroPadValue;
-    solidityPacked: typeof import("./encoding").solidityPacked;
-    solidityPackedKeccak256: typeof import("./encoding").solidityPackedKeccak256;
-    solidityPackedSha256: typeof import("./encoding").solidityPackedSha256;
-    bytesToHex: typeof import("./encoding").bytesToHex;
-    hexToBytes: typeof import("./encoding").hexToBytes;
-    isAddress: typeof import("./address").isAddress;
-    getAddress: typeof import("./address").getAddress;
-    isAddressable: typeof import("./address").isAddressable;
-    resolveAddress: typeof import("./address").resolveAddress;
-    getContractAddress: typeof import("./address").getContractAddress;
-    getCreateAddress: typeof import("./address").getCreateAddress;
-    getCreate2Address: typeof import("./address").getCreate2Address;
-    computeAddress: typeof import("./address").computeAddress;
-    verifyMessage: typeof import("./address").verifyMessage;
-    recoverAddress: typeof import("./address").recoverAddress;
-};
-export = _exports;
+declare const _exports: {
+    formatUnits(value: import("./units").BigNumberish, decimals?: number | undefined): string;
+    parseUnits(value: string, decimals?: number | undefined): bigint;
+    formatEther(value: import("./units").BigNumberish): string;
+    parseEther(value: string): bigint;
+    WeiPerEther: bigint;
+    checkResultErrors(result: any): Array<{
+        error: Error;
+        path: Array<string | number>;
+    }>;
+    Result: typeof import("./result").Result;
+    encodeRlp(value: any): string;
+    decodeRlp(data: string): any;
+    keccak256(data: string | Uint8Array): string;
+    hashMessage(message: string | Uint8Array): string;
+    sha256(data: string | Uint8Array): string;
+    sha512(data: string | Uint8Array): string;
+    ripemd160(data: string | Uint8Array): string;
+    id(text: string): string;
+    randomBytes(length: number): Uint8Array;
+    computeHmac(algorithm: string, key: string | Uint8Array, data: string | Uint8Array): string;
+    pbkdf2(password: string | Uint8Array, salt: string | Uint8Array, iterations: number, keylen: number, algorithm?: string | undefined): string;
+    scrypt(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): Promise<string>;
+    scryptSync(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): string;
+    toUtf8String(data: import("./encoding").BytesLike): string;
+    toUtf8Bytes(str: string): Uint8Array;
+    toHex(data: import("./encoding").BytesLike): string;
+    hexlify(data: import("./encoding").BytesLike): string;
+    arrayify(data: import("./encoding").BytesLike): Uint8Array;
+    concat(items: import("./encoding").BytesLike[]): string;
+    stripZerosLeft(data: import("./encoding").BytesLike): string;
+    encodeBytes32String(text: string): string;
+    decodeBytes32String(bytes: import("./encoding").BytesLike): string;
+    decodeBase58(data: string): Uint8Array;
+    decodeBase64(data: string): Uint8Array;
+    encodeBase58(data: import("./encoding").BytesLike): string;
+    encodeBase64(data: import("./encoding").BytesLike): string;
+    toUtf8CodePoints(str: string): number[];
+    isBytesLike(value: any): boolean;
+    zeroPad(value: import("./encoding").BytesLike, length: number): string;
+    zeroPadValue(value: import("./encoding").BytesLike, length: number): string;
+    solidityPacked(): void;
+    solidityPackedKeccak256(): void;
+    solidityPackedSha256(): void;
+    isHexString: typeof import("./encoding").isHexString;
+    bytesToHex: typeof import("./encoding").bytesToHex;
+    hexToBytes: typeof import("./encoding").hexToBytes;
+    isAddress(address: string): boolean;
+    getAddress(address: string): string;
+    isAddressable(value: any): boolean;
+    resolveAddress(target: any): string | Promise<string>;
+    getContractAddress(tx: {
+        from: string;
+        nonce: number;
+    }): string;
+    getCreateAddress(tx: {
+        from: string;
+        nonce: number;
+    }): string;
+    getCreate2Address(from: string, salt: string, initCodeHash: string): string;
+    computeAddress(key: string | Uint8Array): string;
+    verifyMessage(message: string | Uint8Array, signature: string): string;
+    recoverAddress(message: string | Uint8Array, signature: string): string;
+};
+export = _exports;

package/src/utils/index.js

@@ -1,13 +1,13 @@
-/**
- * @fileoverview Utilities export barrel.
- */
-
-module.exports = {
-  ...require("./address"),
-  ...require("./encoding"),
-  ...require("./hashing"),
-  ...require("./rlp"),
-  ...require("./result"),
-  ...require("./units"),
-};
-
+/**
+ * @fileoverview Utilities export barrel.
+ */
+
+module.exports = {
+  ...require("./address"),
+  ...require("./encoding"),
+  ...require("./hashing"),
+  ...require("./rlp"),
+  ...require("./result"),
+  ...require("./units"),
+};
+

package/src/utils/result.d.ts

@@ -1,57 +1,57 @@
-/**
- * @fileoverview Result utility (ethers.js v6 compatible).
- *
- * ethers.js Result is an Array-like with optional named keys.
- * This simplified implementation covers the common patterns used in this SDK.
- */
-export class Result extends Array<any> {
-    /**
-     * @param {Array<any>} items
-     * @param {Array<null|string>=} keys
-     * @returns {Result}
-     */
-    static fromItems(items: Array<any>, keys?: Array<null | string> | undefined): Result;
-    /**
-     * @param {any[]=} items
-     * @param {(null|string)[]=} keys
-     */
-    constructor(items?: any[] | undefined, keys?: (null | string)[] | undefined);
-    /** @type {(null|string)[]|null} */
-    _keys: (null | string)[] | null;
-    /**
-     * Get a value by key.
-     * @param {string} name
-     * @returns {any}
-     */
-    getValue(name: string): any;
-    /**
-     * Convert to array (optionally deep).
-     * @param {boolean=} deep
-     * @returns {any[]}
-     */
-    toArray(deep?: boolean | undefined): any[];
-    /**
-     * Convert to object (optionally deep).
-     * @param {boolean=} deep
-     * @returns {Record<string, any>}
-     */
-    toObject(deep?: boolean | undefined): Record<string, any>;
-}
-/**
- * Scan a decoded Result (or nested structure) for embedded Error objects.
- *
- * ethers.js uses this to surface nested decode errors (especially for tuples
- * and structs). This lightweight implementation walks:
- * - Result instances (by index; prefers named keys in the path when available)
- * - Arrays
- * - Plain objects (for struct-like outputs)
- *
- * It is cycle-safe.
- *
- * @param {any} result
- * @returns {Array<{ error: Error, path: Array<string|number> }>}
- */
-export function checkResultErrors(result: any): Array<{
-    error: Error;
-    path: Array<string | number>;
-}>;
+/**
+ * @fileoverview Result utility (ethers.js v6 compatible).
+ *
+ * ethers.js Result is an Array-like with optional named keys.
+ * This simplified implementation covers the common patterns used in this SDK.
+ */
+export class Result extends Array<any> {
+    /**
+     * @param {Array<any>} items
+     * @param {Array<null|string>=} keys
+     * @returns {Result}
+     */
+    static fromItems(items: Array<any>, keys?: Array<null | string> | undefined): Result;
+    /**
+     * @param {any[]=} items
+     * @param {(null|string)[]=} keys
+     */
+    constructor(items?: any[] | undefined, keys?: (null | string)[] | undefined);
+    /** @type {(null|string)[]|null} */
+    _keys: (null | string)[] | null;
+    /**
+     * Get a value by key.
+     * @param {string} name
+     * @returns {any}
+     */
+    getValue(name: string): any;
+    /**
+     * Convert to array (optionally deep).
+     * @param {boolean=} deep
+     * @returns {any[]}
+     */
+    toArray(deep?: boolean | undefined): any[];
+    /**
+     * Convert to object (optionally deep).
+     * @param {boolean=} deep
+     * @returns {Record<string, any>}
+     */
+    toObject(deep?: boolean | undefined): Record<string, any>;
+}
+/**
+ * Scan a decoded Result (or nested structure) for embedded Error objects.
+ *
+ * ethers.js uses this to surface nested decode errors (especially for tuples
+ * and structs). This lightweight implementation walks:
+ * - Result instances (by index; prefers named keys in the path when available)
+ * - Arrays
+ * - Plain objects (for struct-like outputs)
+ *
+ * It is cycle-safe.
+ *
+ * @param {any} result
+ * @returns {Array<{ error: Error, path: Array<string|number> }>}
+ */
+export function checkResultErrors(result: any): Array<{
+    error: Error;
+    path: Array<string | number>;
+}>;

package/src/utils/result.js

@@ -1,128 +1,128 @@
-/**
- * @fileoverview Result utility (ethers.js v6 compatible).
- *
- * ethers.js Result is an Array-like with optional named keys.
- * This simplified implementation covers the common patterns used in this SDK.
- */
-
-class Result extends Array {
-  /**
-   * @param {any[]=} items
-   * @param {(null|string)[]=} keys
-   */
-  constructor(items, keys) {
-    super();
-    if (Array.isArray(items)) this.push(...items);
-    /** @type {(null|string)[]|null} */
-    this._keys = Array.isArray(keys) ? keys : null;
-
-    if (this._keys) {
-      for (let i = 0; i < this._keys.length; i++) {
-        const k = this._keys[i];
-        if (k) this[k] = this[i];
-      }
-    }
-  }
-
-  /**
-   * @param {Array<any>} items
-   * @param {Array<null|string>=} keys
-   * @returns {Result}
-   */
-  static fromItems(items, keys) {
-    return new Result(items, keys);
-  }
-
-  /**
-   * Get a value by key.
-   * @param {string} name
-   * @returns {any}
-   */
-  getValue(name) {
-    return this[name];
-  }
-
-  /**
-   * Convert to array (optionally deep).
-   * @param {boolean=} deep
-   * @returns {any[]}
-   */
-  toArray(deep) {
-    if (!deep) return Array.from(this);
-    return Array.from(this).map((v) => (v instanceof Result ? v.toArray(true) : v));
-  }
-
-  /**
-   * Convert to object (optionally deep).
-   * @param {boolean=} deep
-   * @returns {Record<string, any>}
-   */
-  toObject(deep) {
-    const out = {};
-    if (!this._keys) return out;
-    for (const k of this._keys) {
-      if (!k) continue;
-      const v = this[k];
-      out[k] = deep && v instanceof Result ? v.toObject(true) : v;
-    }
-    return out;
-  }
-}
-
-/**
- * Scan a decoded Result (or nested structure) for embedded Error objects.
- *
- * ethers.js uses this to surface nested decode errors (especially for tuples
- * and structs). This lightweight implementation walks:
- * - Result instances (by index; prefers named keys in the path when available)
- * - Arrays
- * - Plain objects (for struct-like outputs)
- *
- * It is cycle-safe.
- *
- * @param {any} result
- * @returns {Array<{ error: Error, path: Array<string|number> }>}
- */
-function checkResultErrors(result) {
-  /** @type {Array<{ error: Error, path: Array<string|number> }>} */
-  const out = [];
-  const seen = new WeakSet();
-
-  /**
-   * @param {any} value
-   * @param {Array<string|number>} path
-   */
-  function walk(value, path) {
-    if (value instanceof Error) {
-      out.push({ error: value, path });
-      return;
-    }
-    if (!value || (typeof value !== "object" && typeof value !== "function")) return;
-    if (seen.has(value)) return;
-    seen.add(value);
-
-    // Prefer walking Result/Array by index to avoid duplicates (Result also has named keys).
-    if (value instanceof Result || Array.isArray(value)) {
-      const keys = value instanceof Result ? value._keys : null;
-      for (let i = 0; i < value.length; i++) {
-        const k = Array.isArray(keys) && keys[i] ? keys[i] : i;
-        walk(value[i], path.concat([k]));
-      }
-      return;
-    }
-
-    // Walk only plain objects to avoid traversing things like Buffers, Dates, etc.
-    const proto = Object.getPrototypeOf(value);
-    if (proto === Object.prototype || proto === null) {
-      for (const k of Object.keys(value)) {
-        walk(value[k], path.concat([k]));
-      }
-    }
-  }
-
-  walk(result, []);
-  return out;
-}
-
-module.exports = { Result, checkResultErrors };
-
+/**
+ * @fileoverview Result utility (ethers.js v6 compatible).
+ *
+ * ethers.js Result is an Array-like with optional named keys.
+ * This simplified implementation covers the common patterns used in this SDK.
+ */
+
+class Result extends Array {
+  /**
+   * @param {any[]=} items
+   * @param {(null|string)[]=} keys
+   */
+  constructor(items, keys) {
+    super();
+    if (Array.isArray(items)) this.push(...items);
+    /** @type {(null|string)[]|null} */
+    this._keys = Array.isArray(keys) ? keys : null;
+
+    if (this._keys) {
+      for (let i = 0; i < this._keys.length; i++) {
+        const k = this._keys[i];
+        if (k) this[k] = this[i];
+      }
+    }
+  }
+
+  /**
+   * @param {Array<any>} items
+   * @param {Array<null|string>=} keys
+   * @returns {Result}
+   */
+  static fromItems(items, keys) {
+    return new Result(items, keys);
+  }
+
+  /**
+   * Get a value by key.
+   * @param {string} name
+   * @returns {any}
+   */
+  getValue(name) {
+    return this[name];
+  }
+
+  /**
+   * Convert to array (optionally deep).
+   * @param {boolean=} deep
+   * @returns {any[]}
+   */
+  toArray(deep) {
+    if (!deep) return Array.from(this);
+    return Array.from(this).map((v) => (v instanceof Result ? v.toArray(true) : v));
+  }
+
+  /**
+   * Convert to object (optionally deep).
+   * @param {boolean=} deep
+   * @returns {Record<string, any>}
+   */
+  toObject(deep) {
+    const out = {};
+    if (!this._keys) return out;
+    for (const k of this._keys) {
+      if (!k) continue;
+      const v = this[k];
+      out[k] = deep && v instanceof Result ? v.toObject(true) : v;
+    }
+    return out;
+  }
+}
+
+/**
+ * Scan a decoded Result (or nested structure) for embedded Error objects.
+ *
+ * ethers.js uses this to surface nested decode errors (especially for tuples
+ * and structs). This lightweight implementation walks:
+ * - Result instances (by index; prefers named keys in the path when available)
+ * - Arrays
+ * - Plain objects (for struct-like outputs)
+ *
+ * It is cycle-safe.
+ *
+ * @param {any} result
+ * @returns {Array<{ error: Error, path: Array<string|number> }>}
+ */
+function checkResultErrors(result) {
+  /** @type {Array<{ error: Error, path: Array<string|number> }>} */
+  const out = [];
+  const seen = new WeakSet();
+
+  /**
+   * @param {any} value
+   * @param {Array<string|number>} path
+   */
+  function walk(value, path) {
+    if (value instanceof Error) {
+      out.push({ error: value, path });
+      return;
+    }
+    if (!value || (typeof value !== "object" && typeof value !== "function")) return;
+    if (seen.has(value)) return;
+    seen.add(value);
+
+    // Prefer walking Result/Array by index to avoid duplicates (Result also has named keys).
+    if (value instanceof Result || Array.isArray(value)) {
+      const keys = value instanceof Result ? value._keys : null;
+      for (let i = 0; i < value.length; i++) {
+        const k = Array.isArray(keys) && keys[i] ? keys[i] : i;
+        walk(value[i], path.concat([k]));
+      }
+      return;
+    }
+
+    // Walk only plain objects to avoid traversing things like Buffers, Dates, etc.
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null) {
+      for (const k of Object.keys(value)) {
+        walk(value[k], path.concat([k]));
+      }
+    }
+  }
+
+  walk(result, []);
+  return out;
+}
+
+module.exports = { Result, checkResultErrors };
+

package/src/utils/rlp.d.ts

@@ -1,12 +1,12 @@
-/**
- * RLP-encode a value.
- * @param {any} value
- * @returns {string}
- */
-export function encodeRlp(value: any): string;
-/**
- * RLP-decode a hex string.
- * @param {string} data
- * @returns {any}
- */
-export function decodeRlp(data: string): any;
+/**
+ * RLP-encode a value.
+ * @param {any} value
+ * @returns {string}
+ */
+export function encodeRlp(value: any): string;
+/**
+ * RLP-decode a hex string.
+ * @param {string} data
+ * @returns {any}
+ */
+export function decodeRlp(data: string): any;