feat!: protocols filter peers as per configured shard (#1756)

* merge: master

* fix: tests

* update: interfafces

* rm: comments

* metadata: store peerIdStr instead of peerId

* chore(utils): move fast-utils to dev deps

* fix: allow autosharding nodes to get peers (#1785)

* fix: merge

* fix: build

* fix: failing tests from master merge

---------

Co-authored-by: Arseniy Klempner <arseniyk@status.im>

package-lock.json

@@ -28010,6 +28010,7 @@
         "@rollup/plugin-node-resolve": "^15.2.3",
         "@waku/build-utils": "*",
         "cspell": "^7.3.2",
+        "fast-check": "^3.14.0",
         "npm-run-all": "^4.1.5",
         "rollup": "^4.9.5"
       },
@@ -32135,6 +32136,7 @@
         "chai": "^4.3.10",
         "cspell": "^7.3.2",
         "debug": "^4.3.4",
+        "fast-check": "^3.14.0",
         "npm-run-all": "^4.1.5",
         "rollup": "^4.9.5",
         "uint8arrays": "^4.0.4"

packages/core/src/index.ts

@@ -14,8 +14,7 @@ export * as waku_filter from "./lib/filter/index.js";
 export { wakuFilter, FilterCodecs } from "./lib/filter/index.js";
 
 export * as waku_light_push from "./lib/light_push/index.js";
-export { LightPushCodec } from "./lib/light_push/index.js";
+export { LightPushCodec, wakuLightPush } from "./lib/light_push/index.js";
-export { wakuLightPush } from "./lib/light_push/index.js";
 
 export * as waku_store from "./lib/store/index.js";
 

packages/core/src/lib/base_protocol.ts

@@ -9,7 +9,7 @@ import type {
 import { DefaultPubsubTopic } from "@waku/interfaces";
 import { Logger, shardInfoToPubsubTopics } from "@waku/utils";
 import {
-  getConnectedPeersForProtocol,
+  getConnectedPeersForProtocolAndShard,
   getPeersForProtocol,
   sortPeersByLatency
 } from "@waku/utils/libp2p";
@@ -25,12 +25,16 @@ export class BaseProtocol implements IBaseProtocol {
   public readonly addLibp2pEventListener: Libp2p["addEventListener"];
   public readonly removeLibp2pEventListener: Libp2p["removeEventListener"];
   protected streamManager: StreamManager;
+  protected pubsubTopics: PubsubTopic[];
 
   constructor(
     public multicodec: string,
     private components: Libp2pComponents,
-    private log: Logger
+    private log: Logger,
+    private options?: ProtocolCreateOptions
   ) {
+    this.pubsubTopics = this.initializePubsubTopic(options);
+
     this.addLibp2pEventListener = components.events.addEventListener.bind(
       components.events
     );
@@ -59,10 +63,19 @@ export class BaseProtocol implements IBaseProtocol {
    * the class protocol. Waku may or may not be currently connected to these
    * peers.
    */
-  public async peers(): Promise<Peer[]> {
+  public async allPeers(): Promise<Peer[]> {
     return getPeersForProtocol(this.peerStore, [this.multicodec]);
   }
 
+  public async connectedPeers(): Promise<Peer[]> {
+    const peers = await this.allPeers();
+    return peers.filter((peer) => {
+      return (
+        this.components.connectionManager.getConnections(peer.id).length > 0
+      );
+    });
+  }
+
   /**
    * Retrieves a list of connected peers that support the protocol. The list is sorted by latency.
    *
@@ -83,16 +96,18 @@ export class BaseProtocol implements IBaseProtocol {
       numPeers: 0
     }
   ): Promise<Peer[]> {
-    // Retrieve all connected peers that support the protocol
+    // Retrieve all connected peers that support the protocol & shard (if configured)
-    const allPeersForProtocol = await getConnectedPeersForProtocol(
+    const connectedPeersForProtocolAndShard =
-      this.components.connectionManager.getConnections(),
+      await getConnectedPeersForProtocolAndShard(
-      this.peerStore,
+        this.components.connectionManager.getConnections(),
-      [this.multicodec]
+        this.peerStore,
-    );
+        [this.multicodec],
+        this.options?.shardInfo
+      );
 
     // Filter the peers based on discovery & number of peers requested
-    const filteredPeers = await filterPeersByDiscovery(
+    const filteredPeers = filterPeersByDiscovery(
-      allPeersForProtocol,
+      connectedPeersForProtocolAndShard,
       numPeers,
       maxBootstrapPeers
     );
@@ -112,7 +127,9 @@ export class BaseProtocol implements IBaseProtocol {
     return sortedFilteredPeers;
   }
 
-  initializePubsubTopic(options?: ProtocolCreateOptions): PubsubTopic[] {
+  private initializePubsubTopic(
+    options?: ProtocolCreateOptions
+  ): PubsubTopic[] {
     return (
       options?.pubsubTopics ??
       (options?.shardInfo

packages/core/src/lib/connection_manager.ts

@@ -1,6 +1,5 @@
 import type { Peer, PeerId, PeerInfo, PeerStore } from "@libp2p/interface";
 import { CustomEvent, TypedEventEmitter } from "@libp2p/interface";
-import { decodeRelayShard } from "@waku/enr";
 import {
   ConnectionManagerOptions,
   EConnectionStateEvents,
@@ -15,7 +14,7 @@ import {
   ShardInfo
 } from "@waku/interfaces";
 import { Libp2p, Tags } from "@waku/interfaces";
-import { shardInfoToPubsubTopics } from "@waku/utils";
+import { decodeRelayShard, shardInfoToPubsubTopics } from "@waku/utils";
 import { Logger } from "@waku/utils";
 
 import { KeepAliveManager } from "./keep_alive_manager.js";
@@ -377,6 +376,8 @@ export class ConnectionManager
     },
     "peer:connect": (evt: CustomEvent<PeerId>): void => {
       void (async () => {
+        log.info(`Connected to peer ${evt.detail.toString()}`);
+
         const peerId = evt.detail;
 
         this.keepAliveManager.start(

packages/core/src/lib/filter/index.ts

@@ -258,7 +258,6 @@ class Subscription {
 }
 
 class Filter extends BaseProtocol implements IReceiver {
-  private readonly pubsubTopics: PubsubTopic[] = [];
   private activeSubscriptions = new Map<string, Subscription>();
   private readonly NUM_PEERS_PROTOCOL = 1;
 
@@ -279,9 +278,7 @@ class Filter extends BaseProtocol implements IReceiver {
   }
 
   constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
-    super(FilterCodecs.SUBSCRIBE, libp2p.components, log);
+    super(FilterCodecs.SUBSCRIBE, libp2p.components, log, options);
-
-    this.pubsubTopics = this.initializePubsubTopic(options);
 
     libp2p.handle(FilterCodecs.PUSH, this.onRequest.bind(this)).catch((e) => {
       log.error("Failed to register ", FilterCodecs.PUSH, e);
@@ -300,8 +297,6 @@ class Filter extends BaseProtocol implements IReceiver {
 
     ensurePubsubTopicIsConfigured(pubsubTopic, this.pubsubTopics);
 
-    //TODO: get a relevant peer for the topic/shard
-    // https://github.com/waku-org/js-waku/pull/1586#discussion_r1336428230
     const peer = (
       await this.getPeers({
         maxBootstrapPeers: 1,

packages/core/src/lib/filterPeers.spec.ts

@@ -27,7 +27,7 @@ describe("filterPeersByDiscovery function", function () {
       }
     ] as unknown as Peer[];
 
-    const result = await filterPeersByDiscovery(mockPeers, 0, 10);
+    const result = filterPeersByDiscovery(mockPeers, 0, 10);
     expect(result.length).to.deep.equal(mockPeers.length);
   });
 
@@ -56,7 +56,7 @@ describe("filterPeersByDiscovery function", function () {
       }
     ] as unknown as Peer[];
 
-    const result = await filterPeersByDiscovery(mockPeers, 0, 0);
+    const result = filterPeersByDiscovery(mockPeers, 0, 0);
 
     // result should have no bootstrap peers, and a total of 2 peers
     expect(result.length).to.equal(2);
@@ -95,7 +95,7 @@ describe("filterPeersByDiscovery function", function () {
       }
     ] as unknown as Peer[];
 
-    const result = await filterPeersByDiscovery(mockPeers, 0, 1);
+    const result = filterPeersByDiscovery(mockPeers, 0, 1);
 
     // result should have 1 bootstrap peers, and a total of 4 peers
     expect(result.length).to.equal(4);
@@ -134,7 +134,7 @@ describe("filterPeersByDiscovery function", function () {
       }
     ] as unknown as Peer[];
 
-    const result = await filterPeersByDiscovery(mockPeers, 5, 2);
+    const result = filterPeersByDiscovery(mockPeers, 5, 2);
 
     // check that result has at least 2 bootstrap peers and no more than 5 peers
     expect(result.length).to.be.at.least(2);

packages/core/src/lib/filterPeers.ts

@@ -10,13 +10,13 @@ import { Tags } from "@waku/interfaces";
  * @param peers - The list of peers to filter from.
  * @param numPeers - The total number of peers to retrieve. If 0, all peers are returned, irrespective of `maxBootstrapPeers`.
  * @param maxBootstrapPeers - The maximum number of bootstrap peers to retrieve.
- * @returns A Promise that resolves to an array of peers based on the specified criteria.
+ * @returns An array of peers based on the specified criteria.
  */
-export async function filterPeersByDiscovery(
+export function filterPeersByDiscovery(
   peers: Peer[],
   numPeers: number,
   maxBootstrapPeers: number
-): Promise<Peer[]> {
+): Peer[] {
   // Collect the bootstrap peers up to the specified maximum
   let bootstrapPeers = peers
     .filter((peer) => peer.tags.has(Tags.BOOTSTRAP))

packages/core/src/lib/light_push/index.ts

@@ -5,7 +5,6 @@ import {
   IMessage,
   Libp2p,
   ProtocolCreateOptions,
-  PubsubTopic,
   SendError,
   SendResult
 } from "@waku/interfaces";
@@ -43,12 +42,10 @@ type PreparePushMessageResult =
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
  */
 class LightPush extends BaseProtocol implements ILightPush {
-  private readonly pubsubTopics: PubsubTopic[];
   private readonly NUM_PEERS_PROTOCOL = 1;
 
   constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
-    super(LightPushCodec, libp2p.components, log);
+    super(LightPushCodec, libp2p.components, log, options);
-    this.pubsubTopics = this.initializePubsubTopic(options);
   }
 
   private async preparePushMessage(
@@ -107,7 +104,6 @@ class LightPush extends BaseProtocol implements ILightPush {
       };
     }
 
-    //TODO: get a relevant peer for the topic/shard
     const peers = await this.getPeers({
       maxBootstrapPeers: 1,
       numPeers: this.NUM_PEERS_PROTOCOL

packages/core/src/lib/metadata/index.ts

@@ -1,14 +1,14 @@
 import type { PeerId } from "@libp2p/interface";
 import { IncomingStreamData } from "@libp2p/interface";
-import { encodeRelayShard } from "@waku/enr";
 import type {
   IMetadata,
   Libp2pComponents,
+  PeerIdStr,
   ShardInfo,
   ShardingParams
 } from "@waku/interfaces";
 import { proto_metadata } from "@waku/proto";
-import { Logger } from "@waku/utils";
+import { encodeRelayShard, Logger } from "@waku/utils";
 import all from "it-all";
 import * as lp from "it-length-prefixed";
 import { pipe } from "it-pipe";
@@ -20,13 +20,16 @@ const log = new Logger("metadata");
 
 export const MetadataCodec = "/vac/waku/metadata/1.0.0";
 
-class Metadata extends BaseProtocol {
+class Metadata extends BaseProtocol implements IMetadata {
-  private readonly shardInfo: ShardingParams;
   private libp2pComponents: Libp2pComponents;
-  constructor(shardInfo: ShardingParams, libp2p: Libp2pComponents) {
+  handshakesConfirmed: Set<PeerIdStr> = new Set();
-    super(MetadataCodec, libp2p.components, log);
+
+  constructor(
+    public shardInfo: ShardingParams,
+    libp2p: Libp2pComponents
+  ) {
+    super(MetadataCodec, libp2p.components, log, shardInfo && { shardInfo });
     this.libp2pComponents = libp2p;
-    this.shardInfo = shardInfo;
     void libp2p.registrar.handle(MetadataCodec, (streamData) => {
       void this.onRequest(streamData);
     });
@@ -53,12 +56,10 @@ class Metadata extends BaseProtocol {
       const remoteShardInfoResponse =
         this.decodeMetadataResponse(encodedResponse);
 
-      // add or update the shardInfo to peer store
+      await this.savePeerShardInfo(
-      await this.libp2pComponents.peerStore.merge(connection.remotePeer, {
+        connection.remotePeer,
-        metadata: {
+        remoteShardInfoResponse
-          shardInfo: encodeRelayShard(remoteShardInfoResponse)
+      );
-        }
-      });
     } catch (error) {
       log.error("Error handling metadata request", error);
     }
@@ -87,9 +88,19 @@ class Metadata extends BaseProtocol {
 
     const decodedResponse = this.decodeMetadataResponse(encodedResponse);
 
+    await this.savePeerShardInfo(peerId, decodedResponse);
+
     return decodedResponse;
   }
 
+  public async confirmOrAttemptHandshake(peerId: PeerId): Promise<void> {
+    if (this.handshakesConfirmed.has(peerId.toString())) return;
+
+    await this.query(peerId);
+
+    return;
+  }
+
   private decodeMetadataResponse(encodedResponse: Uint8ArrayList[]): ShardInfo {
     const bytes = new Uint8ArrayList();
 
@@ -104,6 +115,20 @@ class Metadata extends BaseProtocol {
 
     return response;
   }
+
+  private async savePeerShardInfo(
+    peerId: PeerId,
+    shardInfo: ShardInfo
+  ): Promise<void> {
+    // add or update the shardInfo to peer store
+    await this.libp2pComponents.peerStore.merge(peerId, {
+      metadata: {
+        shardInfo: encodeRelayShard(shardInfo)
+      }
+    });
+
+    this.handshakesConfirmed.add(peerId.toString());
+  }
 }
 
 export function wakuMetadata(

packages/core/src/lib/store/index.ts

@@ -6,8 +6,7 @@ import {
   IDecoder,
   IStore,
   Libp2p,
-  ProtocolCreateOptions,
+  ProtocolCreateOptions
-  PubsubTopic
 } from "@waku/interfaces";
 import { proto_store as proto } from "@waku/proto";
 import { ensurePubsubTopicIsConfigured, isDefined } from "@waku/utils";
@@ -74,12 +73,10 @@ export interface QueryOptions {
  * The Waku Store protocol can be used to retrieved historical messages.
  */
 class Store extends BaseProtocol implements IStore {
-  private readonly pubsubTopics: PubsubTopic[];
   private readonly NUM_PEERS_PROTOCOL = 1;
 
   constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
-    super(StoreCodec, libp2p.components, log);
+    super(StoreCodec, libp2p.components, log, options);
-    this.pubsubTopics = this.initializePubsubTopic(options);
   }
 
   /**

packages/core/src/lib/wait_for_remote_peer.ts

@@ -1,9 +1,8 @@
 import type { IdentifyResult } from "@libp2p/interface";
-import type { IBaseProtocol, IRelay, Waku } from "@waku/interfaces";
+import type { IBaseProtocol, IMetadata, IRelay, Waku } from "@waku/interfaces";
 import { Protocols } from "@waku/interfaces";
 import { Logger } from "@waku/utils";
 import { pEvent } from "p-event";
-
 const log = new Logger("wait-for-remote-peer");
 
 /**
@@ -32,6 +31,11 @@ export async function waitForRemotePeer(
 ): Promise<void> {
   protocols = protocols ?? getEnabledProtocols(waku);
 
+  const isShardingEnabled = waku.shardInfo !== undefined;
+  const metadataService = isShardingEnabled
+    ? waku.libp2p.services.metadata
+    : undefined;
+
   if (!waku.isStarted()) return Promise.reject("Waku node is not started");
 
   const promises = [];
@@ -45,19 +49,19 @@ export async function waitForRemotePeer(
   if (protocols.includes(Protocols.Store)) {
     if (!waku.store)
       throw new Error("Cannot wait for Store peer: protocol not mounted");
-    promises.push(waitForConnectedPeer(waku.store));
+    promises.push(waitForConnectedPeer(waku.store, metadataService));
   }
 
   if (protocols.includes(Protocols.LightPush)) {
     if (!waku.lightPush)
       throw new Error("Cannot wait for LightPush peer: protocol not mounted");
-    promises.push(waitForConnectedPeer(waku.lightPush));
+    promises.push(waitForConnectedPeer(waku.lightPush, metadataService));
   }
 
   if (protocols.includes(Protocols.Filter)) {
     if (!waku.filter)
       throw new Error("Cannot wait for Filter peer: protocol not mounted");
-    promises.push(waitForConnectedPeer(waku.filter));
+    promises.push(waitForConnectedPeer(waku.filter, metadataService));
   }
 
   if (timeoutMs) {
@@ -73,21 +77,62 @@ export async function waitForRemotePeer(
 
 /**
  * Wait for a peer with the given protocol to be connected.
+ * If sharding is enabled on the node, it will also wait for the peer to be confirmed by the metadata service.
  */
-async function waitForConnectedPeer(protocol: IBaseProtocol): Promise<void> {
+async function waitForConnectedPeer(
+  protocol: IBaseProtocol,
+  metadataService?: IMetadata
+): Promise<void> {
   const codec = protocol.multicodec;
-  const peers = await protocol.peers();
+  const peers = await protocol.connectedPeers();
 
   if (peers.length) {
-    log.info(`${codec} peer found: `, peers[0].id.toString());
+    if (!metadataService) {
-    return;
+      log.info(`${codec} peer found: `, peers[0].id.toString());
+      return;
+    }
+
+    // once a peer is connected, we need to confirm the metadata handshake with at least one of those peers if sharding is enabled
+    try {
+      await Promise.any(
+        peers.map((peer) => metadataService.confirmOrAttemptHandshake(peer.id))
+      );
+      return;
+    } catch (e) {
+      if ((e as any).code === "ERR_CONNECTION_BEING_CLOSED")
+        log.error(
+          `Connection with the peer was closed and possibly because it's on a different shard. Error: ${e}`
+        );
+
+      log.error(`Error waiting for handshake confirmation: ${e}`);
+    }
   }
 
+  log.info(`Waiting for ${codec} peer`);
+
+  // else we'll just wait for the next peer to connect
   await new Promise<void>((resolve) => {
     const cb = (evt: CustomEvent<IdentifyResult>): void => {
       if (evt.detail?.protocols?.includes(codec)) {
-        protocol.removeLibp2pEventListener("peer:identify", cb);
+        if (metadataService) {
-        resolve();
+          metadataService
+            .confirmOrAttemptHandshake(evt.detail.peerId)
+            .then(() => {
+              protocol.removeLibp2pEventListener("peer:identify", cb);
+              resolve();
+            })
+            .catch((e) => {
+              if (e.code === "ERR_CONNECTION_BEING_CLOSED")
+                log.error(
+                  `Connection with the peer was closed and possibly because it's on a different shard. Error: ${e}`
+                );
+
+              log.error(`Error waiting for handshake confirmation: ${e}`);
+            });
+        } else {
+          protocol.removeLibp2pEventListener("peer:identify", cb);
+          resolve();
+        }
       }
     };
     protocol.addLibp2pEventListener("peer:identify", cb);

packages/core/src/lib/waku.ts

@@ -57,7 +57,7 @@ export class WakuNode implements Waku {
     options: WakuOptions,
     pubsubTopics: PubsubTopic[] = [],
     libp2p: Libp2p,
-    pubsubShardInfo?: ShardingParams,
+    private pubsubShardInfo?: ShardingParams,
     store?: (libp2p: Libp2p) => IStore,
     lightPush?: (libp2p: Libp2p) => ILightPush,
     filter?: (libp2p: Libp2p) => IFilter,
@@ -110,6 +110,10 @@ export class WakuNode implements Waku {
     );
   }
 
+  get shardInfo(): ShardingParams | undefined {
+    return this.pubsubShardInfo;
+  }
+
   /**
    * Dials to the provided peer.
    *

packages/dns-discovery/src/dns_discovery.ts

@@ -6,14 +6,13 @@ import {
 } from "@libp2p/interface";
 import { peerDiscoverySymbol as symbol } from "@libp2p/interface";
 import type { PeerInfo } from "@libp2p/interface";
-import { encodeRelayShard } from "@waku/enr";
 import type {
   DnsDiscOptions,
   DnsDiscoveryComponents,
   IEnr,
   NodeCapabilityCount
 } from "@waku/interfaces";
-import { Logger } from "@waku/utils";
+import { encodeRelayShard, Logger } from "@waku/utils";
 
 import {
   DEFAULT_BOOTSTRAP_TAG_NAME,

packages/enr/src/enr.spec.ts

@@ -393,7 +393,6 @@ describe("ENR", function () {
 
     it("should properly create peer info with all multiaddrs", () => {
       const peerInfo = enr.peerInfo!;
-      console.log(peerInfo);
       expect(peerInfo.id.toString()).to.equal(peerId.toString());
       expect(peerInfo.multiaddrs.length).to.equal(5);
       expect(peerInfo.multiaddrs.map((ma) => ma.toString())).to.contain(

packages/enr/src/index.ts

@@ -5,4 +5,3 @@ export * from "./enr.js";
 export * from "./peer_id.js";
 export * from "./waku2_codec.js";
 export * from "./crypto.js";
-export * from "./relay_shard_codec.js";

packages/enr/src/raw_enr.ts

@@ -10,11 +10,11 @@ import type {
   ShardInfo,
   Waku2
 } from "@waku/interfaces";
+import { decodeRelayShard } from "@waku/utils";
 import { bytesToUtf8 } from "@waku/utils/bytes";
 
 import { ERR_INVALID_ID } from "./constants.js";
 import { decodeMultiaddrs, encodeMultiaddrs } from "./multiaddrs_codec.js";
-import { decodeRelayShard } from "./relay_shard_codec.js";
 import { decodeWaku2, encodeWaku2 } from "./waku2_codec.js";
 
 export class RawEnr extends Map<ENRKey, ENRValue> {

packages/interfaces/src/metadata.ts

@@ -1,8 +1,11 @@
 import type { PeerId } from "@libp2p/interface";
 
 import type { ShardInfo } from "./enr.js";
-import type { IBaseProtocol } from "./protocols.js";
+import type { IBaseProtocol, ShardingParams } from "./protocols.js";
 
-export interface IMetadata extends IBaseProtocol {
+// IMetadata always has shardInfo defined while it is optionally undefined in IBaseProtocol
+export interface IMetadata extends Omit<IBaseProtocol, "shardInfo"> {
+  shardInfo: ShardingParams;
+  confirmOrAttemptHandshake(peerId: PeerId): Promise<void>;
   query(peerId: PeerId): Promise<ShardInfo | undefined>;
 }

packages/interfaces/src/protocols.ts

@@ -15,9 +15,11 @@ export enum Protocols {
 }
 
 export interface IBaseProtocol {
+  shardInfo?: ShardInfo;
   multicodec: string;
   peerStore: PeerStore;
-  peers: () => Promise<Peer[]>;
+  allPeers: () => Promise<Peer[]>;
+  connectedPeers: () => Promise<Peer[]>;
   addLibp2pEventListener: Libp2p["addEventListener"];
   removeLibp2pEventListener: Libp2p["removeEventListener"];
 }

packages/interfaces/src/waku.ts

@@ -5,7 +5,7 @@ import { IConnectionManager } from "./connection_manager.js";
 import type { IFilter } from "./filter.js";
 import type { Libp2p } from "./libp2p.js";
 import type { ILightPush } from "./light_push.js";
-import { Protocols } from "./protocols.js";
+import { Protocols, ShardingParams } from "./protocols.js";
 import type { IRelay } from "./relay.js";
 import type { IStore } from "./store.js";
 
@@ -16,6 +16,8 @@ export interface Waku {
   filter?: IFilter;
   lightPush?: ILightPush;
 
+  shardInfo?: ShardingParams;
+
   connectionManager: IConnectionManager;
 
   dial(peer: PeerId | Multiaddr, protocols?: Protocols[]): Promise<Stream>;

packages/peer-exchange/src/waku_peer_exchange_discovery.ts

@@ -7,9 +7,8 @@ import type {
   PeerId,
   PeerInfo
 } from "@libp2p/interface";
-import { encodeRelayShard } from "@waku/enr";
 import { Libp2pComponents, Tags } from "@waku/interfaces";
-import { Logger } from "@waku/utils";
+import { encodeRelayShard, Logger } from "@waku/utils";
 
 import { PeerExchangeCodec, WakuPeerExchange } from "./waku_peer_exchange.js";
 

packages/tests/tests/filter/utils.ts

@@ -55,7 +55,8 @@ export async function runNodes(
       filter: true,
       lightpush: true,
       relay: true,
-      pubsubTopic: pubsubTopics
+      pubsubTopic: pubsubTopics,
+      ...(shardInfo && { clusterId: shardInfo.clusterId })
     },
     { retries: 3 }
   );

packages/tests/tests/getPeers.spec.ts

@@ -1,16 +1,403 @@
 import type { Connection, Peer, PeerStore } from "@libp2p/interface";
 import { createSecp256k1PeerId } from "@libp2p/peer-id-factory";
+import { LightPushCodec, waitForRemotePeer } from "@waku/core";
 import {
+  ContentTopicInfo,
   createLightNode,
   Libp2pComponents,
   type LightNode,
+  Protocols,
+  ShardInfo,
   Tags,
   utf8ToBytes
 } from "@waku/sdk";
+import { shardInfoToPubsubTopics } from "@waku/utils";
+import { getConnectedPeersForProtocolAndShard } from "@waku/utils/libp2p";
 import { expect } from "chai";
 import fc from "fast-check";
 import Sinon from "sinon";
 
+import { makeLogFileName, ServiceNode, tearDownNodes } from "../src/index.js";
+
+describe("getConnectedPeersForProtocolAndShard", function () {
+  let waku: LightNode;
+  let serviceNode1: ServiceNode;
+  let serviceNode2: ServiceNode;
+  const contentTopic = "/test/2/waku-light-push/utf8";
+
+  this.beforeEach(async function () {
+    this.timeout(15000);
+    serviceNode1 = new ServiceNode(makeLogFileName(this) + "1");
+    serviceNode2 = new ServiceNode(makeLogFileName(this) + "2");
+  });
+
+  afterEach(async function () {
+    this.timeout(15000);
+    await tearDownNodes([serviceNode1, serviceNode2], waku);
+  });
+
+  it("same cluster, same shard: nodes connect", async function () {
+    this.timeout(15000);
+
+    const shardInfo: ShardInfo = {
+      clusterId: 1,
+      shards: [1]
+    };
+
+    await serviceNode1.start({
+      discv5Discovery: true,
+      peerExchange: true,
+      clusterId: shardInfo.clusterId,
+      pubsubTopic: shardInfoToPubsubTopics(shardInfo),
+      lightpush: true,
+      relay: true
+    });
+
+    const serviceNodeMa = await serviceNode1.getMultiaddrWithId();
+
+    waku = await createLightNode({ shardInfo });
+    await waku.start();
+    await waku.libp2p.dialProtocol(serviceNodeMa, LightPushCodec);
+    await waitForRemotePeer(waku, [Protocols.LightPush]);
+    const peers = await getConnectedPeersForProtocolAndShard(
+      waku.libp2p.getConnections(),
+      waku.libp2p.peerStore,
+      waku.libp2p.getProtocols(),
+      shardInfo
+    );
+    expect(peers.length).to.be.greaterThan(0);
+  });
+
+  it("same cluster, different shard: nodes connect", async function () {
+    this.timeout(15000);
+
+    const shardInfo: ShardInfo = {
+      clusterId: 1,
+      shards: [1]
+    };
+
+    const shardInfoServiceNode: ShardInfo = {
+      clusterId: 1,
+      shards: [2]
+    };
+
+    await serviceNode1.start({
+      discv5Discovery: true,
+      peerExchange: true,
+      clusterId: shardInfoServiceNode.clusterId,
+      pubsubTopic: shardInfoToPubsubTopics(shardInfoServiceNode),
+      lightpush: true,
+      relay: true
+    });
+
+    const serviceNodeMa = await serviceNode1.getMultiaddrWithId();
+
+    waku = await createLightNode({ shardInfo });
+    await waku.libp2p.dialProtocol(serviceNodeMa, LightPushCodec);
+    await waku.start();
+    await waitForRemotePeer(waku, [Protocols.LightPush]);
+
+    const peers = await getConnectedPeersForProtocolAndShard(
+      waku.libp2p.getConnections(),
+      waku.libp2p.peerStore,
+      waku.libp2p.getProtocols(),
+      shardInfo
+    );
+    expect(peers.length).to.be.greaterThan(0);
+  });
+
+  it("different cluster, same shard: nodes don't connect", async function () {
+    this.timeout(15000);
+
+    const shardInfo1: ShardInfo = {
+      clusterId: 1,
+      shards: [1]
+    };
+
+    const shardInfo2: ShardInfo = {
+      clusterId: 2,
+      shards: [1]
+    };
+
+    // we start one node in a separate cluster
+    await serviceNode1.start({
+      discv5Discovery: true,
+      peerExchange: true,
+      clusterId: shardInfo1.clusterId,
+      pubsubTopic: shardInfoToPubsubTopics(shardInfo1),
+      lightpush: true,
+      relay: true
+    });
+
+    // and another node in the same cluster cluster as our node
+    await serviceNode2.start({
+      discv5Discovery: true,
+      peerExchange: true,
+      clusterId: shardInfo2.clusterId,
+      pubsubTopic: shardInfoToPubsubTopics(shardInfo2),
+      lightpush: true,
+      relay: true
+    });
+
+    const serviceNode1Ma = await serviceNode1.getMultiaddrWithId();
+    const serviceNode2Ma = await serviceNode2.getMultiaddrWithId();
+
+    waku = await createLightNode({ shardInfo: shardInfo2 });
+    await waku.libp2p.dialProtocol(serviceNode1Ma, LightPushCodec);
+    await waku.libp2p.dialProtocol(serviceNode2Ma, LightPushCodec);
+
+    await waku.start();
+    await waitForRemotePeer(waku, [Protocols.LightPush]);
+
+    const peers = await getConnectedPeersForProtocolAndShard(
+      waku.libp2p.getConnections(),
+      waku.libp2p.peerStore,
+      waku.libp2p.getProtocols(),
+      shardInfo2
+    );
+    expect(peers.length).to.be.equal(1);
+  });
+
+  it("different cluster, different shard: nodes don't connect", async function () {
+    this.timeout(15000);
+
+    const shardInfo1: ShardInfo = {
+      clusterId: 1,
+      shards: [1]
+    };
+
+    const shardInfo2: ShardInfo = {
+      clusterId: 2,
+      shards: [2]
+    };
+
+    // we start one node in a separate cluster
+    await serviceNode1.start({
+      discv5Discovery: true,
+      peerExchange: true,
+      clusterId: shardInfo1.clusterId,
+      pubsubTopic: shardInfoToPubsubTopics(shardInfo1),
+      lightpush: true,
+      relay: true
+    });
+
+    // and another node in the same cluster cluster as our node
+    const serviceNode2 = new ServiceNode(makeLogFileName(this) + "2");
+    await serviceNode2.start({
+      discv5Discovery: true,
+      peerExchange: true,
+      clusterId: shardInfo2.clusterId,
+      pubsubTopic: shardInfoToPubsubTopics(shardInfo2),
+      lightpush: true,
+      relay: true
+    });
+
+    const serviceNodeMa1 = await serviceNode1.getMultiaddrWithId();
+    const serviceNodeMa2 = await serviceNode2.getMultiaddrWithId();
+
+    waku = await createLightNode({ shardInfo: shardInfo2 });
+    await waku.libp2p.dialProtocol(serviceNodeMa1, LightPushCodec);
+    await waku.libp2p.dialProtocol(serviceNodeMa2, LightPushCodec);
+    await waku.start();
+    await waitForRemotePeer(waku, [Protocols.LightPush]);
+
+    const peers = await getConnectedPeersForProtocolAndShard(
+      waku.libp2p.getConnections(),
+      waku.libp2p.peerStore,
+      waku.libp2p.getProtocols(),
+      shardInfo2
+    );
+    expect(peers.length).to.be.equal(1);
+  });
+
+  it("same cluster, same shard: nodes connect (autosharding)", async function () {
+    this.timeout(15000);
+
+    const shardInfo: ContentTopicInfo = {
+      clusterId: 1,
+      contentTopics: [contentTopic]
+    };
+
+    await serviceNode1.start({
+      discv5Discovery: true,
+      peerExchange: true,
+      clusterId: shardInfo.clusterId,
+      pubsubTopic: shardInfoToPubsubTopics(shardInfo),
+      lightpush: true,
+      relay: true
+    });
+
+    const serviceNodeMa = await serviceNode1.getMultiaddrWithId();
+
+    waku = await createLightNode({ shardInfo });
+    await waku.start();
+    await waku.libp2p.dialProtocol(serviceNodeMa, LightPushCodec);
+    await waitForRemotePeer(waku, [Protocols.LightPush]);
+    const peers = await getConnectedPeersForProtocolAndShard(
+      waku.libp2p.getConnections(),
+      waku.libp2p.peerStore,
+      waku.libp2p.getProtocols(),
+      shardInfo
+    );
+    expect(peers.length).to.be.greaterThan(0);
+  });
+
+  it("same cluster, different shard: nodes connect (autosharding)", async function () {
+    this.timeout(15000);
+
+    const shardInfo1: ContentTopicInfo = {
+      clusterId: 1,
+      contentTopics: [contentTopic]
+    };
+
+    const shardInfo2: ContentTopicInfo = {
+      clusterId: 1,
+      contentTopics: ["/test/5/waku-light-push/utf8"]
+    };
+
+    // Separate shard
+    await serviceNode1.start({
+      discv5Discovery: true,
+      peerExchange: true,
+      clusterId: shardInfo1.clusterId,
+      pubsubTopic: shardInfoToPubsubTopics(shardInfo1),
+      lightpush: true,
+      relay: true
+    });
+
+    // Same shard
+    await serviceNode2.start({
+      discv5Discovery: true,
+      peerExchange: true,
+      clusterId: shardInfo2.clusterId,
+      pubsubTopic: shardInfoToPubsubTopics(shardInfo2),
+      lightpush: true,
+      relay: true
+    });
+
+    const serviceNode1Ma = await serviceNode1.getMultiaddrWithId();
+    const serviceNode2Ma = await serviceNode2.getMultiaddrWithId();
+
+    waku = await createLightNode({ shardInfo: shardInfo2 });
+    await waku.libp2p.dialProtocol(serviceNode1Ma, LightPushCodec);
+    await waku.libp2p.dialProtocol(serviceNode2Ma, LightPushCodec);
+
+    await waku.start();
+    await waitForRemotePeer(waku, [Protocols.LightPush]);
+
+    const peers = await getConnectedPeersForProtocolAndShard(
+      waku.libp2p.getConnections(),
+      waku.libp2p.peerStore,
+      waku.libp2p.getProtocols(),
+      shardInfo2
+    );
+    expect(peers.length).to.be.equal(1);
+  });
+
+  it("different cluster, same shard: nodes don't connect (autosharding)", async function () {
+    this.timeout(15000);
+
+    const shardInfo1: ContentTopicInfo = {
+      clusterId: 1,
+      contentTopics: [contentTopic]
+    };
+
+    const shardInfo2: ContentTopicInfo = {
+      clusterId: 2,
+      contentTopics: [contentTopic]
+    };
+
+    // we start one node in a separate cluster
+    await serviceNode1.start({
+      discv5Discovery: true,
+      peerExchange: true,
+      clusterId: shardInfo1.clusterId,
+      pubsubTopic: shardInfoToPubsubTopics(shardInfo1),
+      lightpush: true,
+      relay: true
+    });
+
+    // and another node in the same cluster cluster as our node
+    await serviceNode2.start({
+      discv5Discovery: true,
+      peerExchange: true,
+      clusterId: shardInfo2.clusterId,
+      pubsubTopic: shardInfoToPubsubTopics(shardInfo2),
+      lightpush: true,
+      relay: true
+    });
+
+    const serviceNode1Ma = await serviceNode1.getMultiaddrWithId();
+    const serviceNode2Ma = await serviceNode2.getMultiaddrWithId();
+
+    waku = await createLightNode({ shardInfo: shardInfo2 });
+    await waku.libp2p.dialProtocol(serviceNode1Ma, LightPushCodec);
+    await waku.libp2p.dialProtocol(serviceNode2Ma, LightPushCodec);
+
+    await waku.start();
+    await waitForRemotePeer(waku, [Protocols.LightPush]);
+
+    const peers = await getConnectedPeersForProtocolAndShard(
+      waku.libp2p.getConnections(),
+      waku.libp2p.peerStore,
+      waku.libp2p.getProtocols(),
+      shardInfo2
+    );
+    expect(peers.length).to.be.equal(1);
+  });
+
+  it("different cluster, different shard: nodes don't connect (autosharding)", async function () {
+    this.timeout(15000);
+
+    const shardInfo1: ContentTopicInfo = {
+      clusterId: 1,
+      contentTopics: [contentTopic]
+    };
+
+    const shardInfo2: ContentTopicInfo = {
+      clusterId: 2,
+      contentTopics: ["/test/5/waku-light-push/utf8"]
+    };
+
+    // we start one node in a separate cluster
+    await serviceNode1.start({
+      discv5Discovery: true,
+      peerExchange: true,
+      clusterId: shardInfo1.clusterId,
+      pubsubTopic: shardInfoToPubsubTopics(shardInfo1),
+      lightpush: true,
+      relay: true
+    });
+
+    // and another node in the same cluster cluster as our node
+    const serviceNode2 = new ServiceNode(makeLogFileName(this) + "2");
+    await serviceNode2.start({
+      discv5Discovery: true,
+      peerExchange: true,
+      clusterId: shardInfo2.clusterId,
+      pubsubTopic: shardInfoToPubsubTopics(shardInfo2),
+      lightpush: true,
+      relay: true
+    });
+
+    const serviceNodeMa1 = await serviceNode1.getMultiaddrWithId();
+    const serviceNodeMa2 = await serviceNode2.getMultiaddrWithId();
+
+    waku = await createLightNode({ shardInfo: shardInfo2 });
+    await waku.libp2p.dialProtocol(serviceNodeMa1, LightPushCodec);
+    await waku.libp2p.dialProtocol(serviceNodeMa2, LightPushCodec);
+    await waku.start();
+    await waitForRemotePeer(waku, [Protocols.LightPush]);
+
+    const peers = await getConnectedPeersForProtocolAndShard(
+      waku.libp2p.getConnections(),
+      waku.libp2p.peerStore,
+      waku.libp2p.getProtocols(),
+      shardInfo2
+    );
+    expect(peers.length).to.be.equal(1);
+  });
+});
 describe("getPeers", function () {
   let peerStore: PeerStore;
   let connectionManager: Libp2pComponents["connectionManager"];

packages/tests/tests/light-push/single_node/multiple_pubsub.node.spec.ts

@@ -33,10 +33,7 @@ describe("Waku Light Push : Multiple PubsubTopics", function () {
     clusterId: 3,
     shard: 1
   });
-  const customPubsubTopic2 = singleShardInfoToPubsubTopic({
+
-    clusterId: 3,
-    shard: 2
-  });
   const shardInfo: ShardInfo = { clusterId: 3, shards: [1, 2] };
   const singleShardInfo1: SingleShardInfo = { clusterId: 3, shard: 1 };
   const singleShardInfo2: SingleShardInfo = { clusterId: 3, shard: 2 };
@@ -57,7 +54,10 @@ describe("Waku Light Push : Multiple PubsubTopics", function () {
     this.timeout(15000);
     [nwaku, waku] = await runNodes(
       this,
-      [customPubsubTopic1, customPubsubTopic2],
+      [
+        singleShardInfoToPubsubTopic(singleShardInfo1),
+        singleShardInfoToPubsubTopic(singleShardInfo2)
+      ],
       shardInfo
     );
     messageCollector = new MessageCollector(nwaku);
@@ -107,7 +107,7 @@ describe("Waku Light Push : Multiple PubsubTopics", function () {
 
     expect(
       await messageCollector2.waitForMessages(1, {
-        pubsubTopic: customPubsubTopic2
+        pubsubTopic: singleShardInfoToPubsubTopic(singleShardInfo2)
       })
     ).to.eq(true);
 
@@ -130,9 +130,12 @@ describe("Waku Light Push : Multiple PubsubTopics", function () {
       filter: true,
       lightpush: true,
       relay: true,
-      pubsubTopic: [customPubsubTopic2]
+      pubsubTopic: [singleShardInfoToPubsubTopic(singleShardInfo2)],
+      clusterId: singleShardInfo2.clusterId
     });
-    await nwaku2.ensureSubscriptions([customPubsubTopic2]);
+    await nwaku2.ensureSubscriptions([
+      singleShardInfoToPubsubTopic(singleShardInfo2)
+    ]);
     await waku.dial(await nwaku2.getMultiaddrWithId());
     await waitForRemotePeer(waku, [Protocols.LightPush]);
 
@@ -147,7 +150,7 @@ describe("Waku Light Push : Multiple PubsubTopics", function () {
         pubsubTopic: customPubsubTopic1
       })) ||
       !(await messageCollector2.waitForMessages(1, {
-        pubsubTopic: customPubsubTopic2
+        pubsubTopic: singleShardInfoToPubsubTopic(singleShardInfo2)
       })) ||
       pushResponse1!.recipients[0].toString() ===
         pushResponse2!.recipients[0].toString()
@@ -168,7 +171,7 @@ describe("Waku Light Push : Multiple PubsubTopics", function () {
     messageCollector2.verifyReceivedMessage(0, {
       expectedMessageText: "M2",
       expectedContentTopic: customContentTopic2,
-      expectedPubsubTopic: customPubsubTopic2
+      expectedPubsubTopic: singleShardInfoToPubsubTopic(singleShardInfo2)
     });
   });
 });
@@ -286,7 +289,8 @@ describe("Waku Light Push (Autosharding): Multiple PubsubTopics", function () {
       filter: true,
       lightpush: true,
       relay: true,
-      pubsubTopic: [autoshardingPubsubTopic2]
+      pubsubTopic: [autoshardingPubsubTopic2],
+      clusterId: shardInfo.clusterId
     });
     await nwaku2.ensureSubscriptionsAutosharding([customContentTopic2]);
     await waku.dial(await nwaku2.getMultiaddrWithId());
@@ -349,10 +353,6 @@ describe("Waku Light Push (named sharding): Multiple PubsubTopics", function ()
     customContentTopic2,
     clusterId
   );
-  const contentTopicInfo: ContentTopicInfo = {
-    clusterId,
-    contentTopics: [customContentTopic1, customContentTopic2]
-  };
   const customEncoder1 = createEncoder({
     contentTopic: customContentTopic1,
     pubsubTopicShardInfo: {
@@ -368,11 +368,10 @@ describe("Waku Light Push (named sharding): Multiple PubsubTopics", function ()
 
   this.beforeEach(async function () {
     this.timeout(15000);
-    [nwaku, waku] = await runNodes(
+    [nwaku, waku] = await runNodes(this, [
-      this,
+      autoshardingPubsubTopic1,
-      [autoshardingPubsubTopic1, autoshardingPubsubTopic2],
+      autoshardingPubsubTopic2
-      contentTopicInfo
+    ]);
-    );
     messageCollector = new MessageCollector(nwaku);
     nimPeerId = await nwaku.getPeerId();
   });

packages/tests/tests/light-push/utils.ts

@@ -24,7 +24,12 @@ export async function runNodes(
 ): Promise<[ServiceNode, LightNode]> {
   const nwaku = new ServiceNode(makeLogFileName(context));
   await nwaku.start(
-    { lightpush: true, relay: true, pubsubTopic: pubsubTopics },
+    {
+      lightpush: true,
+      relay: true,
+      pubsubTopic: pubsubTopics,
+      ...(shardInfo && { clusterId: shardInfo.clusterId })
+    },
     { retries: 3 }
   );
 

packages/tests/tests/metadata.spec.ts

@@ -1,7 +1,7 @@
 import { MetadataCodec } from "@waku/core";
-import { decodeRelayShard } from "@waku/enr";
 import type { LightNode, ShardInfo } from "@waku/interfaces";
 import { createLightNode } from "@waku/sdk";
+import { decodeRelayShard } from "@waku/utils";
 import { shardInfoToPubsubTopics } from "@waku/utils";
 import chai, { expect } from "chai";
 import chaiAsPromised from "chai-as-promised";

packages/tests/tests/store/multiple_pubsub.spec.ts

@@ -1,7 +1,10 @@
 import { createDecoder, waitForRemotePeer } from "@waku/core";
 import type { ContentTopicInfo, IMessage, LightNode } from "@waku/interfaces";
 import { createLightNode, Protocols } from "@waku/sdk";
-import { contentTopicToPubsubTopic } from "@waku/utils";
+import {
+  contentTopicToPubsubTopic,
+  singleShardInfosToShardInfo
+} from "@waku/utils";
 import { expect } from "chai";
 
 import {
@@ -18,6 +21,8 @@ import {
   customDecoder2,
   customShardedPubsubTopic1,
   customShardedPubsubTopic2,
+  customShardInfo1,
+  customShardInfo2,
   processQueriedMessages,
   sendMessages,
   sendMessagesAutosharding,
@@ -39,6 +44,7 @@ describe("Waku Store, custom pubsub topic", function () {
     await nwaku.start({
       store: true,
       pubsubTopic: [customShardedPubsubTopic1, customShardedPubsubTopic2],
+      clusterId: customShardInfo1.clusterId,
       relay: true
     });
     await nwaku.ensureSubscriptions([
@@ -123,6 +129,7 @@ describe("Waku Store, custom pubsub topic", function () {
     await nwaku2.start({
       store: true,
       pubsubTopic: [customShardedPubsubTopic2],
+      clusterId: customShardInfo2.clusterId,
       relay: true
     });
     await nwaku2.ensureSubscriptions([customShardedPubsubTopic2]);
@@ -210,7 +217,8 @@ describe("Waku Store (Autosharding), custom pubsub topic", function () {
     await nwaku.start({
       store: true,
       pubsubTopic: [autoshardingPubsubTopic1, autoshardingPubsubTopic2],
-      relay: true
+      relay: true,
+      clusterId
     });
     await nwaku.ensureSubscriptionsAutosharding([
       customContentTopic1,
@@ -283,7 +291,8 @@ describe("Waku Store (Autosharding), custom pubsub topic", function () {
     await nwaku2.start({
       store: true,
       pubsubTopic: [autoshardingPubsubTopic2],
-      relay: true
+      relay: true,
+      clusterId
     });
     await nwaku2.ensureSubscriptionsAutosharding([customContentTopic2]);
 
@@ -339,11 +348,18 @@ describe("Waku Store (named sharding), custom pubsub topic", function () {
 
   beforeEach(async function () {
     this.timeout(15000);
+
+    const shardInfo = singleShardInfosToShardInfo([
+      customShardInfo1,
+      customShardInfo2
+    ]);
+
     nwaku = new ServiceNode(makeLogFileName(this));
     await nwaku.start({
       store: true,
       relay: true,
-      pubsubTopic: [customShardedPubsubTopic1, customShardedPubsubTopic2]
+      pubsubTopic: [customShardedPubsubTopic1, customShardedPubsubTopic2],
+      clusterId: shardInfo.clusterId
     });
     await nwaku.ensureSubscriptions([
       customShardedPubsubTopic1,
@@ -353,10 +369,7 @@ describe("Waku Store (named sharding), custom pubsub topic", function () {
     waku = await startAndConnectLightNode(
       nwaku,
       [customShardedPubsubTopic1, customShardedPubsubTopic2],
-      {
+      shardInfo
-        clusterId: 3,
-        shards: [1, 2]
-      }
     );
   });
 
@@ -434,7 +447,8 @@ describe("Waku Store (named sharding), custom pubsub topic", function () {
     await nwaku2.start({
       store: true,
       pubsubTopic: [customShardedPubsubTopic2],
-      relay: true
+      relay: true,
+      clusterId: customShardInfo2.clusterId
     });
     await nwaku2.ensureSubscriptions([customShardedPubsubTopic2]);
 

packages/tests/tests/store/utils.ts

@@ -10,7 +10,8 @@ import {
   LightNode,
   Protocols,
   ShardInfo,
-  ShardingParams
+  ShardingParams,
+  type SingleShardInfo
 } from "@waku/interfaces";
 import { createLightNode } from "@waku/sdk";
 import { Logger, singleShardInfoToPubsubTopic } from "@waku/utils";
@@ -23,14 +24,13 @@ export const log = new Logger("test:store");
 export const TestContentTopic = "/test/1/waku-store/utf8";
 export const TestEncoder = createEncoder({ contentTopic: TestContentTopic });
 export const TestDecoder = createDecoder(TestContentTopic);
-export const customShardedPubsubTopic1 = singleShardInfoToPubsubTopic({
+export const customShardInfo1: SingleShardInfo = { clusterId: 3, shard: 1 };
-  clusterId: 3,
+export const customShardedPubsubTopic1 =
-  shard: 1
+  singleShardInfoToPubsubTopic(customShardInfo1);
-});
+
-export const customShardedPubsubTopic2 = singleShardInfoToPubsubTopic({
+export const customShardInfo2: SingleShardInfo = { clusterId: 3, shard: 2 };
-  clusterId: 3,
+export const customShardedPubsubTopic2 =
-  shard: 2
+  singleShardInfoToPubsubTopic(customShardInfo2);
-});
 export const shardInfo1: ShardInfo = { clusterId: 3, shards: [1] };
 export const customContentTopic1 = "/test/2/waku-store/utf8";
 export const customContentTopic2 = "/test/3/waku-store/utf8";

packages/tests/tests/wait_for_remote_peer.node.spec.ts

@@ -115,7 +115,9 @@ describe("Wait for remote peer", function () {
     await delay(1000);
     await waitForRemotePeer(waku2, [Protocols.Store]);
 
-    const peers = (await waku2.store.peers()).map((peer) => peer.id.toString());
+    const peers = (await waku2.store.connectedPeers()).map((peer) =>
+      peer.id.toString()
+    );
     const nimPeerId = multiAddrWithId.getPeerId();
 
     expect(nimPeerId).to.not.be.undefined;
@@ -142,7 +144,9 @@ describe("Wait for remote peer", function () {
     await waku2.dial(multiAddrWithId);
     await waitPromise;
 
-    const peers = (await waku2.store.peers()).map((peer) => peer.id.toString());
+    const peers = (await waku2.store.connectedPeers()).map((peer) =>
+      peer.id.toString()
+    );
 
     const nimPeerId = multiAddrWithId.getPeerId();
 
@@ -168,7 +172,7 @@ describe("Wait for remote peer", function () {
     await waku2.dial(multiAddrWithId);
     await waitForRemotePeer(waku2, [Protocols.LightPush]);
 
-    const peers = (await waku2.lightPush.peers()).map((peer) =>
+    const peers = (await waku2.lightPush.connectedPeers()).map((peer) =>
       peer.id.toString()
     );
 
@@ -196,7 +200,7 @@ describe("Wait for remote peer", function () {
     await waku2.dial(multiAddrWithId);
     await waitForRemotePeer(waku2, [Protocols.Filter]);
 
-    const peers = (await waku2.filter.peers()).map((peer) =>
+    const peers = (await waku2.filter.connectedPeers()).map((peer) =>
       peer.id.toString()
     );
 
@@ -228,14 +232,14 @@ describe("Wait for remote peer", function () {
       Protocols.LightPush
     ]);
 
-    const filterPeers = (await waku2.filter.peers()).map((peer) =>
+    const filterPeers = (await waku2.filter.connectedPeers()).map((peer) =>
       peer.id.toString()
     );
-    const storePeers = (await waku2.store.peers()).map((peer) =>
+    const storePeers = (await waku2.store.connectedPeers()).map((peer) =>
       peer.id.toString()
     );
-    const lightPushPeers = (await waku2.lightPush.peers()).map((peer) =>
+    const lightPushPeers = (await waku2.lightPush.connectedPeers()).map(
-      peer.id.toString()
+      (peer) => peer.id.toString()
     );
 
     const nimPeerId = multiAddrWithId.getPeerId();

packages/utils/package.json

@@ -80,6 +80,7 @@
     "@waku/build-utils": "*",
     "cspell": "^7.3.2",
     "npm-run-all": "^4.1.5",
+    "fast-check": "^3.14.0",
     "rollup": "^4.9.5"
   },
   "files": [

packages/utils/src/common/index.ts

@@ -5,6 +5,7 @@ export * from "./to_async_iterator.js";
 export * from "./is_size_valid.js";
 export * from "./sharding.js";
 export * from "./push_or_init_map.js";
+export * from "./relay_shard_codec.js";
 
 export function removeItemFromArray(arr: unknown[], value: unknown): unknown[] {
   const index = arr.indexOf(value);

packages/utils/src/common/sharding.ts

@@ -2,6 +2,7 @@ import { sha256 } from "@noble/hashes/sha256";
 import {
   DefaultPubsubTopic,
   PubsubTopic,
+  ShardInfo,
   ShardingParams,
   SingleShardInfo
 } from "@waku/interfaces";
@@ -17,11 +18,32 @@ export const singleShardInfoToPubsubTopic = (
   return `/waku/2/rs/${shardInfo.clusterId}/${shardInfo.shard}`;
 };
 
+export const singleShardInfosToShardInfo = (
+  singleShardInfos: SingleShardInfo[]
+): ShardInfo => {
+  if (singleShardInfos.length === 0) throw new Error("Invalid shard");
+
+  const clusterIds = singleShardInfos.map((shardInfo) => shardInfo.clusterId);
+  if (new Set(clusterIds).size !== 1) {
+    throw new Error("Passed shard infos have different clusterIds");
+  }
+
+  const shards = singleShardInfos
+    .map((shardInfo) => shardInfo.shard)
+    .filter((shard): shard is number => shard !== undefined);
+
+  return {
+    clusterId: singleShardInfos[0].clusterId,
+    shards
+  };
+};
+
 export const shardInfoToPubsubTopics = (
   shardInfo: ShardingParams
 ): PubsubTopic[] => {
   if (shardInfo.clusterId === undefined)
     throw new Error("Cluster ID must be specified");
+
   if ("contentTopics" in shardInfo) {
     // Autosharding: explicitly defined content topics
     return Array.from(

packages/utils/src/libp2p/index.ts

@@ -1,6 +1,8 @@
 import type { Connection, Peer, PeerStore } from "@libp2p/interface";
+import { ShardingParams } from "@waku/interfaces";
 
 import { bytesToUtf8 } from "../bytes/index.js";
+import { decodeRelayShard } from "../common/relay_shard_codec.js";
 
 /**
  * Returns a pseudo-random peer that supports the given protocol.
@@ -68,10 +70,11 @@ export async function getPeersForProtocol(
   return peers;
 }
 
-export async function getConnectedPeersForProtocol(
+export async function getConnectedPeersForProtocolAndShard(
   connections: Connection[],
   peerStore: PeerStore,
-  protocols: string[]
+  protocols: string[],
+  shardInfo?: ShardingParams
 ): Promise<Peer[]> {
   const openConnections = connections.filter(
     (connection) => connection.status === "open"
@@ -79,10 +82,24 @@ export async function getConnectedPeersForProtocol(
 
   const peerPromises = openConnections.map(async (connection) => {
     const peer = await peerStore.get(connection.remotePeer);
-    const supportsProtocol = peer.protocols.some((protocol) =>
+    const supportsProtocol = protocols.some((protocol) =>
-      protocols.includes(protocol)
+      peer.protocols.includes(protocol)
     );
-    return supportsProtocol ? peer : null;
+
+    if (supportsProtocol) {
+      if (shardInfo) {
+        const encodedPeerShardInfo = peer.metadata.get("shardInfo");
+        const peerShardInfo =
+          encodedPeerShardInfo && decodeRelayShard(encodedPeerShardInfo);
+
+        if (peerShardInfo && shardInfo.clusterId === peerShardInfo.clusterId) {
+          return peer;
+        }
+      } else {
+        return peer;
+      }
+    }
+    return null;
   });
 
   const peersWithNulls = await Promise.all(peerPromises);