@waku/core 0.0.27 → 0.0.28-b5e8b17.0

package/src/lib/light_push/index.ts

@@ -1,18 +1,16 @@
-import type { PeerId, Stream } from "@libp2p/interface";
+import type { Peer, PeerId, Stream } from "@libp2p/interface";
 import {
+  Failure,
+  IBaseProtocolCore,
   IEncoder,
-  ILightPush,
   IMessage,
   Libp2p,
   ProtocolCreateOptions,
-  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";
@@ -28,20 +26,14 @@ 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 {
+export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
   constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
     super(
       LightPushCodec,
@@ -54,18 +46,17 @@ class LightPush extends BaseProtocol implements ILightPush {
 
   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,132 +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
+        }
       };
     }
 
-    const peers = await this.getPeers({
-      maxBootstrapPeers: 1,
-      numPeers: this.numPeersToUse
-    });
-
-    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);
-
-    // TODO: handle renewing faulty peers with new peers (https://github.com/waku-org/js-waku/issues/1463)
-    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,10 +1,12 @@
 import type { PeerId } from "@libp2p/interface";
 import { IncomingStreamData } from "@libp2p/interface";
-import type {
-  IMetadata,
-  Libp2pComponents,
-  PeerIdStr,
-  ShardInfo
+import {
+  type IMetadata,
+  type Libp2pComponents,
+  type PeerIdStr,
+  ProtocolError,
+  QueryResult,
+  type ShardInfo
 } from "@waku/interfaces";
 import { proto_metadata } from "@waku/proto";
 import { encodeRelayShard, Logger, shardInfoToPubsubTopics } from "@waku/utils";
@@ -21,7 +23,7 @@ export const MetadataCodec = "/vac/waku/metadata/1.0.0";
 
 class Metadata extends BaseProtocol implements IMetadata {
   private libp2pComponents: Libp2pComponents;
-  handshakesConfirmed: Set<PeerIdStr> = new Set();
+  handshakesConfirmed: Map<PeerIdStr, ShardInfo> = new Map();
 
   constructor(
     public shardInfo: ShardInfo,
@@ -57,13 +59,13 @@ class Metadata extends BaseProtocol implements IMetadata {
         async (source) => await all(source)
       );
 
-      const remoteShardInfoResponse =
-        this.decodeMetadataResponse(encodedResponse);
+      const { error, shardInfo } = this.decodeMetadataResponse(encodedResponse);
 
-      await this.savePeerShardInfo(
-        connection.remotePeer,
-        remoteShardInfoResponse
-      );
+      if (error) {
+        return;
+      }
+
+      await this.savePeerShardInfo(connection.remotePeer, shardInfo);
     } catch (error) {
       log.error("Error handling metadata request", error);
     }
@@ -72,12 +74,15 @@ class Metadata extends BaseProtocol implements IMetadata {
   /**
    * 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.peerStore.get(peerId);
     if (!peer) {
-      throw new Error(`Peer ${peerId.toString()} not found`);
+      return {
+        shardInfo: null,
+        error: ProtocolError.NO_PEER_AVAILABLE
+      };
     }
 
     const stream = await this.getStream(peer);
@@ -90,22 +95,38 @@ class Metadata extends BaseProtocol implements IMetadata {
       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, decodedResponse);
+    await this.savePeerShardInfo(peerId, shardInfo);
 
-    return decodedResponse;
+    return {
+      shardInfo,
+      error: null
+    };
   }
 
-  public async confirmOrAttemptHandshake(peerId: PeerId): Promise<void> {
-    if (this.handshakesConfirmed.has(peerId.toString())) return;
-
-    await this.query(peerId);
+  public async confirmOrAttemptHandshake(peerId: PeerId): Promise<QueryResult> {
+    const shardInfo = this.handshakesConfirmed.get(peerId.toString());
+    if (shardInfo) {
+      return {
+        shardInfo,
+        error: null
+      };
+    }
 
-    return;
+    return await this.query(peerId);
   }
 
-  private decodeMetadataResponse(encodedResponse: Uint8ArrayList[]): ShardInfo {
+  private decodeMetadataResponse(
+    encodedResponse: Uint8ArrayList[]
+  ): QueryResult {
     const bytes = new Uint8ArrayList();
 
     encodedResponse.forEach((chunk) => {
@@ -115,9 +136,18 @@ class Metadata extends BaseProtocol implements IMetadata {
       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 response;
+    return {
+      shardInfo: response,
+      error: null
+    };
   }
 
   private async savePeerShardInfo(
@@ -131,7 +161,7 @@ class Metadata extends BaseProtocol implements IMetadata {
       }
     });
 
-    this.handshakesConfirmed.add(peerId.toString());
+    this.handshakesConfirmed.set(peerId.toString(), shardInfo);
   }
 }
 

package/src/lib/wait_for_remote_peer.ts

@@ -1,10 +1,16 @@
 import type { IdentifyResult } from "@libp2p/interface";
-import type { IBaseProtocol, IMetadata, 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
@@ -53,7 +59,10 @@ export async function waitForRemotePeer(
     if (!waku.lightPush)
       throw new Error("Cannot wait for LightPush peer: protocol not mounted");
     promises.push(
-      waitForConnectedPeer(waku.lightPush, waku.libp2p.services.metadata)
+      waitForConnectedPeer(
+        waku.lightPush.protocol,
+        waku.libp2p.services.metadata
+      )
     );
   }
 
@@ -76,12 +85,13 @@ 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,
+  protocol: IBaseProtocolCore,
   metadataService?: IMetadata
 ): Promise<void> {
   const codec = protocol.multicodec;