@waku/core 0.0.17 → 0.0.18

package/src/lib/message/topic_only_message.ts

@@ -1,51 +0,0 @@
-import type {
-  IDecodedMessage,
-  IDecoder,
-  IProtoMessage,
-} from "@waku/interfaces";
-import { TopicOnlyMessage as ProtoTopicOnlyMessage } from "@waku/proto";
-import debug from "debug";
-
-const log = debug("waku:message:topic-only");
-
-export class TopicOnlyMessage implements IDecodedMessage {
-  public payload: Uint8Array = new Uint8Array();
-  public rateLimitProof: undefined;
-  public timestamp: undefined;
-  public meta: undefined;
-  public ephemeral: undefined;
-
-  constructor(
-    public pubSubTopic: string,
-    private proto: ProtoTopicOnlyMessage
-  ) {}
-
-  get contentTopic(): string {
-    return this.proto.contentTopic;
-  }
-}
-
-export class TopicOnlyDecoder implements IDecoder<TopicOnlyMessage> {
-  public contentTopic = "";
-
-  fromWireToProtoObj(bytes: Uint8Array): Promise<IProtoMessage | undefined> {
-    const protoMessage = ProtoTopicOnlyMessage.decode(bytes);
-    log("Message decoded", protoMessage);
-    return Promise.resolve({
-      contentTopic: protoMessage.contentTopic,
-      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(pubSubTopic, proto);
-  }
-}

package/src/lib/relay/constants.ts

@@ -1,74 +0,0 @@
-export const second = 1000;
-export const minute = 60 * second;
-
-/**
- * RelayCodec is the libp2p identifier for the waku relay protocol
- */
-export const RelayCodecs = ["/vac/waku/relay/2.0.0"];
-
-export const RelayPingContentTopic = "/relay-ping/1/ping/null";
-
-/**
- * RelayGossipFactor affects how many peers we will emit gossip to at each heartbeat.
- * We will send gossip to RelayGossipFactor * (total number of non-mesh peers), or
- * RelayDlazy, whichever is greater.
- */
-export const RelayGossipFactor = 0.25;
-
-/**
- * GossipsubHeartbeatInitialDelay is the short delay before the heartbeat timer begins
- * after the router is initialized.
- */
-export const RelayHeartbeatInitialDelay = 100;
-
-/**
- * RelayHeartbeatInterval controls the time between heartbeats.
- */
-export const RelayHeartbeatInterval = second;
-
-/**
- * RelayPrunePeers controls the number of peers to include in prune Peer eXchange.
- * When we prune a peer that's eligible for PX (has a good score, etc), we will try to
- * send them signed peer records for up to RelayPrunePeers other peers that we
- * know of.
- */
-export const RelayPrunePeers = 16;
-
-/**
- * RelayPruneBackoff controls the backoff time for pruned peers. This is how long
- * a peer must wait before attempting to graft into our mesh again after being pruned.
- * When pruning a peer, we send them our value of RelayPruneBackoff so they know
- * the minimum time to wait. Peers running older versions may not send a backoff time,
- * so if we receive a prune message without one, we will wait at least RelayPruneBackoff
- * before attempting to re-graft.
- */
-export const RelayPruneBackoff = minute;
-
-/**
- * RelayFanoutTTL controls how long we keep track of the fanout state. If it's been
- * RelayFanoutTTL since we've published to a topic that we're not subscribed to,
- * we'll delete the fanout map for that topic.
- */
-export const RelayFanoutTTL = minute;
-
-/**
- * RelayOpportunisticGraftTicks is the number of heartbeat ticks for attempting to improve the mesh
- * with opportunistic grafting. Every RelayOpportunisticGraftTicks we will attempt to select some
- * high-scoring mesh peers to replace lower-scoring ones, if the median score of our mesh peers falls
- * below a threshold
- */
-export const RelayOpportunisticGraftTicks = 60;
-
-/**
- * RelayOpportunisticGraftPeers is the number of peers to opportunistically graft.
- */
-export const RelayOpportunisticGraftPeers = 2;
-
-/**
- * RelayMaxIHaveLength is the maximum number of messages to include in an IHAVE message.
- * Also controls the maximum number of IHAVE ids we will accept and request with IWANT from a
- * peer within a heartbeat, to protect from IHAVE floods. You should adjust this value from the
- * default if your system is pushing more than 5000 messages in GossipsubHistoryGossip heartbeats;
- * with the defaults this is 1666 messages/s.
- */
-export const RelayMaxIHaveLength = 5000;

package/src/lib/relay/index.ts

@@ -1,294 +0,0 @@
-import {
-  GossipSub,
-  GossipSubComponents,
-  GossipsubMessage,
-  GossipsubOpts,
-} from "@chainsafe/libp2p-gossipsub";
-import type { PeerIdStr, TopicStr } from "@chainsafe/libp2p-gossipsub/types";
-import { SignaturePolicy } from "@chainsafe/libp2p-gossipsub/types";
-import type { Libp2p } from "@libp2p/interface-libp2p";
-import type { PubSub } from "@libp2p/interface-pubsub";
-import { sha256 } from "@noble/hashes/sha256";
-import type {
-  ActiveSubscriptions,
-  Callback,
-  IAsyncIterator,
-  IDecodedMessage,
-  IDecoder,
-  IEncoder,
-  IMessage,
-  IRelay,
-  ProtocolCreateOptions,
-  ProtocolOptions,
-  SendResult,
-} from "@waku/interfaces";
-import { toAsyncIterator } from "@waku/utils";
-import debug from "debug";
-
-import { DefaultPubSubTopic } from "../constants.js";
-import { groupByContentTopic } from "../group_by.js";
-import { TopicOnlyDecoder } from "../message/topic_only_message.js";
-
-import * as constants from "./constants.js";
-import { messageValidator } from "./message_validator.js";
-
-const log = debug("waku:relay");
-
-export type Observer<T extends IDecodedMessage> = {
-  decoder: IDecoder<T>;
-  callback: Callback<T>;
-};
-
-export type RelayCreateOptions = ProtocolCreateOptions & GossipsubOpts;
-export type ContentTopic = string;
-
-/**
- * Implements the [Waku v2 Relay protocol](https://rfc.vac.dev/spec/11/).
- * Throws if libp2p.pubsub does not support Waku Relay
- */
-class Relay implements IRelay {
-  private readonly pubSubTopic: string;
-  private defaultDecoder: IDecoder<IDecodedMessage>;
-
-  public static multicodec: string = constants.RelayCodecs[0];
-  public readonly gossipSub: GossipSub;
-
-  /**
-   * observers called when receiving new message.
-   * Observers under key `""` are always called.
-   */
-  private observers: Map<ContentTopic, Set<unknown>>;
-
-  constructor(libp2p: Libp2p, options?: Partial<RelayCreateOptions>) {
-    if (!this.isRelayPubSub(libp2p.pubsub)) {
-      throw Error(
-        `Failed to initialize Relay. libp2p.pubsub does not support ${Relay.multicodec}`
-      );
-    }
-
-    this.gossipSub = libp2p.pubsub as GossipSub;
-    this.pubSubTopic = options?.pubSubTopic ?? DefaultPubSubTopic;
-
-    if (this.gossipSub.isStarted()) {
-      this.gossipSubSubscribe(this.pubSubTopic);
-    }
-
-    this.observers = new Map();
-
-    // TODO: User might want to decide what decoder should be used (e.g. for RLN)
-    this.defaultDecoder = new TopicOnlyDecoder();
-  }
-
-  /**
-   * Mounts the gossipsub protocol onto the libp2p node
-   * and subscribes to the default topic.
-   *
-   * @override
-   * @returns {void}
-   */
-  public async start(): Promise<void> {
-    if (this.gossipSub.isStarted()) {
-      throw Error("GossipSub already started.");
-    }
-
-    await this.gossipSub.start();
-    this.gossipSubSubscribe(this.pubSubTopic);
-  }
-
-  /**
-   * Send Waku message.
-   */
-  public async send(encoder: IEncoder, message: IMessage): Promise<SendResult> {
-    const msg = await encoder.toWire(message);
-    if (!msg) {
-      log("Failed to encode message, aborting publish");
-      return { recipients: [] };
-    }
-
-    return this.gossipSub.publish(this.pubSubTopic, msg);
-  }
-
-  /**
-   * Add an observer and associated Decoder to process incoming messages on a given content topic.
-   *
-   * @returns Function to delete the observer
-   */
-  public subscribe<T extends IDecodedMessage>(
-    decoders: IDecoder<T> | IDecoder<T>[],
-    callback: Callback<T>
-  ): () => void {
-    const contentTopicToObservers = Array.isArray(decoders)
-      ? toObservers(decoders, callback)
-      : toObservers([decoders], callback);
-
-    for (const contentTopic of contentTopicToObservers.keys()) {
-      const currObservers = this.observers.get(contentTopic) || new Set();
-      const newObservers =
-        contentTopicToObservers.get(contentTopic) || new Set();
-
-      this.observers.set(contentTopic, union(currObservers, newObservers));
-    }
-
-    return () => {
-      for (const contentTopic of contentTopicToObservers.keys()) {
-        const currentObservers = this.observers.get(contentTopic) || new Set();
-        const observersToRemove =
-          contentTopicToObservers.get(contentTopic) || new Set();
-
-        const nextObservers = leftMinusJoin(
-          currentObservers,
-          observersToRemove
-        );
-
-        if (nextObservers.size) {
-          this.observers.set(contentTopic, nextObservers);
-        } else {
-          this.observers.delete(contentTopic);
-        }
-      }
-    };
-  }
-
-  public toSubscriptionIterator<T extends IDecodedMessage>(
-    decoders: IDecoder<T> | IDecoder<T>[],
-    opts?: ProtocolOptions | undefined
-  ): Promise<IAsyncIterator<T>> {
-    return toAsyncIterator(this, decoders, opts);
-  }
-
-  public getActiveSubscriptions(): ActiveSubscriptions {
-    const map = new Map();
-    map.set(this.pubSubTopic, this.observers.keys());
-    return map;
-  }
-
-  public getMeshPeers(topic?: TopicStr): PeerIdStr[] {
-    return this.gossipSub.getMeshPeers(topic ?? this.pubSubTopic);
-  }
-
-  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.
-   *
-   * @override
-   */
-  private gossipSubSubscribe(pubSubTopic: string): void {
-    this.gossipSub.addEventListener(
-      "gossipsub:message",
-      async (event: CustomEvent<GossipsubMessage>) => {
-        if (event.detail.msg.topic !== pubSubTopic) return;
-        log(`Message received on ${pubSubTopic}`);
-
-        this.processIncomingMessage(
-          event.detail.msg.topic,
-          event.detail.msg.data
-        ).catch((e) => log("Failed to process incoming message", e));
-      }
-    );
-
-    this.gossipSub.topicValidators.set(pubSubTopic, messageValidator);
-    this.gossipSub.subscribe(pubSubTopic);
-  }
-
-  private isRelayPubSub(pubsub: PubSub): boolean {
-    return pubsub?.multicodecs?.includes(Relay.multicodec) || false;
-  }
-}
-
-export function wakuRelay(
-  init: Partial<ProtocolCreateOptions> = {}
-): (libp2p: Libp2p) => IRelay {
-  return (libp2p: Libp2p) => new Relay(libp2p, init);
-}
-
-export function wakuGossipSub(
-  init: Partial<RelayCreateOptions> = {}
-): (components: GossipSubComponents) => GossipSub {
-  return (components: GossipSubComponents) => {
-    init = {
-      ...init,
-      msgIdFn: ({ data }) => sha256(data),
-      // Ensure that no signature is included nor expected in the messages.
-      globalSignaturePolicy: SignaturePolicy.StrictNoSign,
-      fallbackToFloodsub: false,
-    };
-    const pubsub = new GossipSub(components, init);
-    pubsub.multicodecs = constants.RelayCodecs;
-    return pubsub;
-  };
-}
-
-function toObservers<T extends IDecodedMessage>(
-  decoders: IDecoder<T>[],
-  callback: Callback<T>
-): Map<ContentTopic, Set<Observer<T>>> {
-  const contentTopicToDecoders = Array.from(
-    groupByContentTopic(decoders).entries()
-  );
-
-  const contentTopicToObserversEntries = contentTopicToDecoders.map(
-    ([contentTopic, decoders]) =>
-      [
-        contentTopic,
-        new Set(
-          decoders.map(
-            (decoder) =>
-              ({
-                decoder,
-                callback,
-              } as Observer<T>)
-          )
-        ),
-      ] as [ContentTopic, Set<Observer<T>>]
-  );
-
-  return new Map(contentTopicToObserversEntries);
-}
-
-function union(left: Set<unknown>, right: Set<unknown>): Set<unknown> {
-  for (const val of right.values()) {
-    left.add(val);
-  }
-  return left;
-}
-
-function leftMinusJoin(left: Set<unknown>, right: Set<unknown>): Set<unknown> {
-  for (const val of right.values()) {
-    if (left.has(val)) {
-      left.delete(val);
-    }
-  }
-  return left;
-}

package/src/lib/relay/message_validator.ts

@@ -1,35 +0,0 @@
-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;
-}