@ckb-ccc/core 1.21.0 → 1.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckb-ccc/core",
-  "version": "1.21.0",
+  "version": "1.22.0",
   "description": "Core of CCC - CKBer's Codebase",
   "author": "Hanssen0 <hanssen0@hanssen0.com>",
   "license": "MIT",

package/src/client/client.ts

@@ -450,7 +450,9 @@ export abstract class Client {
     after?: string,
   ): Promise<ClientFindCellsResponse> {
     const res = await this.findCellsPagedNoCache(key, order, limit, after);
-    await this.cache.recordCells(res.cells);
+    if (key.withData !== false) {
+      await this.cache.recordCells(res.cells);
+    }
     return res;
   }
 
@@ -645,7 +647,11 @@ export abstract class Client {
 
   /**
    * Resolve cell dependency info into concrete CellDep objects.
-   * If a CellDepInfo specifies a type script, the actual deployed cell is located on-chain.
+   *
+   * If a CellDepInfo specifies a type script, the live cell carrying it is looked up
+   * on-chain and, when found, its outpoint is used instead of the configured one. When
+   * the lookup finds nothing, the configured outpoint is used as written. A CellDepInfo
+   * without a type script is always used as written.
    *
    * @param cellDepsInfoLike - One or more CellDepInfo or arrays of CellDepInfo.
    * @returns Resolved CellDep array ready to be added to a transaction.

package/src/client/clientPublicMainnet.advanced.ts

@@ -1,6 +1,15 @@
 import { ScriptInfoLike } from "./clientTypes.js";
 import { KnownScript } from "./knownScript.js";
 
+/**
+ * The known scripts, with a cell dep outpoint recorded for each.
+ *
+ * An outpoint here is a starting point. A dep with a `type` is resolved on-chain by
+ * {@link Client.getCellDeps} before use, so its outpoint keeps working after the code
+ * cell moves and may look spent when checked directly. Only a dep without a `type`
+ * needs updating when its cell moves. See #531.
+ */
+
 export const MAINNET_SCRIPTS: Record<KnownScript, ScriptInfoLike | undefined> =
   Object.freeze({
     [KnownScript.NervosDao]: {

package/src/client/clientPublicTestnet.advanced.ts

@@ -1,6 +1,15 @@
 import { ScriptInfoLike } from "./clientTypes.js";
 import { KnownScript } from "./knownScript.js";
 
+/**
+ * The known scripts, with a cell dep outpoint recorded for each.
+ *
+ * An outpoint here is a starting point. A dep with a `type` is resolved on-chain by
+ * {@link Client.getCellDeps} before use, so its outpoint keeps working after the code
+ * cell moves and may look spent when checked directly. Only a dep without a `type`
+ * needs updating when its cell moves. See #531.
+ */
+
 export const TESTNET_SCRIPTS: Record<KnownScript, ScriptInfoLike> =
   Object.freeze({
     [KnownScript.NervosDao]: {

package/src/jsonRpc/requestor.ts

@@ -1,11 +1,14 @@
+import { abortSignalToPromise } from "../utils/abortSignal.js";
 import { OwnerAggregated } from "../utils/owner/aggregated.js";
 import { Owner } from "../utils/owner/owner.js";
 import { jsonRpcTransportFromUri } from "./transports/factory.js";
 import { JsonRpcTransportFallback } from "./transports/fallback.js";
 import {
+  JsonRpcError,
   JsonRpcPayload,
   JsonRpcResponse,
   JsonRpcTransport,
+  JsonRpcTransportRequestOptions,
 } from "./transports/index.js";
 
 function openTransports(
@@ -146,6 +149,7 @@ export class RequestorJsonRpc {
     inTransformers?: (((_: any) => unknown) | undefined)[],
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     outTransformer?: (_: any) => unknown,
+    options?: JsonRpcTransportRequestOptions,
   ): Promise<unknown> {
     const payload = this.buildPayload(
       rpcMethod,
@@ -164,7 +168,7 @@ export class RequestorJsonRpc {
 
     try {
       return await transform(
-        await this.requestPayload(payload),
+        await this.requestPayload(payload, options),
         outTransformer,
       );
     } catch (err: unknown) {
@@ -175,21 +179,41 @@ export class RequestorJsonRpc {
     }
   }
 
-  async requestPayload(payload: JsonRpcPayload): Promise<unknown> {
+  async requestPayload(
+    payload: JsonRpcPayload,
+    options?: JsonRpcTransportRequestOptions,
+  ): Promise<unknown> {
     if (
       this.maxConcurrent !== undefined &&
       this.concurrent >= this.maxConcurrent
     ) {
-      const pending = new Promise<void>((resolve) =>
-        this.pending.push(resolve),
-      );
-      await pending;
+      options?.signal?.throwIfAborted();
+      let resolvePending: (() => void) | undefined;
+      const pending = new Promise<void>((resolve) => {
+        resolvePending = resolve;
+        this.pending.push(resolve);
+      });
+      try {
+        await (options?.signal
+          ? Promise.race([pending, abortSignalToPromise(options.signal)])
+          : pending);
+      } catch (cause) {
+        const index = resolvePending
+          ? this.pending.indexOf(resolvePending)
+          : -1;
+        if (index !== -1) {
+          this.pending.splice(index, 1);
+        } else {
+          this.pending.shift()?.();
+        }
+        throw cause;
+      }
     }
 
     const res: JsonRpcResponse = await (async () => {
       this.concurrent += 1;
       try {
-        return await this.transport.request(payload);
+        return await this.transport.request(payload, options);
       } finally {
         this.concurrent -= 1;
         this.pending.shift()?.();
@@ -200,7 +224,7 @@ export class RequestorJsonRpc {
       throw new Error(`Id mismatched, got ${res.id}, expected ${payload.id}`);
     }
     if (res.error != null) {
-      throw res.error as unknown;
+      throw new JsonRpcError(res.error);
     }
     return res.result;
   }

package/src/jsonRpc/transports/fallback.ts

@@ -2,6 +2,7 @@ import {
   JsonRpcPayload,
   JsonRpcResponse,
   JsonRpcTransport,
+  JsonRpcTransportRequestOptions,
 } from "./transport.js";
 
 export class JsonRpcTransportFallback implements JsonRpcTransport {
@@ -10,7 +11,10 @@ export class JsonRpcTransportFallback implements JsonRpcTransport {
 
   constructor(private readonly transports: JsonRpcTransport[]) {}
 
-  async request(data: JsonRpcPayload): Promise<JsonRpcResponse> {
+  async request(
+    data: JsonRpcPayload,
+    options?: JsonRpcTransportRequestOptions,
+  ): Promise<JsonRpcResponse> {
     const startI = this.i;
     let lastErr: unknown = new Error(
       "JsonRpcTransportFallback requires at least one transport",
@@ -20,7 +24,7 @@ export class JsonRpcTransportFallback implements JsonRpcTransport {
       const i = (startI + tried) % this.transports.length;
 
       try {
-        const res = await this.transports[i].request(data);
+        const res = await this.transports[i].request(data, options);
 
         this.i = i;
         return res;

package/src/jsonRpc/transports/http.ts

@@ -1,7 +1,9 @@
+import { abortSignalAny } from "../../utils/abortSignal.js";
 import {
   JsonRpcPayload,
   JsonRpcResponse,
   JsonRpcTransport,
+  JsonRpcTransportRequestOptions,
 } from "./transport.js";
 
 export class JsonRpcTransportHttp implements JsonRpcTransport {
@@ -10,23 +12,24 @@ export class JsonRpcTransportHttp implements JsonRpcTransport {
     private readonly timeout = 30000,
   ) {}
 
-  async request(payload: JsonRpcPayload): Promise<JsonRpcResponse> {
-    const aborter = new AbortController();
-    const abortTimer = setTimeout(() => aborter.abort(), this.timeout);
+  async request(
+    payload: JsonRpcPayload,
+    options?: JsonRpcTransportRequestOptions,
+  ): Promise<JsonRpcResponse> {
+    const timeoutSignal = AbortSignal.timeout(options?.timeout ?? this.timeout);
+    const signal = options?.signal
+      ? abortSignalAny([options.signal, timeoutSignal])
+      : timeoutSignal;
 
-    try {
-      return (await (
-        await fetch(this.url, {
-          method: "POST",
-          headers: {
-            "content-type": "application/json",
-          },
-          body: JSON.stringify(payload),
-          signal: aborter.signal,
-        })
-      ).json()) as JsonRpcResponse;
-    } finally {
-      clearTimeout(abortTimer);
-    }
+    return (await (
+      await fetch(this.url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+        },
+        body: JSON.stringify(payload),
+        signal,
+      })
+    ).json()) as JsonRpcResponse;
   }
 }

package/src/jsonRpc/transports/transport.ts

@@ -33,6 +33,13 @@ export type JsonRpcResponse<Result = unknown, ErrorData = unknown> = {
   | { result?: never; error: JsonRpcErrorLike<ErrorData> }
 );
 
+export type JsonRpcTransportRequestOptions = {
+  /** Cancels this individual request without disposing the transport. */
+  signal?: AbortSignal;
+  /** Overrides the transport's default timeout for this request. */
+  timeout?: number;
+};
+
 export interface JsonRpcTransport {
   /**
    * Sends a JSON-RPC request to the server.
@@ -40,5 +47,8 @@ export interface JsonRpcTransport {
    * @param payload - The JSON-RPC payload to send.
    * @returns The JSON-RPC response.
    */
-  request(payload: JsonRpcPayload): Promise<JsonRpcResponse>;
+  request(
+    payload: JsonRpcPayload,
+    options?: JsonRpcTransportRequestOptions,
+  ): Promise<JsonRpcResponse>;
 }

package/src/jsonRpc/transports/webSocket.ts

@@ -5,17 +5,21 @@ import {
   JsonRpcPayload,
   JsonRpcResponse,
   JsonRpcTransport,
+  JsonRpcTransportRequestOptions,
 } from "./transport.js";
 
+const SOCKET_TIMEOUT_GRACE_PERIOD = 10_000;
+
 export class JsonRpcTransportWebSocket implements JsonRpcTransport {
   private ongoing: Map<
     JsonRpcId,
     [
       (response: JsonRpcResponse) => unknown,
       (error: unknown) => unknown,
-      ReturnType<typeof setTimeout>,
+      WebSocket,
     ]
   > = new Map();
+  private firstTimeout?: { socket: WebSocket; at: number };
   private disposed = false;
   private socket?: WebSocket;
   private openSocket?: Promise<WebSocket>;
@@ -39,12 +43,20 @@ export class JsonRpcTransportWebSocket implements JsonRpcTransport {
     return new OwnerUnique(transport, (transport) => transport.dispose());
   }
 
-  request(data: JsonRpcPayload): Promise<JsonRpcResponse> {
+  request(
+    data: JsonRpcPayload,
+    options?: JsonRpcTransportRequestOptions,
+  ): Promise<JsonRpcResponse> {
     if (this.disposed) {
       return Promise.reject(
         new Error("Cannot use a disposed JsonRpcTransportWebSocket"),
       );
     }
+    if (options?.signal?.aborted) {
+      return Promise.reject(
+        options.signal.reason ?? new Error("Request aborted"),
+      );
+    }
 
     const [socketUnsafe, socket] = (() => {
       if (
@@ -71,23 +83,26 @@ export class JsonRpcTransportWebSocket implements JsonRpcTransport {
           return;
         }
         const id = res.id;
+        if (this.firstTimeout?.socket === socket) {
+          this.firstTimeout = undefined;
+        }
 
         const req = this.ongoing.get(id);
-        if (!req) {
+        if (!req || req[2] !== socket) {
           return;
         }
-        const [resolve, _, timeout] = req;
-        clearTimeout(timeout);
-        this.ongoing.delete(id);
-
+        const [resolve] = req;
         resolve(res);
       };
       const onClose = () => {
-        this.ongoing.forEach(([_, reject, timeout]) => {
-          clearTimeout(timeout);
-          reject(new Error("Connection closed"));
+        if (this.firstTimeout?.socket === socket) {
+          this.firstTimeout = undefined;
+        }
+        this.ongoing.forEach(([_, reject, requestSocket]) => {
+          if (requestSocket === socket) {
+            reject(new Error("Connection closed"));
+          }
         });
-        this.ongoing.clear();
       };
 
       socket.onclose = onClose;
@@ -108,41 +123,84 @@ export class JsonRpcTransportWebSocket implements JsonRpcTransport {
     })();
 
     return new Promise<JsonRpcResponse>((resolve, reject) => {
+      const abortSignal = options?.signal;
+      let timeout: ReturnType<typeof setTimeout>;
       const req: [
         (res: JsonRpcResponse) => unknown,
         (err: unknown) => unknown,
-        ReturnType<typeof setTimeout>,
+        WebSocket,
       ] = [
-        resolve,
-        reject,
-        setTimeout(() => {
-          this.ongoing.delete(data.id);
-          socketUnsafe.close();
-          reject(new Error("Request timeout"));
-        }, this.timeout),
+        (response) => {
+          if (cleanup()) {
+            resolve(response);
+          }
+        },
+        (error) => {
+          if (cleanup()) {
+            reject(error);
+          }
+        },
+        socketUnsafe,
       ];
+      const cleanup = () => {
+        if (this.ongoing.get(data.id) !== req) {
+          return false;
+        }
+        this.ongoing.delete(data.id);
+        clearTimeout(timeout);
+        abortSignal?.removeEventListener("abort", onAbort);
+        return true;
+      };
+      const onAbort = () => {
+        req[1](abortSignal?.reason ?? new Error("Request aborted"));
+      };
+
+      timeout = setTimeout(() => {
+        if (this.ongoing.get(data.id) === req) {
+          req[1](new Error("Request timeout"));
+          const hasPending = [...this.ongoing.values()].some(
+            ([, , requestSocket]) => requestSocket === socketUnsafe,
+          );
+          if (!hasPending) {
+            socketUnsafe.close();
+            return;
+          }
+
+          const firstTimeout = this.firstTimeout;
+          if (firstTimeout?.socket !== socketUnsafe) {
+            this.firstTimeout = { socket: socketUnsafe, at: Date.now() };
+          } else if (
+            Date.now() - firstTimeout.at >=
+            SOCKET_TIMEOUT_GRACE_PERIOD
+          ) {
+            socketUnsafe.close();
+          }
+        }
+      }, options?.timeout ?? this.timeout);
       this.ongoing.set(data.id, req);
 
+      abortSignal?.addEventListener("abort", onAbort, { once: true });
+      if (abortSignal?.aborted) {
+        onAbort();
+        return;
+      }
+
       void socket
         .then((socket) => {
-          if (!this.ongoing.has(data.id)) {
+          if (this.ongoing.get(data.id) !== req) {
             return;
           }
           if (
             socket.readyState === socket.CLOSED ||
             socket.readyState === socket.CLOSING
           ) {
-            clearTimeout(req[2]);
-            this.ongoing.delete(data.id);
-            reject(new Error("Connection closed"));
+            req[1](new Error("Connection closed"));
           } else {
             socket.send(JSON.stringify(data));
           }
         })
         .catch((err) => {
-          clearTimeout(req[2]);
-          this.ongoing.delete(data.id);
-          reject(err);
+          req[1](err);
         });
     });
   }

package/src/signer/btc/psbt.ts

@@ -5,7 +5,7 @@ import { Hex, HexLike, hexFrom } from "../../hex/index.js";
  */
 export type SignPsbtOptionsLike = {
   /**
-   * Whether to finalize the PSBT after signing.
+   * Whether to attempt to finalize the signed inputs after signing.
    * Default is true.
    */
   autoFinalized?: boolean;
@@ -21,7 +21,9 @@ export class SignPsbtOptions {
     public inputsToSign: InputToSign[],
   ) {}
 
-  static from(options?: SignPsbtOptionsLike): SignPsbtOptions {
+  static from(
+    options?: SignPsbtOptionsLike | SignPsbtOptions,
+  ): SignPsbtOptions {
     if (options instanceof SignPsbtOptions) {
       return options;
     }