@ckb-ccc/core 0.0.13-alpha.0 → 0.0.13-alpha.1

package/src/client/clientPublicMainnet.ts

@@ -8,11 +8,17 @@ import { ClientJsonRpc } from "./jsonRpc/index.js";
  */
 export class ClientPublicMainnet extends ClientJsonRpc {
   constructor(
-    url = "https://mainnet.ckb.dev/",
+    url?: string,
     timeout?: number,
     private readonly scripts = MAINNET_SCRIPTS,
   ) {
-    super(url, timeout);
+    super(
+      url ??
+        (typeof WebSocket !== "undefined"
+          ? "wss://mainnet.ckb.dev/ws"
+          : "https://mainnet.ckb.dev/"),
+      timeout,
+    );
   }
 
   get addressPrefix(): string {

package/src/client/clientPublicTestnet.ts

@@ -8,11 +8,17 @@ import { ClientJsonRpc } from "./jsonRpc/index.js";
  */
 export class ClientPublicTestnet extends ClientJsonRpc {
   constructor(
-    url = "https://testnet.ckb.dev/",
+    url?: string,
     timeout?: number,
     private readonly scripts = TESTNET_SCRIPTS,
   ) {
-    super(url, timeout);
+    super(
+      url ??
+        (typeof WebSocket !== "undefined"
+          ? "wss://testnet.ckb.dev/ws"
+          : "https://testnet.ckb.dev/"),
+      timeout,
+    );
   }
 
   get addressPrefix(): string {

package/src/client/clientTypes.ts

@@ -17,6 +17,7 @@ export type OutputsValidator = "passthrough" | "well_known_scripts_only";
  * @public
  */
 export type TransactionStatus =
+  | "sent"
   | "pending"
   | "proposed"
   | "committed"

package/src/client/jsonRpc/index.ts

@@ -1,4 +1,3 @@
-import fetch from "cross-fetch";
 import { apply } from "../../barrel.js";
 import { TransactionLike } from "../../ckb/index.js";
 import { Hex, HexLike, hexFrom } from "../../hex/index.js";
@@ -10,7 +9,12 @@ import {
   ClientTransactionResponse,
   OutputsValidator,
 } from "../clientTypes.js";
-import { JsonRpcPayload, JsonRpcTransformers } from "./advanced.js";
+import {
+  JsonRpcPayload,
+  Transport,
+  transportFromUri,
+} from "../transports/advanced.js";
+import { JsonRpcTransformers } from "./advanced.js";
 
 /**
  * Applies a transformation function to a value if the transformer is provided.
@@ -42,18 +46,22 @@ async function transform(
  */
 
 export abstract class ClientJsonRpc extends Client {
+  private readonly transport: Transport;
+
   /**
    * Creates an instance of ClientJsonRpc.
    *
    * @param url_ - The URL of the JSON-RPC server.
-   * @param timeout - The timeout for requests in milliseconds, default is 30000.
+   * @param timeout - The timeout for requests in milliseconds
    */
 
   constructor(
     private readonly url_: string,
-    private readonly timeout = 30000,
+    private readonly timeout?: number,
   ) {
     super();
+
+    this.transport = transportFromUri(url_);
   }
 
   /**
@@ -232,22 +240,8 @@ export abstract class ClientJsonRpc extends Client {
    *
    * @throws Will throw an error if the response ID does not match the request ID, or if the response contains an error.
    */
-
   async send(payload: JsonRpcPayload): Promise<unknown> {
-    const aborter = new AbortController();
-    const abortTimer = setTimeout(() => aborter.abort(), this.timeout);
-
-    const raw = await fetch(this.url, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-      },
-      body: JSON.stringify(payload),
-      signal: aborter.signal,
-    });
-    clearTimeout(abortTimer);
-
-    const res = (await raw.json()) as {
+    const res = (await this.transport.request(payload)) as {
       id: number;
       error: unknown;
       result: unknown;

package/src/client/jsonRpc/types.ts

@@ -1,12 +1,5 @@
 import { Hex } from "../../hex/index.js";
 
-export type JsonRpcPayload = {
-  id: number;
-  jsonrpc: "2.0";
-  method: string;
-  params: unknown[] | Record<string, unknown>;
-};
-
 export type JsonRpcHashType = "type" | "data" | "data1" | "data2";
 export type JsonRpcDepType = "dep_group" | "code";
 

package/src/client/transports/advanced.ts

@@ -0,0 +1,14 @@
+import { TransportHttp } from "./http.js";
+import { TransportWebSocket } from "./webSocket.js";
+
+export * from "./http.js";
+export * from "./transport.js";
+export * from "./webSocket.js";
+
+export function transportFromUri(uri: string, config?: { timeout?: number }) {
+  if (uri.startsWith("wss://")) {
+    return new TransportWebSocket(uri, config?.timeout);
+  }
+
+  return new TransportHttp(uri, config?.timeout);
+}

package/src/client/transports/http.ts

@@ -0,0 +1,26 @@
+import { JsonRpcPayload, Transport } from "./transport.js";
+
+export class TransportHttp implements Transport {
+  constructor(
+    private readonly url: string,
+    private readonly timeout = 30000,
+  ) {}
+
+  async request(payload: JsonRpcPayload) {
+    const aborter = new AbortController();
+    const abortTimer = setTimeout(() => aborter.abort(), this.timeout);
+
+    const raw = await (
+      await fetch(this.url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+        },
+        body: JSON.stringify(payload),
+        signal: aborter.signal,
+      })
+    ).json();
+    clearTimeout(abortTimer);
+    return raw;
+  }
+}

package/src/client/transports/transport.ts

@@ -0,0 +1,10 @@
+export type JsonRpcPayload = {
+  id: number;
+  jsonrpc: "2.0";
+  method: string;
+  params: unknown[] | Record<string, unknown>;
+};
+
+export interface Transport {
+  request(data: JsonRpcPayload): Promise<unknown>;
+}

package/src/client/transports/webSocket.ts

@@ -0,0 +1,81 @@
+import { JsonRpcPayload, Transport } from "./transport.js";
+
+export class TransportWebSocket implements Transport {
+  private ongoing: Map<
+    number,
+    [
+      (response: unknown) => unknown,
+      (error: unknown) => unknown,
+      ReturnType<typeof setTimeout>,
+    ]
+  > = new Map();
+  private socket?: Promise<WebSocket>;
+
+  constructor(
+    private readonly url: string,
+    private readonly timeout = 30000,
+  ) {}
+
+  async request(data: JsonRpcPayload) {
+    const socket = (() => {
+      if (this.socket) {
+        return this.socket;
+      }
+
+      const socket = new WebSocket(this.url);
+      const onMessage = ({ data }: { data: string }) => {
+        const res = JSON.parse(data);
+        if (typeof res !== "object" || res === null) {
+          throw new Error(`Unknown response ${data}`);
+        }
+
+        const req = this.ongoing.get(res.id);
+        if (!req) {
+          return;
+        }
+        clearTimeout(req[2]);
+        this.ongoing.delete(res.id);
+
+        req[0](res);
+      };
+      const onClose = (error?: unknown) => {
+        this.socket = undefined;
+        this.ongoing.forEach(([_, onError]) =>
+          onError(error ?? new Error("Connection closed")),
+        );
+        this.ongoing.clear();
+      };
+
+      socket.onclose = onClose;
+      socket.onerror = onClose;
+      socket.onmessage = onMessage;
+
+      this.socket = new Promise((resolve) => {
+        if (socket.readyState === socket.CONNECTING) {
+          socket.onopen = resolve;
+        } else {
+          resolve(undefined);
+        }
+      }).then(() => socket);
+      return this.socket;
+    })();
+
+    return new Promise((resolve, reject) => {
+      this.ongoing.set(data.id, [
+        resolve,
+        reject,
+        setTimeout(() => reject(new Error("Request timeout")), this.timeout),
+      ]);
+      socket.then((socket) => {
+        if (
+          socket.readyState === socket.CLOSED ||
+          socket.readyState === socket.CLOSING
+        ) {
+          reject(new Error("Connection closed"));
+        } else {
+          socket.send(JSON.stringify(data));
+        }
+      });
+    });
+  }
+}