quantumcoin 7.0.6 → 7.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quantumcoin",
-  "version": "7.0.6",
+  "version": "7.0.8",
   "description": "QuantumCoin SDK - a complete SDK for dapps",
   "main": "index.js",
   "types": "src/index.d.ts",
@@ -90,6 +90,6 @@
   },
   "dependencies": {
     "seed-words": "^1.0.2",
-    "quantum-coin-js-sdk": "1.0.31"
+    "quantum-coin-js-sdk": "1.0.32"
   }
 }

package/src/utils/fixednumber.d.ts

@@ -0,0 +1,57 @@
+import type { BytesLike } from "./encoding";
+
+export type BigNumberish = string | number | bigint;
+
+export type FixedFormat = number | string | {
+    signed?: boolean;
+    width?: number;
+    decimals?: number;
+};
+
+export class FixedNumber {
+    private constructor(guard: any, value: bigint, format: any);
+
+    readonly format: string;
+    readonly _value: string;
+
+    get signed(): boolean;
+    get width(): number;
+    get decimals(): number;
+    get value(): bigint;
+
+    add(other: FixedNumber): FixedNumber;
+    addUnsafe(other: FixedNumber): FixedNumber;
+    sub(other: FixedNumber): FixedNumber;
+    subUnsafe(other: FixedNumber): FixedNumber;
+    mul(other: FixedNumber): FixedNumber;
+    mulUnsafe(other: FixedNumber): FixedNumber;
+    mulSignal(other: FixedNumber): FixedNumber;
+    div(other: FixedNumber): FixedNumber;
+    divUnsafe(other: FixedNumber): FixedNumber;
+    divSignal(other: FixedNumber): FixedNumber;
+
+    cmp(other: FixedNumber): number;
+    eq(other: FixedNumber): boolean;
+    lt(other: FixedNumber): boolean;
+    lte(other: FixedNumber): boolean;
+    gt(other: FixedNumber): boolean;
+    gte(other: FixedNumber): boolean;
+
+    floor(): FixedNumber;
+    ceiling(): FixedNumber;
+    round(decimals?: number): FixedNumber;
+
+    isZero(): boolean;
+    isNegative(): boolean;
+
+    toString(): string;
+    toUnsafeFloat(): number;
+    toFormat(format: FixedFormat): FixedNumber;
+    toHexString(width?: number): string;
+
+    static fromValue(value: BigNumberish, decimals?: number, format?: FixedFormat): FixedNumber;
+    static fromString(value: string, format?: FixedFormat): FixedNumber;
+    static fromBytes(value: BytesLike, format?: FixedFormat): FixedNumber;
+    static from(value: any, format?: FixedFormat): FixedNumber;
+    static isFixedNumber(value: any): value is FixedNumber;
+}

package/src/utils/fixednumber.js

@@ -0,0 +1,366 @@
+/**
+ * @fileoverview Fixed-point arithmetic (ethers.js v5/v6 compatible).
+ *
+ * FixedNumber stores values as a bigint multiplied by 10**decimals,
+ * inside a fixed bit-width field.  All instances are immutable.
+ */
+
+const { makeError, assertArgument, assert } = require("../errors");
+const { arrayify, hexlify, isBytesLike, zeroPad } = require("./encoding");
+
+const BN_N1 = -1n;
+const BN_0 = 0n;
+const BN_1 = 1n;
+const BN_5 = 5n;
+
+const _guard = {};
+
+let _zeros = "0000";
+while (_zeros.length < 80) { _zeros += _zeros; }
+
+function _getTens(decimals) {
+  let z = _zeros;
+  while (z.length < decimals) { z += z; }
+  return BigInt("1" + z.substring(0, decimals));
+}
+
+function _fromTwos(value, width) {
+  const limit = BN_1 << BigInt(width);
+  if (value & (limit >> BN_1)) {
+    return value - limit;
+  }
+  return value;
+}
+
+function _mask(value, width) {
+  return value & ((BN_1 << BigInt(width)) - BN_1);
+}
+
+function _checkValue(val, format, safeOp) {
+  const width = BigInt(format.width);
+  if (format.signed) {
+    const limit = BN_1 << (width - BN_1);
+    assert(safeOp == null || (val >= -limit && val < limit), "overflow", "NUMERIC_FAULT", {
+      operation: safeOp, fault: "overflow", value: val,
+    });
+    if (val > BN_0) {
+      val = _fromTwos(_mask(val, width), format.width);
+    } else if (val < BN_0) {
+      val = -_fromTwos(_mask(-val, width), format.width);
+    }
+  } else {
+    const limit = BN_1 << width;
+    assert(safeOp == null || (val >= BN_0 && val < limit), "overflow", "NUMERIC_FAULT", {
+      operation: safeOp, fault: "overflow", value: val,
+    });
+    val = ((val % limit) + limit) % limit & (limit - BN_1);
+  }
+  return val;
+}
+
+/**
+ * @param {import("./units").BigNumberish} value
+ * @returns {bigint}
+ */
+function _getBigInt(value) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") {
+    assertArgument(Number.isInteger(value), "invalid numeric value", "value", value);
+    return BigInt(value);
+  }
+  if (typeof value === "string") {
+    const v = value.trim();
+    assertArgument(v.length > 0 && /^-?(?:0x[0-9a-fA-F]+|[0-9]+)$/.test(v), "invalid BigNumberish string", "value", value);
+    return BigInt(v);
+  }
+  assertArgument(false, "invalid BigNumberish", "value", value);
+}
+
+function _getFormat(value) {
+  if (typeof value === "number") { value = `fixed128x${value}`; }
+
+  let signed = true;
+  let width = 128;
+  let decimals = 18;
+
+  if (typeof value === "string") {
+    if (value === "fixed") {
+      // defaults
+    } else if (value === "ufixed") {
+      signed = false;
+    } else {
+      const match = value.match(/^(u?)fixed([0-9]+)x([0-9]+)$/);
+      assertArgument(match, "invalid fixed format", "format", value);
+      signed = match[1] !== "u";
+      width = parseInt(match[2]);
+      decimals = parseInt(match[3]);
+    }
+  } else if (value != null && typeof value === "object") {
+    const check = (key, type, defaultValue) => {
+      if (value[key] == null) return defaultValue;
+      assertArgument(typeof value[key] === type,
+        `invalid fixed format (${key} not ${type})`, `format.${key}`, value[key]);
+      return value[key];
+    };
+    signed = check("signed", "boolean", signed);
+    width = check("width", "number", width);
+    decimals = check("decimals", "number", decimals);
+  }
+
+  assertArgument(width % 8 === 0, "invalid FixedNumber width (not byte aligned)", "format.width", width);
+  assertArgument(decimals <= 80, "invalid FixedNumber decimals (too large)", "format.decimals", decimals);
+
+  const name = (signed ? "" : "u") + "fixed" + String(width) + "x" + String(decimals);
+  return { signed, width, decimals, name };
+}
+
+function _toString(val, decimals) {
+  let negative = "";
+  if (val < BN_0) {
+    negative = "-";
+    val *= BN_N1;
+  }
+  let str = val.toString();
+  if (decimals === 0) return negative + str;
+
+  while (str.length <= decimals) { str = _zeros + str; }
+  const index = str.length - decimals;
+  str = str.substring(0, index) + "." + str.substring(index);
+
+  while (str[0] === "0" && str[1] !== ".") { str = str.substring(1); }
+  while (str[str.length - 1] === "0" && str[str.length - 2] !== ".") { str = str.substring(0, str.length - 1); }
+
+  return negative + str;
+}
+
+class FixedNumber {
+  /**
+   * @param {any} guard
+   * @param {bigint} value
+   * @param {any} format
+   */
+  constructor(guard, value, format) {
+    assertArgument(guard === _guard, "cannot use FixedNumber constructor; use FixedNumber.from", "guard", "INVALID");
+
+    /** @type {bigint} */
+    this._val = value;
+    /** @type {{ signed: boolean, width: number, decimals: number, name: string }} */
+    this._format = format;
+    /** @type {string} */
+    this.format = format.name;
+    /** @type {string} */
+    this._value = _toString(value, format.decimals);
+    /** @type {bigint} */
+    this._tens = _getTens(format.decimals);
+
+    Object.freeze(this);
+  }
+
+  get signed() { return this._format.signed; }
+  get width() { return this._format.width; }
+  get decimals() { return this._format.decimals; }
+  get value() { return this._val; }
+
+  _checkFormat(other) {
+    assertArgument(this.format === other.format,
+      "incompatible format; use fixedNumber.toFormat", "other", other);
+  }
+
+  _checkValue(val, safeOp) {
+    val = _checkValue(val, this._format, safeOp);
+    return new FixedNumber(_guard, val, this._format);
+  }
+
+  // --- Arithmetic -----------------------------------------------------------
+
+  _add(o, safeOp) {
+    this._checkFormat(o);
+    return this._checkValue(this._val + o._val, safeOp);
+  }
+  addUnsafe(other) { return this._add(other); }
+  add(other) { return this._add(other, "add"); }
+
+  _sub(o, safeOp) {
+    this._checkFormat(o);
+    return this._checkValue(this._val - o._val, safeOp);
+  }
+  subUnsafe(other) { return this._sub(other); }
+  sub(other) { return this._sub(other, "sub"); }
+
+  _mul(o, safeOp) {
+    this._checkFormat(o);
+    return this._checkValue((this._val * o._val) / this._tens, safeOp);
+  }
+  mulUnsafe(other) { return this._mul(other); }
+  mul(other) { return this._mul(other, "mul"); }
+
+  mulSignal(other) {
+    this._checkFormat(other);
+    const value = this._val * other._val;
+    assert(value % this._tens === BN_0, "precision lost during signalling mul", "NUMERIC_FAULT", {
+      operation: "mulSignal", fault: "underflow", value: this,
+    });
+    return this._checkValue(value / this._tens, "mulSignal");
+  }
+
+  _div(o, safeOp) {
+    assert(o._val !== BN_0, "division by zero", "NUMERIC_FAULT", {
+      operation: "div", fault: "divide-by-zero", value: this,
+    });
+    this._checkFormat(o);
+    return this._checkValue((this._val * this._tens) / o._val, safeOp);
+  }
+  divUnsafe(other) { return this._div(other); }
+  div(other) { return this._div(other, "div"); }
+
+  divSignal(other) {
+    assert(other._val !== BN_0, "division by zero", "NUMERIC_FAULT", {
+      operation: "div", fault: "divide-by-zero", value: this,
+    });
+    this._checkFormat(other);
+    const value = this._val * this._tens;
+    assert(value % other._val === BN_0, "precision lost during signalling div", "NUMERIC_FAULT", {
+      operation: "divSignal", fault: "underflow", value: this,
+    });
+    return this._checkValue(value / other._val, "divSignal");
+  }
+
+  // --- Comparison -----------------------------------------------------------
+
+  cmp(other) {
+    let a = this._val, b = other._val;
+    const delta = this.decimals - other.decimals;
+    if (delta > 0) { b *= _getTens(delta); }
+    else if (delta < 0) { a *= _getTens(-delta); }
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  }
+
+  eq(other) { return this.cmp(other) === 0; }
+  lt(other) { return this.cmp(other) < 0; }
+  lte(other) { return this.cmp(other) <= 0; }
+  gt(other) { return this.cmp(other) > 0; }
+  gte(other) { return this.cmp(other) >= 0; }
+
+  // --- Rounding -------------------------------------------------------------
+
+  floor() {
+    let val = this._val;
+    if (val < BN_0) { val -= this._tens - BN_1; }
+    val = (val / this._tens) * this._tens;
+    return this._checkValue(val, "floor");
+  }
+
+  ceiling() {
+    let val = this._val;
+    if (val > BN_0) { val += this._tens - BN_1; }
+    val = (val / this._tens) * this._tens;
+    return this._checkValue(val, "ceiling");
+  }
+
+  round(decimals) {
+    if (decimals == null) { decimals = 0; }
+    if (decimals >= this.decimals) return this;
+    const delta = this.decimals - decimals;
+    const bump = BN_5 * _getTens(delta - 1);
+    let value = this._val;
+    if (value < BN_0) { value -= bump; } else { value += bump; }
+    const tens = _getTens(delta);
+    value = (value / tens) * tens;
+    _checkValue(value, this._format, "round");
+    return new FixedNumber(_guard, value, this._format);
+  }
+
+  // --- Inspection -----------------------------------------------------------
+
+  isZero() { return this._val === BN_0; }
+  isNegative() { return this._val < BN_0; }
+
+  // --- Conversion -----------------------------------------------------------
+
+  toString() { return this._value; }
+  toUnsafeFloat() { return parseFloat(this.toString()); }
+
+  toFormat(format) {
+    return FixedNumber.fromString(this._value, format);
+  }
+
+  toHexString(width) {
+    let val = this._val;
+    const w = width || this.width;
+    if (this._format.signed && val < BN_0) {
+      val = (BN_1 << BigInt(w)) + val;
+    }
+    let hex = val.toString(16);
+    const byteLen = w / 8;
+    while (hex.length < byteLen * 2) { hex = "0" + hex; }
+    return "0x" + hex;
+  }
+
+  // --- Static factories -----------------------------------------------------
+
+  static fromValue(_value, decimals, _format) {
+    if (decimals == null) { decimals = 0; }
+    const format = _getFormat(_format);
+    let value = _getBigInt(_value);
+    const delta = decimals - format.decimals;
+    if (delta > 0) {
+      const tens = _getTens(delta);
+      assert(value % tens === BN_0, "value loses precision for format", "NUMERIC_FAULT", {
+        operation: "fromValue", fault: "underflow", value: _value,
+      });
+      value /= tens;
+    } else if (delta < 0) {
+      value *= _getTens(-delta);
+    }
+    _checkValue(value, format, "fromValue");
+    return new FixedNumber(_guard, value, format);
+  }
+
+  static fromString(_value, _format) {
+    const match = _value.match(/^(-?)([0-9]*)\.?([0-9]*)$/);
+    assertArgument(match && (match[2].length + match[3].length) > 0,
+      "invalid FixedNumber string value", "value", _value);
+    const format = _getFormat(_format);
+    let whole = match[2] || "0";
+    let decimal = match[3] || "";
+
+    while (decimal.length < format.decimals) { decimal += _zeros; }
+
+    assert(decimal.substring(format.decimals).match(/^0*$/),
+      "too many decimals for format", "NUMERIC_FAULT", {
+        operation: "fromString", fault: "underflow", value: _value,
+      });
+    decimal = decimal.substring(0, format.decimals);
+
+    const value = BigInt(match[1] + whole + decimal);
+    _checkValue(value, format, "fromString");
+    return new FixedNumber(_guard, value, format);
+  }
+
+  static fromBytes(_value, _format) {
+    let value = BigInt("0x" + hexlify(arrayify(_value)).replace(/^0x/, ""));
+    const format = _getFormat(_format);
+    if (format.signed) { value = _fromTwos(value, format.width); }
+    _checkValue(value, format, "fromBytes");
+    return new FixedNumber(_guard, value, format);
+  }
+
+  static from(value, format) {
+    if (typeof value === "string") return FixedNumber.fromString(value, format);
+    if (isBytesLike(value)) return FixedNumber.fromBytes(value, format);
+    try {
+      return FixedNumber.fromValue(value, 0, format);
+    } catch (error) {
+      if (error.code !== "INVALID_ARGUMENT") throw error;
+    }
+    return assertArgument(false, "invalid FixedNumber value", "value", value);
+  }
+
+  static isFixedNumber(value) {
+    return !!(value && value instanceof FixedNumber);
+  }
+}
+
+module.exports = { FixedNumber };

package/src/utils/hashing.js

@@ -293,7 +293,7 @@ function scrypt(password, salt, N, r, p, dkLen) {
 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 });
+  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));
 }
 

package/src/utils/index.d.ts

@@ -61,5 +61,6 @@ declare const _exports: {
     computeAddress(key: string | Uint8Array): string;
     verifyMessage(message: string | Uint8Array, signature: string): string;
     recoverAddress(message: string | Uint8Array, signature: string): string;
+    FixedNumber: typeof import("./fixednumber").FixedNumber;
 };
 export = _exports;

package/src/utils/index.js

@@ -9,5 +9,6 @@ module.exports = {
   ...require("./rlp"),
   ...require("./result"),
   ...require("./units"),
+  ...require("./fixednumber"),
 };
 

package/src/wallet/wallet.d.ts

@@ -66,9 +66,23 @@ export class Wallet extends BaseWallet {
     /**
      * Creates a new random wallet.
      * @param {import("../providers/provider").AbstractProvider=} provider
+     * @param {number|null=} keyType  Optional key type: null (default=3), 3, or 5
      * @returns {Wallet}
      */
-    static createRandom(provider?: import("../providers/provider").AbstractProvider | undefined): Wallet;
+    static createRandom(provider?: import("../providers/provider").AbstractProvider | undefined, keyType?: number | null): Wallet;
+    /**
+     * Creates a new random seed word list (32 words for keyType 3, 36 for keyType 5).
+     * @param {number|null=} keyType  Optional key type: null (default=3), 3, or 5
+     * @returns {string[]}
+     */
+    static createRandomSeed(keyType?: number | null): string[];
+    /**
+     * Creates a wallet from raw seed bytes.
+     * @param {number[]} seed  Raw seed bytes: 64 (keyType 3), 72 (keyType 5), or 96 (legacy)
+     * @param {import("../providers/provider").AbstractProvider=} provider
+     * @returns {Wallet}
+     */
+    static fromSeed(seed: number[], provider?: import("../providers/provider").AbstractProvider | undefined): Wallet;
     /**
      * Creates a wallet from an encrypted JSON string.
      * @param {string} json

package/src/wallet/wallet.js

@@ -323,12 +323,54 @@ class Wallet extends BaseWallet {
   /**
    * Creates a new random wallet.
    * @param {import("../providers/provider").AbstractProvider=} provider
+   * @param {number|null=} keyType  Optional key type: null (default=3), 3, or 5
    * @returns {Wallet}
    */
-  static createRandom(provider) {
+  static createRandom(provider, keyType) {
     _requireInitialized();
-    const qcWallet = qcsdk.newWallet();
-    if (!qcWallet) throw makeError("newWallet failed", "UNKNOWN_ERROR", {});
+    if (keyType != null) {
+      assertArgument(keyType === 3 || keyType === 5, "keyType must be null, 3, or 5", "keyType", keyType);
+    }
+    const qcWallet = qcsdk.newWallet(keyType ?? null);
+    if (!qcWallet || typeof qcWallet === "number") {
+      throw makeError("newWallet failed", "UNKNOWN_ERROR", { result: qcWallet });
+    }
+    return Wallet._fromQcWallet(qcWallet, provider || null);
+  }
+
+  /**
+   * Creates a new random seed word list (32 words for keyType 3, 36 for keyType 5).
+   * Use the returned words with `Wallet.fromPhrase()` to create a wallet.
+   * @param {number|null=} keyType  Optional key type: null (default=3), 3, or 5
+   * @returns {string[]}
+   */
+  static createRandomSeed(keyType) {
+    _requireInitialized();
+    if (keyType != null) {
+      assertArgument(keyType === 3 || keyType === 5, "keyType must be null, 3, or 5", "keyType", keyType);
+    }
+    const words = qcsdk.newWalletSeed(keyType ?? null);
+    if (!words || !Array.isArray(words)) {
+      throw makeError("newWalletSeed failed", "UNKNOWN_ERROR", { result: words });
+    }
+    return words;
+  }
+
+  /**
+   * Creates a wallet from raw seed bytes.
+   * @param {number[]} seed  Raw seed bytes: 64 (keyType 3), 72 (keyType 5), or 96 (legacy)
+   * @param {import("../providers/provider").AbstractProvider=} provider
+   * @returns {Wallet}
+   */
+  static fromSeed(seed, provider) {
+    _requireInitialized();
+    assertArgument(Array.isArray(seed), "seed must be an array of numbers", "seed", seed);
+    const allowedLengths = [64, 72, 96];
+    assertArgument(allowedLengths.includes(seed.length), "seed must be 64, 72, or 96 bytes", "seed", seed.length);
+    const qcWallet = qcsdk.openWalletFromSeed(seed);
+    if (!qcWallet || typeof qcWallet === "number") {
+      throw makeError("openWalletFromSeed failed", "UNKNOWN_ERROR", { result: qcWallet });
+    }
     return Wallet._fromQcWallet(qcWallet, provider || null);
   }