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

package/bundle/{base_protocol-C6HnrRx8.js → base_protocol-BM6GbS_d.js}

@@ -118,24 +118,6 @@ async function getConnectedPeersForProtocolAndShard(connections, peerStore, prot
     const peersWithNulls = await Promise.all(peerPromises);
     return peersWithNulls.filter((peer) => peer !== null);
 }
-function selectConnection(connections) {
-    if (!connections.length)
-        return;
-    if (connections.length === 1)
-        return connections[0];
-    let latestConnection;
-    connections.forEach((connection) => {
-        if (connection.status === "open") {
-            if (!latestConnection) {
-                latestConnection = connection;
-            }
-            else if (connection.timeline.open > latestConnection.timeline.open) {
-                latestConnection = connection;
-            }
-        }
-    });
-    return latestConnection;
-}
 
 /**
  * Retrieves a list of peers based on the specified criteria:
@@ -174,6 +156,25 @@ function filterPeersByDiscovery(peers, numPeers, maxBootstrapPeers) {
     return selectedPeers;
 }
 
+function selectConnection(connections) {
+    if (!connections.length)
+        return;
+    if (connections.length === 1)
+        return connections[0];
+    let latestConnection;
+    connections.forEach((connection) => {
+        if (connection.status === "open") {
+            if (!latestConnection) {
+                latestConnection = connection;
+            }
+            else if (connection.timeline.open > latestConnection.timeline.open) {
+                latestConnection = connection;
+            }
+        }
+    });
+    return latestConnection;
+}
+
 const CONNECTION_TIMEOUT = 5_000;
 const RETRY_BACKOFF_BASE = 1_000;
 const MAX_RETRIES = 3;

package/bundle/index.js

@@ -1,8 +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-DQ9xsSLk.js';
-export { j as createDecoder } from './version_0-DQ9xsSLk.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-C6HnrRx8.js';
-export { S as StreamManager } from './base_protocol-C6HnrRx8.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;
@@ -1622,35 +1622,6 @@ class FilterCore extends BaseProtocol {
             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);
@@ -1802,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({
@@ -2594,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;
@@ -2619,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) {
@@ -2629,7 +2629,7 @@ class KeepAliveManager {
                             return;
                         }
                         try {
-                            await peerStore.merge(peerId, {
+                            await this.libp2p.peerStore.merge(peerId, {
                                 metadata: {
                                     ping: utf8ToBytes(ping.toString())
                                 }
@@ -2818,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));
@@ -2865,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) {
@@ -2953,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) => {
@@ -2974,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
@@ -3014,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;
         }
@@ -3047,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);
@@ -3114,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
      */
@@ -3179,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,2 +1,2 @@
 import '../index-DnW8ifxc.js';
-export { B as BaseProtocol } from '../base_protocol-C6HnrRx8.js';
+export { B as BaseProtocol } from '../base_protocol-BM6GbS_d.js';

package/bundle/lib/message/version_0.js

@@ -1,2 +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-DQ9xsSLk.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-DQ9xsSLk.js → version_0-WhJLc79v.js}

@@ -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 };