@waku/core 0.0.29 → 0.0.30-16e9116.0

package/bundle/{base_protocol-CrPXdVvO.js → base_protocol-DCOj0QWD.js}

@@ -1,5 +1,5 @@
-import { c as bytesToUtf8, L as Logger, e as ensureShardingConfigured } from './index-NYIjIEV5.js';
-import { T as Tags } from './browser-DoQRY-an.js';
+import { c as bytesToUtf8, L as Logger, e as ensureShardingConfigured } from './index-BcSodzY4.js';
+import { T as Tags } from './browser-zSUobdfj.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,78 @@ 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);
     }
     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
+        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 stream;
+        return this.createStream(peer);
     }
-    async newStream(peer) {
+    async createStream(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.createStream(peer, retries + 1);
+            }
+            throw new Error(`Failed to create a new stream for ${peer.id.toString()} -- ` + 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()}`);
+    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);
     }
     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.prepareStream(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-zSUobdfj.js}

@@ -656,6 +656,11 @@ var ProtocolError;
      * Please ensure that the PubsubTopic is used when initializing the Waku node.
      */
     ProtocolError["TOPIC_NOT_CONFIGURED"] = "Topic not configured";
+    /**
+     * The pubsub topic configured on the decoder does not match the pubsub topic setup on the protocol.
+     * Ensure that the pubsub topic used for decoder creation is the same as the one used for protocol.
+     */
+    ProtocolError["TOPIC_DECODER_MISMATCH"] = "Topic decoder mismatch";
     /**
      * Failure to find a peer with suitable protocols. This may due to a connection issue.
      * Mitigation can be: retrying after a given time period, display connectivity issue
@@ -663,6 +668,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-NYIjIEV5.js → index-BcSodzY4.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-zSUobdfj.js';
 
 /**
  * Returns a `Uint8Array` of the requested size. Referenced memory will

package/bundle/index.js

@@ -1,9 +1,9 @@
-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, H as HistoryRpc$1, f as PagingInfo, g as HistoryResponse, h as createEncoder, W as WakuMetadataResponse, i as WakuMetadataRequest } from './version_0-C6GyvOeg.js';
-export { j as createDecoder } from './version_0-C6GyvOeg.js';
-import { g as getDefaultExportFromCjs, P as ProtocolError, a as Protocols, E as EConnectionStateEvents, T as Tags, b as EPeersByDiscoveryEvents } from './browser-DoQRY-an.js';
-import { a as allocUnsafe, b as alloc, L as Logger, u as utf8ToBytes, p as pubsubTopicToSingleShardInfo, s as shardInfoToPubsubTopics } from './index-NYIjIEV5.js';
-import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-CrPXdVvO.js';
-export { S as StreamManager } from './base_protocol-CrPXdVvO.js';
+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, H as HistoryRpc$1, f as PagingInfo, g as HistoryResponse, h as createEncoder, W as WakuMetadataResponse, i as WakuMetadataRequest } from './version_0-TEIsGmpJ.js';
+export { j as createDecoder } from './version_0-TEIsGmpJ.js';
+import { g as getDefaultExportFromCjs, P as ProtocolError, a as Protocols, E as EConnectionStateEvents, T as Tags, b as EPeersByDiscoveryEvents } from './browser-zSUobdfj.js';
+import { a as allocUnsafe, b as alloc, L as Logger, u as utf8ToBytes, p as pubsubTopicToSingleShardInfo, s as shardInfoToPubsubTopics } from './index-BcSodzY4.js';
+import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-DCOj0QWD.js';
+export { S as StreamManager } from './base_protocol-DCOj0QWD.js';
 
 const MB = 1024 ** 2;
 const SIZE_CAP_IN_MB = 1;
@@ -1615,7 +1615,11 @@ class FilterCore extends BaseProtocol {
     constructor(handleIncomingMessage, libp2p, options) {
         super(FilterCodecs.SUBSCRIBE, libp2p.components, log$6, options.pubsubTopics, options);
         this.handleIncomingMessage = handleIncomingMessage;
-        libp2p.handle(FilterCodecs.PUSH, this.onRequest.bind(this)).catch((e) => {
+        libp2p
+            .handle(FilterCodecs.PUSH, this.onRequest.bind(this), {
+            maxInboundStreams: 100
+        })
+            .catch((e) => {
             log$6.error("Failed to register ", FilterCodecs.PUSH, e);
         });
     }
@@ -1651,50 +1655,153 @@ class FilterCore extends BaseProtocol {
     async subscribe(pubsubTopic, peer, contentTopics) {
         const stream = await this.getStream(peer);
         const request = FilterSubscribeRpc.createSubscribeRequest(pubsubTopic, contentTopics);
-        const res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
-        if (!res || !res.length) {
-            throw Error(`No response received for request ${request.requestId}: ${res}`);
+        let res;
+        try {
+            res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
+        }
+        catch (error) {
+            log$6.error("Failed to send subscribe request", error);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.GENERIC_FAIL,
+                    peerId: peer.id
+                }
+            };
         }
         const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
         if (statusCode < 200 || statusCode >= 300) {
-            throw new Error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$6.error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            return {
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    peerId: peer.id
+                },
+                success: null
+            };
         }
+        return {
+            failure: null,
+            success: peer.id
+        };
     }
     async unsubscribe(pubsubTopic, peer, contentTopics) {
-        const stream = await this.getStream(peer);
+        let stream;
+        try {
+            stream = await this.getStream(peer);
+        }
+        catch (error) {
+            log$6.error(`Failed to get a stream for remote peer${peer.id.toString()}`, error);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    peerId: peer.id
+                }
+            };
+        }
         const unsubscribeRequest = FilterSubscribeRpc.createUnsubscribeRequest(pubsubTopic, contentTopics);
-        await pipe([unsubscribeRequest.encode()], encode, stream.sink);
+        try {
+            await pipe([unsubscribeRequest.encode()], encode, stream.sink);
+        }
+        catch (error) {
+            log$6.error("Failed to send unsubscribe request", error);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.GENERIC_FAIL,
+                    peerId: peer.id
+                }
+            };
+        }
+        return {
+            success: peer.id,
+            failure: null
+        };
     }
     async unsubscribeAll(pubsubTopic, peer) {
         const stream = await this.getStream(peer);
         const request = FilterSubscribeRpc.createUnsubscribeAllRequest(pubsubTopic);
         const res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
         if (!res || !res.length) {
-            throw Error(`No response received for request ${request.requestId}: ${res}`);
+            return {
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    peerId: peer.id
+                },
+                success: null
+            };
         }
         const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
         if (statusCode < 200 || statusCode >= 300) {
-            throw new Error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$6.error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            return {
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    peerId: peer.id
+                },
+                success: null
+            };
         }
+        return {
+            failure: null,
+            success: peer.id
+        };
     }
     async ping(peer) {
-        const stream = await this.getStream(peer);
+        let stream;
+        try {
+            stream = await this.getStream(peer);
+        }
+        catch (error) {
+            log$6.error(`Failed to get a stream for remote peer${peer.id.toString()}`, error);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    peerId: peer.id
+                }
+            };
+        }
         const request = FilterSubscribeRpc.createSubscriberPingRequest();
+        let res;
         try {
-            const res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
-            if (!res || !res.length) {
-                throw Error(`No response received for request ${request.requestId}: ${res}`);
-            }
-            const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
-            if (statusCode < 200 || statusCode >= 300) {
-                throw new Error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
-            }
-            log$6.info(`Ping successful for peer ${peer.id.toString()}`);
+            res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
         }
         catch (error) {
-            log$6.error("Error pinging: ", error);
-            throw error; // Rethrow the actual error instead of wrapping it
+            log$6.error("Failed to send ping request", error);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.GENERIC_FAIL,
+                    peerId: peer.id
+                }
+            };
+        }
+        if (!res || !res.length) {
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    peerId: peer.id
+                }
+            };
         }
+        const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
+        if (statusCode < 200 || statusCode >= 300) {
+            log$6.error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    peerId: peer.id
+                }
+            };
+        }
+        return {
+            success: peer.id,
+            failure: null
+        };
     }
 }
 
@@ -1787,12 +1894,12 @@ class LightPushCore extends BaseProtocol {
         try {
             stream = await this.getStream(peer);
         }
-        catch (err) {
-            log$5.error(`Failed to get a stream for remote peer${peer.id.toString()}`, err);
+        catch (error) {
+            log$5.error("Failed to get stream", error);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    error: ProtocolError.NO_STREAM_AVAILABLE,
                     peerId: peer.id
                 }
             };
@@ -1964,7 +2071,14 @@ class StoreCore extends BaseProtocol {
         while (true) {
             queryOpts.cursor = currentCursor;
             const historyRpcQuery = HistoryRpc.createQuery(queryOpts);
-            const stream = await this.getStream(peer);
+            let stream;
+            try {
+                stream = await this.getStream(peer);
+            }
+            catch (e) {
+                log$4.error("Failed to get stream", e);
+                break;
+            }
             const res = await pipe([historyRpcQuery.encode()], encode, stream, decode, async (source) => await all(source));
             const bytes = new Uint8ArrayList();
             res.forEach((chunk) => {
@@ -3031,7 +3145,17 @@ class Metadata extends BaseProtocol {
                 error: ProtocolError.NO_PEER_AVAILABLE
             };
         }
-        const stream = await this.getStream(peer);
+        let stream;
+        try {
+            stream = await this.getStream(peer);
+        }
+        catch (error) {
+            log.error("Failed to get stream", error);
+            return {
+                shardInfo: null,
+                error: ProtocolError.NO_STREAM_AVAILABLE
+            };
+        }
         const encodedResponse = await pipe([request], encode, stream, decode, async (source) => await all(source));
         const { error, shardInfo } = this.decodeMetadataResponse(encodedResponse);
         if (error) {

package/bundle/lib/base_protocol.js

@@ -1,3 +1,3 @@
-import '../index-NYIjIEV5.js';
-import '../browser-DoQRY-an.js';
-export { B as BaseProtocol } from '../base_protocol-CrPXdVvO.js';
+import '../index-BcSodzY4.js';
+import '../browser-zSUobdfj.js';
+export { B as BaseProtocol } from '../base_protocol-DCOj0QWD.js';

package/bundle/lib/message/version_0.js

@@ -1,3 +1,3 @@
-export { D as DecodedMessage, k as Decoder, E as Encoder, V as Version, j as createDecoder, h as createEncoder, m as proto } from '../../version_0-C6GyvOeg.js';
-import '../../index-NYIjIEV5.js';
-import '../../browser-DoQRY-an.js';
+export { D as DecodedMessage, k as Decoder, E as Encoder, V as Version, j as createDecoder, h as createEncoder, m as proto } from '../../version_0-TEIsGmpJ.js';
+import '../../index-BcSodzY4.js';
+import '../../browser-zSUobdfj.js';

package/bundle/lib/predefined_bootstrap_nodes.js

@@ -1,4 +1,4 @@
-import '../browser-DoQRY-an.js';
+import '../browser-zSUobdfj.js';
 
 /**
  * Return pseudo random subset of the input.

package/bundle/{version_0-C6GyvOeg.js → version_0-TEIsGmpJ.js}

@@ -1,4 +1,4 @@
-import { a as allocUnsafe, f as fromString, b as alloc$1, L as Logger, d as determinePubsubTopic } from './index-NYIjIEV5.js';
+import { a as allocUnsafe, f as fromString, b as alloc$1, L as Logger, d as determinePubsubTopic } from './index-BcSodzY4.js';
 
 /* eslint-disable no-fallthrough */
 const N1 = Math.pow(2, 7);