@waku/core 0.0.1 → 0.0.3

package/src/lib/peer_discovery_dns/fetch_nodes.ts

@@ -1,180 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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/utils.ts

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

package/src/lib/waku_message/constants.ts

@@ -1,10 +0,0 @@
-export const Symmetric = {
-  keySize: 32,
-  ivSize: 12,
-  tagSize: 16,
-  algorithm: { name: "AES-GCM", length: 128 },
-};
-
-export const Asymmetric = {
-  keySize: 32,
-};

package/src/lib/waku_message/ecies.ts

@@ -1,194 +0,0 @@
-import * as secp from "@noble/secp256k1";
-
-import { getSubtle, randomBytes, sha256 } from "../crypto";
-import { concat, hexToBytes } from "../utils";
-/**
- * HKDF as implemented in go-ethereum.
- */
-function kdf(secret: Uint8Array, outputLength: number): Promise<Uint8Array> {
-  let ctr = 1;
-  let written = 0;
-  let willBeResult = Promise.resolve(new Uint8Array());
-  while (written < outputLength) {
-    const counters = new Uint8Array([ctr >> 24, ctr >> 16, ctr >> 8, ctr]);
-    const countersSecret = concat(
-      [counters, secret],
-      counters.length + secret.length
-    );
-    const willBeHashResult = sha256(countersSecret);
-    willBeResult = willBeResult.then((result) =>
-      willBeHashResult.then((hashResult) => {
-        const _hashResult = new Uint8Array(hashResult);
-        return concat(
-          [result, _hashResult],
-          result.length + _hashResult.length
-        );
-      })
-    );
-    written += 32;
-    ctr += 1;
-  }
-  return willBeResult;
-}
-
-function aesCtrEncrypt(
-  counter: Uint8Array,
-  key: ArrayBufferLike,
-  data: ArrayBufferLike
-): Promise<Uint8Array> {
-  return getSubtle()
-    .importKey("raw", key, "AES-CTR", false, ["encrypt"])
-    .then((cryptoKey) =>
-      getSubtle().encrypt(
-        { name: "AES-CTR", counter: counter, length: 128 },
-        cryptoKey,
-        data
-      )
-    )
-    .then((bytes) => new Uint8Array(bytes));
-}
-
-function aesCtrDecrypt(
-  counter: Uint8Array,
-  key: ArrayBufferLike,
-  data: ArrayBufferLike
-): Promise<Uint8Array> {
-  return getSubtle()
-    .importKey("raw", key, "AES-CTR", false, ["decrypt"])
-    .then((cryptoKey) =>
-      getSubtle().decrypt(
-        { name: "AES-CTR", counter: counter, length: 128 },
-        cryptoKey,
-        data
-      )
-    )
-    .then((bytes) => new Uint8Array(bytes));
-}
-
-function hmacSha256Sign(
-  key: ArrayBufferLike,
-  msg: ArrayBufferLike
-): PromiseLike<Uint8Array> {
-  const algorithm = { name: "HMAC", hash: { name: "SHA-256" } };
-  return getSubtle()
-    .importKey("raw", key, algorithm, false, ["sign"])
-    .then((cryptoKey) => getSubtle().sign(algorithm, cryptoKey, msg))
-    .then((bytes) => new Uint8Array(bytes));
-}
-
-function hmacSha256Verify(
-  key: ArrayBufferLike,
-  msg: ArrayBufferLike,
-  sig: ArrayBufferLike
-): Promise<boolean> {
-  const algorithm = { name: "HMAC", hash: { name: "SHA-256" } };
-  const _key = getSubtle().importKey("raw", key, algorithm, false, ["verify"]);
-  return _key.then((cryptoKey) =>
-    getSubtle().verify(algorithm, cryptoKey, sig, msg)
-  );
-}
-
-/**
- * Derive shared secret for given private and public keys.
- *
- * @param  privateKeyA Sender's private key (32 bytes)
- * @param  publicKeyB Recipient's public key (65 bytes)
- * @returns  A promise that resolves with the derived shared secret (Px, 32 bytes)
- * @throws Error If arguments are invalid
- */
-function derive(privateKeyA: Uint8Array, publicKeyB: Uint8Array): Uint8Array {
-  if (privateKeyA.length !== 32) {
-    throw new Error(
-      `Bad private key, it should be 32 bytes but it's actually ${privateKeyA.length} bytes long`
-    );
-  } else if (publicKeyB.length !== 65) {
-    throw new Error(
-      `Bad public key, it should be 65 bytes but it's actually ${publicKeyB.length} bytes long`
-    );
-  } else if (publicKeyB[0] !== 4) {
-    throw new Error("Bad public key, a valid public key would begin with 4");
-  } else {
-    const px = secp.getSharedSecret(privateKeyA, publicKeyB, true);
-    // Remove the compression prefix
-    return new Uint8Array(hexToBytes(px).slice(1));
-  }
-}
-
-/**
- * Encrypt message for given recipient's public key.
- *
- * @param  publicKeyTo Recipient's public key (65 bytes)
- * @param  msg The message being encrypted
- * @return A promise that resolves with the ECIES structure serialized
- */
-export async function encrypt(
-  publicKeyTo: Uint8Array,
-  msg: Uint8Array
-): Promise<Uint8Array> {
-  const ephemPrivateKey = randomBytes(32);
-
-  const sharedPx = await derive(ephemPrivateKey, publicKeyTo);
-
-  const hash = await kdf(sharedPx, 32);
-
-  const iv = randomBytes(16);
-  const encryptionKey = hash.slice(0, 16);
-  const cipherText = await aesCtrEncrypt(iv, encryptionKey, msg);
-
-  const ivCipherText = concat([iv, cipherText], iv.length + cipherText.length);
-
-  const macKey = await sha256(hash.slice(16));
-  const hmac = await hmacSha256Sign(macKey, ivCipherText);
-  const ephemPublicKey = secp.getPublicKey(ephemPrivateKey, false);
-
-  return concat(
-    [ephemPublicKey, ivCipherText, hmac],
-    ephemPublicKey.length + ivCipherText.length + hmac.length
-  );
-}
-
-const metaLength = 1 + 64 + 16 + 32;
-
-/**
- * Decrypt message using given private key.
- *
- * @param privateKey A 32-byte private key of recipient of the message
- * @param encrypted ECIES serialized structure (result of ECIES encryption)
- * @returns The clear text
- * @throws Error If decryption fails
- */
-export async function decrypt(
-  privateKey: Uint8Array,
-  encrypted: Uint8Array
-): Promise<Uint8Array> {
-  if (encrypted.length <= metaLength) {
-    throw new Error(
-      `Invalid Ciphertext. Data is too small. It should ba at least ${metaLength} bytes`
-    );
-  } else if (encrypted[0] !== 4) {
-    throw new Error(
-      `Not a valid ciphertext. It should begin with 4 but actually begin with ${encrypted[0]}`
-    );
-  } else {
-    // deserialize
-    const ephemPublicKey = encrypted.slice(0, 65);
-    const cipherTextLength = encrypted.length - metaLength;
-    const iv = encrypted.slice(65, 65 + 16);
-    const cipherAndIv = encrypted.slice(65, 65 + 16 + cipherTextLength);
-    const ciphertext = cipherAndIv.slice(16);
-    const msgMac = encrypted.slice(65 + 16 + cipherTextLength);
-
-    // check HMAC
-    const px = derive(privateKey, ephemPublicKey);
-    const hash = await kdf(px, 32);
-    const [encryptionKey, macKey] = await sha256(hash.slice(16)).then(
-      (macKey) => [hash.slice(0, 16), macKey]
-    );
-
-    if (!(await hmacSha256Verify(macKey, cipherAndIv, msgMac))) {
-      throw new Error("Incorrect MAC");
-    }
-
-    return aesCtrDecrypt(iv, encryptionKey, ciphertext);
-  }
-}

package/src/lib/waku_message/symmetric.ts

@@ -1,33 +0,0 @@
-import { getSubtle, randomBytes } from "../crypto";
-
-import { Symmetric } from "./constants";
-
-export async function encrypt(
-  iv: Uint8Array,
-  key: Uint8Array,
-  clearText: Uint8Array
-): Promise<Uint8Array> {
-  return getSubtle()
-    .importKey("raw", key, Symmetric.algorithm, false, ["encrypt"])
-    .then((cryptoKey) =>
-      getSubtle().encrypt({ iv, ...Symmetric.algorithm }, cryptoKey, clearText)
-    )
-    .then((cipher) => new Uint8Array(cipher));
-}
-
-export async function decrypt(
-  iv: Uint8Array,
-  key: Uint8Array,
-  cipherText: Uint8Array
-): Promise<Uint8Array> {
-  return getSubtle()
-    .importKey("raw", key, Symmetric.algorithm, false, ["decrypt"])
-    .then((cryptoKey) =>
-      getSubtle().decrypt({ iv, ...Symmetric.algorithm }, cryptoKey, cipherText)
-    )
-    .then((clear) => new Uint8Array(clear));
-}
-
-export function generateIv(): Uint8Array {
-  return randomBytes(Symmetric.ivSize);
-}