@aztec/p2p 0.0.1-commit.e558bd1c → 0.0.1-commit.e5a3663dd

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

@@ -1,6 +1,7 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { type BlockNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import type { Logger } from '@aztec/foundation/log';
+import type { L2Block, L2BlockId } from '@aztec/stdlib/block';
 import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import type {
   BlockProposal,
@@ -13,14 +14,16 @@ import { type BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 import EventEmitter from 'events';
 
 import type { TryAddResult } from '../mem_pools/attestation_pool/attestation_pool.js';
-import type { TxPool } from '../mem_pools/tx_pool/index.js';
+import type { AddTxsResult, TxPoolV2, TxPoolV2Config } from '../mem_pools/tx_pool_v2/interfaces.js';
+import type { TxState } from '../mem_pools/tx_pool_v2/tx_metadata.js';
 import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.js';
 
 /**
  * In-memory TxPool implementation for testing.
  * Provides basic tx storage without persistence.
+ * Implements TxPoolV2 interface with stub implementations for testing.
  */
-export class InMemoryTxPool extends EventEmitter implements TxPool {
+export class InMemoryTxPool extends EventEmitter implements TxPoolV2 {
   private txsByHash = new Map<string, Tx>();
   private logger: Logger | null = null;
 
@@ -54,93 +57,154 @@ export class InMemoryTxPool extends EventEmitter implements TxPool {
     this.removeAllListeners();
   }
 
-  addTxs(txs: Tx[], opts?: { source?: string }): Promise<number> {
+  // === Core Operations (TxPoolV2) ===
+
+  addPendingTxs(txs: Tx[], opts?: { source?: string; feeComparisonOnly?: boolean }): Promise<AddTxsResult> {
+    const accepted: TxHash[] = [];
     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;
+        accepted.push(tx.getTxHash());
       }
       this.txsByHash.set(key, tx);
     }
     if (newTxs.length > 0) {
       this.emit('txs-added', { txs: newTxs, source: opts?.source });
     }
-    return Promise.resolve(added);
+    return Promise.resolve({ accepted, ignored: [], rejected: [] });
   }
 
-  getTxByHash(hash: TxHash): Promise<Tx | undefined> {
-    return Promise.resolve(this.txsByHash.get(hash.toString()));
+  canAddPendingTx(tx: Tx): Promise<'accepted' | 'ignored'> {
+    const key = tx.getTxHash().toString();
+    if (this.txsByHash.has(key)) {
+      return Promise.resolve('ignored');
+    }
+    return Promise.resolve('accepted');
   }
 
-  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);
+  addProtectedTxs(txs: Tx[], _block: BlockHeader, opts?: { source?: string }): Promise<void> {
+    for (const tx of txs) {
+      const key = tx.getTxHash().toString();
+      this.txsByHash.set(key, tx);
+    }
+    if (txs.length > 0) {
+      this.emit('txs-added', { txs, source: opts?.source });
+    }
+    return Promise.resolve();
   }
 
-  hasTxs(hashes: TxHash[]): Promise<boolean[]> {
-    return Promise.resolve(hashes.map(h => this.txsByHash.has(h.toString())));
+  protectTxs(txHashes: TxHash[], _block: BlockHeader): Promise<TxHash[]> {
+    const notFound: TxHash[] = [];
+    for (const txHash of txHashes) {
+      if (!this.txsByHash.has(txHash.toString())) {
+        notFound.push(txHash);
+      }
+    }
+    return Promise.resolve(notFound);
   }
 
-  hasTx(hash: TxHash): Promise<boolean> {
-    return Promise.resolve(this.txsByHash.has(hash.toString()));
+  addMinedTxs(txs: Tx[], _block: BlockHeader, _opts?: { source?: string }): Promise<void> {
+    for (const tx of txs) {
+      const key = tx.getTxHash().toString();
+      this.txsByHash.set(key, tx);
+    }
+    return Promise.resolve();
   }
 
-  getArchivedTxByHash(_hash: TxHash): Promise<Tx | undefined> {
-    return Promise.resolve(undefined);
+  // === State Transition Handlers (TxPoolV2) ===
+
+  handleMinedBlock(_block: L2Block): Promise<void> {
+    return Promise.resolve();
   }
 
-  async markAsMined(_txHashes: TxHash[], _blockHeader: BlockHeader): Promise<void> {}
+  prepareForSlot(_slotNumber: SlotNumber): Promise<void> {
+    return Promise.resolve();
+  }
 
-  async markMinedAsPending(_txHashes: TxHash[], _latestBlock: BlockNumber): Promise<void> {}
+  handlePrunedBlocks(_latestBlock: L2BlockId, _options?: { deleteAllTxs?: boolean }): Promise<void> {
+    return Promise.resolve();
+  }
 
-  deleteTxs(txHashes: TxHash[], _opts?: { permanently?: boolean }): Promise<void> {
+  handleFailedExecution(txHashes: TxHash[]): Promise<void> {
     for (const txHash of txHashes) {
       this.txsByHash.delete(txHash.toString());
     }
     return Promise.resolve();
   }
 
-  getAllTxs(): Promise<Tx[]> {
-    return Promise.resolve([...this.txsByHash.values()]);
+  handleFinalizedBlock(_block: BlockHeader): Promise<void> {
+    return Promise.resolve();
   }
 
-  getAllTxHashes(): Promise<TxHash[]> {
-    return Promise.resolve([...this.txsByHash.keys()].map(key => TxHash.fromString(key)));
+  // === Query Operations (TxPoolV2) ===
+
+  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())));
+  }
+
+  getArchivedTxByHash(_hash: TxHash): Promise<Tx | undefined> {
+    return Promise.resolve(undefined);
   }
 
   getPendingTxHashes(): Promise<TxHash[]> {
     return Promise.resolve([...this.txsByHash.keys()].map(key => TxHash.fromString(key)));
   }
 
+  getEligiblePendingTxHashes(): Promise<TxHash[]> {
+    return this.getPendingTxHashes();
+  }
+
   getPendingTxCount(): Promise<number> {
     return Promise.resolve(this.txsByHash.size);
   }
 
-  getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: BlockNumber][]> {
+  getMinedTxHashes(): Promise<[TxHash, L2BlockId][]> {
     return Promise.resolve([]);
   }
 
-  getTxStatus(hash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined> {
-    return Promise.resolve(this.txsByHash.has(hash.toString()) ? 'pending' : undefined);
+  getMinedTxCount(): Promise<number> {
+    return Promise.resolve(0);
   }
 
-  updateConfig(_config: { maxPendingTxCount?: number; archivedTxLimit?: number }): void {}
+  getTxStatus(hash: TxHash): Promise<TxState | 'deleted' | undefined> {
+    return Promise.resolve(this.txsByHash.has(hash.toString()) ? 'pending' : undefined);
+  }
 
   isEmpty(): Promise<boolean> {
     return Promise.resolve(this.txsByHash.size === 0);
   }
 
-  async markTxsAsNonEvictable(_txHashes: TxHash[]): Promise<void> {}
+  getLowestPriorityPending(_limit: number): Promise<TxHash[]> {
+    return Promise.resolve([]);
+  }
 
-  async clearNonEvictableTxs(): Promise<void> {}
+  // === Configuration (TxPoolV2) ===
 
-  cleanupDeletedMinedTxs(_blockNumber: BlockNumber): Promise<number> {
-    return Promise.resolve(0);
+  updateConfig(_config: Partial<TxPoolV2Config>): Promise<void> {
+    return Promise.resolve();
+  }
+
+  // === Lifecycle (TxPoolV2) ===
+
+  start(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  stop(): Promise<void> {
+    return Promise.resolve();
   }
 }
 
@@ -155,10 +219,10 @@ export class InMemoryAttestationPool {
     const id = blockProposal.archive.toString();
     const alreadyExists = this.proposals.has(id);
     if (alreadyExists) {
-      return Promise.resolve({ added: false, alreadyExists: true, totalForPosition: 1 });
+      return Promise.resolve({ added: false, alreadyExists: true, count: 1 });
     }
     this.proposals.set(id, blockProposal);
-    return Promise.resolve({ added: true, alreadyExists: false, totalForPosition: 1 });
+    return Promise.resolve({ added: true, alreadyExists: false, count: 1 });
   }
 
   getBlockProposal(id: string): Promise<BlockProposal | undefined> {
@@ -166,7 +230,7 @@ export class InMemoryAttestationPool {
   }
 
   tryAddCheckpointProposal(_proposal: CheckpointProposal): Promise<TryAddResult> {
-    return Promise.resolve({ added: true, alreadyExists: false, totalForPosition: 1 });
+    return Promise.resolve({ added: true, alreadyExists: false, count: 1 });
   }
 
   getCheckpointProposal(_id: string): Promise<CheckpointProposalCore | undefined> {
@@ -188,8 +252,12 @@ export class InMemoryAttestationPool {
     return Promise.resolve([]);
   }
 
-  tryAddCheckpointAttestation(_attestation: CheckpointAttestation, _committeeSize: number): Promise<TryAddResult> {
-    return Promise.resolve({ added: true, alreadyExists: false, totalForPosition: 1 });
+  tryAddCheckpointAttestation(_attestation: CheckpointAttestation): Promise<TryAddResult> {
+    return Promise.resolve({ added: true, alreadyExists: false, count: 1 });
+  }
+
+  hasBlockProposalsForSlot(_slot: SlotNumber): Promise<boolean> {
+    return Promise.resolve(false);
   }
 
   isEmpty(): Promise<boolean> {
@@ -205,18 +273,54 @@ export class InMemoryAttestationPool {
  * Creates a mock EpochCache for testing.
  */
 export function createMockEpochCache(): EpochCacheInterface {
-  return {
+  const cache: EpochCacheInterface = {
     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 }),
+    getSlotNow: () => SlotNumber.ZERO,
+    getTargetSlot: () => SlotNumber.ZERO,
+    getEpochNow: () => EpochNumber.ZERO,
+    getTargetEpoch: () => EpochNumber.ZERO,
+    getEpochAndSlotNow: () => ({
+      epoch: EpochNumber.ZERO,
+      slot: SlotNumber.ZERO,
+      ts: 0n,
+      nowMs: 0n,
+    }),
+    isProposerPipeliningEnabled: () => false,
+    pipeliningOffset: () => 0,
     computeProposerIndex: () => 0n,
     getCurrentAndNextSlot: () => ({ currentSlot: SlotNumber.ZERO, nextSlot: SlotNumber.ZERO }),
+    getTargetAndNextSlot: () => ({ targetSlot: SlotNumber.ZERO, nextSlot: SlotNumber.ZERO }),
     getProposerAttesterAddressInSlot: () => Promise.resolve(undefined),
-    getEpochAndSlotInNextL1Slot: () => ({ epoch: EpochNumber.ZERO, slot: SlotNumber.ZERO, ts: 0n, now: 0n }),
+    getEpochAndSlotInNextL1Slot: () => ({
+      epoch: EpochNumber.ZERO,
+      slot: SlotNumber.ZERO,
+      ts: 0n,
+      nowSeconds: 0n,
+    }),
+    getTargetEpochAndSlotInNextL1Slot: () => ({
+      epoch: EpochNumber.ZERO,
+      slot: SlotNumber.ZERO,
+      ts: 0n,
+      nowSeconds: 0n,
+    }),
     isInCommittee: () => Promise.resolve(false),
     getRegisteredValidators: () => Promise.resolve([]),
     filterInCommittee: () => Promise.resolve([]),
+    isEscapeHatchOpen: () => Promise.resolve(false),
+    isEscapeHatchOpenAtSlot: () => Promise.resolve(false),
+    getL1Constants: () => ({
+      l1StartBlock: 0n,
+      l1GenesisTime: 0n,
+      epochDuration: 1,
+      slotDuration: 1,
+      ethereumSlotDuration: 1,
+      proofSubmissionEpochs: 1,
+      targetCommitteeSize: 48,
+      rollupManaLimit: Number.MAX_SAFE_INTEGER,
+    }),
   };
+  return cache;
 }
 
 /**

package/src/testbench/p2p_client_testbench_worker.ts

@@ -12,14 +12,15 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider, Timer } from '@aztec/foundation/timer';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 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 type { L2BlockSource } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { GasFees } from '@aztec/stdlib/gas';
 import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { type BlockProposal, P2PClientType, P2PMessage } from '@aztec/stdlib/p2p';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
+import { type BlockProposal, P2PMessage } from '@aztec/stdlib/p2p';
 import { ChonkProof } from '@aztec/stdlib/proofs';
 import { makeAztecAddress, makeBlockHeader, makeBlockProposal, mockTx } from '@aztec/stdlib/testing';
 import { Tx, TxHash, type TxValidationResult } from '@aztec/stdlib/tx';
@@ -29,22 +30,19 @@ import type { Message, PeerId } from '@libp2p/interface';
 import { TopicValidatorResult } from '@libp2p/interface';
 import { peerIdFromString } from '@libp2p/peer-id';
 
-import type { P2PClient } from '../client/p2p_client.js';
+import type { P2PClient } from '../client/index.js';
 import type { P2PConfig } from '../config.js';
 import { createP2PClient } from '../index.js';
-import type { MemPools } from '../mem_pools/interface.js';
-import { LibP2PService } from '../services/libp2p/libp2p_service.js';
+import type { MemPools } from '../mem_pools/index.js';
+import { BatchTxRequesterCollector, LibP2PService, SendBatchRequestCollector } from '../services/index.js';
 import type { PeerManager } from '../services/peer-manager/peer_manager.js';
 import type { BatchTxRequesterLibP2PService } from '../services/reqresp/batch-tx-requester/interface.js';
 import type { IBatchRequestTxValidator } from '../services/reqresp/batch-tx-requester/tx_validator.js';
 import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.js';
 import type { ReqResp } from '../services/reqresp/reqresp.js';
 import type { PeerDiscoveryService } from '../services/service.js';
-import {
-  BatchTxRequesterCollector,
-  SendBatchRequestCollector,
-} from '../services/tx_collection/proposal_tx_collector.js';
-import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
+import { RequestTracker } from '../services/tx_collection/request_tracker.js';
+import { AlwaysTrueCircuitVerifier } from '../test-helpers/index.js';
 import {
   BENCHMARK_CONSTANTS,
   type CollectorType,
@@ -55,7 +53,7 @@ import {
   createMockEpochCache,
   createMockWorldStateSynchronizer,
   filterTxsByDistribution,
-} from '../test-helpers/testbench-utils.js';
+} from '../test-helpers/index.js';
 import type { PubSubLibp2p } from '../util.js';
 
 export type { DistributionPattern, CollectorType } from '../test-helpers/testbench-utils.js';
@@ -89,12 +87,11 @@ export interface BenchReadyMessage {
 }
 const txCache = new Map<number, Tx[]>();
 
-class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends LibP2PService<T> {
+class TestLibP2PService extends LibP2PService {
   private disableTxValidation: boolean;
   private gossipMessageCount = 0;
 
   constructor(
-    clientType: T,
     config: P2PConfig,
     node: PubSubLibp2p,
     peerDiscoveryService: PeerDiscoveryService,
@@ -110,7 +107,6 @@ class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends Li
     disableTxValidation = true,
   ) {
     super(
-      clientType,
       config,
       node,
       peerDiscoveryService,
@@ -121,6 +117,7 @@ class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends Li
       epochCache,
       proofVerifier,
       worldStateSynchronizer,
+      { getCurrentMinFees: () => Promise.resolve(GasFees.empty()) },
       telemetry,
       logger,
     );
@@ -144,7 +141,7 @@ class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends Li
       const txHash = tx.getTxHash();
       const txHashString = txHash.toString();
       this.logger.verbose(`Received tx ${txHashString} from external peer ${source.toString()}.`);
-      await this.mempools.txPool.addTxs([tx]);
+      await this.mempools.txPool.addPendingTxs([tx]);
     } else {
       await super.handleGossipedTx(payload, msgId, source);
     }
@@ -166,7 +163,7 @@ async function generateDeterministicTxs(txCount: number, seed: number, config: P
     return cached.slice(0, txCount);
   }
 
-  const includeByTimestampBase = BigInt(seed);
+  const expirationTimestampBase = BigInt(seed);
   for (let i = cached.length; i < txCount; i++) {
     const txSeed = seed * 10000 + i;
     const tx = await mockTx(txSeed, {
@@ -182,7 +179,7 @@ async function generateDeterministicTxs(txCount: number, seed: number, config: P
       hasPublicTeardownCallRequest: false,
       publicCalldataSize: 0,
     });
-    tx.data.includeByTimestamp = includeByTimestampBase + BigInt(i);
+    tx.data.expirationTimestamp = expirationTimestampBase + BigInt(i);
     await tx.recomputeHash();
     cached.push(tx);
   }
@@ -209,6 +206,25 @@ function installUnlimitedRateLimits(client: P2PClient): void {
   rateLimiter.allow = () => RateLimitStatus.Allowed;
 }
 
+/** Resets peer scores to prevent cross-case contamination in benchmarks. */
+function resetPeerScores(client: P2PClient): void {
+  const peerManager = (client as any).p2pService.peerManager;
+  const peerScoring = peerManager?.peerScoring;
+  if (peerScoring?.resetAllScores) {
+    peerScoring.resetAllScores();
+  }
+}
+
+/** Returns the number of connected peers for connectivity checks. */
+function getConnectedPeerCount(client: P2PClient): number {
+  const p2pService = (client as any).p2pService;
+  const connectionSampler = p2pService?.reqresp?.getConnectionSampler?.();
+  if (connectionSampler?.getPeerListSortedByConnectionCountAsc) {
+    return connectionSampler.getPeerListSortedByConnectionCountAsc().length;
+  }
+  return 0;
+}
+
 async function runAggregatorBenchmark(
   client: P2PClient,
   blockProposal: BlockProposal,
@@ -277,7 +293,11 @@ async function runAggregatorBenchmark(
         new DateProvider(),
         noopTxValidator,
       );
-      const fetchedTxs = await collector.collectTxs(txHashes, blockProposal, pinnedPeer, timeoutMs);
+      const fetchedTxs = await collector.collectTxs(
+        RequestTracker.create(txHashes, new Date(Date.now() + timeoutMs)),
+        blockProposal,
+        pinnedPeer,
+      );
       const durationMs = timer.ms();
       return {
         type: 'BENCH_RESULT',
@@ -292,7 +312,11 @@ async function runAggregatorBenchmark(
       BENCHMARK_CONSTANTS.FIXED_MAX_PEERS,
       BENCHMARK_CONSTANTS.FIXED_MAX_RETRY_ATTEMPTS,
     );
-    const fetchedTxs = await collector.collectTxs(txHashes, blockProposal, pinnedPeer, timeoutMs);
+    const fetchedTxs = await collector.collectTxs(
+      RequestTracker.create(txHashes, new Date(Date.now() + timeoutMs)),
+      blockProposal,
+      pinnedPeer,
+    );
     const durationMs = timer.ms();
     return {
       type: 'BENCH_RESULT',
@@ -318,6 +342,37 @@ let workerConfig: P2PConfig | null = null;
 let workerLogger: Logger | null = null;
 let kvStore: Awaited<ReturnType<typeof openTmpStore>> | null = 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: number = 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 => {
   const {
@@ -335,6 +390,7 @@ process.on('message', async msg => {
       const config: P2PConfig = {
         ...rawConfig,
         peerIdPrivateKey: rawConfig.peerIdPrivateKey ? new SecretValue(rawConfig.peerIdPrivateKey) : undefined,
+        priceBumpPercentage: 10n,
       } as P2PConfig;
 
       workerConfig = config;
@@ -358,12 +414,12 @@ process.on('message', async msg => {
       };
 
       const client = await createP2PClient(
-        P2PClientType.Full,
         config as P2PConfig & DataStoreConfig,
         l2BlockSource,
         proofVerifier as ClientProtocolCircuitVerifier,
         worldState,
         epochCache,
+        { getCurrentMinFees: () => Promise.resolve(GasFees.empty()) },
         'test-p2p-bench-worker',
         undefined,
         telemetry as TelemetryClient,
@@ -371,7 +427,6 @@ process.on('message', async msg => {
       );
 
       const testService = new TestLibP2PService(
-        P2PClientType.Full,
         config,
         (client as any).p2pService.node,
         (client as any).p2pService.peerDiscoveryService,
@@ -408,13 +463,8 @@ process.on('message', async msg => {
     const cmd = msg as any;
     switch (cmd.type) {
       case 'STOP':
-        if (workerClient) {
-          await workerClient.stop();
-        }
-        if (kvStore?.close) {
-          await kvStore.close();
-        }
-        process.exit(0);
+        await stopWorker();
+        gracefulExit(0);
         break;
 
       case 'SEND_TX':
@@ -424,6 +474,13 @@ process.on('message', async msg => {
         }
         break;
 
+      case 'GET_PEER_COUNT':
+        process.send!({
+          type: 'PEER_COUNT',
+          count: workerClient ? getConnectedPeerCount(workerClient) : 0,
+        });
+        break;
+
       case 'BENCH_REQRESP': {
         const benchCmd = cmd as BenchReqRespCommand;
         if (!workerClient || !workerTxPool || !workerAttestationPool || !workerConfig || !workerLogger) {
@@ -440,6 +497,7 @@ process.on('message', async msg => {
         // Reset state before each benchmark run to avoid cross-run contamination
         workerTxPool.resetState();
         workerAttestationPool.resetState();
+        resetPeerScores(workerClient);
 
         installUnlimitedRateLimits(workerClient);
 
@@ -491,7 +549,12 @@ process.on('message', async msg => {
       }
     }
   } catch (err: any) {
-    process.send!({ type: 'ERROR', error: err.message });
-    process.exit(1);
+    try {
+      process.send!({ type: 'ERROR', error: err.message });
+    } catch {
+      // IPC channel may be closed
+    }
+    await stopWorker();
+    gracefulExit(1);
   }
 });