@aztec/p2p 0.0.1-commit.e61ad554 → 0.0.1-commit.ee80a48

package/dest/testbench/p2p_client_testbench_worker.js

@@ -1,115 +1,33 @@
 /**
  * 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 { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import { P2PClientType, P2PMessage } from '@aztec/stdlib/p2p';
-import { Tx, TxStatus } from '@aztec/stdlib/tx';
+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 { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.js';
+import { BatchTxRequesterCollector, SendBatchRequestCollector } from '../services/tx_collection/proposal_tx_collector.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,
-                nowMs: 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([])
-    };
-}
-function mockWorldStateSynchronizer() {
-    return {
-        status: ()=>Promise.resolve({
-                syncSummary: {
-                    latestBlockNumber: 0,
-                    latestBlockHash: '',
-                    finalizedBlockNumber: 0,
-                    treesAreSynched: false,
-                    oldestHistoricBlockNumber: 0
-                }
-            })
-    };
-}
+import { BENCHMARK_CONSTANTS, InMemoryAttestationPool, InMemoryTxPool, UNLIMITED_RATE_LIMIT_QUOTA, createMockEpochCache, createMockWorldStateSynchronizer, filterTxsByDistribution } from '../test-helpers/testbench-utils.js';
+export { COLLECTOR_DISPLAY_NAMES } from '../test-helpers/testbench-utils.js';
+const txCache = new Map();
 class TestLibP2PService extends LibP2PService {
     disableTxValidation;
     gossipMessageCount = 0;
@@ -147,68 +65,231 @@ 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 includeByTimestampBase = 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.includeByTimestamp = includeByTimestampBase + 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;
+}
+async function runAggregatorBenchmark(client, blockProposal, collectorType, 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 = {
+            validateRequestedTx: (_tx)=>Promise.resolve({
+                    result: 'valid'
+                }),
+            validateRequestedTxs: (txs)=>Promise.resolve(txs.map(()=>({
+                        result: 'valid'
+                    })))
+        };
+        timer = new Timer();
+        if (collectorType === 'batch-requester') {
+            const collector = new BatchTxRequesterCollector(batchTxRequesterService, logger, new DateProvider(), noopTxValidator);
+            const fetchedTxs = await collector.collectTxs(txHashes, blockProposal, pinnedPeer, timeoutMs);
+            const durationMs = timer.ms();
+            return {
+                type: 'BENCH_RESULT',
+                durationMs,
+                fetchedCount: fetchedTxs.length,
+                success: fetchedTxs.length === txHashes.length
+            };
+        }
+        const collector = new SendBatchRequestCollector(batchTxRequesterService, BENCHMARK_CONSTANTS.FIXED_MAX_PEERS, BENCHMARK_CONSTANTS.FIXED_MAX_RETRY_ATTEMPTS);
+        const fetchedTxs = await collector.collectTxs(txHashes, blockProposal, pinnedPeer, timeoutMs);
+        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;
 // 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
             };
-            const txPool = mockTxPool();
-            const attestationPool = mockAttestationPool();
-            const epochCache = mockEpochCache();
-            const worldState = mockWorldStateSynchronizer();
+            workerConfig = config;
+            workerTxPool = new InMemoryTxPool();
+            workerAttestationPool = new InMemoryAttestationPool();
+            const epochCache = createMockEpochCache();
+            const worldState = createMockWorldStateSynchronizer();
             const l2BlockSource = new MockL2BlockSource();
             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 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, 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':
+                if (workerClient) {
+                    await workerClient.stop();
+                }
+                if (kvStore?.close) {
+                    await kvStore.close();
+                }
+                process.exit(0);
+                break;
+            case 'SEND_TX':
+                if (workerClient) {
+                    await workerClient.sendTx(Tx.fromBuffer(Buffer.from(cmd.tx)));
+                    process.send({
+                        type: 'TX_SENT'
+                    });
+                }
+                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();
+                    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.addBlockProposal(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}, collector=${benchCmd.collectorType}, distribution=${benchCmd.distribution}`);
+                        const result = await runAggregatorBenchmark(workerClient, blockProposal, benchCmd.collectorType, 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;
                 }
-            });
-            process.send({
-                type: 'READY'
-            });
         }
     } catch (err) {
         process.send({

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 { CollectorType, DistributionPattern } from './p2p_client_testbench_worker.js';
 declare const testChainConfig: ChainConfig;
+export interface ReqRespBenchmarkConfig {
+    txCount: number;
+    distribution: DistributionPattern;
+    collectorType: CollectorType;
+    timeoutMs: number;
+    pinnedPeerIndex?: number;
+    blockNumber?: number;
+    seed?: number;
+}
+export interface ReqRespBenchmarkResult {
+    txCount: number;
+    distribution: DistributionPattern;
+    collector: CollectorType;
+    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.
      */
     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,21 @@ declare class WorkerClientManager {
      * Cleans up all worker processes with timeout and force kill if needed
      */
     cleanup(): Promise<void>;
+    /**
+     * 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, CollectorType } from './p2p_client_testbench_worker.js';
+export { COLLECTOR_DISPLAY_NAMES } from './p2p_client_testbench_worker.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2VyX2NsaWVudF9tYW5hZ2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGJlbmNoL3dvcmtlcl9jbGllbnRfbWFuYWdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUVwRCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUV4RCxPQUFPLEVBQUUsS0FBSyxZQUFZLEVBQVEsTUFBTSxlQUFlLENBQUM7QUFLeEQsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUF1QixNQUFNLGNBQWMsQ0FBQztBQUtuRSxPQUFPLEtBQUssRUFHVixhQUFhLEVBQ2IsbUJBQW1CLEVBQ3BCLE1BQU0sa0NBQWtDLENBQUM7QUFRMUMsUUFBQSxNQUFNLGVBQWUsRUFBRSxXQU10QixDQUFDO0FBRUYsTUFBTSxXQUFXLHNCQUFzQjtJQUNyQyxPQUFPLEVBQUUsTUFBTSxDQUFDO0lBQ2hCLFlBQVksRUFBRSxtQkFBbUIsQ0FBQztJQUNsQyxhQUFhLEVBQUUsYUFBYSxDQUFDO0lBQzdCLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsZUFBZSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3pCLFdBQVcsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNyQixJQUFJLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDZjtBQUVELE1BQU0sV0FBVyxzQkFBc0I7SUFDckMsT0FBTyxFQUFFLE1BQU0sQ0FBQztJQUNoQixZQUFZLEVBQUUsbUJBQW1CLENBQUM7SUFDbEMsU0FBUyxFQUFFLGFBQWEsQ0FBQztJQUN6QixVQUFVLEVBQUUsTUFBTSxDQUFDO0lBQ25CLFlBQVksRUFBRSxNQUFNLENBQUM7SUFDckIsT0FBTyxFQUFFLE9BQU8sQ0FBQztJQUNqQixLQUFLLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDaEI7QUFFRCxjQUFNLG1CQUFtQjtJQUNoQixTQUFTLEVBQUUsWUFBWSxFQUFFLENBQU07SUFDL0IsaUJBQWlCLEVBQUUsTUFBTSxFQUFFLENBQU07SUFDakMsUUFBUSxFQUFFLE1BQU0sRUFBRSxDQUFNO0lBQ3hCLEtBQUssRUFBRSxNQUFNLEVBQUUsQ0FBTTtJQUNyQixPQUFPLEVBQUUsTUFBTSxFQUFFLENBQU07SUFDOUIsT0FBTyxDQUFDLFNBQVMsQ0FBcUI7SUFDdEMsT0FBTyxDQUFDLE1BQU0sQ0FBUztJQUN2QixPQUFPLENBQUMsdUJBQXVCLENBQWdCO0lBRS9DLFlBQVksTUFBTSxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUd4RDtJQUVELE9BQU8sU0FLTjtJQUVEOzs7OztPQUtHO0lBQ0gsT0FBTyxDQUFDLGtCQUFrQjtJQWlCMUI7OztPQUdHO0lBQ0gsT0FBTyxDQUFDLGtCQUFrQjtJQWdHMUI7Ozs7Ozs7T0FPRztJQUNHLGlCQUFpQixDQUNyQixlQUFlLEVBQUUsTUFBTSxFQUN2QixPQUFPLEdBQUU7UUFDUCxhQUFhLENBQUMsRUFBRSxRQUFRLEdBQUcsS0FBSyxDQUFDO1FBQ2pDLGFBQWEsQ0FBQyxFQUFFLE1BQU0sQ0FBQztRQUN2QixTQUFTLENBQUMsRUFBRSxNQUFNLENBQUM7UUFDbkIsWUFBWSxDQUFDLEVBQUUsTUFBTSxDQUFDO0tBQ2xCLHFCQStEUDtJQUVELDRCQUE0QixTQUUzQjtJQUVELGtDQUFrQyxXQUVqQztJQUVEOzs7OztPQUtHO0lBQ0csVUFBVSxDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLE1BQU0saUJBOENwRDtJQUVEOztPQUVHO0lBQ0gsT0FBTyxDQUFDLGdCQUFnQjtJQXFDeEI7O09BRUc7SUFDRyxPQUFPLGtCQWdDWjtJQUVEOzs7Ozs7Ozs7T0FTRztJQUNHLG1CQUFtQixDQUFDLE1BQU0sRUFBRSxzQkFBc0IsR0FBRyxPQUFPLENBQUMsc0JBQXNCLENBQUMsQ0FzRXpGO0lBRUQsT0FBTyxDQUFDLGlCQUFpQjtJQWtDekIsT0FBTyxDQUFDLGtCQUFrQjtDQWlDM0I7QUFFRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsZUFBZSxFQUFFLENBQUM7QUFDaEQsWUFBWSxFQUFFLG1CQUFtQixFQUFFLGFBQWEsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQzNGLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDIn0=

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,EAGV,aAAa,EACb,mBAAmB,EACpB,MAAM,kCAAkC,CAAC;AAQ1C,QAAA,MAAM,eAAe,EAAE,WAMtB,CAAC;AAEF,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,mBAAmB,CAAC;IAClC,aAAa,EAAE,aAAa,CAAC;IAC7B,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,SAAS,EAAE,aAAa,CAAC;IACzB,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,SAKN;IAED;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IAiB1B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAgG1B;;;;;;;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;;;;;;;;;OASG;IACG,mBAAmB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAsEzF;IAED,OAAO,CAAC,iBAAiB;IAkCzB,OAAO,CAAC,kBAAkB;CAiC3B;AAED,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,CAAC;AAChD,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAC3F,OAAO,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC"}