@aztec/p2p 0.0.1-commit.43597cc1 → 0.0.1-commit.4ad48494d

package/src/services/tx_collection/tx_collection_sink.ts

@@ -1,24 +1,28 @@
 import type { Logger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
-import { Tx, type TxHash } from '@aztec/stdlib/tx';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 import type { TelemetryClient } from '@aztec/telemetry-client';
 
 import EventEmitter from 'node:events';
 
-import type { TxPool, TxPoolEvents } from '../../mem_pools/tx_pool/tx_pool.js';
+import type { TxPoolV2, TxPoolV2Events } from '../../mem_pools/tx_pool_v2/interfaces.js';
 import { TxCollectionInstrumentation } from './instrumentation.js';
 import type { CollectionMethod } from './tx_collection.js';
 
+/** Context determining how collected txs should be added to the pool. */
+export type TxAddContext = { type: 'proposal'; blockHeader: BlockHeader } | { type: 'mined'; block: L2Block };
+
 /**
  * Executes collection requests from the fast and slow collection loops, and handles collected txs
  * by adding them to the tx pool and emitting events, as well as handling logging and metrics.
  */
-export class TxCollectionSink extends (EventEmitter as new () => TypedEventEmitter<TxPoolEvents>) {
+export class TxCollectionSink extends (EventEmitter as new () => TypedEventEmitter<TxPoolV2Events>) {
   private readonly instrumentation: TxCollectionInstrumentation;
 
   constructor(
-    private readonly txPool: TxPool,
+    private readonly txPool: TxPoolV2,
     telemetryClient: TelemetryClient,
     private readonly log: Logger,
   ) {
@@ -30,6 +34,7 @@ export class TxCollectionSink extends (EventEmitter as new () => TypedEventEmitt
     collectValidTxsFn: (txHashes: TxHash[]) => Promise<(Tx | undefined)[]>,
     requested: TxHash[],
     info: Record<string, any> & { description: string; method: CollectionMethod },
+    context: TxAddContext,
   ) {
     this.log.trace(`Requesting ${requested.length} txs via ${info.description}`, {
       ...info,
@@ -99,12 +104,13 @@ export class TxCollectionSink extends (EventEmitter as new () => TypedEventEmitt
       },
     );
 
-    return await this.foundTxs(validTxs, { ...info, duration });
+    return await this.foundTxs(validTxs, { ...info, duration }, context);
   }
 
   private async foundTxs(
     txs: Tx[],
     info: Record<string, any> & { description: string; method: CollectionMethod; duration: number },
+    context: TxAddContext,
   ) {
     // Report metrics for the collection
     this.instrumentation.increaseTxsFor(info.method, txs.length, info.duration);
@@ -112,9 +118,13 @@ export class TxCollectionSink extends (EventEmitter as new () => TypedEventEmitt
     // Mark txs as found in the slow missing txs set and all fast requests
     this.emit('txs-added', { txs });
 
-    // Add the txs to the tx pool (should not fail, but we catch it just in case)
+    // Add the txs to the tx pool using the appropriate method based on context
     try {
-      await this.txPool.addTxs(txs, { source: `tx-collection` });
+      if (context.type === 'mined') {
+        await this.txPool.addMinedTxs(txs, context.block.header, { source: 'tx-collection' });
+      } else {
+        await this.txPool.addProtectedTxs(txs, context.blockHeader, { source: 'tx-collection' });
+      }
     } catch (err) {
       this.log.error(`Error adding txs to the pool via ${info.description}`, err, {
         ...info,

package/src/services/tx_file_store/config.ts

@@ -6,8 +6,6 @@ import { type ConfigMappingsType, booleanConfigHelper, numberConfigHelper } from
 export type TxFileStoreConfig = {
   /** URL for uploading txs to file storage (s3://, gs://, file://) */
   txFileStoreUrl?: string;
-  /** URL for downloading txs from file storage */
-  txFileStoreDownloadUrl?: string;
   /** Max concurrent uploads */
   txFileStoreUploadConcurrency: number;
   /** Max queue size to prevent unbounded memory growth */
@@ -21,10 +19,6 @@ export const txFileStoreConfigMappings: ConfigMappingsType<TxFileStoreConfig> =
     env: 'TX_FILE_STORE_URL',
     description: 'URL for uploading txs to file storage (s3://, gs://, file://)',
   },
-  txFileStoreDownloadUrl: {
-    env: 'TX_FILE_STORE_DOWNLOAD_URL',
-    description: 'URL for downloading txs from file storage',
-  },
   txFileStoreUploadConcurrency: {
     env: 'TX_FILE_STORE_UPLOAD_CONCURRENCY',
     description: 'Maximum number of concurrent tx uploads',

package/src/services/tx_file_store/tx_file_store.ts

@@ -6,7 +6,7 @@ import { type FileStore, createFileStore } from '@aztec/stdlib/file-store';
 import type { Tx } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import type { TxPool, TxPoolEvents } from '../../mem_pools/tx_pool/index.js';
+import type { TxPoolV2 } from '../../mem_pools/index.js';
 import type { TxFileStoreConfig } from './config.js';
 import { TxFileStoreInstrumentation } from './instrumentation.js';
 
@@ -18,7 +18,7 @@ export class TxFileStore {
   private uploadQueue: Tx[] = [];
   private activeUploads = 0;
   private readonly queueProcessor: RunningPromise;
-  private readonly handleTxsAdded: TxPoolEvents['txs-added'];
+  private readonly handleTxsAdded: (args: { txs: Tx[]; source?: string }) => void;
 
   /** Recently uploaded tx hashes for deduplication. */
   private recentUploads: Set<string> = new Set();
@@ -27,10 +27,11 @@ export class TxFileStore {
 
   private constructor(
     private readonly fileStore: FileStore,
-    private readonly txPool: TxPool,
+    private readonly txPool: TxPoolV2,
     private readonly config: TxFileStoreConfig,
     private readonly instrumentation: TxFileStoreInstrumentation,
     private readonly log: Logger,
+    private readonly basePath: string,
   ) {
     this.handleTxsAdded = (args: { txs: Tx[]; source?: string }) => {
       this.enqueueTxs(args.txs);
@@ -48,8 +49,9 @@ export class TxFileStore {
    * @returns The file store instance, or undefined if not configured/enabled.
    */
   static async create(
-    txPool: TxPool,
+    txPool: TxPoolV2,
     config: TxFileStoreConfig,
+    basePath: string,
     log: Logger = createLogger('p2p:tx_file_store'),
     telemetry: TelemetryClient = getTelemetryClient(),
     fileStoreOverride?: FileStore,
@@ -71,8 +73,8 @@ export class TxFileStore {
     }
 
     const instrumentation = new TxFileStoreInstrumentation(telemetry, 'TxFileStore');
-    log.info('Created tx file store', { url: config.txFileStoreUrl });
-    return new TxFileStore(fileStore, txPool, config, instrumentation, log);
+    log.info('Created tx file store', { url: config.txFileStoreUrl, basePath });
+    return new TxFileStore(fileStore, txPool, config, instrumentation, log, basePath);
   }
 
   /** Starts listening to TxPool events and uploading txs. */
@@ -122,7 +124,7 @@ export class TxFileStore {
 
   private async uploadTx(tx: Tx): Promise<void> {
     const txHash = tx.getTxHash().toString();
-    const path = `txs/${txHash}.bin`;
+    const path = `${this.basePath}/txs/${txHash}.bin`;
     const timer = new Timer();
 
     if (this.recentUploads.has(txHash)) {

package/src/services/tx_provider.ts

@@ -5,13 +5,13 @@ import { elapsed } from '@aztec/foundation/timer';
 import type { L2Block, L2BlockInfo } from '@aztec/stdlib/block';
 import type { ITxProvider } from '@aztec/stdlib/interfaces/server';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
-import { Tx, TxHash } from '@aztec/stdlib/tx';
+import { type BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import type { PeerId } from '@libp2p/interface';
 
 import type { P2PClient } from '../client/p2p_client.js';
-import type { TxPool } from '../mem_pools/index.js';
+import type { TxPoolV2 } from '../mem_pools/tx_pool_v2/interfaces.js';
 import type { FastCollectionRequestInput, TxCollection } from './tx_collection/tx_collection.js';
 import { TxProviderInstrumentation } from './tx_provider_instrumentation.js';
 
@@ -24,7 +24,7 @@ export class TxProvider implements ITxProvider {
 
   constructor(
     private txCollection: TxCollection,
-    private txPool: TxPool,
+    private txPool: TxPoolV2,
     private txValidator: Pick<P2PClient, 'validate'>,
     private log: Logger = createLogger('p2p:tx-collector'),
     client: TelemetryClient = getTelemetryClient(),
@@ -144,6 +144,7 @@ export class TxProvider implements ITxProvider {
     // Take txs from the proposal body if there are any
     // Note that we still have to validate these txs, but we do it in parallel with tx collection
     const proposal = request.type === 'proposal' ? request.blockProposal : undefined;
+    const proposalBlockHeader = proposal?.blockHeader;
     const txsFromProposal = this.extractFromProposal(proposal, [...missingTxHashes]);
     if (txsFromProposal.length > 0) {
       this.instrumentation.incTxsFromProposals(txsFromProposal.length);
@@ -155,7 +156,7 @@ export class TxProvider implements ITxProvider {
     }
 
     if (missingTxHashes.size === 0) {
-      await this.processProposalTxs(txsFromProposal);
+      await this.processProposalTxs(txsFromProposal, proposalBlockHeader!);
       this.instrumentation.incTxsFromP2P(0, txHashes.length);
       return { txsFromMempool, txsFromProposal };
     }
@@ -163,7 +164,7 @@ export class TxProvider implements ITxProvider {
     // 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.collectFromP2P(request, [...missingTxHashes], opts),
-      this.processProposalTxs(txsFromProposal),
+      this.processProposalTxs(txsFromProposal, proposalBlockHeader!),
     ] as const);
 
     if (txsFromNetwork.length > 0) {
@@ -222,11 +223,11 @@ export class TxProvider implements ITxProvider {
     return compactArray(proposal.txs ?? []).filter(tx => missingTxHashes.includes(tx.getTxHash().toString()));
   }
 
-  private async processProposalTxs(txs: Tx[]): Promise<void> {
+  private async processProposalTxs(txs: Tx[], blockHeader: BlockHeader): Promise<void> {
     if (txs.length === 0) {
       return;
     }
     await this.txValidator.validate(txs);
-    await this.txPool.addTxs(txs);
+    await this.txPool.addProtectedTxs(txs, blockHeader);
   }
 }

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

@@ -13,7 +13,7 @@ import { createP2PClient } from '../client/index.js';
 import type { P2PClient } from '../client/p2p_client.js';
 import type { P2PConfig } from '../config.js';
 import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
-import type { TxPool } from '../mem_pools/tx_pool/index.js';
+import type { TxPoolV2 } from '../mem_pools/tx_pool_v2/interfaces.js';
 import { generatePeerIdPrivateKeys } from '../test-helpers/generate-peer-id-private-keys.js';
 import { getPorts } from './get-ports.js';
 import { makeEnrs } from './make-enrs.js';
@@ -22,7 +22,7 @@ import { AlwaysFalseCircuitVerifier, AlwaysTrueCircuitVerifier } from './reqresp
 
 export interface MakeTestP2PClientOptions {
   mockAttestationPool: AttestationPool;
-  mockTxPool: TxPool;
+  mockTxPool: TxPoolV2;
   mockEpochCache: EpochCache;
   mockWorldState: WorldStateSynchronizer;
   alwaysTrueVerifier?: boolean;
@@ -108,7 +108,7 @@ export async function makeTestP2PClient(
     undefined,
     undefined,
     {
-      txPool: mockTxPool as unknown as TxPool,
+      txPool: mockTxPool as unknown as TxPoolV2,
       attestationPool: mockAttestationPool as unknown as AttestationPool,
       store: kvStore,
       logger,

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

@@ -19,8 +19,20 @@ import {
 
 import type { P2PConfig } from '../config.js';
 import type { MemPools } from '../mem_pools/interface.js';
-import { DummyPeerDiscoveryService, DummyPeerManager, DummyReqResp, LibP2PService } from '../services/index.js';
-import type { ReqRespInterface } from '../services/reqresp/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,
+} from '../services/reqresp/interface.js';
+import { ReqRespStatus } from '../services/reqresp/status.js';
 import { GossipSubEvent } from '../types/index.js';
 import type { PubSubLibp2p } from '../util.js';
 
@@ -52,7 +64,7 @@ export function getMockPubSubP2PServiceFactory<T extends P2PClientType>(
     deps.logger.verbose('Creating mock PubSub service');
     const libp2p = new MockPubSub(peerId, network);
     const peerManager = new DummyPeerManager(peerId, network);
-    const reqresp: ReqRespInterface = new DummyReqResp();
+    const reqresp: ReqRespInterface = new MockReqResp(peerId, network);
     const peerDiscoveryService = new DummyPeerDiscoveryService();
     const service = new LibP2PService<T>(
       clientType as T,
@@ -74,6 +86,115 @@ export function getMockPubSubP2PServiceFactory<T extends P2PClientType>(
   };
 }
 
+/**
+ * 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.
+ */
+class MockReqResp implements ReqRespInterface {
+  private handlers: Partial<ReqRespSubProtocolHandlers> = {};
+  private logger = createLogger('p2p:test:mock-reqresp');
+
+  constructor(
+    private peerId: PeerId,
+    private network: MockGossipSubNetwork,
+  ) {
+    network.registerReqRespPeer(this);
+  }
+
+  updateConfig(_config: Partial<P2PReqRespConfig>): void {}
+
+  start(
+    subProtocolHandlers: Partial<ReqRespSubProtocolHandlers>,
+    _subProtocolValidators: ReqRespSubProtocolValidators,
+  ): Promise<void> {
+    Object.assign(this.handlers, subProtocolHandlers);
+    return Promise.resolve();
+  }
+
+  addSubProtocol(
+    subProtocol: ReqRespSubProtocol,
+    handler: ReqRespSubProtocolHandler,
+    _validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
+  ): Promise<void> {
+    this.handlers[subProtocol] = handler;
+    return Promise.resolve();
+  }
+
+  stop(): Promise<void> {
+    this.handlers = {};
+    return Promise.resolve();
+  }
+
+  getHandler(subProtocol: ReqRespSubProtocol): ReqRespSubProtocolHandler | undefined {
+    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,
+    payload: Buffer,
+    _dialTimeout?: number,
+  ): Promise<ReqRespResponse> {
+    const peer = this.network.getReqRespPeers().find(p => p.peerId.equals(peerId));
+    const handler = peer?.getHandler(subProtocol);
+    if (!handler) {
+      return { status: ReqRespStatus.SUCCESS, data: Buffer.from([]) };
+    }
+    try {
+      const data = await handler(this.peerId, payload);
+      return { status: ReqRespStatus.SUCCESS, data };
+    } catch {
+      return { status: ReqRespStatus.FAILURE };
+    }
+  }
+
+  getConnectionSampler(): Pick<ConnectionSampler, 'getPeerListSortedByConnectionCountAsc'> {
+    return {
+      getPeerListSortedByConnectionCountAsc: () =>
+        this.network
+          .getReqRespPeers()
+          .filter(p => !p.peerId.equals(this.peerId))
+          .map(p => p.peerId),
+    };
+  }
+}
+
 /**
  * Implementation of PubSub services that relies on a mock gossip sub network.
  * This is used in tests to simulate a gossip sub network without needing a real P2P network.
@@ -157,6 +278,7 @@ class MockGossipSubService extends TypedEventEmitter<GossipsubEvents> implements
  */
 export class MockGossipSubNetwork {
   private peers: MockGossipSubService[] = [];
+  private reqRespPeers: MockReqResp[] = [];
   private nextMsgId = 0;
 
   private logger = createLogger('p2p:test:mock-gossipsub-network');
@@ -169,6 +291,14 @@ export class MockGossipSubNetwork {
     this.peers.push(peer);
   }
 
+  public registerReqRespPeer(peer: MockReqResp): void {
+    this.reqRespPeers.push(peer);
+  }
+
+  public getReqRespPeers(): MockReqResp[] {
+    return this.reqRespPeers;
+  }
+
   public publishToPeers(topic: TopicStr, data: Uint8Array, sender: PeerId): void {
     const msgId = (this.nextMsgId++).toString();
     this.logger.debug(`Network is distributing message on topic ${topic}`, {

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 }): 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' | 'rejected'> {
+    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): 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> {