@waku/discovery 0.0.10 → 0.0.11-158e115.0

package/bundle/index.js

@@ -286,6 +286,12 @@ var ProtocolError;
     ProtocolError["INVALID_DECODER_TOPICS"] = "Invalid decoder topics";
 })(ProtocolError || (ProtocolError = {}));
 
+var WakuEventType;
+(function (WakuEventType) {
+    WakuEventType["Connection"] = "waku:connection";
+    WakuEventType["Health"] = "waku:health";
+})(WakuEventType || (WakuEventType = {}));
+
 // Peer tags
 var Tags;
 (function (Tags) {
@@ -316,6 +322,25 @@ function isDefined(value) {
     return Boolean(value);
 }
 
+/**
+ * Return pseudo random subset of the input.
+ */
+function shuffle(arr) {
+    if (arr.length <= 1) {
+        return arr;
+    }
+    const randInt = () => {
+        return Math.floor(Math.random() * Math.floor(arr.length));
+    };
+    for (let i = 0; i < arr.length; i++) {
+        const j = randInt();
+        const tmp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = tmp;
+    }
+    return arr;
+}
+
 const crypto$2 = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
 
 /**
@@ -3151,11 +3176,6 @@ const enrTree = {
 const DEFAULT_BOOTSTRAP_TAG_NAME = Tags.BOOTSTRAP;
 const DEFAULT_BOOTSTRAP_TAG_VALUE = 50;
 const DEFAULT_BOOTSTRAP_TAG_TTL = 100_000_000;
-const DEFAULT_NODE_REQUIREMENTS = {
-    store: 1,
-    filter: 2,
-    lightPush: 2
-};
 
 // Maximum encoded size of an ENR
 const ERR_INVALID_ID = "Invalid record id";
@@ -15099,188 +15119,63 @@ class ENRTree {
 
 const log$5 = new Logger$1("discovery:fetch_nodes");
 /**
- * Fetch nodes using passed [[getNode]] until all wanted capabilities are
- * fulfilled or the number of [[getNode]] call exceeds the sum of
- * [[wantedNodeCapabilityCount]] plus [[errorTolerance]].
+ * Fetch nodes using passed [[getNode]] until it has been called [[maxGet]]
+ * times, or it has returned empty or duplicate results more than [[maxErrors]]
+ * times.
  */
-async function fetchNodesUntilCapabilitiesFulfilled(wantedNodeCapabilityCount, errorTolerance, getNode) {
-    const wanted = {
-        relay: wantedNodeCapabilityCount.relay ?? 0,
-        store: wantedNodeCapabilityCount.store ?? 0,
-        filter: wantedNodeCapabilityCount.filter ?? 0,
-        lightPush: wantedNodeCapabilityCount.lightPush ?? 0
-    };
-    const maxSearches = wanted.relay + wanted.store + wanted.filter + wanted.lightPush;
-    const actual = {
-        relay: 0,
-        store: 0,
-        filter: 0,
-        lightPush: 0
-    };
+async function* fetchNodes(getNode, maxGet = 10, maxErrors = 3) {
+    const peerNodeIds = new Set();
     let totalSearches = 0;
-    const peers = [];
-    while (!isSatisfied(wanted, actual) &&
-        totalSearches < maxSearches + errorTolerance) {
-        const peer = await getNode();
-        if (peer && isNewPeer(peer, peers)) {
-            // ENRs without a waku2 key are ignored.
-            if (peer.waku2) {
-                if (helpsSatisfyCapabilities(peer.waku2, wanted, actual)) {
-                    addCapabilities(peer.waku2, actual);
-                    peers.push(peer);
-                }
-            }
-            log$5.info(`got new peer candidate from DNS address=${peer.nodeId}@${peer.ip}`);
-        }
+    let erroneousSearches = 0;
+    while (totalSearches < maxGet &&
+        erroneousSearches < maxErrors // Allows a couple of empty results before calling it quit
+    ) {
         totalSearches++;
-    }
-    return peers;
-}
-/**
- * Fetch nodes using passed [[getNode]] until all wanted capabilities are
- * fulfilled or the number of [[getNode]] call exceeds the sum of
- * [[wantedNodeCapabilityCount]] plus [[errorTolerance]].
- */
-async function* yieldNodesUntilCapabilitiesFulfilled(wantedNodeCapabilityCount, errorTolerance, getNode) {
-    const wanted = {
-        relay: wantedNodeCapabilityCount.relay ?? 0,
-        store: wantedNodeCapabilityCount.store ?? 0,
-        filter: wantedNodeCapabilityCount.filter ?? 0,
-        lightPush: wantedNodeCapabilityCount.lightPush ?? 0
-    };
-    const maxSearches = wanted.relay + wanted.store + wanted.filter + wanted.lightPush;
-    const actual = {
-        relay: 0,
-        store: 0,
-        filter: 0,
-        lightPush: 0
-    };
-    let totalSearches = 0;
-    const peerNodeIds = new Set();
-    while (!isSatisfied(wanted, actual) &&
-        totalSearches < maxSearches + errorTolerance) {
         const peer = await getNode();
-        if (peer && peer.nodeId && !peerNodeIds.has(peer.nodeId)) {
+        if (!peer || !peer.nodeId) {
+            erroneousSearches++;
+            continue;
+        }
+        if (!peerNodeIds.has(peer.nodeId)) {
             peerNodeIds.add(peer.nodeId);
             // ENRs without a waku2 key are ignored.
             if (peer.waku2) {
-                if (helpsSatisfyCapabilities(peer.waku2, wanted, actual)) {
-                    addCapabilities(peer.waku2, actual);
-                    yield peer;
-                }
+                yield peer;
             }
             log$5.info(`got new peer candidate from DNS address=${peer.nodeId}@${peer.ip}`);
         }
-        totalSearches++;
     }
 }
-function isSatisfied(wanted, actual) {
-    return (actual.relay >= wanted.relay &&
-        actual.store >= wanted.store &&
-        actual.filter >= wanted.filter &&
-        actual.lightPush >= wanted.lightPush);
-}
-function isNewPeer(peer, peers) {
-    if (!peer.nodeId)
-        return false;
-    for (const existingPeer of peers) {
-        if (peer.nodeId === existingPeer.nodeId) {
-            return false;
-        }
-    }
-    return true;
-}
-function addCapabilities(node, total) {
-    if (node.relay)
-        total.relay += 1;
-    if (node.store)
-        total.store += 1;
-    if (node.filter)
-        total.filter += 1;
-    if (node.lightPush)
-        total.lightPush += 1;
-}
-/**
- * Checks if the proposed ENR [[node]] helps satisfy the [[wanted]] capabilities,
- * considering the [[actual]] capabilities of nodes retrieved so far..
- *
- * @throws If the function is called when the wanted capabilities are already fulfilled.
- */
-function helpsSatisfyCapabilities(node, wanted, actual) {
-    if (isSatisfied(wanted, actual)) {
-        throw "Internal Error: Waku2 wanted capabilities are already fulfilled";
-    }
-    const missing = missingCapabilities(wanted, actual);
-    return ((missing.relay && node.relay) ||
-        (missing.store && node.store) ||
-        (missing.filter && node.filter) ||
-        (missing.lightPush && node.lightPush));
-}
-/**
- * Return a [[Waku2]] Object for which capabilities are set to true if they are
- * [[wanted]] yet missing from [[actual]].
- */
-function missingCapabilities(wanted, actual) {
-    return {
-        relay: actual.relay < wanted.relay,
-        store: actual.store < wanted.store,
-        filter: actual.filter < wanted.filter,
-        lightPush: actual.lightPush < wanted.lightPush
-    };
-}
 
 const log$4 = new Logger$1("discovery:dns");
 class DnsNodeDiscovery {
     dns;
     _DNSTreeCache;
-    _errorTolerance = 10;
     static async dnsOverHttp(dnsClient) {
         if (!dnsClient) {
             dnsClient = await DnsOverHttps.create();
         }
         return new DnsNodeDiscovery(dnsClient);
     }
-    /**
-     * Returns a list of verified peers listed in an EIP-1459 DNS tree. Method may
-     * return fewer peers than requested if @link wantedNodeCapabilityCount requires
-     * larger quantity of peers than available or the number of errors/duplicate
-     * peers encountered by randomized search exceeds the sum of the fields of
-     * @link wantedNodeCapabilityCount plus the @link _errorTolerance factor.
-     */
-    async getPeers(enrTreeUrls, wantedNodeCapabilityCount) {
-        const networkIndex = Math.floor(Math.random() * enrTreeUrls.length);
-        const { publicKey, domain } = ENRTree.parseTree(enrTreeUrls[networkIndex]);
-        const context = {
-            domain,
-            publicKey,
-            visits: {}
-        };
-        const peers = await fetchNodesUntilCapabilitiesFulfilled(wantedNodeCapabilityCount, this._errorTolerance, () => this._search(domain, context));
-        log$4.info("retrieved peers: ", peers.map((peer) => {
-            return {
-                id: peer.peerId?.toString(),
-                multiaddrs: peer.multiaddrs?.map((ma) => ma.toString())
-            };
-        }));
-        return peers;
-    }
     constructor(dns) {
         this._DNSTreeCache = {};
         this.dns = dns;
     }
     /**
-     * {@inheritDoc getPeers}
+     * Retrieve the next peers from the passed [[enrTreeUrls]],
      */
-    async *getNextPeer(enrTreeUrls, wantedNodeCapabilityCount) {
-        const networkIndex = Math.floor(Math.random() * enrTreeUrls.length);
-        const { publicKey, domain } = ENRTree.parseTree(enrTreeUrls[networkIndex]);
-        const context = {
-            domain,
-            publicKey,
-            visits: {}
-        };
-        for await (const peer of yieldNodesUntilCapabilitiesFulfilled(wantedNodeCapabilityCount, this._errorTolerance, () => this._search(domain, context))) {
-            yield peer;
+    async *getNextPeer(enrTreeUrls) {
+        // Shuffle the ENR Trees so that not all clients connect to same nodes first.
+        for (const enrTreeUrl of shuffle(enrTreeUrls)) {
+            const { publicKey, domain } = ENRTree.parseTree(enrTreeUrl);
+            const context = {
+                domain,
+                publicKey,
+                visits: {}
+            };
+            for await (const peer of fetchNodes(() => this._search(domain, context))) {
+                yield peer;
+            }
         }
     }
     /**
@@ -15338,7 +15233,7 @@ class DnsNodeDiscovery {
             throw new Error("Received empty result array while fetching TXT record");
         if (!response[0].length)
             throw new Error("Received empty TXT record");
-        // Branch entries can be an array of strings of comma delimited subdomains, with
+        // Branch entries can be an array of strings of comma-delimited subdomains, with
         // some subdomain strings split across the array elements
         const result = response.join("");
         this._DNSTreeCache[subdomain] = result;
@@ -15414,9 +15309,8 @@ class PeerDiscoveryDns extends TypedEventEmitter {
             let { enrUrls } = this._options;
             if (!Array.isArray(enrUrls))
                 enrUrls = [enrUrls];
-            const { wantedNodeCapabilityCount } = this._options;
             const dns = await DnsNodeDiscovery.dnsOverHttp();
-            this.nextPeer = dns.getNextPeer.bind(dns, enrUrls, wantedNodeCapabilityCount);
+            this.nextPeer = dns.getNextPeer.bind(dns, enrUrls);
         }
         for await (const peerEnr of this.nextPeer()) {
             if (!this._started) {
@@ -15433,8 +15327,8 @@ class PeerDiscoveryDns extends TypedEventEmitter {
                 }
             };
             let isPeerChanged = false;
-            const isPeerExists = await this._components.peerStore.has(peerInfo.id);
-            if (isPeerExists) {
+            const isPeerAlreadyInPeerStore = await this._components.peerStore.has(peerInfo.id);
+            if (isPeerAlreadyInPeerStore) {
                 const peer = await this._components.peerStore.get(peerInfo.id);
                 const hasBootstrapTag = peer.tags.has(DEFAULT_BOOTSTRAP_TAG_NAME);
                 if (!hasBootstrapTag) {
@@ -15473,8 +15367,8 @@ class PeerDiscoveryDns extends TypedEventEmitter {
         return DNS_DISCOVERY_TAG;
     }
 }
-function wakuDnsDiscovery(enrUrls, wantedNodeCapabilityCount = DEFAULT_NODE_REQUIREMENTS) {
-    return (components) => new PeerDiscoveryDns(components, { enrUrls, wantedNodeCapabilityCount });
+function wakuDnsDiscovery(enrUrls) {
+    return (components) => new PeerDiscoveryDns(components, { enrUrls });
 }
 
 /* eslint-disable import/export */
@@ -18020,6 +17914,10 @@ var SdsMessage;
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
+                if ((obj.senderId != null && obj.senderId !== '')) {
+                    w.uint32(10);
+                    w.string(obj.senderId);
+                }
                 if ((obj.messageId != null && obj.messageId !== '')) {
                     w.uint32(18);
                     w.string(obj.messageId);
@@ -18051,6 +17949,7 @@ var SdsMessage;
                 }
             }, (reader, length, opts = {}) => {
                 const obj = {
+                    senderId: '',
                     messageId: '',
                     channelId: '',
                     causalHistory: []
@@ -18059,6 +17958,10 @@ var SdsMessage;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
+                        case 1: {
+                            obj.senderId = reader.string();
+                            break;
+                        }
                         case 2: {
                             obj.messageId = reader.string();
                             break;
@@ -19078,13 +18981,11 @@ class StreamManager {
             this.streamPool.delete(peerIdStr);
             await scheduledStream;
         }
-        let stream = this.getOpenStreamForCodec(peerId);
-        if (stream) {
-            this.log.info(`Found existing stream peerId=${peerIdStr} multicodec=${this.multicodec}`);
-            this.lockStream(peerIdStr, stream);
-            return stream;
+        const stream = this.getOpenStreamForCodec(peerId) || (await this.createStream(peerId));
+        if (!stream) {
+            return;
         }
-        stream = await this.createStream(peerId);
+        this.log.info(`Using stream for peerId=${peerIdStr} multicodec=${this.multicodec}`);
         this.lockStream(peerIdStr, stream);
         return stream;
     }
@@ -19092,7 +18993,8 @@ class StreamManager {
         const connections = this.libp2p.connectionManager.getConnections(peerId);
         const connection = selectOpenConnection(connections);
         if (!connection) {
-            throw new Error(`Failed to get a connection to the peer peerId=${peerId.toString()} multicodec=${this.multicodec}`);
+            this.log.error(`Failed to get a connection to the peer peerId=${peerId.toString()} multicodec=${this.multicodec}`);
+            return;
         }
         let lastError;
         let stream;
@@ -19108,7 +19010,8 @@ class StreamManager {
             }
         }
         if (!stream) {
-            throw new Error(`Failed to create a new stream for ${peerId.toString()} -- ` + lastError);
+            this.log.error(`Failed to create a new stream for ${peerId.toString()} -- ` + lastError);
+            return;
         }
         return stream;
     }
@@ -19153,16 +19056,20 @@ class StreamManager {
         const connections = this.libp2p.connectionManager.getConnections(peerId);
         const connection = selectOpenConnection(connections);
         if (!connection) {
+            this.log.info(`No open connection found for peerId=${peerId.toString()} multicodec=${this.multicodec}`);
             return;
         }
         const stream = connection.streams.find((s) => s.protocol === this.multicodec);
         if (!stream) {
+            this.log.info(`No open stream found for peerId=${peerId.toString()} multicodec=${this.multicodec}`);
             return;
         }
         const isStreamUnusable = ["done", "closed", "closing"].includes(stream.writeStatus || "");
         if (isStreamUnusable || this.isStreamLocked(stream)) {
+            this.log.info(`Stream for peerId=${peerId.toString()} multicodec=${this.multicodec} is unusable`);
             return;
         }
+        this.log.info(`Found open stream for peerId=${peerId.toString()} multicodec=${this.multicodec}`);
         return stream;
     }
     lockStream(peerId, stream) {
@@ -19264,12 +19171,9 @@ class WakuPeerExchange {
                 error: ProtocolError.NO_PEER_AVAILABLE
             };
         }
-        let stream;
-        try {
-            stream = await this.streamManager.getStream(peerId);
-        }
-        catch (err) {
-            log$2.error("Failed to get stream", err);
+        const stream = await this.streamManager.getStream(peerId);
+        if (!stream) {
+            log$2.error(`Failed to get a stream for remote peer:${peerId.toString()}`);
             return {
                 peerInfos: null,
                 error: ProtocolError.NO_STREAM_AVAILABLE