@aztec/p2p 0.0.1-commit.9b94fc1 → 0.0.1-commit.9d2bcf6d

package/src/services/tx_provider.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { compactArray } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
@@ -55,7 +56,7 @@ export class TxProvider implements ITxProvider {
   /** Gathers txs from the tx pool, proposal body, remote rpc nodes, and reqresp. */
   public getTxsForBlockProposal(
     blockProposal: BlockProposal,
-    blockNumber: number,
+    blockNumber: BlockNumber,
     opts: { pinnedPeer: PeerId | undefined; deadline: Date },
   ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
     return this.getOrderedTxsFromAllSources(
@@ -136,6 +137,7 @@ export class TxProvider implements ITxProvider {
     );
 
     if (missingTxHashes.size === 0) {
+      this.instrumentation.incTxsFromP2P(0, txHashes.length);
       return { txsFromMempool };
     }
 
@@ -154,24 +156,26 @@ export class TxProvider implements ITxProvider {
 
     if (missingTxHashes.size === 0) {
       await this.processProposalTxs(txsFromProposal);
+      this.instrumentation.incTxsFromP2P(0, txHashes.length);
       return { txsFromMempool, txsFromProposal };
     }
 
     // Start tx collection from the network if needed, while we validate the txs taken from the proposal in parallel
     const [txsFromNetwork] = await Promise.all([
-      this.txCollection.collectFastFor(request, [...missingTxHashes], opts),
+      this.collectFromP2P(request, [...missingTxHashes], opts),
       this.processProposalTxs(txsFromProposal),
     ] as const);
 
     if (txsFromNetwork.length > 0) {
       txsFromNetwork.forEach(tx => missingTxHashes.delete(tx.txHash.toString()));
-      this.instrumentation.incTxsFromP2P(txsFromNetwork.length);
       this.log.debug(
         `Retrieved ${txsFromNetwork.length} txs from network for block proposal (${missingTxHashes.size} pending)`,
         { ...blockInfo, missingTxHashes: [...missingTxHashes] },
       );
     }
 
+    this.instrumentation.incTxsFromP2P(txsFromNetwork.length, txHashes.length);
+
     if (missingTxHashes.size === 0) {
       return { txsFromNetwork, txsFromMempool, txsFromProposal };
     }
@@ -199,6 +203,18 @@ export class TxProvider implements ITxProvider {
     };
   }
 
+  private async collectFromP2P(
+    input: FastCollectionRequestInput,
+    txHashes: TxHash[] | string[],
+    opts: { deadline: Date; pinnedPeer?: PeerId },
+  ): Promise<Tx[]> {
+    const requestedAt = Date.now();
+    const result = await this.txCollection.collectFastFor(input, txHashes, opts);
+    const requestProcessedAt = Date.now();
+    this.instrumentation.recordTxsRequestDelay(requestProcessedAt - requestedAt);
+    return result;
+  }
+
   private extractFromProposal(proposal: BlockProposal | undefined, missingTxHashes: string[]): Tx[] {
     if (!proposal) {
       return [];

package/src/services/tx_provider_instrumentation.ts

@@ -1,4 +1,10 @@
-import { Metrics, type TelemetryClient, type UpDownCounter } from '@aztec/telemetry-client';
+import {
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  createUpDownCounterWithDefault,
+} from '@aztec/telemetry-client';
 
 export class TxProviderInstrumentation {
   private txFromProposalCount: UpDownCounter;
@@ -6,24 +12,23 @@ export class TxProviderInstrumentation {
   private txFromP2PCount: UpDownCounter;
   private missingTxsCount: UpDownCounter;
 
+  private fractionOfTxsRequestedFromP2P: Histogram;
+  private txsRequestDelay: Histogram;
+
   constructor(client: TelemetryClient, name: string) {
     const meter = client.getMeter(name);
 
-    this.txFromProposalCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_PROPOSALS_COUNT, {
-      description: 'The number of txs taken from block proposals',
-    });
+    this.txFromProposalCount = createUpDownCounterWithDefault(meter, Metrics.TX_PROVIDER_TXS_FROM_PROPOSALS_COUNT);
+
+    this.txFromMempoolCount = createUpDownCounterWithDefault(meter, Metrics.TX_PROVIDER_TXS_FROM_MEMPOOL_COUNT);
+
+    this.txFromP2PCount = createUpDownCounterWithDefault(meter, Metrics.TX_PROVIDER_TXS_FROM_P2P_COUNT);
 
-    this.txFromMempoolCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_MEMPOOL_COUNT, {
-      description: 'The number of txs taken from the local mempool',
-    });
+    this.missingTxsCount = createUpDownCounterWithDefault(meter, Metrics.TX_PROVIDER_MISSING_TXS_COUNT);
 
-    this.txFromP2PCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_P2P_COUNT, {
-      description: 'The number of txs taken from the p2p network',
-    });
+    this.fractionOfTxsRequestedFromP2P = meter.createHistogram(Metrics.TX_PROVIDER_P2P_TXS_REQUESTED_FRACTION);
 
-    this.missingTxsCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_MISSING_TXS_COUNT, {
-      description: 'The number of txs not found anywhere',
-    });
+    this.txsRequestDelay = meter.createHistogram(Metrics.TX_PROVIDER_P2P_TXS_REQUEST_DELAY);
   }
 
   incTxsFromProposals(count: number) {
@@ -34,8 +39,13 @@ export class TxProviderInstrumentation {
     this.txFromMempoolCount.add(count);
   }
 
-  incTxsFromP2P(count: number) {
+  incTxsFromP2P(count: number, total: number) {
     this.txFromP2PCount.add(count);
+    this.fractionOfTxsRequestedFromP2P.record(count / total);
+  }
+
+  recordTxsRequestDelay(delay: number) {
+    this.txsRequestDelay.record(delay);
   }
 
   incMissingTxs(count: number) {

package/src/test-helpers/index.ts

@@ -4,3 +4,5 @@ export * from './make-enrs.js';
 export * from './make-test-p2p-clients.js';
 export * from './reqresp-nodes.js';
 export * from './mock-pubsub.js';
+export * from './test_tx_provider.js';
+export * from './testbench-utils.js';

package/src/test-helpers/mock-pubsub.ts

@@ -39,7 +39,7 @@ export function getMockPubSubP2PServiceFactory<T extends P2PClientType>(
     peerId: PeerId,
     deps: {
       packageVersion: string;
-      mempools: MemPools<T>;
+      mempools: MemPools;
       l2BlockSource: L2BlockSource & ContractDataSource;
       epochCache: EpochCacheInterface;
       proofVerifier: ClientProtocolCircuitVerifier;

package/src/test-helpers/mock-tx-helpers.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
 import { mockTx } from '@aztec/stdlib/testing';

package/src/test-helpers/reqresp-nodes.ts

@@ -112,7 +112,7 @@ export async function createTestLibP2PService<T extends P2PClientType>(
   archiver: L2BlockSource & ContractDataSource,
   worldStateSynchronizer: WorldStateSynchronizer,
   epochCache: EpochCache,
-  mempools: MemPools<T>,
+  mempools: MemPools,
   telemetry: TelemetryClient,
   port: number = 0,
   peerId?: PeerId,

package/src/test-helpers/test_tx_provider.ts

@@ -0,0 +1,64 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { ITxProvider } from '@aztec/stdlib/interfaces/server';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+
+/**
+ * Test transaction provider that can be seeded with transactions.
+ * Returns seeded txs when requested by hash, useful for testing block
+ * proposal handling without requiring a full P2P network.
+ */
+export class TestTxProvider implements ITxProvider {
+  private txs: Map<string, Tx> = new Map();
+
+  /** Seed transactions that will be returned when requested. */
+  seed(txs: Tx[]) {
+    for (const tx of txs) {
+      this.txs.set(tx.getTxHash().toString(), tx);
+    }
+  }
+
+  /** Clear all seeded transactions. */
+  clear() {
+    this.txs.clear();
+  }
+
+  /** Returns txs from the seeded collection given their hashes. */
+  getAvailableTxs(txHashes: TxHash[]): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    return this.getTxsByHashes(txHashes);
+  }
+
+  /** Get txs for a block proposal, returning any seeded txs that match the requested hashes. */
+  getTxsForBlockProposal(
+    blockProposal: BlockProposal,
+    _blockNumber: BlockNumber,
+    _opts: { pinnedPeer: PeerId | undefined; deadline: Date },
+  ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    return this.getTxsByHashes(blockProposal.txHashes);
+  }
+
+  /** Get txs for a block, returning any seeded txs that match the tx effects in the block. */
+  getTxsForBlock(block: L2Block, _opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    const txHashes = block.body.txEffects.map(txEffect => txEffect.txHash);
+    return this.getTxsByHashes(txHashes);
+  }
+
+  private getTxsByHashes(txHashes: TxHash[]): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    const txs: Tx[] = [];
+    const missingTxs: TxHash[] = [];
+
+    for (const txHash of txHashes) {
+      const tx = this.txs.get(txHash.toString());
+      if (tx) {
+        txs.push(tx);
+      } else {
+        missingTxs.push(txHash);
+      }
+    }
+
+    return Promise.resolve({ txs, missingTxs });
+  }
+}

package/src/test-helpers/testbench-utils.ts

@@ -0,0 +1,374 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type BlockNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { Logger } from '@aztec/foundation/log';
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type {
+  BlockProposal,
+  CheckpointAttestation,
+  CheckpointProposal,
+  CheckpointProposalCore,
+} from '@aztec/stdlib/p2p';
+import { type BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
+
+import EventEmitter from 'events';
+
+import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
+import type { TxPool } from '../mem_pools/tx_pool/index.js';
+import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.js';
+
+/**
+ * In-memory TxPool implementation for testing.
+ * Provides basic tx storage without persistence.
+ */
+export class InMemoryTxPool extends EventEmitter implements TxPool {
+  private txsByHash = new Map<string, Tx>();
+  private logger: Logger | null = null;
+
+  setLogger(logger: Logger): void {
+    this.logger = logger;
+  }
+
+  setTxs(txs: Tx[]): number {
+    this.txsByHash.clear();
+    return this.appendTxs(txs);
+  }
+
+  appendTxs(txs: Tx[]): number {
+    let added = 0;
+    for (const tx of txs) {
+      const key = tx.getTxHash().toString();
+      if (!this.txsByHash.has(key)) {
+        added += 1;
+      }
+      this.txsByHash.set(key, tx);
+    }
+    return added;
+  }
+
+  clearTxs(): void {
+    this.txsByHash.clear();
+  }
+
+  resetState(): void {
+    this.txsByHash.clear();
+    this.removeAllListeners();
+  }
+
+  addTxs(txs: Tx[], opts?: { source?: string }): Promise<number> {
+    const newTxs: Tx[] = [];
+    let added = 0;
+    for (const tx of txs) {
+      const key = tx.getTxHash().toString();
+      if (!this.txsByHash.has(key)) {
+        newTxs.push(tx);
+        added += 1;
+      }
+      this.txsByHash.set(key, tx);
+    }
+    if (newTxs.length > 0) {
+      this.emit('txs-added', { txs: newTxs, source: opts?.source });
+    }
+    return Promise.resolve(added);
+  }
+
+  getTxByHash(hash: TxHash): Promise<Tx | undefined> {
+    return Promise.resolve(this.txsByHash.get(hash.toString()));
+  }
+
+  getTxsByHash(hashes: TxHash[]): Promise<(Tx | undefined)[]> {
+    const result = hashes.map(h => this.txsByHash.get(h.toString()));
+    const found = result.filter(tx => tx !== undefined).length;
+    this.logger?.debug(`[TxPool] getTxsByHash: requested ${hashes.length}, found ${found}`);
+    return Promise.resolve(result);
+  }
+
+  hasTxs(hashes: TxHash[]): Promise<boolean[]> {
+    return Promise.resolve(hashes.map(h => this.txsByHash.has(h.toString())));
+  }
+
+  hasTx(hash: TxHash): Promise<boolean> {
+    return Promise.resolve(this.txsByHash.has(hash.toString()));
+  }
+
+  getArchivedTxByHash(_hash: TxHash): Promise<Tx | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  async markAsMined(_txHashes: TxHash[], _blockHeader: BlockHeader): Promise<void> {}
+
+  async markMinedAsPending(_txHashes: TxHash[], _latestBlock: BlockNumber): Promise<void> {}
+
+  deleteTxs(txHashes: TxHash[], _opts?: { permanently?: boolean }): Promise<void> {
+    for (const txHash of txHashes) {
+      this.txsByHash.delete(txHash.toString());
+    }
+    return Promise.resolve();
+  }
+
+  getAllTxs(): Promise<Tx[]> {
+    return Promise.resolve([...this.txsByHash.values()]);
+  }
+
+  getAllTxHashes(): Promise<TxHash[]> {
+    return Promise.resolve([...this.txsByHash.keys()].map(key => TxHash.fromString(key)));
+  }
+
+  getPendingTxHashes(): Promise<TxHash[]> {
+    return Promise.resolve([...this.txsByHash.keys()].map(key => TxHash.fromString(key)));
+  }
+
+  getPendingTxCount(): Promise<number> {
+    return Promise.resolve(this.txsByHash.size);
+  }
+
+  getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: BlockNumber][]> {
+    return Promise.resolve([]);
+  }
+
+  getTxStatus(hash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined> {
+    return Promise.resolve(this.txsByHash.has(hash.toString()) ? 'pending' : undefined);
+  }
+
+  updateConfig(_config: { maxPendingTxCount?: number; archivedTxLimit?: number }): void {}
+
+  isEmpty(): Promise<boolean> {
+    return Promise.resolve(this.txsByHash.size === 0);
+  }
+
+  async markTxsAsNonEvictable(_txHashes: TxHash[]): Promise<void> {}
+
+  async clearNonEvictableTxs(): Promise<void> {}
+
+  cleanupDeletedMinedTxs(_blockNumber: BlockNumber): Promise<number> {
+    return Promise.resolve(0);
+  }
+}
+
+/**
+ * In-memory AttestationPool implementation for testing.
+ */
+export class InMemoryAttestationPool implements AttestationPool {
+  private proposals = new Map<string, BlockProposal>();
+
+  addBlockProposal(blockProposal: BlockProposal): Promise<void> {
+    this.proposals.set(blockProposal.archive.toString(), blockProposal);
+    return Promise.resolve();
+  }
+
+  getBlockProposal(id: string): Promise<BlockProposal | undefined> {
+    return Promise.resolve(this.proposals.get(id));
+  }
+
+  hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean> {
+    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.archive.toString();
+    return Promise.resolve(this.proposals.has(id));
+  }
+
+  canAddProposal(_block: BlockProposal): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
+  async addCheckpointProposal(_proposal: CheckpointProposal): Promise<void> {}
+
+  getCheckpointProposal(_id: string): Promise<CheckpointProposalCore | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  hasCheckpointProposal(_idOrProposal: string | CheckpointProposal): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  async addCheckpointAttestations(_attestations: CheckpointAttestation[]): Promise<void> {}
+
+  async deleteCheckpointAttestationsOlderThan(_slot: SlotNumber): Promise<void> {}
+
+  getCheckpointAttestationsForSlot(_slot: SlotNumber): Promise<CheckpointAttestation[]> {
+    return Promise.resolve([]);
+  }
+
+  getCheckpointAttestationsForSlotAndProposal(
+    _slot: SlotNumber,
+    _proposalId: string,
+  ): Promise<CheckpointAttestation[]> {
+    return Promise.resolve([]);
+  }
+
+  hasCheckpointAttestation(_attestation: CheckpointAttestation): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  canAddCheckpointProposal(_proposal: CheckpointProposal): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
+  canAddCheckpointAttestation(_attestation: CheckpointAttestation, _committeeSize: number): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
+  hasReachedCheckpointProposalCap(_slot: SlotNumber): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  hasReachedCheckpointAttestationCap(_slot: SlotNumber, _proposalId: string, _committeeSize: number): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  isEmpty(): Promise<boolean> {
+    return Promise.resolve(this.proposals.size === 0);
+  }
+
+  resetState(): void {
+    this.proposals.clear();
+  }
+}
+
+/**
+ * Creates a mock EpochCache for testing.
+ */
+export function createMockEpochCache(): EpochCacheInterface {
+  return {
+    getCommittee: () => Promise.resolve({ committee: [], seed: 1n, epoch: EpochNumber.ZERO, isEscapeHatchOpen: false }),
+    getProposerIndexEncoding: () => '0x' as `0x${string}`,
+    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([]),
+  };
+}
+
+/**
+ * Creates a mock WorldStateSynchronizer for testing.
+ */
+export function createMockWorldStateSynchronizer(): WorldStateSynchronizer {
+  return {
+    status: () =>
+      Promise.resolve({
+        syncSummary: {
+          latestBlockNumber: 0,
+          latestBlockHash: '',
+          finalizedBlockNumber: 0,
+          treesAreSynched: false,
+          oldestHistoricBlockNumber: 0,
+        },
+      }),
+  } as WorldStateSynchronizer;
+}
+
+/**
+ * Unlimited rate limit configuration for benchmarks.
+ */
+export const UNLIMITED_RATE_LIMIT_QUOTA = {
+  peerLimit: { quotaTimeMs: 1000, quotaCount: 10_000 },
+  globalLimit: { quotaTimeMs: 1000, quotaCount: 100_000 },
+};
+
+/**
+ * Installs unlimited rate limits on a ReqResp instance.
+ * Used in benchmarks to avoid rate limiting affecting results.
+ *
+ * Note: Uses `as any` because rateLimiter is private. This is acceptable
+ * in test code where we need to override internal behavior.
+ */
+export function installUnlimitedRateLimitsOnReqResp(reqResp: any): void {
+  const rateLimiter = reqResp.rateLimiter;
+  rateLimiter.getRateLimits = () => UNLIMITED_RATE_LIMIT_QUOTA;
+  rateLimiter.allow = () => RateLimitStatus.Allowed;
+}
+
+/**
+ * Distribution patterns for benchmark transaction distribution.
+ */
+export type DistributionPattern = 'uniform' | 'sparse' | 'pinned-only';
+
+/**
+ * Collector implementation types for benchmarking.
+ */
+export type CollectorType = 'batch-requester' | 'send-batch-request';
+
+/**
+ * Display names for collector types (for output/logging only).
+ */
+export const COLLECTOR_DISPLAY_NAMES: Record<CollectorType, string> = {
+  'batch-requester': 'batch-requester (new)',
+  'send-batch-request': 'send-batch-request (old)',
+};
+
+/**
+ * Benchmark timing constants.
+ */
+export const BENCHMARK_CONSTANTS = {
+  /** Time to wait for peers to connect before starting benchmark */
+  PEER_DISCOVERY_WAIT_MS: 10_000,
+  /** Maximum time to wait for peer connections */
+  MAX_PEER_WAIT_MS: 60_000,
+  /** Interval between peer connection checks */
+  PEER_CHECK_INTERVAL_MS: 500,
+  /** Default worker ready timeout */
+  WORKER_READY_TIMEOUT_MS: 30_000,
+  /** Graceful shutdown timeout before force kill */
+  GRACEFUL_SHUTDOWN_TIMEOUT_MS: 5_000,
+  /** Overall cleanup timeout */
+  CLEANUP_TIMEOUT_MS: 10_000,
+  /** Buffer time for internal timeout to ensure we return before outer timeout */
+  TIMEOUT_BUFFER_MS: 5_000,
+  /** Minimum internal timeout regardless of buffer */
+  MIN_INTERNAL_TIMEOUT_MS: 1_000,
+  /** Fixed max peers for fair benchmarking */
+  FIXED_MAX_PEERS: 10,
+  /** Fixed max retry attempts for fair benchmarking */
+  FIXED_MAX_RETRY_ATTEMPTS: 3,
+  /** LMDB map size for temp stores used in benchmarks (in KB). */
+  KV_STORE_MAP_SIZE_KB: 256 * 1024,
+} as const;
+
+/**
+ * Filters transactions based on distribution pattern for benchmark responders.
+ *
+ * @param allTxs - All transactions to filter
+ * @param peerIndex - Index of the current peer (0 = aggregator)
+ * @param peerCount - Total number of peers
+ * @param distribution - Distribution pattern to apply
+ * @param pinnedPeerIndex - Index of the pinned peer (for pinned-only distribution)
+ * @returns Filtered transactions for this peer
+ */
+export function filterTxsByDistribution(
+  allTxs: Tx[],
+  peerIndex: number,
+  peerCount: number,
+  distribution: DistributionPattern,
+  pinnedPeerIndex: number = 1,
+): Tx[] {
+  if (peerIndex === 0) {
+    return [];
+  }
+
+  const responderCount = peerCount - 1;
+
+  switch (distribution) {
+    case 'uniform':
+      return allTxs;
+
+    case 'sparse': {
+      const responderIndex = peerIndex - 1;
+      return allTxs.filter((_, txIndex) => {
+        const bucket = txIndex % responderCount;
+        return bucket === responderIndex || bucket === (responderIndex + 1) % responderCount;
+      });
+    }
+
+    case 'pinned-only':
+      return peerIndex === pinnedPeerIndex ? allTxs : [];
+  }
+}
+
+/**
+ * Calculates the internal timeout for collector operations.
+ * Ensures we return before the outer timeout while maintaining a minimum.
+ */
+export function calculateInternalTimeout(timeoutMs: number): number {
+  return Math.max(timeoutMs - BENCHMARK_CONSTANTS.TIMEOUT_BUFFER_MS, BENCHMARK_CONSTANTS.MIN_INTERNAL_TIMEOUT_MS);
+}