@waku/core 0.0.26-7eb3375.0 → 0.0.27

package/src/lib/message/version_0.ts

@@ -7,12 +7,11 @@ import type {
   IMetaSetter,
   IProtoMessage,
   IRateLimitProof,
-  PubsubTopic
+  PubsubTopic,
+  SingleShardInfo
 } from "@waku/interfaces";
 import { proto_message as proto } from "@waku/proto";
-import { Logger } from "@waku/utils";
-
-import { DefaultPubsubTopic } from "../constants.js";
+import { determinePubsubTopic, Logger } from "@waku/utils";
 
 const log = new Logger("message:version-0");
 const OneMillion = BigInt(1_000_000);
@@ -119,12 +118,18 @@ export class Encoder implements IEncoder {
  * messages.
  */
 export function createEncoder({
-  pubsubTopic = DefaultPubsubTopic,
+  pubsubTopic,
+  pubsubTopicShardInfo,
   contentTopic,
   ephemeral,
   metaSetter
 }: EncoderOptions): Encoder {
-  return new Encoder(contentTopic, ephemeral, pubsubTopic, metaSetter);
+  return new Encoder(
+    contentTopic,
+    ephemeral,
+    determinePubsubTopic(contentTopic, pubsubTopic ?? pubsubTopicShardInfo),
+    metaSetter
+  );
 }
 
 export class Decoder implements IDecoder<DecodedMessage> {
@@ -182,7 +187,10 @@ export class Decoder implements IDecoder<DecodedMessage> {
  */
 export function createDecoder(
   contentTopic: string,
-  pubsubTopic: PubsubTopic = DefaultPubsubTopic
+  pubsubTopicShardInfo?: SingleShardInfo | PubsubTopic
 ): Decoder {
-  return new Decoder(pubsubTopic, contentTopic);
+  return new Decoder(
+    determinePubsubTopic(contentTopic, pubsubTopicShardInfo),
+    contentTopic
+  );
 }

package/src/lib/metadata/index.ts

@@ -0,0 +1,142 @@
+import type { PeerId } from "@libp2p/interface";
+import { IncomingStreamData } from "@libp2p/interface";
+import type {
+  IMetadata,
+  Libp2pComponents,
+  PeerIdStr,
+  ShardInfo
+} from "@waku/interfaces";
+import { proto_metadata } from "@waku/proto";
+import { encodeRelayShard, Logger, shardInfoToPubsubTopics } from "@waku/utils";
+import all from "it-all";
+import * as lp from "it-length-prefixed";
+import { pipe } from "it-pipe";
+import { Uint8ArrayList } from "uint8arraylist";
+
+import { BaseProtocol } from "../base_protocol.js";
+
+const log = new Logger("metadata");
+
+export const MetadataCodec = "/vac/waku/metadata/1.0.0";
+
+class Metadata extends BaseProtocol implements IMetadata {
+  private libp2pComponents: Libp2pComponents;
+  handshakesConfirmed: Set<PeerIdStr> = new Set();
+
+  constructor(
+    public shardInfo: ShardInfo,
+    libp2p: Libp2pComponents
+  ) {
+    super(
+      MetadataCodec,
+      libp2p.components,
+      log,
+      shardInfoToPubsubTopics(shardInfo)
+    );
+    this.libp2pComponents = libp2p;
+    void libp2p.registrar.handle(MetadataCodec, (streamData) => {
+      void this.onRequest(streamData);
+    });
+  }
+
+  /**
+   * Handle an incoming metadata request
+   */
+  private async onRequest(streamData: IncomingStreamData): Promise<void> {
+    try {
+      const { stream, connection } = streamData;
+      const encodedShardInfo = proto_metadata.WakuMetadataResponse.encode(
+        this.shardInfo
+      );
+
+      const encodedResponse = await pipe(
+        [encodedShardInfo],
+        lp.encode,
+        stream,
+        lp.decode,
+        async (source) => await all(source)
+      );
+
+      const remoteShardInfoResponse =
+        this.decodeMetadataResponse(encodedResponse);
+
+      await this.savePeerShardInfo(
+        connection.remotePeer,
+        remoteShardInfoResponse
+      );
+    } catch (error) {
+      log.error("Error handling metadata request", error);
+    }
+  }
+
+  /**
+   * Make a metadata query to a peer
+   */
+  async query(peerId: PeerId): Promise<ShardInfo> {
+    const request = proto_metadata.WakuMetadataRequest.encode(this.shardInfo);
+
+    const peer = await this.peerStore.get(peerId);
+    if (!peer) {
+      throw new Error(`Peer ${peerId.toString()} not found`);
+    }
+
+    const stream = await this.getStream(peer);
+
+    const encodedResponse = await pipe(
+      [request],
+      lp.encode,
+      stream,
+      lp.decode,
+      async (source) => await all(source)
+    );
+
+    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();
+
+    encodedResponse.forEach((chunk) => {
+      bytes.append(chunk);
+    });
+    const response = proto_metadata.WakuMetadataResponse.decode(
+      bytes
+    ) as ShardInfo;
+
+    if (!response) log.error("Error decoding metadata response");
+
+    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(
+  shardInfo: ShardInfo
+): (components: Libp2pComponents) => IMetadata {
+  return (components: Libp2pComponents) => new Metadata(shardInfo, components);
+}

package/src/lib/store/index.ts

@@ -1,4 +1,4 @@
-import type { Stream } from "@libp2p/interface/connection";
+import type { Stream } from "@libp2p/interface";
 import { sha256 } from "@noble/hashes/sha256";
 import {
   Cursor,
@@ -6,8 +6,7 @@ import {
   IDecoder,
   IStore,
   Libp2p,
-  ProtocolCreateOptions,
-  PubsubTopic
+  ProtocolCreateOptions
 } from "@waku/interfaces";
 import { proto_store as proto } from "@waku/proto";
 import { ensurePubsubTopicIsConfigured, isDefined } from "@waku/utils";
@@ -19,7 +18,6 @@ import { pipe } from "it-pipe";
 import { Uint8ArrayList } from "uint8arraylist";
 
 import { BaseProtocol } from "../base_protocol.js";
-import { DefaultPubsubTopic } from "../constants.js";
 import { toProtoMessage } from "../to_proto_message.js";
 
 import { HistoryRpc, PageDirection, Params } from "./history_rpc.js";
@@ -75,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);
-    this.pubsubTopics = options?.pubsubTopics ?? [DefaultPubsubTopic];
+    super(StoreCodec, libp2p.components, log, options!.pubsubTopics!, options);
   }
 
   /**

package/src/lib/stream_manager.ts

@@ -1,6 +1,5 @@
-import type { PeerUpdate } from "@libp2p/interface";
-import type { Stream } from "@libp2p/interface/connection";
-import { Peer } from "@libp2p/interface/peer-store";
+import type { PeerUpdate, Stream } from "@libp2p/interface";
+import { Peer } from "@libp2p/interface";
 import { Libp2p } from "@waku/interfaces";
 import { Logger } from "@waku/utils";
 import { selectConnection } from "@waku/utils/libp2p";

package/src/lib/wait_for_remote_peer.ts

@@ -1,15 +1,14 @@
 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");
 
 /**
  * Wait for a remote peer to be ready given the passed protocols.
  * Must be used after attempting to connect to nodes, using
- * {@link @waku/core!WakuNode.dial} or a bootstrap method with
+ * {@link @waku/sdk!WakuNode.dial} or a bootstrap method with
  * {@link @waku/sdk!createLightNode}.
  *
  * If the passed protocols is a GossipSub protocol, then it resolves only once
@@ -45,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));
+    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));
+    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));
+    promises.push(
+      waitForConnectedPeer(waku.filter, waku.libp2p.services.metadata)
+    );
   }
 
   if (timeoutMs) {
@@ -73,21 +78,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());
-    return;
+    if (!metadataService) {
+      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);
-        resolve();
+        if (metadataService) {
+          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);