@waku/core 0.0.37-7a9850d.0 → 0.0.37-c24842a.0

package/src/lib/connection_manager/shard_reader.ts

@@ -0,0 +1,134 @@
+import type { PeerId } from "@libp2p/interface";
+import type {
+  NetworkConfig,
+  PubsubTopic,
+  ShardInfo,
+  SingleShardInfo,
+  StaticSharding
+} from "@waku/interfaces";
+import {
+  contentTopicToShardIndex,
+  decodeRelayShard,
+  Logger,
+  pubsubTopicToSingleShardInfo
+} from "@waku/utils";
+import { Libp2p } from "libp2p";
+
+const log = new Logger("shard-reader");
+
+type ShardReaderConstructorOptions = {
+  libp2p: Libp2p;
+  networkConfig: NetworkConfig;
+};
+
+interface IShardReader {
+  hasShardInfo(id: PeerId): Promise<boolean>;
+  isPeerOnNetwork(id: PeerId): Promise<boolean>;
+  isPeerOnShard(id: PeerId, shard: SingleShardInfo): Promise<boolean>;
+  isPeerOnTopic(id: PeerId, pubsubTopic: PubsubTopic): Promise<boolean>;
+}
+
+/**
+ * This class is responsible for reading the shard info from the libp2p peer store or from the current node's network config.
+ */
+export class ShardReader implements IShardReader {
+  private readonly libp2p: Libp2p;
+
+  private readonly staticShard: StaticSharding;
+
+  public constructor(options: ShardReaderConstructorOptions) {
+    this.libp2p = options.libp2p;
+
+    this.staticShard = this.getStaticShardFromNetworkConfig(
+      options.networkConfig
+    );
+  }
+
+  public async isPeerOnNetwork(id: PeerId): Promise<boolean> {
+    const shardInfo = await this.getShardInfo(id);
+
+    if (!shardInfo) {
+      return false;
+    }
+
+    const clusterMatch = shardInfo.clusterId === this.staticShard.clusterId;
+    const shardOverlap = this.staticShard.shards.some((s) =>
+      shardInfo.shards.includes(s)
+    );
+
+    return clusterMatch && shardOverlap;
+  }
+
+  public async hasShardInfo(id: PeerId): Promise<boolean> {
+    const shardInfo = await this.getShardInfo(id);
+    return !!shardInfo;
+  }
+
+  public async isPeerOnTopic(
+    id: PeerId,
+    pubsubTopic: PubsubTopic
+  ): Promise<boolean> {
+    try {
+      const shardInfo = pubsubTopicToSingleShardInfo(pubsubTopic);
+      return await this.isPeerOnShard(id, shardInfo);
+    } catch (error) {
+      log.error(
+        `Error comparing pubsub topic ${pubsubTopic} with shard info for ${id}`,
+        error
+      );
+      return false;
+    }
+  }
+
+  public async isPeerOnShard(
+    id: PeerId,
+    shard: SingleShardInfo
+  ): Promise<boolean> {
+    const peerShardInfo = await this.getShardInfo(id);
+
+    if (!peerShardInfo || shard.shard === undefined) {
+      return false;
+    }
+
+    return (
+      peerShardInfo.clusterId === shard.clusterId &&
+      peerShardInfo.shards.includes(shard.shard)
+    );
+  }
+
+  private async getShardInfo(id: PeerId): Promise<ShardInfo | undefined> {
+    try {
+      const peer = await this.libp2p.peerStore.get(id);
+
+      const shardInfoBytes = peer.metadata.get("shardInfo");
+
+      if (!shardInfoBytes) {
+        return undefined;
+      }
+
+      const decodedShardInfo = decodeRelayShard(shardInfoBytes);
+
+      return decodedShardInfo;
+    } catch (error) {
+      log.error(`Error getting shard info for ${id}`, error);
+      return undefined;
+    }
+  }
+
+  private getStaticShardFromNetworkConfig(
+    networkConfig: NetworkConfig
+  ): StaticSharding {
+    if ("shards" in networkConfig) {
+      return networkConfig;
+    }
+
+    const shards = networkConfig.contentTopics.map((topic) =>
+      contentTopicToShardIndex(topic)
+    );
+
+    return {
+      clusterId: networkConfig.clusterId!,
+      shards
+    };
+  }
+}

package/src/lib/connection_manager/utils.ts

@@ -1,4 +1,6 @@
-import type { Peer } from "@libp2p/interface";
+import { isPeerId, type Peer, type PeerId } from "@libp2p/interface";
+import { peerIdFromString } from "@libp2p/peer-id";
+import { Multiaddr, multiaddr, MultiaddrInput } from "@multiformats/multiaddr";
 import { bytesToUtf8 } from "@waku/utils/bytes";
 
 /**
@@ -23,3 +25,27 @@ export const getPeerPing = (peer: Peer | null): number => {
     return -1;
   }
 };
+
+/**
+ * Maps a PeerId or MultiaddrInput to a PeerId or Multiaddr.
+ * @param input - The PeerId or MultiaddrInput to map.
+ * @returns The PeerId or Multiaddr.
+ * @throws {Error} If the input is not a valid PeerId or MultiaddrInput.
+ */
+export const mapToPeerIdOrMultiaddr = (
+  input: PeerId | MultiaddrInput
+): PeerId | Multiaddr => {
+  return isPeerId(input) ? input : multiaddr(input);
+};
+
+/**
+ * Maps a PeerId or MultiaddrInput to a PeerId.
+ * @param input - The PeerId or MultiaddrInput to map.
+ * @returns The PeerId.
+ * @throws {Error} If the input is not a valid PeerId or MultiaddrInput.
+ */
+export const mapToPeerId = (input: PeerId | MultiaddrInput): PeerId => {
+  return isPeerId(input)
+    ? input
+    : peerIdFromString(multiaddr(input).getPeerId()!);
+};

package/src/lib/filter/filter.ts

@@ -22,7 +22,7 @@ import {
   FilterSubscribeRpc
 } from "./filter_rpc.js";
 
-const log = new Logger("filter:v2");
+const log = new Logger("filter-core");
 
 export const FilterCodecs = {
   SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
@@ -37,13 +37,11 @@ type IncomingMessageHandler = (
 
 export class FilterCore {
   private streamManager: StreamManager;
-  private static handleIncomingMessage?: IncomingMessageHandler;
 
   public readonly multicodec = FilterCodecs.SUBSCRIBE;
 
   public constructor(
-    handleIncomingMessage: IncomingMessageHandler,
-    public readonly pubsubTopics: PubsubTopic[],
+    private handleIncomingMessage: IncomingMessageHandler,
     libp2p: Libp2p
   ) {
     this.streamManager = new StreamManager(
@@ -51,29 +49,6 @@ export class FilterCore {
       libp2p.components
     );
 
-    // TODO(weboko): remove when @waku/sdk 0.0.33 is released
-    const prevHandler = FilterCore.handleIncomingMessage;
-    FilterCore.handleIncomingMessage = !prevHandler
-      ? handleIncomingMessage
-      : async (pubsubTopic, message, peerIdStr): Promise<void> => {
-          try {
-            await prevHandler(pubsubTopic, message, peerIdStr);
-          } catch (e) {
-            log.error(
-              "Previous FilterCore incoming message handler failed ",
-              e
-            );
-          }
-
-          try {
-            await handleIncomingMessage(pubsubTopic, message, peerIdStr);
-          } catch (e) {
-            log.error("Present FilterCore incoming message handler failed ", e);
-          }
-
-          return;
-        };
-
     libp2p
       .handle(FilterCodecs.PUSH, this.onRequest.bind(this), {
         maxInboundStreams: 100
@@ -327,7 +302,7 @@ export class FilterCore {
             return;
           }
 
-          await FilterCore.handleIncomingMessage?.(
+          await this.handleIncomingMessage(
             pubsubTopic,
             wakuMessage,
             connection.remotePeer.toString()

package/src/lib/light_push/light_push.ts

@@ -5,7 +5,6 @@ import {
   type IMessage,
   type Libp2p,
   ProtocolError,
-  PubsubTopic,
   type ThisOrThat
 } from "@waku/interfaces";
 import { PushResponse } from "@waku/proto";
@@ -36,10 +35,7 @@ export class LightPushCore {
 
   public readonly multicodec = LightPushCodec;
 
-  public constructor(
-    public readonly pubsubTopics: PubsubTopic[],
-    libp2p: Libp2p
-  ) {
+  public constructor(libp2p: Libp2p) {
     this.streamManager = new StreamManager(LightPushCodec, libp2p.components);
   }
 

package/src/lib/metadata/metadata.ts

@@ -1,16 +1,16 @@
 import type { PeerId } from "@libp2p/interface";
 import { IncomingStreamData } from "@libp2p/interface";
 import {
+  type ClusterId,
   type IMetadata,
   type Libp2pComponents,
   type MetadataQueryResult,
   type PeerIdStr,
   ProtocolError,
-  PubsubTopic,
   type ShardInfo
 } from "@waku/interfaces";
 import { proto_metadata } from "@waku/proto";
-import { encodeRelayShard, Logger, pubsubTopicsToShardInfo } 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";
@@ -30,7 +30,7 @@ class Metadata implements IMetadata {
   public readonly multicodec = MetadataCodec;
 
   public constructor(
-    public pubsubTopics: PubsubTopic[],
+    public clusterId: ClusterId,
     libp2p: Libp2pComponents
   ) {
     this.streamManager = new StreamManager(MetadataCodec, libp2p);
@@ -44,9 +44,10 @@ class Metadata implements IMetadata {
    * Make a metadata query to a peer
    */
   public async query(peerId: PeerId): Promise<MetadataQueryResult> {
-    const request = proto_metadata.WakuMetadataRequest.encode(
-      pubsubTopicsToShardInfo(this.pubsubTopics)
-    );
+    const request = proto_metadata.WakuMetadataRequest.encode({
+      clusterId: this.clusterId,
+      shards: [] // Only services node need to provide shards
+    });
 
     const peer = await this.libp2pComponents.peerStore.get(peerId);
     if (!peer) {
@@ -112,9 +113,10 @@ class Metadata implements IMetadata {
   private async onRequest(streamData: IncomingStreamData): Promise<void> {
     try {
       const { stream, connection } = streamData;
-      const encodedShardInfo = proto_metadata.WakuMetadataResponse.encode(
-        pubsubTopicsToShardInfo(this.pubsubTopics)
-      );
+      const encodedShardInfo = proto_metadata.WakuMetadataResponse.encode({
+        clusterId: this.clusterId,
+        shards: [] // Only service nodes need to provide shards
+      });
 
       const encodedResponse = await pipe(
         [encodedShardInfo],
@@ -178,8 +180,7 @@ class Metadata implements IMetadata {
 }
 
 export function wakuMetadata(
-  pubsubTopics: PubsubTopic[]
+  clusterId: ClusterId
 ): (components: Libp2pComponents) => IMetadata {
-  return (components: Libp2pComponents) =>
-    new Metadata(pubsubTopics, components);
+  return (components: Libp2pComponents) => new Metadata(clusterId, components);
 }