quantum-coin-js-sdk 1.0.36 → 1.0.39

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

@@ -0,0 +1,215 @@
+/**
+ * @fileoverview RLP encoding utilities.
+ *
+ * SPEC.md section 5.9 mirrors ethers.js v6 RLP helpers.
+ *
+ * This implementation is self-contained (no vendored ethers.js dependency).
+ */
+
+const { arrayify, bytesToHex, hexToBytes, isHexString, normalizeHex, utf8ToBytes } = require("../internal/hex");
+
+function _toBytes(value) {
+  if (value == null) return new Uint8Array([]);
+
+  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.
+    if (value.every((v) => Number.isInteger(v) && v >= 0 && v <= 255)) {
+      return new Uint8Array(value);
+    }
+    throw new TypeError("invalid RLP bytes array");
+  }
+
+  if (typeof value === "string") {
+    // Prefer hex strings (ethers-style); otherwise treat as utf8.
+    if (value === "0x" || value === "") return new Uint8Array([]);
+    if (isHexString(value)) return hexToBytes(normalizeHex(value));
+    return utf8ToBytes(value);
+  }
+
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value < 0) throw new TypeError("invalid RLP number");
+    if (value === 0) return new Uint8Array([]);
+    let n = BigInt(value);
+    const out = [];
+    while (n > 0n) {
+      out.push(Number(n & 0xffn));
+      n >>= 8n;
+    }
+    out.reverse();
+    return new Uint8Array(out);
+  }
+
+  if (typeof value === "bigint") {
+    if (value < 0n) throw new TypeError("invalid RLP bigint");
+    if (value === 0n) return new Uint8Array([]);
+    let n = value;
+    const out = [];
+    while (n > 0n) {
+      out.push(Number(n & 0xffn));
+      n >>= 8n;
+    }
+    out.reverse();
+    return new Uint8Array(out);
+  }
+
+  throw new TypeError("unsupported RLP value type");
+}
+
+function _encodeLen(len, offsetShort, offsetLong) {
+  if (len <= 55) {
+    return new Uint8Array([offsetShort + len]);
+  }
+  // length-of-length (big-endian)
+  let l = len;
+  const bytes = [];
+  while (l > 0) {
+    bytes.push(l & 0xff);
+    l >>= 8;
+  }
+  bytes.reverse();
+  return new Uint8Array([offsetLong + bytes.length, ...bytes]);
+}
+
+function _concat(a, b) {
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a, 0);
+  out.set(b, a.length);
+  return out;
+}
+
+function _encode(value) {
+  if (Array.isArray(value) && !value.every((v) => Number.isInteger(v) && v >= 0 && v <= 255)) {
+    // List
+    let payload = new Uint8Array([]);
+    for (const item of value) {
+      payload = _concat(payload, _encode(item));
+    }
+    const prefix = _encodeLen(payload.length, 0xc0, 0xf7);
+    return _concat(prefix, payload);
+  }
+
+  // String/bytes/integer
+  const bytes = _toBytes(value);
+  if (bytes.length === 1 && bytes[0] < 0x80) {
+    return bytes;
+  }
+  const prefix = _encodeLen(bytes.length, 0x80, 0xb7);
+  return _concat(prefix, bytes);
+}
+
+function _readLen(bytes, offset, lenOfLen) {
+  if (lenOfLen === 0) return 0;
+  if (offset + lenOfLen > bytes.length) throw new Error("RLP: insufficient data for length");
+  // Canonical encoding forbids a leading zero byte in the length field.
+  if (bytes[offset] === 0) throw new Error("RLP: non-canonical length (leading zero byte)");
+  // Accumulate with multiplication (not `<< 8`, which is a signed 32-bit op
+  // that overflows/wraps for 4+ byte lengths) and reject impossibly large lengths.
+  let len = 0;
+  for (let i = 0; i < lenOfLen; i++) {
+    len = len * 256 + bytes[offset + i];
+    if (len > Number.MAX_SAFE_INTEGER) throw new Error("RLP: length exceeds maximum safe integer");
+  }
+  return len;
+}
+
+const MAX_RLP_DEPTH = 64;
+
+function _decode(bytes, start, end, depth) {
+  if (depth > MAX_RLP_DEPTH) throw new Error("RLP: maximum nesting depth exceeded");
+  if (start >= end) throw new Error("RLP: empty input");
+  const prefix = bytes[start];
+
+  // Single byte
+  if (prefix <= 0x7f) {
+    return { value: bytesToHex(new Uint8Array([prefix])), next: start + 1 };
+  }
+
+  // Short string
+  if (prefix <= 0xb7) {
+    const len = prefix - 0x80;
+    const dataStart = start + 1;
+    const dataEnd = dataStart + len;
+    if (dataEnd > end) throw new Error("RLP: out of bounds");
+    // Canonical encoding requires a single byte < 0x80 to be encoded as
+    // itself, never as a 1-byte string.
+    if (len === 1 && bytes[dataStart] < 0x80) throw new Error("RLP: non-canonical single byte encoding");
+    const out = bytesToHex(bytes.slice(dataStart, dataEnd));
+    return { value: out, next: dataEnd };
+  }
+
+  // Long string
+  if (prefix <= 0xbf) {
+    const lenOfLen = prefix - 0xb7;
+    const len = _readLen(bytes, start + 1, lenOfLen);
+    // Lengths <= 55 must use the short-string form.
+    if (len <= 55) throw new Error("RLP: non-canonical long string (length fits short form)");
+    const dataStart = start + 1 + lenOfLen;
+    const dataEnd = dataStart + len;
+    if (dataEnd > end) throw new Error("RLP: out of bounds");
+    const out = bytesToHex(bytes.slice(dataStart, dataEnd));
+    return { value: out, next: dataEnd };
+  }
+
+  // Short list
+  if (prefix <= 0xf7) {
+    const len = prefix - 0xc0;
+    const dataStart = start + 1;
+    const dataEnd = dataStart + len;
+    if (dataEnd > end) throw new Error("RLP: out of bounds");
+    const out = [];
+    let pos = dataStart;
+    while (pos < dataEnd) {
+      const decoded = _decode(bytes, pos, dataEnd, depth + 1);
+      out.push(decoded.value);
+      pos = decoded.next;
+    }
+    if (pos !== dataEnd) throw new Error("RLP: list length mismatch");
+    return { value: out, next: dataEnd };
+  }
+
+  // Long list
+  const lenOfLen = prefix - 0xf7;
+  const len = _readLen(bytes, start + 1, lenOfLen);
+  // Lengths <= 55 must use the short-list form.
+  if (len <= 55) throw new Error("RLP: non-canonical long list (length fits short form)");
+  const dataStart = start + 1 + lenOfLen;
+  const dataEnd = dataStart + len;
+  if (dataEnd > end) throw new Error("RLP: out of bounds");
+  const out = [];
+  let pos = dataStart;
+  while (pos < dataEnd) {
+    const decoded = _decode(bytes, pos, dataEnd, depth + 1);
+    out.push(decoded.value);
+    pos = decoded.next;
+  }
+  if (pos !== dataEnd) throw new Error("RLP: list length mismatch");
+  return { value: out, next: dataEnd };
+}
+
+/**
+ * RLP-encode a value.
+ * @param {any} value
+ * @returns {string}
+ */
+function encodeRlp(value) {
+  return bytesToHex(_encode(value));
+}
+
+/**
+ * RLP-decode a hex string.
+ * @param {string} data
+ * @returns {any}
+ */
+function decodeRlp(data) {
+  if (typeof data !== "string") throw new TypeError("RLP data must be a hex string");
+  const bytes = arrayify(data);
+  const decoded = _decode(bytes, 0, bytes.length, 0);
+  if (decoded.next !== bytes.length) throw new Error("RLP: trailing data");
+  return decoded.value;
+}
+
+module.exports = { encodeRlp, decodeRlp };
+

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

@@ -0,0 +1,29 @@
+export type BigNumberish = string | number | bigint;
+/**
+ * Format a BigNumberish into a decimal string with `decimals` places.
+ * @param {BigNumberish} value
+ * @param {number=} decimals
+ * @returns {string}
+ */
+export function formatUnits(value: BigNumberish, decimals?: number | undefined): string;
+/**
+ * Parse a decimal string into bigint with `decimals` places.
+ * @param {string} value
+ * @param {number=} decimals
+ * @returns {bigint}
+ */
+export function parseUnits(value: string, decimals?: number | undefined): bigint;
+/**
+ * Format wei as coin string.
+ * @param {BigNumberish} value
+ * @returns {string}
+ */
+export function formatEther(value: BigNumberish): string;
+/**
+ * Parse coin string to wei.
+ * @param {string} value
+ * @returns {bigint}
+ */
+export function parseEther(value: string): bigint;
+import { WeiPerEther } from "../constants";
+export { WeiPerEther };

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

@@ -0,0 +1,107 @@
+/**
+ * @fileoverview Unit conversion helpers (ethers.js v6 compatible names).
+ */
+
+const { WeiPerEther } = require("../constants");
+const { assertArgument, makeError } = require("../errors");
+
+/**
+ * @typedef {string | number | bigint} BigNumberish
+ */
+
+function _toBigInt(value) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") {
+    assertArgument(Number.isFinite(value) && Math.floor(value) === value, "invalid number", "value", value);
+    return BigInt(value);
+  }
+  if (typeof value === "string") {
+    if (value.trim() === "") throw makeError("invalid BigNumberish string", "INVALID_ARGUMENT", { value });
+    if (value.startsWith("0x") || value.startsWith("0X")) return BigInt(value);
+    return BigInt(value);
+  }
+  throw makeError("invalid BigNumberish", "INVALID_ARGUMENT", { value });
+}
+
+/**
+ * Format a BigNumberish into a decimal string with `decimals` places.
+ * @param {BigNumberish} value
+ * @param {number=} decimals
+ * @returns {string}
+ */
+function formatUnits(value, decimals) {
+  const dec = decimals == null ? 18 : decimals;
+  assertArgument(Number.isInteger(dec) && dec >= 0 && dec <= 256, "invalid decimals", "decimals", decimals);
+  const v = _toBigInt(value);
+  const neg = v < 0n;
+  const abs = neg ? -v : v;
+
+  const base = 10n ** BigInt(dec);
+  const whole = abs / base;
+  const frac = abs % base;
+
+  let fracStr = frac.toString().padStart(dec, "0");
+  // trim trailing zeros
+  fracStr = fracStr.replace(/0+$/, "");
+  const out = fracStr.length ? `${whole.toString()}.${fracStr}` : whole.toString();
+  return neg ? "-" + out : out;
+}
+
+/**
+ * Parse a decimal string into bigint with `decimals` places.
+ * @param {string} value
+ * @param {number=} decimals
+ * @returns {bigint}
+ */
+function parseUnits(value, decimals) {
+  const dec = decimals == null ? 18 : decimals;
+  assertArgument(Number.isInteger(dec) && dec >= 0 && dec <= 256, "invalid decimals", "decimals", decimals);
+  assertArgument(typeof value === "string", "value must be a string", "value", value);
+
+  const v = value.trim();
+  assertArgument(v.length > 0, "invalid value", "value", value);
+
+  const neg = v.startsWith("-");
+  const s = neg ? v.slice(1) : v;
+  const parts = s.split(".");
+  assertArgument(parts.length <= 2, "invalid decimal string", "value", value);
+
+  const whole = parts[0] || "0";
+  const frac = parts[1] || "";
+  assertArgument(/^\d+$/.test(whole), "invalid whole component", "value", value);
+  assertArgument(/^\d*$/.test(frac), "invalid fractional component", "value", value);
+  assertArgument(frac.length <= dec, "fractional component exceeds decimals", "value", value);
+
+  const base = 10n ** BigInt(dec);
+  const wholeBI = BigInt(whole) * base;
+  const fracBI = frac.length ? BigInt(frac.padEnd(dec, "0")) : 0n;
+  const out = wholeBI + fracBI;
+  return neg ? -out : out;
+}
+
+/**
+ * Format wei as coin string.
+ * @param {BigNumberish} value
+ * @returns {string}
+ */
+function formatEther(value) {
+  return formatUnits(value, 18);
+}
+
+/**
+ * Parse coin string to wei.
+ * @param {string} value
+ * @returns {bigint}
+ */
+function parseEther(value) {
+  return parseUnits(value, 18);
+}
+
+module.exports = {
+  formatUnits,
+  parseUnits,
+  formatEther,
+  parseEther,
+  WeiPerEther,
+};
+

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

@@ -0,0 +1,10 @@
+declare const _exports: {
+    SigningKey: typeof import("./wallet").SigningKey;
+    AbstractSigner: typeof import("./wallet").AbstractSigner;
+    BaseWallet: typeof import("./wallet").BaseWallet;
+    Wallet: typeof import("./wallet").Wallet;
+    NonceManager: typeof import("./wallet").NonceManager;
+    JsonRpcSigner: typeof import("./wallet").JsonRpcSigner;
+    VoidSigner: typeof import("./wallet").VoidSigner;
+};
+export = _exports;

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

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Wallet exports.
+ */
+
+module.exports = {
+  ...require("./wallet"),
+};
+

package/example/node_modules/quantumcoin/src/wallet/wallet.d.ts

@@ -0,0 +1,192 @@
+/**
+ * SigningKey wrapper (PQC private/public key bytes).
+ */
+export class SigningKey {
+    /**
+     * @param {Uint8Array} privateKeyBytes
+     * @param {Uint8Array} publicKeyBytes
+     */
+    constructor(privateKeyBytes: Uint8Array, publicKeyBytes: Uint8Array);
+    privateKeyBytes: Uint8Array<ArrayBuffer>;
+    publicKeyBytes: Uint8Array<ArrayBuffer>;
+}
+/**
+ * AbstractSigner base (minimal).
+ */
+export class AbstractSigner {
+    /**
+     * @param {import("../providers/provider").AbstractProvider|null} provider
+     */
+    constructor(provider: import("../providers/provider").AbstractProvider | null);
+    provider: import("../providers/provider").AbstractProvider;
+    getAddress(): Promise<void>;
+}
+/**
+ * BaseWallet - core signing implementation.
+ */
+export class BaseWallet extends AbstractSigner {
+    /**
+     * @param {SigningKey} signingKey
+     * @param {import("../providers/provider").AbstractProvider|null=} provider
+     * @param {{ address: string }=} precomputed
+     * @param {any=} qcWallet Internal quantum-coin-js-sdk Wallet (optional)
+     */
+    constructor(signingKey: SigningKey, provider?: (import("../providers/provider").AbstractProvider | null) | undefined, precomputed?: {
+        address: string;
+    } | undefined, qcWallet?: any | undefined);
+    signingKey: SigningKey;
+    _qcWallet: any;
+    /** @type {string} */
+    address: string;
+    readonly publicKey: string;
+    readonly seed: string | null;
+    getAddress(): Promise<string>;
+    /**
+     * Sign a transaction using quantum-coin-js-sdk signRawTransaction().
+     * @param {import("../providers/provider").TransactionRequest} tx
+     * @returns {Promise<string>}
+     */
+    signTransaction(tx: import("../providers/provider").TransactionRequest): Promise<string>;
+    /**
+     * Signs and sends a transaction.
+     * @param {import("../providers/provider").TransactionRequest} tx
+     * @returns {Promise<import("../providers/provider").TransactionResponse>}
+     */
+    sendTransaction(tx: import("../providers/provider").TransactionRequest): Promise<import("../providers/provider").TransactionResponse>;
+}
+/**
+ * Wallet - convenience methods around BaseWallet.
+ */
+export class Wallet extends BaseWallet {
+    /**
+     * Returns the seed phrase (list of words) if this wallet has a seed, else null.
+     * Derived from the stored pre-expansion seed via seed-words.getWordListFromSeedArray.
+     */
+    getPhrase(): string[] | null;
+    /**
+     * Returns the recommended signing context for this wallet.
+     * Setting fullSign to true may incur additional gas cost.
+     * @param {boolean|null=} fullSign  Defaults to false when null or omitted.
+     * @returns {number}
+     */
+    getSigningContext(fullSign?: boolean | null): number;
+    /**
+     * 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, keyType?: number | null): Wallet;
+    /**
+     * 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
+     * @param {string} password
+     * @param {import("../providers/provider").AbstractProvider=} provider
+     * @returns {Wallet}
+     */
+    static fromEncryptedJsonSync(json: string, password: string, provider?: import("../providers/provider").AbstractProvider | undefined): Wallet;
+    /**
+     * Creates a wallet from a seed phrase (32, 36, or 48 words).
+     * @param {string|string[]} phrase
+     * @param {import("../providers/provider").AbstractProvider=} provider
+     * @returns {Wallet}
+     */
+    static fromPhrase(phrase: string | string[], provider?: import("../providers/provider").AbstractProvider | undefined): Wallet;
+    /**
+     * Creates a wallet from raw private and public key bytes.
+     * @param {Uint8Array|string} privateKey  Private key bytes or hex string
+     * @param {Uint8Array|string} publicKey   Public key bytes or hex string
+     * @param {import("../providers/provider").AbstractProvider=} provider
+     * @returns {Wallet}
+     */
+    static fromKeys(privateKey: Uint8Array | string, publicKey: Uint8Array | string, provider?: import("../providers/provider").AbstractProvider | undefined): Wallet;
+    /**
+     * Internal helper: build a Wallet from a quantum-coin-js-sdk Wallet object.
+     * @param {any} qcWallet
+     * @param {import("../providers/provider").AbstractProvider|null} provider
+     * @returns {Wallet}
+     */
+    static _fromQcWallet(qcWallet: any, provider: import("../providers/provider").AbstractProvider | null): Wallet;
+    /**
+     * @param {string|Uint8Array|SigningKey} key
+     * @param {import("../providers/provider").AbstractProvider=} provider
+     */
+    constructor(key: string | Uint8Array | SigningKey, provider?: import("../providers/provider").AbstractProvider | undefined);
+    /**
+     * Returns wallet address (sync).
+     * @returns {string}
+     */
+    getAddress(): string;
+    /**
+     * Returns wallet balance.
+     * @param {string=} blockTag
+     * @returns {Promise<bigint>}
+     */
+    getBalance(blockTag?: string | undefined): Promise<bigint>;
+    /**
+     * Returns wallet nonce.
+     * @param {string=} blockTag
+     * @returns {Promise<number>}
+     */
+    getTransactionCount(blockTag?: string | undefined): Promise<number>;
+    /**
+     * Encrypts and serializes this wallet to JSON.
+     * @param {string|Uint8Array} password
+     * @returns {string}
+     */
+    encryptSync(password: string | Uint8Array): string;
+    /**
+     * Encrypts raw seed bytes into a wallet JSON string (version 5 pre-expansion format).
+     * The resulting JSON can be opened with `Wallet.fromEncryptedJsonSync()` or
+     * Desktop/Mobile/Web/CLI wallet applications.
+     * @param {number[]|Uint8Array} seed  Raw seed bytes: 64 (keyType 3), 72 (keyType 5), or 96 (legacy)
+     * @param {string|Uint8Array} password  Passphrase (at least 12 characters)
+     * @returns {string}
+     */
+    static encryptSeedSync(seed: number[] | Uint8Array, password: string | Uint8Array): string;
+    /**
+     * Returns a new wallet connected to a provider.
+     * @param {import("../providers/provider").AbstractProvider} provider
+     * @returns {Wallet}
+     */
+    connect(provider: import("../providers/provider").AbstractProvider): Wallet;
+}
+/**
+ * NonceManager wrapper.
+ */
+export class NonceManager extends AbstractSigner {
+    /**
+     * @param {AbstractSigner} signer
+     */
+    constructor(signer: AbstractSigner);
+    signer: AbstractSigner;
+    _nonce: any;
+    getTransactionCount(blockTag: any): any;
+    sendTransaction(tx: any): Promise<any>;
+    reset(): void;
+    increment(): void;
+}
+/**
+ * JsonRpcSigner placeholder (ethers-like).
+ * This SDK encourages using Wallet directly for signing.
+ */
+export class JsonRpcSigner extends AbstractSigner {
+    constructor(provider: any, address: any);
+    _address: any;
+    getAddress(): Promise<any>;
+}
+/**
+ * VoidSigner (cannot sign, only provides address).
+ */
+export class VoidSigner extends AbstractSigner {
+    constructor(address: any, provider: any);
+    _address: string;
+    getAddress(): Promise<string>;
+}