@waku/core 0.0.1

package/src/lib/peer_discovery_dns/fetch_nodes.ts

@@ -0,0 +1,180 @@
+import debug from "debug";
+
+import { ENR, Waku2 } from "../enr";
+
+import { NodeCapabilityCount } from "./dns";
+
+const log = debug("waku:discovery:fetch_nodes");
+
+/**
+ * Fetch nodes using passed [[getNode]] until all wanted capabilities are
+ * fulfilled or the number of [[getNode]] call exceeds the sum of
+ * [[wantedNodeCapabilityCount]] plus [[errorTolerance]].
+ */
+export async function fetchNodesUntilCapabilitiesFulfilled(
+  wantedNodeCapabilityCount: Partial<NodeCapabilityCount>,
+  errorTolerance: number,
+  getNode: () => Promise<ENR | null>
+): Promise<ENR[]> {
+  const wanted = {
+    relay: wantedNodeCapabilityCount.relay ?? 0,
+    store: wantedNodeCapabilityCount.store ?? 0,
+    filter: wantedNodeCapabilityCount.filter ?? 0,
+    lightPush: wantedNodeCapabilityCount.lightPush ?? 0,
+  };
+
+  const maxSearches =
+    wanted.relay + wanted.store + wanted.filter + wanted.lightPush;
+
+  const actual = {
+    relay: 0,
+    store: 0,
+    filter: 0,
+    lightPush: 0,
+  };
+
+  let totalSearches = 0;
+  const peers: ENR[] = [];
+
+  while (
+    !isSatisfied(wanted, actual) &&
+    totalSearches < maxSearches + errorTolerance
+  ) {
+    const peer = await getNode();
+    if (peer && isNewPeer(peer, peers)) {
+      // ENRs without a waku2 key are ignored.
+      if (peer.waku2) {
+        if (helpsSatisfyCapabilities(peer.waku2, wanted, actual)) {
+          addCapabilities(peer.waku2, actual);
+          peers.push(peer);
+        }
+      }
+      log(`got new peer candidate from DNS address=${peer.nodeId}@${peer.ip}`);
+    }
+
+    totalSearches++;
+  }
+  return peers;
+}
+
+/**
+ * Fetch nodes using passed [[getNode]] until all wanted capabilities are
+ * fulfilled or the number of [[getNode]] call exceeds the sum of
+ * [[wantedNodeCapabilityCount]] plus [[errorTolerance]].
+ */
+export async function* yieldNodesUntilCapabilitiesFulfilled(
+  wantedNodeCapabilityCount: Partial<NodeCapabilityCount>,
+  errorTolerance: number,
+  getNode: () => Promise<ENR | null>
+): AsyncGenerator<ENR> {
+  const wanted = {
+    relay: wantedNodeCapabilityCount.relay ?? 0,
+    store: wantedNodeCapabilityCount.store ?? 0,
+    filter: wantedNodeCapabilityCount.filter ?? 0,
+    lightPush: wantedNodeCapabilityCount.lightPush ?? 0,
+  };
+
+  const maxSearches =
+    wanted.relay + wanted.store + wanted.filter + wanted.lightPush;
+
+  const actual = {
+    relay: 0,
+    store: 0,
+    filter: 0,
+    lightPush: 0,
+  };
+
+  let totalSearches = 0;
+  const peerNodeIds = new Set();
+
+  while (
+    !isSatisfied(wanted, actual) &&
+    totalSearches < maxSearches + errorTolerance
+  ) {
+    const peer = await getNode();
+    if (peer && peer.nodeId && !peerNodeIds.has(peer.nodeId)) {
+      peerNodeIds.add(peer.nodeId);
+      // ENRs without a waku2 key are ignored.
+      if (peer.waku2) {
+        if (helpsSatisfyCapabilities(peer.waku2, wanted, actual)) {
+          addCapabilities(peer.waku2, actual);
+          yield peer;
+        }
+      }
+      log(`got new peer candidate from DNS address=${peer.nodeId}@${peer.ip}`);
+    }
+    totalSearches++;
+  }
+}
+
+function isSatisfied(
+  wanted: NodeCapabilityCount,
+  actual: NodeCapabilityCount
+): boolean {
+  return (
+    actual.relay >= wanted.relay &&
+    actual.store >= wanted.store &&
+    actual.filter >= wanted.filter &&
+    actual.lightPush >= wanted.lightPush
+  );
+}
+
+function isNewPeer(peer: ENR, peers: ENR[]): boolean {
+  if (!peer.nodeId) return false;
+
+  for (const existingPeer of peers) {
+    if (peer.nodeId === existingPeer.nodeId) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function addCapabilities(node: Waku2, total: NodeCapabilityCount): void {
+  if (node.relay) total.relay += 1;
+  if (node.store) total.store += 1;
+  if (node.filter) total.filter += 1;
+  if (node.lightPush) total.lightPush += 1;
+}
+
+/**
+ * Checks if the proposed ENR [[node]] helps satisfy the [[wanted]] capabilities,
+ * considering the [[actual]] capabilities of nodes retrieved so far..
+ *
+ * @throws If the function is called when the wanted capabilities are already fulfilled.
+ */
+function helpsSatisfyCapabilities(
+  node: Waku2,
+  wanted: NodeCapabilityCount,
+  actual: NodeCapabilityCount
+): boolean {
+  if (isSatisfied(wanted, actual)) {
+    throw "Internal Error: Waku2 wanted capabilities are already fulfilled";
+  }
+
+  const missing = missingCapabilities(wanted, actual);
+
+  return (
+    (missing.relay && node.relay) ||
+    (missing.store && node.store) ||
+    (missing.filter && node.filter) ||
+    (missing.lightPush && node.lightPush)
+  );
+}
+
+/**
+ * Return a [[Waku2]] Object for which capabilities are set to true if they are
+ * [[wanted]] yet missing from [[actual]].
+ */
+function missingCapabilities(
+  wanted: NodeCapabilityCount,
+  actual: NodeCapabilityCount
+): Waku2 {
+  return {
+    relay: actual.relay < wanted.relay,
+    store: actual.store < wanted.store,
+    filter: actual.filter < wanted.filter,
+    lightPush: actual.lightPush < wanted.lightPush,
+  };
+}

package/src/lib/peer_discovery_dns/index.ts

@@ -0,0 +1,84 @@
+import type {
+  PeerDiscovery,
+  PeerDiscoveryEvents,
+} from "@libp2p/interface-peer-discovery";
+import { symbol } from "@libp2p/interface-peer-discovery";
+import type { PeerInfo } from "@libp2p/interface-peer-info";
+import { CustomEvent, EventEmitter } from "@libp2p/interfaces/events";
+import debug from "debug";
+
+import { ENR } from "../enr";
+import { multiaddrsToPeerInfo } from "../multiaddr_to_peer_info";
+
+import { DnsNodeDiscovery, NodeCapabilityCount } from "./dns";
+
+const log = debug("waku:peer-discovery-dns");
+
+/**
+ * Parse options and expose function to return bootstrap peer addresses.
+ *
+ * @throws if an invalid combination of options is passed, see [[BootstrapOptions]] for details.
+ */
+export class PeerDiscoveryDns
+  extends EventEmitter<PeerDiscoveryEvents>
+  implements PeerDiscovery
+{
+  private readonly nextPeer: () => AsyncGenerator<ENR>;
+  private _started: boolean;
+
+  /**
+   * @param enrUrl An EIP-1459 ENR Tree URL. For example:
+   * "enrtree://AOFTICU2XWDULNLZGRMQS4RIZPAZEHYMV4FYHAPW563HNRAOERP7C@test.nodes.vac.dev"
+   * @param wantedNodeCapabilityCount Specifies what node capabilities
+   * (protocol) must be returned.
+   */
+  constructor(
+    enrUrl: string,
+    wantedNodeCapabilityCount: Partial<NodeCapabilityCount>
+  ) {
+    super();
+    this._started = false;
+    log("Use following EIP-1459 ENR Tree URL: ", enrUrl);
+
+    const dns = DnsNodeDiscovery.dnsOverHttp();
+
+    this.nextPeer = dns.getNextPeer.bind(
+      {},
+      [enrUrl],
+      wantedNodeCapabilityCount
+    );
+  }
+
+  /**
+   * Start discovery process
+   */
+  async start(): Promise<void> {
+    log("Starting peer discovery via dns");
+
+    this._started = true;
+    for await (const peer of this.nextPeer()) {
+      if (!this._started) return;
+      const peerInfos = multiaddrsToPeerInfo(peer.getFullMultiaddrs());
+      peerInfos.forEach((peerInfo) => {
+        this.dispatchEvent(
+          new CustomEvent<PeerInfo>("peer", { detail: peerInfo })
+        );
+      });
+    }
+  }
+
+  /**
+   * Stop emitting events
+   */
+  stop(): void {
+    this._started = false;
+  }
+
+  get [symbol](): true {
+    return true;
+  }
+
+  get [Symbol.toStringTag](): string {
+    return "@waku/bootstrap";
+  }
+}

package/src/lib/peer_discovery_static_list.ts

@@ -0,0 +1,118 @@
+import type {
+  PeerDiscovery,
+  PeerDiscoveryEvents,
+} from "@libp2p/interface-peer-discovery";
+import { symbol } from "@libp2p/interface-peer-discovery";
+import type { PeerInfo } from "@libp2p/interface-peer-info";
+import { CustomEvent, EventEmitter } from "@libp2p/interfaces/events";
+import type { Multiaddr } from "@multiformats/multiaddr";
+import { multiaddr } from "@multiformats/multiaddr";
+import debug from "debug";
+
+import { multiaddrsToPeerInfo } from "./multiaddr_to_peer_info";
+import { getPseudoRandomSubset } from "./random_subset";
+
+const log = debug("waku:peer-discovery-static-list");
+
+export interface Options {
+  /**
+   * The maximum of peers to connect to as part of the bootstrap process.
+   *
+   * @default The length of the passed `peers` array.
+   */
+  maxPeers?: number;
+  /**
+   * The interval between emitting addresses in milliseconds.
+   *
+   * @default {@link PeerDiscoveryStaticPeers.DefaultInterval}
+   */
+  interval?: number;
+}
+
+/**
+ * Pass a list of multiaddr that will be used to bootstrap a node.
+ */
+export class PeerDiscoveryStaticPeers
+  extends EventEmitter<PeerDiscoveryEvents>
+  implements PeerDiscovery
+{
+  static DefaultInterval = 200;
+  private readonly peers: PeerInfo[];
+  private timer?: ReturnType<typeof setInterval>;
+  private readonly interval: number;
+
+  /**
+   * @param peers Multiaddrs of peers to connect to.
+   * @param opts
+   */
+  constructor(peers: string[] | Multiaddr[], opts?: Options) {
+    super();
+
+    this.interval = opts?.interval ?? PeerDiscoveryStaticPeers.DefaultInterval;
+    const maxPeers = opts?.maxPeers ?? peers?.length;
+
+    const peerMas = peers.map((peer: string | Multiaddr) => {
+      if (typeof peer === "string") {
+        return multiaddr(peer);
+      } else {
+        return peer;
+      }
+    });
+    this.peers = multiaddrsToPeerInfo(getPseudoRandomSubset(peerMas, maxPeers));
+    log(
+      "Use provided list of peers (reduced to maxPeers)",
+      this.peers.map((ma) => ma.toString())
+    );
+  }
+
+  /**
+   * Start emitting static peers.
+   */
+  start(): void {
+    this._startTimer();
+  }
+
+  private _startTimer(): void {
+    if (this.peers) {
+      log("Starting to emit static peers.");
+      if (this.timer != null) {
+        return;
+      }
+
+      this.timer = setInterval(() => this._returnPeers(), this.interval);
+
+      this._returnPeers();
+    }
+  }
+
+  _returnPeers(): void {
+    if (this.timer == null) {
+      return;
+    }
+
+    this.peers.forEach((peerData) => {
+      this.dispatchEvent(
+        new CustomEvent<PeerInfo>("peer", { detail: peerData })
+      );
+    });
+  }
+
+  /**
+   * Stop emitting peers.
+   */
+  stop(): void {
+    if (this.timer != null) {
+      clearInterval(this.timer);
+    }
+
+    this.timer = undefined;
+  }
+
+  get [symbol](): true {
+    return true;
+  }
+
+  get [Symbol.toStringTag](): string {
+    return "@waku/peer-discovery-static-list";
+  }
+}

package/src/lib/predefined_bootstrap_nodes.ts

@@ -0,0 +1,72 @@
+import type { Multiaddr } from "@multiformats/multiaddr";
+import { multiaddr } from "@multiformats/multiaddr";
+
+import { getPseudoRandomSubset } from "./random_subset";
+
+export const DefaultWantedNumber = 1;
+
+export enum Fleet {
+  Prod = "prod",
+  Test = "test",
+}
+
+/**
+ * Return list of pre-defined (hardcoded) bootstrap nodes.
+ *
+ * Default behavior is to return nodes of the nwaku Status Prod fleet.
+ *
+ * @param fleet The fleet to be returned. Defaults to production fleet.
+ * @param wantedNumber The number of connections desired. Defaults to {@link DefaultWantedNumber}.
+ *
+ * @returns An array of multiaddresses.
+ */
+export function getPredefinedBootstrapNodes(
+  fleet: Fleet = Fleet.Prod,
+  wantedNumber: number = DefaultWantedNumber
+): Multiaddr[] {
+  if (wantedNumber <= 0) {
+    return [];
+  }
+
+  let nodes;
+  switch (fleet) {
+    case Fleet.Prod:
+      nodes = fleets.fleets["wakuv2.prod"]["waku-websocket"];
+      break;
+    case Fleet.Test:
+      nodes = fleets.fleets["wakuv2.test"]["waku-websocket"];
+      break;
+    default:
+      nodes = fleets.fleets["wakuv2.prod"]["waku-websocket"];
+  }
+
+  nodes = Object.values(nodes) as string[];
+
+  nodes = nodes.map((node: string) => multiaddr(node));
+  return getPseudoRandomSubset(nodes, wantedNumber);
+}
+
+export const fleets = {
+  fleets: {
+    "wakuv2.prod": {
+      "waku-websocket": {
+        "node-01.ac-cn-hongkong-c.wakuv2.prod":
+          "/dns4/node-01.ac-cn-hongkong-c.wakuv2.prod.statusim.net/tcp/443/wss/p2p/16Uiu2HAm4v86W3bmT1BiH6oSPzcsSr24iDQpSN5Qa992BCjjwgrD",
+        "node-01.do-ams3.wakuv2.prod":
+          "/dns4/node-01.do-ams3.wakuv2.prod.statusim.net/tcp/443/wss/p2p/16Uiu2HAmL5okWopX7NqZWBUKVqW8iUxCEmd5GMHLVPwCgzYzQv3e",
+        "node-01.gc-us-central1-a.wakuv2.prod":
+          "/dns4/node-01.gc-us-central1-a.wakuv2.prod.statusim.net/tcp/443/wss/p2p/16Uiu2HAmVkKntsECaYfefR1V2yCR79CegLATuTPE6B9TxgxBiiiA",
+      },
+    },
+    "wakuv2.test": {
+      "waku-websocket": {
+        "node-01.ac-cn-hongkong-c.wakuv2.test":
+          "/dns4/node-01.ac-cn-hongkong-c.wakuv2.test.statusim.net/tcp/443/wss/p2p/16Uiu2HAkvWiyFsgRhuJEb9JfjYxEkoHLgnUQmr1N5mKWnYjxYRVm",
+        "node-01.do-ams3.wakuv2.test":
+          "/dns4/node-01.do-ams3.wakuv2.test.statusim.net/tcp/443/wss/p2p/16Uiu2HAmPLe7Mzm8TsYUubgCAW1aJoeFScxrLj8ppHFivPo97bUZ",
+        "node-01.gc-us-central1-a.wakuv2.test":
+          "/dns4/node-01.gc-us-central1-a.wakuv2.test.statusim.net/tcp/443/wss/p2p/16Uiu2HAmJb2e28qLXxT5kZxVUUoJt72EMzNGXB47Rxx5hw3q4YjS",
+      },
+    },
+  },
+};

package/src/lib/push_or_init_map.ts

@@ -0,0 +1,13 @@
+export function pushOrInitMapSet<K, V>(
+  map: Map<K, Set<V>>,
+  key: K,
+  newValue: V
+): void {
+  let arr = map.get(key);
+  if (typeof arr === "undefined") {
+    map.set(key, new Set());
+    arr = map.get(key) as Set<V>;
+  }
+
+  arr.add(newValue);
+}

package/src/lib/random_subset.ts

@@ -0,0 +1,30 @@
+/**
+ * Return pseudo random subset of the input.
+ */
+export function getPseudoRandomSubset<T>(
+  values: T[],
+  wantedNumber: number
+): T[] {
+  if (values.length <= wantedNumber || values.length <= 1) {
+    return values;
+  }
+
+  return shuffle(values).slice(0, wantedNumber);
+}
+
+function shuffle<T>(arr: T[]): T[] {
+  if (arr.length <= 1) {
+    return arr;
+  }
+  const randInt = (): number => {
+    return Math.floor(Math.random() * Math.floor(arr.length));
+  };
+
+  for (let i = 0; i < arr.length; i++) {
+    const j = randInt();
+    const tmp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = tmp;
+  }
+  return arr;
+}

package/src/lib/select_connection.ts

@@ -0,0 +1,24 @@
+import { Connection } from "@libp2p/interface-connection";
+
+export function selectConnection(
+  connections: Connection[]
+): Connection | undefined {
+  if (!connections.length) return;
+  if (connections.length === 1) return connections[0];
+
+  let latestConnection: Connection | undefined;
+
+  connections.forEach((connection) => {
+    if (connection.stat.status === "OPEN") {
+      if (!latestConnection) {
+        latestConnection = connection;
+      } else if (
+        connection.stat.timeline.open > latestConnection.stat.timeline.open
+      ) {
+        latestConnection = connection;
+      }
+    }
+  });
+
+  return latestConnection;
+}

package/src/lib/select_peer.ts

@@ -0,0 +1,77 @@
+import type { PeerId } from "@libp2p/interface-peer-id";
+import type { Peer, PeerStore } from "@libp2p/interface-peer-store";
+import debug from "debug";
+
+const log = debug("waku:select-peer");
+
+/**
+ * Returns a pseudo-random peer that supports the given protocol.
+ * Useful for protocols such as store and light push
+ */
+export function selectRandomPeer(peers: Peer[]): Peer | undefined {
+  if (peers.length === 0) return;
+
+  const index = Math.round(Math.random() * (peers.length - 1));
+  return peers[index];
+}
+
+/**
+ * Returns the list of peers that supports the given protocol.
+ */
+export async function getPeersForProtocol(
+  peerStore: PeerStore,
+  protocols: string[]
+): Promise<Peer[]> {
+  const peers: Peer[] = [];
+  await peerStore.forEach((peer) => {
+    for (let i = 0; i < protocols.length; i++) {
+      if (peer.protocols.includes(protocols[i])) {
+        peers.push(peer);
+        break;
+      }
+    }
+  });
+  return peers;
+}
+
+export async function selectPeerForProtocol(
+  peerStore: PeerStore,
+  protocols: string[],
+  peerId?: PeerId
+): Promise<{ peer: Peer; protocol: string } | undefined> {
+  let peer;
+  if (peerId) {
+    peer = await peerStore.get(peerId);
+    if (!peer) {
+      log(
+        `Failed to retrieve connection details for provided peer in peer store: ${peerId.toString()}`
+      );
+      return;
+    }
+  } else {
+    const peers = await getPeersForProtocol(peerStore, protocols);
+    peer = selectRandomPeer(peers);
+    if (!peer) {
+      log("Failed to find known peer that registers protocols", protocols);
+      return;
+    }
+  }
+
+  let protocol;
+  for (const codec of protocols) {
+    if (peer.protocols.includes(codec)) {
+      protocol = codec;
+      // Do not break as we want to keep the last value
+    }
+  }
+  log(`Using codec ${protocol}`);
+  if (!protocol) {
+    log(
+      `Peer does not register required protocols: ${peer.id.toString()}`,
+      protocols
+    );
+    return;
+  }
+
+  return { peer, protocol };
+}

package/src/lib/to_proto_message.ts

@@ -0,0 +1,15 @@
+import { ProtoMessage } from "@waku/interfaces";
+
+import { WakuMessage as WakuMessageProto } from "../proto/message";
+
+const EmptyMessage: ProtoMessage = {
+  payload: undefined,
+  contentTopic: undefined,
+  version: undefined,
+  timestamp: undefined,
+  rateLimitProof: undefined,
+};
+
+export function toProtoMessage(wire: WakuMessageProto): ProtoMessage {
+  return { ...EmptyMessage, ...wire };
+}

package/src/lib/utils.ts

@@ -0,0 +1,50 @@
+import { fromString } from "uint8arrays/from-string";
+import { toString } from "uint8arrays/to-string";
+
+/**
+ * Convert input to a byte array.
+ *
+ * Handles both `0x` prefixed and non-prefixed strings.
+ */
+export function hexToBytes(hex: string | Uint8Array): Uint8Array {
+  if (typeof hex === "string") {
+    const _hex = hex.replace(/^0x/i, "");
+    return fromString(_hex.toLowerCase(), "base16");
+  }
+  return hex;
+}
+
+/**
+ * Convert byte array to hex string (no `0x` prefix).
+ */
+export const bytesToHex = (bytes: Uint8Array): string =>
+  toString(bytes, "base16");
+
+/**
+ * Decode byte array to utf-8 string.
+ */
+export const bytesToUtf8 = (b: Uint8Array): string => toString(b, "utf8");
+
+/**
+ * Encode utf-8 string to byte array.
+ */
+export const utf8ToBytes = (s: string): Uint8Array => fromString(s, "utf8");
+
+/**
+ * Concatenate using Uint8Arrays as `Buffer` has a different behavior with `DataView`
+ */
+export function concat(
+  byteArrays: Uint8Array[],
+  totalLength?: number
+): Uint8Array {
+  const len =
+    totalLength ?? byteArrays.reduce((acc, curr) => acc + curr.length, 0);
+  const res = new Uint8Array(len);
+
+  let offset = 0;
+  for (const bytes of byteArrays) {
+    res.set(bytes, offset);
+    offset += bytes.length;
+  }
+  return res;
+}