@aztec/p2p 0.0.1-commit.d431d1c → 0.0.1-commit.d58ff9d0

package/dest/testbench/p2p_client_testbench_worker.js

@@ -1,119 +1,58 @@
 /**
  * A testbench worker that creates a p2p client and listens for commands from the parent.
  *
- * Used when running testbench commands
+ * Used when running testbench commands.
  */ import { MockL2BlockSource } from '@aztec/archiver/test';
-import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
+import { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
+import { DateProvider, Timer } from '@aztec/foundation/timer';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
-import { P2PClientType, P2PMessage } from '@aztec/stdlib/p2p';
-import { Tx, TxStatus } from '@aztec/stdlib/tx';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { EmptyL1RollupConstants } from '@aztec/stdlib/epoch-helpers';
+import { GasFees } from '@aztec/stdlib/gas';
+import { P2PMessage } from '@aztec/stdlib/p2p';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import { makeAztecAddress, makeBlockHeader, makeBlockProposal, mockTx } from '@aztec/stdlib/testing';
+import { Tx } from '@aztec/stdlib/tx';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 import { TopicValidatorResult } from '@libp2p/interface';
-import EventEmitter from 'events';
+import { peerIdFromString } from '@libp2p/peer-id';
 import { createP2PClient } from '../index.js';
-import { LibP2PService } from '../services/libp2p/libp2p_service.js';
-import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
-// Simple mock implementation
-function mockTxPool() {
-    // Mock all methods
-    const pool = {
-        isEmpty: ()=>Promise.resolve(false),
-        addTxs: ()=>Promise.resolve(1),
-        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([]),
-        getPendingTxCount: ()=>Promise.resolve(0),
-        getMinedTxHashes: ()=>Promise.resolve([]),
-        getTxStatus: ()=>Promise.resolve(TxStatus.PENDING),
-        getTxsByHash: ()=>Promise.resolve([]),
-        hasTxs: ()=>Promise.resolve([]),
-        hasTx: ()=>Promise.resolve(false),
-        updateConfig: ()=>{},
-        markTxsAsNonEvictable: ()=>Promise.resolve(),
-        clearNonEvictableTxs: ()=>Promise.resolve(),
-        cleanupDeletedMinedTxs: ()=>Promise.resolve(0)
-    };
-    return Object.assign(new EventEmitter(), pool);
-}
-function mockAttestationPool() {
-    return {
-        isEmpty: ()=>Promise.resolve(false),
-        addBlockProposal: ()=>Promise.resolve(),
-        getBlockProposal: ()=>Promise.resolve(undefined),
-        hasBlockProposal: ()=>Promise.resolve(false),
-        canAddProposal: ()=>Promise.resolve(true),
-        // Checkpoint attestation methods
-        addCheckpointProposal: ()=>Promise.resolve(),
-        getCheckpointProposal: ()=>Promise.resolve(undefined),
-        hasCheckpointProposal: ()=>Promise.resolve(false),
-        addCheckpointAttestations: ()=>Promise.resolve(),
-        getCheckpointAttestationsForSlot: ()=>Promise.resolve([]),
-        getCheckpointAttestationsForSlotAndProposal: ()=>Promise.resolve([]),
-        deleteCheckpointAttestationsOlderThan: ()=>Promise.resolve(),
-        hasReachedCheckpointProposalCap: ()=>Promise.resolve(false),
-        hasReachedCheckpointAttestationCap: ()=>Promise.resolve(false),
-        canAddCheckpointProposal: ()=>Promise.resolve(true),
-        canAddCheckpointAttestation: ()=>Promise.resolve(true),
-        hasCheckpointAttestation: ()=>Promise.resolve(false)
-    };
-}
-function mockEpochCache() {
-    return {
-        getCommittee: ()=>Promise.resolve({
-                committee: [],
-                seed: 1n,
-                epoch: EpochNumber.ZERO,
-                isEscapeHatchOpen: false
-            }),
-        getProposerIndexEncoding: ()=>'0x',
-        getEpochAndSlotNow: ()=>({
-                epoch: EpochNumber.ZERO,
-                slot: SlotNumber.ZERO,
-                ts: 0n
-            }),
-        computeProposerIndex: ()=>0n,
-        getCurrentAndNextSlot: ()=>({
-                currentSlot: SlotNumber.ZERO,
-                nextSlot: SlotNumber.ZERO
-            }),
-        getProposerAttesterAddressInSlot: ()=>Promise.resolve(undefined),
-        getEpochAndSlotInNextL1Slot: ()=>({
-                epoch: EpochNumber.ZERO,
-                slot: SlotNumber.ZERO,
-                ts: 0n,
-                now: 0n
-            }),
-        isInCommittee: ()=>Promise.resolve(false),
-        getRegisteredValidators: ()=>Promise.resolve([]),
-        filterInCommittee: ()=>Promise.resolve([])
-    };
+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 mockWorldStateSynchronizer() {
+function createBenchmarkEpochCache() {
     return {
-        status: ()=>Promise.resolve({
-                syncSummary: {
-                    latestBlockNumber: 0,
-                    latestBlockHash: '',
-                    finalizedBlockNumber: 0,
-                    treesAreSynched: false,
-                    oldestHistoricBlockNumber: 0
-                }
-            })
+        ...createMockEpochCache(),
+        getL1Constants: ()=>BENCH_L1_CONSTANTS
     };
 }
 class TestLibP2PService extends LibP2PService {
     disableTxValidation;
     gossipMessageCount = 0;
-    constructor(clientType, config, node, peerDiscoveryService, reqresp, peerManager, mempools, archiver, epochCache, proofVerifier, worldStateSynchronizer, telemetry, logger = createLogger('p2p:test:libp2p_service'), disableTxValidation = true){
-        super(clientType, config, node, peerDiscoveryService, reqresp, peerManager, mempools, archiver, epochCache, proofVerifier, worldStateSynchronizer, telemetry, logger);
+    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() {
@@ -130,7 +69,7 @@ class TestLibP2PService extends LibP2PService {
             const txHash = tx.getTxHash();
             const txHashString = txHash.toString();
             this.logger.verbose(`Received tx ${txHashString} from external peer ${source.toString()}.`);
-            await this.mempools.txPool.addTxs([
+            await this.mempools.txPool.addPendingTxs([
                 tx
             ]);
         } else {
@@ -146,74 +85,280 @@ class TestLibP2PService extends LibP2PService {
         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)=>{
-    // Note: peerIdPrivateKey comes as a raw string (not SecretValue) because
-    // SecretValue's private fields can't be serialized via IPC
     const { type, config: rawConfig, clientIndex } = msg;
     try {
         if (type === 'START') {
-            // Re-wrap the peerIdPrivateKey with SecretValue
             const config = {
                 ...rawConfig,
-                peerIdPrivateKey: rawConfig.peerIdPrivateKey ? new SecretValue(rawConfig.peerIdPrivateKey) : undefined
+                peerIdPrivateKey: rawConfig.peerIdPrivateKey ? new SecretValue(rawConfig.peerIdPrivateKey) : undefined,
+                priceBumpPercentage: 10n
             };
-            const txPool = mockTxPool();
-            const attestationPool = mockAttestationPool();
-            const epochCache = mockEpochCache();
-            const worldState = mockWorldStateSynchronizer();
-            const l2BlockSource = new MockL2BlockSource();
+            workerConfig = config;
+            workerTxPool = new InMemoryTxPool();
+            workerAttestationPool = new InMemoryAttestationPool();
+            const epochCache = createBenchmarkEpochCache();
+            const worldState = createMockWorldStateSynchronizer();
+            const l2BlockSource = new TestbenchL2BlockSource();
             const proofVerifier = new AlwaysTrueCircuitVerifier();
-            const kvStore = await openTmpStore(`test-${clientIndex}`);
-            const logger = createLogger(`p2p:${clientIndex}`);
+            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,
-                attestationPool,
+                txPool: workerTxPool,
+                attestationPool: workerAttestationPool,
                 store: kvStore,
-                logger
+                logger: workerLogger
             };
-            const client = await createP2PClient(P2PClientType.Full, config, l2BlockSource, proofVerifier, worldState, epochCache, 'test-p2p-bench-worker', undefined, telemetry, deps);
-            // Create test service with validation disabled
-            // Note: Parameter order must match LibP2PService constructor
-            const testService = new TestLibP2PService(P2PClientType.Full, config, client.p2pService.node, client.p2pService.peerDiscoveryService, client.p2pService.reqresp, client.p2pService.peerManager, client.p2pService.mempools, client.p2pService.archiver, epochCache, proofVerifier, worldState, telemetry, logger, true);
-            // Replace the existing p2pService with our test version
+            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();
-            // Wait until the client is ready
             for(let i = 0; i < 100; i++){
                 const isReady = client.isReady();
-                logger.debug(`Client ${clientIndex} isReady: ${isReady}`);
+                workerLogger.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)));
+            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: 'TX_SENT'
+                            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: 'READY'
+                type: 'ERROR',
+                error: err.message
             });
+        } catch  {
+        // IPC channel may be closed
         }
-    } catch (err) {
-        process.send({
-            type: 'ERROR',
-            error: err.message
-        });
-        process.exit(1);
+        await stopWorker();
+        gracefulExit(1);
     }
 });

package/dest/testbench/worker_client_manager.d.ts

@@ -2,33 +2,63 @@ 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';
+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
+     * 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
+     * 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 overrided with the test specific config
+     * 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): Promise<string[]>;
+    makeWorkerClients(numberOfClients: number, options?: {
+        bootstrapMode?: 'subset' | 'all';
+        seedPeerLimit?: number;
+        batchSize?: number;
+        batchDelayMs?: number;
+    }): Promise<string[]>;
     purgeMessageReceivedByClient(): void;
     numberOfClientsThatReceivedMessage(): number;
     /**
@@ -46,6 +76,27 @@ declare class WorkerClientManager {
      * 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 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2VyX2NsaWVudF9tYW5hZ2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGJlbmNoL3dvcmtlcl9jbGllbnRfbWFuYWdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUVwRCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUV4RCxPQUFPLEVBQUUsS0FBSyxZQUFZLEVBQVEsTUFBTSxlQUFlLENBQUM7QUFJeEQsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUF1QixNQUFNLGNBQWMsQ0FBQztBQVFuRSxRQUFBLE1BQU0sZUFBZSxFQUFFLFdBTXRCLENBQUM7QUFFRixjQUFNLG1CQUFtQjtJQUNoQixTQUFTLEVBQUUsWUFBWSxFQUFFLENBQU07SUFDL0IsaUJBQWlCLEVBQUUsTUFBTSxFQUFFLENBQU07SUFDakMsUUFBUSxFQUFFLE1BQU0sRUFBRSxDQUFNO0lBQ3hCLEtBQUssRUFBRSxNQUFNLEVBQUUsQ0FBTTtJQUM1QixPQUFPLENBQUMsU0FBUyxDQUFxQjtJQUN0QyxPQUFPLENBQUMsTUFBTSxDQUFTO0lBQ3ZCLE9BQU8sQ0FBQyx1QkFBdUIsQ0FBZ0I7SUFFL0MsWUFBWSxNQUFNLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxPQUFPLENBQUMsU0FBUyxDQUFDLEVBR3hEO0lBRUQsT0FBTyxTQUtOO0lBRUQ7O09BRUc7SUFDSCxPQUFPLENBQUMsa0JBQWtCO0lBaUIxQjs7T0FFRztJQUNILE9BQU8sQ0FBQyxrQkFBa0I7SUF5RDFCOzs7Ozs7T0FNRztJQUNHLGlCQUFpQixDQUFDLGVBQWUsRUFBRSxNQUFNLHFCQXlDOUM7SUFFRCw0QkFBNEIsU0FFM0I7SUFFRCxrQ0FBa0MsV0FFakM7SUFFRDs7Ozs7T0FLRztJQUNHLFVBQVUsQ0FBQyxXQUFXLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxNQUFNLGlCQTRDcEQ7SUFFRDs7T0FFRztJQUNILE9BQU8sQ0FBQyxnQkFBZ0I7SUFzQ3hCOztPQUVHO0lBQ0csT0FBTyxrQkFnQ1o7Q0FDRjtBQUVELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxlQUFlLEVBQUUsQ0FBQyJ9
+export type { DistributionPattern } from './p2p_client_testbench_worker.js';
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"worker_client_manager.d.ts","sourceRoot":"","sources":["../../src/testbench/worker_client_manager.ts"],"names":[],"mappings":"AAEA,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;IAE/C,YAAY,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,EAGxD;IAED,OAAO,SAKN;IAED;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAiB1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAyD1B;;;;;;OAMG;IACG,iBAAiB,CAAC,eAAe,EAAE,MAAM,qBAyC9C;IAED,4BAA4B,SAE3B;IAED,kCAAkC,WAEjC;IAED;;;;;OAKG;IACG,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,iBA4CpD;IAED;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsCxB;;OAEG;IACG,OAAO,kBAgCZ;CACF;AAED,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,CAAC"}
+{"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;AAKxD,OAAO,EAAE,KAAK,SAAS,EAAuB,MAAM,cAAc,CAAC;AAKnE,OAAO,KAAK,EAA2C,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAQrH,QAAA,MAAM,eAAe,EAAE,WAItB,CAAC;AAEF,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,mBAAmB,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,mBAAmB,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,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;IACrB,OAAO,EAAE,MAAM,EAAE,CAAM;IAC9B,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,uBAAuB,CAAgB;IAE/C,YAAY,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,EAGxD;IAED,OAAO,SAIN;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB;IAoB1B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAkG1B;;;;;;;OAOG;IACG,iBAAiB,CACrB,eAAe,EAAE,MAAM,EACvB,OAAO,GAAE;QACP,aAAa,CAAC,EAAE,QAAQ,GAAG,KAAK,CAAC;QACjC,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,YAAY,CAAC,EAAE,MAAM,CAAC;KAClB,qBA+DP;IAED,4BAA4B,SAE3B;IAED,kCAAkC,WAEjC;IAED;;;;;OAKG;IACG,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,iBA8CpD;IAED;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAqCxB;;OAEG;IACG,OAAO,kBAgCZ;IAED;;;;OAIG;IACG,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,GAAE,MAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAkBvF;IAED,OAAO,CAAC,YAAY;IA8BpB;;;;;;;;;OASG;IACG,mBAAmB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAkEzF;IAED,OAAO,CAAC,iBAAiB;IAkCzB,OAAO,CAAC,kBAAkB;CAiC3B;AAED,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,CAAC;AAChD,YAAY,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC"}