@waku/core 0.0.33-c50088a.0 → 0.0.33-c9fdfb3.0

package/bundle/{base_protocol-BUWwtk7E.js → base_protocol-BDjsZTsQ.js}

@@ -1,4 +1,4 @@
-import { g as bytesToUtf8, T as Tags, L as Logger } from './index-CpCu13gb.js';
+import { g as bytesToUtf8, T as Tags, L as Logger } from './index-CeEH6b9b.js';
 
 /**
  * Function to sort peers by latency from lowest to highest
@@ -80,110 +80,129 @@ 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;
+const STREAM_LOCK_KEY = "consumed";
 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);
+        const peerId = peer.id.toString();
+        const scheduledStream = this.streamPool.get(peerId);
+        if (scheduledStream) {
+            this.streamPool.delete(peerId);
+            await scheduledStream;
         }
-        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");
+        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");
+            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);
+        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];
     }
 }
 
@@ -211,7 +230,6 @@ class BaseProtocol {
     async getStream(peer) {
         return this.streamManager.getStream(peer);
     }
-    //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
@@ -220,13 +238,10 @@ class BaseProtocol {
     async allPeers() {
         return getPeersForProtocol(this.components.peerStore, [this.multicodec]);
     }
-    async connectedPeers(withOpenStreams = false) {
+    async connectedPeers() {
         const peers = await this.allPeers();
         return peers.filter((peer) => {
             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;
         });
     }

package/bundle/{index-CpCu13gb.js → index-CeEH6b9b.js}

@@ -236,11 +236,12 @@ class Decoder {
     constructor(name, prefix, baseDecode) {
         this.name = name;
         this.prefix = prefix;
+        const prefixCodePoint = prefix.codePointAt(0);
         /* c8 ignore next 3 */
-        if (prefix.codePointAt(0) === undefined) {
+        if (prefixCodePoint === undefined) {
             throw new Error('Invalid prefix character');
         }
-        this.prefixCodePoint = prefix.codePointAt(0);
+        this.prefixCodePoint = prefixCodePoint;
         this.baseDecode = baseDecode;
     }
     decode(text) {
@@ -444,7 +445,14 @@ var base2$1 = /*#__PURE__*/Object.freeze({
 
 const alphabet = Array.from('🚀🪐☄🛰🌌🌑🌒🌓🌔🌕🌖🌗🌘🌍🌏🌎🐉☀💻🖥💾💿😂❤😍🤣😊🙏💕😭😘👍😅👏😁🔥🥰💔💖💙😢🤔😆🙄💪😉☺👌🤗💜😔😎😇🌹🤦🎉💞✌✨🤷😱😌🌸🙌😋💗💚😏💛🙂💓🤩😄😀🖤😃💯🙈👇🎶😒🤭❣😜💋👀😪😑💥🙋😞😩😡🤪👊🥳😥🤤👉💃😳✋😚😝😴🌟😬🙃🍀🌷😻😓⭐✅🥺🌈😈🤘💦✔😣🏃💐☹🎊💘😠☝😕🌺🎂🌻😐🖕💝🙊😹🗣💫💀👑🎵🤞😛🔴😤🌼😫⚽🤙☕🏆🤫👈😮🙆🍻🍃🐶💁😲🌿🧡🎁⚡🌞🎈❌✊👋😰🤨😶🤝🚶💰🍓💢🤟🙁🚨💨🤬✈🎀🍺🤓😙💟🌱😖👶🥴▶➡❓💎💸⬇😨🌚🦋😷🕺⚠🙅😟😵👎🤲🤠🤧📌🔵💅🧐🐾🍒😗🤑🌊🤯🐷☎💧😯💆👆🎤🙇🍑❄🌴💣🐸💌📍🥀🤢👅💡💩👐📸👻🤐🤮🎼🥵🚩🍎🍊👼💍📣🥂');
 const alphabetBytesToChars = (alphabet.reduce((p, c, i) => { p[i] = c; return p; }, ([])));
-const alphabetCharsToBytes = (alphabet.reduce((p, c, i) => { p[c.codePointAt(0)] = i; return p; }, ([])));
+const alphabetCharsToBytes = (alphabet.reduce((p, c, i) => {
+    const codePoint = c.codePointAt(0);
+    if (codePoint == null) {
+        throw new Error(`Invalid character: ${c}`);
+    }
+    p[codePoint] = i;
+    return p;
+}, ([])));
 function encode(data) {
     return data.reduce((p, c) => {
         p += alphabetBytesToChars[c];
@@ -454,8 +462,12 @@ function encode(data) {
 function decode(str) {
     const byts = [];
     for (const char of str) {
-        const byt = alphabetCharsToBytes[char.codePointAt(0)];
-        if (byt === undefined) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint == null) {
+            throw new Error(`Invalid character: ${char}`);
+        }
+        const byt = alphabetCharsToBytes[codePoint];
+        if (byt == null) {
             throw new Error(`Non-base256emoji character: ${char}`);
         }
         byts.push(byt);
@@ -895,7 +907,7 @@ function requireMs () {
 	 * @api public
 	 */
 
-	ms = function(val, options) {
+	ms = function (val, options) {
 	  options = options || {};
 	  var type = typeof val;
 	  if (type === 'string' && val.length > 0) {
@@ -1588,6 +1600,7 @@ var debug = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
 const APP_NAME = "waku";
 class Logger {
+    _debug;
     _info;
     _warn;
     _error;
@@ -1595,10 +1608,14 @@ class Logger {
         return prefix ? `${APP_NAME}:${level}:${prefix}` : `${APP_NAME}:${level}`;
     }
     constructor(prefix) {
+        this._debug = debug(Logger.createDebugNamespace("debug", prefix));
         this._info = debug(Logger.createDebugNamespace("info", prefix));
         this._warn = debug(Logger.createDebugNamespace("warn", prefix));
         this._error = debug(Logger.createDebugNamespace("error", prefix));
     }
+    get debug() {
+        return this._debug;
+    }
     get info() {
         return this._info;
     }
@@ -1614,4 +1631,4 @@ class Logger {
     }
 }
 
-export { EPeersByDiscoveryEvents as E, HealthStatus as H, Logger as L, ProtocolError as P, Tags as T, allocUnsafe as a, alloc as b, Protocols as c, EConnectionStateEvents as d, concat as e, fromString as f, bytesToUtf8 as g, utf8ToBytes as u };
+export { EPeersByDiscoveryEvents as E, HealthStatus as H, Logger as L, ProtocolError as P, Tags as T, allocUnsafe as a, alloc as b, EConnectionStateEvents as c, Protocols as d, concat as e, fromString as f, bytesToUtf8 as g, utf8ToBytes as u };