quantumcoin 7.0.3 → 7.0.5

package/src/internal/hex.js

@@ -1,144 +1,144 @@
-/**
- * @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;
-}
-
-/**
- * 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,
-  isHexString,
-  strip0x,
-  add0x,
-  hexToBytes,
-  bytesToHex,
-  utf8ToBytes,
-  bytesToUtf8,
-  arrayify,
-};
-
+/**
+ * @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;
+}
+
+/**
+ * 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,
+  isHexString,
+  strip0x,
+  add0x,
+  hexToBytes,
+  bytesToHex,
+  utf8ToBytes,
+  bytesToUtf8,
+  arrayify,
+};
+

package/src/providers/extra-providers.d.ts

@@ -1,128 +1,139 @@
-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;
-    };
-}
-import { AbstractProvider } from "./provider";
-import { JsonRpcSigner } from "../wallet/wallet";
+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";