@ckb-ccc/core 2.0.0-next.0 → 2.0.0-next.1

package/src/jsonRpc/transports/webSocket.ts

@@ -1,63 +1,108 @@
 import WebSocket from "isomorphic-ws";
-import { JsonRpcPayload, Transport } from "./transport.js";
+import { OwnerUnique } from "../../utils/owner/unique.js";
+import {
+  JsonRpcId,
+  JsonRpcPayload,
+  JsonRpcResponse,
+  JsonRpcTransport,
+  JsonRpcTransportRequestOptions,
+} from "./transport.js";
 
-export class TransportWebSocket implements Transport {
+const SOCKET_TIMEOUT_GRACE_PERIOD = 10_000;
+
+export class JsonRpcTransportWebSocket implements JsonRpcTransport {
   private ongoing: Map<
-    number,
+    JsonRpcId,
     [
-      (response: unknown) => unknown,
+      (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>;
 
+  /**
+   * @deprecated Use {@link JsonRpcTransportWebSocket.open} to make lifecycle
+   * ownership explicit. This constructor will become private in a future
+   * release.
+   */
   constructor(
     private readonly url: string,
     private readonly timeout = 30000,
   ) {}
 
-  request(data: JsonRpcPayload) {
-    const socket = (() => {
+  /** Opens an owned WebSocket transport. */
+  static open(
+    url: string,
+    timeout = 30000,
+  ): OwnerUnique<JsonRpcTransportWebSocket> {
+    const transport = new JsonRpcTransportWebSocket(url, timeout);
+    return new OwnerUnique(transport, (transport) => transport.dispose());
+  }
+
+  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 (
         this.socket &&
         this.socket.readyState !== this.socket.CLOSING &&
         this.socket.readyState !== this.socket.CLOSED &&
         this.openSocket
       ) {
-        return this.openSocket;
+        return [this.socket, this.openSocket] as const;
       }
       const socket = new WebSocket(this.url);
       const onMessage = ({ data }: WebSocket.MessageEvent) => {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const res = JSON.parse(data as string);
+        let res: JsonRpcResponse;
+        try {
+          res = JSON.parse(data as string) as JsonRpcResponse;
+        } catch (_) {
+          return;
+        }
         if (
           typeof res !== "object" ||
           res === null ||
-          typeof res.id !== "number"
+          (typeof res.id !== "number" && typeof res.id !== "string")
         ) {
-          throw new Error(`Unknown response ${data as string}`);
+          return;
+        }
+        const id = res.id;
+        if (this.firstTimeout?.socket === socket) {
+          this.firstTimeout = undefined;
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const id: number = res.id;
 
         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;
@@ -74,41 +119,101 @@ export class TransportWebSocket implements Transport {
           };
         }
       });
-      return this.openSocket;
+      return [socket, this.openSocket] as const;
     })();
 
-    return new Promise((resolve, reject) => {
+    return new Promise<JsonRpcResponse>((resolve, reject) => {
+      const abortSignal = options?.signal;
+      let timeout: ReturnType<typeof setTimeout>;
       const req: [
-        (res: unknown) => unknown,
+        (res: JsonRpcResponse) => unknown,
         (err: unknown) => unknown,
-        ReturnType<typeof setTimeout>,
+        WebSocket,
       ] = [
-        resolve,
-        reject,
-        setTimeout(() => {
-          this.ongoing.delete(data.id);
-          void socket
-            .then((socket) => socket.close())
-            .catch((err) => reject(err));
-          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.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) => reject(err));
+        .catch((err) => {
+          req[1](err);
+        });
+    });
+  }
+
+  private async dispose(): Promise<void> {
+    this.disposed = true;
+    const socket = this.socket;
+
+    if (!socket || socket.readyState === socket.CLOSED) return;
+
+    await new Promise<void>((resolve) => {
+      socket.addEventListener("close", () => resolve(), { once: true });
+      socket.close();
     });
   }
 }

package/src/keystore/index.ts

@@ -14,7 +14,7 @@ const DEFAULT_SCRYPT_PARAM_N = 262144;
 
 function mac(derivedKey: Bytes, cipherText: Bytes) {
   return hexFrom(
-    keccak_256(bytesConcat(derivedKey.slice(16, 32), cipherText)),
+    keccak_256(bytesConcat(derivedKey.subarray(16, 32), cipherText)),
   ).slice(2);
 }
 
@@ -60,7 +60,7 @@ export async function keystoreEncrypt(
     dkLen: kdfparams.dklen,
   });
   const cipher = ctr(
-    derivedKey.slice(0, 16),
+    derivedKey.subarray(0, 16),
     iv.map((v) => v),
   );
   const ciphertext = cipher.encrypt(
@@ -151,7 +151,7 @@ export async function keystoreDecrypt(
     throw Error("Invalid password");
   }
   const cipher = ctr(
-    derivedKey.slice(0, 16),
+    derivedKey.subarray(0, 16),
     bytesFrom(crypto.cipherparams.iv),
   );
   const result = cipher.decrypt(ciphertext);

package/src/molecule/codec.ts

@@ -86,7 +86,7 @@ export function fixedItemVec<Encodable, Decoded>(
           `fixedItemVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`,
         );
       }
-      const itemCount = uint32From(value.slice(0, 4));
+      const itemCount = uint32From(value.subarray(0, 4));
       const byteLength = 4 + itemCount * itemByteLength;
       if (value.byteLength !== byteLength) {
         throw new Error(
@@ -99,7 +99,7 @@ export function fixedItemVec<Encodable, Decoded>(
         for (let offset = 4; offset < byteLength; offset += itemByteLength) {
           decodedArray.push(
             itemCodec.decode(
-              value.slice(offset, offset + itemByteLength),
+              value.subarray(offset, offset + itemByteLength),
               config,
             ),
           );
@@ -155,7 +155,7 @@ export function dynItemVec<Encodable, Decoded>(
           `dynItemVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`,
         );
       }
-      const byteLength = uint32From(value.slice(0, 4));
+      const byteLength = uint32From(value.subarray(0, 4));
       if (byteLength !== value.byteLength) {
         throw new Error(
           `dynItemVec: invalid buffer size, expected ${byteLength}, but got ${value.byteLength}`,
@@ -166,10 +166,10 @@ export function dynItemVec<Encodable, Decoded>(
         return [];
       }
 
-      const offset = uint32From(value.slice(4, 8));
+      const offset = uint32From(value.subarray(4, 8));
       const itemCount = (offset - 4) / 4;
       const offsets = Array.from(new Array(itemCount), (_, index) =>
-        uint32From(value.slice(4 + index * 4, 8 + index * 4)),
+        uint32From(value.subarray(4 + index * 4, 8 + index * 4)),
       );
       offsets.push(byteLength);
       try {
@@ -177,7 +177,7 @@ export function dynItemVec<Encodable, Decoded>(
         for (let index = 0; index < offsets.length - 1; index++) {
           const start = offsets[index];
           const end = offsets[index + 1];
-          const itemBuffer = value.slice(start, end);
+          const itemBuffer = value.subarray(start, end);
           decodedArray.push(itemCodec.decode(itemBuffer, config));
         }
         return decodedArray;
@@ -281,14 +281,14 @@ export function byteVec<Encodable, Decoded>(
           `byteVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`,
         );
       }
-      const byteLength = uint32From(value.slice(0, 4));
+      const byteLength = uint32From(value.subarray(0, 4));
       if (byteLength !== value.byteLength - 4) {
         throw new Error(
           `byteVec: invalid buffer size, expected ${byteLength}, but got ${value.byteLength}`,
         );
       }
       try {
-        return codec.decode(value.slice(4), config);
+        return codec.decode(value.subarray(4), config);
       } catch (e: unknown) {
         throw new Error(`byteVec - ${getMessage(e)}`, { cause: e });
       }
@@ -375,8 +375,8 @@ export function table<
           `table: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`,
         );
       }
-      const byteLength = uint32From(value.slice(0, 4));
-      const headerLength = uint32From(value.slice(4, 8));
+      const byteLength = uint32From(value.subarray(0, 4));
+      const headerLength = uint32From(value.subarray(4, 8));
       const actualFieldCount = (headerLength - 4) / 4;
 
       if (byteLength !== value.byteLength) {
@@ -397,12 +397,12 @@ export function table<
         );
       }
       const offsets = keys.map((_, index) =>
-        uint32From(value.slice(4 + index * 4, 8 + index * 4)),
+        uint32From(value.subarray(4 + index * 4, 8 + index * 4)),
       );
       // If there are extra fields, add the last offset to the offsets array
       if (actualFieldCount > keys.length) {
         offsets.push(
-          uint32From(value.slice(4 + keys.length * 4, 8 + keys.length * 4)),
+          uint32From(value.subarray(4 + keys.length * 4, 8 + keys.length * 4)),
         );
       } else {
         // If there are no extra fields, add the byte length to the offsets array
@@ -414,7 +414,7 @@ export function table<
         const end = offsets[i + 1];
         const field = keys[i];
         const codec = codecLayout[field];
-        const payload = value.slice(start, end);
+        const payload = value.subarray(start, end);
         try {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           Object.assign(object, { [field]: codec.decode(payload, config) });
@@ -563,7 +563,7 @@ export function union<T extends Record<string, CodecLike<any, any>>>(
     },
     decode(buffer, config) {
       const value = bytesFrom(buffer);
-      const fieldIndex = uint32From(value.slice(0, 4));
+      const fieldIndex = uint32From(value.subarray(0, 4));
       const keys = Object.keys(codecLayout);
 
       const field = (() => {
@@ -591,7 +591,7 @@ export function union<T extends Record<string, CodecLike<any, any>>>(
       return {
         type: field,
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        value: codecLayout[field].decode(value.slice(4), config),
+        value: codecLayout[field].decode(value.subarray(4), config),
       } as UnionDecoded<T>;
     },
     from(encodable) {
@@ -660,7 +660,7 @@ export function struct<
       const object = {};
       let offset = 0;
       Object.entries(codecLayout).forEach(([key, codec]) => {
-        const payload = value.slice(offset, offset + codec.byteLength!);
+        const payload = value.subarray(offset, offset + codec.byteLength!);
         try {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           Object.assign(object, { [key]: codec.decode(payload, config) });
@@ -728,7 +728,10 @@ export function array<Encodable, Decoded>(
         const result: Array<Decoded> = [];
         for (let i = 0; i < value.byteLength; i += itemCodec.byteLength!) {
           result.push(
-            itemCodec.decode(value.slice(i, i + itemCodec.byteLength!), config),
+            itemCodec.decode(
+              value.subarray(i, i + itemCodec.byteLength!),
+              config,
+            ),
           );
         }
         return result;

package/src/signer/advanced.ts

@@ -0,0 +1 @@
+export * from "./jsonRpc/transformers.js";

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

package/src/signer/btc/verify.ts

@@ -78,7 +78,7 @@ export function btcP2pkhAddressFromPublicKey(
  * @public
  */
 export function btcPublicKeyFromP2pkhAddress(address: string): Hex {
-  return hexFrom(bs58check.decode(address).slice(1));
+  return hexFrom(bs58check.decode(address).subarray(1));
 }
 
 /**
@@ -92,7 +92,7 @@ export function verifyMessageBtcEcdsa(
   const challenge =
     typeof message === "string" ? message : hexFrom(message).slice(2);
 
-  const rawSign = bytesFrom(signature, "base64").slice(1);
+  const rawSign = bytesFrom(signature, "base64").subarray(1);
 
   return secp256k1.verify(
     bytesFrom(rawSign),

package/src/signer/ckb/secp256k1Signing.ts

@@ -21,7 +21,7 @@ export function signMessageSecp256k1(
     format: "recovered",
     prehash: false,
   });
-  return hexFrom(bytesConcat(signature.slice(1), signature.slice(0, 1)));
+  return hexFrom(bytesConcat(signature.subarray(1), signature.subarray(0, 1)));
 }
 
 /**
@@ -40,7 +40,7 @@ export function verifyMessageSecp256k1(
 ): boolean {
   const signatureBytes = bytesFrom(signature);
   return secp256k1.verify(
-    bytesConcat(signatureBytes.slice(64), signatureBytes.slice(0, 64)),
+    bytesConcat(signatureBytes.subarray(64), signatureBytes.subarray(0, 64)),
     bytesFrom(message),
     bytesFrom(publicKey),
     { format: "recovered", prehash: false },
@@ -62,7 +62,7 @@ export function recoverMessageSecp256k1(
   const signatureBytes = bytesFrom(signature);
   return hexFrom(
     secp256k1.recoverPublicKey(
-      bytesConcat(signatureBytes.slice(64), signatureBytes.slice(0, 64)),
+      bytesConcat(signatureBytes.subarray(64), signatureBytes.subarray(0, 64)),
       bytesFrom(message),
       { prehash: false },
     ),

package/src/signer/doge/signerDoge.ts

@@ -53,7 +53,7 @@ export abstract class SignerDoge extends Signer {
    * @returns A promise that resolves to an array of Address objects.
    */
   async getAddressObjs(): Promise<Address[]> {
-    const hash = bs58check.decode(await this.getDogeAddress()).slice(1);
+    const hash = bs58check.decode(await this.getDogeAddress()).subarray(1);
 
     return [
       await Address.fromKnownScript(

package/src/signer/doge/signerDogePrivateKey.ts

@@ -93,7 +93,7 @@ export class SignerDogePrivateKey extends SignerDoge {
       },
     );
     return bytesTo(
-      bytesConcat([31 + Number(signature[0])], signature.slice(1)),
+      bytesConcat([31 + Number(signature[0])], signature.subarray(1)),
       "base64",
     );
   }

package/src/signer/index.ts

@@ -3,6 +3,7 @@ export * from "./ckb/index.js";
 export * from "./doge/index.js";
 export * from "./dummy/index.js";
 export * from "./evm/index.js";
+export * from "./jsonRpc/index.js";
 export * from "./nostr/index.js";
 export * from "./signer/index.js";
 export * from "./signerFromSignature.js";