@aztec-labs/p2p 6.0.0-nightly.20260829

package/dest/testbench/p2p_client_testbench_worker.js

@@ -0,0 +1,364 @@
+/**
+ * A testbench worker that creates a p2p client and listens for commands from the parent.
+ *
+ * Used when running testbench commands.
+ */ import { MockL2BlockSource } from '@aztec-labs/archiver/test';
+import { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import { SecretValue } from '@aztec-labs/foundation/config';
+import { Secp256k1Signer } from '@aztec-labs/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { sleep } from '@aztec-labs/foundation/sleep';
+import { DateProvider, Timer } from '@aztec-labs/foundation/timer';
+import { openTmpStore } from '@aztec-labs/kv-store/lmdb-v2';
+import { getVKTreeRoot } from '@aztec-labs/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec-labs/protocol-contracts';
+import { EmptyL1RollupConstants } from '@aztec-labs/stdlib/epoch-helpers';
+import { GasFees } from '@aztec-labs/stdlib/gas';
+import { P2PMessage } from '@aztec-labs/stdlib/p2p';
+import { ChonkProof } from '@aztec-labs/stdlib/proofs';
+import { makeAztecAddress, makeBlockHeader, makeBlockProposal, mockTx } from '@aztec-labs/stdlib/testing';
+import { Tx } from '@aztec-labs/stdlib/tx';
+import { getTelemetryClient } from '@aztec-labs/telemetry-client';
+import { TopicValidatorResult } from '@libp2p/interface';
+import { peerIdFromString } from '@libp2p/peer-id';
+import { createP2PClient } from '../index.js';
+import { LibP2PService } from '../services/index.js';
+import { BatchTxRequester } from '../services/reqresp/batch-tx-requester/batch_tx_requester.js';
+import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.js';
+import { RequestTracker } from '../services/tx_collection/request_tracker.js';
+import { AlwaysTrueCircuitVerifier } from '../test-helpers/index.js';
+import { BENCHMARK_CONSTANTS, InMemoryAttestationPool, InMemoryTxPool, UNLIMITED_RATE_LIMIT_QUOTA, createMockEpochCache, createMockWorldStateSynchronizer, filterTxsByDistribution } from '../test-helpers/index.js';
+const txCache = new Map();
+const BENCH_L1_CONSTANTS = {
+    ...EmptyL1RollupConstants,
+    slotDuration: 12,
+    ethereumSlotDuration: 4
+};
+class TestbenchL2BlockSource extends MockL2BlockSource {
+    getL1Constants() {
+        return Promise.resolve(BENCH_L1_CONSTANTS);
+    }
+}
+function createBenchmarkEpochCache() {
+    return {
+        ...createMockEpochCache(),
+        getL1Constants: ()=>BENCH_L1_CONSTANTS
+    };
+}
+class TestLibP2PService extends LibP2PService {
+    disableTxValidation;
+    gossipMessageCount = 0;
+    constructor(config, node, peerDiscoveryService, reqresp, peerManager, mempools, archiver, epochCache, proofVerifier, worldStateSynchronizer, telemetry, logger = createLogger('p2p:test:libp2p_service'), disableTxValidation = true){
+        super(config, node, peerDiscoveryService, reqresp, peerManager, mempools, archiver, epochCache, proofVerifier, worldStateSynchronizer, {
+            getCurrentMinFees: ()=>Promise.resolve(GasFees.empty())
+        }, telemetry, logger);
+        this.disableTxValidation = disableTxValidation;
+    }
+    getGossipMessageCount() {
+        return this.gossipMessageCount;
+    }
+    setDisableTxValidation(disable) {
+        this.disableTxValidation = disable;
+    }
+    async handleGossipedTx(payload, msgId, source) {
+        if (this.disableTxValidation) {
+            const p2pMessage = P2PMessage.fromMessageData(payload);
+            const tx = Tx.fromBuffer(p2pMessage.payload);
+            this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), TopicValidatorResult.Accept);
+            const txHash = tx.getTxHash();
+            const txHashString = txHash.toString();
+            this.logger.verbose(`Received tx ${txHashString} from external peer ${source.toString()}.`);
+            await this.mempools.txPool.addPendingTxs([
+                tx
+            ]);
+        } else {
+            await super.handleGossipedTx(payload, msgId, source);
+        }
+    }
+    async handleNewGossipMessage(msg, msgId, source) {
+        this.gossipMessageCount++;
+        process.send({
+            type: 'GOSSIP_RECEIVED',
+            count: this.gossipMessageCount
+        });
+        await super.handleNewGossipMessage(msg, msgId, source);
+    }
+}
+async function generateDeterministicTxs(txCount, seed, config) {
+    const cached = txCache.get(seed) ?? [];
+    if (cached.length >= txCount) {
+        return cached.slice(0, txCount);
+    }
+    const expirationTimestampBase = BigInt(seed);
+    for(let i = cached.length; i < txCount; i++){
+        const txSeed = seed * 10000 + i;
+        const tx = await mockTx(txSeed, {
+            chainId: new Fr(config.l1ChainId),
+            version: new Fr(config.rollupVersion),
+            vkTreeRoot: getVKTreeRoot(),
+            protocolContractsHash,
+            feePayer: makeAztecAddress(txSeed + 1),
+            chonkProof: ChonkProof.empty(),
+            numberOfNonRevertiblePublicCallRequests: 0,
+            numberOfRevertiblePublicCallRequests: 0,
+            numberOfRevertibleNullifiers: 0,
+            hasPublicTeardownCallRequest: false,
+            publicCalldataSize: 0
+        });
+        tx.data.expirationTimestamp = expirationTimestampBase + BigInt(i);
+        await tx.recomputeHash();
+        cached.push(tx);
+    }
+    txCache.set(seed, cached);
+    return cached.slice(0, txCount);
+}
+async function createBlockProposal(blockNumber, txHashes, seed) {
+    const archiveRoot = new Fr(BigInt(seed) * 1000000n + BigInt(blockNumber));
+    return await makeBlockProposal({
+        signer: Secp256k1Signer.random(),
+        blockHeader: makeBlockHeader(1, {
+            blockNumber: BlockNumber(blockNumber)
+        }),
+        archiveRoot,
+        txHashes
+    });
+}
+function installUnlimitedRateLimits(client) {
+    const reqResp = client.p2pService.reqresp;
+    const rateLimiter = reqResp.rateLimiter;
+    rateLimiter.getRateLimits = ()=>UNLIMITED_RATE_LIMIT_QUOTA;
+    rateLimiter.allow = ()=>RateLimitStatus.Allowed;
+}
+/** Resets peer scores to prevent cross-case contamination in benchmarks. */ function resetPeerScores(client) {
+    const peerManager = client.p2pService.peerManager;
+    const peerScoring = peerManager?.peerScoring;
+    if (peerScoring?.resetAllScores) {
+        peerScoring.resetAllScores();
+    }
+}
+/** Returns the number of connected peers for connectivity checks. */ function getConnectedPeerCount(client) {
+    const p2pService = client.p2pService;
+    const connectionSampler = p2pService?.reqresp?.getConnectionSampler?.();
+    if (connectionSampler?.getPeerListSortedByConnectionCountAsc) {
+        return connectionSampler.getPeerListSortedByConnectionCountAsc().length;
+    }
+    return 0;
+}
+async function runAggregatorBenchmark(client, blockProposal, timeoutMs, pinnedPeerId, pinnedPeerIndex, logger, expectedPeerCount) {
+    let timer = new Timer();
+    try {
+        installUnlimitedRateLimits(client);
+        const txHashes = blockProposal.txHashes;
+        logger.info(`[BENCH] Using block proposal with archive ${blockProposal.archive.toString().slice(0, 10)}...`);
+        const p2pService = client.p2pService;
+        const batchTxRequesterService = p2pService.getBatchTxRequesterService();
+        const minPeersRequired = Math.max(1, expectedPeerCount - 1);
+        const maxWaitMs = BENCHMARK_CONSTANTS.MAX_PEER_WAIT_MS;
+        const waitInterval = BENCHMARK_CONSTANTS.PEER_CHECK_INTERVAL_MS;
+        let waited = 0;
+        while(waited < maxWaitMs){
+            const connectedPeers = batchTxRequesterService.connectionSampler.getPeerListSortedByConnectionCountAsc();
+            if (connectedPeers.length >= minPeersRequired) {
+                logger.info(`[BENCH] Aggregator has ${connectedPeers.length} connected peers, starting benchmark`);
+                break;
+            }
+            logger.debug(`[BENCH] Waiting for peers: ${connectedPeers.length}/${minPeersRequired} (waited ${waited}ms)`);
+            await sleep(waitInterval);
+            waited += waitInterval;
+        }
+        const connectedPeers = batchTxRequesterService.connectionSampler.getPeerListSortedByConnectionCountAsc();
+        logger.info(`[BENCH] Aggregator has ${connectedPeers.length} connected peers`);
+        logger.info(`[BENCH] Requesting ${txHashes.length} tx hashes: ${txHashes.slice(0, 3).map((h)=>h.toString()).join(', ')}...`);
+        let pinnedPeer;
+        if (pinnedPeerId) {
+            pinnedPeer = peerIdFromString(pinnedPeerId);
+        } else if (pinnedPeerIndex !== undefined) {
+            if (pinnedPeerIndex > 0 && pinnedPeerIndex <= connectedPeers.length) {
+                pinnedPeer = connectedPeers[pinnedPeerIndex - 1];
+            }
+        }
+        const noopTxValidator = {
+            validateTx: (_tx)=>Promise.resolve({
+                    result: 'valid'
+                })
+        };
+        timer = new Timer();
+        const tracker = RequestTracker.create(txHashes, new Date(Date.now() + timeoutMs));
+        const batchRequester = new BatchTxRequester(tracker, blockProposal, pinnedPeer, batchTxRequesterService, logger, new DateProvider(), {
+            txValidator: noopTxValidator
+        });
+        const fetchedTxs = await BatchTxRequester.collectAllTxs(batchRequester.run());
+        const durationMs = timer.ms();
+        return {
+            type: 'BENCH_RESULT',
+            durationMs,
+            fetchedCount: fetchedTxs.length,
+            success: fetchedTxs.length === txHashes.length
+        };
+    } catch (err) {
+        return {
+            type: 'BENCH_RESULT',
+            durationMs: timer.ms(),
+            fetchedCount: 0,
+            success: false,
+            error: err?.message ?? String(err)
+        };
+    }
+}
+let workerClient = null;
+let workerTxPool = null;
+let workerAttestationPool = null;
+let workerConfig = null;
+let workerLogger = null;
+let kvStore = null;
+async function stopWorker() {
+    try {
+        if (workerClient) {
+            await workerClient.stop();
+            workerClient = null;
+        }
+    } catch (e) {
+        workerLogger?.error('Error stopping worker client', e);
+    }
+    try {
+        if (kvStore?.close) {
+            await kvStore.close();
+            kvStore = null;
+        }
+    } catch (e) {
+        workerLogger?.error('Error closing kv store', e);
+    }
+}
+function gracefulExit(code = 0) {
+    try {
+        if (process.connected) {
+            process.disconnect();
+        }
+    } catch  {
+    // IPC channel already closed
+    }
+    // Safety fallback if lingering handles prevent the event loop from draining
+    setTimeout(()=>process.exit(code), 5000).unref();
+}
+// eslint-disable-next-line @typescript-eslint/no-misused-promises
+process.on('message', async (msg)=>{
+    const { type, config: rawConfig, clientIndex } = msg;
+    try {
+        if (type === 'START') {
+            const config = {
+                ...rawConfig,
+                peerIdPrivateKey: rawConfig.peerIdPrivateKey ? new SecretValue(rawConfig.peerIdPrivateKey) : undefined,
+                priceBumpPercentage: 10n
+            };
+            workerConfig = config;
+            workerTxPool = new InMemoryTxPool();
+            workerAttestationPool = new InMemoryAttestationPool();
+            const epochCache = createBenchmarkEpochCache();
+            const worldState = createMockWorldStateSynchronizer();
+            const l2BlockSource = new TestbenchL2BlockSource();
+            const proofVerifier = new AlwaysTrueCircuitVerifier();
+            kvStore = await openTmpStore(`test-${clientIndex}`, true, BENCHMARK_CONSTANTS.KV_STORE_MAP_SIZE_KB);
+            workerLogger = createLogger(`p2p:${clientIndex}`);
+            workerTxPool.setLogger(workerLogger);
+            const telemetry = getTelemetryClient();
+            const deps = {
+                txPool: workerTxPool,
+                attestationPool: workerAttestationPool,
+                store: kvStore,
+                logger: workerLogger
+            };
+            const client = await createP2PClient(config, l2BlockSource, proofVerifier, worldState, epochCache, {
+                getCurrentMinFees: ()=>Promise.resolve(GasFees.empty())
+            }, 'test-p2p-bench-worker', undefined, telemetry, deps, await l2BlockSource.getInitialHeader().hash());
+            const testService = new TestLibP2PService(config, client.p2pService.node, client.p2pService.peerDiscoveryService, client.p2pService.reqresp, client.p2pService.peerManager, client.p2pService.mempools, client.p2pService.archiver, epochCache, proofVerifier, worldState, telemetry, workerLogger, true);
+            client.p2pService = testService;
+            await client.start();
+            for(let i = 0; i < 100; i++){
+                const isReady = client.isReady();
+                workerLogger.debug(`Client ${clientIndex} isReady: ${isReady}`);
+                if (isReady) {
+                    break;
+                }
+                await sleep(1000);
+            }
+            workerClient = client;
+            const peerId = client.p2pService.node.peerId.toString();
+            process.send({
+                type: 'READY',
+                peerId
+            });
+            return;
+        }
+        const cmd = msg;
+        switch(cmd.type){
+            case 'STOP':
+                await stopWorker();
+                gracefulExit(0);
+                break;
+            case 'SEND_TX':
+                if (workerClient) {
+                    await workerClient.sendTx(Tx.fromBuffer(Buffer.from(cmd.tx)));
+                    process.send({
+                        type: 'TX_SENT'
+                    });
+                }
+                break;
+            case 'GET_PEER_COUNT':
+                process.send({
+                    type: 'PEER_COUNT',
+                    count: workerClient ? getConnectedPeerCount(workerClient) : 0
+                });
+                break;
+            case 'BENCH_REQRESP':
+                {
+                    const benchCmd = cmd;
+                    if (!workerClient || !workerTxPool || !workerAttestationPool || !workerConfig || !workerLogger) {
+                        process.send({
+                            type: 'BENCH_RESULT',
+                            durationMs: 0,
+                            fetchedCount: 0,
+                            success: false,
+                            error: 'Worker not initialized'
+                        });
+                        break;
+                    }
+                    // Reset state before each benchmark run to avoid cross-run contamination
+                    workerTxPool.resetState();
+                    workerAttestationPool.resetState();
+                    resetPeerScores(workerClient);
+                    installUnlimitedRateLimits(workerClient);
+                    const allTxs = await generateDeterministicTxs(benchCmd.txCount, benchCmd.seed, workerConfig);
+                    const txHashes = allTxs.map((tx)=>tx.getTxHash());
+                    const blockProposal = await createBlockProposal(benchCmd.blockNumber, txHashes, benchCmd.seed);
+                    await workerAttestationPool.tryAddBlockProposal(blockProposal);
+                    workerLogger.debug(`[BENCH] Added block proposal with archive ${blockProposal.archive.toString().slice(0, 10)}...`);
+                    if (benchCmd.isAggregator) {
+                        workerTxPool.clearTxs();
+                        workerLogger.info(`[BENCH] Aggregator starting benchmark: txCount=${benchCmd.txCount}, distribution=${benchCmd.distribution}`);
+                        const result = await runAggregatorBenchmark(workerClient, blockProposal, benchCmd.timeoutMs, benchCmd.pinnedPeerId, benchCmd.pinnedPeerIndex, workerLogger, benchCmd.peerCount);
+                        process.send(result);
+                    } else {
+                        const myTxs = filterTxsByDistribution(allTxs, benchCmd.peerIndex, benchCmd.peerCount, benchCmd.distribution, benchCmd.pinnedPeerIndex);
+                        workerTxPool.setTxs(myTxs);
+                        workerLogger.info(`[BENCH] Peer ${benchCmd.peerIndex} populated tx pool with ${myTxs.length}/${benchCmd.txCount} txs (${benchCmd.distribution})`);
+                        process.send({
+                            type: 'BENCH_READY'
+                        });
+                    }
+                    break;
+                }
+        }
+    } catch (err) {
+        try {
+            process.send({
+                type: 'ERROR',
+                error: err.message
+            });
+        } catch  {
+        // IPC channel may be closed
+        }
+        await stopWorker();
+        gracefulExit(1);
+    }
+});

package/dest/testbench/parse_log_file.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2VfbG9nX2ZpbGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0YmVuY2gvcGFyc2VfbG9nX2ZpbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dest/testbench/parse_log_file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse_log_file.d.ts","sourceRoot":"","sources":["../../src/testbench/parse_log_file.ts"],"names":[],"mappings":""}

package/dest/testbench/parse_log_file.js

@@ -0,0 +1,131 @@
+// 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-labs/foundation/log';
+import * as fs from 'fs';
+const logger = createLogger('parse_log_file');
+function getTimestamp(line) {
+    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 "Received tx" event,
+ * it extracts the timestamp and the peer ID.
+ */ function parseReceivedTx(line) {
+    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;
+    }
+    // Extract the peer ID from the log line
+    // Example format: "module":"p2p:1","msg":"Received tx 0x0feeafa65f25fd8d613fe4aca44fd65fe41c149ef1941e2019d40925c40748f9 from external peer 16Uiu2HAm8w4oxXF3TwDKoGL9U66thMXWqCgPnb2CgkYwmUqFCWbC."
+    const peerIdMatch = line.match(/"module":"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) {
+    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, outputJsonPath) {
+    const content = fs.readFileSync(logFilePath, 'utf-8');
+    const lines = content.split('\n');
+    const events = [];
+    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 = {
+            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/dest/testbench/testbench.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdGJlbmNoLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGJlbmNoL3Rlc3RiZW5jaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dest/testbench/testbench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testbench.d.ts","sourceRoot":"","sources":["../../src/testbench/testbench.ts"],"names":[],"mappings":""}

package/dest/testbench/testbench.js

@@ -0,0 +1,62 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { sleep } from '@aztec-labs/foundation/sleep';
+import { ChonkProof } from '@aztec-labs/stdlib/proofs';
+import { mockTx } from '@aztec-labs/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');
+        }
+        // @dependency ../../testbench/configurations/*.json
+        const configPath = path.join(__dirname, '../../testbench/configurations', configFile);
+        const config = await import(configPath, {
+            with: {
+                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, {
+            chonkProof: ChonkProof.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(10000);
+        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);
+});

package/dest/testbench/worker_client_manager.d.ts

@@ -0,0 +1,102 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import type { ChainConfig } from '@aztec-labs/stdlib/config';
+import { type ChildProcess } from 'child_process';
+import { type P2PConfig } from '../config.js';
+import type { DistributionPattern } from './p2p_client_testbench_worker.js';
+declare const testChainConfig: ChainConfig;
+export interface ReqRespBenchmarkConfig {
+    txCount: number;
+    distribution: DistributionPattern;
+    timeoutMs: number;
+    pinnedPeerIndex?: number;
+    blockNumber?: number;
+    seed?: number;
+}
+export interface ReqRespBenchmarkResult {
+    txCount: number;
+    distribution: DistributionPattern;
+    durationMs: number;
+    fetchedCount: number;
+    success: boolean;
+    error?: string;
+}
+declare class WorkerClientManager {
+    processes: ChildProcess[];
+    peerIdPrivateKeys: string[];
+    peerEnrs: string[];
+    ports: number[];
+    peerIds: string[];
+    private p2pConfig;
+    private logger;
+    private messageReceivedByClient;
+    constructor(logger: Logger, p2pConfig: Partial<P2PConfig>);
+    destroy(): void;
+    /**
+     * Creates a client configuration object for IPC.
+     * Note: We send the raw peerIdPrivateKey string instead of SecretValue
+     * because SecretValue.toJSON() returns '[Redacted]', losing the value.
+     * The worker must re-wrap it in SecretValue.
+     * We also omit priceBumpPercentage since it's a bigint and can't be
+     * serialized over IPC (which uses JSON under the hood).
+     */
+    private createClientConfig;
+    /**
+     * Spawns a worker process and returns a promise that resolves when the worker is ready.
+     * Config uses raw string for peerIdPrivateKey (not SecretValue) for IPC serialization.
+     */
+    private spawnWorkerProcess;
+    /**
+     * Creates a number of worker clients in separate processes.
+     * All are configured to connect to each other and overridden with the test-specific config.
+     *
+     * @param numberOfClients - The number of clients to create
+     * @param options - Optional overrides for seeding/bootstrapping strategy
+     * @returns The ENRs of the created clients
+     */
+    makeWorkerClients(numberOfClients: number, options?: {
+        bootstrapMode?: 'subset' | 'all';
+        seedPeerLimit?: number;
+        batchSize?: number;
+        batchDelayMs?: number;
+    }): Promise<string[]>;
+    purgeMessageReceivedByClient(): void;
+    numberOfClientsThatReceivedMessage(): number;
+    /**
+     * 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
+     */
+    changePort(clientIndex: number, newPort: number): Promise<void>;
+    /**
+     * Terminate a single process with timeout and force kill if needed
+     */
+    private terminateProcess;
+    /**
+     * Cleans up all worker processes with timeout and force kill if needed
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Checks that the aggregator (client 0) has sufficient peer connections before running a benchmark.
+     * This prevents benchmark cases from starting with degraded connectivity after a previous case
+     * caused connection failures.
+     */
+    waitForConnectivity(minPeers: number, timeoutMs?: number): Promise<number>;
+    private getPeerCount;
+    /**
+     * Run a req/resp benchmark across all worker clients.
+     *
+     * This sends a BENCH_REQRESP command to all workers:
+     * - Aggregator (client 0) runs the collector and returns timing results
+     * - Responders (clients 1..N) populate their tx pools based on distribution
+     *
+     * All workers generate the same txs deterministically from a shared seed,
+     * then filter based on their peerIndex and distribution pattern.
+     */
+    runReqRespBenchmark(config: ReqRespBenchmarkConfig): Promise<ReqRespBenchmarkResult>;
+    private waitForBenchReady;
+    private waitForBenchResult;
+}
+export { WorkerClientManager, testChainConfig };
+export type { DistributionPattern } from './p2p_client_testbench_worker.js';
+//# sourceMappingURL=data:application/json;base64,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