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

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));
+        }
+      });
+    });
+  }
+}