quantumcoin 7.0.15 → 8.0.1

package/src/utils/hashing.d.ts

@@ -1,76 +1,97 @@
-/**
- * keccak256 hash of BytesLike.
- * @param {string|Uint8Array} data
- * @returns {string}
- */
-export function keccak256(data: string | Uint8Array): string;
-/**
- * sha256 hash of BytesLike.
- * @param {string|Uint8Array} data
- * @returns {string}
- */
-export function sha256(data: string | Uint8Array): string;
-/**
- * sha512 hash of BytesLike.
- * @param {string|Uint8Array} data
- * @returns {string}
- */
-export function sha512(data: string | Uint8Array): string;
-/**
- * ripemd160 hash of BytesLike.
- * @param {string|Uint8Array} data
- * @returns {string}
- */
-export function ripemd160(data: string | Uint8Array): string;
-/**
- * ethers-style id(text) => keccak256(utf8Bytes(text))
- * @param {string} text
- * @returns {string}
- */
-export function id(text: string): string;
-/**
- * Generate cryptographically strong random bytes.
- * @param {number} length
- * @returns {Uint8Array}
- */
-export function randomBytes(length: number): Uint8Array;
-/**
- * Compute HMAC over data.
- * @param {string} algorithm
- * @param {string|Uint8Array} key
- * @param {string|Uint8Array} data
- * @returns {string}
- */
-export function computeHmac(algorithm: string, key: string | Uint8Array, data: string | Uint8Array): string;
-/**
- * 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}
- */
-export function pbkdf2(password: string | Uint8Array, salt: string | Uint8Array, iterations: number, keylen: number, algorithm?: string | undefined): string;
-/**
- * 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>}
- */
-export function scrypt(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): Promise<string>;
-/**
- * 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}
- */
-export function scryptSync(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): string;
+/**
+ * keccak256 hash of BytesLike.
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+export function keccak256(data: string | Uint8Array): string;
+/**
+ * sha256 hash of BytesLike.
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+export function sha256(data: string | Uint8Array): string;
+/**
+ * sha512 hash of BytesLike.
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+export function sha512(data: string | Uint8Array): string;
+/**
+ * ripemd160 hash of BytesLike.
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+export function ripemd160(data: string | Uint8Array): string;
+/**
+ * ethers-style id(text) => keccak256(utf8Bytes(text))
+ * @param {string} text
+ * @returns {string}
+ */
+export function id(text: string): string;
+/**
+ * Compute the EIP-191 "personal message" digest for a message.
+ *
+ * QuantumCoin uses the exact same prefix as Ethereum, so this is byte-for-byte
+ * compatible with `personal_sign` in `quantum-coin-go`:
+ *
+ *   keccak256("\x19Ethereum Signed Message:\n" + message.length + message)
+ *
+ * The resulting 32-byte hash is the digest passed to `Wallet.signMessage` /
+ * `Wallet.signMessageSync` and re-derived by `verifyMessage`. The decimal length
+ * prefix counts message BYTES, not characters. A string message is UTF-8
+ * encoded; a Uint8Array (or 0x hex string coerced via `arrayify`) is treated as
+ * raw bytes.
+ *
+ * @param {string|Uint8Array} message The message to hash. Strings are UTF-8 encoded.
+ * @returns {string} 0x-prefixed, 32-byte keccak256 digest.
+ */
+export function hashMessage(message: string | Uint8Array): string;
+/**
+ * Generate cryptographically strong random bytes.
+ *
+ * Uses the platform Web Crypto API (`globalThis.crypto`), which is available in
+ * modern browsers and Node.js 20+.
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+export function randomBytes(length: number): Uint8Array;
+/**
+ * Compute HMAC over data.
+ * @param {string} algorithm "sha256" or "sha512"
+ * @param {string|Uint8Array} key
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+export function computeHmac(algorithm: string, key: string | Uint8Array, data: string | Uint8Array): string;
+/**
+ * PBKDF2 (sync) helper returning hex string.
+ * @param {string|Uint8Array} password
+ * @param {string|Uint8Array} salt
+ * @param {number} iterations
+ * @param {number} keylen
+ * @param {string=} algorithm "sha256" (default) or "sha512"
+ * @returns {string}
+ */
+export function pbkdf2(password: string | Uint8Array, salt: string | Uint8Array, iterations: number, keylen: number, algorithm?: string | undefined): string;
+/**
+ * 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>}
+ */
+export function scrypt(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): Promise<string>;
+/**
+ * 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}
+ */
+export function scryptSync(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): string;

package/src/utils/hashing.js

@@ -1,145 +1,43 @@
 /**
  * @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.
+ * All cryptographic primitives are provided by `quantum-coin-js-sdk`, which
+ * runs in both Node.js and modern browsers (WebAssembly + Web Crypto). This
+ * keeps the SDK platform agnostic and free of Node's built-in `crypto` module.
+ *
+ * NOTE: The underlying primitives require the SDK to be initialized. Call
+ * `Initialize()` (see the `quantumcoin/config` module) before using these
+ * helpers, otherwise a `NOT_INITIALIZED` error is thrown.
  */
 
-const crypto = require("crypto");
+const qcsdk = require("quantum-coin-js-sdk");
 const { arrayify, bytesToHex, utf8ToBytes } = require("../internal/hex");
+const { makeError } = require("../errors");
 
-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;
-  }
+// quantum-coin-js-sdk returns -1000 from crypto helpers when the SDK has not
+// been initialized yet, and null when the input is invalid.
+const _NOT_INITIALIZED = -1000;
 
-  // 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;
+/**
+ * Convert a byte array returned by a quantum-coin-js-sdk crypto helper into a
+ * normalized hex string, throwing a clear error when the SDK is not
+ * initialized or the operation failed.
+ * @param {number[]|Uint8Array|number|null} result
+ * @param {string} operation
+ * @returns {string}
+ */
+function _hexFromQcsdk(result, operation) {
+  if (result === _NOT_INITIALIZED) {
+    throw makeError(
+      "quantum-coin-js-sdk not initialized; call Initialize() first",
+      "NOT_INITIALIZED",
+      { operation },
+    );
   }
-  _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++;
+  if (result == null || typeof result === "number") {
+    throw makeError(`${operation} failed`, "UNKNOWN_ERROR", { operation });
   }
-  return out;
-}
-
-function _hash(alg, data) {
-  const bytes = arrayify(data);
-  return bytesToHex(crypto.createHash(alg).update(Buffer.from(bytes)).digest());
+  return bytesToHex(result instanceof Uint8Array ? result : Uint8Array.from(result));
 }
 
 /**
@@ -149,18 +47,7 @@ function _hash(alg, data) {
  */
 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));
+  return _hexFromQcsdk(qcsdk.keccak256(bytes), "keccak256");
 }
 
 /**
@@ -169,7 +56,8 @@ function keccak256(data) {
  * @returns {string}
  */
 function sha256(data) {
-  return _hash("sha256", data);
+  const bytes = arrayify(data);
+  return _hexFromQcsdk(qcsdk.sha256(bytes), "sha256");
 }
 
 /**
@@ -178,7 +66,8 @@ function sha256(data) {
  * @returns {string}
  */
 function sha512(data) {
-  return _hash("sha512", data);
+  const bytes = arrayify(data);
+  return _hexFromQcsdk(qcsdk.sha512(bytes), "sha512");
 }
 
 /**
@@ -187,7 +76,8 @@ function sha512(data) {
  * @returns {string}
  */
 function ripemd160(data) {
-  return _hash("ripemd160", data);
+  const bytes = arrayify(data);
+  return _hexFromQcsdk(qcsdk.ripemd160(bytes), "ripemd160");
 }
 
 /**
@@ -199,18 +89,62 @@ function id(text) {
   return keccak256(utf8ToBytes(text));
 }
 
+/**
+ * Compute the EIP-191 "personal message" digest for a message.
+ *
+ * QuantumCoin uses the exact same prefix as Ethereum, so this is byte-for-byte
+ * compatible with `personal_sign` in `quantum-coin-go`:
+ *
+ *   keccak256("\x19Ethereum Signed Message:\n" + message.length + message)
+ *
+ * The resulting 32-byte hash is the digest passed to `Wallet.signMessage` /
+ * `Wallet.signMessageSync` and re-derived by `verifyMessage`. The decimal length
+ * prefix counts message BYTES, not characters. A string message is UTF-8
+ * encoded; a Uint8Array (or 0x hex string coerced via `arrayify`) is treated as
+ * raw bytes.
+ *
+ * @param {string|Uint8Array} message The message to hash. Strings are UTF-8 encoded.
+ * @returns {string} 0x-prefixed, 32-byte keccak256 digest.
+ */
+function hashMessage(message) {
+  const msgBytes = typeof message === "string" ? utf8ToBytes(message) : arrayify(message);
+  const prefix = utf8ToBytes(`\x19Ethereum Signed Message:\n${msgBytes.length}`);
+  const composed = new Uint8Array(prefix.length + msgBytes.length);
+  composed.set(prefix, 0);
+  composed.set(msgBytes, prefix.length);
+  return keccak256(composed);
+}
+
 /**
  * Generate cryptographically strong random bytes.
+ *
+ * Uses the platform Web Crypto API (`globalThis.crypto`), which is available in
+ * modern browsers and Node.js 20+.
  * @param {number} length
  * @returns {Uint8Array}
  */
 function randomBytes(length) {
-  return new Uint8Array(crypto.randomBytes(length));
+  const webcrypto = typeof globalThis !== "undefined" ? globalThis.crypto : undefined;
+  if (!webcrypto || typeof webcrypto.getRandomValues !== "function") {
+    throw makeError(
+      "secure random source (globalThis.crypto.getRandomValues) not available in this environment",
+      "UNKNOWN_ERROR",
+      { operation: "randomBytes" },
+    );
+  }
+  const out = new Uint8Array(length);
+  // getRandomValues rejects requests larger than 65536 bytes; fill in chunks.
+  const MAX_CHUNK = 65536;
+  for (let offset = 0; offset < length; offset += MAX_CHUNK) {
+    const chunk = out.subarray(offset, Math.min(offset + MAX_CHUNK, length));
+    webcrypto.getRandomValues(chunk);
+  }
+  return out;
 }
 
 /**
  * Compute HMAC over data.
- * @param {string} algorithm
+ * @param {string} algorithm "sha256" or "sha512"
  * @param {string|Uint8Array} key
  * @param {string|Uint8Array} data
  * @returns {string}
@@ -218,8 +152,7 @@ function randomBytes(length) {
 function computeHmac(algorithm, key, data) {
   const k = typeof key === "string" ? utf8ToBytes(key) : arrayify(key);
   const d = typeof data === "string" ? utf8ToBytes(data) : arrayify(data);
-  const h = crypto.createHmac(algorithm, Buffer.from(k)).update(Buffer.from(d)).digest();
-  return bytesToHex(new Uint8Array(h));
+  return _hexFromQcsdk(qcsdk.computeHmac(algorithm, k, d), "computeHmac");
 }
 
 /**
@@ -228,59 +161,44 @@ function computeHmac(algorithm, key, data) {
  * @param {string|Uint8Array} salt
  * @param {number} iterations
  * @param {number} keylen
- * @param {string=} algorithm
+ * @param {string=} algorithm "sha256" (default) or "sha512"
  * @returns {string}
  */
 function pbkdf2(password, salt, iterations, keylen, algorithm) {
   const p = typeof password === "string" ? utf8ToBytes(password) : arrayify(password);
   const s = typeof salt === "string" ? utf8ToBytes(salt) : arrayify(salt);
   const a = algorithm || "sha256";
-  const out = crypto.pbkdf2Sync(Buffer.from(p), Buffer.from(s), iterations, keylen, a);
-  return bytesToHex(new Uint8Array(out));
+  return _hexFromQcsdk(qcsdk.pbkdf2(p, s, iterations, keylen, a), "pbkdf2");
 }
 
 /**
- * scrypt (async) helper returning hex string.
+ * 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 {Promise<string>}
+ * @returns {string}
  */
-function scrypt(password, salt, N, r, p, dkLen) {
+function scryptSync(password, salt, N, r, p, dkLen) {
   const pw = typeof password === "string" ? utf8ToBytes(password) : arrayify(password);
   const sa = typeof salt === "string" ? utf8ToBytes(salt) : 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)));
-      },
-    );
-  });
+  return _hexFromQcsdk(qcsdk.scryptDeriveKey(pw, sa, N, r, p, dkLen), "scrypt");
 }
 
 /**
- * scrypt (sync) helper returning hex string.
+ * 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 {string}
+ * @returns {Promise<string>}
  */
-function scryptSync(password, salt, N, r, p, dkLen) {
-  const pw = typeof password === "string" ? utf8ToBytes(password) : arrayify(password);
-  const sa = typeof salt === "string" ? utf8ToBytes(salt) : arrayify(salt);
-  const out = crypto.scryptSync(Buffer.from(pw), Buffer.from(sa), dkLen, { N, r, p, maxmem: 257 * 1024 * 1024 }); //257 instead of 256 for buffer for compat for N=262144, r=8, p=1
-  return bytesToHex(new Uint8Array(out));
+function scrypt(password, salt, N, r, p, dkLen) {
+  return Promise.resolve().then(() => scryptSync(password, salt, N, r, p, dkLen));
 }
 
 module.exports = {
@@ -289,10 +207,10 @@ module.exports = {
   sha512,
   ripemd160,
   id,
+  hashMessage,
   randomBytes,
   computeHmac,
   pbkdf2,
   scrypt,
   scryptSync,
 };
-

package/src/utils/index.d.ts

@@ -1,4 +1,5 @@
 declare const _exports: {
+    FixedNumber: typeof import("./fixednumber").FixedNumber;
     formatUnits(value: import("./units").BigNumberish, decimals?: number | undefined): string;
     parseUnits(value: string, decimals?: number | undefined): bigint;
     formatEther(value: import("./units").BigNumberish): string;
@@ -16,6 +17,7 @@ declare const _exports: {
     sha512(data: string | Uint8Array): string;
     ripemd160(data: string | Uint8Array): string;
     id(text: string): string;
+    hashMessage(message: string | Uint8Array): 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;
@@ -58,6 +60,5 @@ declare const _exports: {
     }): string;
     getCreate2Address(from: string, salt: string, initCodeHash: string): string;
     computeAddress(key: string | Uint8Array): string;
-    FixedNumber: typeof import("./fixednumber").FixedNumber;
 };
 export = _exports;

package/src/utils/rlp.js

@@ -11,8 +11,8 @@ const { arrayify, bytesToHex, hexToBytes, isHexString, normalizeHex, utf8ToBytes
 function _toBytes(value) {
   if (value == null) return new Uint8Array([]);
 
+  // Node Buffers are Uint8Array subclasses, so this covers both.
   if (value instanceof Uint8Array) return new Uint8Array(value);
-  if (Buffer.isBuffer(value)) return new Uint8Array(value);
 
   if (Array.isArray(value)) {
     // List gets handled elsewhere; here we accept array-of-bytes as a BytesLike.

package/src/wallet/index.d.ts

@@ -1,4 +1,5 @@
 declare const _exports: {
+    verifyMessage(message: string | Uint8Array, signature: string | Uint8Array): string;
     SigningKey: typeof import("./wallet").SigningKey;
     AbstractSigner: typeof import("./wallet").AbstractSigner;
     BaseWallet: typeof import("./wallet").BaseWallet;