quantum-coin-js-sdk 1.0.39 → 2.1.0

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

@@ -1,306 +0,0 @@
-/**
- * @fileoverview Encoding/decoding helpers (ethers.js v6 compatible names).
- *
- * Notes:
- * - QuantumCoin addresses are 32 bytes (not 20).
- * - This module intentionally uses only built-in Node.js APIs.
- */
-
-const {
-  isUint8Array,
-  normalizeHex,
-  isHexString,
-  strip0x,
-  add0x,
-  hexToBytes,
-  bytesToHex,
-  utf8ToBytes,
-  bytesToUtf8,
-  arrayify: _arrayify,
-} = require("../internal/hex");
-
-/**
- * @typedef {string | Uint8Array} BytesLike
- */
-
-/**
- * Converts bytes to UTF-8 string.
- * @param {BytesLike} data
- * @returns {string}
- */
-function toUtf8String(data) {
-  return bytesToUtf8(arrayify(data));
-}
-
-/**
- * Converts string to UTF-8 bytes.
- * @param {string} str
- * @returns {Uint8Array}
- */
-function toUtf8Bytes(str) {
-  return utf8ToBytes(str);
-}
-
-/**
- * Converts data to hex string.
- * @param {BytesLike} data
- * @returns {string}
- */
-function toHex(data) {
-  if (typeof data === "string") return normalizeHex(data);
-  return bytesToHex(arrayify(data));
-}
-
-/**
- * Alias for toHex.
- * @param {BytesLike} data
- * @returns {string}
- */
-function hexlify(data) {
-  return toHex(data);
-}
-
-/**
- * Converts data to byte array.
- * @param {BytesLike} data
- * @returns {Uint8Array}
- */
-function arrayify(data) {
-  return _arrayify(data);
-}
-
-/**
- * Returns true if value is BytesLike.
- * @param {any} value
- * @returns {boolean}
- */
-function isBytesLike(value) {
-  return (typeof value === "string" && isHexString(value)) || isUint8Array(value);
-}
-
-/**
- * Concatenates byte arrays and returns a hex string.
- * @param {BytesLike[]} items
- * @returns {string}
- */
-function concat(items) {
-  if (!Array.isArray(items)) throw new TypeError("items must be an array");
-  const parts = items.map((i) => arrayify(i));
-  const len = parts.reduce((a, b) => a + b.length, 0);
-  const out = new Uint8Array(len);
-  let offset = 0;
-  for (const p of parts) {
-    out.set(p, offset);
-    offset += p.length;
-  }
-  return bytesToHex(out);
-}
-
-/**
- * Strips leading zeros from a hex string.
- * @param {BytesLike} data
- * @returns {string}
- */
-function stripZerosLeft(data) {
-  const hex = toHex(data);
-  let h = strip0x(hex);
-  h = h.replace(/^0+/, "");
-  if (h.length === 0) return "0x";
-  if (h.length % 2 !== 0) h = "0" + h;
-  return add0x(h);
-}
-
-/**
- * Pads a BytesLike value to the left with zeros (byte length).
- * @param {BytesLike} value
- * @param {number} length
- * @returns {string}
- */
-function zeroPad(value, length) {
-  const bytes = arrayify(value);
-  if (bytes.length > length) throw new RangeError("value exceeds length");
-  const out = new Uint8Array(length);
-  out.set(bytes, length - bytes.length);
-  return bytesToHex(out);
-}
-
-/**
- * Pads a hex value (interpreted as bytes) to the left with zeros (byte length).
- * @param {BytesLike} value
- * @param {number} length
- * @returns {string}
- */
-function zeroPadValue(value, length) {
-  return zeroPad(value, length);
-}
-
-/**
- * Encodes a short UTF-8 string into a bytes32 hex string.
- * @param {string} text
- * @returns {string}
- */
-function encodeBytes32String(text) {
-  const bytes = toUtf8Bytes(text);
-  if (bytes.length > 32) throw new RangeError("string too long (max 32 bytes)");
-  const out = new Uint8Array(32);
-  out.set(bytes, 0);
-  return bytesToHex(out);
-}
-
-/**
- * Decodes a bytes32 hex string into a UTF-8 string (trailing zeros stripped).
- * @param {BytesLike} bytes
- * @returns {string}
- */
-function decodeBytes32String(bytes) {
-  const b = arrayify(bytes);
-  if (b.length !== 32) throw new RangeError("invalid bytes32 length");
-  let end = b.length;
-  while (end > 0 && b[end - 1] === 0) end--;
-  return bytesToUtf8(b.slice(0, end));
-}
-
-/**
- * Base64 decode to bytes.
- * @param {string} data
- * @returns {Uint8Array}
- */
-function decodeBase64(data) {
-  const buf = Buffer.from(data, "base64");
-  return new Uint8Array(buf);
-}
-
-/**
- * Base64 encode BytesLike.
- * @param {BytesLike} data
- * @returns {string}
- */
-function encodeBase64(data) {
-  return Buffer.from(arrayify(data)).toString("base64");
-}
-
-// Minimal base58 implementation (Bitcoin alphabet) for compatibility with ethers helpers.
-const _B58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-const _B58_INDEX = new Map(_B58_ALPHABET.split("").map((c, i) => [c, i]));
-
-/**
- * Decode Base58 string to bytes.
- * @param {string} data
- * @returns {Uint8Array}
- */
-function decodeBase58(data) {
-  if (typeof data !== "string" || data.length === 0) throw new TypeError("invalid base58 string");
-
-  let bytes = [0];
-  for (const ch of data) {
-    const val = _B58_INDEX.get(ch);
-    if (val == null) throw new TypeError("invalid base58 character");
-
-    let carry = val;
-    for (let i = 0; i < bytes.length; i++) {
-      const x = bytes[i] * 58 + carry;
-      bytes[i] = x & 0xff;
-      carry = x >> 8;
-    }
-    while (carry > 0) {
-      bytes.push(carry & 0xff);
-      carry >>= 8;
-    }
-  }
-
-  // Deal with leading zeros
-  let leading = 0;
-  for (const ch of data) {
-    if (ch === "1") leading++;
-    else break;
-  }
-
-  const out = new Uint8Array(leading + bytes.length);
-  for (let i = 0; i < bytes.length; i++) out[out.length - 1 - i] = bytes[i];
-  return out;
-}
-
-/**
- * Encode BytesLike as Base58.
- * @param {BytesLike} data
- * @returns {string}
- */
-function encodeBase58(data) {
-  const bytes = arrayify(data);
-  let digits = [0];
-
-  for (const b of bytes) {
-    let carry = b;
-    for (let i = 0; i < digits.length; i++) {
-      const x = digits[i] * 256 + carry;
-      digits[i] = x % 58;
-      carry = (x / 58) | 0;
-    }
-    while (carry > 0) {
-      digits.push(carry % 58);
-      carry = (carry / 58) | 0;
-    }
-  }
-
-  // Leading zeros
-  let leading = 0;
-  for (const b of bytes) {
-    if (b === 0) leading++;
-    else break;
-  }
-
-  let out = "1".repeat(leading);
-  for (let i = digits.length - 1; i >= 0; i--) out += _B58_ALPHABET[digits[i]];
-  return out;
-}
-
-/**
- * Returns UTF-8 code points for a string.
- * @param {string} str
- * @returns {number[]}
- */
-function toUtf8CodePoints(str) {
-  return Array.from(str).map((c) => c.codePointAt(0) || 0);
-}
-
-/**
- * Solidity packed encoding.
- * This is a complex helper in ethers.js; in QuantumCoin.js it is currently not implemented.
- * @throws
- */
-function solidityPacked() {
-  throw new Error("solidityPacked is not implemented in QuantumCoin.js yet");
-}
-function solidityPackedKeccak256() {
-  throw new Error("solidityPackedKeccak256 is not implemented in QuantumCoin.js yet");
-}
-function solidityPackedSha256() {
-  throw new Error("solidityPackedSha256 is not implemented in QuantumCoin.js yet");
-}
-
-module.exports = {
-  toUtf8String,
-  toUtf8Bytes,
-  toHex,
-  hexlify,
-  arrayify,
-  concat,
-  stripZerosLeft,
-  encodeBytes32String,
-  decodeBytes32String,
-  decodeBase58,
-  decodeBase64,
-  encodeBase58,
-  encodeBase64,
-  toUtf8CodePoints,
-  isHexString,
-  isBytesLike,
-  zeroPad,
-  zeroPadValue,
-  solidityPacked,
-  solidityPackedKeccak256,
-  solidityPackedSha256,
-  bytesToHex,
-  hexToBytes,
-};
-

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

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