@waku/core 0.0.6 → 0.0.8

package/src/lib/{waku_message → message}/version_0.ts

@@ -1,22 +1,21 @@
 import type {
-  DecodedMessage,
-  Decoder,
-  Encoder,
-  Message,
-  ProtoMessage,
-  RateLimitProof,
+  IDecodedMessage,
+  IDecoder,
+  IEncoder,
+  IMessage,
+  IProtoMessage,
+  IRateLimitProof,
 } from "@waku/interfaces";
+import { proto_message as proto } from "@waku/proto";
 import debug from "debug";
 
-import * as proto from "../../proto/message";
-
 const log = debug("waku:message:version-0");
 const OneMillion = BigInt(1_000_000);
 
 export const Version = 0;
 export { proto };
 
-export class MessageV0 implements DecodedMessage {
+export class DecodedMessage implements IDecodedMessage {
   constructor(protected proto: proto.WakuMessage) {}
 
   get _rawPayload(): Uint8Array | undefined {
@@ -66,19 +65,19 @@ export class MessageV0 implements DecodedMessage {
     return this.proto.version ?? 0;
   }
 
-  get rateLimitProof(): RateLimitProof | undefined {
+  get rateLimitProof(): IRateLimitProof | undefined {
     return this.proto.rateLimitProof;
   }
 }
 
-export class EncoderV0 implements Encoder {
+export class Encoder implements IEncoder {
   constructor(public contentTopic: string, public ephemeral: boolean = false) {}
 
-  async toWire(message: Partial<Message>): Promise<Uint8Array> {
+  async toWire(message: IMessage): Promise<Uint8Array> {
     return proto.WakuMessage.encode(await this.toProtoObj(message));
   }
 
-  async toProtoObj(message: Partial<Message>): Promise<ProtoMessage> {
+  async toProtoObj(message: IMessage): Promise<IProtoMessage> {
     const timestamp = message.timestamp ?? new Date();
 
     return {
@@ -92,10 +91,29 @@ export class EncoderV0 implements Encoder {
   }
 }
 
-export class DecoderV0 implements Decoder<MessageV0> {
-  constructor(public contentTopic: string, public ephemeral: boolean = false) {}
+/**
+ * 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/)
+ * 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
+ * messages.
+ *
+ * @param contentTopic The content topic to set on outgoing messages.
+ * @param ephemeral An optional flag to mark message as ephemeral, ie, not to be stored by Waku Store nodes.
+ */
+export function createEncoder(
+  contentTopic: string,
+  ephemeral = false
+): Encoder {
+  return new Encoder(contentTopic, ephemeral);
+}
 
-  fromWireToProtoObj(bytes: Uint8Array): Promise<ProtoMessage | undefined> {
+export class Decoder implements IDecoder<DecodedMessage> {
+  constructor(public contentTopic: string) {}
+
+  fromWireToProtoObj(bytes: Uint8Array): Promise<IProtoMessage | undefined> {
     const protoMessage = proto.WakuMessage.decode(bytes);
     log("Message decoded", protoMessage);
     return Promise.resolve({
@@ -108,7 +126,9 @@ export class DecoderV0 implements Decoder<MessageV0> {
     });
   }
 
-  async fromProtoObj(proto: ProtoMessage): Promise<MessageV0 | undefined> {
+  async fromProtoObj(
+    proto: IProtoMessage
+  ): Promise<DecodedMessage | undefined> {
     // https://github.com/status-im/js-waku/issues/921
     if (proto.version === undefined) {
       proto.version = 0;
@@ -124,6 +144,21 @@ export class DecoderV0 implements Decoder<MessageV0> {
       return Promise.resolve(undefined);
     }
 
-    return new MessageV0(proto);
+    return new DecodedMessage(proto);
   }
 }
+
+/**
+ * Creates an decoder that decode messages without Waku level encryption.
+ *
+ * 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
+ * messages.
+ *
+ * @param contentTopic The resulting decoder will only decode messages with this content topic.
+ */
+export function createDecoder(contentTopic: string): Decoder {
+  return new Decoder(contentTopic);
+}

package/src/lib/predefined_bootstrap_nodes.ts

@@ -1,4 +1,4 @@
-import { getPseudoRandomSubset } from "./random_subset";
+import { getPseudoRandomSubset } from "./random_subset.js";
 
 export const DefaultWantedNumber = 1;
 

package/src/lib/{waku_relay → relay}/index.ts

@@ -4,32 +4,29 @@ import {
   GossipsubMessage,
   GossipsubOpts,
 } from "@chainsafe/libp2p-gossipsub";
-import {
-  PeerIdStr,
-  TopicStr,
-} from "@chainsafe/libp2p-gossipsub/dist/src/types";
+import type { PeerIdStr, TopicStr } from "@chainsafe/libp2p-gossipsub/types";
 import { SignaturePolicy } from "@chainsafe/libp2p-gossipsub/types";
 import type {
   Callback,
-  Decoder,
-  Encoder,
-  Message,
-  Relay,
+  IDecoder,
+  IEncoder,
+  IMessage,
+  IRelay,
   SendResult,
 } from "@waku/interfaces";
-import { DecodedMessage } from "@waku/interfaces";
+import { IDecodedMessage } from "@waku/interfaces";
 import debug from "debug";
 
-import { DefaultPubSubTopic } from "../constants";
-import { pushOrInitMapSet } from "../push_or_init_map";
-import { TopicOnlyDecoder } from "../waku_message/topic_only_message";
+import { DefaultPubSubTopic } from "../constants.js";
+import { TopicOnlyDecoder } from "../message/topic_only_message.js";
+import { pushOrInitMapSet } from "../push_or_init_map.js";
 
-import * as constants from "./constants";
+import * as constants from "./constants.js";
 
 const log = debug("waku:relay");
 
-export type Observer<T extends DecodedMessage> = {
-  decoder: Decoder<T>;
+export type Observer<T extends IDecodedMessage> = {
+  decoder: IDecoder<T>;
   callback: Callback<T>;
 };
 
@@ -56,9 +53,9 @@ export type CreateOptions = {
  *
  * @implements {require('libp2p-interfaces/src/pubsub')}
  */
-class WakuRelay extends GossipSub implements Relay {
+class Relay extends GossipSub implements IRelay {
   pubSubTopic: string;
-  defaultDecoder: Decoder<DecodedMessage>;
+  defaultDecoder: IDecoder<IDecodedMessage>;
   public static multicodec: string = constants.RelayCodecs[0];
 
   /**
@@ -102,10 +99,7 @@ class WakuRelay extends GossipSub implements Relay {
   /**
    * Send Waku message.
    */
-  public async send(
-    encoder: Encoder,
-    message: Partial<Message>
-  ): Promise<SendResult> {
+  public async send(encoder: IEncoder, message: IMessage): Promise<SendResult> {
     const msg = await encoder.toWire(message);
     if (!msg) {
       log("Failed to encode message, aborting publish");
@@ -119,8 +113,8 @@ class WakuRelay extends GossipSub implements Relay {
    *
    * @returns Function to delete the observer
    */
-  addObserver<T extends DecodedMessage>(
-    decoder: Decoder<T>,
+  addObserver<T extends IDecodedMessage>(
+    decoder: IDecoder<T>,
     callback: Callback<T>
   ): () => void {
     const observer = {
@@ -191,10 +185,10 @@ class WakuRelay extends GossipSub implements Relay {
   }
 }
 
-WakuRelay.multicodec = constants.RelayCodecs[constants.RelayCodecs.length - 1];
+Relay.multicodec = constants.RelayCodecs[constants.RelayCodecs.length - 1];
 
 export function wakuRelay(
   init: Partial<CreateOptions> = {}
-): (components: GossipSubComponents) => Relay {
-  return (components: GossipSubComponents) => new WakuRelay(components, init);
+): (components: GossipSubComponents) => IRelay {
+  return (components: GossipSubComponents) => new Relay(components, init);
 }

package/src/lib/{waku_store → store}/history_rpc.ts

@@ -1,8 +1,7 @@
+import { proto_store as proto } from "@waku/proto";
 import type { Uint8ArrayList } from "uint8arraylist";
 import { v4 as uuid } from "uuid";
 
-import * as proto from "../../proto/store";
-
 const OneMillion = BigInt(1_000_000);
 
 export enum PageDirection {

package/src/lib/{waku_store → store}/index.ts

@@ -4,20 +4,29 @@ 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 { DecodedMessage, Decoder, Index, Store } from "@waku/interfaces";
+import {
+  Cursor,
+  IDecodedMessage,
+  IDecoder,
+  Index,
+  IStore,
+} from "@waku/interfaces";
+import {
+  getPeersForProtocol,
+  selectConnection,
+  selectPeerForProtocol,
+} from "@waku/libp2p-utils";
+import { proto_store as proto } from "@waku/proto";
 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 * as proto from "../../proto/store";
-import { DefaultPubSubTopic } from "../constants";
-import { selectConnection } from "../select_connection";
-import { getPeersForProtocol, selectPeerForProtocol } from "../select_peer";
-import { toProtoMessage } from "../to_proto_message";
+import { DefaultPubSubTopic } from "../constants.js";
+import { toProtoMessage } from "../to_proto_message.js";
 
-import { HistoryRPC, PageDirection, Params } from "./history_rpc";
+import { HistoryRPC, PageDirection, Params } from "./history_rpc.js";
 
 import HistoryError = proto.HistoryResponse.HistoryError;
 
@@ -84,8 +93,10 @@ export interface QueryOptions {
   timeFilter?: TimeFilter;
   /**
    * Cursor as an index to start a query from.
+   * The cursor index will be exclusive (i.e. the message at the cursor index will not be included in the result).
+   * If undefined, the query will start from the beginning or end of the history, depending on the page direction.
    */
-  cursor?: Index;
+  cursor?: Cursor;
 }
 
 /**
@@ -93,7 +104,7 @@ export interface QueryOptions {
  *
  * The Waku Store protocol can be used to retrieved historical messages.
  */
-class WakuStore implements Store {
+class Store implements IStore {
   pubSubTopic: string;
 
   constructor(public components: StoreComponents, options?: CreateOptions) {
@@ -117,8 +128,8 @@ class WakuStore implements Store {
    * or if an error is encountered when processing the reply,
    * or if two decoders with the same content topic are passed.
    */
-  async queryOrderedCallback<T extends DecodedMessage>(
-    decoders: Decoder<T>[],
+  async queryOrderedCallback<T extends IDecodedMessage>(
+    decoders: IDecoder<T>[],
     callback: (message: T) => Promise<void | boolean> | boolean | void,
     options?: QueryOptions
   ): Promise<void> {
@@ -166,8 +177,8 @@ class WakuStore implements Store {
    * or if an error is encountered when processing the reply,
    * or if two decoders with the same content topic are passed.
    */
-  async queryCallbackOnPromise<T extends DecodedMessage>(
-    decoders: Decoder<T>[],
+  async queryCallbackOnPromise<T extends IDecodedMessage>(
+    decoders: IDecoder<T>[],
     callback: (
       message: Promise<T | undefined>
     ) => Promise<void | boolean> | boolean | void,
@@ -204,8 +215,8 @@ class WakuStore implements Store {
    * or if an error is encountered when processing the reply,
    * or if two decoders with the same content topic are passed.
    */
-  async *queryGenerator<T extends DecodedMessage>(
-    decoders: Decoder<T>[],
+  async *queryGenerator<T extends IDecodedMessage>(
+    decoders: IDecoder<T>[],
     options?: QueryOptions
   ): AsyncGenerator<Promise<T | undefined>[]> {
     let startTime, endTime;
@@ -284,12 +295,12 @@ class WakuStore implements Store {
   }
 }
 
-async function* paginate<T extends DecodedMessage>(
+async function* paginate<T extends IDecodedMessage>(
   connection: Connection,
   protocol: string,
   queryOpts: Params,
-  decoders: Map<string, Decoder<T>>,
-  cursor?: Index
+  decoders: Map<string, IDecoder<T>>,
+  cursor?: Cursor
 ): AsyncGenerator<Promise<T | undefined>[]> {
   if (
     queryOpts.contentTopics.toString() !==
@@ -300,8 +311,9 @@ async function* paginate<T extends DecodedMessage>(
     );
   }
 
+  let currentCursor = cursor;
   while (true) {
-    queryOpts = Object.assign(queryOpts, { cursor });
+    queryOpts.cursor = currentCursor;
 
     const stream = await connection.newStream(protocol);
     const historyRpcQuery = HistoryRPC.createQuery(queryOpts);
@@ -362,8 +374,8 @@ async function* paginate<T extends DecodedMessage>(
       return Promise.resolve(undefined);
     });
 
-    cursor = response.pagingInfo?.cursor;
-    if (typeof cursor === "undefined") {
+    const nextCursor = response.pagingInfo?.cursor;
+    if (typeof nextCursor === "undefined") {
       // If the server does not return cursor then there is an issue,
       // Need to abort, or we end up in an infinite loop
       log(
@@ -372,6 +384,8 @@ async function* paginate<T extends DecodedMessage>(
       break;
     }
 
+    currentCursor = nextCursor;
+
     const responsePageSize = response.pagingInfo?.pageSize;
     const queryPageSize = historyRpcQuery.query?.pagingInfo?.pageSize;
     if (
@@ -390,7 +404,7 @@ export function isDefined<T>(msg: T | undefined): msg is T {
 }
 
 export async function createCursor(
-  message: DecodedMessage,
+  message: IDecodedMessage,
   pubsubTopic: string = DefaultPubSubTopic
 ): Promise<Index> {
   if (
@@ -418,6 +432,6 @@ export async function createCursor(
 
 export function wakuStore(
   init: Partial<CreateOptions> = {}
-): (components: StoreComponents) => Store {
-  return (components: StoreComponents) => new WakuStore(components, init);
+): (components: StoreComponents) => IStore {
+  return (components: StoreComponents) => new Store(components, init);
 }

package/src/lib/to_proto_message.ts

@@ -1,8 +1,7 @@
-import { ProtoMessage } from "@waku/interfaces";
+import { IProtoMessage } from "@waku/interfaces";
+import { WakuMessage as WakuMessageProto } from "@waku/proto";
 
-import { WakuMessage as WakuMessageProto } from "../proto/message";
-
-const EmptyMessage: ProtoMessage = {
+const EmptyMessage: IProtoMessage = {
   payload: undefined,
   contentTopic: undefined,
   version: undefined,
@@ -11,6 +10,6 @@ const EmptyMessage: ProtoMessage = {
   ephemeral: undefined,
 };
 
-export function toProtoMessage(wire: WakuMessageProto): ProtoMessage {
+export function toProtoMessage(wire: WakuMessageProto): IProtoMessage {
   return { ...EmptyMessage, ...wire };
 }

package/src/lib/wait_for_remote_peer.ts

@@ -1,12 +1,13 @@
 import { PeerProtocolsChangeData } from "@libp2p/interface-peer-store";
-import type { PointToPointProtocol, Relay, Waku } from "@waku/interfaces";
+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 "./waku_filter";
-import { LightPushCodec } from "./waku_light_push";
-import { StoreCodec } from "./waku_store";
+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");
 
@@ -64,6 +65,14 @@ export async function waitForRemotePeer(
     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]));
+  }
+
   if (timeoutMs) {
     await rejectOnTimeout(
       Promise.all(promises),
@@ -108,7 +117,7 @@ async function waitForConnectedPeer(
  * Wait for a peer with the given protocol to be connected and in the gossipsub
  * mesh.
  */
-async function waitForGossipSubPeerInMesh(waku: Relay): Promise<void> {
+async function waitForGossipSubPeerInMesh(waku: IRelay): Promise<void> {
   let peers = waku.getMeshPeers();
 
   while (peers.length == 0) {
@@ -146,6 +155,9 @@ function getEnabledProtocols(waku: Waku): Protocols[] {
   if (waku.lightPush) {
     protocols.push(Protocols.LightPush);
   }
+  if (waku.peerExchange) {
+    protocols.push(Protocols.PeerExchange);
+  }
 
   return protocols;
 }

package/src/lib/waku.ts

@@ -2,17 +2,26 @@ import type { Stream } from "@libp2p/interface-connection";
 import type { PeerId } from "@libp2p/interface-peer-id";
 import type { PubSub } from "@libp2p/interface-pubsub";
 import type { Multiaddr } from "@multiformats/multiaddr";
-import type { Filter, LightPush, Relay, Store, 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, FilterComponents } from "./waku_filter";
-import { LightPushCodec, LightPushComponents } from "./waku_light_push";
-import { EncoderV0 } from "./waku_message/version_0";
-import * as relayConstants from "./waku_relay/constants";
-import { RelayCodecs, RelayPingContentTopic } from "./waku_relay/constants";
-import { StoreCodec, StoreComponents } 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;
@@ -44,10 +53,11 @@ export interface WakuOptions {
 
 export class WakuNode implements Waku {
   public libp2p: Libp2p;
-  public relay?: Relay;
-  public store?: Store;
-  public filter?: Filter;
-  public lightPush?: LightPush;
+  public relay?: IRelay;
+  public store?: IStore;
+  public filter?: IFilter;
+  public lightPush?: ILightPush;
+  public peerExchange?: IPeerExchange;
 
   private pingKeepAliveTimers: {
     [peer: string]: ReturnType<typeof setInterval>;
@@ -59,9 +69,10 @@ export class WakuNode implements Waku {
   constructor(
     options: WakuOptions,
     libp2p: Libp2p,
-    store?: (components: StoreComponents) => Store,
-    lightPush?: (components: LightPushComponents) => LightPush,
-    filter?: (components: FilterComponents) => Filter
+    store?: (components: StoreComponents) => IStore,
+    lightPush?: (components: LightPushComponents) => ILightPush,
+    filter?: (components: FilterComponents) => IFilter,
+    peerExchange?: (components: PeerExchangeComponents) => IPeerExchange
   ) {
     this.libp2p = libp2p;
 
@@ -78,6 +89,10 @@ export class WakuNode implements Waku {
       this.lightPush = lightPush(components);
     }
 
+    if (peerExchange) {
+      this.peerExchange = peerExchange(components);
+    }
+
     if (isRelay(libp2p.pubsub)) {
       this.relay = libp2p.pubsub;
     }
@@ -86,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 = {};
@@ -144,6 +160,7 @@ 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[] = [];
@@ -160,6 +177,12 @@ export class WakuNode implements Waku {
       codecs.push(FilterCodec);
     }
 
+    if (_protocols.includes(Protocols.PeerExchange)) {
+      codecs.push(PeerExchangeCodec);
+    }
+
+    log(`Dialing to ${peer.toString()} with protocols ${_protocols}`);
+
     return this.libp2p.dialProtocol(peer, codecs);
   }
 
@@ -211,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
@@ -248,7 +271,7 @@ export class WakuNode implements Waku {
   }
 }
 
-function isRelay(pubsub: PubSub): pubsub is Relay {
+function isRelay(pubsub: PubSub): pubsub is IRelay {
   if (pubsub) {
     try {
       return pubsub.multicodecs.includes(