@waku/core 0.0.30-e49e728.0 → 0.0.31-04bd518.0

package/bundle/index.js

@@ -1,9 +1,8 @@
-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';
+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 WakuMetadataRequest, i as WakuMetadataResponse } from './version_0-WhJLc79v.js';
+export { j as createDecoder } from './version_0-WhJLc79v.js';
+import { a as allocUnsafe, b as alloc, g as getDefaultExportFromCjs, L as Logger, P as ProtocolError, c as Protocols, u as utf8ToBytes, p as pubsubTopicToSingleShardInfo, E as EConnectionStateEvents, T as Tags, d as EPeersByDiscoveryEvents, s as shardInfoToPubsubTopics } from './index-DnW8ifxc.js';
+import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-BM6GbS_d.js';
+export { S as StreamManager } from './base_protocol-BM6GbS_d.js';
 
 const MB = 1024 ** 2;
 const SIZE_CAP_IN_MB = 1;
@@ -1615,39 +1614,14 @@ 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);
         });
     }
-    onRequest(streamData) {
-        const { connection, stream } = streamData;
-        const { remotePeer } = connection;
-        log$6.info(`Received message from ${remotePeer.toString()}`);
-        try {
-            pipe(stream, decode, async (source) => {
-                for await (const bytes of source) {
-                    const response = FilterPushRpc.decode(bytes.slice());
-                    const { pubsubTopic, wakuMessage } = response;
-                    if (!wakuMessage) {
-                        log$6.error("Received empty message");
-                        return;
-                    }
-                    if (!pubsubTopic) {
-                        log$6.error("Pubsub topic missing from push message");
-                        return;
-                    }
-                    await this.handleIncomingMessage(pubsubTopic, wakuMessage);
-                }
-            }).then(() => {
-                log$6.info("Receiving pipe closed.");
-            }, (e) => {
-                log$6.error("Error with receiving pipe", e);
-            });
-        }
-        catch (e) {
-            log$6.error("Error decoding message", e);
-        }
-    }
     async subscribe(pubsubTopic, peer, contentTopics) {
         const stream = await this.getStream(peer);
         const request = FilterSubscribeRpc.createSubscribeRequest(pubsubTopic, contentTopics);
@@ -1799,6 +1773,35 @@ class FilterCore extends BaseProtocol {
             failure: null
         };
     }
+    onRequest(streamData) {
+        const { connection, stream } = streamData;
+        const { remotePeer } = connection;
+        log$6.info(`Received message from ${remotePeer.toString()}`);
+        try {
+            pipe(stream, decode, async (source) => {
+                for await (const bytes of source) {
+                    const response = FilterPushRpc.decode(bytes.slice());
+                    const { pubsubTopic, wakuMessage } = response;
+                    if (!wakuMessage) {
+                        log$6.error("Received empty message");
+                        return;
+                    }
+                    if (!pubsubTopic) {
+                        log$6.error("Pubsub topic missing from push message");
+                        return;
+                    }
+                    await this.handleIncomingMessage(pubsubTopic, wakuMessage, connection.remotePeer.toString());
+                }
+            }).then(() => {
+                log$6.info("Receiving pipe closed.");
+            }, (e) => {
+                log$6.error("Error with receiving pipe", e);
+            });
+        }
+        catch (e) {
+            log$6.error("Error decoding message", e);
+        }
+    }
 }
 
 var index$2 = /*#__PURE__*/Object.freeze({
@@ -2591,17 +2594,17 @@ const CustomEvent = globalThis.CustomEvent ?? CustomEventPolyfill;
 const RelayPingContentTopic = "/relay-ping/1/ping/null";
 const log$2 = new Logger("keep-alive");
 class KeepAliveManager {
-    pingKeepAliveTimers;
-    relayKeepAliveTimers;
-    options;
     relay;
-    constructor(options, relay) {
-        this.pingKeepAliveTimers = new Map();
-        this.relayKeepAliveTimers = new Map();
+    libp2p;
+    options;
+    pingKeepAliveTimers = new Map();
+    relayKeepAliveTimers = new Map();
+    constructor({ options, relay, libp2p }) {
         this.options = options;
         this.relay = relay;
+        this.libp2p = libp2p;
     }
-    start(peerId, libp2pPing, peerStore) {
+    start(peerId) {
         // Just in case a timer already exists for this peer
         this.stop(peerId);
         const { pingKeepAlive: pingPeriodSecs, relayKeepAlive: relayPeriodSecs } = this.options;
@@ -2616,7 +2619,7 @@ class KeepAliveManager {
                         // ping the peer for keep alive
                         // also update the peer store with the latency
                         try {
-                            ping = await libp2pPing.ping(peerId);
+                            ping = await this.libp2p.services.ping.ping(peerId);
                             log$2.info(`Ping succeeded (${peerIdStr})`, ping);
                         }
                         catch (error) {
@@ -2626,7 +2629,7 @@ class KeepAliveManager {
                             return;
                         }
                         try {
-                            await peerStore.merge(peerId, {
+                            await this.libp2p.peerStore.merge(peerId, {
                                 metadata: {
                                     ping: utf8ToBytes(ping.toString())
                                 }
@@ -2739,6 +2742,22 @@ class ConnectionManager extends TypedEventEmitter {
         }
         return instance;
     }
+    stop() {
+        this.keepAliveManager.stopAll();
+        this.libp2p.removeEventListener("peer:connect", this.onEventHandlers["peer:connect"]);
+        this.libp2p.removeEventListener("peer:disconnect", this.onEventHandlers["peer:disconnect"]);
+        this.libp2p.removeEventListener("peer:discovery", this.onEventHandlers["peer:discovery"]);
+    }
+    async dropConnection(peerId) {
+        try {
+            this.keepAliveManager.stop(peerId);
+            await this.libp2p.hangUp(peerId);
+            log$1.info(`Dropped connection with peer ${peerId.toString()}`);
+        }
+        catch (error) {
+            log$1.error(`Error dropping connection with peer ${peerId.toString()} - ${error}`);
+        }
+    }
     async getPeersByDiscovery() {
         const peersDiscovered = await this.libp2p.peerStore.all();
         const peersConnected = this.libp2p
@@ -2799,7 +2818,11 @@ class ConnectionManager extends TypedEventEmitter {
             maxParallelDials: DEFAULT_MAX_PARALLEL_DIALS,
             ...options
         };
-        this.keepAliveManager = new KeepAliveManager(keepAliveOptions, relay);
+        this.keepAliveManager = new KeepAliveManager({
+            relay,
+            libp2p,
+            options: keepAliveOptions
+        });
         this.run()
             .then(() => log$1.info(`Connection Manager is now running`))
             .catch((error) => log$1.error(`Unexpected error while running service`, error));
@@ -2829,12 +2852,6 @@ class ConnectionManager extends TypedEventEmitter {
         this.startPeerConnectionListener();
         this.startPeerDisconnectionListener();
     }
-    stop() {
-        this.keepAliveManager.stopAll();
-        this.libp2p.removeEventListener("peer:connect", this.onEventHandlers["peer:connect"]);
-        this.libp2p.removeEventListener("peer:disconnect", this.onEventHandlers["peer:disconnect"]);
-        this.libp2p.removeEventListener("peer:discovery", this.onEventHandlers["peer:discovery"]);
-    }
     async dialPeer(peerId) {
         this.currentActiveParallelDialCount += 1;
         let dialAttempt = 0;
@@ -2852,6 +2869,7 @@ class ConnectionManager extends TypedEventEmitter {
                 // this helps us keep track of peers that have been dialed before
                 this.dialAttemptsForPeer.set(peerId.toString(), -1);
                 // Dialing succeeded, break the loop
+                this.keepAliveManager.start(peerId);
                 break;
             }
             catch (error) {
@@ -2901,16 +2919,6 @@ class ConnectionManager extends TypedEventEmitter {
             }
         }
     }
-    async dropConnection(peerId) {
-        try {
-            this.keepAliveManager.stop(peerId);
-            await this.libp2p.hangUp(peerId);
-            log$1.info(`Dropped connection with peer ${peerId.toString()}`);
-        }
-        catch (error) {
-            log$1.error(`Error dropping connection with peer ${peerId.toString()} - ${error}`);
-        }
-    }
     processDialQueue() {
         if (this.pendingPeerDialQueue.length > 0 &&
             this.currentActiveParallelDialCount < this.options.maxParallelDials) {
@@ -2950,9 +2958,7 @@ class ConnectionManager extends TypedEventEmitter {
             this.pendingPeerDialQueue.push(peerId);
             return;
         }
-        this.dialPeer(peerId).catch((err) => {
-            log$1.error(`Error dialing peer ${peerId.toString()} : ${err}`);
-        });
+        await this.dialPeer(peerId);
     }
     onEventHandlers = {
         "peer:discovery": (evt) => {
@@ -2971,7 +2977,7 @@ class ConnectionManager extends TypedEventEmitter {
             void (async () => {
                 log$1.info(`Connected to peer ${evt.detail.toString()}`);
                 const peerId = evt.detail;
-                this.keepAliveManager.start(peerId, this.libp2p.services.ping, this.libp2p.peerStore);
+                this.keepAliveManager.start(peerId);
                 const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(Tags.BOOTSTRAP);
                 if (isBootstrap) {
                     const bootstrapConnections = this.libp2p
@@ -3011,26 +3017,25 @@ class ConnectionManager extends TypedEventEmitter {
      * @returns true if the peer should be dialed, false otherwise
      */
     async shouldDialPeer(peerId) {
-        // if we're already connected to the peer, don't dial
         const isConnected = this.libp2p.getConnections(peerId).length > 0;
         if (isConnected) {
             log$1.warn(`Already connected to peer ${peerId.toString()}. Not dialing.`);
             return false;
         }
-        // if the peer is not part of any of the configured pubsub topics, don't dial
-        if (!(await this.isPeerTopicConfigured(peerId))) {
+        const isSameShard = await this.isPeerTopicConfigured(peerId);
+        if (!isSameShard) {
             const shardInfo = await this.getPeerShardInfo(peerId, this.libp2p.peerStore);
             log$1.warn(`Discovered peer ${peerId.toString()} with ShardInfo ${shardInfo} is not part of any of the configured pubsub topics (${this.configuredPubsubTopics}).
             Not dialing.`);
             return false;
         }
-        // if the peer is not dialable based on bootstrap status, don't dial
-        if (!(await this.isPeerDialableBasedOnBootstrapStatus(peerId))) {
+        const isPreferredBasedOnBootstrap = await this.isPeerDialableBasedOnBootstrapStatus(peerId);
+        if (!isPreferredBasedOnBootstrap) {
             log$1.warn(`Peer ${peerId.toString()} is not dialable based on bootstrap status. Not dialing.`);
             return false;
         }
-        // If the peer is already already has an active dial attempt, or has been dialed before, don't dial it
-        if (this.dialAttemptsForPeer.has(peerId.toString())) {
+        const hasBeenDialed = this.dialAttemptsForPeer.has(peerId.toString());
+        if (hasBeenDialed) {
             log$1.warn(`Peer ${peerId.toString()} has already been attempted dial before, or already has a dial attempt in progress, skipping dial`);
             return false;
         }
@@ -3044,19 +3049,15 @@ class ConnectionManager extends TypedEventEmitter {
     async isPeerDialableBasedOnBootstrapStatus(peerId) {
         const tagNames = await this.getTagNamesForPeer(peerId);
         const isBootstrap = tagNames.some((tagName) => tagName === Tags.BOOTSTRAP);
-        if (isBootstrap) {
-            const currentBootstrapConnections = this.libp2p
-                .getConnections()
-                .filter((conn) => {
-                return conn.tags.find((name) => name === Tags.BOOTSTRAP);
-            }).length;
-            if (currentBootstrapConnections < this.options.maxBootstrapPeersAllowed)
-                return true;
-        }
-        else {
+        if (!isBootstrap) {
             return true;
         }
-        return false;
+        const currentBootstrapConnections = this.libp2p
+            .getConnections()
+            .filter((conn) => {
+            return conn.tags.find((name) => name === Tags.BOOTSTRAP);
+        }).length;
+        return currentBootstrapConnections < this.options.maxBootstrapPeersAllowed;
     }
     async dispatchDiscoveryEvent(peerId) {
         const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(Tags.BOOTSTRAP);
@@ -3111,24 +3112,6 @@ class Metadata extends BaseProtocol {
             void this.onRequest(streamData);
         });
     }
-    /**
-     * Handle an incoming metadata request
-     */
-    async onRequest(streamData) {
-        try {
-            const { stream, connection } = streamData;
-            const encodedShardInfo = WakuMetadataResponse.encode(this.shardInfo);
-            const encodedResponse = await pipe([encodedShardInfo], encode, stream, decode, async (source) => await all(source));
-            const { error, shardInfo } = this.decodeMetadataResponse(encodedResponse);
-            if (error) {
-                return;
-            }
-            await this.savePeerShardInfo(connection.remotePeer, shardInfo);
-        }
-        catch (error) {
-            log.error("Error handling metadata request", error);
-        }
-    }
     /**
      * Make a metadata query to a peer
      */
@@ -3176,6 +3159,24 @@ class Metadata extends BaseProtocol {
         }
         return await this.query(peerId);
     }
+    /**
+     * Handle an incoming metadata request
+     */
+    async onRequest(streamData) {
+        try {
+            const { stream, connection } = streamData;
+            const encodedShardInfo = WakuMetadataResponse.encode(this.shardInfo);
+            const encodedResponse = await pipe([encodedShardInfo], encode, stream, decode, async (source) => await all(source));
+            const { error, shardInfo } = this.decodeMetadataResponse(encodedResponse);
+            if (error) {
+                return;
+            }
+            await this.savePeerShardInfo(connection.remotePeer, shardInfo);
+        }
+        catch (error) {
+            log.error("Error handling metadata request", error);
+        }
+    }
     decodeMetadataResponse(encodedResponse) {
         const bytes = new Uint8ArrayList();
         encodedResponse.forEach((chunk) => {

package/bundle/lib/base_protocol.js

@@ -1,3 +1,2 @@
-import '../index-BcSodzY4.js';
-import '../browser-zSUobdfj.js';
-export { B as BaseProtocol } from '../base_protocol-DCOj0QWD.js';
+import '../index-DnW8ifxc.js';
+export { B as BaseProtocol } from '../base_protocol-BM6GbS_d.js';

package/bundle/lib/message/version_0.js

@@ -1,3 +1,2 @@
-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';
+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-WhJLc79v.js';
+import '../../index-DnW8ifxc.js';

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

@@ -1,4 +1,4 @@
-import { a as allocUnsafe, f as fromString, b as alloc$1, L as Logger, d as determinePubsubTopic } from './index-BcSodzY4.js';
+import { a as allocUnsafe, f as fromString, b as alloc$1, L as Logger, e as determinePubsubTopic } from './index-DnW8ifxc.js';
 
 /* eslint-disable no-fallthrough */
 const N1 = Math.pow(2, 7);
@@ -4056,4 +4056,4 @@ var version_0 = /*#__PURE__*/Object.freeze({
     proto: message
 });
 
-export { DecodedMessage as D, Encoder as E, FilterSubscribeRequest as F, HistoryRpc$1 as H, MessagePush as M, PushRpc$1 as P, Version as V, WakuMetadataResponse as W, encode as a, FilterSubscribeResponse$1 as b, PushResponse as c, decode as d, encodingLength as e, PagingInfo as f, HistoryResponse as g, createEncoder as h, WakuMetadataRequest as i, createDecoder as j, Decoder as k, message as m, version_0 as v };
+export { DecodedMessage as D, Encoder as E, FilterSubscribeRequest as F, HistoryRpc$1 as H, MessagePush as M, PushRpc$1 as P, Version as V, WakuMetadataRequest as W, encode as a, FilterSubscribeResponse$1 as b, PushResponse as c, decode as d, encodingLength as e, PagingInfo as f, HistoryResponse as g, createEncoder as h, WakuMetadataResponse as i, createDecoder as j, Decoder as k, message as m, version_0 as v };