@waku/core 0.0.37-2ed5ddc.0 → 0.0.37-987c6cd.0

package/bundle/index.js

@@ -1,5 +1,5 @@
-import { e as equals$2, c as coerce, b as base32, a as base58btc, d as base36, v as version_0, f as allocUnsafe, g as alloc, h as encodingLength$1, i as encode$3, j as decode$4, L as Logger, F as FilterSubscribeRequest, k as FilterSubscribeResponse$1, M as MessagePush, P as ProtocolError, l as PushRpc$1, m as PushResponse, S as StoreQueryRequest$1, n as StoreQueryResponse$1, T as Tags, o as createEncoder, p as pubsubTopicToSingleShardInfo, u as utf8ToBytes, q as contentTopicToShardIndex, t as toString, r as fromString, s as hexToBytes, w as isBytes, x as abytes, y as bytesToHex, z as concatBytes, A as anumber, B as randomBytes, C as sha512, D as enumeration, E as message, G as encodeMessage, H as decodeMessage, I as Hash, J as ahash, K as toBytes, N as clean, O as aexists, Q as sha256$1, R as bases, U as base64url, V as encodeUint8Array, W as bytesToUtf8, X as WakuMetadataRequest, Y as pubsubTopicsToShardInfo, Z as WakuMetadataResponse, _ as concat$1, $ as sha256$2, a0 as bytesToHex$1, a1 as numberToBytes } from './version_0-Bc0h7ah2.js';
-export { a2 as createDecoder } from './version_0-Bc0h7ah2.js';
+import { e as equals$2, c as coerce, b as base32, a as base58btc, d as base36, v as version_0, f as allocUnsafe, g as alloc, h as encodingLength$1, i as encode$3, j as decode$4, L as Logger, F as FilterSubscribeRequest, k as FilterSubscribeResponse$1, M as MessagePush, P as ProtocolError, l as PushRpc$1, m as PushResponse, S as StoreQueryRequest$1, n as StoreQueryResponse$1, T as Tags, o as createEncoder, p as pubsubTopicToSingleShardInfo, u as utf8ToBytes, q as contentTopicToShardIndex, t as toString, r as fromString, s as hexToBytes, w as isBytes, x as abytes, y as bytesToHex, z as concatBytes, A as anumber, B as randomBytes, C as sha512, D as enumeration, E as message, G as encodeMessage, H as decodeMessage, I as Hash, J as ahash, K as toBytes, N as clean, O as aexists, Q as sha256$1, R as bases, U as base64url, V as encodeUint8Array, W as bytesToUtf8, X as WakuMetadataRequest, Y as pubsubTopicsToShardInfo, Z as WakuMetadataResponse, _ as concat$1, $ as sha256$2, a0 as bytesToHex$1, a1 as numberToBytes } from './version_0-BpF0pNhc.js';
+export { a2 as createDecoder } from './version_0-BpF0pNhc.js';
 
 /* eslint-disable */
 var encode_1 = encode$2;
@@ -2478,7 +2478,7 @@ class FilterSubscribeResponse {
     }
 }
 
-const log$8 = new Logger("filter-core");
+const log$9 = new Logger("filter-core");
 const FilterCodecs = {
     SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
     PUSH: "/vac/waku/filter-push/2.0.0-beta1"
@@ -2495,7 +2495,7 @@ class FilterCore {
             maxInboundStreams: 100
         })
             .catch((e) => {
-            log$8.error("Failed to register ", FilterCodecs.PUSH, e);
+            log$9.error("Failed to register ", FilterCodecs.PUSH, e);
         });
     }
     async subscribe(pubsubTopic, peerId, contentTopics) {
@@ -2509,7 +2509,7 @@ class FilterCore {
             }
         }
         catch (error) {
-            log$8.error("Failed to send subscribe request", error);
+            log$9.error("Failed to send subscribe request", error);
             return {
                 success: null,
                 failure: {
@@ -2520,7 +2520,7 @@ class FilterCore {
         }
         const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
         if (statusCode < 200 || statusCode >= 300) {
-            log$8.error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$9.error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             return {
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
@@ -2540,7 +2540,7 @@ class FilterCore {
             stream = await this.streamManager.getStream(peerId);
         }
         catch (error) {
-            log$8.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
+            log$9.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
             return {
                 success: null,
                 failure: {
@@ -2554,7 +2554,7 @@ class FilterCore {
             await pipe([unsubscribeRequest.encode()], encode, stream.sink);
         }
         catch (error) {
-            log$8.error("Failed to send unsubscribe request", error);
+            log$9.error("Failed to send unsubscribe request", error);
             return {
                 success: null,
                 failure: {
@@ -2583,7 +2583,7 @@ class FilterCore {
         }
         const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
         if (statusCode < 200 || statusCode >= 300) {
-            log$8.error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$9.error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             return {
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
@@ -2603,7 +2603,7 @@ class FilterCore {
             stream = await this.streamManager.getStream(peerId);
         }
         catch (error) {
-            log$8.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
+            log$9.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
             return {
                 success: null,
                 failure: {
@@ -2618,7 +2618,7 @@ class FilterCore {
             res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
         }
         catch (error) {
-            log$8.error("Failed to send ping request", error);
+            log$9.error("Failed to send ping request", error);
             return {
                 success: null,
                 failure: {
@@ -2638,7 +2638,7 @@ class FilterCore {
         }
         const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
         if (statusCode < 200 || statusCode >= 300) {
-            log$8.error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            log$9.error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             return {
                 success: null,
                 failure: {
@@ -2655,30 +2655,30 @@ class FilterCore {
     onRequest(streamData) {
         const { connection, stream } = streamData;
         const { remotePeer } = connection;
-        log$8.info(`Received message from ${remotePeer.toString()}`);
+        log$9.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$8.error("Received empty message");
+                        log$9.error("Received empty message");
                         return;
                     }
                     if (!pubsubTopic) {
-                        log$8.error("Pubsub topic missing from push message");
+                        log$9.error("Pubsub topic missing from push message");
                         return;
                     }
                     await this.handleIncomingMessage(pubsubTopic, wakuMessage, connection.remotePeer.toString());
                 }
             }).then(() => {
-                log$8.info("Receiving pipe closed.");
+                log$9.info("Receiving pipe closed.");
             }, async (e) => {
-                log$8.error(`Error with receiving pipe on peer:${connection.remotePeer.toString()} -- stream:${stream.id} -- protocol:${stream.protocol}: `, e);
+                log$9.error(`Error with receiving pipe on peer:${connection.remotePeer.toString()} -- stream:${stream.id} -- protocol:${stream.protocol}: `, e);
             });
         }
         catch (e) {
-            log$8.error("Error decoding message", e);
+            log$9.error("Error decoding message", e);
         }
     }
 }
@@ -2737,7 +2737,7 @@ const isRLNResponseError = (info) => {
         info.includes(RLN_REMOTE_VALIDATION));
 };
 
-const log$7 = new Logger("light-push");
+const log$8 = new Logger("light-push");
 const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
 /**
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
@@ -2751,16 +2751,16 @@ class LightPushCore {
     async preparePushMessage(encoder, message) {
         try {
             if (!message.payload || message.payload.length === 0) {
-                log$7.error("Failed to send waku light push: payload is empty");
+                log$8.error("Failed to send waku light push: payload is empty");
                 return { query: null, error: ProtocolError.EMPTY_PAYLOAD };
             }
             if (!(await isMessageSizeUnderCap(encoder, message))) {
-                log$7.error("Failed to send waku light push: message is bigger than 1MB");
+                log$8.error("Failed to send waku light push: message is bigger than 1MB");
                 return { query: null, error: ProtocolError.SIZE_TOO_BIG };
             }
             const protoMessage = await encoder.toProtoObj(message);
             if (!protoMessage) {
-                log$7.error("Failed to encode to protoMessage, aborting push");
+                log$8.error("Failed to encode to protoMessage, aborting push");
                 return {
                     query: null,
                     error: ProtocolError.ENCODE_FAILED
@@ -2770,7 +2770,7 @@ class LightPushCore {
             return { query, error: null };
         }
         catch (error) {
-            log$7.error("Failed to prepare push message", error);
+            log$8.error("Failed to prepare push message", error);
             return {
                 query: null,
                 error: ProtocolError.GENERIC_FAIL
@@ -2793,7 +2793,7 @@ class LightPushCore {
             stream = await this.streamManager.getStream(peerId);
         }
         catch (error) {
-            log$7.error("Failed to get stream", error);
+            log$8.error("Failed to get stream", error);
             return {
                 success: null,
                 failure: {
@@ -2808,7 +2808,7 @@ class LightPushCore {
         }
         catch (err) {
             // can fail only because of `stream` abortion
-            log$7.error("Failed to send waku light push request", err);
+            log$8.error("Failed to send waku light push request", err);
             return {
                 success: null,
                 failure: {
@@ -2826,7 +2826,7 @@ class LightPushCore {
             response = PushRpc.decode(bytes).response;
         }
         catch (err) {
-            log$7.error("Failed to decode push reply", err);
+            log$8.error("Failed to decode push reply", err);
             return {
                 success: null,
                 failure: {
@@ -2836,7 +2836,7 @@ class LightPushCore {
             };
         }
         if (!response) {
-            log$7.error("Remote peer fault: No response in PushRPC");
+            log$8.error("Remote peer fault: No response in PushRPC");
             return {
                 success: null,
                 failure: {
@@ -2846,7 +2846,7 @@ class LightPushCore {
             };
         }
         if (isRLNResponseError(response.info)) {
-            log$7.error("Remote peer fault: RLN generation");
+            log$8.error("Remote peer fault: RLN generation");
             return {
                 success: null,
                 failure: {
@@ -2856,7 +2856,7 @@ class LightPushCore {
             };
         }
         if (!response.isSuccess) {
-            log$7.error("Remote peer rejected the message: ", response.info);
+            log$8.error("Remote peer rejected the message: ", response.info);
             return {
                 success: null,
                 failure: {
@@ -2967,7 +2967,7 @@ class StoreQueryResponse {
     }
 }
 
-const log$6 = new Logger("store");
+const log$7 = new Logger("store");
 const StoreCodec = "/vac/waku/store-query/3.0.0";
 class StoreCore {
     streamManager;
@@ -2990,7 +2990,7 @@ class StoreCore {
                 ...queryOpts,
                 paginationCursor: currentCursor
             });
-            log$6.info("Sending store query request:", {
+            log$7.info("Sending store query request:", {
                 hasMessageHashes: !!queryOpts.messageHashes?.length,
                 messageHashCount: queryOpts.messageHashes?.length,
                 pubsubTopic: queryOpts.pubsubTopic,
@@ -3001,7 +3001,7 @@ class StoreCore {
                 stream = await this.streamManager.getStream(peerId);
             }
             catch (e) {
-                log$6.error("Failed to get stream", e);
+                log$7.error("Failed to get stream", e);
                 break;
             }
             const res = await pipe([storeQueryRequest.encode()], encode, stream, decode, async (source) => await all(source));
@@ -3013,14 +3013,14 @@ class StoreCore {
             if (!storeQueryResponse.statusCode ||
                 storeQueryResponse.statusCode >= 300) {
                 const errorMessage = `Store query failed with status code: ${storeQueryResponse.statusCode}, description: ${storeQueryResponse.statusDesc}`;
-                log$6.error(errorMessage);
+                log$7.error(errorMessage);
                 throw new Error(errorMessage);
             }
             if (!storeQueryResponse.messages || !storeQueryResponse.messages.length) {
-                log$6.warn("Stopping pagination due to empty messages in response");
+                log$7.warn("Stopping pagination due to empty messages in response");
                 break;
             }
-            log$6.info(`${storeQueryResponse.messages.length} messages retrieved from store`);
+            log$7.info(`${storeQueryResponse.messages.length} messages retrieved from store`);
             const decodedMessages = storeQueryResponse.messages.map((protoMsg) => {
                 if (!protoMsg.message) {
                     return Promise.resolve(undefined);
@@ -3058,7 +3058,7 @@ var index = /*#__PURE__*/Object.freeze({
     StoreCore: StoreCore
 });
 
-const log$5 = new Logger("connection-limiter");
+const log$6 = new Logger("connection-limiter");
 /**
  * This class is responsible for limiting the number of connections to peers.
  * It also dials all known peers because libp2p might have emitted `peer:discovery` before initialization
@@ -3066,16 +3066,24 @@ const log$5 = new Logger("connection-limiter");
  */
 class ConnectionLimiter {
     libp2p;
+    events;
+    networkMonitor;
+    dialer;
     options;
     constructor(options) {
         this.libp2p = options.libp2p;
+        this.events = options.events;
+        this.networkMonitor = options.networkMonitor;
+        this.dialer = options.dialer;
         this.options = options.options;
+        this.onWakuConnectionEvent = this.onWakuConnectionEvent.bind(this);
         this.onConnectedEvent = this.onConnectedEvent.bind(this);
         this.onDisconnectedEvent = this.onDisconnectedEvent.bind(this);
     }
     start() {
         // dial all known peers because libp2p might have emitted `peer:discovery` before initialization
         void this.dialPeersFromStore();
+        this.events.addEventListener("waku:connection", this.onWakuConnectionEvent);
         this.libp2p.addEventListener("peer:connect", this.onConnectedEvent);
         /**
          * NOTE: Event is not being emitted on closing nor losing a connection.
@@ -3091,37 +3099,50 @@ class ConnectionLimiter {
         this.libp2p.addEventListener("peer:disconnect", this.onDisconnectedEvent);
     }
     stop() {
+        this.events.removeEventListener("waku:connection", this.onWakuConnectionEvent);
         this.libp2p.removeEventListener("peer:connect", this.onConnectedEvent);
         this.libp2p.removeEventListener("peer:disconnect", this.onDisconnectedEvent);
     }
+    onWakuConnectionEvent() {
+        if (this.networkMonitor.isBrowserConnected()) {
+            void this.dialPeersFromStore();
+        }
+    }
     async onConnectedEvent(evt) {
-        log$5.info(`Connected to peer ${evt.detail.toString()}`);
+        log$6.info(`Connected to peer ${evt.detail.toString()}`);
         const peerId = evt.detail;
         const tags = await this.getTagsForPeer(peerId);
         const isBootstrap = tags.includes(Tags.BOOTSTRAP);
         if (!isBootstrap) {
+            log$6.info(`Connected to peer ${peerId.toString()} is not a bootstrap peer`);
             return;
         }
         if (await this.hasMoreThanMaxBootstrapConnections()) {
+            log$6.info(`Connected to peer ${peerId.toString()} and node has more than max bootstrap connections ${this.options.maxBootstrapPeers}. Dropping connection.`);
             await this.libp2p.hangUp(peerId);
         }
     }
     async onDisconnectedEvent() {
         if (this.libp2p.getConnections().length === 0) {
+            log$6.info(`No connections, dialing peers from store`);
             await this.dialPeersFromStore();
         }
     }
     async dialPeersFromStore() {
+        log$6.info(`Dialing peers from store`);
         const allPeers = await this.libp2p.peerStore.all();
         const allConnections = this.libp2p.getConnections();
+        log$6.info(`Found ${allPeers.length} peers in store, and found ${allConnections.length} connections`);
         const promises = allPeers
             .filter((p) => !allConnections.some((c) => c.remotePeer.equals(p.id)))
-            .map((p) => this.libp2p.dial(p.id));
+            .map((p) => this.dialer.dial(p.id));
         try {
+            log$6.info(`Dialing ${promises.length} peers from store`);
             await Promise.all(promises);
+            log$6.info(`Dialed ${promises.length} peers from store`);
         }
         catch (error) {
-            log$5.error(`Unexpected error while dialing peer store peers`, error);
+            log$6.error(`Unexpected error while dialing peer store peers`, error);
         }
     }
     async hasMoreThanMaxBootstrapConnections() {
@@ -3134,7 +3155,7 @@ class ConnectionLimiter {
             return bootstrapPeers.length > this.options.maxBootstrapPeers;
         }
         catch (error) {
-            log$5.error(`Unexpected error while checking for bootstrap connections`, error);
+            log$6.error(`Unexpected error while checking for bootstrap connections`, error);
             return false;
         }
     }
@@ -3143,7 +3164,7 @@ class ConnectionLimiter {
             return await this.libp2p.peerStore.get(peerId);
         }
         catch (error) {
-            log$5.error(`Failed to get peer ${peerId}, error: ${error}`);
+            log$6.error(`Failed to get peer ${peerId}, error: ${error}`);
             return null;
         }
     }
@@ -3153,103 +3174,148 @@ class ConnectionLimiter {
             return Array.from(peer.tags.keys());
         }
         catch (error) {
-            log$5.error(`Failed to get peer ${peerId}, error: ${error}`);
+            log$6.error(`Failed to get peer ${peerId}, error: ${error}`);
             return [];
         }
     }
 }
 
-const log$4 = new Logger("discovery-dialer");
-/**
- * This class is responsible for dialing peers that are discovered by the libp2p node.
- * Managing limits for the peers is out of scope for this class.
- * Dialing after discovery is needed to identify the peer and get all other information: metadata, protocols, etc.
- */
-class DiscoveryDialer {
+const log$5 = new Logger("dialer");
+class Dialer {
     libp2p;
     shardReader;
-    dialingInterval = null;
     dialingQueue = [];
-    dialHistory = new Set();
+    dialHistory = new Map();
+    dialingInterval = null;
+    isProcessing = false;
     constructor(options) {
         this.libp2p = options.libp2p;
         this.shardReader = options.shardReader;
-        this.onPeerDiscovery = this.onPeerDiscovery.bind(this);
     }
     start() {
-        log$4.info("Starting discovery dialer");
-        this.libp2p.addEventListener("peer:discovery", this.onPeerDiscovery);
         if (!this.dialingInterval) {
             this.dialingInterval = setInterval(() => {
                 void this.processQueue();
             }, 500);
-            log$4.info("Started dialing interval processor");
         }
         this.dialHistory.clear();
     }
     stop() {
-        log$4.info("Stopping discovery dialer");
-        this.libp2p.removeEventListener("peer:discovery", this.onPeerDiscovery);
         if (this.dialingInterval) {
             clearInterval(this.dialingInterval);
             this.dialingInterval = null;
-            log$4.info("Stopped dialing interval processor");
         }
         this.dialHistory.clear();
     }
-    async onPeerDiscovery(event) {
-        const peerId = event.detail.id;
-        log$4.info(`Discovered new peer: ${peerId}`);
-        try {
-            const shouldSkip = await this.shouldSkipPeer(peerId);
-            if (shouldSkip) {
-                log$4.info(`Skipping peer: ${peerId}`);
-                return;
-            }
-            await this.updatePeerStore(peerId, event.detail.multiaddrs);
-            if (this.dialingQueue.length === 0) {
-                await this.dialPeer(peerId);
-            }
-            else {
-                this.dialingQueue.push(peerId);
-                log$4.info(`Added peer to dialing queue, queue size: ${this.dialingQueue.length}`);
-            }
+    async dial(peerId) {
+        const shouldSkip = await this.shouldSkipPeer(peerId);
+        if (shouldSkip) {
+            log$5.info(`Skipping peer: ${peerId}`);
+            return;
         }
-        catch (error) {
-            log$4.error(`Error dialing peer ${peerId}`, error);
+        // If queue is empty and we're not currently processing, dial immediately
+        if (this.dialingQueue.length === 0 && !this.isProcessing) {
+            await this.dialPeer(peerId);
+        }
+        else {
+            // Add to queue
+            this.dialingQueue.push(peerId);
+            log$5.info(`Added peer to dialing queue, queue size: ${this.dialingQueue.length}`);
         }
     }
     async processQueue() {
-        if (this.dialingQueue.length === 0)
+        if (this.dialingQueue.length === 0 || this.isProcessing)
             return;
-        const peersToDial = this.dialingQueue.slice(0, 3);
-        this.dialingQueue = this.dialingQueue.slice(peersToDial.length);
-        log$4.info(`Processing dial queue: dialing ${peersToDial.length} peers, ${this.dialingQueue.length} remaining in queue`);
-        await Promise.all(peersToDial.map(this.dialPeer));
+        this.isProcessing = true;
+        try {
+            const peersToDial = this.dialingQueue.slice(0, 3);
+            this.dialingQueue = this.dialingQueue.slice(peersToDial.length);
+            log$5.info(`Processing dial queue: dialing ${peersToDial.length} peers, ${this.dialingQueue.length} remaining in queue`);
+            await Promise.all(peersToDial.map((peerId) => this.dialPeer(peerId)));
+        }
+        finally {
+            this.isProcessing = false;
+        }
+    }
+    async dialPeer(peerId) {
+        try {
+            log$5.info(`Dialing peer from queue: ${peerId}`);
+            await this.libp2p.dial(peerId);
+            this.dialHistory.set(peerId.toString(), Date.now());
+            log$5.info(`Successfully dialed peer from queue: ${peerId}`);
+        }
+        catch (error) {
+            log$5.error(`Error dialing peer ${peerId}`, error);
+        }
     }
     async shouldSkipPeer(peerId) {
-        if (this.dialHistory.has(peerId.toString())) {
+        const hasConnection = this.libp2p.getPeers().some((p) => p.equals(peerId));
+        if (hasConnection) {
+            log$5.info(`Skipping peer ${peerId} - already connected`);
+            return true;
+        }
+        const lastDialed = this.dialHistory.get(peerId.toString());
+        if (lastDialed && Date.now() - lastDialed < 10_000) {
+            log$5.info(`Skipping peer ${peerId} - already dialed in the last 10 seconds`);
             return true;
         }
-        const hasShardInfo = await this.shardReader.hasShardInfo(peerId);
-        if (!hasShardInfo) {
+        try {
+            const hasShardInfo = await this.shardReader.hasShardInfo(peerId);
+            if (!hasShardInfo) {
+                log$5.info(`Skipping peer ${peerId} - no shard info`);
+                return false;
+            }
+            const isOnSameShard = await this.shardReader.isPeerOnNetwork(peerId);
+            if (!isOnSameShard) {
+                log$5.info(`Skipping peer ${peerId} - not on same shard`);
+                return true;
+            }
             return false;
         }
-        const isOnSameShard = await this.shardReader.isPeerOnNetwork(peerId);
-        if (!isOnSameShard) {
-            log$4.info(`Skipping peer ${peerId} - not on same shard`);
-            return true;
+        catch (error) {
+            log$5.error(`Error checking shard info for peer ${peerId}`, error);
+            return true; // Skip peer when there's an error
         }
-        const hasConnection = this.libp2p.getPeers().some((p) => p.equals(peerId));
-        if (hasConnection) {
-            return true;
+    }
+}
+
+const log$4 = new Logger("discovery-dialer");
+/**
+ * This class is responsible for dialing peers that are discovered by the libp2p node.
+ * Managing limits for the peers is out of scope for this class.
+ * Dialing after discovery is needed to identify the peer and get all other information: metadata, protocols, etc.
+ */
+class DiscoveryDialer {
+    libp2p;
+    dialer;
+    constructor(options) {
+        this.libp2p = options.libp2p;
+        this.dialer = options.dialer;
+        this.onPeerDiscovery = this.onPeerDiscovery.bind(this);
+    }
+    start() {
+        this.libp2p.addEventListener("peer:discovery", this.onPeerDiscovery);
+    }
+    stop() {
+        this.libp2p.removeEventListener("peer:discovery", this.onPeerDiscovery);
+    }
+    async onPeerDiscovery(event) {
+        const peerId = event.detail.id;
+        log$4.info(`Discovered new peer: ${peerId}`);
+        try {
+            await this.updatePeerStore(peerId, event.detail.multiaddrs);
+            await this.dialer.dial(peerId);
+        }
+        catch (error) {
+            log$4.error(`Error dialing peer ${peerId}`, error);
         }
-        return false;
     }
     async updatePeerStore(peerId, multiaddrs) {
         try {
+            log$4.info(`Updating peer store for ${peerId}`);
             const peer = await this.getPeer(peerId);
             if (!peer) {
+                log$4.info(`Peer ${peerId} not found in store, saving`);
                 await this.libp2p.peerStore.save(peerId, {
                     multiaddrs: multiaddrs
                 });
@@ -3257,8 +3323,10 @@ class DiscoveryDialer {
             }
             const hasSameAddr = multiaddrs.every((addr) => peer.addresses.some((a) => a.multiaddr.equals(addr)));
             if (hasSameAddr) {
+                log$4.info(`Peer ${peerId} has same addresses in peer store, skipping`);
                 return;
             }
+            log$4.info(`Merging peer ${peerId} addresses in peer store`);
             await this.libp2p.peerStore.merge(peerId, {
                 multiaddrs: multiaddrs
             });
@@ -3267,17 +3335,6 @@ class DiscoveryDialer {
             log$4.error(`Error updating peer store for ${peerId}`, error);
         }
     }
-    async dialPeer(peerId) {
-        try {
-            log$4.info(`Dialing peer from queue: ${peerId}`);
-            await this.libp2p.dial(peerId);
-            this.dialHistory.add(peerId.toString());
-            log$4.info(`Successfully dialed peer from queue: ${peerId}`);
-        }
-        catch (error) {
-            log$4.error(`Error dialing peer ${peerId}`, error);
-        }
-    }
     async getPeer(peerId) {
         try {
             return await this.libp2p.peerStore.get(peerId);
@@ -3467,7 +3524,25 @@ class NetworkMonitor {
             // ignore
         }
     }
+    /**
+     * Returns true if the node is connected to the network via libp2p and browser.
+     */
     isConnected() {
+        if (!this.isBrowserConnected()) {
+            return false;
+        }
+        return this.isP2PConnected();
+    }
+    /**
+     * Returns true if the node is connected to the network via libp2p.
+     */
+    isP2PConnected() {
+        return this.isNetworkConnected;
+    }
+    /**
+     * Returns true if the node is connected to the network via browser.
+     */
+    isBrowserConnected() {
         try {
             if (globalThis?.navigator && !globalThis?.navigator?.onLine) {
                 return false;
@@ -3476,7 +3551,7 @@ class NetworkMonitor {
         catch (err) {
             // ignore
         }
-        return this.isNetworkConnected;
+        return true;
     }
     onConnectedEvent() {
         if (!this.isNetworkConnected) {
@@ -8849,6 +8924,7 @@ class ConnectionManager {
     pubsubTopics;
     keepAliveManager;
     discoveryDialer;
+    dialer;
     shardReader;
     networkMonitor;
     connectionLimiter;
@@ -8875,16 +8951,23 @@ class ConnectionManager {
             libp2p: options.libp2p,
             networkConfig: options.networkConfig
         });
-        this.discoveryDialer = new DiscoveryDialer({
+        this.dialer = new Dialer({
             libp2p: options.libp2p,
             shardReader: this.shardReader
         });
+        this.discoveryDialer = new DiscoveryDialer({
+            libp2p: options.libp2p,
+            dialer: this.dialer
+        });
         this.networkMonitor = new NetworkMonitor({
             libp2p: options.libp2p,
             events: options.events
         });
         this.connectionLimiter = new ConnectionLimiter({
             libp2p: options.libp2p,
+            events: options.events,
+            networkMonitor: this.networkMonitor,
+            dialer: this.dialer,
             options: this.options
         });
     }
@@ -8905,11 +8988,16 @@ class ConnectionManager {
     }
     async dial(peer, protocolCodecs) {
         const ma = mapToPeerIdOrMultiaddr(peer);
-        return this.libp2p.dialProtocol(ma, protocolCodecs);
+        log$1.info(`Dialing peer ${ma.toString()} with protocols ${protocolCodecs}`);
+        // must use libp2p directly instead of dialer because we need to dial the peer right away
+        const stream = await this.libp2p.dialProtocol(ma, protocolCodecs);
+        log$1.info(`Dialed peer ${ma.toString()} with protocols ${protocolCodecs}`);
+        return stream;
     }
     async hangUp(peer) {
         const peerId = mapToPeerId(peer);
         try {
+            log$1.info(`Dropping connection with peer ${peerId.toString()}`);
             await this.libp2p.hangUp(peerId);
             log$1.info(`Dropped connection with peer ${peerId.toString()}`);
             return true;
@@ -8921,7 +9009,9 @@ class ConnectionManager {
     }
     async getConnectedPeers(codec) {
         const peerIDs = this.libp2p.getPeers();
+        log$1.info(`Getting connected peers for codec ${codec}`);
         if (peerIDs.length === 0) {
+            log$1.info(`No connected peers`);
             return [];
         }
         const peers = await Promise.all(peerIDs.map(async (id) => {
@@ -8932,10 +9022,12 @@ class ConnectionManager {
                 return null;
             }
         }));
-        return peers
+        const result = peers
             .filter((p) => !!p)
             .filter((p) => (codec ? p.protocols.includes(codec) : true))
             .sort((left, right) => getPeerPing(left) - getPeerPing(right));
+        log$1.info(`Found ${result.length} connected peers for codec ${codec}`);
+        return result;
     }
     isTopicConfigured(pubsubTopic) {
         return this.pubsubTopics.includes(pubsubTopic);