@aztec/p2p 0.0.0-test.0

package/src/testbench/p2p_client_testbench_worker.ts

@@ -0,0 +1,152 @@
+/**
+ * A testbench worker that creates a p2p client and listens for commands from the parent.
+ *
+ * Used when running testbench commands
+ */
+import { MockL2BlockSource } from '@aztec/archiver/test';
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { P2PClientType } from '@aztec/stdlib/p2p';
+import { Tx, TxStatus } from '@aztec/stdlib/tx';
+
+import type { Message, PeerId } from '@libp2p/interface';
+
+import type { P2PConfig } from '../config.js';
+import { createP2PClient } from '../index.js';
+import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
+import type { TxPool } from '../mem_pools/tx_pool/index.js';
+import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
+
+// Simple mock implementation
+function mockTxPool(): TxPool {
+  // Mock all methods
+  return {
+    addTxs: () => Promise.resolve(),
+    getTxByHash: () => Promise.resolve(undefined),
+    getArchivedTxByHash: () => Promise.resolve(undefined),
+    markAsMined: () => Promise.resolve(),
+    markMinedAsPending: () => Promise.resolve(),
+    deleteTxs: () => Promise.resolve(),
+    getAllTxs: () => Promise.resolve([]),
+    getAllTxHashes: () => Promise.resolve([]),
+    getPendingTxHashes: () => Promise.resolve([]),
+    getMinedTxHashes: () => Promise.resolve([]),
+    getTxStatus: () => Promise.resolve(TxStatus.PENDING),
+  };
+}
+
+function mockAttestationPool(): AttestationPool {
+  return {
+    addAttestations: () => Promise.resolve(),
+    deleteAttestations: () => Promise.resolve(),
+    deleteAttestationsOlderThan: () => Promise.resolve(),
+    deleteAttestationsForSlot: () => Promise.resolve(),
+    deleteAttestationsForSlotAndProposal: () => Promise.resolve(),
+    getAttestationsForSlot: () => Promise.resolve([]),
+  };
+}
+
+function mockEpochCache(): EpochCacheInterface {
+  return {
+    getCommittee: () => Promise.resolve([] as EthAddress[]),
+    getProposerIndexEncoding: () => '0x' as `0x${string}`,
+    getEpochAndSlotNow: () => ({ epoch: 0n, slot: 0n, ts: 0n }),
+    computeProposerIndex: () => 0n,
+    getProposerInCurrentOrNextSlot: () =>
+      Promise.resolve({
+        currentProposer: EthAddress.ZERO,
+        nextProposer: EthAddress.ZERO,
+        currentSlot: 0n,
+        nextSlot: 0n,
+      }),
+    isInCommittee: () => Promise.resolve(false),
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/no-misused-promises
+process.on('message', async msg => {
+  const { type, config, clientIndex } = msg as { type: string; config: P2PConfig; clientIndex: number };
+
+  try {
+    if (type === 'START') {
+      const txPool = mockTxPool();
+      const attestationPool = mockAttestationPool();
+      const epochCache = mockEpochCache();
+      const worldState = {} as WorldStateSynchronizer;
+      const l2BlockSource = new MockL2BlockSource();
+      await l2BlockSource.createBlocks(100);
+
+      const proofVerifier = new AlwaysTrueCircuitVerifier();
+      const kvStore = await openTmpStore(`test-${clientIndex}`);
+      const logger = createLogger(`p2p:${clientIndex}`);
+
+      const deps = {
+        txPool,
+        attestationPool,
+        store: kvStore,
+        logger,
+      };
+
+      const client = await createP2PClient(
+        P2PClientType.Full,
+        config as P2PConfig & DataStoreConfig,
+        l2BlockSource,
+        proofVerifier,
+        worldState,
+        epochCache,
+        undefined,
+        deps,
+      );
+
+      // Create spy for gossip messages
+      let gossipMessageCount = 0;
+      (client as any).p2pService.handleNewGossipMessage = (msg: Message, msgId: string, source: PeerId) => {
+        gossipMessageCount++;
+        process.send!({
+          type: 'GOSSIP_RECEIVED',
+          count: gossipMessageCount,
+        });
+        return (client as any).p2pService.constructor.prototype.handleNewGossipMessage.apply(
+          (client as any).p2pService,
+          [msg, msgId, source],
+        );
+      };
+
+      await client.start();
+      // Wait until the client is ready
+      for (let i = 0; i < 100; i++) {
+        const isReady = client.isReady();
+        logger.debug(`Client ${clientIndex} isReady: ${isReady}`);
+        if (isReady) {
+          break;
+        }
+        await sleep(1000);
+      }
+
+      // Listen for commands from parent
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      process.on('message', async (cmd: any) => {
+        switch (cmd.type) {
+          case 'STOP':
+            await client.stop();
+            process.exit(0);
+            break;
+          case 'SEND_TX':
+            await client.sendTx(Tx.fromBuffer(Buffer.from(cmd.tx)));
+            process.send!({ type: 'TX_SENT' });
+            break;
+        }
+      });
+
+      process.send!({ type: 'READY' });
+    }
+  } catch (err: any) {
+    process.send!({ type: 'ERROR', error: err.message });
+    process.exit(1);
+  }
+});

package/src/testbench/parse_log_file.ts

@@ -0,0 +1,175 @@
+// Parse Log File
+// 1. Determine when a message was sent from the Sent Message log
+// 2. Parse all Received Tx logs, extracting the timestamp and peer ID
+// 3. Compute the delay for each peer relative to the timestamp of the sent message
+// 4. Print the delays
+import { createLogger } from '@aztec/foundation/log';
+
+import * as fs from 'fs';
+
+const logger = createLogger('parse_log_file');
+
+interface LogEvent {
+  timestamp: number; // in milliseconds (from start of log)
+  peerId: string;
+}
+
+interface BenchmarkResult {
+  delays: {
+    peerId: string;
+    delay: number;
+  }[];
+  stats: {
+    numberReceived: number;
+    minDelay: number;
+    maxDelay: number;
+    averageDelay: number;
+    medianDelay: number;
+  };
+}
+
+function getTimestamp(line: string): number | null {
+  const timestampMatch = line.match(/"time":(\d+)/);
+  if (!timestampMatch) {
+    return null;
+  }
+  return parseInt(timestampMatch[1], 10);
+}
+
+/**
+ * Parses a single log line. If the line contains an "rpc.from" event,
+ * it extracts the timestamp and the peer ID.
+ */
+function parseReceivedTx(line: string): LogEvent | null {
+  if (!line.includes('Received tx')) {
+    return null;
+  }
+
+  // Extract timestamp from the line: e.g. {"time":1740142435845}
+  const timestamp = getTimestamp(line);
+  if (!timestamp) {
+    logger.error('No timestamp found in received tx log');
+    return null;
+  }
+
+  // TODO: this is not correct - it is just the tx hash for now
+  // Extract the peer ID after "Received tx"
+  const peerIdMatch = line.match(/p2p:(\d+):/);
+  if (!peerIdMatch) {
+    logger.error('No peer Number found in received tx log');
+    return null;
+  }
+  const peerId = peerIdMatch[1];
+
+  return {
+    timestamp,
+    peerId,
+  };
+}
+
+function parseSentMessage(line: string): number | null {
+  if (!line.includes('Sent message')) {
+    return null;
+  }
+
+  const timestamp = getTimestamp(line);
+  if (!timestamp) {
+    logger.error('No timestamp found in sent message log');
+    return null;
+  }
+
+  return timestamp;
+}
+
+/**
+ * Processes the given log file, extracts all rpc.from events, computes the
+ * propagation delay for each peer relative to the earliest event, and prints
+ * some benchmark statistics.
+ */
+function processLogFile(logFilePath: string, outputJsonPath?: string) {
+  const content = fs.readFileSync(logFilePath, 'utf-8');
+  const lines = content.split('\n');
+  const events: LogEvent[] = [];
+  let t0 = 0;
+
+  // We begin our search as soon as we see the Sent message log
+  let messageSent = false;
+  for (const line of lines) {
+    // Look for Sent message log
+    if (line.includes('Sent message')) {
+      messageSent = true;
+      t0 = parseSentMessage(line)!;
+    }
+
+    if (!messageSent) {
+      continue;
+    }
+    // Once we see the sent message log, we begin parsing Received tx logs
+    const event = parseReceivedTx(line);
+    if (event) {
+      events.push(event);
+    }
+  }
+
+  if (events.length === 0) {
+    logger.error('No message received events found in log file.');
+    return;
+  }
+
+  // Sort events by timestamp (ascending)
+  events.sort((a, b) => a.timestamp - b.timestamp);
+
+  // Compute delay for each event relative to t0
+  const numberReceived = events.length;
+  const delays = events.map(e => ({
+    peerId: e.peerId,
+    delay: e.timestamp - t0,
+  }));
+
+  logger.info('Propagation delays (in ms) per peer:');
+  for (const d of delays) {
+    logger.info(`${d.peerId}: ${d.delay} ms`);
+  }
+
+  // Compute basic statistics
+  const delayValues = delays.map(d => d.delay);
+  const minDelay = Math.min(...delayValues);
+  const maxDelay = Math.max(...delayValues);
+  const sumDelay = delayValues.reduce((sum, val) => sum + val, 0);
+  const avgDelay = sumDelay / delayValues.length;
+  const sortedDelays = delayValues.slice().sort((a, b) => a - b);
+  const medianDelay = sortedDelays[Math.floor(sortedDelays.length / 2)];
+
+  logger.info('\nBenchmark Statistics:');
+  logger.info(`Number of messages received: ${numberReceived}`);
+  logger.info(`Min delay: ${minDelay} ms`);
+  logger.info(`Max delay: ${maxDelay} ms`);
+  logger.info(`Average delay: ${avgDelay.toFixed(2)} ms`);
+  logger.info(`Median delay: ${medianDelay} ms`);
+
+  // If output JSON path is provided, write results to file
+  if (outputJsonPath) {
+    const result: BenchmarkResult = {
+      delays,
+      stats: {
+        numberReceived,
+        minDelay,
+        maxDelay,
+        averageDelay: Number(avgDelay.toFixed(2)),
+        medianDelay,
+      },
+    };
+
+    fs.writeFileSync(outputJsonPath, JSON.stringify(result, null, 2));
+    logger.info(`\nResults written to ${outputJsonPath}`);
+  }
+}
+
+// Get the log file path and optional output JSON path from command-line arguments
+const [logFilePath, outputJsonPath] = process.argv.slice(2);
+if (!logFilePath) {
+  logger.error('Usage: ts-node parse_log_file.ts <logFilePath> [outputJsonPath]');
+  process.exit(1);
+}
+
+processLogFile(logFilePath, outputJsonPath);

package/src/testbench/testbench.ts

@@ -0,0 +1,66 @@
+import { createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { mockTx } from '@aztec/stdlib/testing';
+
+import assert from 'assert';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { WorkerClientManager, testChainConfig } from './worker_client_manager.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const logger = createLogger('testbench');
+
+async function main() {
+  try {
+    // Read configuration file name from command line args
+    const configFile = process.argv[2];
+    if (!configFile) {
+      throw new Error('Configuration file must be provided as first argument');
+    }
+
+    const configPath = path.join(__dirname, '../../testbench/configurations', configFile);
+    const config = await import(configPath, { assert: { type: 'json' } });
+    const testConfig = { ...testChainConfig, ...config.default };
+    const numberOfClients = config.default.numberOfClients;
+
+    // Setup clients in separate processes
+    const workerClientManager = new WorkerClientManager(logger, testConfig);
+    await workerClientManager.makeWorkerClients(numberOfClients);
+
+    // wait a bit longer for all peers to be ready
+    await sleep(5000);
+    logger.info('Workers Ready');
+
+    // Send tx from client 0
+    const tx = await mockTx(1, {
+      clientIvcProof: ClientIvcProof.random(),
+    });
+
+    workerClientManager.processes[0].send({ type: 'SEND_TX', tx: tx.toBuffer() });
+    logger.info('Transaction sent from client 0');
+
+    // Give time for message propagation
+    await sleep(30000);
+    logger.info('Checking message propagation results');
+
+    // Check message propagation results
+    const numberOfClientsThatReceivedMessage = workerClientManager.numberOfClientsThatReceivedMessage();
+    logger.info(`Number of clients that received message: ${numberOfClientsThatReceivedMessage}`);
+
+    assert(numberOfClientsThatReceivedMessage === numberOfClients - 1);
+
+    logger.info('Test passed, cleaning up');
+
+    // cleanup
+    await workerClientManager.cleanup();
+  } catch (error) {
+    logger.error('Test failed with error:', error);
+    process.exit(1);
+  }
+}
+
+main().catch(error => {
+  logger.error('Unhandled error:', error);
+});