@ckb-ccc/libp2p 0.2.0 → 0.3.0

package/src/jsonRpcService.ts

@@ -4,6 +4,7 @@ import type { Registrar } from "@libp2p/interface-internal";
 import { lpStream } from "@libp2p/utils";
 
 const DEFAULT_MAX_MESSAGE_LENGTH = 1024 * 1024;
+const DEFAULT_TIMEOUT = 30_000;
 
 export type JsonRpcServiceComponents = {
   registrar: Registrar;
@@ -12,12 +13,15 @@ export type JsonRpcServiceComponents = {
 export type JsonRpcServiceConfig = {
   protocol: string;
   maxMessageLength?: number;
+  timeout?: number;
 };
 
 export type JsonRpcRequest = {
   connection: Connection;
   peerId: PeerId;
   payload: ccc.JsonRpcPayload;
+  /** Aborts if the service times out or the request stream closes. */
+  signal: AbortSignal;
 };
 
 export type JsonRpcRequestHandler<
@@ -29,6 +33,7 @@ export abstract class JsonRpcService<
 > {
   private readonly errorListeners = new Set<(error: Error) => void>();
   readonly maxMessageLength: number;
+  readonly timeout: number;
 
   constructor(
     readonly components: Components,
@@ -43,6 +48,13 @@ export abstract class JsonRpcService<
     }
 
     this.maxMessageLength = maxMessageLength;
+
+    const timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    if (!Number.isSafeInteger(timeout) || timeout <= 0) {
+      throw new Error("JSON-RPC request timeout must be a positive integer");
+    }
+
+    this.timeout = timeout;
   }
 
   protected abstract handleRequest(request: JsonRpcRequest): unknown;
@@ -66,28 +78,57 @@ export abstract class JsonRpcService<
 
   private async handleProtocol(stream: Stream, connection: Connection) {
     let requestAborted = false;
+    const controller = new AbortController();
+    const timeoutSignal = AbortSignal.timeout(this.timeout);
+    const abortRequest = (event: { error?: Error }) => {
+      requestAborted = true;
+      const error = new Error(event.error?.message ?? "JSON-RPC stream closed");
+      error.name = "AbortError";
+      controller.abort(error);
+    };
+    const abortTimeout = () => {
+      requestAborted = true;
+      const error = abortReason(timeoutSignal, "JSON-RPC request timed out");
+      controller.abort(error);
+      stream.abort(error);
+    };
+    stream.addEventListener("close", abortRequest, { once: true });
+    timeoutSignal.addEventListener("abort", abortTimeout, { once: true });
+    if (stream.status !== "open") {
+      abortRequest({});
+    }
 
     try {
       const rpcStream = lpStream(stream, {
         maxDataLength: this.maxMessageLength,
       });
       const payload = parseJsonRpcRequest(
-        ccc.bytesTo((await rpcStream.read()).subarray(), "utf8"),
+        ccc.bytesTo(
+          (await rpcStream.read({ signal: controller.signal })).subarray(),
+          "utf8",
+        ),
       );
 
       let response: ccc.JsonRpcResponse;
       try {
+        controller.signal.throwIfAborted();
         response = {
           jsonrpc: "2.0",
           id: payload.id,
-          result: await this.handleRequest({
-            connection,
-            peerId: connection.remotePeer,
-            payload,
-          }),
+          result: await Promise.race([
+            Promise.resolve(
+              this.handleRequest({
+                connection,
+                peerId: connection.remotePeer,
+                payload,
+                signal: controller.signal,
+              }),
+            ),
+            ccc.abortSignalToPromise(controller.signal),
+          ]),
         };
       } catch (cause) {
-        requestAborted = isAbortError(cause);
+        requestAborted ||= isAbortError(cause);
         const error = toJsonRpcError(cause);
         response = {
           jsonrpc: "2.0",
@@ -100,13 +141,19 @@ export abstract class JsonRpcService<
         };
       }
 
-      await rpcStream.write(ccc.bytesFrom(JSON.stringify(response), "utf8"));
-      await stream.close();
+      await rpcStream.write(ccc.bytesFrom(JSON.stringify(response), "utf8"), {
+        signal: controller.signal,
+      });
+      stream.removeEventListener("close", abortRequest);
+      await stream.close({ signal: controller.signal });
     } catch (cause) {
       if (requestAborted) {
         return;
       }
       this.handleError(cause, stream);
+    } finally {
+      stream.removeEventListener("close", abortRequest);
+      timeoutSignal.removeEventListener("abort", abortTimeout);
     }
   }
 
@@ -147,6 +194,10 @@ function asJsonRpcError(cause: unknown) {
   return cause instanceof Error ? cause : new Error("JSON-RPC request failed");
 }
 
+function abortReason(signal: AbortSignal, fallback: string) {
+  return signal.reason instanceof Error ? signal.reason : new Error(fallback);
+}
+
 function isAbortError(cause: unknown) {
   return (
     cause instanceof Error &&

package/src/jsonRpcTransport.ts

@@ -4,7 +4,7 @@ import { lpStream } from "@libp2p/utils";
 import { dialKnownAddresses } from "./dial.js";
 
 const DEFAULT_MAX_MESSAGE_LENGTH = 1024 * 1024;
-const DEFAULT_TIMEOUT = 120_000;
+const DEFAULT_TIMEOUT = 30_000;
 
 export type JsonRpcTransportLibp2pConfig = {
   protocol: string;
@@ -41,11 +41,15 @@ export class JsonRpcTransportLibp2p implements ccc.JsonRpcTransport {
     this.timeout = timeout;
   }
 
-  async request(payload: ccc.JsonRpcPayload): Promise<ccc.JsonRpcResponse> {
-    const timeoutSignal = AbortSignal.timeout(this.timeout);
-    const signal = this.config.signal
-      ? ccc.abortSignalAny([this.config.signal, timeoutSignal])
-      : timeoutSignal;
+  async request(
+    payload: ccc.JsonRpcPayload,
+    options?: ccc.JsonRpcTransportRequestOptions,
+  ): Promise<ccc.JsonRpcResponse> {
+    const timeoutSignal = AbortSignal.timeout(options?.timeout ?? this.timeout);
+    const signals = [this.config.signal, options?.signal, timeoutSignal].filter(
+      (signal): signal is AbortSignal => signal !== undefined,
+    );
+    const signal = ccc.abortSignalAny(signals);
 
     let stream: Stream | undefined;
     let response: ccc.JsonRpcResponse;

package/src/pairingEndpoint.ts

@@ -7,7 +7,14 @@ const MAX_DECOMPRESSED_ADDRESSES_LENGTH = 16 * 1024;
 const MAX_ADDRESSES = 16;
 const PAIRING_PARAMETER_NAMES = ["addresses", "role", "secret"] as const;
 
-export class PairingEndpointRoleError extends Error {
+export class PairingEndpointError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "PairingEndpointError";
+  }
+}
+
+export class PairingEndpointRoleError extends PairingEndpointError {
   constructor(
     readonly expectedRole: string,
     readonly actualRole: string | undefined,
@@ -66,7 +73,14 @@ export async function decodePairingEndpoint(
   endpoint: string,
   expectedRole?: string,
 ): Promise<PairingTarget> {
-  const url = new URL(endpoint.trim());
+  let url: URL;
+  try {
+    url = new URL(endpoint.trim());
+  } catch (cause) {
+    throw new PairingEndpointError("Pairing endpoint is not a valid URL", {
+      cause,
+    });
+  }
   const { params } = fragmentParameters(url);
   if (expectedRole) {
     const actualRole = params.get("role")?.trim() || undefined;
@@ -78,7 +92,7 @@ export async function decodePairingEndpoint(
   const secret = params.get("secret")?.trim();
 
   if (!compressedAddresses || !secret) {
-    throw new Error("Pairing endpoint is incomplete");
+    throw new PairingEndpointError("Pairing endpoint is incomplete");
   }
 
   const addresses = await decodeCompressedAddresses(compressedAddresses);
@@ -128,9 +142,10 @@ async function decodeCompressedAddresses(value: string): Promise<Multiaddr[]> {
     }
     return addresses;
   } catch (cause) {
-    throw new Error("Pairing endpoint contains invalid compressed addresses", {
-      cause,
-    });
+    throw new PairingEndpointError(
+      "Pairing endpoint contains invalid compressed addresses",
+      { cause },
+    );
   }
 }
 

package/src/pairingService.ts

@@ -5,19 +5,14 @@ import type {
   PeerId,
   Stream,
 } from "@libp2p/interface";
-import type {
-  AddressManager,
-  ConnectionManager,
-  Registrar,
-} from "@libp2p/interface-internal";
+import type { ConnectionManager, Registrar } from "@libp2p/interface-internal";
 import { lpStream } from "@libp2p/utils";
-import { CODE_P2P, multiaddr, type Multiaddr } from "@multiformats/multiaddr";
+import type { Multiaddr } from "@multiformats/multiaddr";
 
 const MAX_PAIRING_MESSAGE_LENGTH = 1024;
 const UNPAIR_TIMEOUT_MS = 10_000;
 
 export type PairingServiceComponents = {
-  addressManager?: Pick<AddressManager, "getAddresses">;
   connectionManager: ConnectionManager;
   registrar: Registrar;
 };
@@ -39,8 +34,7 @@ export type PairingGuard<
 > = (this: PairingService<Components>, peerId: PeerId) => boolean;
 
 type PairingRequest =
-  | { type: "pair"; secret: string; name?: string; addresses?: string[] }
-  | { type: "unpair" };
+  { type: "pair"; secret: string; name?: string } | { type: "unpair" };
 
 type PairingResponse =
   { ok: true; name?: string } | { ok: false; error: string };
@@ -147,7 +141,7 @@ export abstract class PairingService<
 
       const response = await exchange(
         stream,
-        createPairRequest(target.secret, this.config.name, this.addresses()),
+        createPairRequest(target.secret, this.config.name),
         options,
       );
       options.signal?.throwIfAborted();
@@ -223,11 +217,6 @@ export abstract class PairingService<
         return;
       }
 
-      const addresses = parseAddresses(
-        request.addresses,
-        connection.remotePeer,
-      );
-
       // Consume the credential before the next asynchronous boundary so two
       // concurrent requests cannot both pair with the same endpoint.
       this.rotateSecret();
@@ -241,7 +230,6 @@ export abstract class PairingService<
       });
       if (addedPeer) {
         this.notifyPairedPeer(addedPeer, request.name);
-        void this.openFallbackConnection(addresses);
       }
     } catch (cause) {
       if (addedPeer) {
@@ -266,22 +254,6 @@ export abstract class PairingService<
     this.pairedListeners.forEach((listener) => listener(peerId, name));
   }
 
-  private addresses() {
-    return this.components.addressManager?.getAddresses() ?? [];
-  }
-
-  private async openFallbackConnection(addresses: Multiaddr[]) {
-    if (addresses.length === 0) {
-      return;
-    }
-
-    try {
-      await this.components.connectionManager.openConnection(addresses);
-    } catch {
-      // The original pairing connection remains usable when the fallback fails.
-    }
-  }
-
   private rotateSecret() {
     this.currentSecret = createSecret();
     this.secretChangedListeners.forEach((listener) =>
@@ -392,22 +364,12 @@ async function exchange(
 function createPairRequest(
   secret: string,
   name: string | undefined,
-  addresses: Multiaddr[],
 ): PairingRequest {
-  const addressStrings = addresses.map((address) => address.toString());
   const request: PairingRequest = {
     type: "pair",
     secret,
     name,
-    addresses: addressStrings,
   };
-  while (addressStrings.length > 0 && !pairingRequestFits(request)) {
-    addressStrings.pop();
-  }
-
-  if (!pairingRequestFits(request)) {
-    delete request.addresses;
-  }
   if (!pairingRequestFits(request)) {
     delete request.name;
   }
@@ -446,7 +408,6 @@ function parsePairingRequest(data: Uint8Array): PairingRequest {
       type: "pair",
       secret: request.secret,
       name: typeof request.name === "string" ? request.name : undefined,
-      addresses: parseAddressStrings(request.addresses),
     };
   }
 
@@ -457,31 +418,6 @@ function parsePairingRequest(data: Uint8Array): PairingRequest {
   throw new Error("Invalid pairing request");
 }
 
-function parseAddressStrings(value: unknown): string[] | undefined {
-  if (!Array.isArray(value)) {
-    return undefined;
-  }
-  return value.filter(
-    (address): address is string =>
-      typeof address === "string" && address.length > 0,
-  );
-}
-
-function parseAddresses(values: string[] | undefined, peerId: PeerId) {
-  return (values ?? []).flatMap((value) => {
-    try {
-      const address = multiaddr(value);
-      const peer = address
-        .getComponents()
-        .filter(({ code }) => code === CODE_P2P)
-        .at(-1)?.value;
-      return peer === peerId.toString() ? [address] : [];
-    } catch {
-      return [];
-    }
-  });
-}
-
 function parsePairingResponse(data: Uint8Array): PairingResponse {
   const response = JSON.parse(
     ccc.bytesTo(data, "utf8"),

package/src/relayConnection.ts

@@ -0,0 +1,120 @@
+import { ccc } from "@ckb-ccc/core";
+import type { Connection, Libp2p } from "@libp2p/interface";
+import { multiaddr, type Multiaddr } from "@multiformats/multiaddr";
+
+const DIAL_TIMEOUT_MS = 10_000;
+const RETRY_DELAYS_MS = [5_000, 10_000, 20_000] as const;
+const RETRY_REPEAT_MS = 30_000;
+
+export type RelayConnectionControllerOptions = {
+  onConnectionChange?: (connection?: Connection) => void;
+};
+
+/** Maintains a connection to a relay until stopped. */
+export class RelayConnectionController {
+  private readonly controller = new AbortController();
+  private readonly addresses: readonly Multiaddr[];
+  private selectedAddress?: Multiaddr;
+  private connection?: Connection;
+  private connecting?: Promise<Connection>;
+
+  constructor(
+    private readonly node: Libp2p,
+    addresses: readonly string[],
+    private readonly options: RelayConnectionControllerOptions = {},
+  ) {
+    if (addresses.length === 0) {
+      throw new Error("At least one relay address is required");
+    }
+    this.addresses = addresses.map((address) => multiaddr(address.trim()));
+    node.addEventListener("connection:close", this.handleConnectionClose, {
+      signal: this.controller.signal,
+    });
+  }
+
+  connect(): Promise<Connection> {
+    this.controller.signal.throwIfAborted();
+    if (this.connection?.status === "open") {
+      return Promise.resolve(this.connection);
+    }
+    if (this.connecting) {
+      return this.connecting;
+    }
+
+    this.connection = undefined;
+    const connecting = ccc
+      .retry<Connection>(
+        RETRY_DELAYS_MS,
+        async ({ resolve }) => {
+          return resolve(await this.dialRelay());
+        },
+        { repeat: RETRY_REPEAT_MS, signal: this.controller.signal },
+      )
+      .finally(() => {
+        if (this.connecting === connecting) {
+          this.connecting = undefined;
+        }
+        if (!this.controller.signal.aborted && !this.connection) {
+          void this.connect().catch(() => {});
+        }
+      });
+    this.connecting = connecting;
+    return connecting;
+  }
+
+  async stop() {
+    if (this.controller.signal.aborted) {
+      return;
+    }
+
+    this.controller.abort();
+    const connection = this.connection;
+    this.connection = undefined;
+    this.options.onConnectionChange?.();
+    await connection?.close();
+  }
+
+  private async dialRelay() {
+    const addresses = this.selectedAddress
+      ? [this.selectedAddress]
+      : this.addresses;
+    let lastError: unknown;
+
+    for (const address of addresses) {
+      await ccc.waitForAvailability(this.controller.signal);
+      let connection: Connection | undefined;
+      try {
+        connection = await this.node.dial(address, {
+          signal: ccc.abortSignalAny([
+            this.controller.signal,
+            AbortSignal.timeout(DIAL_TIMEOUT_MS),
+          ]),
+        });
+        this.controller.signal.throwIfAborted();
+        this.connection = connection;
+        if (connection.status !== "open") {
+          this.connection = undefined;
+          throw new Error("Relay connection closed while dialing");
+        }
+        this.selectedAddress = address;
+        this.options.onConnectionChange?.(connection);
+        return connection;
+      } catch (cause) {
+        lastError = cause;
+        await connection?.close();
+      }
+    }
+
+    throw lastError;
+  }
+
+  private readonly handleConnectionClose = (event: CustomEvent<Connection>) => {
+    if (event.detail.id !== this.connection?.id) {
+      return;
+    }
+
+    this.connection = undefined;
+    this.options.onConnectionChange?.();
+    void this.connect().catch(() => {});
+  };
+}