quantum-coin-js-sdk 1.0.39 → 2.1.0

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

@@ -1,122 +0,0 @@
-declare const _exports: {
-    isError(error: any, code: string): boolean;
-    isCallException(error: any): boolean;
-    makeError(message: string, code: errors.ErrorCode, info?: Record<string, any> | undefined): Error & {
-        code: errors.ErrorCode;
-        shortMessage: string;
-    };
-    assert(check: any, message: string, code: errors.ErrorCode, info?: Record<string, any> | undefined): void;
-    assertArgument(check: any, message: string, name: string, value: any): void;
-    ProviderError: typeof errors.ProviderError;
-    TransactionError: typeof errors.TransactionError;
-    ContractError: typeof errors.ContractError;
-    formatUnits(value: import("./utils/units").BigNumberish, decimals?: number | undefined): string;
-    parseUnits(value: string, decimals?: number | undefined): bigint;
-    formatEther(value: import("./utils/units").BigNumberish): string;
-    parseEther(value: string): bigint;
-    WeiPerEther: bigint;
-    checkResultErrors(result: any): Array<{
-        error: Error;
-        path: Array<string | number>;
-    }>;
-    Result: typeof import("./utils/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("./utils/encoding").BytesLike): string;
-    toUtf8Bytes(str: string): Uint8Array;
-    toHex(data: import("./utils/encoding").BytesLike): string;
-    hexlify(data: import("./utils/encoding").BytesLike): string;
-    arrayify(data: import("./utils/encoding").BytesLike): Uint8Array;
-    concat(items: import("./utils/encoding").BytesLike[]): string;
-    stripZerosLeft(data: import("./utils/encoding").BytesLike): string;
-    encodeBytes32String(text: string): string;
-    decodeBytes32String(bytes: import("./utils/encoding").BytesLike): string;
-    decodeBase58(data: string): Uint8Array;
-    decodeBase64(data: string): Uint8Array;
-    encodeBase58(data: import("./utils/encoding").BytesLike): string;
-    encodeBase64(data: import("./utils/encoding").BytesLike): string;
-    toUtf8CodePoints(str: string): number[];
-    isBytesLike(value: any): boolean;
-    zeroPad(value: import("./utils/encoding").BytesLike, length: number): string;
-    zeroPadValue(value: import("./utils/encoding").BytesLike, length: number): string;
-    solidityPacked(): void;
-    solidityPackedKeccak256(): void;
-    solidityPackedSha256(): void;
-    isHexString: typeof import("./internal/hex").isHexString;
-    bytesToHex: typeof import("./internal/hex").bytesToHex;
-    hexToBytes: typeof import("./internal/hex").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;
-    Interface: typeof import("./abi/interface").Interface;
-    AbiCoder: typeof import("./abi/interface").AbiCoder;
-    Fragment: typeof import("./abi/fragments").Fragment;
-    NamedFragment: typeof import("./abi/fragments").NamedFragment;
-    FunctionFragment: typeof import("./abi/fragments").FunctionFragment;
-    EventFragment: typeof import("./abi/fragments").EventFragment;
-    ErrorFragment: typeof import("./abi/fragments").ErrorFragment;
-    ConstructorFragment: typeof import("./abi/fragments").ConstructorFragment;
-    StructFragment: typeof import("./abi/fragments").StructFragment;
-    FallbackFragment: typeof import("./abi/fragments").FallbackFragment;
-    ContractFactory: typeof import("./contract/contract-factory").ContractFactory;
-    BaseContract: typeof import("./contract/contract").BaseContract;
-    Contract: typeof import("./contract/contract").Contract;
-    ContractTransactionResponse: typeof import("./contract/contract").ContractTransactionResponse;
-    ContractTransactionReceipt: typeof import("./contract/contract").ContractTransactionReceipt;
-    EventLog: typeof import("./contract/contract").EventLog;
-    SigningKey: typeof import("./wallet/wallet").SigningKey;
-    AbstractSigner: typeof import("./wallet/wallet").AbstractSigner;
-    BaseWallet: typeof import("./wallet/wallet").BaseWallet;
-    Wallet: typeof import("./wallet/wallet").Wallet;
-    NonceManager: typeof import("./wallet/wallet").NonceManager;
-    JsonRpcSigner: typeof import("./wallet/wallet").JsonRpcSigner;
-    VoidSigner: typeof import("./wallet/wallet").VoidSigner;
-    getProvider(endpoint?: string | undefined, chainId?: number | undefined): import("./providers/provider").AbstractProvider;
-    WebSocketProvider: typeof import("./providers/extra-providers").WebSocketProvider;
-    IpcSocketProvider: typeof import("./providers/extra-providers").IpcSocketProvider;
-    BrowserProvider: typeof import("./providers/extra-providers").BrowserProvider;
-    FallbackProvider: typeof import("./providers/extra-providers").FallbackProvider;
-    FilterByBlockHash: typeof import("./providers/extra-providers").FilterByBlockHash;
-    JsonRpcProvider: typeof import("./providers/json-rpc-provider").JsonRpcProvider;
-    JsonRpcApiProvider: typeof import("./providers/json-rpc-provider").JsonRpcApiProvider;
-    Provider: typeof import("./providers/provider").Provider;
-    AbstractProvider: typeof import("./providers/provider").AbstractProvider;
-    Block: typeof import("./providers/provider").Block;
-    TransactionResponse: typeof import("./providers/provider").TransactionResponse;
-    TransactionReceipt: typeof import("./providers/provider").TransactionReceipt;
-    Log: typeof import("./providers/provider").Log;
-    version: string;
-    ZeroAddress: string;
-    ZeroHash: string;
-    MaxUint256: bigint;
-    MaxUint160: bigint;
-    MinInt256: bigint;
-    MaxInt256: bigint;
-    NumericFault: string;
-    NumericFaultCode: string;
-    EtherSymbol: string;
-    N: bigint;
-};
-export = _exports;
-import errors = require("./errors");

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

@@ -1,41 +0,0 @@
-/**
- * @fileoverview QuantumCoin.js main entrypoint (ethers.js v6 compatible API surface).
- *
- * IMPORTANT: Call `Initialize()` (from `quantumcoin/config`) before using
- * any functionality that relies on `quantum-coin-js-sdk` (address validation,
- * ABI packing/unpacking, signing, etc.).
- */
-
-// Core constants
-const constants = require("./constants");
-
-// Modules
-const providers = require("./providers");
-const wallet = require("./wallet");
-const contract = require("./contract");
-const abi = require("./abi");
-const utils = require("./utils");
-const errors = require("./errors");
-
-module.exports = {
-  ...constants,
-
-  // Providers
-  ...providers,
-
-  // Wallet / signers
-  ...wallet,
-
-  // Contracts
-  ...contract,
-
-  // ABI
-  ...abi,
-
-  // Utils
-  ...utils,
-
-  // Errors
-  ...errors,
-};
-

package/example/node_modules/quantumcoin/src/internal/hex.d.ts

@@ -1,68 +0,0 @@
-/**
- * Return true if `value` is a Uint8Array.
- * @param {any} value
- * @returns {value is Uint8Array}
- */
-export function isUint8Array(value: any): value is Uint8Array;
-/**
- * Normalize a hex string.
- * @param {string} hex
- * @returns {string}
- */
-export function normalizeHex(hex: string): string;
-/**
- * Format a number/bigint as a JSON-RPC QUANTITY hex string (no leading zeros).
- * @param value
- */
-export function toQuantityHex(value: number | bigint): string;
-/** Alias of `toQuantityHex` matching ethers.js v6 naming. */
-export const toQuantity: typeof toQuantityHex;
-/**
- * Returns true if value is a hex string.
- * @param {any} value
- * @param {number=} lengthBytes Optional exact byte length.
- * @returns {boolean}
- */
-export function isHexString(value: any, lengthBytes?: number | undefined): boolean;
-/**
- * Strip 0x prefix.
- * @param {string} hex
- * @returns {string}
- */
-export function strip0x(hex: string): string;
-/**
- * Ensure a 0x prefix.
- * @param {string} hex
- * @returns {string}
- */
-export function add0x(hex: string): string;
-/**
- * Convert a hex string to bytes.
- * @param {string} hex
- * @returns {Uint8Array}
- */
-export function hexToBytes(hex: string): Uint8Array;
-/**
- * Convert bytes to hex string.
- * @param {Uint8Array} bytes
- * @returns {string}
- */
-export function bytesToHex(bytes: Uint8Array): string;
-/**
- * UTF-8 encode a string to bytes.
- * @param {string} str
- * @returns {Uint8Array}
- */
-export function utf8ToBytes(str: string): Uint8Array;
-/**
- * UTF-8 decode bytes to a string.
- * @param {Uint8Array} bytes
- * @returns {string}
- */
-export function bytesToUtf8(bytes: Uint8Array): string;
-/**
- * Convert BytesLike to Uint8Array.
- * @param {string | Uint8Array} data
- * @returns {Uint8Array}
- */
-export function arrayify(data: string | Uint8Array): Uint8Array;

package/example/node_modules/quantumcoin/src/internal/hex.js

@@ -1,180 +0,0 @@
-/**
- * @fileoverview Internal hex and bytes helpers.
- *
- * IMPORTANT:
- * - This module intentionally avoids external dependencies.
- * - All hex strings in this SDK are normalized to lowercase with a `0x` prefix.
- */
-
-const { TextEncoder, TextDecoder } = require("util");
-
-/** @type {TextEncoder} */
-const _utf8Encoder = new TextEncoder();
-/** @type {TextDecoder} */
-const _utf8Decoder = new TextDecoder("utf-8", { fatal: false });
-
-/**
- * Return true if `value` is a Uint8Array.
- * @param {any} value
- * @returns {value is Uint8Array}
- */
-function isUint8Array(value) {
-  return value instanceof Uint8Array;
-}
-
-/**
- * Normalize a hex string.
- * @param {string} hex
- * @returns {string}
- */
-function normalizeHex(hex) {
-  if (typeof hex !== "string") throw new TypeError("hex must be a string");
-  let h = hex.toLowerCase();
-  if (!h.startsWith("0x")) h = "0x" + h;
-  if (h.length % 2 !== 0) h = "0x0" + h.slice(2);
-  return h;
-}
-
-/**
- * Format a number/bigint as a JSON-RPC QUANTITY hex string.
- *
- * Per the Ethereum JSON-RPC spec, quantities use the most compact
- * representation with no leading zeros, with the single exception that
- * zero is encoded as "0x0".
- *
- * Use this for block numbers, gas amounts, nonces, balances, and other
- * numeric RPC parameters. Do NOT use it for DATA hex (addresses,
- * bytecode, byte-arrays) — use `normalizeHex` for those.
- *
- * @param {number|bigint} value
- * @returns {string}
- */
-function toQuantityHex(value) {
-  let n;
-  if (typeof value === "bigint") {
-    n = value;
-  } else if (typeof value === "number") {
-    if (!Number.isInteger(value)) {
-      throw new TypeError("toQuantityHex: value must be an integer or bigint");
-    }
-    n = BigInt(value);
-  } else {
-    throw new TypeError("toQuantityHex: value must be a number or bigint");
-  }
-  if (n < 0n) throw new RangeError("toQuantityHex: value must be non-negative");
-  if (n === 0n) return "0x0";
-  return "0x" + n.toString(16);
-}
-
-/** Alias of `toQuantityHex` matching ethers.js v6 naming. */
-const toQuantity = toQuantityHex;
-
-/**
- * Returns true if value is a hex string.
- * @param {any} value
- * @param {number=} lengthBytes Optional exact byte length.
- * @returns {boolean}
- */
-function isHexString(value, lengthBytes) {
-  if (typeof value !== "string") return false;
-  const v = value.startsWith("0x") ? value.slice(2) : value;
-  if (v.length === 0) return false;
-  if (!/^[0-9a-fA-F]+$/.test(v)) return false;
-  if (v.length % 2 !== 0) return false;
-  if (lengthBytes != null) return v.length === lengthBytes * 2;
-  return true;
-}
-
-/**
- * Strip 0x prefix.
- * @param {string} hex
- * @returns {string}
- */
-function strip0x(hex) {
-  if (typeof hex !== "string") throw new TypeError("hex must be a string");
-  return hex.startsWith("0x") ? hex.slice(2) : hex;
-}
-
-/**
- * Ensure a 0x prefix.
- * @param {string} hex
- * @returns {string}
- */
-function add0x(hex) {
-  if (typeof hex !== "string") throw new TypeError("hex must be a string");
-  return hex.startsWith("0x") ? hex : "0x" + hex;
-}
-
-/**
- * Convert a hex string to bytes.
- * @param {string} hex
- * @returns {Uint8Array}
- */
-function hexToBytes(hex) {
-  if (!isHexString(hex)) throw new TypeError("invalid hex string");
-  const h = strip0x(hex);
-  const out = new Uint8Array(h.length / 2);
-  for (let i = 0; i < out.length; i++) {
-    out[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
-  }
-  return out;
-}
-
-/**
- * Convert bytes to hex string.
- * @param {Uint8Array} bytes
- * @returns {string}
- */
-function bytesToHex(bytes) {
-  if (!isUint8Array(bytes)) throw new TypeError("bytes must be Uint8Array");
-  let out = "0x";
-  for (const b of bytes) out += b.toString(16).padStart(2, "0");
-  return out;
-}
-
-/**
- * UTF-8 encode a string to bytes.
- * @param {string} str
- * @returns {Uint8Array}
- */
-function utf8ToBytes(str) {
-  if (typeof str !== "string") throw new TypeError("str must be a string");
-  return _utf8Encoder.encode(str);
-}
-
-/**
- * UTF-8 decode bytes to a string.
- * @param {Uint8Array} bytes
- * @returns {string}
- */
-function bytesToUtf8(bytes) {
-  if (!isUint8Array(bytes)) throw new TypeError("bytes must be Uint8Array");
-  return _utf8Decoder.decode(bytes);
-}
-
-/**
- * Convert BytesLike to Uint8Array.
- * @param {string | Uint8Array} data
- * @returns {Uint8Array}
- */
-function arrayify(data) {
-  if (typeof data === "string") return hexToBytes(data);
-  if (isUint8Array(data)) return new Uint8Array(data);
-  throw new TypeError("unsupported BytesLike");
-}
-
-module.exports = {
-  isUint8Array,
-  normalizeHex,
-  toQuantityHex,
-  toQuantity,
-  isHexString,
-  strip0x,
-  add0x,
-  hexToBytes,
-  bytesToHex,
-  utf8ToBytes,
-  bytesToUtf8,
-  arrayify,
-};
-

package/example/node_modules/quantumcoin/src/providers/extra-providers.d.ts

@@ -1,139 +0,0 @@
-export class WebSocketProvider extends AbstractProvider {
-    /**
-     * Create a WebSocket JSON-RPC provider.
-     *
-     * This uses the built-in global `WebSocket` available in recent Node.js
-     * versions (via undici). No additional npm dependencies are required.
-     *
-     * @param {string} url WebSocket endpoint (e.g. ws://127.0.0.1:8546)
-     * @param {number=} chainId Optional chain id (compat)
-     */
-    constructor(url: string, chainId?: number | undefined);
-    url: string;
-    chainId: number;
-    /** @type {any|null} */
-    _ws: any | null;
-    /** @type {Promise<void>|null} */
-    _wsReady: Promise<void> | null;
-    /** @type {Map<number, { resolve: Function, reject: Function, timer: any }>} */
-    _pending: Map<number, {
-        resolve: Function;
-        reject: Function;
-        timer: any;
-    }>;
-    /**
-     * Close the underlying WebSocket connection and reject any pending requests.
-     * This is important for tests so the Node.js event loop can exit cleanly.
-     */
-    destroy(): void;
-    _rejectAllPending(err: any): void;
-    _connect(): Promise<void>;
-}
-export class IpcSocketProvider extends AbstractProvider {
-    /**
-     * Create an IPC provider.
-     *
-     * On Windows, use a named pipe path like: `\\\\.\\pipe\\geth.ipc`
-     * On Unix, use a domain socket path like: `/path/to/geth.ipc`
-     *
-     * @param {string} path IPC socket path
-     */
-    constructor(path: string);
-    path: string;
-}
-export class BrowserProvider extends AbstractProvider {
-    /**
-     * Create a BrowserProvider from an EIP-1193 provider (e.g. MetaMask).
-     *
-     * This is a lightweight implementation that focuses on the core behaviors:
-     * - `send(method, params)` dispatches EIP-1193 requests
-     * - `getSigner()` resolves the connected account
-     * - emits ethers-like `debug` events for request/response tracking
-     *
-     * @param {{ request: Function }} eip1193Provider
-     * @param {any=} network Unused (compat)
-     * @param {{ providerInfo?: any }=} options
-     */
-    constructor(eip1193Provider: {
-        request: Function;
-    }, network?: any | undefined, options?: {
-        providerInfo?: any;
-    } | undefined);
-    provider: {
-        request: Function;
-    };
-    providerInfo: any;
-    /**
-     * Send an EIP-1193 JSON-RPC request.
-     * @param {string} method
-     * @param {any[]|Record<string, any>=} params
-     * @returns {Promise<any>}
-     */
-    send(method: string, params?: (any[] | Record<string, any>) | undefined): Promise<any>;
-    /**
-     * Map an EIP-1193 error into a normalized Error.
-     * @param {{ method: string, params?: any }} payload
-     * @param {any} error
-     * @returns {Error}
-     */
-    getRpcError(payload: {
-        method: string;
-        params?: any;
-    }, error: any): Error;
-    /**
-     * Ethers compatibility: internal send for single or batched payloads.
-     * @param {any|any[]} payload
-     * @returns {Promise<any>}
-     */
-    _send(payload: any | any[]): Promise<any>;
-    /**
-     * Returns a signer for the specified account index or address.
-     * @param {number|string=} address
-     * @returns {Promise<JsonRpcSigner>}
-     */
-    getSigner(address?: (number | string) | undefined): Promise<JsonRpcSigner>;
-    /**
-     * Resolve whether this provider manages the address/index.
-     * @param {number|string} address
-     * @returns {Promise<boolean>}
-     */
-    hasSigner(address: number | string): Promise<boolean>;
-}
-/**
- * FallbackProvider - uses the first provider in the list.
- */
-export class FallbackProvider extends AbstractProvider {
-    /**
-     * @param {AbstractProvider[]|AbstractProvider} providers
-     */
-    constructor(providers: AbstractProvider[] | AbstractProvider);
-    providers: AbstractProvider[];
-    _perform(method: any, params: any): Promise<any>;
-}
-/**
- * FilterByBlockHash placeholder.
- */
-export class FilterByBlockHash {
-    constructor(blockHash: any, address: any, topics: any);
-    blockHash: string;
-    address: any;
-    topics: any;
-    toJSON(): {
-        blockHash: string;
-        address: any;
-        topics: any;
-    };
-}
-/**
- * Create a provider from an endpoint string. Detects connection type by scheme/path:
- * - http:// or https:// → JsonRpcProvider
- * - ws:// or wss:// → WebSocketProvider
- * - otherwise (e.g. \\\\.\\pipe\\geth.ipc or /path/to/geth.ipc) → IpcSocketProvider
- *
- * @param {string=} endpoint - RPC URL (http/https), WebSocket URL (ws/wss), or IPC path. If omitted or empty, uses default from Config (HTTP).
- * @param {number=} chainId - Chain ID (default 123123). Used for HTTP and WebSocket; ignored for IPC.
- * @returns {AbstractProvider}
- */
-export function getProvider(endpoint?: string | undefined, chainId?: number | undefined): AbstractProvider;
-import { AbstractProvider } from "./provider";
-import { JsonRpcSigner } from "../wallet/wallet";