@aztec/p2p 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/dest/test-helpers/testbench-utils.js

@@ -5,6 +5,7 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
 /**
  * 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 {
     txsByHash = new Map();
     logger = null;
@@ -33,14 +34,15 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
         this.txsByHash.clear();
         this.removeAllListeners();
     }
-    addTxs(txs, opts) {
+    // === Core Operations (TxPoolV2) ===
+    addPendingTxs(txs, opts) {
+        const accepted = [];
         const newTxs = [];
-        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);
         }
@@ -50,8 +52,71 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
                 source: opts?.source
             });
         }
-        return Promise.resolve(added);
+        return Promise.resolve({
+            accepted,
+            ignored: [],
+            rejected: []
+        });
+    }
+    canAddPendingTx(tx) {
+        const key = tx.getTxHash().toString();
+        if (this.txsByHash.has(key)) {
+            return Promise.resolve('ignored');
+        }
+        return Promise.resolve('accepted');
+    }
+    addProtectedTxs(txs, _block, opts) {
+        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();
+    }
+    protectTxs(txHashes, _block) {
+        const notFound = [];
+        for (const txHash of txHashes){
+            if (!this.txsByHash.has(txHash.toString())) {
+                notFound.push(txHash);
+            }
+        }
+        return Promise.resolve(notFound);
+    }
+    addMinedTxs(txs, _block, _opts) {
+        for (const tx of txs){
+            const key = tx.getTxHash().toString();
+            this.txsByHash.set(key, tx);
+        }
+        return Promise.resolve();
+    }
+    // === State Transition Handlers (TxPoolV2) ===
+    handleMinedBlock(_block) {
+        return Promise.resolve();
+    }
+    prepareForSlot(_slotNumber) {
+        return Promise.resolve();
+    }
+    unprotectTxs(_txHashes, _slotNumber) {
+        return Promise.resolve();
+    }
+    handlePrunedBlocks(_latestBlock, _options) {
+        return Promise.resolve();
+    }
+    handleFailedExecution(txHashes) {
+        for (const txHash of txHashes){
+            this.txsByHash.delete(txHash.toString());
+        }
+        return Promise.resolve();
+    }
+    handleFinalizedBlock(_block) {
+        return Promise.resolve();
     }
+    // === Query Operations (TxPoolV2) ===
     getTxByHash(hash) {
         return Promise.resolve(this.txsByHash.get(hash.toString()));
     }
@@ -64,52 +129,48 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
     hasTxs(hashes) {
         return Promise.resolve(hashes.map((h)=>this.txsByHash.has(h.toString())));
     }
-    hasTx(hash) {
-        return Promise.resolve(this.txsByHash.has(hash.toString()));
-    }
     getArchivedTxByHash(_hash) {
         return Promise.resolve(undefined);
     }
-    async markAsMined(_txHashes, _blockHeader) {}
-    async markMinedAsPending(_txHashes, _latestBlock) {}
-    deleteTxs(txHashes, _opts) {
-        for (const txHash of txHashes){
-            this.txsByHash.delete(txHash.toString());
-        }
-        return Promise.resolve();
-    }
-    getAllTxs() {
-        return Promise.resolve([
-            ...this.txsByHash.values()
-        ]);
-    }
-    getAllTxHashes() {
-        return Promise.resolve([
-            ...this.txsByHash.keys()
-        ].map((key)=>TxHash.fromString(key)));
-    }
     getPendingTxHashes() {
         return Promise.resolve([
             ...this.txsByHash.keys()
         ].map((key)=>TxHash.fromString(key)));
     }
+    getEligiblePendingTxHashes() {
+        return this.getPendingTxHashes();
+    }
     getPendingTxCount() {
         return Promise.resolve(this.txsByHash.size);
     }
+    async hasEligiblePendingTxs(minCount) {
+        return await this.getPendingTxCount() >= minCount;
+    }
     getMinedTxHashes() {
         return Promise.resolve([]);
     }
+    getMinedTxCount() {
+        return Promise.resolve(0);
+    }
     getTxStatus(hash) {
         return Promise.resolve(this.txsByHash.has(hash.toString()) ? 'pending' : undefined);
     }
-    updateConfig(_config) {}
     isEmpty() {
         return Promise.resolve(this.txsByHash.size === 0);
     }
-    async markTxsAsNonEvictable(_txHashes) {}
-    async clearNonEvictableTxs() {}
-    cleanupDeletedMinedTxs(_blockNumber) {
-        return Promise.resolve(0);
+    getLowestPriorityPending(_limit) {
+        return Promise.resolve([]);
+    }
+    // === Configuration (TxPoolV2) ===
+    updateConfig(_config) {
+        return Promise.resolve();
+    }
+    // === Lifecycle (TxPoolV2) ===
+    start() {
+        return Promise.resolve();
+    }
+    stop() {
+        return Promise.resolve();
     }
 }
 /**
@@ -117,6 +178,7 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
  * Provides minimal implementation without persistence.
  */ export class InMemoryAttestationPool {
     proposals = new Map();
+    checkpoints = new Map();
     tryAddBlockProposal(blockProposal) {
         const id = blockProposal.archive.toString();
         const alreadyExists = this.proposals.has(id);
@@ -124,55 +186,73 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
             return Promise.resolve({
                 added: false,
                 alreadyExists: true,
-                totalForPosition: 1
+                count: 1
             });
         }
         this.proposals.set(id, blockProposal);
         return Promise.resolve({
             added: true,
             alreadyExists: false,
-            totalForPosition: 1
+            count: 1
         });
     }
-    getBlockProposal(id) {
+    getBlockProposalByArchive(id) {
         return Promise.resolve(this.proposals.get(id));
     }
-    tryAddCheckpointProposal(_proposal) {
+    tryAddCheckpointProposal(proposal) {
+        const proposals = this.checkpoints.get(proposal.slotNumber) ?? [];
+        proposals.push(proposal);
+        this.checkpoints.set(proposal.slotNumber, proposals);
         return Promise.resolve({
             added: true,
             alreadyExists: false,
-            totalForPosition: 1
+            count: 1
         });
     }
-    getCheckpointProposal(_id) {
-        return Promise.resolve(undefined);
+    getCheckpointProposal(slot) {
+        return Promise.resolve(this.checkpoints.get(slot)?.[0]);
+    }
+    hasCheckpointProposalForSlot(slot) {
+        return Promise.resolve(this.checkpoints.has(slot));
+    }
+    getProposalsForSlot(slot) {
+        return Promise.resolve({
+            blockProposals: [
+                ...this.proposals.values()
+            ].filter((proposal)=>proposal.slotNumber === slot),
+            checkpointProposals: this.checkpoints.get(slot) ?? []
+        });
     }
     async addOwnCheckpointAttestations(_attestations) {}
     async deleteOlderThan(_slot) {}
     getCheckpointAttestationsForSlot(_slot) {
         return Promise.resolve([]);
     }
-    getCheckpointAttestationsForSlotAndProposal(_slot, _proposalId) {
+    getCheckpointAttestationsForSlotAndProposal(_slot, _proposalPayloadHash) {
         return Promise.resolve([]);
     }
-    tryAddCheckpointAttestation(_attestation, _committeeSize) {
+    tryAddCheckpointAttestation(_attestation) {
         return Promise.resolve({
             added: true,
             alreadyExists: false,
-            totalForPosition: 1
+            count: 1
         });
     }
+    hasBlockProposalsForSlot(_slot) {
+        return Promise.resolve(false);
+    }
     isEmpty() {
-        return Promise.resolve(this.proposals.size === 0);
+        return Promise.resolve(this.proposals.size === 0 && this.checkpoints.size === 0);
     }
     resetState() {
         this.proposals.clear();
+        this.checkpoints.clear();
     }
 }
 /**
  * Creates a mock EpochCache for testing.
  */ export function createMockEpochCache() {
-    return {
+    const cache = {
         getCommittee: ()=>Promise.resolve({
                 committee: [],
                 seed: 1n,
@@ -180,6 +260,10 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
                 isEscapeHatchOpen: false
             }),
         getProposerIndexEncoding: ()=>'0x',
+        getSlotNow: ()=>SlotNumber.ZERO,
+        getTargetSlot: ()=>SlotNumber.ZERO,
+        getEpochNow: ()=>EpochNumber.ZERO,
+        getTargetEpoch: ()=>EpochNumber.ZERO,
         getEpochAndSlotNow: ()=>({
                 epoch: EpochNumber.ZERO,
                 slot: SlotNumber.ZERO,
@@ -191,16 +275,28 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
                 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
+                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,
@@ -208,9 +304,11 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
                 slotDuration: 1,
                 ethereumSlotDuration: 1,
                 proofSubmissionEpochs: 1,
-                targetCommitteeSize: 48
+                targetCommitteeSize: 48,
+                rollupManaLimit: Number.MAX_SAFE_INTEGER
             })
     };
+    return cache;
 }
 /**
  * Creates a mock WorldStateSynchronizer for testing.
@@ -250,12 +348,6 @@ import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.j
     rateLimiter.getRateLimits = ()=>UNLIMITED_RATE_LIMIT_QUOTA;
     rateLimiter.allow = ()=>RateLimitStatus.Allowed;
 }
-/**
- * Display names for collector types (for output/logging only).
- */ export const COLLECTOR_DISPLAY_NAMES = {
-    'batch-requester': 'batch-requester (new)',
-    'send-batch-request': 'send-batch-request (old)'
-};
 /**
  * Benchmark timing constants.
  */ export const BENCHMARK_CONSTANTS = {

package/dest/testbench/p2p_client_testbench_worker.d.ts

@@ -1,12 +1,10 @@
-import { type CollectorType, type DistributionPattern } from '../test-helpers/testbench-utils.js';
-export type { DistributionPattern, CollectorType } from '../test-helpers/testbench-utils.js';
-export { COLLECTOR_DISPLAY_NAMES } from '../test-helpers/testbench-utils.js';
+import { type DistributionPattern } from '../test-helpers/index.js';
+export type { DistributionPattern } from '../test-helpers/testbench-utils.js';
 export interface BenchReqRespCommand {
     type: 'BENCH_REQRESP';
     txCount: number;
     peerCount: number;
     distribution: DistributionPattern;
-    collectorType: CollectorType;
     timeoutMs: number;
     isAggregator: boolean;
     peerIndex: number;
@@ -25,4 +23,4 @@ export interface BenchResultMessage {
 export interface BenchReadyMessage {
     type: 'BENCH_READY';
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicDJwX2NsaWVudF90ZXN0YmVuY2hfd29ya2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGJlbmNoL3AycF9jbGllbnRfdGVzdGJlbmNoX3dvcmtlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUErQ0EsT0FBTyxFQUVMLEtBQUssYUFBYSxFQUNsQixLQUFLLG1CQUFtQixFQU96QixNQUFNLG9DQUFvQyxDQUFDO0FBRzVDLFlBQVksRUFBRSxtQkFBbUIsRUFBRSxhQUFhLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUM3RixPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUU3RSxNQUFNLFdBQVcsbUJBQW1CO0lBQ2xDLElBQUksRUFBRSxlQUFlLENBQUM7SUFDdEIsT0FBTyxFQUFFLE1BQU0sQ0FBQztJQUNoQixTQUFTLEVBQUUsTUFBTSxDQUFDO0lBQ2xCLFlBQVksRUFBRSxtQkFBbUIsQ0FBQztJQUNsQyxhQUFhLEVBQUUsYUFBYSxDQUFDO0lBQzdCLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsWUFBWSxFQUFFLE9BQU8sQ0FBQztJQUN0QixTQUFTLEVBQUUsTUFBTSxDQUFDO0lBQ2xCLGVBQWUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN6QixZQUFZLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDdEIsV0FBVyxFQUFFLE1BQU0sQ0FBQztJQUNwQixJQUFJLEVBQUUsTUFBTSxDQUFDO0NBQ2Q7QUFFRCxNQUFNLFdBQVcsa0JBQWtCO0lBQ2pDLElBQUksRUFBRSxjQUFjLENBQUM7SUFDckIsVUFBVSxFQUFFLE1BQU0sQ0FBQztJQUNuQixZQUFZLEVBQUUsTUFBTSxDQUFDO0lBQ3JCLE9BQU8sRUFBRSxPQUFPLENBQUM7SUFDakIsS0FBSyxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ2hCO0FBRUQsTUFBTSxXQUFXLGlCQUFpQjtJQUNoQyxJQUFJLEVBQUUsYUFBYSxDQUFDO0NBQ3JCIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicDJwX2NsaWVudF90ZXN0YmVuY2hfd29ya2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGJlbmNoL3AycF9jbGllbnRfdGVzdGJlbmNoX3dvcmtlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE4Q0EsT0FBTyxFQUVMLEtBQUssbUJBQW1CLEVBT3pCLE1BQU0sMEJBQTBCLENBQUM7QUFHbEMsWUFBWSxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFFOUUsTUFBTSxXQUFXLG1CQUFtQjtJQUNsQyxJQUFJLEVBQUUsZUFBZSxDQUFDO0lBQ3RCLE9BQU8sRUFBRSxNQUFNLENBQUM7SUFDaEIsU0FBUyxFQUFFLE1BQU0sQ0FBQztJQUNsQixZQUFZLEVBQUUsbUJBQW1CLENBQUM7SUFDbEMsU0FBUyxFQUFFLE1BQU0sQ0FBQztJQUNsQixZQUFZLEVBQUUsT0FBTyxDQUFDO0lBQ3RCLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsZUFBZSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3pCLFlBQVksQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN0QixXQUFXLEVBQUUsTUFBTSxDQUFDO0lBQ3BCLElBQUksRUFBRSxNQUFNLENBQUM7Q0FDZDtBQUVELE1BQU0sV0FBVyxrQkFBa0I7SUFDakMsSUFBSSxFQUFFLGNBQWMsQ0FBQztJQUNyQixVQUFVLEVBQUUsTUFBTSxDQUFDO0lBQ25CLFlBQVksRUFBRSxNQUFNLENBQUM7SUFDckIsT0FBTyxFQUFFLE9BQU8sQ0FBQztJQUNqQixLQUFLLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDaEI7QUFFRCxNQUFNLFdBQVcsaUJBQWlCO0lBQ2hDLElBQUksRUFBRSxhQUFhLENBQUM7Q0FDckIifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"p2p_client_testbench_worker.d.ts","sourceRoot":"","sources":["../../src/testbench/p2p_client_testbench_worker.ts"],"names":[],"mappings":"AA+CA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,mBAAmB,EAOzB,MAAM,oCAAoC,CAAC;AAG5C,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAC7F,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAE7E,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,mBAAmB,CAAC;IAClC,aAAa,EAAE,aAAa,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,cAAc,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,aAAa,CAAC;CACrB"}
+{"version":3,"file":"p2p_client_testbench_worker.d.ts","sourceRoot":"","sources":["../../src/testbench/p2p_client_testbench_worker.ts"],"names":[],"mappings":"AA8CA,OAAO,EAEL,KAAK,mBAAmB,EAOzB,MAAM,0BAA0B,CAAC;AAGlC,YAAY,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAE9E,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,mBAAmB,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,cAAc,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,aAAa,CAAC;CACrB"}

package/dest/testbench/p2p_client_testbench_worker.js

@@ -13,7 +13,9 @@ 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 { 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';
@@ -21,18 +23,36 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
 import { TopicValidatorResult } from '@libp2p/interface';
 import { peerIdFromString } from '@libp2p/peer-id';
 import { createP2PClient } from '../index.js';
-import { LibP2PService } from '../services/libp2p/libp2p_service.js';
+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 { BatchTxRequesterCollector, SendBatchRequestCollector } from '../services/tx_collection/proposal_tx_collector.js';
-import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
-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';
+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 createBenchmarkEpochCache() {
+    return {
+        ...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() {
@@ -49,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 {
@@ -70,7 +90,7 @@ async function generateDeterministicTxs(txCount, seed, config) {
     if (cached.length >= txCount) {
         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, {
@@ -86,7 +106,7 @@ async function generateDeterministicTxs(txCount, seed, config) {
             hasPublicTeardownCallRequest: false,
             publicCalldataSize: 0
         });
-        tx.data.includeByTimestamp = includeByTimestampBase + BigInt(i);
+        tx.data.expirationTimestamp = expirationTimestampBase + BigInt(i);
         await tx.recomputeHash();
         cached.push(tx);
     }
@@ -110,7 +130,22 @@ function installUnlimitedRateLimits(client) {
     rateLimiter.getRateLimits = ()=>UNLIMITED_RATE_LIMIT_QUOTA;
     rateLimiter.allow = ()=>RateLimitStatus.Allowed;
 }
-async function runAggregatorBenchmark(client, blockProposal, collectorType, timeoutMs, pinnedPeerId, pinnedPeerIndex, logger, expectedPeerCount) {
+/** 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);
@@ -144,27 +179,16 @@ async function runAggregatorBenchmark(client, blockProposal, collectorType, time
             }
         }
         const noopTxValidator = {
-            validateRequestedTx: (_tx)=>Promise.resolve({
+            validateTx: (_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 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',
@@ -188,6 +212,35 @@ 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)=>{
     const { type, config: rawConfig, clientIndex } = msg;
@@ -195,14 +248,15 @@ process.on('message', async (msg)=>{
         if (type === 'START') {
             const config = {
                 ...rawConfig,
-                peerIdPrivateKey: rawConfig.peerIdPrivateKey ? new SecretValue(rawConfig.peerIdPrivateKey) : undefined
+                peerIdPrivateKey: rawConfig.peerIdPrivateKey ? new SecretValue(rawConfig.peerIdPrivateKey) : undefined,
+                priceBumpPercentage: 10n
             };
             workerConfig = config;
             workerTxPool = new InMemoryTxPool();
             workerAttestationPool = new InMemoryAttestationPool();
-            const epochCache = createMockEpochCache();
+            const epochCache = createBenchmarkEpochCache();
             const worldState = createMockWorldStateSynchronizer();
-            const l2BlockSource = new MockL2BlockSource();
+            const l2BlockSource = new TestbenchL2BlockSource();
             const proofVerifier = new AlwaysTrueCircuitVerifier();
             kvStore = await openTmpStore(`test-${clientIndex}`, true, BENCHMARK_CONSTANTS.KV_STORE_MAP_SIZE_KB);
             workerLogger = createLogger(`p2p:${clientIndex}`);
@@ -214,8 +268,10 @@ process.on('message', async (msg)=>{
                 store: kvStore,
                 logger: workerLogger
             };
-            const client = await createP2PClient(P2PClientType.Full, config, l2BlockSource, proofVerifier, worldState, epochCache, 'test-p2p-bench-worker', undefined, telemetry, deps);
-            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);
+            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();
             for(let i = 0; i < 100; i++){
@@ -237,13 +293,8 @@ process.on('message', async (msg)=>{
         const cmd = msg;
         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':
                 if (workerClient) {
@@ -253,6 +304,12 @@ 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;
@@ -269,6 +326,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);
                     const allTxs = await generateDeterministicTxs(benchCmd.txCount, benchCmd.seed, workerConfig);
                     const txHashes = allTxs.map((tx)=>tx.getTxHash());
@@ -277,8 +335,8 @@ process.on('message', async (msg)=>{
                     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);
+                        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);
@@ -292,10 +350,15 @@ process.on('message', async (msg)=>{
                 }
         }
     } catch (err) {
-        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);
     }
 });