@waku/core 0.0.5 → 0.0.7

package/src/lib/waku.ts

@@ -1,24 +1,31 @@
 import type { Stream } from "@libp2p/interface-connection";
 import type { PeerId } from "@libp2p/interface-peer-id";
 import type { PubSub } from "@libp2p/interface-pubsub";
-import { peerIdFromString } from "@libp2p/peer-id";
 import type { Multiaddr } from "@multiformats/multiaddr";
-import { multiaddr } from "@multiformats/multiaddr";
-import type { Waku } from "@waku/interfaces";
+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, WakuFilter } from "./waku_filter";
-import { LightPushCodec, WakuLightPush } from "./waku_light_push";
-import { EncoderV0 } from "./waku_message/version_0";
-import { WakuRelay } from "./waku_relay";
-import { RelayCodecs, RelayPingContentTopic } from "./waku_relay/constants";
-import * as relayConstants from "./waku_relay/constants";
-import { StoreCodec, WakuStore } from "./waku_store";
+import { FilterCodec, FilterComponents } from "./filter/index.js";
+import { LightPushCodec, LightPushComponents } from "./light_push/index.js";
+import { createEncoder } from "./message/version_0.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;
+export const DefaultUserAgent = "js-waku";
 
 const log = debug("waku:waku");
 
@@ -37,14 +44,20 @@ export interface WakuOptions {
    * @default {@link DefaultRelayKeepAliveValueSecs}
    */
   relayKeepAlive?: number;
+  /**
+   * Set the user agent string to be used in identification of the node.
+   * @default {@link DefaultUserAgent}
+   */
+  userAgent?: string;
 }
 
 export class WakuNode implements Waku {
   public libp2p: Libp2p;
-  public relay?: WakuRelay;
-  public store?: WakuStore;
-  public filter?: WakuFilter;
-  public lightPush?: WakuLightPush;
+  public relay?: IRelay;
+  public store?: IStore;
+  public filter?: IFilter;
+  public lightPush?: ILightPush;
+  public peerExchange?: IPeerExchange;
 
   private pingKeepAliveTimers: {
     [peer: string]: ReturnType<typeof setInterval>;
@@ -56,16 +69,31 @@ export class WakuNode implements Waku {
   constructor(
     options: WakuOptions,
     libp2p: Libp2p,
-    store?: WakuStore,
-    lightPush?: WakuLightPush,
-    filter?: WakuFilter
+    store?: (components: StoreComponents) => IStore,
+    lightPush?: (components: LightPushComponents) => ILightPush,
+    filter?: (components: FilterComponents) => IFilter,
+    peerExchange?: (components: PeerExchangeComponents) => IPeerExchange
   ) {
     this.libp2p = libp2p;
-    this.store = store;
-    this.filter = filter;
-    this.lightPush = lightPush;
 
-    if (isWakuRelay(libp2p.pubsub)) {
+    const { peerStore, connectionManager, registrar } = libp2p;
+    const components = { peerStore, connectionManager, registrar };
+
+    if (store) {
+      this.store = store(components);
+    }
+    if (filter) {
+      this.filter = filter(components);
+    }
+    if (lightPush) {
+      this.lightPush = lightPush(components);
+    }
+
+    if (peerExchange) {
+      this.peerExchange = peerExchange(components);
+    }
+
+    if (isRelay(libp2p.pubsub)) {
       this.relay = libp2p.pubsub;
     }
 
@@ -73,7 +101,8 @@ export class WakuNode implements Waku {
       "Waku node created",
       this.libp2p.peerId.toString(),
       `relay: ${!!this.relay}, store: ${!!this.store}, light push: ${!!this
-        .lightPush}, filter: ${!!this.filter}`
+        .lightPush}, filter: ${!!this.filter}, peer exchange: ${!!this
+        .peerExchange} `
     );
 
     this.pingKeepAliveTimers = {};
@@ -103,19 +132,36 @@ export class WakuNode implements Waku {
     libp2p.connectionManager.addEventListener("peer:disconnect", (evt) => {
       this.stopKeepAlive(evt.detail.remotePeer);
     });
+
+    // 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);
+      });
+    });
   }
 
   /**
    * Dials to the provided peer.
    *
    * @param peer The peer to dial
-   * @param protocols Waku protocols we expect from the peer; Default to Relay
+   * @param protocols Waku protocols we expect from the peer; Defaults to mounted protocols
    */
   async dial(
     peer: PeerId | Multiaddr,
     protocols?: Protocols[]
   ): Promise<Stream> {
-    const _protocols = protocols ?? [Protocols.Relay];
+    const _protocols = protocols ?? [];
+
+    if (typeof protocols === "undefined") {
+      this.relay && _protocols.push(Protocols.Relay);
+      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)) {
@@ -131,32 +177,13 @@ export class WakuNode implements Waku {
       codecs.push(FilterCodec);
     }
 
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore: new Multiaddr is not backward compatible
-    return this.libp2p.dialProtocol(peer, codecs);
-  }
-
-  /**
-   * Add peer to address book, it will be auto-dialed in the background.
-   */
-  async addPeerToAddressBook(
-    peerId: PeerId | string,
-    multiaddrs: Multiaddr[] | string[]
-  ): Promise<void> {
-    let peer;
-    if (typeof peerId === "string") {
-      peer = peerIdFromString(peerId);
-    } else {
-      peer = peerId;
+    if (_protocols.includes(Protocols.PeerExchange)) {
+      codecs.push(PeerExchangeCodec);
     }
-    const addresses = multiaddrs.map((addr: Multiaddr | string) => {
-      if (typeof addr === "string") {
-        return multiaddr(addr);
-      } else {
-        return addr;
-      }
-    });
-    await this.libp2p.peerStore.addressBook.set(peer, addresses);
+
+    log(`Dialing to ${peer.toString()} with protocols ${_protocols}`);
+
+    return this.libp2p.dialProtocol(peer, codecs);
   }
 
   async start(): Promise<void> {
@@ -207,7 +234,7 @@ export class WakuNode implements Waku {
 
     const relay = this.relay;
     if (relay && relayPeriodSecs !== 0) {
-      const encoder = new EncoderV0(RelayPingContentTopic);
+      const encoder = createEncoder(RelayPingContentTopic);
       this.relayKeepAliveTimers[peerIdStr] = setInterval(() => {
         log("Sending Waku Relay ping message");
         relay
@@ -244,7 +271,7 @@ export class WakuNode implements Waku {
   }
 }
 
-function isWakuRelay(pubsub: PubSub): pubsub is WakuRelay {
+function isRelay(pubsub: PubSub): pubsub is IRelay {
   if (pubsub) {
     try {
       return pubsub.multicodecs.includes(