@aztec/p2p 0.0.0-test.0

package/dest/testbench/p2p_client_testbench_worker.js

@@ -0,0 +1,132 @@
+/**
+ * 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 { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
+import { P2PClientType } from '@aztec/stdlib/p2p';
+import { Tx, TxStatus } from '@aztec/stdlib/tx';
+import { createP2PClient } from '../index.js';
+import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
+// Simple mock implementation
+function mockTxPool() {
+    // 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() {
+    return {
+        addAttestations: ()=>Promise.resolve(),
+        deleteAttestations: ()=>Promise.resolve(),
+        deleteAttestationsOlderThan: ()=>Promise.resolve(),
+        deleteAttestationsForSlot: ()=>Promise.resolve(),
+        deleteAttestationsForSlotAndProposal: ()=>Promise.resolve(),
+        getAttestationsForSlot: ()=>Promise.resolve([])
+    };
+}
+function mockEpochCache() {
+    return {
+        getCommittee: ()=>Promise.resolve([]),
+        getProposerIndexEncoding: ()=>'0x',
+        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;
+    try {
+        if (type === 'START') {
+            const txPool = mockTxPool();
+            const attestationPool = mockAttestationPool();
+            const epochCache = mockEpochCache();
+            const worldState = {};
+            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, l2BlockSource, proofVerifier, worldState, epochCache, undefined, deps);
+            // Create spy for gossip messages
+            let gossipMessageCount = 0;
+            client.p2pService.handleNewGossipMessage = (msg, msgId, source)=>{
+                gossipMessageCount++;
+                process.send({
+                    type: 'GOSSIP_RECEIVED',
+                    count: gossipMessageCount
+                });
+                return client.p2pService.constructor.prototype.handleNewGossipMessage.apply(client.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)=>{
+                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) {
+        process.send({
+            type: 'ERROR',
+            error: err.message
+        });
+        process.exit(1);
+    }
+});

package/dest/testbench/parse_log_file.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parse_log_file.d.ts.map

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/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 "rpc.from" 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;
+    }
+    // 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) {
+    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=testbench.d.ts.map

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,61 @@
+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);
+});

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