@hardkas/kaspa-rpc 0.5.1-alpha → 0.5.3-alpha

package/dist/index.d.ts

@@ -120,7 +120,6 @@ interface RpcHealthResult {
     readonly circuitState?: string | undefined;
     readonly stale?: boolean | undefined;
 }
-
 declare function checkKaspaRpcHealth(options?: RpcHealthCheckOptions): Promise<RpcHealthResult>;
 declare function waitForKaspaRpcReady(options?: RpcReadinessWaitOptions): Promise<RpcHealthResult>;
 
@@ -171,6 +170,39 @@ declare class LoadBalancedRpcProvider implements KaspaRpcClient {
     private withFailover;
 }
 
+interface WrpcRequest {
+    id: number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface WrpcResponse {
+    id?: number;
+    result?: unknown;
+    params?: unknown;
+    error?: {
+        message: string;
+        code?: number;
+    };
+}
+declare class KaspaWrpcClient {
+    private url;
+    private ws;
+    private requestId;
+    private pending;
+    onNotification?: (msg: WrpcResponse) => void;
+    debug: boolean;
+    constructor(url: string);
+    getUrl(): string;
+    connect(timeoutMs?: number): Promise<void>;
+    request(method: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<unknown>;
+    getServerInfo(): Promise<unknown>;
+    getBlockDagInfo(): Promise<unknown>;
+    getVirtualSelectedParentBlueScore(): Promise<unknown>;
+    getUtxosByAddresses(addresses: string[]): Promise<unknown>;
+    ping(): Promise<boolean>;
+    disconnect(): void;
+}
+
 interface KaspaNodeInfo {
     serverVersion?: string | undefined;
     isSynced?: boolean | undefined;
@@ -290,4 +322,4 @@ declare class MockKaspaRpcClient implements KaspaRpcClient {
     close(): Promise<void>;
 }
 
-export { type BlockDagInfo, type CircuitBreakerOptions, CircuitState, JsonWrpcKaspaClient, type JsonWrpcKaspaClientOptions, type KaspaAddressBalance, KaspaJsonRpcClient, type KaspaNodeInfo, type KaspaRpcClient, type KaspaRpcHealth, type KaspaRpcOutpoint, type KaspaRpcUtxo, type KaspaSubmitTransactionResult, LoadBalancedRpcProvider, type LoadBalancerOptions, type MempoolEntry, MockKaspaRpcClient, type ResilienceReport, type RetryOptions, RpcCircuitOpenError, type RpcClientOptions, type RpcConfidence, RpcError, type RpcHealthCheckOptions, type RpcHealthResult, type RpcHealthState, RpcRateLimitError, type RpcReadinessWaitOptions, RpcTimeoutError, type RpcTrace, RpcUnavailableError, RpcValidationError, type ServerInfo, calculateConfidence, checkKaspaRpcHealth, classifyRpcError, mapKaspaAddressBalance, mapKaspaNodeInfo, mapKaspaRpcUtxos, mapKaspaSubmitTransactionResult, waitForKaspaRpcReady };
+export { type BlockDagInfo, type CircuitBreakerOptions, CircuitState, JsonWrpcKaspaClient, type JsonWrpcKaspaClientOptions, type KaspaAddressBalance, KaspaJsonRpcClient, type KaspaNodeInfo, type KaspaRpcClient, type KaspaRpcHealth, type KaspaRpcOutpoint, type KaspaRpcUtxo, type KaspaSubmitTransactionResult, KaspaWrpcClient, LoadBalancedRpcProvider, type LoadBalancerOptions, type MempoolEntry, MockKaspaRpcClient, type ResilienceReport, type RetryOptions, RpcCircuitOpenError, type RpcClientOptions, type RpcConfidence, RpcError, type RpcHealthCheckOptions, type RpcHealthResult, type RpcHealthState, RpcRateLimitError, type RpcReadinessWaitOptions, RpcTimeoutError, type RpcTrace, RpcUnavailableError, RpcValidationError, type ServerInfo, type WrpcRequest, type WrpcResponse, calculateConfidence, checkKaspaRpcHealth, classifyRpcError, mapKaspaAddressBalance, mapKaspaNodeInfo, mapKaspaRpcUtxos, mapKaspaSubmitTransactionResult, waitForKaspaRpcReady };

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { WebSocket } from "ws";
+import { WebSocket as WebSocket2 } from "ws";
 
 // src/errors.ts
 var RpcError = class extends Error {
@@ -438,11 +438,180 @@ var KaspaJsonRpcClient = class {
   }
 };
 
+// src/wrpc-client.ts
+import WebSocket from "ws";
+var KaspaWrpcClient = class {
+  url;
+  ws = null;
+  requestId = 0;
+  pending = /* @__PURE__ */ new Map();
+  onNotification;
+  debug = false;
+  constructor(url) {
+    if (url.startsWith("http://")) {
+      this.url = url.replace("http://", "ws://");
+    } else if (url.startsWith("https://")) {
+      this.url = url.replace("https://", "wss://");
+    } else if (!url.startsWith("ws://") && !url.startsWith("wss://")) {
+      this.url = `ws://${url}`;
+    } else {
+      this.url = url;
+    }
+  }
+  getUrl() {
+    return this.url;
+  }
+  async connect(timeoutMs = 5e3) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.disconnect();
+        reject(new Error(`WebSocket connection timeout after ${timeoutMs}ms to ${this.url}`));
+      }, timeoutMs);
+      try {
+        this.ws = new WebSocket(this.url);
+      } catch (err) {
+        clearTimeout(timer);
+        reject(new Error(`Failed to create WebSocket to ${this.url}: ${err}`));
+        return;
+      }
+      this.ws.on("open", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      this.ws.on("error", (err) => {
+        clearTimeout(timer);
+        reject(new Error(`WebSocket error: ${err.message}`));
+      });
+      this.ws.on("message", (data) => {
+        try {
+          const response = JSON.parse(data.toString());
+          if (response.id !== void 0) {
+            const pending = this.pending.get(response.id);
+            if (pending) {
+              clearTimeout(pending.timer);
+              this.pending.delete(response.id);
+              pending.resolve(response);
+            }
+          } else {
+            if (this.onNotification) {
+              this.onNotification(response);
+            }
+          }
+        } catch (parseErr) {
+          if (this.debug) {
+            console.debug("[wRPC] Non-JSON message received:", data.toString().slice(0, 200));
+          }
+        }
+      });
+      this.ws.on("close", () => {
+        for (const [, pending] of this.pending) {
+          clearTimeout(pending.timer);
+          pending.reject(new Error("WebSocket closed"));
+        }
+        this.pending.clear();
+      });
+    });
+  }
+  async request(method, params, timeoutMs = 5e3) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket not connected. Call connect() first.");
+    }
+    const id = ++this.requestId;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`wRPC timeout: ${method} (${timeoutMs}ms)`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (response) => {
+          if (response.error) {
+            const errMsg = response.error.message || `wRPC error code ${response.error.code || "unknown"}`;
+            reject(new Error(errMsg));
+          } else {
+            resolve(response.result !== void 0 ? response.result : response.params);
+          }
+        },
+        reject,
+        timer
+      });
+      this.ws.send(JSON.stringify({ id, method, params: params || {} }));
+    });
+  }
+  async getServerInfo() {
+    return this.request("getServerInfo");
+  }
+  async getBlockDagInfo() {
+    return this.request("getBlockDagInfo");
+  }
+  async getVirtualSelectedParentBlueScore() {
+    return this.request("getVirtualSelectedParentBlueScore");
+  }
+  async getUtxosByAddresses(addresses) {
+    return this.request("getUtxosByAddresses", { addresses });
+  }
+  async ping() {
+    try {
+      await this.getServerInfo();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  disconnect() {
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+    for (const [, pending] of this.pending) {
+      clearTimeout(pending.timer);
+    }
+    this.pending.clear();
+  }
+};
+
 // src/health.ts
 async function checkKaspaRpcHealth(options) {
-  const url = options?.url || "http://127.0.0.1:18210";
-  const client = new KaspaJsonRpcClient({ url, timeoutMs: options?.timeoutMs });
+  const url = options?.url || "ws://127.0.0.1:18210";
   const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const timeoutMs = options?.timeoutMs || 2e3;
+  if (url.startsWith("ws://") || url.startsWith("wss://") || url.includes("18210") || url.includes("18110")) {
+    const client2 = new KaspaWrpcClient(url);
+    const start = Date.now();
+    try {
+      await client2.connect(timeoutMs);
+      const info = await client2.getServerInfo();
+      const dagInfo = await client2.getBlockDagInfo();
+      const latencyMs = Date.now() - start;
+      client2.disconnect();
+      return {
+        endpoint: url,
+        status: "healthy",
+        ready: true,
+        checkedAt,
+        latencyMs,
+        networkId: dagInfo?.networkId || "simnet",
+        virtualDaaScore: dagInfo?.virtualDaaScore?.toString() || "0",
+        serverVersion: info?.serverVersion || "unknown",
+        isSynced: info?.isSynced ?? true,
+        lastError: null,
+        stale: !(info?.isSynced ?? true)
+      };
+    } catch (e) {
+      client2.disconnect();
+      return {
+        endpoint: url,
+        status: "unreachable",
+        ready: false,
+        checkedAt,
+        error: e.message,
+        lastError: e.message
+      };
+    }
+  }
+  const client = new KaspaJsonRpcClient({ url, timeoutMs });
   try {
     const health = await client.healthCheck();
     return {
@@ -487,7 +656,7 @@ async function waitForKaspaRpcReady(options) {
     await new Promise((resolve) => setTimeout(resolve, intervalMs));
   }
   return lastResult || {
-    endpoint: options?.url || "http://127.0.0.1:18210",
+    endpoint: options?.url || "ws://127.0.0.1:18210",
     status: "unreachable",
     ready: false,
     checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -766,11 +935,11 @@ var JsonWrpcKaspaClient = class {
     });
   }
   async connect() {
-    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+    if (this.socket && this.socket.readyState === WebSocket2.OPEN) {
       return this.socket;
     }
     return new Promise((resolve, reject) => {
-      const ws = new WebSocket(this.rpcUrl);
+      const ws = new WebSocket2(this.rpcUrl);
       const timeout = setTimeout(() => {
         ws.close();
         reject(new Error(`Cannot connect to Kaspa RPC at ${this.rpcUrl}. Connection timed out.`));
@@ -916,6 +1085,7 @@ export {
   CircuitState,
   JsonWrpcKaspaClient,
   KaspaJsonRpcClient,
+  KaspaWrpcClient,
   LoadBalancedRpcProvider,
   MockKaspaRpcClient,
   RpcCircuitOpenError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hardkas/kaspa-rpc",
-  "version": "0.5.1-alpha",
+  "version": "0.5.3-alpha",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -9,8 +9,8 @@
   },
   "dependencies": {
     "ws": "^8.18.0",
-    "@hardkas/core": "0.5.1-alpha",
-    "@hardkas/tx-builder": "0.5.1-alpha"
+    "@hardkas/core": "0.5.3-alpha",
+    "@hardkas/tx-builder": "0.5.3-alpha"
   },
   "devDependencies": {
     "@types/ws": "^8.5.13",