@waku/core 0.0.22 → 0.0.24

package/src/lib/filterPeers.ts

@@ -0,0 +1,43 @@
+import { Peer } from "@libp2p/interface/peer-store";
+import { Tags } from "@waku/interfaces";
+
+/**
+ * Retrieves a list of peers based on the specified criteria.
+ *
+ * @param peers - The list of peers to filter from.
+ * @param numPeers - The total number of peers to retrieve. If 0, all peers are returned.
+ * @param maxBootstrapPeers - The maximum number of bootstrap peers to retrieve.
+ * @returns A Promise that resolves to an array of peers based on the specified criteria.
+ */
+export async function filterPeers(
+  peers: Peer[],
+  numPeers: number,
+  maxBootstrapPeers: number
+): Promise<Peer[]> {
+  // Collect the bootstrap peers up to the specified maximum
+  const bootstrapPeers = peers
+    .filter((peer) => peer.tags.has(Tags.BOOTSTRAP))
+    .slice(0, maxBootstrapPeers);
+
+  // Collect non-bootstrap peers
+  const nonBootstrapPeers = peers.filter(
+    (peer) => !peer.tags.has(Tags.BOOTSTRAP)
+  );
+
+  // If numPeers is 0, return all peers
+  if (numPeers === 0) {
+    return [...bootstrapPeers, ...nonBootstrapPeers];
+  }
+
+  // Initialize the list of selected peers with the bootstrap peers
+  const selectedPeers: Peer[] = [...bootstrapPeers];
+
+  // Fill up to numPeers with remaining random peers if needed
+  while (selectedPeers.length < numPeers && nonBootstrapPeers.length > 0) {
+    const randomIndex = Math.floor(Math.random() * nonBootstrapPeers.length);
+    const randomPeer = nonBootstrapPeers.splice(randomIndex, 1)[0];
+    selectedPeers.push(randomPeer);
+  }
+
+  return selectedPeers;
+}

package/src/lib/keep_alive_manager.ts

@@ -1,17 +1,19 @@
-import type { PeerId } from "@libp2p/interface-peer-id";
-import type { IRelay } from "@waku/interfaces";
+import type { PeerId } from "@libp2p/interface/peer-id";
+import type { PeerStore } from "@libp2p/interface/peer-store";
+import type { IRelay, PeerIdStr } from "@waku/interfaces";
 import type { KeepAliveOptions } from "@waku/interfaces";
+import { utf8ToBytes } from "@waku/utils/bytes";
 import debug from "debug";
 import type { PingService } from "libp2p/ping";
 
-import { createEncoder } from "../index.js";
+import { createEncoder } from "./message/version_0.js";
 
 export const RelayPingContentTopic = "/relay-ping/1/ping/null";
 const log = debug("waku:keep-alive");
 
 export class KeepAliveManager {
   private pingKeepAliveTimers: Map<string, ReturnType<typeof setInterval>>;
-  private relayKeepAliveTimers: Map<PeerId, ReturnType<typeof setInterval>>;
+  private relayKeepAliveTimers: Map<PeerId, ReturnType<typeof setInterval>[]>;
   private options: KeepAliveOptions;
   private relay?: IRelay;
 
@@ -22,8 +24,12 @@ export class KeepAliveManager {
     this.relay = relay;
   }
 
-  public start(peerId: PeerId, libp2pPing: PingService): void {
-    // Just in case a timer already exist for this peer
+  public start(
+    peerId: PeerId,
+    libp2pPing: PingService,
+    peerStore: PeerStore
+  ): void {
+    // Just in case a timer already exists for this peer
     this.stop(peerId);
 
     const { pingKeepAlive: pingPeriodSecs, relayKeepAlive: relayPeriodSecs } =
@@ -31,28 +37,51 @@ export class KeepAliveManager {
 
     const peerIdStr = peerId.toString();
 
+    // Ping the peer every pingPeriodSecs seconds
+    // if pingPeriodSecs is 0, don't ping the peer
     if (pingPeriodSecs !== 0) {
       const interval = setInterval(() => {
-        libp2pPing.ping(peerId).catch((e) => {
-          log(`Ping failed (${peerIdStr})`, e);
-        });
+        void (async () => {
+          let ping: number;
+          try {
+            // ping the peer for keep alive
+            // also update the peer store with the latency
+            try {
+              ping = await libp2pPing.ping(peerId);
+              log(`Ping succeeded (${peerIdStr})`, ping);
+            } catch (error) {
+              log(`Ping failed for peer (${peerIdStr}).
+                Next ping will be attempted in ${pingPeriodSecs} seconds.
+              `);
+              return;
+            }
+
+            try {
+              await peerStore.patch(peerId, {
+                metadata: {
+                  ping: utf8ToBytes(ping.toString())
+                }
+              });
+            } catch (e) {
+              log("Failed to update ping", e);
+            }
+          } catch (e) {
+            log(`Ping failed (${peerIdStr})`, e);
+          }
+        })();
       }, pingPeriodSecs * 1000);
+
       this.pingKeepAliveTimers.set(peerIdStr, interval);
     }
 
     const relay = this.relay;
     if (relay && relayPeriodSecs !== 0) {
-      const encoder = createEncoder({
-        contentTopic: RelayPingContentTopic,
-        ephemeral: true,
-      });
-      const interval = setInterval(() => {
-        log("Sending Waku Relay ping message");
-        relay
-          .send(encoder, { payload: new Uint8Array([1]) })
-          .catch((e) => log("Failed to send relay ping", e));
-      }, relayPeriodSecs * 1000);
-      this.relayKeepAliveTimers.set(peerId, interval);
+      const intervals = this.scheduleRelayPings(
+        relay,
+        relayPeriodSecs,
+        peerId.toString()
+      );
+      this.relayKeepAliveTimers.set(peerId, intervals);
     }
   }
 
@@ -65,7 +94,7 @@ export class KeepAliveManager {
     }
 
     if (this.relayKeepAliveTimers.has(peerId)) {
-      clearInterval(this.relayKeepAliveTimers.get(peerId));
+      this.relayKeepAliveTimers.get(peerId)?.map(clearInterval);
       this.relayKeepAliveTimers.delete(peerId);
     }
   }
@@ -73,7 +102,7 @@ export class KeepAliveManager {
   public stopAll(): void {
     for (const timer of [
       ...Object.values(this.pingKeepAliveTimers),
-      ...Object.values(this.relayKeepAliveTimers),
+      ...Object.values(this.relayKeepAliveTimers)
     ]) {
       clearInterval(timer);
     }
@@ -81,4 +110,32 @@ export class KeepAliveManager {
     this.pingKeepAliveTimers.clear();
     this.relayKeepAliveTimers.clear();
   }
+
+  private scheduleRelayPings(
+    relay: IRelay,
+    relayPeriodSecs: number,
+    peerIdStr: PeerIdStr
+  ): NodeJS.Timeout[] {
+    // send a ping message to each PubSubTopic the peer is part of
+    const intervals: NodeJS.Timeout[] = [];
+    for (const topic of relay.pubsubTopics) {
+      const meshPeers = relay.getMeshPeers(topic);
+      if (!meshPeers.includes(peerIdStr)) continue;
+
+      const encoder = createEncoder({
+        pubsubTopic: topic,
+        contentTopic: RelayPingContentTopic,
+        ephemeral: true
+      });
+      const interval = setInterval(() => {
+        log("Sending Waku Relay ping message");
+        relay
+          .send(encoder, { payload: new Uint8Array([1]) })
+          .catch((e) => log("Failed to send relay ping", e));
+      }, relayPeriodSecs * 1000);
+      intervals.push(interval);
+    }
+
+    return intervals;
+  }
 }

package/src/lib/light_push/index.ts

@@ -1,16 +1,17 @@
-import type { PeerId } from "@libp2p/interface-peer-id";
+import type { Stream } from "@libp2p/interface/connection";
+import type { PeerId } from "@libp2p/interface/peer-id";
 import {
   IEncoder,
   ILightPush,
   IMessage,
   Libp2p,
   ProtocolCreateOptions,
-  ProtocolOptions,
+  PubSubTopic,
   SendError,
-  SendResult,
+  SendResult
 } from "@waku/interfaces";
 import { PushResponse } from "@waku/proto";
-import { isSizeValid } from "@waku/utils";
+import { ensurePubsubTopicIsConfigured, isSizeValid } from "@waku/utils";
 import debug from "debug";
 import all from "it-all";
 import * as lp from "it-length-prefixed";
@@ -27,80 +28,160 @@ const log = debug("waku:light-push");
 export const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
 export { PushResponse };
 
+type PreparePushMessageResult =
+  | {
+      query: PushRpc;
+      error: null;
+    }
+  | {
+      query: null;
+      error: SendError;
+    };
+
 /**
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
  */
 class LightPush extends BaseProtocol implements ILightPush {
-  options: ProtocolCreateOptions;
+  private readonly pubsubTopics: PubSubTopic[];
+  private readonly NUM_PEERS_PROTOCOL = 1;
 
   constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
     super(LightPushCodec, libp2p.components);
-    this.options = options || {};
+    this.pubsubTopics = options?.pubsubTopics ?? [DefaultPubSubTopic];
   }
 
-  async send(
+  private async preparePushMessage(
     encoder: IEncoder,
     message: IMessage,
-    opts?: ProtocolOptions
-  ): Promise<SendResult> {
-    const { pubSubTopic = DefaultPubSubTopic } = this.options;
-
-    const peer = await this.getPeer(opts?.peerId);
-    const stream = await this.newStream(peer);
-
-    const recipients: PeerId[] = [];
-    let error: undefined | SendError = undefined;
-
+    pubsubTopic: string
+  ): Promise<PreparePushMessageResult> {
     try {
       if (!isSizeValid(message.payload)) {
-        log("Failed to send waku light push: message is bigger that 1MB");
-        return {
-          recipients,
-          error: SendError.SIZE_TOO_BIG,
-        };
+        log("Failed to send waku light push: message is bigger than 1MB");
+        return { query: null, error: SendError.SIZE_TOO_BIG };
       }
 
       const protoMessage = await encoder.toProtoObj(message);
       if (!protoMessage) {
         log("Failed to encode to protoMessage, aborting push");
         return {
-          recipients,
-          error: SendError.ENCODE_FAILED,
+          query: null,
+          error: SendError.ENCODE_FAILED
         };
       }
-      const query = PushRpc.createRequest(protoMessage, pubSubTopic);
-      const res = await pipe(
-        [query.encode()],
-        lp.encode,
-        stream,
-        lp.decode,
-        async (source) => await all(source)
-      );
+
+      const query = PushRpc.createRequest(protoMessage, pubsubTopic);
+      return { query, error: null };
+    } catch (error) {
+      log("Failed to prepare push message", error);
+
+      return {
+        query: null,
+        error: SendError.GENERIC_FAIL
+      };
+    }
+  }
+
+  async send(encoder: IEncoder, message: IMessage): Promise<SendResult> {
+    const { pubsubTopic } = encoder;
+    ensurePubsubTopicIsConfigured(pubsubTopic, this.pubsubTopics);
+
+    const recipients: PeerId[] = [];
+
+    const { query, error: preparationError } = await this.preparePushMessage(
+      encoder,
+      message,
+      pubsubTopic
+    );
+
+    if (preparationError || !query) {
+      return {
+        recipients,
+        errors: [preparationError]
+      };
+    }
+
+    //TODO: get a relevant peer for the topic/shard
+    const peers = await this.getPeers({
+      maxBootstrapPeers: 1,
+      numPeers: this.NUM_PEERS_PROTOCOL
+    });
+
+    if (!peers.length) {
+      return {
+        recipients,
+        errors: [SendError.NO_PEER_AVAILABLE]
+      };
+    }
+
+    const promises = peers.map(async (peer) => {
+      let stream: Stream | undefined;
+      try {
+        stream = await this.getStream(peer);
+      } catch (err) {
+        log(`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("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 {
-        const bytes = new Uint8ArrayList();
-        res.forEach((chunk) => {
-          bytes.append(chunk);
-        });
-
-        const response = PushRpc.decode(bytes).response;
-
-        if (response?.isSuccess) {
-          recipients.push(peer.id);
-        } else {
-          log("No response in PushRPC");
-          error = SendError.NO_RPC_RESPONSE;
-        }
+        response = PushRpc.decode(bytes).response;
       } catch (err) {
         log("Failed to decode push reply", err);
-        error = SendError.DECODE_FAILED;
+        return { recipients, error: SendError.DECODE_FAILED };
       }
-    } catch (err) {
-      log("Failed to send waku light push request", err);
-      error = SendError.GENERIC_FAIL;
-    }
+
+      if (!response) {
+        log("Remote peer fault: No response in PushRPC");
+        return { recipients, error: SendError.REMOTE_PEER_FAULT };
+      }
+
+      if (!response.isSuccess) {
+        log("Remote peer rejected the message: ", response.info);
+        return { recipients, error: SendError.REMOTE_PEER_REJECTED };
+      }
+
+      recipients.some((recipient) => recipient.equals(peer.id)) ||
+        recipients.push(peer.id);
+
+      return { recipients };
+    });
+
+    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 {
-      error,
       recipients,
+      errors
     };
   }
 }

package/src/lib/light_push/push_rpc.ts

@@ -7,15 +7,15 @@ export class PushRpc {
 
   static createRequest(
     message: proto.WakuMessage,
-    pubSubTopic: string
+    pubsubTopic: string
   ): PushRpc {
     return new PushRpc({
       requestId: uuid(),
       request: {
         message: message,
-        pubsubTopic: pubSubTopic,
+        pubsubTopic: pubsubTopic
       },
-      response: undefined,
+      response: undefined
     });
   }
 

package/src/lib/message/version_0.ts

@@ -7,10 +7,13 @@ import type {
   IMetaSetter,
   IProtoMessage,
   IRateLimitProof,
+  PubSubTopic
 } from "@waku/interfaces";
 import { proto_message as proto } from "@waku/proto";
 import debug from "debug";
 
+import { DefaultPubSubTopic } from "../constants.js";
+
 const log = debug("waku:message:version-0");
 const OneMillion = BigInt(1_000_000);
 
@@ -18,7 +21,10 @@ export const Version = 0;
 export { proto };
 
 export class DecodedMessage implements IDecodedMessage {
-  constructor(public pubSubTopic: string, protected proto: proto.WakuMessage) {}
+  constructor(
+    public pubsubTopic: string,
+    protected proto: proto.WakuMessage
+  ) {}
 
   get ephemeral(): boolean {
     return Boolean(this.proto.ephemeral);
@@ -70,6 +76,7 @@ export class Encoder implements IEncoder {
   constructor(
     public contentTopic: string,
     public ephemeral: boolean = false,
+    public pubsubTopic: PubSubTopic,
     public metaSetter?: IMetaSetter
   ) {
     if (!contentTopic || contentTopic === "") {
@@ -91,7 +98,7 @@ export class Encoder implements IEncoder {
       timestamp: BigInt(timestamp.valueOf()) * OneMillion,
       meta: undefined,
       rateLimitProof: message.rateLimitProof,
-      ephemeral: this.ephemeral,
+      ephemeral: this.ephemeral
     };
 
     if (this.metaSetter) {
@@ -106,22 +113,25 @@ export class Encoder implements IEncoder {
 /**
  * Creates an encoder that encode messages without Waku level encryption or signature.
  *
- * An encoder is used to encode messages in the [`14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/)
+ * An encoder is used to encode messages in the [14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/)
  * format to be sent over the Waku network. The resulting encoder can then be
- * pass to { @link @waku/interfaces.LightPush.push } or
- * { @link @waku/interfaces.Relay.send } to automatically encode outgoing
+ * pass to { @link @waku/interfaces!ISender.send } to automatically encode outgoing
  * messages.
  */
 export function createEncoder({
+  pubsubTopic = DefaultPubSubTopic,
   contentTopic,
   ephemeral,
-  metaSetter,
+  metaSetter
 }: EncoderOptions): Encoder {
-  return new Encoder(contentTopic, ephemeral, metaSetter);
+  return new Encoder(contentTopic, ephemeral, pubsubTopic, metaSetter);
 }
 
 export class Decoder implements IDecoder<DecodedMessage> {
-  constructor(public contentTopic: string) {
+  constructor(
+    public pubsubTopic: PubSubTopic,
+    public contentTopic: string
+  ) {
     if (!contentTopic || contentTopic === "") {
       throw new Error("Content topic must be specified");
     }
@@ -137,12 +147,12 @@ export class Decoder implements IDecoder<DecodedMessage> {
       timestamp: protoMessage.timestamp ?? undefined,
       meta: protoMessage.meta ?? undefined,
       rateLimitProof: protoMessage.rateLimitProof ?? undefined,
-      ephemeral: protoMessage.ephemeral ?? false,
+      ephemeral: protoMessage.ephemeral ?? false
     });
   }
 
   async fromProtoObj(
-    pubSubTopic: string,
+    pubsubTopic: string,
     proto: IProtoMessage
   ): Promise<DecodedMessage | undefined> {
     // https://rfc.vac.dev/spec/14/
@@ -157,7 +167,7 @@ export class Decoder implements IDecoder<DecodedMessage> {
       return Promise.resolve(undefined);
     }
 
-    return new DecodedMessage(pubSubTopic, proto);
+    return new DecodedMessage(pubsubTopic, proto);
   }
 }
 
@@ -166,12 +176,14 @@ export class Decoder implements IDecoder<DecodedMessage> {
  *
  * A decoder is used to decode messages from the [14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/)
  * format when received from the Waku network. The resulting decoder can then be
- * pass to { @link @waku/interfaces.Filter.subscribe } or
- * { @link @waku/interfaces.Relay.subscribe } to automatically decode incoming
+ * pass to { @link @waku/interfaces!IReceiver.subscribe } to automatically decode incoming
  * messages.
  *
  * @param contentTopic The resulting decoder will only decode messages with this content topic.
  */
-export function createDecoder(contentTopic: string): Decoder {
-  return new Decoder(contentTopic);
+export function createDecoder(
+  contentTopic: string,
+  pubsubTopic: PubSubTopic = DefaultPubSubTopic
+): Decoder {
+  return new Decoder(pubsubTopic, contentTopic);
 }

package/src/lib/predefined_bootstrap_nodes.ts

@@ -4,7 +4,7 @@ export const DefaultWantedNumber = 1;
 
 export enum Fleet {
   Prod = "prod",
-  Test = "test",
+  Test = "test"
 }
 
 /**
@@ -51,8 +51,8 @@ export const fleets = {
         "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",
-      },
+          "/dns4/node-01.gc-us-central1-a.wakuv2.prod.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmVkKntsECaYfefR1V2yCR79CegLATuTPE6B9TxgxBiiiA"
+      }
     },
     "wakuv2.test": {
       "waku-websocket": {
@@ -61,8 +61,8 @@ export const fleets = {
         "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",
-      },
-    },
-  },
+          "/dns4/node-01.gc-us-central1-a.wakuv2.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmJb2e28qLXxT5kZxVUUoJt72EMzNGXB47Rxx5hw3q4YjS"
+      }
+    }
+  }
 };

package/src/lib/store/history_rpc.ts

@@ -6,12 +6,12 @@ const OneMillion = BigInt(1_000_000);
 
 export enum PageDirection {
   BACKWARD = "backward",
-  FORWARD = "forward",
+  FORWARD = "forward"
 }
 
 export interface Params {
   contentTopics: string[];
-  pubSubTopic: string;
+  pubsubTopic: string;
   pageDirection: PageDirection;
   pageSize: number;
   startTime?: Date;
@@ -43,7 +43,7 @@ export class HistoryRpc {
     const pagingInfo = {
       pageSize: BigInt(params.pageSize),
       cursor: params.cursor,
-      direction,
+      direction
     } as proto.PagingInfo;
 
     let startTime, endTime;
@@ -59,13 +59,13 @@ export class HistoryRpc {
     return new HistoryRpc({
       requestId: uuid(),
       query: {
-        pubsubTopic: params.pubSubTopic,
+        pubsubTopic: params.pubsubTopic,
         contentFilters,
         pagingInfo,
         startTime,
-        endTime,
+        endTime
       },
-      response: undefined,
+      response: undefined
     });
   }