@waku/core 0.0.37-7a9850d.0 → 0.0.37-c7682ea.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);
   }