quantum-coin-js-sdk 2.0.1 → 2.1.1

package/example/node_modules/quantumcoin/src/utils/hashing.js

@@ -1,298 +0,0 @@
-/**
- * @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 = 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));
-}
-
-/**
- * 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 = 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));
-}
-
-/**
- * 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 = 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)));
-      },
-    );
-  });
-}
-
-/**
- * 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 = 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));
-}
-
-module.exports = {
-  keccak256,
-  sha256,
-  sha512,
-  ripemd160,
-  id,
-  randomBytes,
-  computeHmac,
-  pbkdf2,
-  scrypt,
-  scryptSync,
-};
-

package/example/node_modules/quantumcoin/src/utils/index.d.ts

@@ -1,63 +0,0 @@
-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;
-    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;
-    FixedNumber: typeof import("./fixednumber").FixedNumber;
-};
-export = _exports;

package/example/node_modules/quantumcoin/src/utils/index.js

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

package/example/node_modules/quantumcoin/src/utils/result.d.ts

@@ -1,57 +0,0 @@
-/**
- * @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/example/node_modules/quantumcoin/src/utils/result.js

@@ -1,128 +0,0 @@
-/**
- * @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/example/node_modules/quantumcoin/src/utils/rlp.d.ts

@@ -1,12 +0,0 @@
-/**
- * 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;