feat: decouple sharding params out of core

Author: adklempner

packages/core/src/lib/base_protocol.ts

@@ -6,12 +6,7 @@ import type {
   ProtocolCreateOptions,
   PubsubTopic
 } from "@waku/interfaces";
-import { DefaultPubsubTopic } from "@waku/interfaces";
-import {
-  ensureShardingConfigured,
-  Logger,
-  shardInfoToPubsubTopics
-} from "@waku/utils";
+import { ensureShardingConfigured, Logger } from "@waku/utils";
 import {
   getConnectedPeersForProtocolAndShard,
   getPeersForProtocol,
@@ -32,16 +27,14 @@ export class BaseProtocol implements IBaseProtocol {
   public readonly removeLibp2pEventListener: Libp2p["removeEventListener"];
   readonly numPeersToUse: number;
   protected streamManager: StreamManager;
-  protected pubsubTopics: PubsubTopic[];
 
   constructor(
     public multicodec: string,
     private components: Libp2pComponents,
     private log: Logger,
+    protected pubsubTopics: PubsubTopic[],
     private options?: ProtocolCreateOptions
   ) {
-    this.pubsubTopics = this.initializePubsubTopic(options);
-
     this.numPeersToUse = options?.numPeersToUse ?? DEFAULT_NUM_PEERS_TO_USE;
 
     this.addLibp2pEventListener = components.events.addEventListener.bind(
@@ -143,15 +136,4 @@ export class BaseProtocol implements IBaseProtocol {
 
     return sortedFilteredPeers;
   }
-
-  private initializePubsubTopic(
-    options?: ProtocolCreateOptions
-  ): PubsubTopic[] {
-    return (
-      options?.pubsubTopics ??
-      (options?.shardInfo
-        ? shardInfoToPubsubTopics(options.shardInfo)
-        : [DefaultPubsubTopic])
-    );
-  }
 }

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

@@ -358,7 +358,13 @@ class Filter extends BaseProtocol implements IReceiver {
   }
 
   constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
-    super(FilterCodecs.SUBSCRIBE, libp2p.components, log, options);
+    super(
+      FilterCodecs.SUBSCRIBE,
+      libp2p.components,
+      log,
+      options!.pubsubTopics!,
+      options
+    );
 
     libp2p.handle(FilterCodecs.PUSH, this.onRequest.bind(this)).catch((e) => {
       log.error("Failed to register ", FilterCodecs.PUSH, e);
@@ -493,7 +499,7 @@ class Filter extends BaseProtocol implements IReceiver {
 }
 
 export function wakuFilter(
-  init: Partial<ProtocolCreateOptions> = {}
+  init: ProtocolCreateOptions = { pubsubTopics: [] }
 ): (libp2p: Libp2p) => IFilter {
   return (libp2p: Libp2p) => new Filter(libp2p, init);
 }

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

@@ -43,7 +43,13 @@ type PreparePushMessageResult =
  */
 class LightPush extends BaseProtocol implements ILightPush {
   constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
-    super(LightPushCodec, libp2p.components, log, options);
+    super(
+      LightPushCodec,
+      libp2p.components,
+      log,
+      options!.pubsubTopics!,
+      options
+    );
   }
 
   private async preparePushMessage(

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

@@ -4,11 +4,10 @@ import type {
   IMetadata,
   Libp2pComponents,
   PeerIdStr,
-  ShardInfo,
-  ShardingParams
+  ShardInfo
 } from "@waku/interfaces";
 import { proto_metadata } from "@waku/proto";
-import { encodeRelayShard, Logger } from "@waku/utils";
+import { encodeRelayShard, Logger, shardInfoToPubsubTopics } from "@waku/utils";
 import all from "it-all";
 import * as lp from "it-length-prefixed";
 import { pipe } from "it-pipe";
@@ -25,10 +24,15 @@ class Metadata extends BaseProtocol implements IMetadata {
   handshakesConfirmed: Set<PeerIdStr> = new Set();
 
   constructor(
-    public shardInfo: ShardingParams,
+    public shardInfo: ShardInfo,
     libp2p: Libp2pComponents
   ) {
-    super(MetadataCodec, libp2p.components, log, shardInfo && { shardInfo });
+    super(
+      MetadataCodec,
+      libp2p.components,
+      log,
+      shardInfoToPubsubTopics(shardInfo)
+    );
     this.libp2pComponents = libp2p;
     void libp2p.registrar.handle(MetadataCodec, (streamData) => {
       void this.onRequest(streamData);

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

@@ -76,7 +76,7 @@ class Store extends BaseProtocol implements IStore {
   private readonly NUM_PEERS_PROTOCOL = 1;
 
   constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
-    super(StoreCodec, libp2p.components, log, options);
+    super(StoreCodec, libp2p.components, log, options!.pubsubTopics!, options);
   }
 
   /**

packages/core/src/lib/wait_for_remote_peer.ts

@@ -31,11 +31,6 @@ 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 = [];
@@ -49,19 +44,25 @@ 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, metadataService));
+    promises.push(
+      waitForConnectedPeer(waku.store, waku.libp2p.services.metadata)
+    );
   }
 
   if (protocols.includes(Protocols.LightPush)) {
     if (!waku.lightPush)
       throw new Error("Cannot wait for LightPush peer: protocol not mounted");
-    promises.push(waitForConnectedPeer(waku.lightPush, metadataService));
+    promises.push(
+      waitForConnectedPeer(waku.lightPush, waku.libp2p.services.metadata)
+    );
   }
 
   if (protocols.includes(Protocols.Filter)) {
     if (!waku.filter)
       throw new Error("Cannot wait for Filter peer: protocol not mounted");
-    promises.push(waitForConnectedPeer(waku.filter, metadataService));
+    promises.push(
+      waitForConnectedPeer(waku.filter, waku.libp2p.services.metadata)
+    );
   }
 
   if (timeoutMs) {

packages/core/src/lib/waku.ts

@@ -8,11 +8,10 @@ import type {
   IStore,
   Libp2p,
   PubsubTopic,
-  ShardingParams,
   Waku
 } from "@waku/interfaces";
-import { DefaultPubsubTopic, Protocols } from "@waku/interfaces";
-import { Logger, shardInfoToPubsubTopics } from "@waku/utils";
+import { Protocols } from "@waku/interfaces";
+import { Logger } from "@waku/utils";
 
 import { ConnectionManager } from "./connection_manager.js";
 
@@ -42,6 +41,7 @@ export interface WakuOptions {
    * @default {@link @waku/core.DefaultUserAgent}
    */
   userAgent?: string;
+  pubsubTopics: PubsubTopic[];
 }
 
 export class WakuNode implements Waku {
@@ -55,20 +55,16 @@ export class WakuNode implements Waku {
 
   constructor(
     options: WakuOptions,
-    pubsubTopics: PubsubTopic[] = [],
     libp2p: Libp2p,
-    private pubsubShardInfo?: ShardingParams,
     store?: (libp2p: Libp2p) => IStore,
     lightPush?: (libp2p: Libp2p) => ILightPush,
     filter?: (libp2p: Libp2p) => IFilter,
     relay?: (libp2p: Libp2p) => IRelay
   ) {
-    if (!pubsubShardInfo) {
-      this.pubsubTopics =
-        pubsubTopics.length > 0 ? pubsubTopics : [DefaultPubsubTopic];
-    } else {
-      this.pubsubTopics = shardInfoToPubsubTopics(pubsubShardInfo);
+    if (options.pubsubTopics.length == 0) {
+      throw new Error("At least one pubsub topic must be provided");
     }
+    this.pubsubTopics = options.pubsubTopics;
 
     this.libp2p = libp2p;
 
@@ -110,10 +106,6 @@ export class WakuNode implements Waku {
     );
   }
 
-  get shardInfo(): ShardingParams | undefined {
-    return this.pubsubShardInfo;
-  }
-
   /**
    * Dials to the provided peer.
    *

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, ShardingParams } from "./protocols.js";
+import { Protocols } from "./protocols.js";
 import type { IRelay } from "./relay.js";
 import type { IStore } from "./store.js";
 
@@ -16,8 +16,6 @@ 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.ts

@@ -4,7 +4,8 @@ import type {
   IPeerExchange,
   Libp2pComponents,
   PeerExchangeQueryParams,
-  PeerInfo
+  PeerInfo,
+  PubsubTopic
 } from "@waku/interfaces";
 import { isDefined } from "@waku/utils";
 import { Logger } from "@waku/utils";
@@ -26,8 +27,8 @@ export class WakuPeerExchange extends BaseProtocol implements IPeerExchange {
   /**
    * @param components - libp2p components
    */
-  constructor(components: Libp2pComponents) {
-    super(PeerExchangeCodec, components, log);
+  constructor(components: Libp2pComponents, pubsubTopics: PubsubTopic[]) {
+    super(PeerExchangeCodec, components, log, pubsubTopics);
   }
 
   /**
@@ -91,8 +92,9 @@ export class WakuPeerExchange extends BaseProtocol implements IPeerExchange {
  *
  * @returns A function that creates a new peer exchange protocol
  */
-export function wakuPeerExchange(): (
-  components: Libp2pComponents
-) => WakuPeerExchange {
-  return (components: Libp2pComponents) => new WakuPeerExchange(components);
+export function wakuPeerExchange(
+  pubsubTopics: PubsubTopic[]
+): (components: Libp2pComponents) => WakuPeerExchange {
+  return (components: Libp2pComponents) =>
+    new WakuPeerExchange(components, pubsubTopics);
 }

packages/peer-exchange/src/waku_peer_exchange_discovery.ts

@@ -7,7 +7,7 @@ import type {
   PeerId,
   PeerInfo
 } from "@libp2p/interface";
-import { Libp2pComponents, Tags } from "@waku/interfaces";
+import { Libp2pComponents, PubsubTopic, Tags } from "@waku/interfaces";
 import { encodeRelayShard, Logger } from "@waku/utils";
 
 import { PeerExchangeCodec, WakuPeerExchange } from "./waku_peer_exchange.js";
@@ -77,10 +77,14 @@ export class PeerExchangeDiscovery
     );
   };
 
-  constructor(components: Libp2pComponents, options: Options = {}) {
+  constructor(
+    components: Libp2pComponents,
+    pubsubTopics: PubsubTopic[],
+    options: Options = {}
+  ) {
     super();
     this.components = components;
-    this.peerExchange = new WakuPeerExchange(components);
+    this.peerExchange = new WakuPeerExchange(components, pubsubTopics);
     this.options = options;
     this.isStarted = false;
   }
@@ -219,9 +223,9 @@ export class PeerExchangeDiscovery
   }
 }
 
-export function wakuPeerExchangeDiscovery(): (
-  components: Libp2pComponents
-) => PeerExchangeDiscovery {
+export function wakuPeerExchangeDiscovery(
+  pubsubTopics: PubsubTopic[]
+): (components: Libp2pComponents) => PeerExchangeDiscovery {
   return (components: Libp2pComponents) =>
-    new PeerExchangeDiscovery(components);
+    new PeerExchangeDiscovery(components, pubsubTopics);
 }

packages/relay/src/index.ts

@@ -24,11 +24,7 @@ import {
   SendError,
   SendResult
 } from "@waku/interfaces";
-import {
-  isWireSizeUnderCap,
-  shardInfoToPubsubTopics,
-  toAsyncIterator
-} from "@waku/utils";
+import { isWireSizeUnderCap, toAsyncIterator } from "@waku/utils";
 import { pushOrInitMapSet } from "@waku/utils";
 import { Logger } from "@waku/utils";
 
@@ -63,19 +59,15 @@ class Relay implements IRelay {
    */
   private observers: Map<PubsubTopic, Map<ContentTopic, Set<unknown>>>;
 
-  constructor(libp2p: Libp2p, options?: Partial<RelayCreateOptions>) {
+  constructor(libp2p: Libp2p, pubsubTopics: PubsubTopic[]) {
     if (!this.isRelayPubsub(libp2p.services.pubsub)) {
       throw Error(
         `Failed to initialize Relay. libp2p.pubsub does not support ${Relay.multicodec}`
       );
     }
 
     this.gossipSub = libp2p.services.pubsub as GossipSub;
-    this.pubsubTopics = new Set(
-      options?.shardInfo
-        ? shardInfoToPubsubTopics(options.shardInfo)
-        : options?.pubsubTopics ?? [DefaultPubsubTopic]
-    );
+    this.pubsubTopics = new Set(pubsubTopics);
 
     if (this.gossipSub.isStarted()) {
       this.subscribeToAllTopics();
@@ -283,9 +275,9 @@ class Relay implements IRelay {
 }
 
 export function wakuRelay(
-  init: Partial<ProtocolCreateOptions> = {}
+  pubsubTopics: PubsubTopic[]
 ): (libp2p: Libp2p) => IRelay {
-  return (libp2p: Libp2p) => new Relay(libp2p, init);
+  return (libp2p: Libp2p) => new Relay(libp2p, pubsubTopics);
 }
 
 export function wakuGossipSub(