@waku/core 0.0.33-aeb05cd.0 → 0.0.33-b93134a.0

package/bundle/{base_protocol-0xHh0_Hq.js → base_protocol-1U9jKpZH.js}

@@ -156,110 +156,115 @@ function filterPeersByDiscovery(peers, numPeers, maxBootstrapPeers) {
     return selectedPeers;
 }
 
-function selectConnection(connections) {
-    if (!connections.length)
-        return;
-    if (connections.length === 1)
-        return connections[0];
-    let latestConnection;
-    connections.forEach((connection) => {
-        if (connection.status === "open") {
-            if (!latestConnection) {
-                latestConnection = connection;
-            }
-            else if (connection.timeline.open > latestConnection.timeline.open) {
-                latestConnection = connection;
-            }
-        }
-    });
-    return latestConnection;
+function selectOpenConnection(connections) {
+    return connections
+        .filter((c) => c.status === "open")
+        .sort((left, right) => right.timeline.open - left.timeline.open)
+        .at(0);
 }
 
-const CONNECTION_TIMEOUT = 5_000;
-const RETRY_BACKOFF_BASE = 1_000;
-const MAX_RETRIES = 3;
 class StreamManager {
     multicodec;
     getConnections;
     addEventListener;
-    streamPool;
     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.streamPool = new Map();
         this.addEventListener("peer:update", this.handlePeerUpdateStreamPool);
     }
     async getStream(peer) {
-        const peerIdStr = peer.id.toString();
-        const streamPromise = this.streamPool.get(peerIdStr);
-        if (!streamPromise) {
-            return this.createStream(peer);
-        }
-        this.streamPool.delete(peerIdStr);
-        this.prepareStream(peer);
-        try {
-            const stream = await streamPromise;
-            if (stream && stream.status !== "closed") {
-                return stream;
-            }
+        const peerId = peer.id.toString();
+        const scheduledStream = this.streamPool.get(peerId);
+        if (scheduledStream) {
+            this.streamPool.delete(peerId);
+            await scheduledStream;
         }
-        catch (error) {
-            this.log.warn(`Failed to get stream for ${peerIdStr} -- `, error);
-            this.log.warn("Attempting to create a new stream for the peer");
+        const stream = this.getOpenStreamForCodec(peer.id);
+        if (stream) {
+            this.log.info(`Found existing stream peerId=${peer.id.toString()} multicodec=${this.multicodec}`);
+            return stream;
         }
         return this.createStream(peer);
     }
     async createStream(peer, retries = 0) {
         const connections = this.getConnections(peer.id);
-        const connection = selectConnection(connections);
+        const connection = selectOpenConnection(connections);
         if (!connection) {
-            throw new Error("Failed to get a connection to the peer");
+            throw new Error(`Failed to get a connection to the peer peerId=${peer.id.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=${peer.id.toString()} multicodec=${this.multicodec}`);
+                stream = await connection.newStream(this.multicodec);
+                this.log.info(`Created stream for peerId=${peer.id.toString()} multicodec=${this.multicodec}`);
+                break;
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        if (!stream) {
+            throw new Error(`Failed to create a new stream for ${peer.id.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 {
-            return await connection.newStream(this.multicodec);
+            this.ongoingCreation.add(peerId);
+            await this.createStream(peer);
         }
         catch (error) {
-            if (retries < MAX_RETRIES) {
-                const backoff = RETRY_BACKOFF_BASE * Math.pow(2, retries);
-                await new Promise((resolve) => setTimeout(resolve, backoff));
-                return this.createStream(peer, retries + 1);
-            }
-            throw new Error(`Failed to create a new stream for ${peer.id.toString()} -- ` + error);
+            this.log.error(`Failed to createStreamWithLock:`, error);
         }
-    }
-    prepareStream(peer) {
-        const timeoutPromise = new Promise((resolve) => setTimeout(resolve, CONNECTION_TIMEOUT));
-        const streamPromise = Promise.race([
-            this.createStream(peer),
-            timeoutPromise.then(() => {
-                throw new Error("Connection timeout");
-            })
-        ]).catch((error) => {
-            this.log.error(`Failed to prepare a new stream for ${peer.id.toString()} -- `, error);
-        });
-        this.streamPool.set(peer.id.toString(), streamPromise);
+        finally {
+            this.ongoingCreation.delete(peerId);
+        }
+        return;
     }
     handlePeerUpdateStreamPool = (evt) => {
         const { peer } = evt.detail;
-        if (peer.protocols.includes(this.multicodec)) {
-            const isConnected = this.isConnectedTo(peer.id);
-            if (isConnected) {
-                this.log.info(`Preemptively opening a stream to ${peer.id.toString()}`);
-                this.prepareStream(peer);
-            }
-            else {
-                const peerIdStr = peer.id.toString();
-                this.streamPool.delete(peerIdStr);
-                this.log.info(`Removed pending stream for disconnected peer ${peerIdStr}`);
-            }
+        if (!peer.protocols.includes(this.multicodec)) {
+            return;
         }
+        const stream = this.getOpenStreamForCodec(peer.id);
+        if (stream) {
+            return;
+        }
+        this.scheduleNewStream(peer);
     };
-    isConnectedTo(peerId) {
+    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);
-        return connections.some((connection) => connection.status === "open");
+        const connection = selectOpenConnection(connections);
+        if (!connection) {
+            return;
+        }
+        const stream = connection.streams.find((s) => s.protocol === this.multicodec);
+        const isStreamUnusable = ["done", "closed", "closing"].includes(stream?.writeStatus || "");
+        if (isStreamUnusable) {
+            return;
+        }
+        return stream;
     }
 }
 
@@ -287,20 +292,21 @@ class BaseProtocol {
     async getStream(peer) {
         return this.streamManager.getStream(peer);
     }
-    //TODO: move to SDK
+    get peerStore() {
+        return this.components.peerStore;
+    }
     /**
      * Returns known peers from the address book (`libp2p.peerStore`) that support
      * the class protocol. Waku may or may not be currently connected to these
      * peers.
      */
     async allPeers() {
-        return getPeersForProtocol(this.components.peerStore, [this.multicodec]);
+        return getPeersForProtocol(this.peerStore, [this.multicodec]);
     }
     async connectedPeers() {
         const peers = await this.allPeers();
         return peers.filter((peer) => {
-            const connections = this.components.connectionManager.getConnections(peer.id);
-            return connections.some((c) => c.streams.some((s) => s.protocol === this.multicodec));
+            return (this.components.connectionManager.getConnections(peer.id).length > 0);
         });
     }
     /**
@@ -316,11 +322,11 @@ class BaseProtocol {
         numPeers: 0
     }) {
         // Retrieve all connected peers that support the protocol & shard (if configured)
-        const connectedPeersForProtocolAndShard = await getConnectedPeersForProtocolAndShard(this.components.connectionManager.getConnections(), this.components.peerStore, [this.multicodec], pubsubTopicsToShardInfo(this.pubsubTopics));
+        const connectedPeersForProtocolAndShard = await getConnectedPeersForProtocolAndShard(this.components.connectionManager.getConnections(), this.peerStore, [this.multicodec], pubsubTopicsToShardInfo(this.pubsubTopics));
         // Filter the peers based on discovery & number of peers requested
         const filteredPeers = filterPeersByDiscovery(connectedPeersForProtocolAndShard, numPeers, maxBootstrapPeers);
         // Sort the peers by latency
-        const sortedFilteredPeers = await sortPeersByLatency(this.components.peerStore, filteredPeers);
+        const sortedFilteredPeers = await sortPeersByLatency(this.peerStore, filteredPeers);
         if (sortedFilteredPeers.length === 0) {
             this.log.warn("No peers found. Ensure you have a connection to the network.");
         }

package/bundle/index.js

@@ -1,8 +1,8 @@
 import { v as version_0, e as encodingLength, a as encode$1, d as decode$1, M as MessagePush, F as FilterSubscribeRequest, b as FilterSubscribeResponse$1, P as PushRpc$1, c as PushResponse, S as StoreQueryRequest$1, f as StoreQueryResponse$1, g as createEncoder, W as WakuMetadataRequest, h as WakuMetadataResponse } from './version_0-BrbNEwD-.js';
 export { i as createDecoder } from './version_0-BrbNEwD-.js';
 import { a as allocUnsafe, b as alloc, L as Logger, P as ProtocolError, c as Protocols, u as utf8ToBytes, p as pubsubTopicToSingleShardInfo, T as Tags, E as EPeersByDiscoveryEvents, s as shardInfoToPubsubTopics, d as EConnectionStateEvents, H as HealthStatus, e as pubsubTopicsToShardInfo } from './index-tdQNdKHx.js';
-import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-0xHh0_Hq.js';
-export { S as StreamManager } from './base_protocol-0xHh0_Hq.js';
+import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-1U9jKpZH.js';
+export { S as StreamManager } from './base_protocol-1U9jKpZH.js';
 
 const MB = 1024 ** 2;
 const SIZE_CAP_IN_MB = 1;
@@ -1564,12 +1564,10 @@ const FilterCodecs = {
 };
 class FilterCore extends BaseProtocol {
     handleIncomingMessage;
-    handleError;
     pubsubTopics;
-    constructor(handleIncomingMessage, handleError, pubsubTopics, libp2p) {
+    constructor(handleIncomingMessage, pubsubTopics, libp2p) {
         super(FilterCodecs.SUBSCRIBE, libp2p.components, log$6, pubsubTopics);
         this.handleIncomingMessage = handleIncomingMessage;
-        this.handleError = handleError;
         this.pubsubTopics = pubsubTopics;
         libp2p
             .handle(FilterCodecs.PUSH, this.onRequest.bind(this), {
@@ -1751,9 +1749,8 @@ class FilterCore extends BaseProtocol {
                 }
             }).then(() => {
                 log$6.info("Receiving pipe closed.");
-            }, async (e) => {
-                log$6.error("Error with receiving pipe", e, " -- ", "on peer ", connection.remotePeer.toString(), " -- ", "stream ", stream);
-                await this.handleError(e);
+            }, (e) => {
+                log$6.error("Error with receiving pipe", e);
             });
         }
         catch (e) {
@@ -3208,7 +3205,7 @@ class Metadata extends BaseProtocol {
      */
     async query(peerId) {
         const request = WakuMetadataRequest.encode(pubsubTopicsToShardInfo(this.pubsubTopics));
-        const peer = await this.libp2pComponents.peerStore.get(peerId);
+        const peer = await this.peerStore.get(peerId);
         if (!peer) {
             return {
                 shardInfo: null,

package/bundle/lib/base_protocol.js

@@ -1,2 +1,2 @@
 import '../index-tdQNdKHx.js';
-export { B as BaseProtocol } from '../base_protocol-0xHh0_Hq.js';
+export { B as BaseProtocol } from '../base_protocol-1U9jKpZH.js';