@aztec/p2p 0.0.1-commit.181e2d196 → 0.0.1-commit.189eedb3

package/src/services/tx_collection/tx_source.ts

@@ -2,7 +2,7 @@ import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import { type AztecNode, createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import type { Tx, TxHash, TxValidator } from '@aztec/stdlib/tx';
 import { type ComponentsVersions, getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
 import { makeTracedFetch } from '@aztec/telemetry-client';
 
@@ -16,12 +16,13 @@ export interface TxSource {
 export class NodeRpcTxSource implements TxSource {
   constructor(
     private readonly client: Pick<AztecNode, 'getTxsByHash'>,
+    private readonly txValidator: TxValidator,
     private readonly info: string,
   ) {}
 
-  public static fromUrl(nodeUrl: string, versions: ComponentsVersions): NodeRpcTxSource {
+  public static fromUrl(nodeUrl: string, txValidator: TxValidator, versions: ComponentsVersions): NodeRpcTxSource {
     const client = createAztecNodeClient(nodeUrl, versions, makeTracedFetch([1, 2, 3], false));
-    return new NodeRpcTxSource(client, nodeUrl);
+    return new NodeRpcTxSource(client, txValidator, nodeUrl);
   }
 
   public getInfo() {
@@ -38,8 +39,8 @@ export class NodeRpcTxSource implements TxSource {
     const invalidTxHashes: string[] = [];
     await Promise.all(
       txs.map(async tx => {
-        const isValid = await tx.validateTxHash();
-        if (isValid) {
+        const validation = await this.txValidator.validateTx(tx);
+        if (validation.result === 'valid') {
           validTxs.push(tx);
         } else {
           invalidTxHashes.push(tx.getTxHash().toString());
@@ -50,7 +51,7 @@ export class NodeRpcTxSource implements TxSource {
   }
 }
 
-export function createNodeRpcTxSources(urls: string[], chainConfig: ChainConfig) {
+export function createNodeRpcTxSources(urls: string[], txValidator: TxValidator, chainConfig: ChainConfig) {
   const versions = getComponentsVersionsFromConfig(chainConfig, protocolContractsHash, getVKTreeRoot());
-  return urls.map(url => NodeRpcTxSource.fromUrl(url, versions));
+  return urls.map(url => NodeRpcTxSource.fromUrl(url, txValidator, versions));
 }

package/src/services/tx_file_store/tx_file_store.ts

@@ -1,3 +1,4 @@
+import { FifoSet } from '@aztec/foundation/fifo-set';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/promise';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
@@ -10,6 +11,8 @@ import type { TxPoolV2 } from '../../mem_pools/index.js';
 import type { TxFileStoreConfig } from './config.js';
 import { TxFileStoreInstrumentation } from './instrumentation.js';
 
+const MAX_RECENT_UPLOADS = 1000;
+
 /**
  * Uploads validated transactions to a file store as a fallback retrieval mechanism.
  * Listens to TxPool txs-added events and uploads txs asynchronously with bounded concurrency.
@@ -21,9 +24,7 @@ export class TxFileStore {
   private readonly handleTxsAdded: (args: { txs: Tx[]; source?: string }) => void;
 
   /** Recently uploaded tx hashes for deduplication. */
-  private recentUploads: Set<string> = new Set();
-  private recentUploadsOrder: string[] = [];
-  private readonly maxRecentUploads = 1000;
+  private recentUploads = FifoSet.withLimit<string>(MAX_RECENT_UPLOADS);
 
   private constructor(
     private readonly fileStore: FileStore,
@@ -127,24 +128,11 @@ export class TxFileStore {
     const path = `${this.basePath}/txs/${txHash}.bin`;
     const timer = new Timer();
 
-    if (this.recentUploads.has(txHash)) {
+    if (!this.recentUploads.addIfAbsent(txHash)) {
       return;
     }
 
     try {
-      this.recentUploads.add(txHash);
-      this.recentUploadsOrder.push(txHash);
-
-      if (this.recentUploadsOrder.length > this.maxRecentUploads) {
-        // delete old entries in recentUploads
-        for (const txHashToRemove of this.recentUploadsOrder.splice(
-          0,
-          this.recentUploadsOrder.length - this.maxRecentUploads,
-        )) {
-          this.recentUploads.delete(txHashToRemove);
-        }
-      }
-
       await retry(
         () => this.fileStore.save(path, tx.toBuffer(), { compress: true }),
         `Uploading tx ${txHash}`,

package/src/services/tx_provider.ts

@@ -32,6 +32,11 @@ export class TxProvider implements ITxProvider {
     this.instrumentation = new TxProviderInstrumentation(client, 'TxProvider');
   }
 
+  /** Returns whether each tx hash is currently in the local tx pool. */
+  public hasTxs(txHashes: TxHash[]): Promise<boolean[]> {
+    return this.txPool.hasTxs(txHashes);
+  }
+
   /** Returns txs from the tx pool given their hashes.*/
   public async getAvailableTxs(txHashes: TxHash[]): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
     const response = await this.txPool.getTxsByHash(txHashes);

package/src/test-helpers/make-test-p2p-clients.ts

@@ -4,9 +4,10 @@ import { SecretValue } from '@aztec/foundation/config';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
+import { GasFees } from '@aztec/stdlib/gas';
 import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 
 import { createP2PClient } from '../client/index.js';
 import type { P2PClient } from '../client/p2p_client.js';
@@ -102,6 +103,7 @@ export async function makeTestP2PClient(
     proofVerifier,
     mockWorldState,
     mockEpochCache,
+    { getCurrentMinFees: () => Promise.resolve(GasFees.empty()) },
     'test-p2p-client',
     undefined,
     undefined,
@@ -112,6 +114,7 @@ export async function makeTestP2PClient(
       logger,
       p2pServiceFactory: mockGossipSubNetwork && getMockPubSubP2PServiceFactory(mockGossipSubNetwork),
     },
+    await l2BlockSource.getInitialHeader().hash(),
   );
 
   return client;

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

@@ -1,8 +1,10 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { L2BlockSource } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { BlockMinFeesProvider } from '@aztec/stdlib/gas';
 import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import type { TelemetryClient } from '@aztec/telemetry-client';
 
@@ -21,15 +23,12 @@ import type { MemPools } from '../mem_pools/interface.js';
 import { DummyPeerDiscoveryService, DummyPeerManager, LibP2PService } from '../services/index.js';
 import type { P2PReqRespConfig } from '../services/reqresp/config.js';
 import type { ConnectionSampler } from '../services/reqresp/connection-sampler/connection_sampler.js';
-import {
-  type ReqRespInterface,
-  type ReqRespResponse,
-  type ReqRespSubProtocol,
-  type ReqRespSubProtocolHandler,
-  type ReqRespSubProtocolHandlers,
-  type ReqRespSubProtocolValidators,
-  type SubProtocolMap,
-  responseFromBuffer,
+import type {
+  ReqRespInterface,
+  ReqRespResponse,
+  ReqRespSubProtocol,
+  ReqRespSubProtocolHandler,
+  ReqRespSubProtocolHandlers,
 } from '../services/reqresp/interface.js';
 import { ReqRespStatus } from '../services/reqresp/status.js';
 import { GossipSubEvent } from '../types/index.js';
@@ -55,6 +54,7 @@ export function getMockPubSubP2PServiceFactory(
       proofVerifier: ClientProtocolCircuitVerifier;
       worldStateSynchronizer: WorldStateSynchronizer;
       peerStore: AztecAsyncKVStore;
+      blockMinFeesProvider: BlockMinFeesProvider;
       telemetry: TelemetryClient;
       logger: Logger;
     },
@@ -75,6 +75,7 @@ export function getMockPubSubP2PServiceFactory(
       deps.epochCache,
       deps.proofVerifier,
       deps.worldStateSynchronizer,
+      deps.blockMinFeesProvider,
       deps.telemetry,
       deps.logger,
     );
@@ -85,8 +86,8 @@ export function getMockPubSubP2PServiceFactory(
 
 /**
  * Mock implementation of ReqRespInterface that routes requests to other peers' handlers through the mock network.
- * When a peer calls sendBatchRequest, the mock iterates over network peers and invokes their registered handler
- * for the sub-protocol, simulating the request-response protocol without actual libp2p streams.
+ * When a peer calls sendRequestToPeer, the mock looks up the target peer's registered handler for the
+ * sub-protocol and invokes it, simulating the request-response protocol without actual libp2p streams.
  */
 class MockReqResp implements ReqRespInterface {
   private handlers: Partial<ReqRespSubProtocolHandlers> = {};
@@ -100,20 +101,14 @@ class MockReqResp implements ReqRespInterface {
   }
 
   updateConfig(_config: Partial<P2PReqRespConfig>): void {}
+  setShouldRejectPeer(): void {}
 
-  start(
-    subProtocolHandlers: Partial<ReqRespSubProtocolHandlers>,
-    _subProtocolValidators: ReqRespSubProtocolValidators,
-  ): Promise<void> {
+  start(subProtocolHandlers: Partial<ReqRespSubProtocolHandlers>): Promise<void> {
     Object.assign(this.handlers, subProtocolHandlers);
     return Promise.resolve();
   }
 
-  addSubProtocol(
-    subProtocol: ReqRespSubProtocol,
-    handler: ReqRespSubProtocolHandler,
-    _validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
-  ): Promise<void> {
+  addSubProtocol(subProtocol: ReqRespSubProtocol, handler: ReqRespSubProtocolHandler): Promise<void> {
     this.handlers[subProtocol] = handler;
     return Promise.resolve();
   }
@@ -127,41 +122,6 @@ class MockReqResp implements ReqRespInterface {
     return this.handlers[subProtocol];
   }
 
-  async sendBatchRequest<SubProtocol extends ReqRespSubProtocol>(
-    subProtocol: SubProtocol,
-    requests: InstanceType<SubProtocolMap[SubProtocol]['request']>[],
-    pinnedPeer: PeerId | undefined,
-    _timeoutMs?: number,
-    _maxPeers?: number,
-    _maxRetryAttempts?: number,
-  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']>[]> {
-    const responses: InstanceType<SubProtocolMap[SubProtocol]['response']>[] = [];
-    const peers = this.network.getReqRespPeers().filter(p => !p.peerId.equals(this.peerId));
-    const targetPeers = pinnedPeer ? peers.filter(p => p.peerId.equals(pinnedPeer)) : peers;
-
-    for (const request of requests) {
-      const requestBuffer = request.toBuffer();
-      for (const peer of targetPeers) {
-        const handler = peer.getHandler(subProtocol);
-        if (!handler) {
-          continue;
-        }
-        try {
-          const responseBuffer = await handler(this.peerId, requestBuffer);
-          if (responseBuffer.length > 0) {
-            const response = responseFromBuffer(subProtocol, responseBuffer);
-            responses.push(response as InstanceType<SubProtocolMap[SubProtocol]['response']>);
-            break;
-          }
-        } catch (err) {
-          this.logger.debug(`Mock reqresp handler error from peer ${peer.peerId}`, { err });
-        }
-      }
-    }
-
-    return responses;
-  }
-
   async sendRequestToPeer(
     peerId: PeerId,
     subProtocol: ReqRespSubProtocol,
@@ -174,7 +134,12 @@ class MockReqResp implements ReqRespInterface {
       return { status: ReqRespStatus.SUCCESS, data: Buffer.from([]) };
     }
     try {
+      const delayMs = this.network.getPropagationDelayMs();
+      if (delayMs > 0) {
+        await sleep(delayMs);
+      }
       const data = await handler(this.peerId, payload);
+
       return { status: ReqRespStatus.SUCCESS, data };
     } catch {
       return { status: ReqRespStatus.FAILURE };
@@ -212,6 +177,13 @@ export class MockPubSub implements PubSubLibp2p {
   get services() {
     return {
       pubsub: this.gossipSub,
+      components: {
+        addressManager: {
+          addObservedAddr: () => {},
+          confirmObservedAddr: () => {},
+          removeObservedAddr: () => {},
+        },
+      },
     };
   }
 
@@ -242,10 +214,10 @@ class MockGossipSubService extends TypedEventEmitter<GossipsubEvents> implements
     score: (_peerId: PeerIdStr) => 0,
   };
 
-  publish(topic: TopicStr, data: Uint8Array, _opts?: PublishOpts): Promise<PublishResult> {
+  async publish(topic: TopicStr, data: Uint8Array, _opts?: PublishOpts): Promise<PublishResult> {
     this.logger.debug(`Publishing message on topic ${topic}`, { topic, sender: this.peerId.toString() });
-    this.network.publishToPeers(topic, data, this.peerId);
-    return Promise.resolve({ recipients: this.network.getPeers().filter(peer => !this.peerId.equals(peer)) });
+    await this.network.publishToPeers(topic, data, this.peerId);
+    return { recipients: this.network.getPeers().filter(peer => !this.peerId.equals(peer)) };
   }
 
   receive(msg: GossipsubMessage) {
@@ -281,7 +253,8 @@ class MockGossipSubService extends TypedEventEmitter<GossipsubEvents> implements
 
 /**
  * Mock gossip sub network used for testing.
- * All instances of MockGossipSubService connected to the same network will instantly receive the same messages.
+ * All instances of MockGossipSubService connected to the same network receive the same messages,
+ * optionally delayed by a configurable propagation time.
  */
 export class MockGossipSubNetwork {
   private peers: MockGossipSubService[] = [];
@@ -290,6 +263,15 @@ export class MockGossipSubNetwork {
 
   private logger = createLogger('p2p:test:mock-gossipsub-network');
 
+  constructor(
+    /** Artificial propagation delay in milliseconds applied to each message delivery. */
+    private propagationDelayMs: number = 0,
+  ) {}
+
+  public getPropagationDelayMs(): number {
+    return this.propagationDelayMs;
+  }
+
   public getPeers(): PeerId[] {
     return this.peers.map(peer => peer.peerId);
   }
@@ -306,7 +288,7 @@ export class MockGossipSubNetwork {
     return this.reqRespPeers;
   }
 
-  public publishToPeers(topic: TopicStr, data: Uint8Array, sender: PeerId): void {
+  public async publishToPeers(topic: TopicStr, data: Uint8Array, sender: PeerId): Promise<void> {
     const msgId = (this.nextMsgId++).toString();
     this.logger.debug(`Network is distributing message on topic ${topic}`, {
       topic,
@@ -315,6 +297,10 @@ export class MockGossipSubNetwork {
       msgId,
     });
 
+    if (this.propagationDelayMs > 0) {
+      await sleep(this.propagationDelayMs);
+    }
+
     const gossipSubMsg: GossipsubMessage = { msgId, msg: { type: 'unsigned', topic, data }, propagationSource: sender };
     for (const peer of this.peers) {
       if (peer.subscribedTopics.has(topic)) {

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

@@ -2,16 +2,17 @@ import type { EpochCache } from '@aztec/epoch-cache';
 import { timesParallel } from '@aztec/foundation/collection';
 import { SecretValue } from '@aztec/foundation/config';
 import { createLogger } from '@aztec/foundation/log';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import type { L2BlockSource } from '@aztec/stdlib/block';
 import { type ChainConfig, emptyChainConfig } from '@aztec/stdlib/config';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { GasFees } from '@aztec/stdlib/gas';
 import type {
   ClientProtocolCircuitVerifier,
   IVCProofVerificationResult,
   WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import type { Tx } from '@aztec/stdlib/tx';
 import { compressComponentVersions } from '@aztec/stdlib/versioning';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
@@ -30,7 +31,7 @@ import getPort from 'get-port';
 import { type Libp2p, type Libp2pOptions, createLibp2p } from 'libp2p';
 
 import { BootstrapNode } from '../bootstrap/bootstrap.js';
-import type { BootnodeConfig, P2PConfig } from '../config.js';
+import { type BootnodeConfig, DEFAULT_PUBLIC_IP_SERVICES, type P2PConfig } from '../config.js';
 import type { MemPools } from '../mem_pools/interface.js';
 import { DiscV5Service } from '../services/discv5/discV5_service.js';
 import { APP_SPECIFIC_WEIGHT } from '../services/gossipsub/scoring.js';
@@ -42,8 +43,6 @@ import {
   ReqRespSubProtocol,
   type ReqRespSubProtocolHandlers,
   type ReqRespSubProtocolRateLimits,
-  type ReqRespSubProtocolValidators,
-  noopValidator,
 } from '../services/reqresp/interface.js';
 import { pingHandler } from '../services/reqresp/protocols/index.js';
 import { ReqResp } from '../services/reqresp/reqresp.js';
@@ -76,6 +75,10 @@ export async function createLibp2pNode(
       identify: identify({
         protocolPrefix: 'aztec',
       }),
+      components: (components: { connectionManager: any; addressManager: any }) => ({
+        connectionManager: components.connectionManager,
+        addressManager: components.addressManager,
+      }),
     },
   };
 
@@ -153,6 +156,8 @@ export async function createTestLibP2PService(
     epochCache,
   );
 
+  reqresp.setShouldRejectPeer(peerId => peerManager.shouldDisableP2PGossip(peerId));
+
   p2pNode.services.pubsub.score.params.appSpecificWeight = APP_SPECIFIC_WEIGHT;
   p2pNode.services.pubsub.score.params.appSpecificScore = (peerId: string) =>
     peerManager.shouldDisableP2PGossip(peerId) ? -Infinity : peerManager.getPeerScore(peerId);
@@ -168,6 +173,7 @@ export async function createTestLibP2PService(
     epochCache,
     proofVerifier,
     worldStateSynchronizer,
+    { getCurrentMinFees: () => Promise.resolve(GasFees.empty()) },
     telemetry,
   );
 }
@@ -187,23 +193,10 @@ export const MOCK_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
   [ReqRespSubProtocol.STATUS]: (_msg: any) => Promise.resolve(Buffer.from('status')),
   [ReqRespSubProtocol.TX]: (_msg: any) => Promise.resolve(Buffer.from('tx')),
   [ReqRespSubProtocol.GOODBYE]: (_msg: any) => Promise.resolve(Buffer.from('goodbye')),
-  [ReqRespSubProtocol.BLOCK]: (_msg: any) => Promise.resolve(Buffer.from('block')),
   [ReqRespSubProtocol.AUTH]: (_msg: any) => Promise.resolve(Buffer.from('auth')),
   [ReqRespSubProtocol.BLOCK_TXS]: (_msg: any) => Promise.resolve(Buffer.from('block_txs')),
 };
 
-// By default, all requests are valid
-// If you want to test an invalid response, you can override the validator
-export const MOCK_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators = {
-  [ReqRespSubProtocol.PING]: noopValidator,
-  [ReqRespSubProtocol.STATUS]: noopValidator,
-  [ReqRespSubProtocol.TX]: noopValidator,
-  [ReqRespSubProtocol.GOODBYE]: noopValidator,
-  [ReqRespSubProtocol.BLOCK]: noopValidator,
-  [ReqRespSubProtocol.AUTH]: noopValidator,
-  [ReqRespSubProtocol.BLOCK_TXS]: noopValidator,
-};
-
 /**
  * @param numberOfNodes - the number of nodes to create
  * @returns An array of the created nodes
@@ -216,13 +209,9 @@ export const createNodes = (
   return timesParallel(numberOfNodes, () => createReqResp(peerScoring, rateLimits));
 };
 
-export const startNodes = async (
-  nodes: ReqRespNode[],
-  subProtocolHandlers = MOCK_SUB_PROTOCOL_HANDLERS,
-  subProtocolValidators = MOCK_SUB_PROTOCOL_VALIDATORS,
-) => {
+export const startNodes = async (nodes: ReqRespNode[], subProtocolHandlers = MOCK_SUB_PROTOCOL_HANDLERS) => {
   for (const node of nodes) {
-    await node.req.start(subProtocolHandlers, subProtocolValidators);
+    await node.req.start(subProtocolHandlers);
   }
 };
 
@@ -290,6 +279,7 @@ export function createBootstrapNodeConfig(privateKey: string, port: number, chai
     bootstrapNodes: [],
     listenAddress: '127.0.0.1',
     queryForIp: false,
+    publicIpServices: DEFAULT_PUBLIC_IP_SERVICES,
   };
 }
 

package/src/test-helpers/test_tx_provider.ts

@@ -31,6 +31,11 @@ export class TestTxProvider implements ITxProvider {
     return this.getTxsByHashes(txHashes);
   }
 
+  /** Returns whether each tx hash is in the seeded collection. */
+  hasTxs(txHashes: TxHash[]): Promise<boolean[]> {
+    return Promise.resolve(txHashes.map(h => this.txs.has(h.toString())));
+  }
+
   /** Get txs for a block proposal, returning any seeded txs that match the requested hashes. */
   getTxsForBlockProposal(
     blockProposal: BlockProposal,

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

@@ -1,14 +1,10 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { CheckpointProposalHash } 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,
-  CheckpointAttestation,
-  CheckpointProposal,
-  CheckpointProposalCore,
-} from '@aztec/stdlib/p2p';
+import type { BlockProposal, CheckpointAttestation, CheckpointProposalCore } from '@aztec/stdlib/p2p';
 import { type BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 
 import EventEmitter from 'events';
@@ -214,6 +210,7 @@ export class InMemoryTxPool extends EventEmitter implements TxPoolV2 {
  */
 export class InMemoryAttestationPool {
   private proposals = new Map<string, BlockProposal>();
+  private checkpoints = new Map<SlotNumber, CheckpointProposalCore[]>();
 
   tryAddBlockProposal(blockProposal: BlockProposal): Promise<TryAddResult> {
     const id = blockProposal.archive.toString();
@@ -225,16 +222,29 @@ export class InMemoryAttestationPool {
     return Promise.resolve({ added: true, alreadyExists: false, count: 1 });
   }
 
-  getBlockProposal(id: string): Promise<BlockProposal | undefined> {
+  getBlockProposalByArchive(id: string): Promise<BlockProposal | undefined> {
     return Promise.resolve(this.proposals.get(id));
   }
 
-  tryAddCheckpointProposal(_proposal: CheckpointProposal): Promise<TryAddResult> {
+  tryAddCheckpointProposal(proposal: CheckpointProposalCore): Promise<TryAddResult> {
+    const proposals = this.checkpoints.get(proposal.slotNumber) ?? [];
+    proposals.push(proposal);
+    this.checkpoints.set(proposal.slotNumber, proposals);
     return Promise.resolve({ added: true, alreadyExists: false, count: 1 });
   }
 
-  getCheckpointProposal(_id: string): Promise<CheckpointProposalCore | undefined> {
-    return Promise.resolve(undefined);
+  getCheckpointProposal(slot: SlotNumber): Promise<CheckpointProposalCore | undefined> {
+    return Promise.resolve(this.checkpoints.get(slot)?.[0]);
+  }
+
+  getProposalsForSlot(slot: SlotNumber): Promise<{
+    blockProposals: BlockProposal[];
+    checkpointProposals: CheckpointProposalCore[];
+  }> {
+    return Promise.resolve({
+      blockProposals: [...this.proposals.values()].filter(proposal => proposal.slotNumber === slot),
+      checkpointProposals: this.checkpoints.get(slot) ?? [],
+    });
   }
 
   async addOwnCheckpointAttestations(_attestations: CheckpointAttestation[]): Promise<void> {}
@@ -247,7 +257,7 @@ export class InMemoryAttestationPool {
 
   getCheckpointAttestationsForSlotAndProposal(
     _slot: SlotNumber,
-    _proposalId: string,
+    _proposalPayloadHash: CheckpointProposalHash,
   ): Promise<CheckpointAttestation[]> {
     return Promise.resolve([]);
   }
@@ -261,11 +271,12 @@ export class InMemoryAttestationPool {
   }
 
   isEmpty(): Promise<boolean> {
-    return Promise.resolve(this.proposals.size === 0);
+    return Promise.resolve(this.proposals.size === 0 && this.checkpoints.size === 0);
   }
 
   resetState(): void {
     this.proposals.clear();
+    this.checkpoints.clear();
   }
 }
 
@@ -273,17 +284,40 @@ 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,
+    }),
     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,
@@ -292,8 +326,10 @@ export function createMockEpochCache(): EpochCacheInterface {
       ethereumSlotDuration: 1,
       proofSubmissionEpochs: 1,
       targetCommitteeSize: 48,
+      rollupManaLimit: Number.MAX_SAFE_INTEGER,
     }),
   };
+  return cache;
 }
 
 /**
@@ -340,19 +376,6 @@ export function installUnlimitedRateLimitsOnReqResp(reqResp: any): void {
  */
 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.
  */