quantumcoin 6.14.5 → 7.0.2

package/src/utils/hashing.js

@@ -0,0 +1,298 @@
+/**
+ * @fileoverview Hash utilities (ethers.js v6 compatible names).
+ *
+ * Where possible, we use Node's built-in crypto module. For keccak256,
+ * we prefer a native OpenSSL implementation if available, otherwise we
+ * fall back to a small pure-JS Keccak-256 implementation.
+ */
+
+const crypto = require("crypto");
+const { arrayify, bytesToHex, utf8ToBytes } = require("../internal/hex");
+
+const _MASK64 = (1n << 64n) - 1n;
+
+function _rotl64(x, n) {
+  const nn = BigInt(n);
+  return ((x << nn) | (x >> (64n - nn))) & _MASK64;
+}
+
+function _readU64LE(bytes, off) {
+  let x = 0n;
+  for (let i = 0; i < 8; i++) {
+    x |= BigInt(bytes[off + i]) << (8n * BigInt(i));
+  }
+  return x;
+}
+
+function _writeU64LE(out, off, x) {
+  let v = x & _MASK64;
+  for (let i = 0; i < 8; i++) {
+    out[off + i] = Number((v >> (8n * BigInt(i))) & 0xffn);
+  }
+}
+
+// Keccak-f[1600] round constants
+const _RC = [
+  0x0000000000000001n, 0x0000000000008082n, 0x800000000000808an, 0x8000000080008000n,
+  0x000000000000808bn, 0x0000000080000001n, 0x8000000080008081n, 0x8000000000008009n,
+  0x000000000000008an, 0x0000000000000088n, 0x0000000080008009n, 0x000000008000000an,
+  0x000000008000808bn, 0x800000000000008bn, 0x8000000000008089n, 0x8000000000008003n,
+  0x8000000000008002n, 0x8000000000000080n, 0x000000000000800an, 0x800000008000000an,
+  0x8000000080008081n, 0x8000000000008080n, 0x0000000080000001n, 0x8000000080008008n,
+];
+
+// Rotation offsets (rho step)
+const _R = [
+  // Indexed by lane index (x + 5*y) where x,y in [0..4]
+  // (This is the standard Keccak rho offsets table, flattened in y-major order.)
+  0, 1, 62, 28, 27,
+  36, 44, 6, 55, 20,
+  3, 10, 43, 25, 39,
+  41, 45, 15, 21, 8,
+  18, 2, 61, 56, 14,
+];
+
+// Pi step mapping: index -> newIndex
+const _PI = [
+  0, 10, 20, 5, 15,
+  16, 1, 11, 21, 6,
+  7, 17, 2, 12, 22,
+  23, 8, 18, 3, 13,
+  14, 24, 9, 19, 4,
+];
+
+function _keccakF1600(state) {
+  const b = new Array(25);
+  const c = new Array(5);
+  const d = new Array(5);
+
+  for (let round = 0; round < 24; round++) {
+    // Theta
+    for (let x = 0; x < 5; x++) {
+      c[x] = state[x] ^ state[x + 5] ^ state[x + 10] ^ state[x + 15] ^ state[x + 20];
+    }
+    for (let x = 0; x < 5; x++) {
+      d[x] = c[(x + 4) % 5] ^ _rotl64(c[(x + 1) % 5], 1);
+    }
+    for (let i = 0; i < 25; i++) {
+      state[i] = (state[i] ^ d[i % 5]) & _MASK64;
+    }
+
+    // Rho + Pi
+    for (let i = 0; i < 25; i++) {
+      b[_PI[i]] = _rotl64(state[i], _R[i]);
+    }
+
+    // Chi
+    for (let y = 0; y < 5; y++) {
+      const row = y * 5;
+      for (let x = 0; x < 5; x++) {
+        state[row + x] = (b[row + x] ^ ((~b[row + ((x + 1) % 5)]) & b[row + ((x + 2) % 5)])) & _MASK64;
+      }
+    }
+
+    // Iota
+    state[0] = (state[0] ^ _RC[round]) & _MASK64;
+  }
+}
+
+function _keccak256Bytes(bytes) {
+  // Keccak-256: rate=1088 bits => 136 bytes
+  const rate = 136;
+  const outLen = 32;
+  const state = new Array(25).fill(0n);
+
+  let offset = 0;
+  while (offset + rate <= bytes.length) {
+    for (let i = 0; i < rate / 8; i++) {
+      state[i] = (state[i] ^ _readU64LE(bytes, offset + i * 8)) & _MASK64;
+    }
+    _keccakF1600(state);
+    offset += rate;
+  }
+
+  // Final block + padding (keccak pad10*1 with domain 0x01)
+  const block = new Uint8Array(rate);
+  const remaining = bytes.length - offset;
+  block.set(bytes.slice(offset), 0);
+  block[remaining] = 0x01;
+  block[rate - 1] |= 0x80;
+
+  for (let i = 0; i < rate / 8; i++) {
+    state[i] = (state[i] ^ _readU64LE(block, i * 8)) & _MASK64;
+  }
+  _keccakF1600(state);
+
+  const out = new Uint8Array(outLen);
+  let outOff = 0;
+  let lane = 0;
+  while (outOff < outLen) {
+    const tmp = new Uint8Array(8);
+    _writeU64LE(tmp, 0, state[lane]);
+    const take = Math.min(8, outLen - outOff);
+    out.set(tmp.slice(0, take), outOff);
+    outOff += take;
+    lane++;
+  }
+  return out;
+}
+
+function _hash(alg, data) {
+  const bytes = arrayify(data);
+  return bytesToHex(crypto.createHash(alg).update(Buffer.from(bytes)).digest());
+}
+
+/**
+ * keccak256 hash of BytesLike.
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+function keccak256(data) {
+  const bytes = arrayify(data);
+  const hashes = crypto.getHashes();
+
+  // Prefer native keccak if available (varies by Node/OpenSSL build).
+  if (hashes.includes("keccak256")) {
+    return bytesToHex(crypto.createHash("keccak256").update(Buffer.from(bytes)).digest());
+  }
+  if (hashes.includes("keccak-256")) {
+    return bytesToHex(crypto.createHash("keccak-256").update(Buffer.from(bytes)).digest());
+  }
+
+  // Fallback: pure JS Keccak-256
+  return bytesToHex(_keccak256Bytes(bytes));
+}
+
+/**
+ * sha256 hash of BytesLike.
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+function sha256(data) {
+  return _hash("sha256", data);
+}
+
+/**
+ * sha512 hash of BytesLike.
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+function sha512(data) {
+  return _hash("sha512", data);
+}
+
+/**
+ * ripemd160 hash of BytesLike.
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+function ripemd160(data) {
+  return _hash("ripemd160", data);
+}
+
+/**
+ * ethers-style id(text) => keccak256(utf8Bytes(text))
+ * @param {string} text
+ * @returns {string}
+ */
+function id(text) {
+  return keccak256(utf8ToBytes(text));
+}
+
+/**
+ * Generate cryptographically strong random bytes.
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+function randomBytes(length) {
+  return new Uint8Array(crypto.randomBytes(length));
+}
+
+/**
+ * Compute HMAC over data.
+ * @param {string} algorithm
+ * @param {string|Uint8Array} key
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+function computeHmac(algorithm, key, data) {
+  const k = arrayify(key);
+  const d = arrayify(data);
+  const h = crypto.createHmac(algorithm, Buffer.from(k)).update(Buffer.from(d)).digest();
+  return bytesToHex(new Uint8Array(h));
+}
+
+/**
+ * PBKDF2 (sync) helper returning hex string.
+ * @param {string|Uint8Array} password
+ * @param {string|Uint8Array} salt
+ * @param {number} iterations
+ * @param {number} keylen
+ * @param {string=} algorithm
+ * @returns {string}
+ */
+function pbkdf2(password, salt, iterations, keylen, algorithm) {
+  const p = arrayify(password);
+  const s = arrayify(salt);
+  const a = algorithm || "sha256";
+  const out = crypto.pbkdf2Sync(Buffer.from(p), Buffer.from(s), iterations, keylen, a);
+  return bytesToHex(new Uint8Array(out));
+}
+
+/**
+ * scrypt (async) helper returning hex string.
+ * @param {string|Uint8Array} password
+ * @param {string|Uint8Array} salt
+ * @param {number} N
+ * @param {number} r
+ * @param {number} p
+ * @param {number} dkLen
+ * @returns {Promise<string>}
+ */
+function scrypt(password, salt, N, r, p, dkLen) {
+  const pw = arrayify(password);
+  const sa = arrayify(salt);
+  return new Promise((resolve, reject) => {
+    crypto.scrypt(
+      Buffer.from(pw),
+      Buffer.from(sa),
+      dkLen,
+      { N, r, p, maxmem: 128 * 1024 * 1024 },
+      (err, derived) => {
+        if (err) return reject(err);
+        resolve(bytesToHex(new Uint8Array(derived)));
+      },
+    );
+  });
+}
+
+/**
+ * scrypt (sync) helper returning hex string.
+ * @param {string|Uint8Array} password
+ * @param {string|Uint8Array} salt
+ * @param {number} N
+ * @param {number} r
+ * @param {number} p
+ * @param {number} dkLen
+ * @returns {string}
+ */
+function scryptSync(password, salt, N, r, p, dkLen) {
+  const pw = arrayify(password);
+  const sa = arrayify(salt);
+  const out = crypto.scryptSync(Buffer.from(pw), Buffer.from(sa), dkLen, { N, r, p, maxmem: 128 * 1024 * 1024 });
+  return bytesToHex(new Uint8Array(out));
+}
+
+module.exports = {
+  keccak256,
+  sha256,
+  sha512,
+  ripemd160,
+  id,
+  randomBytes,
+  computeHmac,
+  pbkdf2,
+  scrypt,
+  scryptSync,
+};
+

package/src/utils/index.d.ts

@@ -0,0 +1,55 @@
+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;

package/src/utils/index.js

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

package/src/utils/result.d.ts

@@ -0,0 +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>;
+}>;

package/src/utils/result.js

@@ -0,0 +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 };
+

package/src/utils/rlp.d.ts

@@ -0,0 +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;