@aztec/p2p 0.0.0-test.0

package/src/testbench/worker_client_manager.ts

@@ -0,0 +1,318 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import type { ChainConfig } from '@aztec/stdlib/config';
+
+import { type ChildProcess, fork } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { type P2PConfig, getP2PDefaultConfig } from '../config.js';
+import { generatePeerIdPrivateKeys } from '../test-helpers/generate-peer-id-private-keys.js';
+import { getPorts } from '../test-helpers/get-ports.js';
+import { makeEnr, makeEnrs } from '../test-helpers/make-enrs.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const workerPath = path.join(__dirname, '../../dest/testbench/p2p_client_testbench_worker.js');
+
+const testChainConfig: ChainConfig = {
+  l1ChainId: 31337,
+  version: 1,
+  l1Contracts: {
+    rollupAddress: EthAddress.random(),
+  },
+};
+
+class WorkerClientManager {
+  public processes: ChildProcess[] = [];
+  public peerIdPrivateKeys: string[] = [];
+  public peerEnrs: string[] = [];
+  public ports: number[] = [];
+  private p2pConfig: Partial<P2PConfig>;
+  private logger: Logger;
+  private messageReceivedByClient: number[] = [];
+
+  constructor(logger: Logger, p2pConfig: Partial<P2PConfig>) {
+    this.logger = logger;
+    this.p2pConfig = p2pConfig;
+  }
+
+  destroy() {
+    this.cleanup().catch((error: Error) => {
+      this.logger.error('Failed to cleanup worker client manager', error);
+      process.exit(1);
+    });
+  }
+
+  /**
+   * Creates address strings from a port
+   */
+  private getAddresses(port: number) {
+    return {
+      addr: `127.0.0.1:${port}`,
+      listenAddr: `0.0.0.0:${port}`,
+    };
+  }
+
+  /**
+   * Creates a client configuration object
+   */
+  private createClientConfig(clientIndex: number, port: number, otherNodes: string[]) {
+    const { addr, listenAddr } = this.getAddresses(port);
+
+    return {
+      ...getP2PDefaultConfig(),
+      p2pEnabled: true,
+      peerIdPrivateKey: this.peerIdPrivateKeys[clientIndex],
+      tcpListenAddress: listenAddr,
+      udpListenAddress: listenAddr,
+      tcpAnnounceAddress: addr,
+      udpAnnounceAddress: addr,
+      bootstrapNodes: [...otherNodes],
+      ...this.p2pConfig,
+    };
+  }
+
+  /**
+   * Spawns a worker process and returns a promise that resolves when the worker is ready
+   */
+  private spawnWorkerProcess(
+    config: P2PConfig & Partial<ChainConfig>,
+    clientIndex: number,
+  ): [ChildProcess, Promise<void>] {
+    const childProcess = fork(workerPath);
+    childProcess.send({ type: 'START', config, clientIndex });
+
+    // Handle unexpected child process exit
+    childProcess.on('exit', (code, signal) => {
+      if (code !== 0) {
+        this.logger.warn(`Worker ${clientIndex} exited unexpectedly with code ${code} and signal ${signal}`);
+      }
+    });
+
+    childProcess.on('message', (msg: any) => {
+      if (msg.type === 'GOSSIP_RECEIVED') {
+        this.messageReceivedByClient[clientIndex] = msg.count;
+      }
+    });
+
+    // Create ready signal promise
+    const readySignal = new Promise<void>((resolve, reject) => {
+      // Set a timeout to avoid hanging indefinitely
+      const timeout = setTimeout(() => {
+        reject(new Error(`Timeout waiting for worker ${clientIndex} to be ready`));
+      }, 30000); // 30 second timeout
+
+      childProcess.once('message', (msg: any) => {
+        clearTimeout(timeout);
+        if (msg.type === 'READY') {
+          resolve();
+        }
+        // For future use
+        if (msg.type === 'ERROR') {
+          reject(new Error(msg.error));
+        }
+      });
+
+      // Also resolve/reject if process exits before sending message
+      childProcess.once('exit', code => {
+        clearTimeout(timeout);
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Worker ${clientIndex} exited with code ${code} before becoming ready`));
+        }
+      });
+    });
+
+    return [childProcess, readySignal];
+  }
+
+  /**
+   * Creates a number of worker clients in separate processes
+   * All are configured to connect to each other and overrided with the test specific config
+   *
+   * @param numberOfClients - The number of clients to create
+   * @returns The ENRs of the created clients
+   */
+  async makeWorkerClients(numberOfClients: number) {
+    try {
+      this.messageReceivedByClient = new Array(numberOfClients).fill(0);
+      this.peerIdPrivateKeys = generatePeerIdPrivateKeys(numberOfClients);
+      this.ports = await getPorts(numberOfClients);
+      this.peerEnrs = await makeEnrs(this.peerIdPrivateKeys, this.ports, testChainConfig);
+
+      this.processes = [];
+      const readySignals: Promise<void>[] = [];
+
+      for (let i = 0; i < numberOfClients; i++) {
+        this.logger.info(`Creating client ${i}`);
+
+        // Maximum seed with 10 other peers to allow peer discovery to connect them at a smoother rate
+        const otherNodes = this.peerEnrs.filter((_, ind) => ind < Math.min(i, 10));
+
+        const config = this.createClientConfig(i, this.ports[i], otherNodes);
+        const [childProcess, readySignal] = this.spawnWorkerProcess(config, i);
+
+        readySignals.push(readySignal);
+        this.processes.push(childProcess);
+      }
+
+      // Wait for peers to all connect with each other
+      await sleep(10000);
+
+      // Wait for all peers to be booted up with timeout
+      await Promise.race([
+        Promise.all(readySignals),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error('Timeout waiting for all workers to be ready')), 30000),
+        ),
+      ]);
+
+      return this.peerEnrs;
+    } catch (error) {
+      // Clean up any processes that were created if there's an error
+      this.logger.error('Error during makeWorkerClients:', error);
+      await this.cleanup();
+      throw error;
+    }
+  }
+
+  purgeMessageReceivedByClient() {
+    this.messageReceivedByClient = new Array(this.processes.length).fill(0);
+  }
+
+  numberOfClientsThatReceivedMessage() {
+    return this.messageReceivedByClient.filter(count => count > 0).length;
+  }
+
+  /**
+   * Changes the port for a specific client
+   *
+   * @param clientIndex - The index of the client to change port for
+   * @param newPort - The new port to use
+   */
+  async changePort(clientIndex: number, newPort: number) {
+    try {
+      if (clientIndex < 0 || clientIndex >= this.processes.length) {
+        throw new Error(`Invalid client index: ${clientIndex}`);
+      }
+
+      this.processes[clientIndex].send({ type: 'STOP' });
+
+      // Wait for the process to be ready with a timeout
+      await sleep(10000);
+
+      this.logger.info(`Changing port for client ${clientIndex} to ${newPort}`);
+
+      // Update the port in the ports array
+      this.ports[clientIndex] = newPort;
+
+      // Update the port in the peerEnrs array
+      this.peerEnrs[clientIndex] = await makeEnr(this.peerIdPrivateKeys[clientIndex], newPort, testChainConfig);
+
+      // Maximum seed with 10 other peers to allow peer discovery to connect them at a smoother rate
+      const otherNodes = this.peerEnrs.filter(
+        (_, ind) => ind !== clientIndex && ind < Math.min(this.peerEnrs.length, 10),
+      );
+
+      const config = this.createClientConfig(clientIndex, newPort, otherNodes);
+      const [childProcess, readySignal] = this.spawnWorkerProcess(config, clientIndex);
+
+      this.processes[clientIndex] = childProcess;
+
+      // Wait for the process to be ready with a timeout
+      await Promise.race([
+        readySignal,
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error(`Timeout waiting for client ${clientIndex} to be ready`)), 30000),
+        ),
+      ]);
+    } catch (error) {
+      this.logger.error(`Error during changePort for client ${clientIndex}:`, error);
+      // Only clean up the specific process that had an issue
+      await this.terminateProcess(this.processes[clientIndex], clientIndex);
+      throw error;
+    }
+  }
+
+  /**
+   * Terminate a single process with timeout and force kill if needed
+   */
+  private terminateProcess(process: ChildProcess, index: number): Promise<void> {
+    if (!process || process.killed) {
+      return Promise.resolve();
+    }
+
+    return new Promise<void>(resolve => {
+      // Set a timeout for the graceful exit
+      const forceKillTimeout = setTimeout(() => {
+        this.logger.warn(`Process ${index} didn't exit gracefully, force killing...`);
+        try {
+          process.kill('SIGKILL'); // Force kill
+        } catch (e) {
+          this.logger.error(`Error force killing process ${index}:`, e);
+        }
+      }, 10000); // 10 second timeout for graceful exit
+
+      // Listen for process exit
+      process.once('exit', () => {
+        clearTimeout(forceKillTimeout);
+        resolve();
+      });
+
+      // Try to gracefully stop the process
+      try {
+        process.send({ type: 'STOP' });
+      } catch (e) {
+        // If sending the message fails, force kill immediately
+        clearTimeout(forceKillTimeout);
+        try {
+          process.kill('SIGKILL');
+        } catch (killError) {
+          this.logger.error(`Error force killing process ${index}:`, killError);
+        }
+        resolve();
+      }
+    });
+  }
+
+  /**
+   * Cleans up all worker processes with timeout and force kill if needed
+   */
+  async cleanup() {
+    this.logger.info(`Cleaning up ${this.processes.length} worker processes`);
+
+    // Create array of promises for each process termination
+    const terminationPromises = this.processes.map((process, index) => this.terminateProcess(process, index));
+
+    // Wait for all processes to terminate with a timeout
+    try {
+      await Promise.race([
+        Promise.all(terminationPromises),
+        new Promise<void>(resolve => {
+          setTimeout(() => {
+            this.logger.warn('Some processes did not terminate in time, force killing all remaining...');
+            this.processes.forEach(p => {
+              try {
+                if (!p.killed) {
+                  p.kill('SIGKILL');
+                }
+              } catch (e) {
+                // Ignore errors when force killing
+              }
+            });
+            resolve();
+          }, 30000); // 30 second timeout for all processes
+        }),
+      ]);
+    } catch (error) {
+      this.logger.error('Error during cleanup:', error);
+    }
+
+    this.processes = [];
+    this.logger.info('All worker processes cleaned up');
+  }
+}
+
+export { WorkerClientManager, testChainConfig };

package/src/types/index.ts

@@ -0,0 +1,36 @@
+/***************************************************
+ *                    Events
+ ***************************************************/
+
+/**
+ * Events emitted from the libp2p node.
+ */
+export enum PeerEvent {
+  DISCOVERED = 'peer:discovered',
+  CONNECTED = 'peer:connect',
+  DISCONNECTED = 'peer:disconnect',
+}
+
+/**
+ * Events emitted from the Discv5 service.
+ */
+export enum Discv5Event {
+  DISCOVERED = 'discovered',
+  ENR_ADDED = 'enrAdded',
+}
+
+/**
+ * Events emitted from the GossipSub protocol.
+ */
+export enum GossipSubEvent {
+  MESSAGE = 'gossipsub:message',
+}
+
+/***************************************************
+ *                    Types
+ ***************************************************/
+
+/**
+ * Aztec network specific types
+ */
+export const AZTEC_ENR_KEY = 'aztec';

package/src/util.ts

@@ -0,0 +1,196 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+
+import type { GossipSub } from '@chainsafe/libp2p-gossipsub';
+import { generateKeyPair, marshalPrivateKey, unmarshalPrivateKey } from '@libp2p/crypto/keys';
+import type { PeerId, PrivateKey } from '@libp2p/interface';
+import type { ConnectionManager } from '@libp2p/interface-internal';
+import { createFromPrivKey } from '@libp2p/peer-id-factory';
+import { resolve } from 'dns/promises';
+import type { Libp2p } from 'libp2p';
+
+import type { P2PConfig } from './config.js';
+
+export interface PubSubLibp2p extends Libp2p {
+  services: {
+    pubsub: GossipSub;
+    components: {
+      connectionManager: ConnectionManager;
+    };
+  };
+}
+
+/**
+ * Converts an address string to a multiaddr string.
+ * Example usage:
+ * const tcpAddr = '123.456.7.8:80' -> /ip4/123.456.7.8/tcp/80
+ * const udpAddr = '[2001:db8::1]:8080' -> /ip6/2001:db8::1/udp/8080
+ * @param address - The address string to convert. Has to be in the format <addr>:<port>.
+ * @param protocol - The protocol to use in the multiaddr string.
+ * @returns A multiaddr compliant string.  */
+export function convertToMultiaddr(address: string, protocol: 'tcp' | 'udp'): string {
+  const [addr, port] = splitAddressPort(address, false);
+
+  const multiaddrPrefix = addressToMultiAddressType(addr);
+  if (multiaddrPrefix === 'dns') {
+    throw new Error('Invalid address format. Expected an IPv4 or IPv6 address.');
+  }
+
+  return `/${multiaddrPrefix}/${addr}/${protocol}/${port}`;
+}
+
+/**
+ * Splits an <address>:<port> string into its components.
+ * @returns The ip6 or ip4 address & port separately
+ */
+export function splitAddressPort(address: string, allowEmptyAddress: boolean): [string, string] {
+  let addr: string;
+  let port: string;
+
+  if (address.startsWith('[')) {
+    // IPv6 address enclosed in square brackets
+    const match = address.match(/^\[([^\]]+)\]:(\d+)$/);
+    if (!match) {
+      throw new Error(`Invalid IPv6 address format:${address}. Expected format: [<addr>]:<port>`);
+    }
+    [, addr, port] = match;
+  } else {
+    // IPv4 address
+    [addr, port] = address.split(':');
+    if ((!addr && !allowEmptyAddress) || !port) {
+      throw new Error(`Invalid address format: ${address}. Expected format: <addr>:<port>`);
+    }
+  }
+
+  return [addr, port];
+}
+
+/**
+ * Queries the public IP address of the machine.
+ */
+export async function getPublicIp(): Promise<string> {
+  const resp = await fetch('http://checkip.amazonaws.com/');
+  const text = await resp.text();
+  return text.trim();
+}
+
+export async function resolveAddressIfNecessary(address: string): Promise<string> {
+  const [addr, port] = splitAddressPort(address, false);
+  const multiaddrPrefix = addressToMultiAddressType(addr);
+  if (multiaddrPrefix === 'dns') {
+    const resolvedAddresses = await resolve(addr);
+    if (resolvedAddresses.length === 0) {
+      throw new Error(`Could not resolve address: ${addr}`);
+    }
+    return `${resolvedAddresses[0]}:${port}`;
+  } else {
+    return address;
+  }
+}
+
+// Not public because it is not used outside of this file.
+// Plus, it relies on `splitAddressPort` being called on the address first.
+function addressToMultiAddressType(address: string): 'ip4' | 'ip6' | 'dns' {
+  if (address.includes(':')) {
+    return 'ip6';
+  } else if (address.match(/^[\d.]+$/)) {
+    return 'ip4';
+  } else {
+    return 'dns';
+  }
+}
+
+export async function configureP2PClientAddresses(
+  _config: P2PConfig & DataStoreConfig,
+): Promise<P2PConfig & DataStoreConfig> {
+  const config = { ..._config };
+  const {
+    tcpAnnounceAddress: configTcpAnnounceAddress,
+    udpAnnounceAddress: configUdpAnnounceAddress,
+    queryForIp,
+  } = config;
+
+  config.tcpAnnounceAddress = configTcpAnnounceAddress
+    ? await resolveAddressIfNecessary(configTcpAnnounceAddress)
+    : undefined;
+  config.udpAnnounceAddress = configUdpAnnounceAddress
+    ? await resolveAddressIfNecessary(configUdpAnnounceAddress)
+    : undefined;
+
+  // create variable for re-use if needed
+  let publicIp;
+
+  // check if no announce IP was provided
+  const splitTcpAnnounceAddress = splitAddressPort(configTcpAnnounceAddress || '', true);
+  if (splitTcpAnnounceAddress.length == 2 && splitTcpAnnounceAddress[0] === '') {
+    if (queryForIp) {
+      publicIp = await getPublicIp();
+      const tcpAnnounceAddress = `${publicIp}:${splitTcpAnnounceAddress[1]}`;
+      config.tcpAnnounceAddress = tcpAnnounceAddress;
+    } else {
+      throw new Error(
+        `Invalid announceTcpAddress provided: ${configTcpAnnounceAddress}. Expected format: <addr>:<port>`,
+      );
+    }
+  }
+
+  const splitUdpAnnounceAddress = splitAddressPort(configUdpAnnounceAddress || '', true);
+  if (splitUdpAnnounceAddress.length == 2 && splitUdpAnnounceAddress[0] === '') {
+    // If announceUdpAddress is not provided, use announceTcpAddress
+    if (!queryForIp && config.tcpAnnounceAddress) {
+      config.udpAnnounceAddress = config.tcpAnnounceAddress;
+    } else if (queryForIp) {
+      const udpPublicIp = publicIp || (await getPublicIp());
+      const udpAnnounceAddress = `${udpPublicIp}:${splitUdpAnnounceAddress[1]}`;
+      config.udpAnnounceAddress = udpAnnounceAddress;
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Get the peer id private key
+ *
+ * 1. Check if we have a peer id private key in the config
+ * 2. If not, check we have a peer id private key persisted in the node
+ * 3. If not, create a new one, then persist it in the node
+ *
+ */
+export async function getPeerIdPrivateKey(
+  config: { peerIdPrivateKey?: string },
+  store: AztecAsyncKVStore,
+): Promise<string> {
+  const peerIdPrivateKeySingleton = store.openSingleton<string>('peerIdPrivateKey');
+  if (config.peerIdPrivateKey) {
+    await peerIdPrivateKeySingleton.set(config.peerIdPrivateKey);
+    return config.peerIdPrivateKey;
+  }
+
+  const storedPeerIdPrivateKey = await peerIdPrivateKeySingleton.getAsync();
+  if (storedPeerIdPrivateKey) {
+    return storedPeerIdPrivateKey;
+  }
+
+  const newPeerIdPrivateKey = await generateKeyPair('secp256k1');
+  const privateKeyString = Buffer.from(marshalPrivateKey(newPeerIdPrivateKey)).toString('hex');
+
+  await peerIdPrivateKeySingleton.set(privateKeyString);
+  return privateKeyString;
+}
+
+/**
+ * Create a libp2p peer ID from the private key.
+ * @param privateKey - peer ID private key as hex string
+ * @returns The peer ID.
+ */
+export async function createLibP2PPeerIdFromPrivateKey(privateKey: string): Promise<PeerId> {
+  if (!privateKey?.length) {
+    throw new Error('No peer private key provided');
+  }
+
+  const asLibp2pPrivateKey: PrivateKey<'secp256k1'> = await unmarshalPrivateKey(
+    new Uint8Array(Buffer.from(privateKey, 'hex')),
+  );
+  return await createFromPrivKey(asLibp2pPrivateKey);
+}

package/src/versioning.ts

@@ -0,0 +1,50 @@
+import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import type { ChainConfig } from '@aztec/stdlib/config';
+import {
+  type ComponentsVersions,
+  checkCompressedComponentVersion,
+  compressComponentVersions,
+  getComponentsVersionsFromConfig,
+} from '@aztec/stdlib/versioning';
+
+import type { SignableENR } from '@chainsafe/enr';
+import xxhashFactory from 'xxhash-wasm';
+
+import { AZTEC_ENR_KEY } from './types/index.js';
+
+const USE_XX_HASH = false; // Enable to reduce the size of the ENR record for production
+const XX_HASH_LEN = 8;
+const xxhash = await xxhashFactory();
+
+/** Returns the component versions based on config and this build. */
+export function getVersions(config: ChainConfig) {
+  return getComponentsVersionsFromConfig(config, protocolContractTreeRoot, getVKTreeRoot());
+}
+
+/** Sets the aztec key on the ENR record with versioning info. */
+export function setAztecEnrKey(enr: SignableENR, config: ChainConfig, useXxHash = USE_XX_HASH) {
+  const versions = getVersions(config);
+  const value = versionsToEnrValue(versions, useXxHash);
+  enr.set(AZTEC_ENR_KEY, value);
+  return versions;
+}
+
+/** Checks the given value from an ENR record against the expected versions. */
+export function checkAztecEnrVersion(enrValue: Buffer, expectedVersions: ComponentsVersions) {
+  if (enrValue.length === XX_HASH_LEN) {
+    const expected = versionsToEnrValue(expectedVersions, true);
+    if (!Buffer.from(enrValue).equals(expected)) {
+      throw new Error(`Expected ENR version ${expected.toString('hex')} but received ${enrValue.toString('hex')}`);
+    }
+  } else {
+    const actual = Buffer.from(enrValue).toString();
+    checkCompressedComponentVersion(actual, expectedVersions);
+  }
+}
+
+function versionsToEnrValue(versions: ComponentsVersions, useXxHash: boolean) {
+  const compressed = compressComponentVersions(versions);
+  return useXxHash ? toBufferBE(xxhash.h64(compressed), XX_HASH_LEN) : Buffer.from(compressed);
+}