@aztec/p2p 0.77.0-testnet-ignition.29 → 0.77.0

package/dest/client/factory.js

@@ -14,8 +14,8 @@ export const createP2PClient = async (clientType, _config, l2BlockSource, proofV
         ..._config
     };
     const logger = deps.logger ?? createLogger('p2p');
-    const store = deps.store ?? await createStore('p2p', config, createLogger('p2p:lmdb-v2'));
-    const archive = await createStore('p2p-archive', config, createLogger('p2p-archive:lmdb-v2'));
+    const store = deps.store ?? await createStore('p2p', 1, config, createLogger('p2p:lmdb-v2'));
+    const archive = await createStore('p2p-archive', 1, config, createLogger('p2p-archive:lmdb-v2'));
     const mempools = {
         txPool: deps.txPool ?? new AztecKVTxPool(store, archive, telemetry, config.archivedTxLimit),
         attestationPool: clientType === P2PClientType.Full ? deps.attestationPool ?? new InMemoryAttestationPool(telemetry) : undefined

package/dest/testbench/testbench.js

@@ -1,98 +1,13 @@
-import { EthAddress } from '@aztec/foundation/eth-address';
 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 { fork } from 'child_process';
+import assert from 'assert';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { getP2PDefaultConfig } from '../config.js';
-import { generatePeerIdPrivateKeys } from '../test-helpers/generate-peer-id-private-keys.js';
-import { getPorts } from '../test-helpers/get-ports.js';
-import { makeEnrs } from '../test-helpers/make-enrs.js';
+import { WorkerClientManager, testChainConfig } from './worker_client_manager.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const workerPath = path.join(__dirname, '../../dest/testbench/p2p_client_testbench_worker.js');
 const logger = createLogger('testbench');
-let processes = [];
-const testChainConfig = {
-    l1ChainId: 31337,
-    version: 1,
-    l1Contracts: {
-        rollupAddress: EthAddress.random()
-    }
-};
-/**
- * Cleanup function to kill all child processes
- */ async function cleanup() {
-    logger.info('Cleaning up processes...');
-    await Promise.all(processes.map((proc)=>new Promise((resolve)=>{
-            proc.once('exit', ()=>resolve());
-            proc.send({
-                type: 'STOP'
-            });
-        })));
-    process.exit(0);
-}
-// Handle cleanup on process termination
-process.on('SIGINT', ()=>void cleanup());
-process.on('SIGTERM', ()=>void cleanup());
-/**
- * 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
- * @param p2pConfig - The P2P config to use for the clients
- * @returns The ENRs of the created clients
- */ async function makeWorkerClients(numberOfClients, p2pConfig) {
-    const peerIdPrivateKeys = generatePeerIdPrivateKeys(numberOfClients);
-    const ports = await getPorts(numberOfClients);
-    const peerEnrs = await makeEnrs(peerIdPrivateKeys, ports, testChainConfig);
-    processes = [];
-    const readySignals = [];
-    for(let i = 0; i < numberOfClients; i++){
-        logger.info(`Creating client ${i}`);
-        const addr = `127.0.0.1:${ports[i]}`;
-        const listenAddr = `0.0.0.0:${ports[i]}`;
-        // Maximum seed with 10 other peers to allow peer discovery to connect them at a smoother rate
-        const otherNodes = peerEnrs.filter((_, ind)=>ind < Math.min(i, 10));
-        const config = {
-            ...getP2PDefaultConfig(),
-            p2pEnabled: true,
-            peerIdPrivateKey: peerIdPrivateKeys[i],
-            tcpListenAddress: listenAddr,
-            udpListenAddress: listenAddr,
-            tcpAnnounceAddress: addr,
-            udpAnnounceAddress: addr,
-            bootstrapNodes: [
-                ...otherNodes
-            ],
-            ...p2pConfig
-        };
-        const childProcess = fork(workerPath);
-        childProcess.send({
-            type: 'START',
-            config,
-            clientIndex: i
-        });
-        // Wait for ready signal
-        readySignals.push(new Promise((resolve, reject)=>{
-            childProcess.once('message', (msg)=>{
-                if (msg.type === 'READY') {
-                    resolve(undefined);
-                }
-                if (msg.type === 'ERROR') {
-                    reject(new Error(msg.error));
-                }
-            });
-        }));
-        processes.push(childProcess);
-    }
-    // Wait for peers to all connect with each other
-    await sleep(4000);
-    // Wait for all peers to be booted up
-    await Promise.all(readySignals);
-    return peerEnrs;
-}
 async function main() {
     try {
         // Read configuration file name from command line args
@@ -112,7 +27,8 @@ async function main() {
         };
         const numberOfClients = config.default.numberOfClients;
         // Setup clients in separate processes
-        await makeWorkerClients(numberOfClients, testConfig);
+        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');
@@ -120,7 +36,7 @@ async function main() {
         const tx = await mockTx(1, {
             clientIvcProof: ClientIvcProof.random()
         });
-        processes[0].send({
+        workerClientManager.processes[0].send({
             type: 'SEND_TX',
             tx: tx.toBuffer()
         });
@@ -128,14 +44,18 @@ async function main() {
         // Give time for message propagation
         await sleep(30000);
         logger.info('Checking message propagation results');
-        await cleanup();
+        // 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);
-        await cleanup();
         process.exit(1);
     }
 }
 main().catch((error)=>{
     logger.error('Unhandled error:', error);
-    cleanup().catch(()=>process.exit(1));
 });

package/dest/testbench/worker_client_manager.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Logger } from '@aztec/foundation/log';
+import type { ChainConfig } from '@aztec/stdlib/config';
+import { type ChildProcess } from 'child_process';
+import { type P2PConfig } from '../config.js';
+declare const testChainConfig: ChainConfig;
+declare class WorkerClientManager {
+    processes: ChildProcess[];
+    peerIdPrivateKeys: string[];
+    peerEnrs: string[];
+    ports: number[];
+    private p2pConfig;
+    private logger;
+    private messageReceivedByClient;
+    constructor(logger: Logger, p2pConfig: Partial<P2PConfig>);
+    destroy(): void;
+    /**
+     * Creates address strings from a port
+     */
+    private getAddresses;
+    /**
+     * Creates a client configuration object
+     */
+    private createClientConfig;
+    /**
+     * Spawns a worker process and returns a promise that resolves when the worker is ready
+     */
+    private spawnWorkerProcess;
+    /**
+     * 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
+     */
+    makeWorkerClients(numberOfClients: 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>;
+}
+export { WorkerClientManager, testChainConfig };
+//# sourceMappingURL=worker_client_manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"worker_client_manager.d.ts","sourceRoot":"","sources":["../../src/testbench/worker_client_manager.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAE,KAAK,YAAY,EAAQ,MAAM,eAAe,CAAC;AAIxD,OAAO,EAAE,KAAK,SAAS,EAAuB,MAAM,cAAc,CAAC;AAQnE,QAAA,MAAM,eAAe,EAAE,WAMtB,CAAC;AAEF,cAAM,mBAAmB;IAChB,SAAS,EAAE,YAAY,EAAE,CAAM;IAC/B,iBAAiB,EAAE,MAAM,EAAE,CAAM;IACjC,QAAQ,EAAE,MAAM,EAAE,CAAM;IACxB,KAAK,EAAE,MAAM,EAAE,CAAM;IAC5B,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,uBAAuB,CAAgB;gBAEnC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC;IAKzD,OAAO;IAOP;;OAEG;IACH,OAAO,CAAC,YAAY;IAOpB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAgB1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAoD1B;;;;;;OAMG;IACG,iBAAiB,CAAC,eAAe,EAAE,MAAM;IA2C/C,4BAA4B;IAI5B,kCAAkC;IAIlC;;;;;OAKG;IACG,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IA4CrD;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsCxB;;OAEG;IACG,OAAO;CAiCd;AAED,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,CAAC"}

package/dest/testbench/worker_client_manager.js

@@ -0,0 +1,266 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { sleep } from '@aztec/foundation/sleep';
+import { fork } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { 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 = {
+    l1ChainId: 31337,
+    version: 1,
+    l1Contracts: {
+        rollupAddress: EthAddress.random()
+    }
+};
+class WorkerClientManager {
+    processes = [];
+    peerIdPrivateKeys = [];
+    peerEnrs = [];
+    ports = [];
+    p2pConfig;
+    logger;
+    messageReceivedByClient = [];
+    constructor(logger, p2pConfig){
+        this.logger = logger;
+        this.p2pConfig = p2pConfig;
+    }
+    destroy() {
+        this.cleanup().catch((error)=>{
+            this.logger.error('Failed to cleanup worker client manager', error);
+            process.exit(1);
+        });
+    }
+    /**
+   * Creates address strings from a port
+   */ getAddresses(port) {
+        return {
+            addr: `127.0.0.1:${port}`,
+            listenAddr: `0.0.0.0:${port}`
+        };
+    }
+    /**
+   * Creates a client configuration object
+   */ createClientConfig(clientIndex, port, otherNodes) {
+        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
+   */ spawnWorkerProcess(config, clientIndex) {
+        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)=>{
+            if (msg.type === 'GOSSIP_RECEIVED') {
+                this.messageReceivedByClient[clientIndex] = msg.count;
+            }
+        });
+        // Create ready signal promise
+        const readySignal = new Promise((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)=>{
+                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) {
+        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 = [];
+            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, newPort) {
+        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
+   */ terminateProcess(process1, index) {
+        if (!process1 || process1.killed) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve)=>{
+            // Set a timeout for the graceful exit
+            const forceKillTimeout = setTimeout(()=>{
+                this.logger.warn(`Process ${index} didn't exit gracefully, force killing...`);
+                try {
+                    process1.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
+            process1.once('exit', ()=>{
+                clearTimeout(forceKillTimeout);
+                resolve();
+            });
+            // Try to gracefully stop the process
+            try {
+                process1.send({
+                    type: 'STOP'
+                });
+            } catch (e) {
+                // If sending the message fails, force kill immediately
+                clearTimeout(forceKillTimeout);
+                try {
+                    process1.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((process1, index)=>this.terminateProcess(process1, index));
+        // Wait for all processes to terminate with a timeout
+        try {
+            await Promise.race([
+                Promise.all(terminationPromises),
+                new Promise((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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/p2p",
-  "version": "0.77.0-testnet-ignition.29",
+  "version": "0.77.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -65,14 +65,14 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.77.0-testnet-ignition.29",
-    "@aztec/epoch-cache": "0.77.0-testnet-ignition.29",
-    "@aztec/foundation": "0.77.0-testnet-ignition.29",
-    "@aztec/kv-store": "0.77.0-testnet-ignition.29",
-    "@aztec/noir-protocol-circuits-types": "0.77.0-testnet-ignition.29",
-    "@aztec/protocol-contracts": "0.77.0-testnet-ignition.29",
-    "@aztec/stdlib": "0.77.0-testnet-ignition.29",
-    "@aztec/telemetry-client": "0.77.0-testnet-ignition.29",
+    "@aztec/constants": "0.77.0",
+    "@aztec/epoch-cache": "0.77.0",
+    "@aztec/foundation": "0.77.0",
+    "@aztec/kv-store": "0.77.0",
+    "@aztec/noir-protocol-circuits-types": "0.77.0",
+    "@aztec/protocol-contracts": "0.77.0",
+    "@aztec/stdlib": "0.77.0",
+    "@aztec/telemetry-client": "0.77.0",
     "@chainsafe/discv5": "9.0.0",
     "@chainsafe/enr": "3.0.0",
     "@chainsafe/libp2p-gossipsub": "13.0.0",
@@ -101,7 +101,7 @@
     "xxhash-wasm": "^1.1.0"
   },
   "devDependencies": {
-    "@aztec/archiver": "0.77.0-testnet-ignition.29",
+    "@aztec/archiver": "0.77.0",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/node": "^18.14.6",

package/src/client/factory.ts

@@ -38,8 +38,8 @@ export const createP2PClient = async <T extends P2PClientType>(
 ) => {
   let config = { ..._config };
   const logger = deps.logger ?? createLogger('p2p');
-  const store = deps.store ?? (await createStore('p2p', config, createLogger('p2p:lmdb-v2')));
-  const archive = await createStore('p2p-archive', config, createLogger('p2p-archive:lmdb-v2'));
+  const store = deps.store ?? (await createStore('p2p', 1, config, createLogger('p2p:lmdb-v2')));
+  const archive = await createStore('p2p-archive', 1, config, createLogger('p2p-archive:lmdb-v2'));
 
   const mempools: MemPools<T> = {
     txPool: deps.txPool ?? new AztecKVTxPool(store, archive, telemetry, config.archivedTxLimit),

package/src/testbench/testbench.ts

@@ -1,117 +1,17 @@
-import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
-import type { ChainConfig } from '@aztec/stdlib/config';
 import { ClientIvcProof } from '@aztec/stdlib/proofs';
 import { mockTx } from '@aztec/stdlib/testing';
 
-import { type ChildProcess, fork } from 'child_process';
+import assert from 'assert';
 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 { makeEnrs } from '../test-helpers/make-enrs.js';
+import { WorkerClientManager, testChainConfig } from './worker_client_manager.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const workerPath = path.join(__dirname, '../../dest/testbench/p2p_client_testbench_worker.js');
 const logger = createLogger('testbench');
 
-let processes: ChildProcess[] = [];
-
-const testChainConfig: ChainConfig = {
-  l1ChainId: 31337,
-  version: 1,
-  l1Contracts: {
-    rollupAddress: EthAddress.random(),
-  },
-};
-
-/**
- * Cleanup function to kill all child processes
- */
-async function cleanup() {
-  logger.info('Cleaning up processes...');
-  await Promise.all(
-    processes.map(
-      proc =>
-        new Promise<void>(resolve => {
-          proc.once('exit', () => resolve());
-          proc.send({ type: 'STOP' });
-        }),
-    ),
-  );
-  process.exit(0);
-}
-
-// Handle cleanup on process termination
-process.on('SIGINT', () => void cleanup());
-process.on('SIGTERM', () => void cleanup());
-
-/**
- * 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
- * @param p2pConfig - The P2P config to use for the clients
- * @returns The ENRs of the created clients
- */
-async function makeWorkerClients(numberOfClients: number, p2pConfig: Partial<P2PConfig>) {
-  const peerIdPrivateKeys = generatePeerIdPrivateKeys(numberOfClients);
-  const ports = await getPorts(numberOfClients);
-  const peerEnrs = await makeEnrs(peerIdPrivateKeys, ports, testChainConfig);
-
-  processes = [];
-  const readySignals: Promise<void>[] = [];
-  for (let i = 0; i < numberOfClients; i++) {
-    logger.info(`Creating client ${i}`);
-    const addr = `127.0.0.1:${ports[i]}`;
-    const listenAddr = `0.0.0.0:${ports[i]}`;
-
-    // Maximum seed with 10 other peers to allow peer discovery to connect them at a smoother rate
-    const otherNodes = peerEnrs.filter((_, ind) => ind < Math.min(i, 10));
-
-    const config: P2PConfig & Partial<ChainConfig> = {
-      ...getP2PDefaultConfig(),
-      p2pEnabled: true,
-      peerIdPrivateKey: peerIdPrivateKeys[i],
-      tcpListenAddress: listenAddr,
-      udpListenAddress: listenAddr,
-      tcpAnnounceAddress: addr,
-      udpAnnounceAddress: addr,
-      bootstrapNodes: [...otherNodes],
-      ...p2pConfig,
-    };
-
-    const childProcess = fork(workerPath);
-    childProcess.send({ type: 'START', config, clientIndex: i });
-
-    // Wait for ready signal
-    readySignals.push(
-      new Promise((resolve, reject) => {
-        childProcess.once('message', (msg: any) => {
-          if (msg.type === 'READY') {
-            resolve(undefined);
-          }
-          if (msg.type === 'ERROR') {
-            reject(new Error(msg.error));
-          }
-        });
-      }),
-    );
-
-    processes.push(childProcess);
-  }
-  // Wait for peers to all connect with each other
-  await sleep(4000);
-
-  // Wait for all peers to be booted up
-  await Promise.all(readySignals);
-
-  return peerEnrs;
-}
-
 async function main() {
   try {
     // Read configuration file name from command line args
@@ -126,7 +26,8 @@ async function main() {
     const numberOfClients = config.default.numberOfClients;
 
     // Setup clients in separate processes
-    await makeWorkerClients(numberOfClients, testConfig);
+    const workerClientManager = new WorkerClientManager(logger, testConfig);
+    await workerClientManager.makeWorkerClients(numberOfClients);
 
     // wait a bit longer for all peers to be ready
     await sleep(5000);
@@ -136,22 +37,30 @@ async function main() {
     const tx = await mockTx(1, {
       clientIvcProof: ClientIvcProof.random(),
     });
-    processes[0].send({ type: 'SEND_TX', tx: tx.toBuffer() });
+
+    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');
 
-    await cleanup();
+    // 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);
-    await cleanup();
     process.exit(1);
   }
 }
 
 main().catch(error => {
   logger.error('Unhandled error:', error);
-  cleanup().catch(() => process.exit(1));
 });

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 };