@waku/core 0.0.26 → 0.0.28-434be7b.0

package/src/lib/light_push/index.ts

@@ -1,20 +1,16 @@
-import type { Stream } from "@libp2p/interface/connection";
-import type { PeerId } from "@libp2p/interface/peer-id";
+import type { Peer, PeerId, Stream } from "@libp2p/interface";
 import {
+  Failure,
+  IBaseProtocolCore,
   IEncoder,
-  ILightPush,
   IMessage,
   Libp2p,
   ProtocolCreateOptions,
-  PubsubTopic,
-  SendError,
-  SendResult
+  ProtocolError,
+  ProtocolResult
 } from "@waku/interfaces";
 import { PushResponse } from "@waku/proto";
-import {
-  ensurePubsubTopicIsConfigured,
-  isMessageSizeUnderCap
-} from "@waku/utils";
+import { isMessageSizeUnderCap } from "@waku/utils";
 import { Logger } from "@waku/utils";
 import all from "it-all";
 import * as lp from "it-length-prefixed";
@@ -30,42 +26,37 @@ const log = new Logger("light-push");
 export const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
 export { PushResponse };
 
-type PreparePushMessageResult =
-  | {
-      query: PushRpc;
-      error: null;
-    }
-  | {
-      query: null;
-      error: SendError;
-    };
+type PreparePushMessageResult = ProtocolResult<"query", PushRpc>;
+
+type CoreSendResult = ProtocolResult<"success", PeerId, "failure", Failure>;
 
 /**
  * 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;
-
+export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
   constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
-    super(LightPushCodec, libp2p.components);
-    this.pubsubTopics = this.initializePubsubTopic(options);
+    super(
+      LightPushCodec,
+      libp2p.components,
+      log,
+      options!.pubsubTopics!,
+      options
+    );
   }
 
   private async preparePushMessage(
     encoder: IEncoder,
-    message: IMessage,
-    pubsubTopic: string
+    message: IMessage
   ): Promise<PreparePushMessageResult> {
     try {
       if (!message.payload || message.payload.length === 0) {
         log.error("Failed to send waku light push: payload is empty");
-        return { query: null, error: SendError.EMPTY_PAYLOAD };
+        return { query: null, error: ProtocolError.EMPTY_PAYLOAD };
       }
 
       if (!(await isMessageSizeUnderCap(encoder, message))) {
         log.error("Failed to send waku light push: message is bigger than 1MB");
-        return { query: null, error: SendError.SIZE_TOO_BIG };
+        return { query: null, error: ProtocolError.SIZE_TOO_BIG };
       }
 
       const protoMessage = await encoder.toProtoObj(message);
@@ -73,131 +64,120 @@ class LightPush extends BaseProtocol implements ILightPush {
         log.error("Failed to encode to protoMessage, aborting push");
         return {
           query: null,
-          error: SendError.ENCODE_FAILED
+          error: ProtocolError.ENCODE_FAILED
         };
       }
 
-      const query = PushRpc.createRequest(protoMessage, pubsubTopic);
+      const query = PushRpc.createRequest(protoMessage, encoder.pubsubTopic);
       return { query, error: null };
     } catch (error) {
       log.error("Failed to prepare push message", error);
 
       return {
         query: null,
-        error: SendError.GENERIC_FAIL
+        error: ProtocolError.GENERIC_FAIL
       };
     }
   }
 
-  async send(encoder: IEncoder, message: IMessage): Promise<SendResult> {
-    const { pubsubTopic } = encoder;
-    ensurePubsubTopicIsConfigured(pubsubTopic, this.pubsubTopics);
-
-    const recipients: PeerId[] = [];
-
+  async send(
+    encoder: IEncoder,
+    message: IMessage,
+    peer: Peer
+  ): Promise<CoreSendResult> {
     const { query, error: preparationError } = await this.preparePushMessage(
       encoder,
-      message,
-      pubsubTopic
+      message
     );
 
     if (preparationError || !query) {
       return {
-        recipients,
-        errors: [preparationError]
+        success: null,
+        failure: {
+          error: preparationError,
+          peerId: peer.id
+        }
       };
     }
 
-    //TODO: get a relevant peer for the topic/shard
-    const peers = await this.getPeers({
-      maxBootstrapPeers: 1,
-      numPeers: this.NUM_PEERS_PROTOCOL
-    });
-
-    if (!peers.length) {
+    let stream: Stream | undefined;
+    try {
+      stream = await this.getStream(peer);
+    } catch (err) {
+      log.error(
+        `Failed to get a stream for remote peer${peer.id.toString()}`,
+        err
+      );
       return {
-        recipients,
-        errors: [SendError.NO_PEER_AVAILABLE]
+        success: null,
+        failure: {
+          error: ProtocolError.REMOTE_PEER_FAULT,
+          peerId: peer.id
+        }
       };
     }
 
-    const promises = peers.map(async (peer) => {
-      let stream: Stream | undefined;
-      try {
-        stream = await this.getStream(peer);
-      } catch (err) {
-        log.error(
-          `Failed to get a stream for remote peer${peer.id.toString()}`,
-          err
-        );
-        return { recipients, error: SendError.REMOTE_PEER_FAULT };
-      }
-
-      let res: Uint8ArrayList[] | undefined;
-      try {
-        res = await pipe(
-          [query.encode()],
-          lp.encode,
-          stream,
-          lp.decode,
-          async (source) => await all(source)
-        );
-      } catch (err) {
-        log.error("Failed to send waku light push request", err);
-        return { recipients, error: SendError.GENERIC_FAIL };
-      }
-
-      const bytes = new Uint8ArrayList();
-      res.forEach((chunk) => {
-        bytes.append(chunk);
-      });
-
-      let response: PushResponse | undefined;
-      try {
-        response = PushRpc.decode(bytes).response;
-      } catch (err) {
-        log.error("Failed to decode push reply", err);
-        return { recipients, error: SendError.DECODE_FAILED };
-      }
+    let res: Uint8ArrayList[] | undefined;
+    try {
+      res = await pipe(
+        [query.encode()],
+        lp.encode,
+        stream,
+        lp.decode,
+        async (source) => await all(source)
+      );
+    } catch (err) {
+      log.error("Failed to send waku light push request", err);
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.GENERIC_FAIL,
+          peerId: peer.id
+        }
+      };
+    }
 
-      if (!response) {
-        log.error("Remote peer fault: No response in PushRPC");
-        return { recipients, error: SendError.REMOTE_PEER_FAULT };
-      }
+    const bytes = new Uint8ArrayList();
+    res.forEach((chunk) => {
+      bytes.append(chunk);
+    });
 
-      if (!response.isSuccess) {
-        log.error("Remote peer rejected the message: ", response.info);
-        return { recipients, error: SendError.REMOTE_PEER_REJECTED };
-      }
+    let response: PushResponse | undefined;
+    try {
+      response = PushRpc.decode(bytes).response;
+    } catch (err) {
+      log.error("Failed to decode push reply", err);
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.DECODE_FAILED,
+          peerId: peer.id
+        }
+      };
+    }
 
-      recipients.some((recipient) => recipient.equals(peer.id)) ||
-        recipients.push(peer.id);
+    if (!response) {
+      log.error("Remote peer fault: No response in PushRPC");
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.REMOTE_PEER_FAULT,
+          peerId: peer.id
+        }
+      };
+    }
 
-      return { recipients };
-    });
+    if (!response.isSuccess) {
+      log.error("Remote peer rejected the message: ", response.info);
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.REMOTE_PEER_REJECTED,
+          peerId: peer.id
+        }
+      };
+    }
 
-    const results = await Promise.allSettled(promises);
-    const errors = results
-      .filter(
-        (
-          result
-        ): result is PromiseFulfilledResult<{
-          recipients: PeerId[];
-          error: SendError | undefined;
-        }> => result.status === "fulfilled"
-      )
-      .map((result) => result.value.error)
-      .filter((error) => error !== undefined) as SendError[];
-
-    return {
-      recipients,
-      errors
-    };
+    return { success: peer.id, failure: null };
   }
 }
-
-export function wakuLightPush(
-  init: Partial<ProtocolCreateOptions> = {}
-): (libp2p: Libp2p) => ILightPush {
-  return (libp2p: Libp2p) => new LightPush(libp2p, init);
-}

package/src/lib/metadata/index.ts

@@ -1,14 +1,15 @@
-import type { PeerId } from "@libp2p/interface/peer-id";
-import { IncomingStreamData } from "@libp2p/interface/stream-handler";
-import { encodeRelayShard } from "@waku/enr";
-import type {
-  IMetadata,
-  Libp2pComponents,
-  ShardInfo,
-  ShardingParams
+import type { PeerId } from "@libp2p/interface";
+import { IncomingStreamData } from "@libp2p/interface";
+import {
+  type IMetadata,
+  type Libp2pComponents,
+  type PeerIdStr,
+  ProtocolError,
+  QueryResult,
+  type ShardInfo
 } from "@waku/interfaces";
 import { proto_metadata } from "@waku/proto";
-import { 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";
@@ -20,13 +21,21 @@ const log = new Logger("metadata");
 
 export const MetadataCodec = "/vac/waku/metadata/1.0.0";
 
-class Metadata extends BaseProtocol {
-  private readonly shardInfo: ShardingParams;
+class Metadata extends BaseProtocol implements IMetadata {
   private libp2pComponents: Libp2pComponents;
-  constructor(shardInfo: ShardingParams, libp2p: Libp2pComponents) {
-    super(MetadataCodec, libp2p.components);
+  handshakesConfirmed: Map<PeerIdStr, ShardInfo> = new Map();
+
+  constructor(
+    public shardInfo: ShardInfo,
+    libp2p: Libp2pComponents
+  ) {
+    super(
+      MetadataCodec,
+      libp2p.components,
+      log,
+      shardInfoToPubsubTopics(shardInfo)
+    );
     this.libp2pComponents = libp2p;
-    this.shardInfo = shardInfo;
     void libp2p.registrar.handle(MetadataCodec, (streamData) => {
       void this.onRequest(streamData);
     });
@@ -50,15 +59,13 @@ class Metadata extends BaseProtocol {
         async (source) => await all(source)
       );
 
-      const remoteShardInfoResponse =
-        this.decodeMetadataResponse(encodedResponse);
+      const { error, shardInfo } = this.decodeMetadataResponse(encodedResponse);
+
+      if (error) {
+        return;
+      }
 
-      // add or update the shardInfo to peer store
-      await this.libp2pComponents.peerStore.merge(connection.remotePeer, {
-        metadata: {
-          shardInfo: encodeRelayShard(remoteShardInfoResponse)
-        }
-      });
+      await this.savePeerShardInfo(connection.remotePeer, shardInfo);
     } catch (error) {
       log.error("Error handling metadata request", error);
     }
@@ -67,10 +74,16 @@ class Metadata extends BaseProtocol {
   /**
    * Make a metadata query to a peer
    */
-  async query(peerId: PeerId): Promise<ShardInfo> {
+  async query(peerId: PeerId): Promise<QueryResult> {
     const request = proto_metadata.WakuMetadataRequest.encode(this.shardInfo);
 
-    const peer = await this.getPeer(peerId);
+    const peer = await this.peerStore.get(peerId);
+    if (!peer) {
+      return {
+        shardInfo: null,
+        error: ProtocolError.NO_PEER_AVAILABLE
+      };
+    }
 
     const stream = await this.getStream(peer);
 
@@ -82,12 +95,38 @@ class Metadata extends BaseProtocol {
       async (source) => await all(source)
     );
 
-    const decodedResponse = this.decodeMetadataResponse(encodedResponse);
+    const { error, shardInfo } = this.decodeMetadataResponse(encodedResponse);
+
+    if (error) {
+      return {
+        shardInfo: null,
+        error
+      };
+    }
+
+    await this.savePeerShardInfo(peerId, shardInfo);
 
-    return decodedResponse;
+    return {
+      shardInfo,
+      error: null
+    };
   }
 
-  private decodeMetadataResponse(encodedResponse: Uint8ArrayList[]): ShardInfo {
+  public async confirmOrAttemptHandshake(peerId: PeerId): Promise<QueryResult> {
+    const shardInfo = this.handshakesConfirmed.get(peerId.toString());
+    if (shardInfo) {
+      return {
+        shardInfo,
+        error: null
+      };
+    }
+
+    return await this.query(peerId);
+  }
+
+  private decodeMetadataResponse(
+    encodedResponse: Uint8ArrayList[]
+  ): QueryResult {
     const bytes = new Uint8ArrayList();
 
     encodedResponse.forEach((chunk) => {
@@ -97,14 +136,37 @@ class Metadata extends BaseProtocol {
       bytes
     ) as ShardInfo;
 
-    if (!response) log.error("Error decoding metadata response");
+    if (!response) {
+      log.error("Error decoding metadata response");
+      return {
+        shardInfo: null,
+        error: ProtocolError.DECODE_FAILED
+      };
+    }
+
+    return {
+      shardInfo: response,
+      error: null
+    };
+  }
+
+  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)
+      }
+    });
 
-    return response;
+    this.handshakesConfirmed.set(peerId.toString(), shardInfo);
   }
 }
 
 export function wakuMetadata(
-  shardInfo: ShardingParams
+  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";
@@ -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);
-    this.pubsubTopics = this.initializePubsubTopic(options);
+    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,20 @@
 import type { IdentifyResult } from "@libp2p/interface";
-import type { IBaseProtocol, IRelay, Waku } from "@waku/interfaces";
+import type {
+  IBaseProtocolCore,
+  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");
 
+//TODO: move this function within the Waku class: https://github.com/waku-org/js-waku/issues/1761
 /**
  * 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 +50,28 @@ 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.protocol,
+        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) {
@@ -71,23 +85,65 @@ export async function waitForRemotePeer(
   }
 }
 
+//TODO: move this function within protocol SDK class: https://github.com/waku-org/js-waku/issues/1761
 /**
  * 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: IBaseProtocolCore,
+  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);