@waku/core 0.0.9 → 0.0.11

package/src/lib/message/topic_only_message.ts

@@ -9,15 +9,19 @@ import debug from "debug";
 const log = debug("waku:message:topic-only");
 
 export class TopicOnlyMessage implements IDecodedMessage {
-  public payload: undefined;
+  public payload: Uint8Array = new Uint8Array();
   public rateLimitProof: undefined;
   public timestamp: undefined;
+  public meta: undefined;
   public ephemeral: undefined;
 
-  constructor(private proto: ProtoTopicOnlyMessage) {}
+  constructor(
+    public pubSubTopic: string,
+    private proto: ProtoTopicOnlyMessage
+  ) {}
 
   get contentTopic(): string {
-    return this.proto.contentTopic ?? "";
+    return this.proto.contentTopic;
   }
 }
 
@@ -29,17 +33,19 @@ export class TopicOnlyDecoder implements IDecoder<TopicOnlyMessage> {
     log("Message decoded", protoMessage);
     return Promise.resolve({
       contentTopic: protoMessage.contentTopic,
-      payload: undefined,
+      payload: new Uint8Array(),
       rateLimitProof: undefined,
       timestamp: undefined,
+      meta: undefined,
       version: undefined,
       ephemeral: undefined,
     });
   }
 
   async fromProtoObj(
+    pubSubTopic: string,
     proto: IProtoMessage
   ): Promise<TopicOnlyMessage | undefined> {
-    return new TopicOnlyMessage(proto);
+    return new TopicOnlyMessage(pubSubTopic, proto);
   }
 }

package/src/lib/message/version_0.ts

@@ -1,4 +1,6 @@
+import { IMetaSetter } from "@waku/interfaces";
 import type {
+  EncoderOptions,
   IDecodedMessage,
   IDecoder,
   IEncoder,
@@ -16,24 +18,17 @@ export const Version = 0;
 export { proto };
 
 export class DecodedMessage implements IDecodedMessage {
-  constructor(protected proto: proto.WakuMessage) {}
-
-  get _rawPayload(): Uint8Array | undefined {
-    if (this.proto.payload) {
-      return new Uint8Array(this.proto.payload);
-    }
-    return;
-  }
+  constructor(public pubSubTopic: string, protected proto: proto.WakuMessage) {}
 
   get ephemeral(): boolean {
     return Boolean(this.proto.ephemeral);
   }
 
-  get payload(): Uint8Array | undefined {
-    return this._rawPayload;
+  get payload(): Uint8Array {
+    return this.proto.payload;
   }
 
-  get contentTopic(): string | undefined {
+  get contentTopic(): string {
     return this.proto.contentTopic;
   }
 
@@ -50,18 +45,19 @@ export class DecodedMessage implements IDecodedMessage {
         const timestamp = this.proto.timestamp / OneMillion;
         return new Date(Number(timestamp));
       }
-
-      if (this.proto.timestampDeprecated) {
-        return new Date(this.proto.timestampDeprecated * 1000);
-      }
+      return;
     } catch (e) {
       return;
     }
-    return;
+  }
+
+  get meta(): Uint8Array | undefined {
+    return this.proto.meta;
   }
 
   get version(): number {
-    // https://github.com/status-im/js-waku/issues/921
+    // https://rfc.vac.dev/spec/14/
+    // > If omitted, the value SHOULD be interpreted as version 0.
     return this.proto.version ?? 0;
   }
 
@@ -71,7 +67,11 @@ export class DecodedMessage implements IDecodedMessage {
 }
 
 export class Encoder implements IEncoder {
-  constructor(public contentTopic: string, public ephemeral: boolean = false) {}
+  constructor(
+    public contentTopic: string,
+    public ephemeral: boolean = false,
+    public metaSetter?: IMetaSetter
+  ) {}
 
   async toWire(message: IMessage): Promise<Uint8Array> {
     return proto.WakuMessage.encode(await this.toProtoObj(message));
@@ -80,14 +80,22 @@ export class Encoder implements IEncoder {
   async toProtoObj(message: IMessage): Promise<IProtoMessage> {
     const timestamp = message.timestamp ?? new Date();
 
-    return {
+    const protoMessage = {
       payload: message.payload,
       version: Version,
       contentTopic: this.contentTopic,
       timestamp: BigInt(timestamp.valueOf()) * OneMillion,
+      meta: undefined,
       rateLimitProof: message.rateLimitProof,
       ephemeral: this.ephemeral,
     };
+
+    if (this.metaSetter) {
+      const meta = this.metaSetter(protoMessage);
+      return { ...protoMessage, meta };
+    }
+
+    return protoMessage;
   }
 }
 
@@ -99,15 +107,13 @@ export class Encoder implements IEncoder {
  * 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 function createEncoder({
+  contentTopic,
+  ephemeral,
+  metaSetter,
+}: EncoderOptions): Encoder {
+  return new Encoder(contentTopic, ephemeral, metaSetter);
 }
 
 export class Decoder implements IDecoder<DecodedMessage> {
@@ -117,24 +123,23 @@ export class Decoder implements IDecoder<DecodedMessage> {
     const protoMessage = proto.WakuMessage.decode(bytes);
     log("Message decoded", protoMessage);
     return Promise.resolve({
-      payload: protoMessage.payload ?? undefined,
-      contentTopic: protoMessage.contentTopic ?? undefined,
+      payload: protoMessage.payload,
+      contentTopic: protoMessage.contentTopic,
       version: protoMessage.version ?? undefined,
       timestamp: protoMessage.timestamp ?? undefined,
+      meta: protoMessage.meta ?? undefined,
       rateLimitProof: protoMessage.rateLimitProof ?? undefined,
       ephemeral: protoMessage.ephemeral ?? false,
     });
   }
 
   async fromProtoObj(
+    pubSubTopic: string,
     proto: IProtoMessage
   ): Promise<DecodedMessage | undefined> {
-    // https://github.com/status-im/js-waku/issues/921
-    if (proto.version === undefined) {
-      proto.version = 0;
-    }
-
-    if (proto.version !== Version) {
+    // https://rfc.vac.dev/spec/14/
+    // > If omitted, the value SHOULD be interpreted as version 0.
+    if (proto.version ?? 0 !== Version) {
       log(
         "Failed to decode due to incorrect version, expected:",
         Version,
@@ -144,12 +149,12 @@ export class Decoder implements IDecoder<DecodedMessage> {
       return Promise.resolve(undefined);
     }
 
-    return new DecodedMessage(proto);
+    return new DecodedMessage(pubSubTopic, proto);
   }
 }
 
 /**
- * Creates an decoder that decode messages without Waku level encryption.
+ * Creates a 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

package/src/lib/predefined_bootstrap_nodes.ts

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

package/src/lib/relay/index.ts

@@ -6,12 +6,14 @@ import {
 } from "@chainsafe/libp2p-gossipsub";
 import type { PeerIdStr, TopicStr } from "@chainsafe/libp2p-gossipsub/types";
 import { SignaturePolicy } from "@chainsafe/libp2p-gossipsub/types";
+import { CustomEvent } from "@libp2p/interfaces/events";
 import type {
   Callback,
   IDecoder,
   IEncoder,
   IMessage,
   IRelay,
+  ProtocolCreateOptions,
   SendResult,
 } from "@waku/interfaces";
 import { IDecodedMessage } from "@waku/interfaces";
@@ -22,6 +24,7 @@ import { TopicOnlyDecoder } from "../message/topic_only_message.js";
 import { pushOrInitMapSet } from "../push_or_init_map.js";
 
 import * as constants from "./constants.js";
+import { messageValidator } from "./message_validator.js";
 
 const log = debug("waku:relay");
 
@@ -30,22 +33,12 @@ export type Observer<T extends IDecodedMessage> = {
   callback: Callback<T>;
 };
 
-export interface RelayCreateOptions extends GossipsubOpts {
-  /**
-   * The PubSub Topic to use. Defaults to {@link DefaultPubSubTopic}.
-   *
-   * One and only one pubsub topic is used by Waku. This is used by:
-   * - WakuRelay to receive, route and send messages,
-   * - WakuLightPush to send messages,
-   * - WakuStore to retrieve messages.
-   *
-   * 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 type RelayCreateOptions = ProtocolCreateOptions & GossipsubOpts;
+export type ContentTopic = string;
+
+type BasicEventPayload = {
+  contentTopic: string;
+};
 
 /**
  * Implements the [Waku v2 Relay protocol](https://rfc.vac.dev/spec/11/).
@@ -54,7 +47,7 @@ export interface RelayCreateOptions extends GossipsubOpts {
  * @implements {require('libp2p-interfaces/src/pubsub')}
  */
 class Relay extends GossipSub implements IRelay {
-  pubSubTopic: string;
+  private readonly pubSubTopic: string;
   defaultDecoder: IDecoder<IDecodedMessage>;
   public static multicodec: string = constants.RelayCodecs[0];
 
@@ -62,7 +55,7 @@ class Relay extends GossipSub implements IRelay {
    * observers called when receiving new message.
    * Observers under key `""` are always called.
    */
-  public observers: Map<string, Set<Observer<any>>>;
+  private observers: Map<ContentTopic, Set<unknown>>;
 
   constructor(
     components: GossipSubComponents,
@@ -73,13 +66,14 @@ class Relay extends GossipSub implements IRelay {
       globalSignaturePolicy: SignaturePolicy.StrictNoSign,
       fallbackToFloodsub: false,
     });
+
     super(components, options);
     this.multicodecs = constants.RelayCodecs;
 
-    this.observers = new Map();
-
     this.pubSubTopic = options?.pubSubTopic ?? DefaultPubSubTopic;
 
+    this.observers = new Map();
+
     // TODO: User might want to decide what decoder should be used (e.g. for RLN)
     this.defaultDecoder = new TopicOnlyDecoder();
   }
@@ -105,6 +99,7 @@ class Relay extends GossipSub implements IRelay {
       log("Failed to encode message, aborting publish");
       return { recipients: [] };
     }
+
     return this.publish(this.pubSubTopic, msg);
   }
 
@@ -121,16 +116,67 @@ class Relay extends GossipSub implements IRelay {
       decoder,
       callback,
     };
-    pushOrInitMapSet(this.observers, decoder.contentTopic, observer);
+    const contentTopic = decoder.contentTopic;
+
+    pushOrInitMapSet(this.observers, contentTopic, observer);
+
+    this.dispatchEvent(
+      new CustomEvent<BasicEventPayload>("observer:added", {
+        detail: {
+          contentTopic,
+        },
+      })
+    );
 
     return () => {
-      const observers = this.observers.get(decoder.contentTopic);
+      const observers = this.observers.get(contentTopic);
       if (observers) {
         observers.delete(observer);
+
+        this.dispatchEvent(
+          new CustomEvent<BasicEventPayload>("observer:removed", {
+            detail: {
+              contentTopic,
+            },
+          })
+        );
       }
     };
   }
 
+  private async processIncomingMessage<T extends IDecodedMessage>(
+    pubSubTopic: string,
+    bytes: Uint8Array
+  ): Promise<void> {
+    const topicOnlyMsg = await this.defaultDecoder.fromWireToProtoObj(bytes);
+    if (!topicOnlyMsg || !topicOnlyMsg.contentTopic) {
+      log("Message does not have a content topic, skipping");
+      return;
+    }
+
+    const observers = this.observers.get(topicOnlyMsg.contentTopic) as Set<
+      Observer<T>
+    >;
+    if (!observers) {
+      return;
+    }
+    await Promise.all(
+      Array.from(observers).map(async ({ decoder, callback }) => {
+        const protoMsg = await decoder.fromWireToProtoObj(bytes);
+        if (!protoMsg) {
+          log("Internal error: message previously decoded failed on 2nd pass.");
+          return;
+        }
+        const msg = await decoder.fromProtoObj(pubSubTopic, protoMsg);
+        if (msg) {
+          callback(msg);
+        } else {
+          log("Failed to decode messages on", topicOnlyMsg.contentTopic);
+        }
+      })
+    );
+  }
+
   /**
    * Subscribe to a pubsub topic and start emitting Waku messages to observers.
    *
@@ -143,43 +189,22 @@ class Relay extends GossipSub implements IRelay {
         if (event.detail.msg.topic !== pubSubTopic) return;
         log(`Message received on ${pubSubTopic}`);
 
-        const topicOnlyMsg = await this.defaultDecoder.fromWireToProtoObj(
+        this.processIncomingMessage(
+          event.detail.msg.topic,
           event.detail.msg.data
-        );
-        if (!topicOnlyMsg || !topicOnlyMsg.contentTopic) {
-          log("Message does not have a content topic, skipping");
-          return;
-        }
-
-        const observers = this.observers.get(topicOnlyMsg.contentTopic);
-        if (!observers) {
-          return;
-        }
-        await Promise.all(
-          Array.from(observers).map(async ({ decoder, callback }) => {
-            const protoMsg = await decoder.fromWireToProtoObj(
-              event.detail.msg.data
-            );
-            if (!protoMsg) {
-              log(
-                "Internal error: message previously decoded failed on 2nd pass."
-              );
-              return;
-            }
-            const msg = await decoder.fromProtoObj(protoMsg);
-            if (msg) {
-              callback(msg);
-            } else {
-              log("Failed to decode messages on", topicOnlyMsg.contentTopic);
-            }
-          })
-        );
+        ).catch((e) => log("Failed to process incoming message", e));
       }
     );
 
+    this.topicValidators.set(pubSubTopic, messageValidator);
     super.subscribe(pubSubTopic);
   }
 
+  unsubscribe(pubSubTopic: TopicStr): void {
+    super.unsubscribe(pubSubTopic);
+    this.topicValidators.delete(pubSubTopic);
+  }
+
   getMeshPeers(topic?: TopicStr): PeerIdStr[] {
     return super.getMeshPeers(topic ?? this.pubSubTopic);
   }

package/src/lib/relay/message_validator.ts

@@ -0,0 +1,35 @@
+import type { PeerId } from "@libp2p/interface-peer-id";
+import type { Message } from "@libp2p/interface-pubsub";
+import { TopicValidatorResult } from "@libp2p/interface-pubsub";
+import { proto_message as proto } from "@waku/proto";
+import debug from "debug";
+
+const log = debug("waku:relay");
+
+export function messageValidator(
+  peer: PeerId,
+  message: Message
+): TopicValidatorResult {
+  const startTime = performance.now();
+  log(`validating message from ${peer} received on ${message.topic}`);
+  let result = TopicValidatorResult.Accept;
+
+  try {
+    const protoMessage = proto.WakuMessage.decode(message.data);
+
+    if (
+      !protoMessage.contentTopic ||
+      !protoMessage.contentTopic.length ||
+      !protoMessage.payload ||
+      !protoMessage.payload.length
+    ) {
+      result = TopicValidatorResult.Reject;
+    }
+  } catch (e) {
+    result = TopicValidatorResult.Reject;
+  }
+
+  const endTime = performance.now();
+  log(`Validation time (must be <100ms): ${endTime - startTime}ms`);
+  return result;
+}

package/src/lib/store/history_rpc.ts

@@ -19,8 +19,8 @@ export interface Params {
   cursor?: proto.Index;
 }
 
-export class HistoryRPC {
-  private constructor(public readonly proto: proto.HistoryRPC) {}
+export class HistoryRpc {
+  private constructor(public readonly proto: proto.HistoryRpc) {}
 
   get query(): proto.HistoryQuery | undefined {
     return this.proto.query;
@@ -33,7 +33,7 @@ export class HistoryRPC {
   /**
    * Create History Query.
    */
-  static createQuery(params: Params): HistoryRPC {
+  static createQuery(params: Params): HistoryRpc {
     const contentFilters = params.contentTopics.map((contentTopic) => {
       return { contentTopic };
     });
@@ -56,10 +56,10 @@ export class HistoryRPC {
       // milliseconds 10^-3 to nanoseconds 10^-9
       endTime = BigInt(params.endTime.valueOf()) * OneMillion;
     }
-    return new HistoryRPC({
+    return new HistoryRpc({
       requestId: uuid(),
       query: {
-        pubSubTopic: params.pubSubTopic,
+        pubsubTopic: params.pubSubTopic,
         contentFilters,
         pagingInfo,
         startTime,
@@ -69,13 +69,13 @@ export class HistoryRPC {
     });
   }
 
-  decode(bytes: Uint8ArrayList): HistoryRPC {
-    const res = proto.HistoryRPC.decode(bytes);
-    return new HistoryRPC(res);
+  decode(bytes: Uint8ArrayList): HistoryRpc {
+    const res = proto.HistoryRpc.decode(bytes);
+    return new HistoryRpc(res);
   }
 
   encode(): Uint8Array {
-    return proto.HistoryRPC.encode(this.proto);
+    return proto.HistoryRpc.encode(this.proto);
   }
 }
 
@@ -84,10 +84,10 @@ function directionToProto(
 ): proto.PagingInfo.Direction {
   switch (pageDirection) {
     case PageDirection.BACKWARD:
-      return proto.PagingInfo.Direction.DIRECTION_BACKWARD_UNSPECIFIED;
+      return proto.PagingInfo.Direction.BACKWARD;
     case PageDirection.FORWARD:
-      return proto.PagingInfo.Direction.DIRECTION_FORWARD;
+      return proto.PagingInfo.Direction.FORWARD;
     default:
-      return proto.PagingInfo.Direction.DIRECTION_BACKWARD_UNSPECIFIED;
+      return proto.PagingInfo.Direction.BACKWARD;
   }
 }