@waku/core 0.0.36-f7c290d.0 → 0.0.36

package/src/lib/filter/filter.ts

@@ -3,7 +3,6 @@ import type { IncomingStreamData } from "@libp2p/interface-internal";
 import {
   type ContentTopic,
   type CoreProtocolResult,
-  type IBaseProtocolCore,
   type Libp2p,
   ProtocolError,
   type PubsubTopic
@@ -15,7 +14,7 @@ import * as lp from "it-length-prefixed";
 import { pipe } from "it-pipe";
 import { Uint8ArrayList } from "uint8arraylist";
 
-import { BaseProtocol } from "../base_protocol.js";
+import { StreamManager } from "../stream_manager/index.js";
 
 import {
   FilterPushRpc,
@@ -36,15 +35,21 @@ type IncomingMessageHandler = (
   peerIdStr: string
 ) => Promise<void>;
 
-export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
+export class FilterCore {
+  private streamManager: StreamManager;
   private static handleIncomingMessage?: IncomingMessageHandler;
 
+  public readonly multicodec = FilterCodecs.SUBSCRIBE;
+
   public constructor(
     handleIncomingMessage: IncomingMessageHandler,
     public readonly pubsubTopics: PubsubTopic[],
     libp2p: Libp2p
   ) {
-    super(FilterCodecs.SUBSCRIBE, libp2p.components, pubsubTopics);
+    this.streamManager = new StreamManager(
+      FilterCodecs.SUBSCRIBE,
+      libp2p.components
+    );
 
     // TODO(weboko): remove when @waku/sdk 0.0.33 is released
     const prevHandler = FilterCore.handleIncomingMessage;
@@ -83,7 +88,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     peerId: PeerId,
     contentTopics: ContentTopic[]
   ): Promise<CoreProtocolResult> {
-    const stream = await this.getStream(peerId);
+    const stream = await this.streamManager.getStream(peerId);
 
     const request = FilterSubscribeRpc.createSubscribeRequest(
       pubsubTopic,
@@ -139,7 +144,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
   ): Promise<CoreProtocolResult> {
     let stream: Stream | undefined;
     try {
-      stream = await this.getStream(peerId);
+      stream = await this.streamManager.getStream(peerId);
     } catch (error) {
       log.error(
         `Failed to get a stream for remote peer${peerId.toString()}`,
@@ -182,7 +187,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     pubsubTopic: PubsubTopic,
     peerId: PeerId
   ): Promise<CoreProtocolResult> {
-    const stream = await this.getStream(peerId);
+    const stream = await this.streamManager.getStream(peerId);
 
     const request = FilterSubscribeRpc.createUnsubscribeAllRequest(pubsubTopic);
 
@@ -229,7 +234,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
   public async ping(peerId: PeerId): Promise<CoreProtocolResult> {
     let stream: Stream | undefined;
     try {
-      stream = await this.getStream(peerId);
+      stream = await this.streamManager.getStream(peerId);
     } catch (error) {
       log.error(
         `Failed to get a stream for remote peer${peerId.toString()}`,

package/src/lib/light_push/light_push.ts

@@ -1,7 +1,6 @@
 import type { PeerId, Stream } from "@libp2p/interface";
 import {
   type CoreProtocolResult,
-  type IBaseProtocolCore,
   type IEncoder,
   type IMessage,
   type Libp2p,
@@ -17,7 +16,7 @@ import * as lp from "it-length-prefixed";
 import { pipe } from "it-pipe";
 import { Uint8ArrayList } from "uint8arraylist";
 
-import { BaseProtocol } from "../base_protocol.js";
+import { StreamManager } from "../stream_manager/index.js";
 
 import { PushRpc } from "./push_rpc.js";
 import { isRLNResponseError } from "./utils.js";
@@ -32,12 +31,16 @@ type PreparePushMessageResult = ThisOrThat<"query", PushRpc>;
 /**
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
  */
-export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
+export class LightPushCore {
+  private readonly streamManager: StreamManager;
+
+  public readonly multicodec = LightPushCodec;
+
   public constructor(
     public readonly pubsubTopics: PubsubTopic[],
     libp2p: Libp2p
   ) {
-    super(LightPushCodec, libp2p.components, pubsubTopics);
+    this.streamManager = new StreamManager(LightPushCodec, libp2p.components);
   }
 
   private async preparePushMessage(
@@ -98,7 +101,7 @@ export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
 
     let stream: Stream;
     try {
-      stream = await this.getStream(peerId);
+      stream = await this.streamManager.getStream(peerId);
     } catch (error) {
       log.error("Failed to get stream", error);
       return {

package/src/lib/metadata/metadata.ts

@@ -16,21 +16,24 @@ import * as lp from "it-length-prefixed";
 import { pipe } from "it-pipe";
 import { Uint8ArrayList } from "uint8arraylist";
 
-import { BaseProtocol } from "../base_protocol.js";
+import { StreamManager } from "../stream_manager/index.js";
 
 const log = new Logger("metadata");
 
 export const MetadataCodec = "/vac/waku/metadata/1.0.0";
 
-class Metadata extends BaseProtocol implements IMetadata {
-  private libp2pComponents: Libp2pComponents;
+class Metadata implements IMetadata {
+  private readonly streamManager: StreamManager;
+  private readonly libp2pComponents: Libp2pComponents;
   protected handshakesConfirmed: Map<PeerIdStr, ShardInfo> = new Map();
 
+  public readonly multicodec = MetadataCodec;
+
   public constructor(
     public pubsubTopics: PubsubTopic[],
     libp2p: Libp2pComponents
   ) {
-    super(MetadataCodec, libp2p.components, pubsubTopics);
+    this.streamManager = new StreamManager(MetadataCodec, libp2p);
     this.libp2pComponents = libp2p;
     void libp2p.registrar.handle(MetadataCodec, (streamData) => {
       void this.onRequest(streamData);
@@ -55,7 +58,7 @@ class Metadata extends BaseProtocol implements IMetadata {
 
     let stream;
     try {
-      stream = await this.getStream(peerId);
+      stream = await this.streamManager.getStream(peerId);
     } catch (error) {
       log.error("Failed to get stream", error);
       return {

package/src/lib/store/store.ts

@@ -2,7 +2,6 @@ import type { PeerId } from "@libp2p/interface";
 import {
   IDecodedMessage,
   IDecoder,
-  IStoreCore,
   Libp2p,
   PubsubTopic,
   QueryRequestParams
@@ -13,7 +12,7 @@ import * as lp from "it-length-prefixed";
 import { pipe } from "it-pipe";
 import { Uint8ArrayList } from "uint8arraylist";
 
-import { BaseProtocol } from "../base_protocol.js";
+import { StreamManager } from "../stream_manager/index.js";
 import { toProtoMessage } from "../to_proto_message.js";
 
 import {
@@ -27,12 +26,16 @@ const log = new Logger("store");
 
 export const StoreCodec = "/vac/waku/store-query/3.0.0";
 
-export class StoreCore extends BaseProtocol implements IStoreCore {
+export class StoreCore {
+  private readonly streamManager: StreamManager;
+
+  public readonly multicodec = StoreCodec;
+
   public constructor(
     public readonly pubsubTopics: PubsubTopic[],
     libp2p: Libp2p
   ) {
-    super(StoreCodec, libp2p.components, pubsubTopics);
+    this.streamManager = new StreamManager(StoreCodec, libp2p.components);
   }
 
   public async *queryPerPage<T extends IDecodedMessage>(
@@ -70,7 +73,7 @@ export class StoreCore extends BaseProtocol implements IStoreCore {
 
       let stream;
       try {
-        stream = await this.getStream(peerId);
+        stream = await this.streamManager.getStream(peerId);
       } catch (e) {
         log.error("Failed to get stream", e);
         break;

package/src/lib/stream_manager/stream_manager.ts

@@ -1,5 +1,5 @@
 import type { Peer, PeerId, PeerUpdate, Stream } from "@libp2p/interface";
-import type { Libp2p } from "@waku/interfaces";
+import type { Libp2pComponents } from "@waku/interfaces";
 import { Logger } from "@waku/utils";
 
 import { selectOpenConnection } from "./utils.js";
@@ -14,11 +14,13 @@ export class StreamManager {
 
   public constructor(
     private multicodec: string,
-    private getConnections: Libp2p["getConnections"],
-    private addEventListener: Libp2p["addEventListener"]
+    private readonly libp2p: Libp2pComponents
   ) {
     this.log = new Logger(`stream-manager:${multicodec}`);
-    this.addEventListener("peer:update", this.handlePeerUpdateStreamPool);
+    this.libp2p.events.addEventListener(
+      "peer:update",
+      this.handlePeerUpdateStreamPool
+    );
   }
 
   public async getStream(peerId: PeerId): Promise<Stream> {
@@ -47,7 +49,7 @@ export class StreamManager {
   }
 
   private async createStream(peerId: PeerId, retries = 0): Promise<Stream> {
-    const connections = this.getConnections(peerId);
+    const connections = this.libp2p.connectionManager.getConnections(peerId);
     const connection = selectOpenConnection(connections);
 
     if (!connection) {
@@ -135,7 +137,7 @@ export class StreamManager {
   }
 
   private getOpenStreamForCodec(peerId: PeerId): Stream | undefined {
-    const connections = this.getConnections(peerId);
+    const connections = this.libp2p.connectionManager.getConnections(peerId);
     const connection = selectOpenConnection(connections);
 
     if (!connection) {

package/bundle/base_protocol-DvQrudwy.js

@@ -1,152 +0,0 @@
-import { L as Logger } from './index-CTo1my9M.js';
-
-function selectOpenConnection(connections) {
-    return connections
-        .filter((c) => c.status === "open")
-        .sort((left, right) => right.timeline.open - left.timeline.open)
-        .at(0);
-}
-
-const STREAM_LOCK_KEY = "consumed";
-class StreamManager {
-    multicodec;
-    getConnections;
-    addEventListener;
-    log;
-    ongoingCreation = new Set();
-    streamPool = new Map();
-    constructor(multicodec, getConnections, addEventListener) {
-        this.multicodec = multicodec;
-        this.getConnections = getConnections;
-        this.addEventListener = addEventListener;
-        this.log = new Logger(`stream-manager:${multicodec}`);
-        this.addEventListener("peer:update", this.handlePeerUpdateStreamPool);
-    }
-    async getStream(peerId) {
-        const peerIdStr = peerId.toString();
-        const scheduledStream = this.streamPool.get(peerIdStr);
-        if (scheduledStream) {
-            this.streamPool.delete(peerIdStr);
-            await scheduledStream;
-        }
-        let stream = this.getOpenStreamForCodec(peerId);
-        if (stream) {
-            this.log.info(`Found existing stream peerId=${peerIdStr} multicodec=${this.multicodec}`);
-            this.lockStream(peerIdStr, stream);
-            return stream;
-        }
-        stream = await this.createStream(peerId);
-        this.lockStream(peerIdStr, stream);
-        return stream;
-    }
-    async createStream(peerId, retries = 0) {
-        const connections = this.getConnections(peerId);
-        const connection = selectOpenConnection(connections);
-        if (!connection) {
-            throw new Error(`Failed to get a connection to the peer peerId=${peerId.toString()} multicodec=${this.multicodec}`);
-        }
-        let lastError;
-        let stream;
-        for (let i = 0; i < retries + 1; i++) {
-            try {
-                this.log.info(`Attempting to create a stream for peerId=${peerId.toString()} multicodec=${this.multicodec}`);
-                stream = await connection.newStream(this.multicodec);
-                this.log.info(`Created stream for peerId=${peerId.toString()} multicodec=${this.multicodec}`);
-                break;
-            }
-            catch (error) {
-                lastError = error;
-            }
-        }
-        if (!stream) {
-            throw new Error(`Failed to create a new stream for ${peerId.toString()} -- ` + lastError);
-        }
-        return stream;
-    }
-    async createStreamWithLock(peer) {
-        const peerId = peer.id.toString();
-        if (this.ongoingCreation.has(peerId)) {
-            this.log.info(`Skipping creation of a stream due to lock for peerId=${peerId} multicodec=${this.multicodec}`);
-            return;
-        }
-        try {
-            this.ongoingCreation.add(peerId);
-            await this.createStream(peer.id);
-        }
-        catch (error) {
-            this.log.error(`Failed to createStreamWithLock:`, error);
-        }
-        finally {
-            this.ongoingCreation.delete(peerId);
-        }
-        return;
-    }
-    handlePeerUpdateStreamPool = (evt) => {
-        const { peer } = evt.detail;
-        if (!peer.protocols.includes(this.multicodec)) {
-            return;
-        }
-        const stream = this.getOpenStreamForCodec(peer.id);
-        if (stream) {
-            return;
-        }
-        this.scheduleNewStream(peer);
-    };
-    scheduleNewStream(peer) {
-        this.log.info(`Scheduling creation of a stream for peerId=${peer.id.toString()} multicodec=${this.multicodec}`);
-        // abandon previous attempt
-        if (this.streamPool.has(peer.id.toString())) {
-            this.streamPool.delete(peer.id.toString());
-        }
-        this.streamPool.set(peer.id.toString(), this.createStreamWithLock(peer));
-    }
-    getOpenStreamForCodec(peerId) {
-        const connections = this.getConnections(peerId);
-        const connection = selectOpenConnection(connections);
-        if (!connection) {
-            return;
-        }
-        const stream = connection.streams.find((s) => s.protocol === this.multicodec);
-        if (!stream) {
-            return;
-        }
-        const isStreamUnusable = ["done", "closed", "closing"].includes(stream.writeStatus || "");
-        if (isStreamUnusable || this.isStreamLocked(stream)) {
-            return;
-        }
-        return stream;
-    }
-    lockStream(peerId, stream) {
-        this.log.info(`Locking stream for peerId:${peerId}\tstreamId:${stream.id}`);
-        stream.metadata[STREAM_LOCK_KEY] = true;
-    }
-    isStreamLocked(stream) {
-        return !!stream.metadata[STREAM_LOCK_KEY];
-    }
-}
-
-/**
- * A class with predefined helpers, to be used as a base to implement Waku
- * Protocols.
- */
-class BaseProtocol {
-    multicodec;
-    components;
-    pubsubTopics;
-    addLibp2pEventListener;
-    removeLibp2pEventListener;
-    streamManager;
-    constructor(multicodec, components, pubsubTopics) {
-        this.multicodec = multicodec;
-        this.components = components;
-        this.pubsubTopics = pubsubTopics;
-        this.addLibp2pEventListener = components.events.addEventListener.bind(components.events);
-        this.removeLibp2pEventListener = components.events.removeEventListener.bind(components.events);
-        this.streamManager = new StreamManager(multicodec, components.connectionManager.getConnections.bind(components.connectionManager), this.addLibp2pEventListener);
-    }
-    async getStream(peerId) {
-        return this.streamManager.getStream(peerId);
-    }
-}
-
-export { BaseProtocol as B, StreamManager as S };