@waku/core 0.0.33-00c3261.0 → 0.0.33-11bf1c1.0

package/bundle/{base_protocol-iQ9XIkPz.js → base_protocol-Dzv-QHPR.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-BIW3qNYx.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:
@@ -156,26 +80,14 @@ 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 STREAM_LOCK_KEY = "consumed";
 class StreamManager {
     multicodec;
     getConnections;
@@ -193,18 +105,23 @@ class StreamManager {
     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 (scheduledStream) {
+            this.streamPool.delete(peerId);
+            await scheduledStream;
+        }
+        let stream = this.getOpenStreamForCodec(peer.id);
         if (stream) {
             this.log.info(`Found existing stream peerId=${peer.id.toString()} multicodec=${this.multicodec}`);
+            this.lockStream(peer.id.toString(), stream);
             return stream;
         }
-        return this.createStream(peer);
+        stream = await this.createStream(peer);
+        this.lockStream(peer.id.toString(), stream);
+        return stream;
     }
     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 peerId=${peer.id.toString()} multicodec=${this.multicodec}`);
         }
@@ -215,6 +132,7 @@ class StreamManager {
                 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;
@@ -236,16 +154,20 @@ class StreamManager {
             this.ongoingCreation.add(peerId);
             await this.createStream(peer);
         }
+        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.getStreamForCodec(peer.id);
+        const stream = this.getOpenStreamForCodec(peer.id);
         if (stream) {
             return;
         }
@@ -253,21 +175,35 @@ class StreamManager {
     };
     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));
-        const streamPromise = Promise.race([
-            this.createStreamWithLock(peer),
-            timeoutPromise
-        ]);
-        this.streamPool.set(peer.id.toString(), streamPromise);
+        // 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));
     }
-    getStreamForCodec(peerId) {
-        const connection = this.getConnections(peerId).find((c) => c.status === "open");
+    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];
+    }
 }
 
 /**
@@ -294,21 +230,19 @@ class BaseProtocol {
     async getStream(peer) {
         return this.streamManager.getStream(peer);
     }
-    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.peerStore, [this.multicodec]);
+        return getPeersForProtocol(this.components.peerStore, [this.multicodec]);
     }
     async connectedPeers() {
         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);
+            return connections.length > 0;
         });
     }
     /**
@@ -316,19 +250,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 +272,4 @@ class BaseProtocol {
     }
 }
 
-export { BaseProtocol as B, StreamManager as S, decodeRelayShard as d, encodeRelayShard as e };
+export { BaseProtocol as B, StreamManager as S };