@waku/core 0.0.5 → 0.0.7

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 {
@@ -26,6 +25,10 @@ export class MessageV0 implements DecodedMessage {
     return;
   }
 
+  get ephemeral(): boolean {
+    return Boolean(this.proto.ephemeral);
+  }
+
   get payload(): Uint8Array | undefined {
     return this._rawPayload;
   }
@@ -62,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 {
-  constructor(public contentTopic: string) {}
+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 {
@@ -83,14 +86,34 @@ export class EncoderV0 implements Encoder {
       contentTopic: this.contentTopic,
       timestamp: BigInt(timestamp.valueOf()) * OneMillion,
       rateLimitProof: message.rateLimitProof,
+      ephemeral: this.ephemeral,
     };
   }
 }
 
-export class DecoderV0 implements Decoder<MessageV0> {
+/**
+ * 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);
+}
+
+export class Decoder implements IDecoder<DecodedMessage> {
   constructor(public contentTopic: string) {}
 
-  fromWireToProtoObj(bytes: Uint8Array): Promise<ProtoMessage | undefined> {
+  fromWireToProtoObj(bytes: Uint8Array): Promise<IProtoMessage | undefined> {
     const protoMessage = proto.WakuMessage.decode(bytes);
     log("Message decoded", protoMessage);
     return Promise.resolve({
@@ -99,10 +122,13 @@ export class DecoderV0 implements Decoder<MessageV0> {
       version: protoMessage.version ?? undefined,
       timestamp: protoMessage.timestamp ?? undefined,
       rateLimitProof: protoMessage.rateLimitProof ?? undefined,
+      ephemeral: protoMessage.ephemeral ?? false,
     });
   }
 
-  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;
@@ -118,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,7 +1,4 @@
-import type { Multiaddr } from "@multiformats/multiaddr";
-import { multiaddr } from "@multiformats/multiaddr";
-
-import { getPseudoRandomSubset } from "./random_subset";
+import { getPseudoRandomSubset } from "./random_subset.js";
 
 export const DefaultWantedNumber = 1;
 
@@ -23,7 +20,7 @@ export enum Fleet {
 export function getPredefinedBootstrapNodes(
   fleet: Fleet = Fleet.Prod,
   wantedNumber: number = DefaultWantedNumber
-): Multiaddr[] {
+): string[] {
   if (wantedNumber <= 0) {
     return [];
   }
@@ -42,7 +39,6 @@ export function getPredefinedBootstrapNodes(
 
   nodes = Object.values(nodes) as string[];
 
-  nodes = nodes.map((node: string) => multiaddr(node));
   return getPseudoRandomSubset(nodes, wantedNumber);
 }
 

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

@@ -1,34 +1,32 @@
 import {
   GossipSub,
+  GossipSubComponents,
   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>;
 };
 
@@ -55,9 +53,9 @@ export type CreateOptions = {
  *
  * @implements {require('libp2p-interfaces/src/pubsub')}
  */
-export 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];
 
   /**
@@ -66,13 +64,16 @@ export class WakuRelay extends GossipSub implements Relay {
    */
   public observers: Map<string, Set<Observer<any>>>;
 
-  constructor(options?: Partial<CreateOptions>) {
+  constructor(
+    components: GossipSubComponents,
+    options?: Partial<CreateOptions>
+  ) {
     options = Object.assign(options ?? {}, {
       // Ensure that no signature is included nor expected in the messages.
       globalSignaturePolicy: SignaturePolicy.StrictNoSign,
       fallbackToFloodsub: false,
     });
-    super(options);
+    super(components, options);
     this.multicodecs = constants.RelayCodecs;
 
     this.observers = new Map();
@@ -98,10 +99,7 @@ export 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");
@@ -115,8 +113,8 @@ export 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 = {
@@ -187,4 +185,10 @@ export 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) => 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

@@ -1,21 +1,32 @@
 import type { Connection } from "@libp2p/interface-connection";
+import type { ConnectionManager } from "@libp2p/interface-connection-manager";
 import type { PeerId } from "@libp2p/interface-peer-id";
-import { Peer } from "@libp2p/interface-peer-store";
-import { DecodedMessage, Decoder } from "@waku/interfaces";
+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,
+} 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 { Libp2p } from "libp2p";
 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;
 
@@ -27,6 +38,11 @@ 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}.
@@ -75,6 +91,12 @@ export interface QueryOptions {
    * Retrieve messages with a timestamp within the provided values.
    */
   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?: Cursor;
 }
 
 /**
@@ -82,10 +104,10 @@ export interface QueryOptions {
  *
  * The Waku Store protocol can be used to retrieved historical messages.
  */
-export class WakuStore {
+class Store implements IStore {
   pubSubTopic: string;
 
-  constructor(public libp2p: Libp2p, options?: CreateOptions) {
+  constructor(public components: StoreComponents, options?: CreateOptions) {
     this.pubSubTopic = options?.pubSubTopic ?? DefaultPubSubTopic;
   }
 
@@ -106,8 +128,8 @@ export class WakuStore {
    * 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> {
@@ -155,8 +177,8 @@ export class WakuStore {
    * 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,
@@ -193,8 +215,8 @@ export class WakuStore {
    * 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;
@@ -227,12 +249,12 @@ export class WakuStore {
     );
 
     log("Querying history with the following options", {
-      peerId: options?.peerId?.toString(),
       ...options,
+      peerId: options?.peerId?.toString(),
     });
 
     const res = await selectPeerForProtocol(
-      this.libp2p.peerStore,
+      this.components.peerStore,
       [StoreCodec],
       options?.peerId
     );
@@ -242,7 +264,9 @@ export class WakuStore {
     }
     const { peer, protocol } = res;
 
-    const connections = this.libp2p.connectionManager.getConnections(peer.id);
+    const connections = this.components.connectionManager.getConnections(
+      peer.id
+    );
     const connection = selectConnection(connections);
 
     if (!connection) throw "Failed to get a connection to the peer";
@@ -251,7 +275,8 @@ export class WakuStore {
       connection,
       protocol,
       queryOpts,
-      decodersAsMap
+      decodersAsMap,
+      options?.cursor
     )) {
       yield messages;
     }
@@ -262,15 +287,20 @@ export class WakuStore {
    * store protocol. Waku may or  may not be currently connected to these peers.
    */
   async peers(): Promise<Peer[]> {
-    return getPeersForProtocol(this.libp2p.peerStore, [StoreCodec]);
+    return getPeersForProtocol(this.components.peerStore, [StoreCodec]);
+  }
+
+  get peerStore(): PeerStore {
+    return this.components.peerStore;
   }
 }
 
-async function* paginate<T extends DecodedMessage>(
+async function* paginate<T extends IDecodedMessage>(
   connection: Connection,
   protocol: string,
   queryOpts: Params,
-  decoders: Map<string, Decoder<T>>
+  decoders: Map<string, IDecoder<T>>,
+  cursor?: Cursor
 ): AsyncGenerator<Promise<T | undefined>[]> {
   if (
     queryOpts.contentTopics.toString() !==
@@ -281,9 +311,9 @@ async function* paginate<T extends DecodedMessage>(
     );
   }
 
-  let cursor = undefined;
+  let currentCursor = cursor;
   while (true) {
-    queryOpts = Object.assign(queryOpts, { cursor });
+    queryOpts.cursor = currentCursor;
 
     const stream = await connection.newStream(protocol);
     const historyRpcQuery = HistoryRPC.createQuery(queryOpts);
@@ -344,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(
@@ -354,6 +384,8 @@ async function* paginate<T extends DecodedMessage>(
       break;
     }
 
+    currentCursor = nextCursor;
+
     const responsePageSize = response.pagingInfo?.pageSize;
     const queryPageSize = historyRpcQuery.query?.pagingInfo?.pageSize;
     if (
@@ -370,3 +402,36 @@ async function* paginate<T extends DecodedMessage>(
 export function isDefined<T>(msg: T | undefined): msg is T {
   return !!msg;
 }
+
+export async function createCursor(
+  message: IDecodedMessage,
+  pubsubTopic: string = DefaultPubSubTopic
+): Promise<Index> {
+  if (
+    !message ||
+    !message.timestamp ||
+    !message.payload ||
+    !message.contentTopic
+  ) {
+    throw new Error("Message is missing required fields");
+  }
+
+  const contentTopicBytes = utf8ToBytes(message.contentTopic);
+
+  const digest = sha256(concat([contentTopicBytes, message.payload]));
+
+  const messageTime = BigInt(message.timestamp.getTime()) * BigInt(1000000);
+
+  return {
+    digest,
+    pubsubTopic,
+    senderTime: messageTime,
+    receivedTime: messageTime,
+  };
+}
+
+export function wakuStore(
+  init: Partial<CreateOptions> = {}
+): (components: StoreComponents) => IStore {
+  return (components: StoreComponents) => new Store(components, init);
+}

package/src/lib/to_proto_message.ts

@@ -1,15 +1,15 @@
-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,
   timestamp: undefined,
   rateLimitProof: undefined,
+  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),
@@ -94,13 +103,13 @@ async function waitForConnectedPeer(
       for (const codec of codecs) {
         if (evt.detail.protocols.includes(codec)) {
           log("Resolving for", codec, evt.detail.protocols);
-          waku.libp2p.peerStore.removeEventListener("change:protocols", cb);
+          waku.peerStore.removeEventListener("change:protocols", cb);
           resolve();
           break;
         }
       }
     };
-    waku.libp2p.peerStore.addEventListener("change:protocols", cb);
+    waku.peerStore.addEventListener("change:protocols", cb);
   });
 }
 
@@ -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;
 }