@waku/discovery 0.0.11-e224c05.0 → 0.0.11-e800af3.0

package/bundle/index.js

@@ -286,12 +286,18 @@ 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) {
     Tags["BOOTSTRAP"] = "bootstrap";
     Tags["PEER_EXCHANGE"] = "peer-exchange";
-    Tags["LOCAL"] = "local-peer-cache";
+    Tags["PEER_CACHE"] = "peer-cache";
 })(Tags || (Tags = {}));
 
 const DNS_DISCOVERY_TAG = "@waku/bootstrap";
@@ -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;
 
 /**
@@ -2355,14 +2380,6 @@ const encodeRelayShard = (shardInfo) => {
     return new Uint8Array(buffer);
 };
 
-function getWsMultiaddrFromMultiaddrs(addresses) {
-    const wsMultiaddr = addresses.find((addr) => addr.toString().includes("ws") || addr.toString().includes("wss"));
-    if (!wsMultiaddr) {
-        throw new Error("No ws multiaddr found in the given addresses");
-    }
-    return wsMultiaddr;
-}
-
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function getDefaultExportFromCjs (x) {
@@ -3151,11 +3168,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 +15111,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 +15225,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 +15301,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 +15319,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,10 +15359,17 @@ 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 });
 }
 
+// amount of peers available per specification
+const DEFAULT_PEER_EXCHANGE_REQUEST_NODES = 60;
+const DEFAULT_PEER_EXCHANGE_TAG_NAME = Tags.PEER_EXCHANGE;
+const DEFAULT_PEER_EXCHANGE_TAG_VALUE = 50;
+const DEFAULT_PEER_EXCHANGE_TAG_TTL = 30_000;
+const PeerExchangeCodec = "/vac/waku/peer-exchange/2.0.0-alpha1";
+
 /* eslint-disable import/export */
 /* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-namespace */
@@ -18020,6 +17913,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 +17948,7 @@ var SdsMessage;
                 }
             }, (reader, length, opts = {}) => {
                 const obj = {
+                    senderId: '',
                     messageId: '',
                     channelId: '',
                     causalHistory: []
@@ -18059,6 +17957,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;
@@ -19072,27 +18974,32 @@ class StreamManager {
         this.libp2p.events.addEventListener("peer:update", this.handlePeerUpdateStreamPool);
     }
     async getStream(peerId) {
-        const peerIdStr = peerId.toString();
-        const scheduledStream = this.streamPool.get(peerIdStr);
-        if (scheduledStream) {
-            this.streamPool.delete(peerIdStr);
-            await scheduledStream;
-        }
-        let stream = this.getOpenStreamForCodec(peerId);
-        if (stream) {
-            this.log.info(`Found existing stream peerId=${peerIdStr} multicodec=${this.multicodec}`);
+        try {
+            const peerIdStr = peerId.toString();
+            const scheduledStream = this.streamPool.get(peerIdStr);
+            if (scheduledStream) {
+                this.streamPool.delete(peerIdStr);
+                await scheduledStream;
+            }
+            const stream = this.getOpenStreamForCodec(peerId) || (await this.createStream(peerId));
+            if (!stream) {
+                return;
+            }
+            this.log.info(`Using stream for peerId=${peerIdStr} multicodec=${this.multicodec}`);
             this.lockStream(peerIdStr, stream);
             return stream;
         }
-        stream = await this.createStream(peerId);
-        this.lockStream(peerIdStr, stream);
-        return stream;
+        catch (error) {
+            this.log.error(`Failed to getStream:`, error);
+            return;
+        }
     }
     async createStream(peerId, retries = 0) {
         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 +19015,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 +19061,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) {
@@ -19234,12 +19146,11 @@ class PeerExchangeRPC {
     }
 }
 
-const PeerExchangeCodec = "/vac/waku/peer-exchange/2.0.0-alpha1";
 const log$2 = new Logger$1("peer-exchange");
 /**
  * Implementation of the Peer Exchange protocol (https://rfc.vac.dev/spec/34/)
  */
-class WakuPeerExchange {
+class PeerExchange {
     components;
     streamManager;
     /**
@@ -19257,19 +19168,16 @@ class WakuPeerExchange {
         const rpcQuery = PeerExchangeRPC.createRequest({
             numPeers: BigInt(numPeers)
         });
-        const peer = await this.components.peerStore.get(peerId);
-        if (!peer) {
+        const hasPeer = await this.components.peerStore.has(peerId);
+        if (!hasPeer) {
             return {
                 peerInfos: null,
                 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
@@ -19309,64 +19217,56 @@ class WakuPeerExchange {
         }
     }
 }
-/**
- *
- * @returns A function that creates a new peer exchange protocol
- */
-function wakuPeerExchange() {
-    return (components) => new WakuPeerExchange(components);
-}
 
 const log$1 = new Logger$1("peer-exchange-discovery");
-const DEFAULT_PEER_EXCHANGE_REQUEST_NODES = 10;
-const DEFAULT_PEER_EXCHANGE_QUERY_INTERVAL_MS = 10 * 1000;
-const DEFAULT_MAX_RETRIES = 3;
-const DEFAULT_PEER_EXCHANGE_TAG_NAME = Tags.PEER_EXCHANGE;
-const DEFAULT_PEER_EXCHANGE_TAG_VALUE = 50;
-const DEFAULT_PEER_EXCHANGE_TAG_TTL = 100_000_000;
 class PeerExchangeDiscovery extends TypedEventEmitter {
     components;
     peerExchange;
     options;
-    isStarted;
+    isStarted = false;
     queryingPeers = new Set();
-    queryAttempts = new Map();
-    handleDiscoveredPeer = (event) => {
-        const { protocols, peerId } = event.detail;
-        if (!protocols.includes(PeerExchangeCodec) ||
-            this.queryingPeers.has(peerId.toString()))
-            return;
-        this.queryingPeers.add(peerId.toString());
-        this.startRecurringQueries(peerId).catch((error) => log$1.error(`Error querying peer ${error}`));
-    };
+    peerExpirationRecords = new Map();
+    continuousDiscoveryInterval = null;
     constructor(components, options = {}) {
         super();
         this.components = components;
-        this.peerExchange = new WakuPeerExchange(components);
-        this.options = options;
-        this.isStarted = false;
+        this.peerExchange = new PeerExchange(components);
+        this.options = {
+            ...options,
+            TTL: options.TTL ?? DEFAULT_PEER_EXCHANGE_TAG_TTL
+        };
+        this.handleDiscoveredPeer = this.handleDiscoveredPeer.bind(this);
     }
     /**
-     * Start emitting events
+     * Start Peer Exchange.
+     * Subscribe to "peer:identify" events and handle them.
      */
     start() {
         if (this.isStarted) {
             return;
         }
-        this.dispatchEvent(new CustomEvent("waku:peer-exchange:started", { detail: true }));
         log$1.info("Starting peer exchange node discovery, discovering peers");
-        // might be better to use "peer:identify" or "peer:update"
+        this.isStarted = true;
         this.components.events.addEventListener("peer:identify", this.handleDiscoveredPeer);
+        this.continuousDiscoveryInterval = setInterval(() => {
+            void this.handlePeriodicDiscovery();
+        }, this.options.TTL);
     }
     /**
-     * Remove event listener
+     * Stop Peer Exchange.
+     * Unsubscribe from "peer:identify" events.
      */
     stop() {
-        if (!this.isStarted)
+        if (!this.isStarted) {
             return;
+        }
         log$1.info("Stopping peer exchange node discovery");
         this.isStarted = false;
         this.queryingPeers.clear();
+        this.peerExpirationRecords.clear();
+        if (this.continuousDiscoveryInterval) {
+            clearInterval(this.continuousDiscoveryInterval);
+        }
         this.components.events.removeEventListener("peer:identify", this.handleDiscoveredPeer);
     }
     get [peerDiscoverySymbol]() {
@@ -19375,228 +19275,268 @@ class PeerExchangeDiscovery extends TypedEventEmitter {
     get [Symbol.toStringTag]() {
         return "@waku/peer-exchange";
     }
-    startRecurringQueries = async (peerId) => {
-        const peerIdStr = peerId.toString();
-        const { queryInterval = DEFAULT_PEER_EXCHANGE_QUERY_INTERVAL_MS, maxRetries = DEFAULT_MAX_RETRIES } = this.options;
-        log$1.info(`Querying peer: ${peerIdStr} (attempt ${this.queryAttempts.get(peerIdStr) ?? 1})`);
-        await this.query(peerId);
-        const currentAttempt = this.queryAttempts.get(peerIdStr) ?? 1;
-        if (currentAttempt > maxRetries) {
-            this.abortQueriesForPeer(peerIdStr);
+    async handleDiscoveredPeer(event) {
+        void this.runQuery(event.detail.peerId, event.detail.protocols);
+    }
+    async handlePeriodicDiscovery() {
+        const connections = this.components.connectionManager.getConnections();
+        await Promise.all(connections.map(async (connection) => {
+            try {
+                const peerIdStr = connection.remotePeer.toString();
+                const shouldQuery = this.peerExpirationRecords.has(peerIdStr)
+                    ? this.peerExpirationRecords.get(peerIdStr) <= Date.now()
+                    : true;
+                if (!shouldQuery) {
+                    return null;
+                }
+                const peer = await this.components.peerStore.get(connection.remotePeer);
+                return this.runQuery(connection.remotePeer, peer.protocols);
+            }
+            catch (error) {
+                log$1.warn("Error getting peer info", error);
+                return null;
+            }
+        }));
+    }
+    async runQuery(peerId, protocols) {
+        if (!protocols.includes(PeerExchangeCodec) ||
+            this.queryingPeers.has(peerId.toString())) {
+            log$1.info(`Skipping peer ${peerId} as it is already querying or does not support peer exchange`);
             return;
         }
-        setTimeout(() => {
-            this.queryAttempts.set(peerIdStr, currentAttempt + 1);
-            this.startRecurringQueries(peerId).catch((error) => {
-                log$1.error(`Error in startRecurringQueries: ${error}`);
-            });
-        }, queryInterval * currentAttempt);
-    };
+        try {
+            this.queryingPeers.add(peerId.toString());
+            await this.query(peerId);
+        }
+        catch (error) {
+            log$1.error("Error querying peer", error);
+        }
+        this.peerExpirationRecords.set(peerId.toString(), Date.now() + this.options.TTL);
+        this.queryingPeers.delete(peerId.toString());
+    }
     async query(peerId) {
+        const peerIdStr = peerId.toString();
+        log$1.info(`Querying peer exchange for ${peerIdStr}`);
         const { error, peerInfos } = await this.peerExchange.query({
             numPeers: DEFAULT_PEER_EXCHANGE_REQUEST_NODES,
             peerId
         });
         if (error) {
-            log$1.error("Peer exchange query failed", error);
-            return { error, peerInfos: null };
+            log$1.error(`Peer exchange query to ${peerIdStr} failed`, error);
+            return;
         }
-        for (const _peerInfo of peerInfos) {
-            const { ENR } = _peerInfo;
+        for (const { ENR } of peerInfos) {
             if (!ENR) {
-                log$1.warn("No ENR in peerInfo object, skipping");
+                log$1.warn(`No ENR in peerInfo object from ${peerIdStr}, skipping`);
                 continue;
             }
-            const { peerId, peerInfo, shardInfo } = ENR;
-            if (!peerId || !peerInfo) {
+            const { peerInfo, shardInfo } = ENR;
+            if (!peerInfo) {
+                log$1.warn(`No peerInfo in ENR from ${peerIdStr}, skipping`);
                 continue;
             }
-            const hasPeer = await this.components.peerStore.has(peerId);
-            if (hasPeer) {
-                const { hasMultiaddrDiff, hasShardDiff } = await this.checkPeerInfoDiff(peerInfo, shardInfo);
-                if (hasMultiaddrDiff || hasShardDiff) {
-                    log$1.info(`Peer ${peerId.toString()} has updated multiaddrs or shardInfo, updating`);
-                    if (hasMultiaddrDiff) {
-                        log$1.info(`Peer ${peerId.toString()} has updated multiaddrs, updating`);
-                        await this.components.peerStore.patch(peerId, {
-                            multiaddrs: peerInfo.multiaddrs
-                        });
-                    }
-                    if (hasShardDiff && shardInfo) {
-                        log$1.info(`Peer ${peerId.toString()} has updated shardInfo, updating`);
-                        await this.components.peerStore.merge(peerId, {
-                            metadata: {
-                                shardInfo: encodeRelayShard(shardInfo)
-                            }
-                        });
-                        this.dispatchEvent(new CustomEvent("peer", {
-                            detail: {
-                                id: peerId,
-                                multiaddrs: peerInfo.multiaddrs
-                            }
-                        }));
-                    }
-                    continue;
-                }
-            }
-            // update the tags for the peer
-            await this.components.peerStore.save(peerId, {
+            const hasPrevShardInfo = await this.hasShardInfo(peerInfo.id);
+            const metadata = !hasPrevShardInfo && shardInfo
+                ? { metadata: { shardInfo: encodeRelayShard(shardInfo) } }
+                : undefined;
+            // merge is smart enough to overwrite only changed parts
+            await this.components.peerStore.merge(peerInfo.id, {
                 tags: {
                     [DEFAULT_PEER_EXCHANGE_TAG_NAME]: {
-                        value: this.options.tagValue ?? DEFAULT_PEER_EXCHANGE_TAG_VALUE,
-                        ttl: this.options.tagTTL ?? DEFAULT_PEER_EXCHANGE_TAG_TTL
+                        value: DEFAULT_PEER_EXCHANGE_TAG_VALUE
                     }
                 },
-                ...(shardInfo && {
-                    metadata: {
-                        shardInfo: encodeRelayShard(shardInfo)
-                    }
-                }),
+                ...metadata,
                 ...(peerInfo.multiaddrs && {
                     multiaddrs: peerInfo.multiaddrs
                 })
             });
-            log$1.info(`Discovered peer: ${peerId.toString()}`);
+            log$1.info(`Discovered peer: ${peerInfo.id.toString()}`);
             this.dispatchEvent(new CustomEvent("peer", {
                 detail: {
-                    id: peerId,
+                    id: peerInfo.id,
                     multiaddrs: peerInfo.multiaddrs
                 }
             }));
         }
-        return { error: null, peerInfos };
-    }
-    abortQueriesForPeer(peerIdStr) {
-        log$1.info(`Aborting queries for peer: ${peerIdStr}`);
-        this.queryingPeers.delete(peerIdStr);
-        this.queryAttempts.delete(peerIdStr);
-    }
-    async checkPeerInfoDiff(peerInfo, shardInfo) {
-        const { id: peerId } = peerInfo;
-        const peer = await this.components.peerStore.get(peerId);
-        const existingMultiaddrs = peer.addresses.map((a) => a.multiaddr.toString());
-        const newMultiaddrs = peerInfo.multiaddrs.map((ma) => ma.toString());
-        const hasMultiaddrDiff = existingMultiaddrs.some((ma) => !newMultiaddrs.includes(ma));
-        let hasShardDiff = false;
-        const existingShardInfoBytes = peer.metadata.get("shardInfo");
-        if (existingShardInfoBytes) {
-            const existingShardInfo = decodeRelayShard(existingShardInfoBytes);
-            if (existingShardInfo || shardInfo) {
-                hasShardDiff =
-                    existingShardInfo.clusterId !== shardInfo?.clusterId ||
-                        existingShardInfo.shards.some((shard) => !shardInfo?.shards.includes(shard));
+    }
+    async hasShardInfo(peerId) {
+        try {
+            const peer = await this.components.peerStore.get(peerId);
+            if (!peer) {
+                return false;
             }
+            return peer.metadata.has("shardInfo");
+        }
+        catch (err) {
+            log$1.warn(`Error getting shard info for ${peerId.toString()}`, err);
         }
-        return { hasMultiaddrDiff, hasShardDiff };
+        return false;
     }
 }
-function wakuPeerExchangeDiscovery() {
-    return (components) => new PeerExchangeDiscovery(components);
+function wakuPeerExchangeDiscovery(options = {}) {
+    return (components) => new PeerExchangeDiscovery(components, options);
+}
+
+const DEFAULT_PEER_CACHE_TAG_NAME = Tags.PEER_CACHE;
+const DEFAULT_PEER_CACHE_TAG_VALUE = 50;
+
+const isValidStoredPeer = (peer) => {
+    return (!!peer &&
+        typeof peer === "object" &&
+        "id" in peer &&
+        typeof peer.id === "string" &&
+        "multiaddrs" in peer &&
+        Array.isArray(peer.multiaddrs));
+};
+/**
+ * A noop cache that will be used in environments where localStorage is not available.
+ */
+class NoopCache {
+    get() {
+        return [];
+    }
+    set(_value) {
+        return;
+    }
+    remove() {
+        return;
+    }
+}
+/**
+ * A cache that uses localStorage to store peer information.
+ */
+class LocalStorageCache {
+    get() {
+        try {
+            const cachedPeers = localStorage.getItem("waku:peers");
+            const peers = cachedPeers ? JSON.parse(cachedPeers) : [];
+            return peers.filter(isValidStoredPeer);
+        }
+        catch (e) {
+            return [];
+        }
+    }
+    set(_value) {
+        try {
+            localStorage.setItem("waku:peers", JSON.stringify(_value));
+        }
+        catch (e) {
+            // ignore
+        }
+    }
+    remove() {
+        try {
+            localStorage.removeItem("waku:peers");
+        }
+        catch (e) {
+            // ignore
+        }
+    }
 }
+const defaultCache = () => {
+    try {
+        if (typeof localStorage !== "undefined") {
+            return new LocalStorageCache();
+        }
+    }
+    catch (_e) {
+        // ignore
+    }
+    return new NoopCache();
+};
 
-const log = new Logger$1("local-cache-discovery");
-const DEFAULT_LOCAL_TAG_NAME = Tags.LOCAL;
-const DEFAULT_LOCAL_TAG_VALUE = 50;
-const DEFAULT_LOCAL_TAG_TTL = 100_000_000;
-class LocalPeerCacheDiscovery extends TypedEventEmitter {
+const log = new Logger$1("peer-cache");
+class PeerCacheDiscovery extends TypedEventEmitter {
     components;
-    options;
-    isStarted;
-    peers = [];
+    isStarted = false;
+    cache;
     constructor(components, options) {
         super();
         this.components = components;
-        this.options = options;
-        this.isStarted = false;
-        this.peers = this.getPeersFromLocalStorage();
+        this.cache = options?.cache ?? defaultCache();
     }
     get [Symbol.toStringTag]() {
-        return "@waku/local-peer-cache-discovery";
+        return `@waku/${DEFAULT_PEER_CACHE_TAG_NAME}`;
     }
     async start() {
-        if (this.isStarted)
+        if (this.isStarted) {
             return;
-        log.info("Starting Local Storage Discovery");
-        this.components.events.addEventListener("peer:identify", this.handleNewPeers);
-        for (const { id: idStr, address } of this.peers) {
-            const peerId = peerIdFromString(idStr);
-            if (await this.components.peerStore.has(peerId))
-                continue;
-            await this.components.peerStore.save(peerId, {
-                multiaddrs: [multiaddr(address)],
-                tags: {
-                    [this.options?.tagName ?? DEFAULT_LOCAL_TAG_NAME]: {
-                        value: this.options?.tagValue ?? DEFAULT_LOCAL_TAG_VALUE,
-                        ttl: this.options?.tagTTL ?? DEFAULT_LOCAL_TAG_TTL
-                    }
-                }
-            });
-            this.dispatchEvent(new CustomEvent("peer", {
-                detail: {
-                    id: peerId,
-                    multiaddrs: [multiaddr(address)]
-                }
-            }));
         }
-        log.info(`Discovered ${this.peers.length} peers`);
+        log.info("Starting Peer Cache Discovery");
+        this.components.events.addEventListener("peer:identify", this.handleDiscoveredPeer);
+        await this.discoverPeers();
         this.isStarted = true;
     }
     stop() {
-        if (!this.isStarted)
+        if (!this.isStarted) {
             return;
-        log.info("Stopping Local Storage Discovery");
-        this.components.events.removeEventListener("peer:identify", this.handleNewPeers);
+        }
+        log.info("Stopping Peer Cache Discovery");
+        this.components.events.removeEventListener("peer:identify", this.handleDiscoveredPeer);
         this.isStarted = false;
-        this.savePeersToLocalStorage();
     }
-    handleNewPeers = (event) => {
+    handleDiscoveredPeer = (event) => {
         const { peerId, listenAddrs } = event.detail;
-        const websocketMultiaddr = getWsMultiaddrFromMultiaddrs(listenAddrs);
-        const localStoragePeers = this.getPeersFromLocalStorage();
-        const existingPeerIndex = localStoragePeers.findIndex((_peer) => _peer.id === peerId.toString());
-        if (existingPeerIndex >= 0) {
-            localStoragePeers[existingPeerIndex].address =
-                websocketMultiaddr.toString();
+        const multiaddrs = listenAddrs.map((addr) => addr.toString());
+        const peerIdStr = peerId.toString();
+        const knownPeers = this.readPeerInfoFromCache();
+        const peerIndex = knownPeers.findIndex((p) => p.id === peerIdStr);
+        if (peerIndex !== -1) {
+            knownPeers[peerIndex].multiaddrs = multiaddrs;
         }
         else {
-            localStoragePeers.push({
-                id: peerId.toString(),
-                address: websocketMultiaddr.toString()
+            knownPeers.push({
+                id: peerIdStr,
+                multiaddrs
             });
         }
-        this.peers = localStoragePeers;
-        this.savePeersToLocalStorage();
+        this.writePeerInfoToCache(knownPeers);
     };
-    getPeersFromLocalStorage() {
+    async discoverPeers() {
+        const knownPeers = this.readPeerInfoFromCache();
+        for (const peer of knownPeers) {
+            const peerId = peerIdFromString(peer.id);
+            const multiaddrs = peer.multiaddrs.map((addr) => multiaddr(addr));
+            if (await this.components.peerStore.has(peerId)) {
+                continue;
+            }
+            await this.components.peerStore.save(peerId, {
+                multiaddrs,
+                tags: {
+                    [DEFAULT_PEER_CACHE_TAG_NAME]: {
+                        value: DEFAULT_PEER_CACHE_TAG_VALUE
+                    }
+                }
+            });
+            this.dispatchEvent(new CustomEvent("peer", {
+                detail: {
+                    id: peerId,
+                    multiaddrs
+                }
+            }));
+        }
+    }
+    readPeerInfoFromCache() {
         try {
-            const storedPeersData = localStorage.getItem("waku:peers");
-            if (!storedPeersData)
-                return [];
-            const peers = JSON.parse(storedPeersData);
-            return peers.filter(isValidStoredPeer);
+            return this.cache.get();
         }
         catch (error) {
-            log.error("Error parsing peers from local storage:", error);
+            log.error("Error parsing peers from cache:", error);
             return [];
         }
     }
-    savePeersToLocalStorage() {
+    writePeerInfoToCache(peers) {
         try {
-            localStorage.setItem("waku:peers", JSON.stringify(this.peers));
+            this.cache.set(peers);
         }
         catch (error) {
-            log.error("Error saving peers to local storage:", error);
+            log.error("Error saving peers to cache:", error);
         }
     }
 }
-function isValidStoredPeer(peer) {
-    return (peer &&
-        typeof peer === "object" &&
-        typeof peer.id === "string" &&
-        typeof peer.address === "string");
-}
-function wakuLocalPeerCacheDiscovery() {
-    return (components, options) => new LocalPeerCacheDiscovery(components, options);
+function wakuPeerCacheDiscovery(options = {}) {
+    return (components) => new PeerCacheDiscovery(components, options);
 }
 
-export { DnsNodeDiscovery, LocalPeerCacheDiscovery, PeerDiscoveryDns, PeerExchangeCodec, PeerExchangeDiscovery, WakuPeerExchange, enrTree, wakuDnsDiscovery, wakuLocalPeerCacheDiscovery, wakuPeerExchange, wakuPeerExchangeDiscovery };
+export { DnsNodeDiscovery, PeerCacheDiscovery, PeerDiscoveryDns, PeerExchangeCodec, PeerExchangeDiscovery, enrTree, wakuDnsDiscovery, wakuPeerCacheDiscovery, wakuPeerExchangeDiscovery };