@waku/core 0.0.10 → 0.0.11

package/src/lib/store/index.ts

@@ -1,32 +1,27 @@
-import type { Connection } from "@libp2p/interface-connection";
-import type { ConnectionManager } from "@libp2p/interface-connection-manager";
+import type { Stream } from "@libp2p/interface-connection";
+import type { Libp2p } from "@libp2p/interface-libp2p";
 import type { PeerId } from "@libp2p/interface-peer-id";
-import type { Peer, PeerStore } from "@libp2p/interface-peer-store";
 import { sha256 } from "@noble/hashes/sha256";
-import { concat, utf8ToBytes } from "@waku/byte-utils";
 import {
   Cursor,
   IDecodedMessage,
   IDecoder,
-  Index,
   IStore,
+  ProtocolCreateOptions,
 } from "@waku/interfaces";
-import {
-  getPeersForProtocol,
-  selectConnection,
-  selectPeerForProtocol,
-} from "@waku/libp2p-utils";
 import { proto_store as proto } from "@waku/proto";
+import { concat, utf8ToBytes } from "@waku/utils/bytes";
 import debug from "debug";
 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";
 import { DefaultPubSubTopic } from "../constants.js";
 import { toProtoMessage } from "../to_proto_message.js";
 
-import { HistoryRPC, PageDirection, Params } from "./history_rpc.js";
+import { HistoryRpc, PageDirection, Params } from "./history_rpc.js";
 
 import HistoryError = proto.HistoryResponse.HistoryError;
 
@@ -38,23 +33,6 @@ export const DefaultPageSize = 10;
 
 export { PageDirection };
 
-export interface StoreComponents {
-  peerStore: PeerStore;
-  connectionManager: ConnectionManager;
-}
-
-export interface CreateOptions {
-  /**
-   * The PubSub Topic to use. Defaults to {@link DefaultPubSubTopic}.
-   *
-   * The usage of the default pubsub topic is recommended.
-   * See [Waku v2 Topic Usage Recommendations](https://rfc.vac.dev/spec/23/) for details.
-   *
-   * @default {@link DefaultPubSubTopic}
-   */
-  pubSubTopic?: string;
-}
-
 export interface TimeFilter {
   startTime: Date;
   endTime: Date;
@@ -65,11 +43,6 @@ export interface QueryOptions {
    * The peer to query. If undefined, a pseudo-random peer is selected from the connected Waku Store peers.
    */
   peerId?: PeerId;
-  /**
-   * The pubsub topic to pass to the query.
-   * See [Waku v2 Topic Usage Recommendations](https://rfc.vac.dev/spec/23/).
-   */
-  pubSubTopic?: string;
   /**
    * The direction in which pages are retrieved:
    * - { @link PageDirection.BACKWARD }: Most recent page first.
@@ -104,11 +77,12 @@ export interface QueryOptions {
  *
  * The Waku Store protocol can be used to retrieved historical messages.
  */
-class Store implements IStore {
-  pubSubTopic: string;
+class Store extends BaseProtocol implements IStore {
+  options: ProtocolCreateOptions;
 
-  constructor(public components: StoreComponents, options?: CreateOptions) {
-    this.pubSubTopic = options?.pubSubTopic ?? DefaultPubSubTopic;
+  constructor(public libp2p: Libp2p, options?: ProtocolCreateOptions) {
+    super(StoreCodec, libp2p.peerStore, libp2p.getConnections.bind(libp2p));
+    this.options = options ?? {};
   }
 
   /**
@@ -219,6 +193,8 @@ class Store implements IStore {
     decoders: IDecoder<T>[],
     options?: QueryOptions
   ): AsyncGenerator<Promise<T | undefined>[]> {
+    const { pubSubTopic = DefaultPubSubTopic } = this.options;
+
     let startTime, endTime;
 
     if (options?.timeFilter) {
@@ -240,7 +216,7 @@ class Store implements IStore {
 
     const queryOpts = Object.assign(
       {
-        pubSubTopic: this.pubSubTopic,
+        pubSubTopic: pubSubTopic,
         pageDirection: PageDirection.BACKWARD,
         pageSize: DefaultPageSize,
       },
@@ -253,27 +229,10 @@ class Store implements IStore {
       peerId: options?.peerId?.toString(),
     });
 
-    const res = await selectPeerForProtocol(
-      this.components.peerStore,
-      [StoreCodec],
-      options?.peerId
-    );
-
-    if (!res) {
-      throw new Error("Failed to get a peer");
-    }
-    const { peer, protocol } = res;
-
-    const connections = this.components.connectionManager.getConnections(
-      peer.id
-    );
-    const connection = selectConnection(connections);
-
-    if (!connection) throw "Failed to get a connection to the peer";
+    const peer = await this.getPeer(options?.peerId);
 
     for await (const messages of paginate<T>(
-      connection,
-      protocol,
+      this.newStream.bind(this, peer),
       queryOpts,
       decodersAsMap,
       options?.cursor
@@ -281,23 +240,10 @@ class Store implements IStore {
       yield messages;
     }
   }
-
-  /**
-   * Returns known peers from the address book (`libp2p.peerStore`) that support
-   * store protocol. Waku may or  may not be currently connected to these peers.
-   */
-  async peers(): Promise<Peer[]> {
-    return getPeersForProtocol(this.components.peerStore, [StoreCodec]);
-  }
-
-  get peerStore(): PeerStore {
-    return this.components.peerStore;
-  }
 }
 
 async function* paginate<T extends IDecodedMessage>(
-  connection: Connection,
-  protocol: string,
+  streamFactory: () => Promise<Stream>,
   queryOpts: Params,
   decoders: Map<string, IDecoder<T>>,
   cursor?: Cursor
@@ -315,16 +261,16 @@ async function* paginate<T extends IDecodedMessage>(
   while (true) {
     queryOpts.cursor = currentCursor;
 
-    const stream = await connection.newStream(protocol);
-    const historyRpcQuery = HistoryRPC.createQuery(queryOpts);
+    const historyRpcQuery = HistoryRpc.createQuery(queryOpts);
 
     log(
       "Querying store peer",
-      connection.remoteAddr.toString(),
       `for (${queryOpts.pubSubTopic})`,
       queryOpts.contentTopics
     );
 
+    const stream = await streamFactory();
+
     const res = await pipe(
       [historyRpcQuery.encode()],
       lp.encode(),
@@ -347,10 +293,7 @@ async function* paginate<T extends IDecodedMessage>(
 
     const response = reply.response as proto.HistoryResponse;
 
-    if (
-      response.error &&
-      response.error !== HistoryError.ERROR_NONE_UNSPECIFIED
-    ) {
+    if (response.error && response.error !== HistoryError.NONE) {
       throw "History response contains an Error: " + response.error;
     }
 
@@ -368,7 +311,10 @@ async function* paginate<T extends IDecodedMessage>(
       if (typeof contentTopic !== "undefined") {
         const decoder = decoders.get(contentTopic);
         if (decoder) {
-          return decoder.fromProtoObj(toProtoMessage(protoMsg));
+          return decoder.fromProtoObj(
+            queryOpts.pubSubTopic,
+            toProtoMessage(protoMsg)
+          );
         }
       }
       return Promise.resolve(undefined);
@@ -406,7 +352,7 @@ export function isDefined<T>(msg: T | undefined): msg is T {
 export async function createCursor(
   message: IDecodedMessage,
   pubsubTopic: string = DefaultPubSubTopic
-): Promise<Index> {
+): Promise<Cursor> {
   if (
     !message ||
     !message.timestamp ||
@@ -426,12 +372,12 @@ export async function createCursor(
     digest,
     pubsubTopic,
     senderTime: messageTime,
-    receivedTime: messageTime,
+    receiverTime: messageTime,
   };
 }
 
 export function wakuStore(
-  init: Partial<CreateOptions> = {}
-): (components: StoreComponents) => IStore {
-  return (components: StoreComponents) => new Store(components, init);
+  init: Partial<ProtocolCreateOptions> = {}
+): (libp2p: Libp2p) => IStore {
+  return (libp2p: Libp2p) => new Store(libp2p, init);
 }

package/src/lib/to_proto_message.ts

@@ -2,10 +2,11 @@ import { IProtoMessage } from "@waku/interfaces";
 import { WakuMessage as WakuMessageProto } from "@waku/proto";
 
 const EmptyMessage: IProtoMessage = {
-  payload: undefined,
-  contentTopic: undefined,
+  payload: new Uint8Array(),
+  contentTopic: "",
   version: undefined,
   timestamp: undefined,
+  meta: undefined,
   rateLimitProof: undefined,
   ephemeral: undefined,
 };

package/src/lib/wait_for_remote_peer.ts

@@ -1,14 +1,9 @@
-import { PeerProtocolsChangeData } from "@libp2p/interface-peer-store";
+import type { PeerProtocolsChangeData } from "@libp2p/interface-peer-store";
 import type { IRelay, PointToPointProtocol, Waku } from "@waku/interfaces";
 import { Protocols } from "@waku/interfaces";
-import { PeerExchangeCodec } from "@waku/peer-exchange";
 import debug from "debug";
 import { pEvent } from "p-event";
 
-import { FilterCodec } from "./filter/index.js";
-import { LightPushCodec } from "./light_push/index.js";
-import { StoreCodec } from "./store/index.js";
-
 const log = debug("waku:wait-for-remote-peer");
 
 /**
@@ -50,27 +45,19 @@ 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, [StoreCodec]));
+    promises.push(waitForConnectedPeer(waku.store));
   }
 
   if (protocols.includes(Protocols.LightPush)) {
     if (!waku.lightPush)
       throw new Error("Cannot wait for LightPush peer: protocol not mounted");
-    promises.push(waitForConnectedPeer(waku.lightPush, [LightPushCodec]));
+    promises.push(waitForConnectedPeer(waku.lightPush));
   }
 
   if (protocols.includes(Protocols.Filter)) {
     if (!waku.filter)
       throw new Error("Cannot wait for Filter peer: protocol not mounted");
-    promises.push(waitForConnectedPeer(waku.filter, [FilterCodec]));
-  }
-
-  if (protocols.includes(Protocols.PeerExchange)) {
-    if (!waku.peerExchange)
-      throw new Error(
-        "Cannot wait for Peer Exchange peer: protocol not mounted"
-      );
-    promises.push(waitForConnectedPeer(waku.peerExchange, [PeerExchangeCodec]));
+    promises.push(waitForConnectedPeer(waku.filter));
   }
 
   if (timeoutMs) {
@@ -88,28 +75,25 @@ export async function waitForRemotePeer(
  * Wait for a peer with the given protocol to be connected.
  */
 async function waitForConnectedPeer(
-  waku: PointToPointProtocol,
-  codecs: string[]
+  protocol: PointToPointProtocol
 ): Promise<void> {
-  const peers = await waku.peers();
+  const codec = protocol.multicodec;
+  const peers = await protocol.peers();
 
   if (peers.length) {
-    log(`${codecs} peer found: `, peers[0].id.toString());
+    log(`${codec} peer found: `, peers[0].id.toString());
     return;
   }
 
   await new Promise<void>((resolve) => {
     const cb = (evt: CustomEvent<PeerProtocolsChangeData>): void => {
-      for (const codec of codecs) {
-        if (evt.detail.protocols.includes(codec)) {
-          log("Resolving for", codec, evt.detail.protocols);
-          waku.peerStore.removeEventListener("change:protocols", cb);
-          resolve();
-          break;
-        }
+      if (evt.detail.protocols.includes(codec)) {
+        log("Resolving for", codec, evt.detail.protocols);
+        protocol.peerStore.removeEventListener("change:protocols", cb);
+        resolve();
       }
     };
-    waku.peerStore.addEventListener("change:protocols", cb);
+    protocol.peerStore.addEventListener("change:protocols", cb);
   });
 }
 

package/src/lib/waku.ts

@@ -1,27 +1,20 @@
 import type { Stream } from "@libp2p/interface-connection";
+import type { Libp2p } from "@libp2p/interface-libp2p";
 import type { PeerId } from "@libp2p/interface-peer-id";
 import type { PubSub } from "@libp2p/interface-pubsub";
 import type { Multiaddr } from "@multiformats/multiaddr";
 import type {
   IFilter,
   ILightPush,
-  IPeerExchange,
   IRelay,
   IStore,
-  PeerExchangeComponents,
   Waku,
 } from "@waku/interfaces";
 import { Protocols } from "@waku/interfaces";
-import { PeerExchangeCodec } from "@waku/peer-exchange";
 import debug from "debug";
-import type { Libp2p } from "libp2p";
 
-import { FilterCodec, FilterComponents } from "./filter/index.js";
-import { LightPushCodec, LightPushComponents } from "./light_push/index.js";
-import { createEncoder } from "./message/version_0.js";
+import { ConnectionManager } from "./connection_manager.js";
 import * as relayConstants from "./relay/constants.js";
-import { RelayCodecs, RelayPingContentTopic } from "./relay/constants.js";
-import { StoreCodec, StoreComponents } from "./store/index.js";
 
 export const DefaultPingKeepAliveValueSecs = 0;
 export const DefaultRelayKeepAliveValueSecs = 5 * 60;
@@ -34,19 +27,19 @@ export interface WakuOptions {
    * Set keep alive frequency in seconds: Waku will send a `/ipfs/ping/1.0.0`
    * request to each peer after the set number of seconds. Set to 0 to disable.
    *
-   * @default {@link DefaultPingKeepAliveValueSecs}
+   * @default {@link @waku/core.DefaultPingKeepAliveValueSecs}
    */
   pingKeepAlive?: number;
   /**
    * Set keep alive frequency in seconds: Waku will send a ping message over
    * relay to each peer after the set number of seconds. Set to 0 to disable.
    *
-   * @default {@link DefaultRelayKeepAliveValueSecs}
+   * @default {@link @waku/core.DefaultRelayKeepAliveValueSecs}
    */
   relayKeepAlive?: number;
   /**
    * Set the user agent string to be used in identification of the node.
-   * @default {@link DefaultUserAgent}
+   * @default {@link @waku/core.DefaultUserAgent}
    */
   userAgent?: string;
 }
@@ -57,90 +50,52 @@ export class WakuNode implements Waku {
   public store?: IStore;
   public filter?: IFilter;
   public lightPush?: ILightPush;
-  public peerExchange?: IPeerExchange;
-
-  private pingKeepAliveTimers: {
-    [peer: string]: ReturnType<typeof setInterval>;
-  };
-  private relayKeepAliveTimers: {
-    [peer: string]: ReturnType<typeof setInterval>;
-  };
+  public connectionManager: ConnectionManager;
 
   constructor(
     options: WakuOptions,
     libp2p: Libp2p,
-    store?: (components: StoreComponents) => IStore,
-    lightPush?: (components: LightPushComponents) => ILightPush,
-    filter?: (components: FilterComponents) => IFilter,
-    peerExchange?: (components: PeerExchangeComponents) => IPeerExchange
+    store?: (libp2p: Libp2p) => IStore,
+    lightPush?: (libp2p: Libp2p) => ILightPush,
+    filter?: (libp2p: Libp2p) => IFilter
   ) {
     this.libp2p = libp2p;
 
-    const { peerStore, connectionManager, registrar } = libp2p;
-    const components = { peerStore, connectionManager, registrar };
-
     if (store) {
-      this.store = store(components);
+      this.store = store(libp2p);
     }
     if (filter) {
-      this.filter = filter(components);
+      this.filter = filter(libp2p);
     }
     if (lightPush) {
-      this.lightPush = lightPush(components);
-    }
-
-    if (peerExchange) {
-      this.peerExchange = peerExchange(components);
+      this.lightPush = lightPush(libp2p);
     }
 
     if (isRelay(libp2p.pubsub)) {
       this.relay = libp2p.pubsub;
     }
 
-    log(
-      "Waku node created",
-      this.libp2p.peerId.toString(),
-      `relay: ${!!this.relay}, store: ${!!this.store}, light push: ${!!this
-        .lightPush}, filter: ${!!this.filter}, peer exchange: ${!!this
-        .peerExchange} `
-    );
-
-    this.pingKeepAliveTimers = {};
-    this.relayKeepAliveTimers = {};
-
     const pingKeepAlive =
       options.pingKeepAlive || DefaultPingKeepAliveValueSecs;
     const relayKeepAlive = this.relay
       ? options.relayKeepAlive || DefaultRelayKeepAliveValueSecs
       : 0;
 
-    libp2p.connectionManager.addEventListener("peer:connect", (evt) => {
-      this.startKeepAlive(evt.detail.remotePeer, pingKeepAlive, relayKeepAlive);
-    });
+    const peerId = this.libp2p.peerId.toString();
 
-    /**
-     * NOTE: Event is not being emitted on closing nor losing a connection.
-     * @see https://github.com/libp2p/js-libp2p/issues/939
-     * @see https://github.com/status-im/js-waku/issues/252
-     *
-     * >This event will be triggered anytime we are disconnected from another peer,
-     * >regardless of the circumstances of that disconnection.
-     * >If we happen to have multiple connections to a peer,
-     * >this event will **only** be triggered when the last connection is closed.
-     * @see https://github.com/libp2p/js-libp2p/blob/bad9e8c0ff58d60a78314077720c82ae331cc55b/doc/API.md?plain=1#L2100
-     */
-    libp2p.connectionManager.addEventListener("peer:disconnect", (evt) => {
-      this.stopKeepAlive(evt.detail.remotePeer);
-    });
+    this.connectionManager = ConnectionManager.create(
+      peerId,
+      libp2p,
+      { pingKeepAlive, relayKeepAlive },
+      this.relay
+    );
 
-    // Trivial handling of discovered peers, to be refined.
-    libp2p.addEventListener("peer:discovery", (evt) => {
-      const peerId = evt.detail.id;
-      log(`Found peer ${peerId.toString()}, dialing.`);
-      libp2p.dial(peerId).catch((err) => {
-        log(`Fail to dial ${peerId}`, err);
-      });
-    });
+    log(
+      "Waku node created",
+      peerId,
+      `relay: ${!!this.relay}, store: ${!!this.store}, light push: ${!!this
+        .lightPush}, filter: ${!!this.filter}`
+    );
   }
 
   /**
@@ -160,25 +115,44 @@ export class WakuNode implements Waku {
       this.store && _protocols.push(Protocols.Store);
       this.filter && _protocols.push(Protocols.Filter);
       this.lightPush && _protocols.push(Protocols.LightPush);
-      this.peerExchange && _protocols.push(Protocols.PeerExchange);
     }
 
     const codecs: string[] = [];
     if (_protocols.includes(Protocols.Relay)) {
-      RelayCodecs.forEach((codec) => codecs.push(codec));
+      if (this.relay) {
+        this.relay.multicodecs.forEach((codec) => codecs.push(codec));
+      } else {
+        log(
+          "Relay codec not included in dial codec: protocol not mounted locally"
+        );
+      }
     }
     if (_protocols.includes(Protocols.Store)) {
-      codecs.push(StoreCodec);
+      if (this.store) {
+        codecs.push(this.store.multicodec);
+      } else {
+        log(
+          "Store codec not included in dial codec: protocol not mounted locally"
+        );
+      }
     }
     if (_protocols.includes(Protocols.LightPush)) {
-      codecs.push(LightPushCodec);
+      if (this.lightPush) {
+        codecs.push(this.lightPush.multicodec);
+      } else {
+        log(
+          "Light Push codec not included in dial codec: protocol not mounted locally"
+        );
+      }
     }
     if (_protocols.includes(Protocols.Filter)) {
-      codecs.push(FilterCodec);
-    }
-
-    if (_protocols.includes(Protocols.PeerExchange)) {
-      codecs.push(PeerExchangeCodec);
+      if (this.filter) {
+        codecs.push(this.filter.multicodec);
+      } else {
+        log(
+          "Filter codec not included in dial codec: protocol not mounted locally"
+        );
+      }
     }
 
     log(`Dialing to ${peer.toString()} with protocols ${_protocols}`);
@@ -191,7 +165,7 @@ export class WakuNode implements Waku {
   }
 
   async stop(): Promise<void> {
-    this.stopAllKeepAlives();
+    this.connectionManager.stop();
     await this.libp2p.stop();
   }
 
@@ -213,62 +187,6 @@ export class WakuNode implements Waku {
     }
     return localMultiaddr + "/p2p/" + this.libp2p.peerId.toString();
   }
-
-  private startKeepAlive(
-    peerId: PeerId,
-    pingPeriodSecs: number,
-    relayPeriodSecs: number
-  ): void {
-    // Just in case a timer already exist for this peer
-    this.stopKeepAlive(peerId);
-
-    const peerIdStr = peerId.toString();
-
-    if (pingPeriodSecs !== 0) {
-      this.pingKeepAliveTimers[peerIdStr] = setInterval(() => {
-        this.libp2p.ping(peerId).catch((e) => {
-          log(`Ping failed (${peerIdStr})`, e);
-        });
-      }, pingPeriodSecs * 1000);
-    }
-
-    const relay = this.relay;
-    if (relay && relayPeriodSecs !== 0) {
-      const encoder = createEncoder(RelayPingContentTopic, true);
-      this.relayKeepAliveTimers[peerIdStr] = setInterval(() => {
-        log("Sending Waku Relay ping message");
-        relay
-          .send(encoder, { payload: new Uint8Array() })
-          .catch((e) => log("Failed to send relay ping", e));
-      }, relayPeriodSecs * 1000);
-    }
-  }
-
-  private stopKeepAlive(peerId: PeerId): void {
-    const peerIdStr = peerId.toString();
-
-    if (this.pingKeepAliveTimers[peerIdStr]) {
-      clearInterval(this.pingKeepAliveTimers[peerIdStr]);
-      delete this.pingKeepAliveTimers[peerIdStr];
-    }
-
-    if (this.relayKeepAliveTimers[peerIdStr]) {
-      clearInterval(this.relayKeepAliveTimers[peerIdStr]);
-      delete this.relayKeepAliveTimers[peerIdStr];
-    }
-  }
-
-  private stopAllKeepAlives(): void {
-    for (const timer of [
-      ...Object.values(this.pingKeepAliveTimers),
-      ...Object.values(this.relayKeepAliveTimers),
-    ]) {
-      clearInterval(timer);
-    }
-
-    this.pingKeepAliveTimers = {};
-    this.relayKeepAliveTimers = {};
-  }
 }
 
 function isRelay(pubsub: PubSub): pubsub is IRelay {