quantumcoin 7.0.14 → 8.0.0

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

@@ -1,139 +1,141 @@
-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";
+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;
+    _wsRpcId: 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 | null>;
+}
+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;
+    _ipcRpcId: number;
+}
+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";

package/src/providers/extra-providers.js

@@ -8,13 +8,26 @@
 const { AbstractProvider } = require("./provider");
 const { JsonRpcProvider } = require("./json-rpc-provider");
 const { makeError } = require("../errors");
-const net = require("node:net");
 const { JsonRpcSigner } = require("../wallet/wallet");
 const { normalizeHex, isHexString } = require("../internal/hex");
 
 const MAX_RESPONSE_SIZE = 16 * 1024 * 1024;
 const MAX_IPC_BUFFER = 16 * 1024 * 1024;
 
+/**
+ * Lazily load Node's "net" module. IPC transport is Node-only; loading it on
+ * demand keeps the providers barrel importable in browsers (where bundlers can
+ * exclude "node:net" via the package "browser" field).
+ * @returns {import("node:net")}
+ */
+function _requireNet() {
+  try {
+    return require("node:net");
+  } catch {
+    throw makeError("IPC not available in this environment", "NOT_IMPLEMENTED", {});
+  }
+}
+
 function _bigIntReplacer(_key, value) {
   return typeof value === "bigint" ? "0x" + value.toString(16) : value;
 }
@@ -297,6 +310,7 @@ class IpcSocketProvider extends AbstractProvider {
       /** @type {string} */
       let buffer = "";
 
+      const net = _requireNet();
       const socket = net.createConnection(this.path);
       socket.setEncoding("utf8");
       socket.setTimeout(30_000);

package/src/providers/index.d.ts

@@ -1,17 +1,18 @@
-declare const _exports: {
-    getProvider(endpoint?: string | undefined, chainId?: number | undefined): import("./provider").AbstractProvider;
-    WebSocketProvider: typeof import("./extra-providers").WebSocketProvider;
-    IpcSocketProvider: typeof import("./extra-providers").IpcSocketProvider;
-    BrowserProvider: typeof import("./extra-providers").BrowserProvider;
-    FallbackProvider: typeof import("./extra-providers").FallbackProvider;
-    FilterByBlockHash: typeof import("./extra-providers").FilterByBlockHash;
-    JsonRpcProvider: typeof import("./json-rpc-provider").JsonRpcProvider;
-    JsonRpcApiProvider: typeof import("./json-rpc-provider").JsonRpcApiProvider;
-    Provider: typeof import("./provider").Provider;
-    AbstractProvider: typeof import("./provider").AbstractProvider;
-    Block: typeof import("./provider").Block;
-    TransactionResponse: typeof import("./provider").TransactionResponse;
-    TransactionReceipt: typeof import("./provider").TransactionReceipt;
-    Log: typeof import("./provider").Log;
-};
-export = _exports;
+declare const _exports: {
+    getProvider(endpoint?: string | undefined, chainId?: number | undefined): import("./provider").AbstractProvider;
+    WebSocketProvider: typeof import("./extra-providers").WebSocketProvider;
+    IpcSocketProvider: typeof import("./extra-providers").IpcSocketProvider;
+    BrowserProvider: typeof import("./extra-providers").BrowserProvider;
+    FallbackProvider: typeof import("./extra-providers").FallbackProvider;
+    FilterByBlockHash: typeof import("./extra-providers").FilterByBlockHash;
+    JsonRpcProvider: typeof import("./json-rpc-provider").JsonRpcProvider;
+    JsonRpcApiProvider: typeof import("./json-rpc-provider").JsonRpcApiProvider;
+    Provider: typeof import("./provider").Provider;
+    AbstractProvider: typeof import("./provider").AbstractProvider;
+    Block: typeof import("./provider").Block;
+    TransactionResponse: typeof import("./provider").TransactionResponse;
+    TransactionReceipt: typeof import("./provider").TransactionReceipt;
+    Log: typeof import("./provider").Log;
+    FeeData: typeof import("./provider").FeeData;
+};
+export = _exports;

package/src/providers/json-rpc-provider.d.ts

@@ -6,6 +6,7 @@ export class JsonRpcProvider extends AbstractProvider {
     constructor(url?: string | undefined, chainId?: number | undefined);
     url: string;
     chainId: number;
+    _rpcId: number;
 }
 export class JsonRpcApiProvider extends JsonRpcProvider {
 }