@waku/discovery 0.0.4-08fc2d1.0 → 0.0.4-88a29c3.0

package/bundle/index.js

@@ -537,6 +537,11 @@ var ProtocolError;
      * Ensure that the pubsub topic used for decoder creation is the same as the one used for protocol.
      */
     ProtocolError["TOPIC_DECODER_MISMATCH"] = "Topic decoder mismatch";
+    /**
+     * The topics passed in the decoders do not match each other, or don't exist at all.
+     * Ensure that all the pubsub topics used in the decoders are valid and match each other.
+     */
+    ProtocolError["INVALID_DECODER_TOPICS"] = "Invalid decoder topics";
     /**
      * Failure to find a peer with suitable protocols. This may due to a connection issue.
      * Mitigation can be: retrying after a given time period, display connectivity issue
@@ -567,12 +572,6 @@ var ProtocolError;
     ProtocolError["REQUEST_TIMEOUT"] = "Request timeout";
 })(ProtocolError || (ProtocolError = {}));
 
-var PageDirection;
-(function (PageDirection) {
-    PageDirection["BACKWARD"] = "backward";
-    PageDirection["FORWARD"] = "forward";
-})(PageDirection || (PageDirection = {}));
-
 var Tags;
 (function (Tags) {
     Tags["BOOTSTRAP"] = "bootstrap";
@@ -596,6 +595,13 @@ var EConnectionStateEvents;
  */
 const DEFAULT_CLUSTER_ID = 1;
 
+var HealthStatus;
+(function (HealthStatus) {
+    HealthStatus["Unhealthy"] = "Unhealthy";
+    HealthStatus["MinimallyHealthy"] = "MinimallyHealthy";
+    HealthStatus["SufficientlyHealthy"] = "SufficientlyHealthy";
+})(HealthStatus || (HealthStatus = {}));
+
 function equals$2(aa, bb) {
     if (aa === bb)
         return true;
@@ -23839,113 +23845,26 @@ var WakuMessage$1;
 /* eslint-disable @typescript-eslint/no-namespace */
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
-var Index;
-(function (Index) {
+var WakuMessageKeyValue;
+(function (WakuMessageKeyValue) {
     let _codec;
-    Index.codec = () => {
+    WakuMessageKeyValue.codec = () => {
         if (_codec == null) {
             _codec = message((obj, w, opts = {}) => {
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if ((obj.digest != null && obj.digest.byteLength > 0)) {
+                if (obj.messageHash != null) {
                     w.uint32(10);
-                    w.bytes(obj.digest);
-                }
-                if ((obj.receiverTime != null && obj.receiverTime !== 0n)) {
-                    w.uint32(16);
-                    w.sint64(obj.receiverTime);
-                }
-                if ((obj.senderTime != null && obj.senderTime !== 0n)) {
-                    w.uint32(24);
-                    w.sint64(obj.senderTime);
-                }
-                if ((obj.pubsubTopic != null && obj.pubsubTopic !== '')) {
-                    w.uint32(34);
-                    w.string(obj.pubsubTopic);
-                }
-                if (opts.lengthDelimited !== false) {
-                    w.ldelim();
-                }
-            }, (reader, length, opts = {}) => {
-                const obj = {
-                    digest: alloc$2(0),
-                    receiverTime: 0n,
-                    senderTime: 0n,
-                    pubsubTopic: ''
-                };
-                const end = length == null ? reader.len : reader.pos + length;
-                while (reader.pos < end) {
-                    const tag = reader.uint32();
-                    switch (tag >>> 3) {
-                        case 1: {
-                            obj.digest = reader.bytes();
-                            break;
-                        }
-                        case 2: {
-                            obj.receiverTime = reader.sint64();
-                            break;
-                        }
-                        case 3: {
-                            obj.senderTime = reader.sint64();
-                            break;
-                        }
-                        case 4: {
-                            obj.pubsubTopic = reader.string();
-                            break;
-                        }
-                        default: {
-                            reader.skipType(tag & 7);
-                            break;
-                        }
-                    }
-                }
-                return obj;
-            });
-        }
-        return _codec;
-    };
-    Index.encode = (obj) => {
-        return encodeMessage(obj, Index.codec());
-    };
-    Index.decode = (buf, opts) => {
-        return decodeMessage(buf, Index.codec(), opts);
-    };
-})(Index || (Index = {}));
-var PagingInfo;
-(function (PagingInfo) {
-    (function (Direction) {
-        Direction["BACKWARD"] = "BACKWARD";
-        Direction["FORWARD"] = "FORWARD";
-    })(PagingInfo.Direction || (PagingInfo.Direction = {}));
-    let __DirectionValues;
-    (function (__DirectionValues) {
-        __DirectionValues[__DirectionValues["BACKWARD"] = 0] = "BACKWARD";
-        __DirectionValues[__DirectionValues["FORWARD"] = 1] = "FORWARD";
-    })(__DirectionValues || (__DirectionValues = {}));
-    (function (Direction) {
-        Direction.codec = () => {
-            return enumeration(__DirectionValues);
-        };
-    })(PagingInfo.Direction || (PagingInfo.Direction = {}));
-    let _codec;
-    PagingInfo.codec = () => {
-        if (_codec == null) {
-            _codec = message((obj, w, opts = {}) => {
-                if (opts.lengthDelimited !== false) {
-                    w.fork();
-                }
-                if (obj.pageSize != null) {
-                    w.uint32(8);
-                    w.uint64(obj.pageSize);
+                    w.bytes(obj.messageHash);
                 }
-                if (obj.cursor != null) {
+                if (obj.message != null) {
                     w.uint32(18);
-                    Index.codec().encode(obj.cursor, w);
+                    WakuMessage.codec().encode(obj.message, w);
                 }
-                if (obj.direction != null) {
-                    w.uint32(24);
-                    PagingInfo.Direction.codec().encode(obj.direction, w);
+                if (obj.pubsubTopic != null) {
+                    w.uint32(26);
+                    w.string(obj.pubsubTopic);
                 }
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
@@ -23957,17 +23876,17 @@ var PagingInfo;
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
                         case 1: {
-                            obj.pageSize = reader.uint64();
+                            obj.messageHash = reader.bytes();
                             break;
                         }
                         case 2: {
-                            obj.cursor = Index.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.cursor
+                            obj.message = WakuMessage.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.message
                             });
                             break;
                         }
                         case 3: {
-                            obj.direction = PagingInfo.Direction.codec().decode(reader);
+                            obj.pubsubTopic = reader.string();
                             break;
                         }
                         default: {
@@ -23981,217 +23900,125 @@ var PagingInfo;
         }
         return _codec;
     };
-    PagingInfo.encode = (obj) => {
-        return encodeMessage(obj, PagingInfo.codec());
+    WakuMessageKeyValue.encode = (obj) => {
+        return encodeMessage(obj, WakuMessageKeyValue.codec());
     };
-    PagingInfo.decode = (buf, opts) => {
-        return decodeMessage(buf, PagingInfo.codec(), opts);
+    WakuMessageKeyValue.decode = (buf, opts) => {
+        return decodeMessage(buf, WakuMessageKeyValue.codec(), opts);
     };
-})(PagingInfo || (PagingInfo = {}));
-var ContentFilter;
-(function (ContentFilter) {
+})(WakuMessageKeyValue || (WakuMessageKeyValue = {}));
+var StoreQueryRequest;
+(function (StoreQueryRequest) {
     let _codec;
-    ContentFilter.codec = () => {
+    StoreQueryRequest.codec = () => {
         if (_codec == null) {
             _codec = message((obj, w, opts = {}) => {
                 if (opts.lengthDelimited !== false) {
                     w.fork();
                 }
-                if ((obj.contentTopic != null && obj.contentTopic !== '')) {
+                if ((obj.requestId != null && obj.requestId !== '')) {
                     w.uint32(10);
-                    w.string(obj.contentTopic);
+                    w.string(obj.requestId);
                 }
-                if (opts.lengthDelimited !== false) {
-                    w.ldelim();
+                if ((obj.includeData != null && obj.includeData !== false)) {
+                    w.uint32(16);
+                    w.bool(obj.includeData);
                 }
-            }, (reader, length, opts = {}) => {
-                const obj = {
-                    contentTopic: ''
-                };
-                const end = length == null ? reader.len : reader.pos + length;
-                while (reader.pos < end) {
-                    const tag = reader.uint32();
-                    switch (tag >>> 3) {
-                        case 1: {
-                            obj.contentTopic = reader.string();
-                            break;
-                        }
-                        default: {
-                            reader.skipType(tag & 7);
-                            break;
-                        }
+                if (obj.pubsubTopic != null) {
+                    w.uint32(82);
+                    w.string(obj.pubsubTopic);
+                }
+                if (obj.contentTopics != null) {
+                    for (const value of obj.contentTopics) {
+                        w.uint32(90);
+                        w.string(value);
                     }
                 }
-                return obj;
-            });
-        }
-        return _codec;
-    };
-    ContentFilter.encode = (obj) => {
-        return encodeMessage(obj, ContentFilter.codec());
-    };
-    ContentFilter.decode = (buf, opts) => {
-        return decodeMessage(buf, ContentFilter.codec(), opts);
-    };
-})(ContentFilter || (ContentFilter = {}));
-var HistoryQuery;
-(function (HistoryQuery) {
-    let _codec;
-    HistoryQuery.codec = () => {
-        if (_codec == null) {
-            _codec = message((obj, w, opts = {}) => {
-                if (opts.lengthDelimited !== false) {
-                    w.fork();
+                if (obj.timeStart != null) {
+                    w.uint32(96);
+                    w.sint64(obj.timeStart);
                 }
-                if (obj.pubsubTopic != null) {
-                    w.uint32(18);
-                    w.string(obj.pubsubTopic);
+                if (obj.timeEnd != null) {
+                    w.uint32(104);
+                    w.sint64(obj.timeEnd);
                 }
-                if (obj.contentFilters != null) {
-                    for (const value of obj.contentFilters) {
-                        w.uint32(26);
-                        ContentFilter.codec().encode(value, w);
+                if (obj.messageHashes != null) {
+                    for (const value of obj.messageHashes) {
+                        w.uint32(162);
+                        w.bytes(value);
                     }
                 }
-                if (obj.pagingInfo != null) {
-                    w.uint32(34);
-                    PagingInfo.codec().encode(obj.pagingInfo, w);
+                if (obj.paginationCursor != null) {
+                    w.uint32(410);
+                    w.bytes(obj.paginationCursor);
                 }
-                if (obj.startTime != null) {
-                    w.uint32(40);
-                    w.sint64(obj.startTime);
+                if ((obj.paginationForward != null && obj.paginationForward !== false)) {
+                    w.uint32(416);
+                    w.bool(obj.paginationForward);
                 }
-                if (obj.endTime != null) {
-                    w.uint32(48);
-                    w.sint64(obj.endTime);
+                if (obj.paginationLimit != null) {
+                    w.uint32(424);
+                    w.uint64(obj.paginationLimit);
                 }
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
             }, (reader, length, opts = {}) => {
                 const obj = {
-                    contentFilters: []
+                    requestId: '',
+                    includeData: false,
+                    contentTopics: [],
+                    messageHashes: [],
+                    paginationForward: false
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 2: {
-                            obj.pubsubTopic = reader.string();
+                        case 1: {
+                            obj.requestId = reader.string();
                             break;
                         }
-                        case 3: {
-                            if (opts.limits?.contentFilters != null && obj.contentFilters.length === opts.limits.contentFilters) {
-                                throw new CodeError('decode error - map field "contentFilters" had too many elements', 'ERR_MAX_LENGTH');
-                            }
-                            obj.contentFilters.push(ContentFilter.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.contentFilters$
-                            }));
+                        case 2: {
+                            obj.includeData = reader.bool();
                             break;
                         }
-                        case 4: {
-                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.pagingInfo
-                            });
+                        case 10: {
+                            obj.pubsubTopic = reader.string();
                             break;
                         }
-                        case 5: {
-                            obj.startTime = reader.sint64();
+                        case 11: {
+                            if (opts.limits?.contentTopics != null && obj.contentTopics.length === opts.limits.contentTopics) {
+                                throw new CodeError('decode error - map field "contentTopics" had too many elements', 'ERR_MAX_LENGTH');
+                            }
+                            obj.contentTopics.push(reader.string());
                             break;
                         }
-                        case 6: {
-                            obj.endTime = reader.sint64();
+                        case 12: {
+                            obj.timeStart = reader.sint64();
                             break;
                         }
-                        default: {
-                            reader.skipType(tag & 7);
+                        case 13: {
+                            obj.timeEnd = reader.sint64();
                             break;
                         }
-                    }
-                }
-                return obj;
-            });
-        }
-        return _codec;
-    };
-    HistoryQuery.encode = (obj) => {
-        return encodeMessage(obj, HistoryQuery.codec());
-    };
-    HistoryQuery.decode = (buf, opts) => {
-        return decodeMessage(buf, HistoryQuery.codec(), opts);
-    };
-})(HistoryQuery || (HistoryQuery = {}));
-var HistoryResponse;
-(function (HistoryResponse) {
-    let HistoryError;
-    (function (HistoryError) {
-        HistoryError["NONE"] = "NONE";
-        HistoryError["INVALID_CURSOR"] = "INVALID_CURSOR";
-        HistoryError["TOO_MANY_REQUESTS"] = "TOO_MANY_REQUESTS";
-        HistoryError["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
-    })(HistoryError = HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
-    let __HistoryErrorValues;
-    (function (__HistoryErrorValues) {
-        __HistoryErrorValues[__HistoryErrorValues["NONE"] = 0] = "NONE";
-        __HistoryErrorValues[__HistoryErrorValues["INVALID_CURSOR"] = 1] = "INVALID_CURSOR";
-        __HistoryErrorValues[__HistoryErrorValues["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
-        __HistoryErrorValues[__HistoryErrorValues["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
-    })(__HistoryErrorValues || (__HistoryErrorValues = {}));
-    (function (HistoryError) {
-        HistoryError.codec = () => {
-            return enumeration(__HistoryErrorValues);
-        };
-    })(HistoryError = HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
-    let _codec;
-    HistoryResponse.codec = () => {
-        if (_codec == null) {
-            _codec = message((obj, w, opts = {}) => {
-                if (opts.lengthDelimited !== false) {
-                    w.fork();
-                }
-                if (obj.messages != null) {
-                    for (const value of obj.messages) {
-                        w.uint32(18);
-                        WakuMessage.codec().encode(value, w);
-                    }
-                }
-                if (obj.pagingInfo != null) {
-                    w.uint32(26);
-                    PagingInfo.codec().encode(obj.pagingInfo, w);
-                }
-                if (obj.error != null && __HistoryErrorValues[obj.error] !== 0) {
-                    w.uint32(32);
-                    HistoryResponse.HistoryError.codec().encode(obj.error, w);
-                }
-                if (opts.lengthDelimited !== false) {
-                    w.ldelim();
-                }
-            }, (reader, length, opts = {}) => {
-                const obj = {
-                    messages: [],
-                    error: HistoryError.NONE
-                };
-                const end = length == null ? reader.len : reader.pos + length;
-                while (reader.pos < end) {
-                    const tag = reader.uint32();
-                    switch (tag >>> 3) {
-                        case 2: {
-                            if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) {
-                                throw new CodeError('decode error - map field "messages" had too many elements', 'ERR_MAX_LENGTH');
+                        case 20: {
+                            if (opts.limits?.messageHashes != null && obj.messageHashes.length === opts.limits.messageHashes) {
+                                throw new CodeError('decode error - map field "messageHashes" had too many elements', 'ERR_MAX_LENGTH');
                             }
-                            obj.messages.push(WakuMessage.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.messages$
-                            }));
+                            obj.messageHashes.push(reader.bytes());
                             break;
                         }
-                        case 3: {
-                            obj.pagingInfo = PagingInfo.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.pagingInfo
-                            });
+                        case 51: {
+                            obj.paginationCursor = reader.bytes();
                             break;
                         }
-                        case 4: {
-                            obj.error = HistoryResponse.HistoryError.codec().decode(reader);
+                        case 52: {
+                            obj.paginationForward = reader.bool();
+                            break;
+                        }
+                        case 53: {
+                            obj.paginationLimit = reader.uint64();
                             break;
                         }
                         default: {
@@ -24205,17 +24032,17 @@ var HistoryResponse;
         }
         return _codec;
     };
-    HistoryResponse.encode = (obj) => {
-        return encodeMessage(obj, HistoryResponse.codec());
+    StoreQueryRequest.encode = (obj) => {
+        return encodeMessage(obj, StoreQueryRequest.codec());
     };
-    HistoryResponse.decode = (buf, opts) => {
-        return decodeMessage(buf, HistoryResponse.codec(), opts);
+    StoreQueryRequest.decode = (buf, opts) => {
+        return decodeMessage(buf, StoreQueryRequest.codec(), opts);
     };
-})(HistoryResponse || (HistoryResponse = {}));
-var HistoryRpc;
-(function (HistoryRpc) {
+})(StoreQueryRequest || (StoreQueryRequest = {}));
+var StoreQueryResponse;
+(function (StoreQueryResponse) {
     let _codec;
-    HistoryRpc.codec = () => {
+    StoreQueryResponse.codec = () => {
         if (_codec == null) {
             _codec = message((obj, w, opts = {}) => {
                 if (opts.lengthDelimited !== false) {
@@ -24225,20 +24052,31 @@ var HistoryRpc;
                     w.uint32(10);
                     w.string(obj.requestId);
                 }
-                if (obj.query != null) {
-                    w.uint32(18);
-                    HistoryQuery.codec().encode(obj.query, w);
+                if (obj.statusCode != null) {
+                    w.uint32(80);
+                    w.uint32(obj.statusCode);
                 }
-                if (obj.response != null) {
-                    w.uint32(26);
-                    HistoryResponse.codec().encode(obj.response, w);
+                if (obj.statusDesc != null) {
+                    w.uint32(90);
+                    w.string(obj.statusDesc);
+                }
+                if (obj.messages != null) {
+                    for (const value of obj.messages) {
+                        w.uint32(162);
+                        WakuMessageKeyValue.codec().encode(value, w);
+                    }
+                }
+                if (obj.paginationCursor != null) {
+                    w.uint32(410);
+                    w.bytes(obj.paginationCursor);
                 }
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
             }, (reader, length, opts = {}) => {
                 const obj = {
-                    requestId: ''
+                    requestId: '',
+                    messages: []
                 };
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
@@ -24248,16 +24086,25 @@ var HistoryRpc;
                             obj.requestId = reader.string();
                             break;
                         }
-                        case 2: {
-                            obj.query = HistoryQuery.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.query
-                            });
+                        case 10: {
+                            obj.statusCode = reader.uint32();
                             break;
                         }
-                        case 3: {
-                            obj.response = HistoryResponse.codec().decode(reader, reader.uint32(), {
-                                limits: opts.limits?.response
-                            });
+                        case 11: {
+                            obj.statusDesc = reader.string();
+                            break;
+                        }
+                        case 20: {
+                            if (opts.limits?.messages != null && obj.messages.length === opts.limits.messages) {
+                                throw new CodeError('decode error - map field "messages" had too many elements', 'ERR_MAX_LENGTH');
+                            }
+                            obj.messages.push(WakuMessageKeyValue.codec().decode(reader, reader.uint32(), {
+                                limits: opts.limits?.messages$
+                            }));
+                            break;
+                        }
+                        case 51: {
+                            obj.paginationCursor = reader.bytes();
                             break;
                         }
                         default: {
@@ -24271,13 +24118,13 @@ var HistoryRpc;
         }
         return _codec;
     };
-    HistoryRpc.encode = (obj) => {
-        return encodeMessage(obj, HistoryRpc.codec());
+    StoreQueryResponse.encode = (obj) => {
+        return encodeMessage(obj, StoreQueryResponse.codec());
     };
-    HistoryRpc.decode = (buf, opts) => {
-        return decodeMessage(buf, HistoryRpc.codec(), opts);
+    StoreQueryResponse.decode = (buf, opts) => {
+        return decodeMessage(buf, StoreQueryResponse.codec(), opts);
     };
-})(HistoryRpc || (HistoryRpc = {}));
+})(StoreQueryResponse || (StoreQueryResponse = {}));
 var RateLimitProof;
 (function (RateLimitProof) {
     let _codec;
@@ -24859,11 +24706,11 @@ class WakuPeerExchange extends BaseProtocol {
      * Make a peer exchange query to a peer
      */
     async query(params) {
-        const { numPeers } = params;
+        const { numPeers, peerId } = params;
         const rpcQuery = PeerExchangeRPC.createRequest({
             numPeers: BigInt(numPeers)
         });
-        const peer = await this.peerStore.get(params.peerId);
+        const peer = await this.peerStore.get(peerId);
         if (!peer) {
             return {
                 peerInfos: null,
@@ -25019,7 +24866,31 @@ class PeerExchangeDiscovery extends TypedEventEmitter {
             }
             const hasPeer = await this.components.peerStore.has(peerId);
             if (hasPeer) {
-                continue;
+                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, {
@@ -25033,6 +24904,9 @@ class PeerExchangeDiscovery extends TypedEventEmitter {
                     metadata: {
                         shardInfo: encodeRelayShard(shardInfo)
                     }
+                }),
+                ...(peerInfo.multiaddrs && {
+                    multiaddrs: peerInfo.multiaddrs
                 })
             });
             log$1.info(`Discovered peer: ${peerId.toString()}`);
@@ -25050,6 +24924,24 @@ class PeerExchangeDiscovery extends TypedEventEmitter {
         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));
+            }
+        }
+        return { hasMultiaddrDiff, hasShardDiff };
+    }
 }
 function wakuPeerExchangeDiscovery(pubsubTopics) {
     return (components) => new PeerExchangeDiscovery(components, pubsubTopics);