@waku/core 0.0.33-00c3261.0 → 0.0.33-09028e7.0

package/bundle/{base_protocol-iQ9XIkPz.js → base_protocol-CS0EDeEY.js}

@@ -1,58 +1,4 @@
-import { h as bytesToUtf8, T as Tags, L as Logger, e as pubsubTopicsToShardInfo } from './index-tdQNdKHx.js';
-
-const decodeRelayShard = (bytes) => {
-    // explicitly converting to Uint8Array to avoid Buffer
-    // https://github.com/libp2p/js-libp2p/issues/2146
-    bytes = new Uint8Array(bytes);
-    if (bytes.length < 3)
-        throw new Error("Insufficient data");
-    const view = new DataView(bytes.buffer);
-    const clusterId = view.getUint16(0);
-    const shards = [];
-    if (bytes.length === 130) {
-        // rsv format (Bit Vector)
-        for (let i = 0; i < 1024; i++) {
-            const byteIndex = Math.floor(i / 8) + 2; // Adjusted for the 2-byte cluster field
-            const bitIndex = 7 - (i % 8);
-            if (view.getUint8(byteIndex) & (1 << bitIndex)) {
-                shards.push(i);
-            }
-        }
-    }
-    else {
-        // rs format (Index List)
-        const numIndices = view.getUint8(2);
-        for (let i = 0, offset = 3; i < numIndices; i++, offset += 2) {
-            if (offset + 1 >= bytes.length)
-                throw new Error("Unexpected end of data");
-            shards.push(view.getUint16(offset));
-        }
-    }
-    return { clusterId, shards };
-};
-const encodeRelayShard = (shardInfo) => {
-    const { clusterId, shards } = shardInfo;
-    const totalLength = shards.length >= 64 ? 130 : 3 + 2 * shards.length;
-    const buffer = new ArrayBuffer(totalLength);
-    const view = new DataView(buffer);
-    view.setUint16(0, clusterId);
-    if (shards.length >= 64) {
-        // rsv format (Bit Vector)
-        for (const index of shards) {
-            const byteIndex = Math.floor(index / 8) + 2; // Adjusted for the 2-byte cluster field
-            const bitIndex = 7 - (index % 8);
-            view.setUint8(byteIndex, view.getUint8(byteIndex) | (1 << bitIndex));
-        }
-    }
-    else {
-        // rs format (Index List)
-        view.setUint8(2, shards.length);
-        for (let i = 0, offset = 3; i < shards.length; i++, offset += 2) {
-            view.setUint16(offset, shards[i]);
-        }
-    }
-    return new Uint8Array(buffer);
-};
+import { g as bytesToUtf8, T as Tags, L as Logger } from './index-BVysxsMu.js';
 
 /**
  * Function to sort peers by latency from lowest to highest
@@ -96,28 +42,6 @@ async function getPeersForProtocol(peerStore, protocols) {
     });
     return peers;
 }
-async function getConnectedPeersForProtocolAndShard(connections, peerStore, protocols, shardInfo) {
-    const openConnections = connections.filter((connection) => connection.status === "open");
-    const peerPromises = openConnections.map(async (connection) => {
-        const peer = await peerStore.get(connection.remotePeer);
-        const supportsProtocol = protocols.some((protocol) => peer.protocols.includes(protocol));
-        if (supportsProtocol) {
-            if (shardInfo) {
-                const encodedPeerShardInfo = peer.metadata.get("shardInfo");
-                const peerShardInfo = encodedPeerShardInfo && decodeRelayShard(encodedPeerShardInfo);
-                if (peerShardInfo && shardInfo.clusterId === peerShardInfo.clusterId) {
-                    return peer;
-                }
-            }
-            else {
-                return peer;
-            }
-        }
-        return null;
-    });
-    const peersWithNulls = await Promise.all(peerPromises);
-    return peersWithNulls.filter((peer) => peer !== null);
-}
 
 /**
  * Retrieves a list of peers based on the specified criteria:
@@ -176,29 +100,39 @@ function selectConnection(connections) {
 }
 
 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 peerId = peer.id.toString();
-        const scheduledStream = this.streamPool.get(peerId);
-        this.streamPool.delete(peerId);
-        await scheduledStream;
-        const stream = this.getStreamForCodec(peer.id);
-        if (stream) {
-            this.log.info(`Found existing stream peerId=${peer.id.toString()} multicodec=${this.multicodec}`);
-            return stream;
+        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;
+            }
+        }
+        catch (error) {
+            this.log.warn(`Failed to get stream for ${peerIdStr} -- `, error);
+            this.log.warn("Attempting to create a new stream for the peer");
         }
         return this.createStream(peer);
     }
@@ -206,67 +140,50 @@ class StreamManager {
         const connections = this.getConnections(peer.id);
         const connection = selectConnection(connections);
         if (!connection) {
-            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}`);
-            }
-            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;
+            throw new Error("Failed to get a connection to the peer");
         }
         try {
-            this.ongoingCreation.add(peerId);
-            await this.createStream(peer);
+            return await connection.newStream(this.multicodec);
         }
-        finally {
-            this.ongoingCreation.delete(peerId);
+        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);
         }
     }
-    handlePeerUpdateStreamPool = (evt) => {
-        const { peer } = evt.detail;
-        if (!peer.protocols.includes(this.multicodec)) {
-            return;
-        }
-        const stream = this.getStreamForCodec(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}`);
-        const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(undefined), CONNECTION_TIMEOUT));
+    prepareStream(peer) {
+        const timeoutPromise = new Promise((resolve) => setTimeout(resolve, CONNECTION_TIMEOUT));
         const streamPromise = Promise.race([
-            this.createStreamWithLock(peer),
-            timeoutPromise
-        ]);
+            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);
     }
-    getStreamForCodec(peerId) {
-        const connection = this.getConnections(peerId).find((c) => c.status === "open");
-        if (!connection) {
-            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}`);
+            }
         }
-        const stream = connection.streams.find((s) => s.protocol === this.multicodec);
-        return stream;
+    };
+    isConnectedTo(peerId) {
+        const connections = this.getConnections(peerId);
+        return connections.some((connection) => connection.status === "open");
     }
 }
 
@@ -294,21 +211,23 @@ class BaseProtocol {
     async getStream(peer) {
         return this.streamManager.getStream(peer);
     }
-    get peerStore() {
-        return this.components.peerStore;
-    }
+    //TODO: move to SDK
     /**
      * 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.peerStore, [this.multicodec]);
+        return getPeersForProtocol(this.components.peerStore, [this.multicodec]);
     }
-    async connectedPeers() {
+    async connectedPeers(withOpenStreams = false) {
         const peers = await this.allPeers();
         return peers.filter((peer) => {
-            return (this.components.connectionManager.getConnections(peer.id).length > 0);
+            const connections = this.components.connectionManager.getConnections(peer.id);
+            if (withOpenStreams) {
+                return connections.some((c) => c.streams.some((s) => s.protocol === this.multicodec));
+            }
+            return connections.length > 0;
         });
     }
     /**
@@ -316,19 +235,18 @@ class BaseProtocol {
      *
      * @param numPeers - The total number of peers to retrieve. If 0, all peers are returned.
      * @param maxBootstrapPeers - The maximum number of bootstrap peers to retrieve.
-  
-    * @returns A list of peers that support the protocol sorted by latency.
-    */
+     * @returns A list of peers that support the protocol sorted by latency. By default, returns all peers available, including bootstrap.
+     */
     async getPeers({ numPeers, maxBootstrapPeers } = {
-        maxBootstrapPeers: 1,
+        maxBootstrapPeers: 0,
         numPeers: 0
     }) {
         // Retrieve all connected peers that support the protocol & shard (if configured)
-        const connectedPeersForProtocolAndShard = await getConnectedPeersForProtocolAndShard(this.components.connectionManager.getConnections(), this.peerStore, [this.multicodec], pubsubTopicsToShardInfo(this.pubsubTopics));
+        const allAvailableConnectedPeers = await this.connectedPeers();
         // Filter the peers based on discovery & number of peers requested
-        const filteredPeers = filterPeersByDiscovery(connectedPeersForProtocolAndShard, numPeers, maxBootstrapPeers);
+        const filteredPeers = filterPeersByDiscovery(allAvailableConnectedPeers, numPeers, maxBootstrapPeers);
         // Sort the peers by latency
-        const sortedFilteredPeers = await sortPeersByLatency(this.peerStore, filteredPeers);
+        const sortedFilteredPeers = await sortPeersByLatency(this.components.peerStore, filteredPeers);
         if (sortedFilteredPeers.length === 0) {
             this.log.warn("No peers found. Ensure you have a connection to the network.");
         }
@@ -339,4 +257,4 @@ class BaseProtocol {
     }
 }
 
-export { BaseProtocol as B, StreamManager as S, decodeRelayShard as d, encodeRelayShard as e };
+export { BaseProtocol as B, StreamManager as S };