@waku/core 0.0.37-987c6cd.0 → 0.0.37-c24842a.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-BpF0pNhc.js';
-export { a2 as createDecoder } from './version_0-BpF0pNhc.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, C as CONNECTION_LOCKED_TAG, 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, D as sha512, E as enumeration, G as message, H as encodeMessage, I as decodeMessage, J as Hash, K as ahash, N as toBytes, O as clean, Q as aexists, R as sha256$1, U as bases, V as base64url, W as encodeUint8Array, X as bytesToUtf8, Y as WakuMetadataRequest, Z as WakuMetadataResponse, _ as concat$1, $ as sha256$2, a0 as bytesToHex$1, a1 as numberToBytes } from './version_0-BHaZD8Qu.js';
+export { a2 as createDecoder } from './version_0-BHaZD8Qu.js';
 
 /* eslint-disable */
 var encode_1 = encode$2;
@@ -3059,6 +3059,7 @@ var index = /*#__PURE__*/Object.freeze({
 });
 
 const log$6 = new Logger("connection-limiter");
+const DEFAULT_CONNECTION_MONITOR_INTERVAL = 5 * 1_000;
 /**
  * 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
@@ -3069,6 +3070,7 @@ class ConnectionLimiter {
     events;
     networkMonitor;
     dialer;
+    connectionMonitorInterval = null;
     options;
     constructor(options) {
         this.libp2p = options.libp2p;
@@ -3077,14 +3079,16 @@ class ConnectionLimiter {
         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();
+        if (this.options.enableAutoRecovery &&
+            this.connectionMonitorInterval === null) {
+            this.connectionMonitorInterval = setInterval(() => void this.maintainConnections(), DEFAULT_CONNECTION_MONITOR_INTERVAL);
+        }
         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.
          * @see https://github.com/libp2p/js-libp2p/issues/939
@@ -3100,27 +3104,24 @@ class ConnectionLimiter {
     }
     stop() {
         this.events.removeEventListener("waku:connection", this.onWakuConnectionEvent);
-        this.libp2p.removeEventListener("peer:connect", this.onConnectedEvent);
         this.libp2p.removeEventListener("peer:disconnect", this.onDisconnectedEvent);
+        if (this.connectionMonitorInterval) {
+            clearInterval(this.connectionMonitorInterval);
+            this.connectionMonitorInterval = null;
+        }
     }
     onWakuConnectionEvent() {
+        if (!this.options.enableAutoRecovery) {
+            log$6.info(`Auto recovery is disabled, skipping`);
+            return;
+        }
         if (this.networkMonitor.isBrowserConnected()) {
             void this.dialPeersFromStore();
         }
     }
-    async onConnectedEvent(evt) {
-        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 maintainConnections() {
+        await this.maintainConnectionsCount();
+        await this.maintainBootstrapConnections();
     }
     async onDisconnectedEvent() {
         if (this.libp2p.getConnections().length === 0) {
@@ -3128,54 +3129,106 @@ class ConnectionLimiter {
             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.dialer.dial(p.id));
+    async maintainConnectionsCount() {
+        log$6.info(`Maintaining connections count`);
+        const connections = this.libp2p.getConnections();
+        if (connections.length <= this.options.maxConnections) {
+            log$6.info(`Node has less than max connections ${this.options.maxConnections}, trying to dial more peers`);
+            const peers = await this.getPrioritizedPeers();
+            if (peers.length === 0) {
+                log$6.info(`No peers to dial, node is utilizing all known peers`);
+                return;
+            }
+            const promises = peers
+                .slice(0, this.options.maxConnections - connections.length)
+                .map((p) => this.dialer.dial(p.id));
+            await Promise.all(promises);
+            return;
+        }
+        log$6.info(`Node has more than max connections ${this.options.maxConnections}, dropping connections`);
         try {
-            log$6.info(`Dialing ${promises.length} peers from store`);
+            const connectionsToDrop = connections
+                .filter((c) => !c.tags.includes(CONNECTION_LOCKED_TAG))
+                .slice(this.options.maxConnections);
+            if (connectionsToDrop.length === 0) {
+                log$6.info(`No connections to drop, skipping`);
+                return;
+            }
+            const promises = connectionsToDrop.map((c) => this.libp2p.hangUp(c.remotePeer));
             await Promise.all(promises);
-            log$6.info(`Dialed ${promises.length} peers from store`);
+            log$6.info(`Dropped ${connectionsToDrop.length} connections`);
         }
         catch (error) {
-            log$6.error(`Unexpected error while dialing peer store peers`, error);
+            log$6.error(`Unexpected error while maintaining connections`, error);
         }
     }
-    async hasMoreThanMaxBootstrapConnections() {
+    async maintainBootstrapConnections() {
+        log$6.info(`Maintaining bootstrap connections`);
+        const bootstrapPeers = await this.getBootstrapPeers();
+        if (bootstrapPeers.length <= this.options.maxBootstrapPeers) {
+            return;
+        }
         try {
-            const peers = await Promise.all(this.libp2p
-                .getConnections()
-                .map((conn) => conn.remotePeer)
-                .map((id) => this.getPeer(id)));
-            const bootstrapPeers = peers.filter((peer) => peer && peer.tags.has(Tags.BOOTSTRAP));
-            return bootstrapPeers.length > this.options.maxBootstrapPeers;
+            const peersToDrop = bootstrapPeers.slice(this.options.maxBootstrapPeers);
+            log$6.info(`Dropping ${peersToDrop.length} bootstrap connections because node has more than max bootstrap connections ${this.options.maxBootstrapPeers}`);
+            const promises = peersToDrop.map((p) => this.libp2p.hangUp(p.id));
+            await Promise.all(promises);
+            log$6.info(`Dropped ${peersToDrop.length} bootstrap connections`);
         }
         catch (error) {
-            log$6.error(`Unexpected error while checking for bootstrap connections`, error);
-            return false;
+            log$6.error(`Unexpected error while maintaining bootstrap connections`, error);
         }
     }
-    async getPeer(peerId) {
+    async dialPeersFromStore() {
+        log$6.info(`Dialing peers from store`);
         try {
-            return await this.libp2p.peerStore.get(peerId);
+            const peers = await this.getPrioritizedPeers();
+            if (peers.length === 0) {
+                log$6.info(`No peers to dial, skipping`);
+                return;
+            }
+            const promises = peers.map((p) => this.dialer.dial(p.id));
+            log$6.info(`Dialing ${peers.length} peers from store`);
+            await Promise.all(promises);
+            log$6.info(`Dialed ${promises.length} peers from store`);
         }
         catch (error) {
-            log$6.error(`Failed to get peer ${peerId}, error: ${error}`);
-            return null;
+            log$6.error(`Unexpected error while dialing peer store peers`, error);
         }
     }
-    async getTagsForPeer(peerId) {
+    /**
+     * Returns a list of peers ordered by priority:
+     * - bootstrap peers
+     * - peers from peer exchange
+     * - peers from local store (last because we are not sure that locally stored information is up to date)
+     */
+    async getPrioritizedPeers() {
+        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 notConnectedPeers = allPeers.filter((p) => !allConnections.some((c) => c.remotePeer.equals(p.id)) &&
+            p.addresses.some((a) => a.multiaddr.toString().includes("wss") ||
+                a.multiaddr.toString().includes("ws")));
+        const bootstrapPeers = notConnectedPeers.filter((p) => p.tags.has(Tags.BOOTSTRAP));
+        const peerExchangePeers = notConnectedPeers.filter((p) => p.tags.has(Tags.PEER_EXCHANGE));
+        const localStorePeers = notConnectedPeers.filter((p) => p.tags.has(Tags.LOCAL));
+        return [...bootstrapPeers, ...peerExchangePeers, ...localStorePeers];
+    }
+    async getBootstrapPeers() {
+        const peers = await Promise.all(this.libp2p
+            .getConnections()
+            .map((conn) => conn.remotePeer)
+            .map((id) => this.getPeer(id)));
+        const bootstrapPeers = peers.filter((peer) => peer && peer.tags.has(Tags.BOOTSTRAP));
+        return bootstrapPeers;
+    }
+    async getPeer(peerId) {
         try {
-            const peer = await this.libp2p.peerStore.get(peerId);
-            return Array.from(peer.tags.keys());
+            return await this.libp2p.peerStore.get(peerId);
         }
         catch (error) {
             log$6.error(`Failed to get peer ${peerId}, error: ${error}`);
-            return [];
+            return null;
         }
     }
 }
@@ -3184,28 +3237,36 @@ const log$5 = new Logger("dialer");
 class Dialer {
     libp2p;
     shardReader;
+    options;
     dialingQueue = [];
     dialHistory = new Map();
+    failedDials = new Map();
     dialingInterval = null;
     isProcessing = false;
+    isImmediateDialing = false;
     constructor(options) {
         this.libp2p = options.libp2p;
         this.shardReader = options.shardReader;
+        this.options = options.options;
     }
     start() {
+        log$5.info("Starting dialer");
         if (!this.dialingInterval) {
             this.dialingInterval = setInterval(() => {
                 void this.processQueue();
             }, 500);
         }
         this.dialHistory.clear();
+        this.failedDials.clear();
     }
     stop() {
+        log$5.info("Stopping dialer");
         if (this.dialingInterval) {
             clearInterval(this.dialingInterval);
             this.dialingInterval = null;
         }
         this.dialHistory.clear();
+        this.failedDials.clear();
     }
     async dial(peerId) {
         const shouldSkip = await this.shouldSkipPeer(peerId);
@@ -3213,22 +3274,28 @@ class Dialer {
             log$5.info(`Skipping peer: ${peerId}`);
             return;
         }
+        const isEmptyQueue = this.dialingQueue.length === 0;
+        const isNotDialing = !this.isProcessing && !this.isImmediateDialing;
         // If queue is empty and we're not currently processing, dial immediately
-        if (this.dialingQueue.length === 0 && !this.isProcessing) {
+        if (isEmptyQueue && isNotDialing) {
+            this.isImmediateDialing = true;
+            log$5.info("Dialed peer immediately");
             await this.dialPeer(peerId);
+            this.isImmediateDialing = false;
+            log$5.info("Released immediate dial lock");
         }
         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 || this.isProcessing)
+        if (this.dialingQueue.length === 0 || this.isProcessing) {
             return;
+        }
         this.isProcessing = true;
         try {
-            const peersToDial = this.dialingQueue.slice(0, 3);
+            const peersToDial = this.dialingQueue.slice(0, this.options.maxDialingPeers);
             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)));
@@ -3242,10 +3309,12 @@ class Dialer {
             log$5.info(`Dialing peer from queue: ${peerId}`);
             await this.libp2p.dial(peerId);
             this.dialHistory.set(peerId.toString(), Date.now());
+            this.failedDials.delete(peerId.toString());
             log$5.info(`Successfully dialed peer from queue: ${peerId}`);
         }
         catch (error) {
             log$5.error(`Error dialing peer ${peerId}`, error);
+            this.failedDials.set(peerId.toString(), Date.now());
         }
     }
     async shouldSkipPeer(peerId) {
@@ -3254,11 +3323,14 @@ class Dialer {
             log$5.info(`Skipping peer ${peerId} - already connected`);
             return true;
         }
-        const lastDialed = this.dialHistory.get(peerId.toString());
-        if (lastDialed && Date.now() - lastDialed < 10_000) {
+        if (this.isRecentlyDialed(peerId)) {
             log$5.info(`Skipping peer ${peerId} - already dialed in the last 10 seconds`);
             return true;
         }
+        if (this.isRecentlyFailed(peerId)) {
+            log$5.info(`Skipping peer ${peerId} - recently failed to dial`);
+            return true;
+        }
         try {
             const hasShardInfo = await this.shardReader.hasShardInfo(peerId);
             if (!hasShardInfo) {
@@ -3277,6 +3349,22 @@ class Dialer {
             return true; // Skip peer when there's an error
         }
     }
+    isRecentlyDialed(peerId) {
+        const lastDialed = this.dialHistory.get(peerId.toString());
+        if (lastDialed &&
+            Date.now() - lastDialed < this.options.dialCooldown * 1000) {
+            return true;
+        }
+        return false;
+    }
+    isRecentlyFailed(peerId) {
+        const lastFailed = this.failedDials.get(peerId.toString());
+        if (lastFailed &&
+            Date.now() - lastFailed < this.options.failedDialCooldown * 1000) {
+            return true;
+        }
+        return false;
+    }
 }
 
 const log$4 = new Logger("discovery-dialer");
@@ -8917,11 +9005,15 @@ const mapToPeerId = (input) => {
 };
 
 const log$1 = new Logger("connection-manager");
-const DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED = 1;
+const DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED = 3;
 const DEFAULT_PING_KEEP_ALIVE_SEC = 5 * 60;
 const DEFAULT_RELAY_KEEP_ALIVE_SEC = 5 * 60;
+const DEFAULT_ENABLE_AUTO_RECOVERY = true;
+const DEFAULT_MAX_CONNECTIONS = 10;
+const DEFAULT_MAX_DIALING_PEERS = 3;
+const DEFAULT_FAILED_DIAL_COOLDOWN_SEC = 60;
+const DEFAULT_DIAL_COOLDOWN_SEC = 10;
 class ConnectionManager {
-    pubsubTopics;
     keepAliveManager;
     discoveryDialer;
     dialer;
@@ -8932,11 +9024,15 @@ class ConnectionManager {
     libp2p;
     constructor(options) {
         this.libp2p = options.libp2p;
-        this.pubsubTopics = options.pubsubTopics;
         this.options = {
             maxBootstrapPeers: DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED,
+            maxConnections: DEFAULT_MAX_CONNECTIONS,
             pingKeepAlive: DEFAULT_PING_KEEP_ALIVE_SEC,
             relayKeepAlive: DEFAULT_RELAY_KEEP_ALIVE_SEC,
+            enableAutoRecovery: DEFAULT_ENABLE_AUTO_RECOVERY,
+            maxDialingPeers: DEFAULT_MAX_DIALING_PEERS,
+            failedDialCooldown: DEFAULT_FAILED_DIAL_COOLDOWN_SEC,
+            dialCooldown: DEFAULT_DIAL_COOLDOWN_SEC,
             ...options.config
         };
         this.keepAliveManager = new KeepAliveManager({
@@ -8953,7 +9049,8 @@ class ConnectionManager {
         });
         this.dialer = new Dialer({
             libp2p: options.libp2p,
-            shardReader: this.shardReader
+            shardReader: this.shardReader,
+            options: this.options
         });
         this.discoveryDialer = new DiscoveryDialer({
             libp2p: options.libp2p,
@@ -8972,12 +9069,14 @@ class ConnectionManager {
         });
     }
     start() {
+        this.dialer.start();
         this.networkMonitor.start();
         this.discoveryDialer.start();
         this.keepAliveManager.start();
         this.connectionLimiter.start();
     }
     stop() {
+        this.dialer.stop();
         this.networkMonitor.stop();
         this.discoveryDialer.stop();
         this.keepAliveManager.stop();
@@ -9029,9 +9128,6 @@ class ConnectionManager {
         log$1.info(`Found ${result.length} connected peers for codec ${codec}`);
         return result;
     }
-    isTopicConfigured(pubsubTopic) {
-        return this.pubsubTopics.includes(pubsubTopic);
-    }
     async hasShardInfo(peerId) {
         return this.shardReader.hasShardInfo(peerId);
     }
@@ -9043,13 +9139,13 @@ class ConnectionManager {
 const log = new Logger("metadata");
 const MetadataCodec = "/vac/waku/metadata/1.0.0";
 class Metadata {
-    pubsubTopics;
+    clusterId;
     streamManager;
     libp2pComponents;
     handshakesConfirmed = new Map();
     multicodec = MetadataCodec;
-    constructor(pubsubTopics, libp2p) {
-        this.pubsubTopics = pubsubTopics;
+    constructor(clusterId, libp2p) {
+        this.clusterId = clusterId;
         this.streamManager = new StreamManager(MetadataCodec, libp2p);
         this.libp2pComponents = libp2p;
         void libp2p.registrar.handle(MetadataCodec, (streamData) => {
@@ -9060,7 +9156,10 @@ class Metadata {
      * Make a metadata query to a peer
      */
     async query(peerId) {
-        const request = WakuMetadataRequest.encode(pubsubTopicsToShardInfo(this.pubsubTopics));
+        const request = WakuMetadataRequest.encode({
+            clusterId: this.clusterId,
+            shards: [] // Only services node need to provide shards
+        });
         const peer = await this.libp2pComponents.peerStore.get(peerId);
         if (!peer) {
             return {
@@ -9109,7 +9208,10 @@ class Metadata {
     async onRequest(streamData) {
         try {
             const { stream, connection } = streamData;
-            const encodedShardInfo = WakuMetadataResponse.encode(pubsubTopicsToShardInfo(this.pubsubTopics));
+            const encodedShardInfo = WakuMetadataResponse.encode({
+                clusterId: this.clusterId,
+                shards: [] // Only service nodes need to provide shards
+            });
             const encodedResponse = await pipe([encodedShardInfo], encode, stream, decode, async (source) => await all(source));
             const { error, shardInfo } = this.decodeMetadataResponse(encodedResponse);
             if (error) {
@@ -9149,8 +9251,8 @@ class Metadata {
         this.handshakesConfirmed.set(peerId.toString(), shardInfo);
     }
 }
-function wakuMetadata(pubsubTopics) {
-    return (components) => new Metadata(pubsubTopics, components);
+function wakuMetadata(clusterId) {
+    return (components) => new Metadata(clusterId, components);
 }
 
 /**

package/bundle/lib/message/version_0.js

@@ -1 +1 @@
-export { a5 as DecodedMessage, a7 as Decoder, a6 as Encoder, a3 as Version, a2 as createDecoder, o as createEncoder, a4 as proto } from '../../version_0-BpF0pNhc.js';
+export { a5 as DecodedMessage, a7 as Decoder, a6 as Encoder, a3 as Version, a2 as createDecoder, o as createEncoder, a4 as proto } from '../../version_0-BHaZD8Qu.js';