@aztec/p2p 0.0.0-test.0

package/src/services/data_store.ts

@@ -0,0 +1,235 @@
+import { filter, map, sort, take } from '@aztec/foundation/iterable';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+
+import { type Batch, type Datastore, Key, type KeyQuery, type Pair, type Query } from 'interface-datastore';
+import type { AwaitIterable } from 'interface-store';
+
+type MemoryItem = {
+  lastAccessedMs: number;
+  data: Uint8Array;
+};
+
+type BatchOp = {
+  type: 'put' | 'del';
+  key: Key;
+  value?: Uint8Array;
+};
+
+class KeyNotFoundError extends Error {
+  code: string;
+  constructor(message: string) {
+    super(message);
+    this.code = 'ERR_NOT_FOUND';
+  }
+}
+
+export class AztecDatastore implements Datastore {
+  #memoryDatastore: Map<string, MemoryItem>;
+  #dbDatastore: AztecAsyncMap<string, Uint8Array>;
+
+  #batchOps: BatchOp[] = [];
+
+  private maxMemoryItems: number;
+
+  constructor(db: AztecAsyncKVStore, { maxMemoryItems } = { maxMemoryItems: 50 }) {
+    this.#memoryDatastore = new Map();
+    this.#dbDatastore = db.openMap('p2p_datastore');
+
+    this.maxMemoryItems = maxMemoryItems;
+  }
+
+  async has(key: Key): Promise<boolean> {
+    return this.#memoryDatastore.has(key.toString()) || (await this.#dbDatastore.hasAsync(key.toString()));
+  }
+
+  async get(key: Key): Promise<Uint8Array> {
+    const keyStr = key.toString();
+    const memoryItem = this.#memoryDatastore.get(keyStr);
+    if (memoryItem) {
+      memoryItem.lastAccessedMs = Date.now();
+      return memoryItem.data;
+    }
+    const dbItem = await this.#dbDatastore.getAsync(keyStr);
+
+    if (!dbItem) {
+      throw new KeyNotFoundError(`Key not found`);
+    }
+
+    return Uint8Array.from(dbItem);
+  }
+
+  put(key: Key, val: Uint8Array): Promise<Key> {
+    return this._put(key, val);
+  }
+
+  async *putMany(source: AwaitIterable<Pair>): AwaitIterable<Key> {
+    for await (const { key, value } of source) {
+      await this.put(key, value);
+      yield key;
+    }
+  }
+
+  async *getMany(source: AwaitIterable<Key>): AwaitIterable<Pair> {
+    for await (const key of source) {
+      yield {
+        key,
+        value: await this.get(key),
+      };
+    }
+  }
+
+  async *deleteMany(source: AwaitIterable<Key>): AwaitIterable<Key> {
+    for await (const key of source) {
+      await this.delete(key);
+      yield key;
+    }
+  }
+
+  async delete(key: Key): Promise<void> {
+    this.#memoryDatastore.delete(key.toString());
+    await this.#dbDatastore.delete(key.toString());
+  }
+
+  batch(): Batch {
+    return {
+      put: (key, value) => {
+        this.#batchOps.push({
+          type: 'put',
+          key,
+          value,
+        });
+      },
+      delete: key => {
+        this.#batchOps.push({
+          type: 'del',
+          key,
+        });
+      },
+      commit: async () => {
+        for (const op of this.#batchOps) {
+          if (op.type === 'put' && op.value) {
+            await this.put(op.key, op.value);
+          } else if (op.type === 'del') {
+            await this.delete(op.key);
+          }
+        }
+        this.#batchOps = []; // Clear operations after commit
+      },
+    };
+  }
+
+  query(q: Query): AwaitIterable<Pair> {
+    let it = this.all(); //
+    const { prefix, filters, orders, offset, limit } = q;
+
+    if (prefix != null) {
+      it = filter(it, e => e.key.toString().startsWith(`${prefix}`));
+    }
+
+    if (Array.isArray(filters)) {
+      it = filters.reduce((it, f) => filter(it, f), it);
+    }
+
+    if (Array.isArray(orders)) {
+      it = orders.reduce((it, f) => sort(it, f), it);
+    }
+
+    if (offset != null) {
+      let i = 0;
+      it = filter(it, () => i++ >= offset);
+    }
+
+    if (limit != null) {
+      it = take(it, limit);
+    }
+
+    return it;
+  }
+
+  queryKeys(q: KeyQuery): AsyncIterable<Key> {
+    let it = map(this.all(), ({ key }) => key);
+    const { prefix, filters, orders, offset, limit } = q;
+    if (prefix != null) {
+      it = filter(it, e => e.toString().startsWith(`${prefix}`));
+    }
+
+    if (Array.isArray(filters)) {
+      it = filters.reduce((it, f) => filter(it, f), it);
+    }
+
+    if (Array.isArray(orders)) {
+      it = orders.reduce((it, f) => sort(it, f), it);
+    }
+
+    if (offset != null) {
+      let i = 0;
+      it = filter(it, () => i++ >= offset);
+    }
+
+    if (limit != null) {
+      it = take(it, limit);
+    }
+
+    return it;
+  }
+
+  private async _put(key: Key, val: Uint8Array): Promise<Key> {
+    const keyStr = key.toString();
+    while (this.#memoryDatastore.size >= this.maxMemoryItems) {
+      this.pruneMemoryDatastore();
+    }
+    const memoryItem = this.#memoryDatastore.get(keyStr);
+    if (memoryItem) {
+      // update existing
+      memoryItem.lastAccessedMs = Date.now();
+      memoryItem.data = val;
+    } else {
+      // new entry
+      this.#memoryDatastore.set(keyStr, { data: val, lastAccessedMs: Date.now() });
+    }
+
+    // Always add to DB
+    await this.#dbDatastore.set(keyStr, val);
+
+    return key;
+  }
+
+  private async *all(): AsyncIterable<Pair> {
+    for (const [key, value] of this.#memoryDatastore.entries()) {
+      yield {
+        key: new Key(key),
+        value: value.data,
+      };
+    }
+
+    for await (const [key, value] of this.#dbDatastore.entriesAsync()) {
+      if (!this.#memoryDatastore.has(key)) {
+        yield {
+          key: new Key(key),
+          value,
+        };
+      }
+    }
+  }
+
+  /**
+   * Prune memory store
+   */
+  private pruneMemoryDatastore(): void {
+    let oldestAccessedMs = Date.now() + 1000;
+    let oldestKey: string | undefined = undefined;
+    let oldestValue: Uint8Array | undefined = undefined;
+
+    for (const [key, value] of this.#memoryDatastore) {
+      if (value.lastAccessedMs < oldestAccessedMs) {
+        oldestAccessedMs = value.lastAccessedMs;
+        oldestKey = key;
+        oldestValue = value.data;
+      }
+    }
+
+    if (oldestKey && oldestValue) {
+      this.#memoryDatastore.delete(oldestKey);
+    }
+  }
+}

package/src/services/discv5/discV5_service.ts

@@ -0,0 +1,256 @@
+import { createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import { type ComponentsVersions, checkCompressedComponentVersion } from '@aztec/stdlib/versioning';
+import { OtelMetricsAdapter, type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { Discv5, type Discv5EventEmitter } from '@chainsafe/discv5';
+import { ENR, SignableENR } from '@chainsafe/enr';
+import type { PeerId } from '@libp2p/interface';
+import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
+import EventEmitter from 'events';
+
+import type { P2PConfig } from '../../config.js';
+import { AZTEC_ENR_KEY, Discv5Event, PeerEvent } from '../../types/index.js';
+import { convertToMultiaddr } from '../../util.js';
+import { setAztecEnrKey } from '../../versioning.js';
+import { type PeerDiscoveryService, PeerDiscoveryState } from '../service.js';
+
+const delayBeforeStart = 2000; // 2sec
+
+/**
+ * Peer discovery service using Discv5.
+ */
+export class DiscV5Service extends EventEmitter implements PeerDiscoveryService {
+  /** The Discv5 instance */
+  private discv5: Discv5 & Discv5EventEmitter;
+
+  /** This instance's ENR */
+  private enr: SignableENR;
+
+  /** Version identifiers. */
+  private versions: ComponentsVersions;
+
+  /** UDP listen addr */
+  private listenMultiAddrUdp: Multiaddr;
+
+  private currentState = PeerDiscoveryState.STOPPED;
+
+  public readonly bootstrapNodes: string[] = [];
+  private bootstrapNodePeerIds: PeerId[] = [];
+  private bootstrapNodeEnrs: ENR[] = [];
+
+  private startTime = 0;
+
+  constructor(
+    private peerId: PeerId,
+    private config: P2PConfig,
+    telemetry: TelemetryClient = getTelemetryClient(),
+    private logger = createLogger('p2p:discv5_service'),
+  ) {
+    super();
+    const { tcpAnnounceAddress, udpAnnounceAddress, udpListenAddress, bootstrapNodes } = config;
+    this.bootstrapNodes = bootstrapNodes ?? [];
+    this.bootstrapNodeEnrs = this.bootstrapNodes.map(x => ENR.decodeTxt(x));
+    // create ENR from PeerId
+    this.enr = SignableENR.createFromPeerId(peerId);
+    // Add aztec identification to ENR
+    this.versions = setAztecEnrKey(this.enr, config);
+
+    if (!tcpAnnounceAddress) {
+      throw new Error('You need to provide at least a TCP announce address.');
+    }
+
+    const multiAddrTcp = multiaddr(`${convertToMultiaddr(tcpAnnounceAddress, 'tcp')}/p2p/${peerId.toString()}`);
+    // if no udp announce address is provided, use the tcp announce address
+    const multiAddrUdp = multiaddr(
+      `${convertToMultiaddr(udpAnnounceAddress || tcpAnnounceAddress, 'udp')}/p2p/${peerId.toString()}`,
+    );
+
+    this.listenMultiAddrUdp = multiaddr(convertToMultiaddr(udpListenAddress, 'udp'));
+
+    // set location multiaddr in ENR record
+    this.enr.setLocationMultiaddr(multiAddrUdp);
+    this.enr.setLocationMultiaddr(multiAddrTcp);
+
+    const metricsRegistry = new OtelMetricsAdapter(telemetry);
+    this.discv5 = Discv5.create({
+      enr: this.enr,
+      peerId,
+      bindAddrs: { ip4: this.listenMultiAddrUdp },
+      config: {
+        lookupTimeout: 2000,
+        requestTimeout: 2000,
+        allowUnverifiedSessions: true,
+      },
+      metricsRegistry,
+    });
+
+    // Hook onto the onEstablished method to check the peer's version from the ENR,
+    // so we don't add it to our dht if it doesn't have the correct version.
+    // In addition, we'll hook onto onDiscovered to to repeat the same check there,
+    // just in case. Note that not adding the peer to the dht could lead to it
+    // being "readded" constantly, we'll need to keep an eye on whether this
+    // turns out to be a problem or not.
+    const origOnEstablished = this.discv5.onEstablished.bind(this.discv5);
+    this.discv5.onEstablished = (...args: unknown[]) => {
+      const enr = args[1] as ENR;
+      // A special case is for bootnodes. If this is a bootnode and we have been told to skip version checks
+      // then proceed straight to handling the event
+      if (!this.config.bootstrapNodeEnrVersionCheck && this.isOurBootnode(enr)) {
+        return origOnEstablished(...args);
+      }
+      if (this.validateEnr(enr)) {
+        return origOnEstablished(...args);
+      }
+    };
+
+    this.discv5.on(Discv5Event.DISCOVERED, this.onDiscovered.bind(this));
+    this.discv5.on(Discv5Event.ENR_ADDED, this.onEnrAdded.bind(this));
+  }
+
+  public async start(): Promise<void> {
+    if (this.currentState === PeerDiscoveryState.RUNNING) {
+      throw new Error('DiscV5Service already started');
+    }
+    this.logger.debug('Starting DiscV5');
+    await this.discv5.start();
+    this.startTime = Date.now();
+
+    this.logger.info(`DiscV5 service started`, {
+      nodeId: this.enr.nodeId,
+      peerId: this.peerId,
+      enrUdp: await this.enr.getFullMultiaddr('udp'),
+      enrTcp: await this.enr.getFullMultiaddr('tcp'),
+      versions: this.versions,
+    });
+    this.currentState = PeerDiscoveryState.RUNNING;
+
+    // Add bootnode ENR if provided
+    if (this.bootstrapNodes?.length) {
+      // Do this conversion once since it involves an async function call
+      this.bootstrapNodePeerIds = await Promise.all(this.bootstrapNodeEnrs.map(enr => enr.peerId()));
+      this.logger.info(`Adding ${this.bootstrapNodes} bootstrap nodes ENRs: ${this.bootstrapNodes.join(', ')}`);
+      for (const enr of this.bootstrapNodeEnrs) {
+        try {
+          if (this.config.bootstrapNodeEnrVersionCheck) {
+            const value = enr.kvs.get(AZTEC_ENR_KEY);
+            if (!value) {
+              throw new Error('ENR does not contain aztec key');
+            }
+            checkCompressedComponentVersion(Buffer.from(value).toString(), this.versions);
+          }
+          this.discv5.addEnr(enr);
+        } catch (e) {
+          this.logger.error(`Error adding bootratrap node ${enr.encodeTxt()}`, e);
+        }
+      }
+    }
+  }
+
+  public async runRandomNodesQuery(): Promise<void> {
+    if (this.currentState !== PeerDiscoveryState.RUNNING) {
+      throw new Error('DiscV5Service not running');
+    }
+
+    // First, wait some time before starting the peer discovery
+    // reference: https://github.com/ChainSafe/lodestar/issues/3423
+    const msSinceStart = Date.now() - this.startTime;
+    if (Date.now() - this.startTime <= delayBeforeStart) {
+      await sleep(delayBeforeStart - msSinceStart);
+    }
+
+    try {
+      await this.discv5.findRandomNode();
+    } catch (err) {
+      this.logger.error(`Error running discV5 random node query: ${err}`);
+    }
+  }
+
+  public getAllPeers(): ENR[] {
+    return this.discv5.kadValues();
+  }
+
+  public getEnr(): ENR {
+    return this.enr.toENR();
+  }
+
+  public getPeerId(): PeerId {
+    return this.peerId;
+  }
+
+  public getStatus(): PeerDiscoveryState {
+    return this.currentState;
+  }
+
+  public isBootstrapPeer(peerId: PeerId): boolean {
+    return this.bootstrapNodePeerIds.some(node => node.equals(peerId));
+  }
+
+  public async stop(): Promise<void> {
+    await this.discv5.off(Discv5Event.DISCOVERED, this.onDiscovered);
+    await this.discv5.off(Discv5Event.ENR_ADDED, this.onEnrAdded);
+
+    await this.discv5.stop();
+
+    this.currentState = PeerDiscoveryState.STOPPED;
+  }
+
+  private async onEnrAdded(enr: ENR) {
+    const multiAddrTcp = await enr.getFullMultiaddr('tcp');
+    const multiAddrUdp = await enr.getFullMultiaddr('udp');
+    this.logger.debug(`Added ENR ${enr.encodeTxt()}`, { multiAddrTcp, multiAddrUdp, nodeId: enr.nodeId });
+    this.onDiscovered(enr);
+  }
+
+  private isOurBootnode(enr: ENR) {
+    return this.bootstrapNodeEnrs.some(x => x.nodeId === enr.nodeId);
+  }
+
+  private onDiscovered(enr: ENR) {
+    // Find out if this is one of our bootnodes
+    if (this.isOurBootnode(enr)) {
+      // it is, what we do here depends
+      if (!this.config.bootstrapNodesAsFullPeers) {
+        // we don't consider bootnodes as full peers, don't perform any checks and don't emit anything
+        return;
+      }
+      if (!this.config.bootstrapNodeEnrVersionCheck) {
+        // we do consider bootnodes to be full peers and we have been told to NOT version check them, so emit
+        this.logger.trace(`Skipping version check for bootnode ${enr.nodeId}`);
+        this.emit(PeerEvent.DISCOVERED, enr);
+        return;
+      }
+      // here, we do consider bootnodes as full peers and we must version check so we continue to regular validation
+    }
+    if (this.validateEnr(enr)) {
+      this.emit(PeerEvent.DISCOVERED, enr);
+    }
+  }
+
+  private validateEnr(enr: ENR): boolean {
+    // Check the peer is an aztec peer
+    const value = enr.kvs.get(AZTEC_ENR_KEY);
+    if (!value) {
+      this.logger.warn(`Peer node ${enr.nodeId} does not have aztec key in ENR`);
+      return false;
+    }
+
+    // And check it has the correct version
+    let compressedVersion;
+    try {
+      compressedVersion = Buffer.from(value).toString();
+      checkCompressedComponentVersion(compressedVersion, this.versions);
+      return true;
+    } catch (err: any) {
+      if (err.name === 'ComponentsVersionsError') {
+        this.logger.debug(`Peer node ${enr.nodeId} has incorrect version: ${err.message}`, {
+          compressedVersion,
+          expected: this.versions,
+        });
+      } else {
+        this.logger.error(`Error checking peer version`, err);
+      }
+    }
+    return false;
+  }
+}

package/src/services/dummy_service.ts

@@ -0,0 +1,134 @@
+import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
+import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/stdlib/p2p';
+import { TxHash } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+import EventEmitter from 'events';
+
+import type { ReqRespSubProtocol, SubProtocolMap } from './reqresp/interface.js';
+import { type P2PService, type PeerDiscoveryService, PeerDiscoveryState } from './service.js';
+
+/**
+ * A dummy implementation of the P2P Service.
+ */
+export class DummyP2PService implements P2PService {
+  /** Returns an empty array for peers. */
+  getPeers(): PeerInfo[] {
+    return [];
+  }
+
+  /**
+   * Starts the dummy implementation.
+   * @returns A resolved promise.
+   */
+  public start() {
+    return Promise.resolve();
+  }
+
+  /**
+   * Stops the dummy implementation.
+   * @returns A resolved promise.
+   */
+  public stop() {
+    return Promise.resolve();
+  }
+
+  /**
+   * Called to have the given message propagated through the P2P network.
+   * @param _ - The message to be propagated.
+   */
+  public propagate<T extends Gossipable>(_: T) {}
+
+  /**
+   * Called upon receipt of settled transactions.
+   * @param _ - The hashes of the settled transactions.
+   */
+  public settledTxs(_: TxHash[]) {}
+
+  /**
+   * Register a callback into the validator client for when a block proposal is received
+   */
+  public registerBlockReceivedCallback(_: (block: BlockProposal) => Promise<BlockAttestation>) {}
+
+  /**
+   * Sends a request to a peer.
+   * @param _protocol - The protocol to send the request on.
+   * @param _request - The request to send.
+   * @returns The response from the peer, otherwise undefined.
+   */
+  public sendRequest<Protocol extends ReqRespSubProtocol>(
+    _protocol: Protocol,
+    _request: InstanceType<SubProtocolMap[Protocol]['request']>,
+  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']> | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  /**
+   * Sends a batch request to a peer.
+   * @param _protocol - The protocol to send the request on.
+   * @param _requests - The requests to send.
+   * @returns The responses from the peer, otherwise undefined.
+   */
+  public sendBatchRequest<Protocol extends ReqRespSubProtocol>(
+    _protocol: Protocol,
+    _requests: InstanceType<SubProtocolMap[Protocol]['request']>[],
+  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[]> {
+    return Promise.resolve([]);
+  }
+
+  /**
+   * Returns the ENR of the peer.
+   * @returns The ENR of the peer, otherwise undefined.
+   */
+  public getEnr(): undefined {
+    return undefined;
+  }
+}
+
+/**
+ * A dummy implementation of the Peer Discovery Service.
+ */
+export class DummyPeerDiscoveryService extends EventEmitter implements PeerDiscoveryService {
+  private currentState = PeerDiscoveryState.STOPPED;
+  public bootstrapNodes: string[] = [];
+
+  /**
+   * Starts the dummy implementation.
+   * @returns A resolved promise.
+   */
+  public start() {
+    this.currentState = PeerDiscoveryState.RUNNING;
+    return Promise.resolve();
+  }
+  /**
+   * Stops the dummy implementation.
+   * @returns A resolved promise.
+   */
+  public stop() {
+    this.currentState = PeerDiscoveryState.STOPPED;
+    return Promise.resolve();
+  }
+  /**
+   * Called to discover peers in the network.
+   * @returns An array of discovered peer addresses.
+   */
+  public getAllPeers() {
+    return [];
+  }
+
+  public runRandomNodesQuery(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  public isBootstrapPeer(_: PeerId): boolean {
+    return false;
+  }
+
+  public getStatus(): PeerDiscoveryState {
+    return this.currentState;
+  }
+
+  public getEnr(): undefined {
+    return undefined;
+  }
+}

package/src/services/encoding.ts

@@ -0,0 +1,79 @@
+// Taken from lodestar: https://github.com/ChainSafe/lodestar
+import { sha256 } from '@aztec/foundation/crypto';
+
+import type { RPC } from '@chainsafe/libp2p-gossipsub/message';
+import type { DataTransform } from '@chainsafe/libp2p-gossipsub/types';
+import type { Message } from '@libp2p/interface';
+import { compressSync, uncompressSync } from 'snappy';
+import xxhashFactory from 'xxhash-wasm';
+
+// Load WASM
+const xxhash = await xxhashFactory();
+
+// Use salt to prevent msgId from being mined for collisions
+const h64Seed = BigInt(Math.floor(Math.random() * 1e9));
+
+// Shared buffer to convert msgId to string
+const sharedMsgIdBuf = Buffer.alloc(20);
+
+/**
+ * The function used to generate a gossipsub message id
+ * We use the first 8 bytes of SHA256(data) for content addressing
+ */
+export function fastMsgIdFn(rpcMsg: RPC.Message): string {
+  if (rpcMsg.data) {
+    return xxhash.h64Raw(rpcMsg.data, h64Seed).toString(16);
+  }
+  return '0000000000000000';
+}
+
+export function msgIdToStrFn(msgId: Uint8Array): string {
+  // This happens serially, no need to reallocate the buffer
+  sharedMsgIdBuf.set(msgId);
+  return `0x${sharedMsgIdBuf.toString('hex')}`;
+}
+
+/**
+ * Get the message identifier from a libp2p message
+ *
+ * Follows similarly to:
+ * https://github.com/ethereum/consensus-specs/blob/v1.1.0-alpha.7/specs/altair/p2p-interface.md#topics-and-messages
+ *
+ * @param message - The libp2p message
+ * @returns The message identifier
+ */
+export function getMsgIdFn(message: Message) {
+  const { topic } = message;
+
+  const vec = [Buffer.from(topic), message.data];
+  return sha256(Buffer.concat(vec)).subarray(0, 20);
+}
+
+/**
+ * Snappy transform for libp2p gossipsub
+ */
+export class SnappyTransform implements DataTransform {
+  // Topic string included to satisfy DataTransform interface
+  inboundTransform(_topicStr: string, data: Uint8Array): Uint8Array {
+    return this.inboundTransformNoTopic(Buffer.from(data));
+  }
+
+  public inboundTransformNoTopic(data: Buffer): Buffer {
+    if (data.length === 0) {
+      return data;
+    }
+    return Buffer.from(uncompressSync(data, { asBuffer: true }));
+  }
+
+  // Topic string included to satisfy DataTransform interface
+  outboundTransform(_topicStr: string, data: Uint8Array): Uint8Array {
+    return this.outboundTransformNoTopic(Buffer.from(data));
+  }
+
+  public outboundTransformNoTopic(data: Buffer): Buffer {
+    if (data.length === 0) {
+      return data;
+    }
+    return Buffer.from(compressSync(data));
+  }
+}