@waku/core 0.0.28 → 0.0.29-3ec2344.0

package/bundle/{base_protocol-D0Zdzb-v.js → base_protocol-3fdjkRTX.js}

@@ -1,5 +1,5 @@
-import { b as bytesToUtf8, L as Logger, j as ensureShardingConfigured } from './index-BJwgMx4y.js';
-import { T as Tags } from './browser-DoQRY-an.js';
+import { c as bytesToUtf8, L as Logger, e as ensureShardingConfigured } from './index-BQ8SG1DC.js';
+import { T as Tags } from './browser-H8Jgqifo.js';
 
 const decodeRelayShard = (bytes) => {
     // explicitly converting to Uint8Array to avoid Buffer
@@ -175,6 +175,9 @@ function filterPeersByDiscovery(peers, numPeers, maxBootstrapPeers) {
     return selectedPeers;
 }
 
+const CONNECTION_TIMEOUT = 5_000;
+const RETRY_BACKOFF_BASE = 1_000;
+const MAX_RETRIES = 3;
 class StreamManager {
     multicodec;
     getConnections;
@@ -186,47 +189,86 @@ class StreamManager {
         this.getConnections = getConnections;
         this.addEventListener = addEventListener;
         this.log = new Logger(`stream-manager:${multicodec}`);
-        this.addEventListener("peer:update", this.handlePeerUpdateStreamPool.bind(this));
-        this.getStream = this.getStream.bind(this);
         this.streamPool = new Map();
+        this.addEventListener("peer:update", this.handlePeerUpdateStreamPool);
+        this.getStream = this.getStream.bind(this);
     }
     async getStream(peer) {
         const peerIdStr = peer.id.toString();
         const streamPromise = this.streamPool.get(peerIdStr);
         if (!streamPromise) {
-            return this.newStream(peer); // fallback by creating a new stream on the spot
+            return this.createStream(peer);
         }
-        // We have the stream, let's remove it from the map
         this.streamPool.delete(peerIdStr);
         this.prepareNewStream(peer);
-        const stream = await streamPromise;
-        if (!stream || stream.status === "closed") {
-            return this.newStream(peer); // fallback by creating a new stream on the spot
+        try {
+            const stream = await streamPromise;
+            if (stream && stream.status !== "closed") {
+                return stream;
+            }
+        }
+        catch (error) {
+            this.log.error(`Failed to get stream for ${peerIdStr} -- `, error);
+        }
+        return this.createStream(peer);
+    }
+    async createStream(peer) {
+        try {
+            return await this.newStream(peer);
+        }
+        catch (error) {
+            throw new Error(`Failed to create a new stream for ${peer.id.toString()} -- ` + error);
         }
-        return stream;
     }
-    async newStream(peer) {
+    async newStream(peer, retries = 0) {
         const connections = this.getConnections(peer.id);
         const connection = selectConnection(connections);
         if (!connection) {
             throw new Error("Failed to get a connection to the peer");
         }
-        return connection.newStream(this.multicodec);
+        try {
+            return await connection.newStream(this.multicodec);
+        }
+        catch (error) {
+            if (retries < MAX_RETRIES) {
+                const backoff = RETRY_BACKOFF_BASE * Math.pow(2, retries);
+                await new Promise((resolve) => setTimeout(resolve, backoff));
+                return this.newStream(peer, retries + 1);
+            }
+            throw error;
+        }
     }
     prepareNewStream(peer) {
-        const streamPromise = this.newStream(peer).catch(() => {
-            // No error thrown as this call is not triggered by the user
-            this.log.error(`Failed to prepare a new stream for ${peer.id.toString()}`);
+        const timeoutPromise = new Promise((resolve) => setTimeout(resolve, CONNECTION_TIMEOUT));
+        const streamPromise = Promise.race([
+            this.newStream(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);
     }
     handlePeerUpdateStreamPool = (evt) => {
-        const peer = evt.detail.peer;
+        const { peer } = evt.detail;
         if (peer.protocols.includes(this.multicodec)) {
-            this.log.info(`Preemptively opening a stream to ${peer.id.toString()}`);
-            this.prepareNewStream(peer);
+            const isConnected = this.isConnectedTo(peer.id);
+            if (isConnected) {
+                this.log.info(`Preemptively opening a stream to ${peer.id.toString()}`);
+                this.prepareNewStream(peer);
+            }
+            else {
+                const peerIdStr = peer.id.toString();
+                this.streamPool.delete(peerIdStr);
+                this.log.info(`Removed pending stream for disconnected peer ${peerIdStr}`);
+            }
         }
     };
+    isConnectedTo(peerId) {
+        const connections = this.getConnections(peerId);
+        return connections.some((connection) => connection.status === "open");
+    }
 }
 
 /**

package/bundle/{browser-DoQRY-an.js → browser-H8Jgqifo.js}

@@ -663,6 +663,11 @@ var ProtocolError;
      * on the connection manager before retrying.
      */
     ProtocolError["NO_PEER_AVAILABLE"] = "No peer available";
+    /**
+     * Failure to find a stream to the peer. This may be because the connection with the peer is not still alive.
+     * Mitigation can be: retrying after a given time period, or mitigation for `NO_PEER_AVAILABLE` can be used.
+     */
+    ProtocolError["NO_STREAM_AVAILABLE"] = "No stream available";
     /**
      * The remote peer did not behave as expected. Mitigation for `NO_PEER_AVAILABLE`
      * or `DECODE_FAILED` can be used.

package/bundle/{index-BJwgMx4y.js → index-BQ8SG1DC.js}

@@ -1,4 +1,4 @@
-import { i as identityBase, c as base2, d as base8, e as base10, f as base16, h as base32, j as base36, k as base58, l as base64, m as base256emoji, n as debug } from './browser-DoQRY-an.js';
+import { i as identityBase, c as base2, d as base8, e as base10, f as base16, h as base32, j as base36, k as base58, l as base64, m as base256emoji, n as debug } from './browser-H8Jgqifo.js';
 
 /**
  * Returns a `Uint8Array` of the requested size. Referenced memory will
@@ -379,7 +379,6 @@ const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
 /**
  * DefaultPubsubTopic is the default gossipsub topic to use for Waku.
  */
-const DefaultPubsubTopic = "/waku/2/default-waku/proto";
 /**
  * The default cluster ID for The Waku Network
  */
@@ -424,9 +423,9 @@ function concat(byteArrays, totalLength) {
 }
 
 const singleShardInfoToPubsubTopic = (shardInfo) => {
-    if (shardInfo.clusterId === undefined || shardInfo.shard === undefined)
+    if (shardInfo.shard === undefined)
         throw new Error("Invalid shard");
-    return `/waku/2/rs/${shardInfo.clusterId}/${shardInfo.shard}`;
+    return `/waku/2/rs/${shardInfo.clusterId ?? DEFAULT_CLUSTER_ID}/${shardInfo.shard}`;
 };
 const shardInfoToPubsubTopics = (shardInfo) => {
     if ("contentTopics" in shardInfo && shardInfo.contentTopics) {
@@ -465,13 +464,6 @@ const pubsubTopicToSingleShardInfo = (pubsubTopics) => {
         shard
     };
 };
-//TODO: move part of BaseProtocol instead of utils
-// return `ProtocolError.TOPIC_NOT_CONFIGURED` instead of throwing
-function ensurePubsubTopicIsConfigured(pubsubTopic, configuredTopics) {
-    if (!configuredTopics.includes(pubsubTopic)) {
-        throw new Error(`Pubsub topic ${pubsubTopic} has not been configured on this instance. Configured topics are: ${configuredTopics}. Please update your configuration by passing in the topic during Waku node instantiation.`);
-    }
-}
 /**
  * Given a string, will throw an error if it is not formatted as a valid content topic for autosharding based on https://rfc.vac.dev/spec/51/
  * @param contentTopic String to validate
@@ -530,23 +522,22 @@ function contentTopicToShardIndex(contentTopic, networkShards = 8) {
     return Number(dataview.getBigUint64(0, false) % BigInt(networkShards));
 }
 function contentTopicToPubsubTopic(contentTopic, clusterId = DEFAULT_CLUSTER_ID, networkShards = 8) {
+    if (!contentTopic) {
+        throw Error("Content topic must be specified");
+    }
     const shardIndex = contentTopicToShardIndex(contentTopic, networkShards);
     return `/waku/2/rs/${clusterId}/${shardIndex}`;
 }
 /**
  * Used when creating encoders/decoders to determine which pubsub topic to use
  */
-function determinePubsubTopic(contentTopic, pubsubTopicShardInfo = DefaultPubsubTopic) {
+function determinePubsubTopic(contentTopic, pubsubTopicShardInfo) {
     if (typeof pubsubTopicShardInfo == "string") {
         return pubsubTopicShardInfo;
     }
-    else {
-        return pubsubTopicShardInfo
-            ? pubsubTopicShardInfo.shard
-                ? singleShardInfoToPubsubTopic(pubsubTopicShardInfo)
-                : contentTopicToPubsubTopic(contentTopic, pubsubTopicShardInfo.clusterId)
-            : DefaultPubsubTopic;
-    }
+    return pubsubTopicShardInfo?.shard !== undefined
+        ? singleShardInfoToPubsubTopic(pubsubTopicShardInfo)
+        : contentTopicToPubsubTopic(contentTopic, pubsubTopicShardInfo?.clusterId ?? DEFAULT_CLUSTER_ID);
 }
 /**
  * Validates sharding configuration and sets defaults where possible.
@@ -620,4 +611,4 @@ class Logger {
     }
 }
 
-export { DefaultPubsubTopic as D, Logger as L, allocUnsafe as a, bytesToUtf8 as b, concat as c, alloc as d, singleShardInfoToPubsubTopic as e, ensurePubsubTopicIsConfigured as f, shardInfoToPubsubTopics as g, fromString as h, determinePubsubTopic as i, ensureShardingConfigured as j, pubsubTopicToSingleShardInfo as p, sha256 as s, utf8ToBytes as u };
+export { Logger as L, allocUnsafe as a, alloc as b, bytesToUtf8 as c, determinePubsubTopic as d, ensureShardingConfigured as e, fromString as f, pubsubTopicToSingleShardInfo as p, shardInfoToPubsubTopics as s, utf8ToBytes as u };