@waku/core 0.0.26 → 0.0.28-070b625.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/predefined_bootstrap_nodes.ts

@@ -3,22 +3,22 @@ import { getPseudoRandomSubset } from "@waku/utils";
 export const DefaultWantedNumber = 1;
 
 export enum Fleet {
-  Prod = "prod",
+  Sandbox = "sandbox",
   Test = "test"
 }
 
 /**
  * Return list of pre-defined (hardcoded) bootstrap nodes.
  *
- * Default behavior is to return nodes of the nwaku Status Prod fleet.
+ * Default behavior is to return nodes of the nwaku Status Sandbox fleet.
  *
- * @param fleet The fleet to be returned. Defaults to production fleet.
+ * @param fleet The fleet to be returned. Defaults to sandbox fleet.
  * @param wantedNumber The number of connections desired. Defaults to {@link DefaultWantedNumber}.
  *
  * @returns An array of multiaddresses.
  */
 export function getPredefinedBootstrapNodes(
-  fleet: Fleet = Fleet.Prod,
+  fleet: Fleet = Fleet.Sandbox,
   wantedNumber: number = DefaultWantedNumber
 ): string[] {
   if (wantedNumber <= 0) {
@@ -27,14 +27,14 @@ export function getPredefinedBootstrapNodes(
 
   let nodes;
   switch (fleet) {
-    case Fleet.Prod:
-      nodes = fleets.fleets["wakuv2.prod"]["waku-websocket"];
+    case Fleet.Sandbox:
+      nodes = fleets.fleets["waku.sandbox"]["waku-websocket"];
       break;
     case Fleet.Test:
-      nodes = fleets.fleets["wakuv2.test"]["waku-websocket"];
+      nodes = fleets.fleets["waku.test"]["waku-websocket"];
       break;
     default:
-      nodes = fleets.fleets["wakuv2.prod"]["waku-websocket"];
+      nodes = fleets.fleets["waku.sandbox"]["waku-websocket"];
   }
 
   nodes = Object.values(nodes) as string[];
@@ -44,24 +44,24 @@ export function getPredefinedBootstrapNodes(
 
 export const fleets = {
   fleets: {
-    "wakuv2.prod": {
+    "waku.sandbox": {
       "waku-websocket": {
-        "node-01.ac-cn-hongkong-c.wakuv2.prod":
-          "/dns4/node-01.ac-cn-hongkong-c.wakuv2.prod.statusim.net/tcp/8000/wss/p2p/16Uiu2HAm4v86W3bmT1BiH6oSPzcsSr24iDQpSN5Qa992BCjjwgrD",
-        "node-01.do-ams3.wakuv2.prod":
-          "/dns4/node-01.do-ams3.wakuv2.prod.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmL5okWopX7NqZWBUKVqW8iUxCEmd5GMHLVPwCgzYzQv3e",
-        "node-01.gc-us-central1-a.wakuv2.prod":
-          "/dns4/node-01.gc-us-central1-a.wakuv2.prod.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmVkKntsECaYfefR1V2yCR79CegLATuTPE6B9TxgxBiiiA"
+        "node-01.ac-cn-hongkong-c.waku.sandbox":
+          "/dns4/node-01.ac-cn-hongkong-c.waku.sandbox.status.im/tcp/8000/wss/p2p/16Uiu2HAmSJvSJphxRdbnigUV5bjRRZFBhTtWFTSyiKaQByCjwmpV",
+        "node-01.do-ams3.waku.sandbox":
+          "/dns4/node-01.do-ams3.waku.sandbox.status.im/tcp/8000/wss/p2p/16Uiu2HAmQSMNExfUYUqfuXWkD5DaNZnMYnigRxFKbk3tcEFQeQeE",
+        "node-01.gc-us-central1-a.waku.sandbox":
+          "/dns4/node-01.gc-us-central1-a.waku.sandbox.status.im/tcp/8000/wss/p2p/16Uiu2HAm6fyqE1jB5MonzvoMdU8v76bWV8ZeNpncDamY1MQXfjdB"
       }
     },
-    "wakuv2.test": {
+    "waku.test": {
       "waku-websocket": {
-        "node-01.ac-cn-hongkong-c.wakuv2.test":
-          "/dns4/node-01.ac-cn-hongkong-c.wakuv2.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAkvWiyFsgRhuJEb9JfjYxEkoHLgnUQmr1N5mKWnYjxYRVm",
-        "node-01.do-ams3.wakuv2.test":
-          "/dns4/node-01.do-ams3.wakuv2.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmPLe7Mzm8TsYUubgCAW1aJoeFScxrLj8ppHFivPo97bUZ",
-        "node-01.gc-us-central1-a.wakuv2.test":
-          "/dns4/node-01.gc-us-central1-a.wakuv2.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmJb2e28qLXxT5kZxVUUoJt72EMzNGXB47Rxx5hw3q4YjS"
+        "node-01.ac-cn-hongkong-c.waku.test":
+          "/dns4/node-01.ac-cn-hongkong-c.waku.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAkzHaTP5JsUwfR9NR8Rj9HC24puS6ocaU8wze4QrXr9iXp",
+        "node-01.do-ams3.waku.test":
+          "/dns4/node-01.do-ams3.waku.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAkykgaECHswi3YKJ5dMLbq2kPVCo89fcyTd38UcQD6ej5W",
+        "node-01.gc-us-central1-a.waku.test":
+          "/dns4/node-01.gc-us-central1-a.waku.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmDCp8XJ9z1ev18zuv8NHekAsjNyezAvmMfFEJkiharitG"
       }
     }
   }