@aztec/p2p 0.0.1-commit.6d63667d → 0.0.1-commit.733c4a3

package/src/services/tx_collection/tx_collection.ts

@@ -2,38 +2,41 @@ import { BlockNumber } from '@aztec/foundation/branded-types';
 import { compactArray } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type PromiseWithResolvers, RunningPromise } from '@aztec/foundation/promise';
+import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { L2Block, L2BlockInfo } from '@aztec/stdlib/block';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
-import { Tx, TxHash } from '@aztec/stdlib/tx';
+import type { Tx } from '@aztec/stdlib/tx';
+import { TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import type { PeerId } from '@libp2p/interface';
 
-import type { TxPool } from '../../mem_pools/index.js';
-import type { TxPoolEvents } from '../../mem_pools/tx_pool/tx_pool.js';
+import type { TxPoolV2, TxPoolV2Events } from '../../mem_pools/tx_pool_v2/interfaces.js';
 import type { BatchTxRequesterLibP2PService } from '../reqresp/batch-tx-requester/interface.js';
 import type { TxCollectionConfig } from './config.js';
 import { FastTxCollection } from './fast_tx_collection.js';
-import { SlowTxCollection } from './slow_tx_collection.js';
-import { TxCollectionSink } from './tx_collection_sink.js';
+import { FileStoreTxCollection } from './file_store_tx_collection.js';
+import type { FileStoreTxSource } from './file_store_tx_source.js';
+import type { IMissingTxsTracker } from './missing_txs_tracker.js';
+import { SlowTxCollection, getProofDeadlineForSlot } from './slow_tx_collection.js';
+import { type TxAddContext, TxCollectionSink } from './tx_collection_sink.js';
 import type { TxSource } from './tx_source.js';
 
-export type CollectionMethod = 'fast-req-resp' | 'fast-node-rpc' | 'slow-req-resp' | 'slow-node-rpc';
+export type CollectionMethod = 'fast-req-resp' | 'fast-node-rpc' | 'slow-req-resp' | 'slow-node-rpc' | 'file-store';
 
-export type MissingTxInfo = { blockNumber: BlockNumber; deadline: Date; readyForReqResp: boolean };
+export type MissingTxInfo = { block: L2Block; blockNumber: BlockNumber; deadline: Date; readyForReqResp: boolean };
 
 export type FastCollectionRequestInput =
   | { type: 'block'; block: L2Block }
   | { type: 'proposal'; blockProposal: BlockProposal; blockNumber: BlockNumber };
 
 export type FastCollectionRequest = FastCollectionRequestInput & {
-  missingTxHashes: Set<string>;
+  missingTxTracker: IMissingTxsTracker;
   deadline: Date;
   blockInfo: L2BlockInfo;
   promise: PromiseWithResolvers<void>;
-  foundTxs: Map<string, Tx>;
 };
 
 /**
@@ -54,6 +57,12 @@ export class TxCollection {
   /** Fast collection methods */
   protected readonly fastCollection: FastTxCollection;
 
+  /** File store collection for slow (mined block) path */
+  protected readonly fileStoreSlowCollection: FileStoreTxCollection;
+
+  /** File store collection for fast (proposal/proving) path */
+  protected readonly fileStoreFastCollection: FileStoreTxCollection;
+
   /** Loop for periodically reconciling found transactions from the tx pool in case we missed some */
   private readonly reconcileFoundTxsLoop: RunningPromise;
 
@@ -61,17 +70,24 @@ export class TxCollection {
   private readonly txCollectionSink: TxCollectionSink;
 
   /** Handler for the txs-added event from the tx pool */
-  protected readonly handleTxsAddedToPool: TxPoolEvents['txs-added'];
+  protected readonly handleTxsAddedToPool: TxPoolV2Events['txs-added'];
 
   /** Handler for the txs-added event from the tx collection sink */
-  protected readonly handleTxsFound: TxPoolEvents['txs-added'];
+  protected readonly handleTxsFound: TxPoolV2Events['txs-added'];
+
+  /** Whether the service has been started. */
+  private started = false;
+
+  /** Whether file store sources are configured. */
+  private readonly hasFileStoreSources: boolean;
 
   constructor(
     private readonly p2pService: BatchTxRequesterLibP2PService,
     private readonly nodes: TxSource[],
     private readonly constants: L1RollupConstants,
-    private readonly txPool: TxPool,
+    private readonly txPool: TxPoolV2,
     private readonly config: TxCollectionConfig,
+    fileStoreSources: FileStoreTxSource[] = [],
     private readonly dateProvider: DateProvider = new DateProvider(),
     telemetryClient: TelemetryClient = getTelemetryClient(),
     private readonly log: Logger = createLogger('p2p:tx_collection_service'),
@@ -98,18 +114,42 @@ export class TxCollection {
       this.log,
     );
 
+    this.hasFileStoreSources = fileStoreSources.length > 0;
+    this.fileStoreSlowCollection = new FileStoreTxCollection(
+      fileStoreSources,
+      this.txCollectionSink,
+      {
+        workerCount: config.txCollectionFileStoreSlowWorkerCount,
+        backoffBaseMs: config.txCollectionFileStoreSlowBackoffBaseMs,
+        backoffMaxMs: config.txCollectionFileStoreSlowBackoffMaxMs,
+      },
+      this.dateProvider,
+      this.log,
+    );
+    this.fileStoreFastCollection = new FileStoreTxCollection(
+      fileStoreSources,
+      this.txCollectionSink,
+      {
+        workerCount: config.txCollectionFileStoreFastWorkerCount,
+        backoffBaseMs: config.txCollectionFileStoreFastBackoffBaseMs,
+        backoffMaxMs: config.txCollectionFileStoreFastBackoffMaxMs,
+      },
+      this.dateProvider,
+      this.log,
+    );
+
     this.reconcileFoundTxsLoop = new RunningPromise(
       () => this.reconcileFoundTxsWithPool(),
       this.log,
       this.config.txCollectionReconcileIntervalMs,
     );
 
-    this.handleTxsFound = (args: Parameters<TxPoolEvents['txs-added']>[0]) => {
+    this.handleTxsFound = (args: Parameters<TxPoolV2Events['txs-added']>[0]) => {
       this.foundTxs(args.txs);
     };
     this.txCollectionSink.on('txs-added', this.handleTxsFound);
 
-    this.handleTxsAddedToPool = (args: Parameters<TxPoolEvents['txs-added']>[0]) => {
+    this.handleTxsAddedToPool = (args: Parameters<TxPoolV2Events['txs-added']>[0]) => {
       const { txs, source } = args;
       if (source !== 'tx-collection') {
         this.foundTxs(txs);
@@ -120,7 +160,10 @@ export class TxCollection {
 
   /** Starts all collection loops. */
   public start(): Promise<void> {
+    this.started = true;
     this.slowCollection.start();
+    this.fileStoreSlowCollection.start();
+    this.fileStoreFastCollection.start();
     this.reconcileFoundTxsLoop.start();
 
     // TODO(palla/txs): Collect mined unproven tx hashes for txs we dont have in the pool and populate missingTxs on startup
@@ -129,7 +172,14 @@ export class TxCollection {
 
   /** Stops all activity. */
   public async stop() {
-    await Promise.all([this.slowCollection.stop(), this.fastCollection.stop(), this.reconcileFoundTxsLoop.stop()]);
+    this.started = false;
+    await Promise.all([
+      this.slowCollection.stop(),
+      this.fastCollection.stop(),
+      this.fileStoreSlowCollection.stop(),
+      this.fileStoreFastCollection.stop(),
+      this.reconcileFoundTxsLoop.stop(),
+    ]);
 
     this.txPool.removeListener('txs-added', this.handleTxsAddedToPool);
     this.txCollectionSink.removeListener('txs-added', this.handleTxsFound);
@@ -147,7 +197,25 @@ export class TxCollection {
 
   /** Starts collecting the given tx hashes for the given L2Block in the slow loop */
   public startCollecting(block: L2Block, txHashes: TxHash[]) {
-    return this.slowCollection.startCollecting(block, txHashes);
+    this.slowCollection.startCollecting(block, txHashes);
+
+    // Delay file store collection to give P2P methods time to find txs first
+    if (this.hasFileStoreSources) {
+      const context: TxAddContext = { type: 'mined', block };
+      const deadline = getProofDeadlineForSlot(block.header.getSlot(), this.constants);
+      sleep(this.config.txCollectionFileStoreSlowDelayMs)
+        .then(() => {
+          if (this.started) {
+            // Only queue txs that are still missing after the delay
+            const stillMissing = new Set(this.slowCollection.getMissingTxHashes().map(h => h.toString()));
+            const remaining = txHashes.filter(h => stillMissing.has(h.toString()));
+            if (remaining.length > 0) {
+              this.fileStoreSlowCollection.startCollecting(remaining, context, deadline);
+            }
+          }
+        })
+        .catch(err => this.log.error('Error in file store slow delay', err));
+    }
   }
 
   /** Collects the set of txs for the given block proposal as fast as possible */
@@ -175,13 +243,38 @@ export class TxCollection {
     txHashes: TxHash[] | string[],
     opts: { deadline: Date; pinnedPeer?: PeerId },
   ) {
+    const hashes = txHashes.map(h => (typeof h === 'string' ? TxHash.fromString(h) : h));
+
+    // Delay file store collection to give P2P methods time to find txs first
+    if (this.hasFileStoreSources) {
+      const context = this.getAddContextForInput(input);
+      sleep(this.config.txCollectionFileStoreFastDelayMs)
+        .then(() => {
+          if (this.started) {
+            this.fileStoreFastCollection.startCollecting(hashes, context, opts.deadline);
+          }
+        })
+        .catch(err => this.log.error('Error in file store fast delay', err));
+    }
+
     return this.fastCollection.collectFastFor(input, txHashes, opts);
   }
 
+  /** Returns the TxAddContext for the given fast collection request input */
+  private getAddContextForInput(input: FastCollectionRequestInput): TxAddContext {
+    if (input.type === 'proposal') {
+      return { type: 'proposal', blockHeader: input.blockProposal.blockHeader };
+    } else {
+      return { type: 'mined', block: input.block };
+    }
+  }
+
   /** Mark the given txs as found. Stops collecting them. */
   private foundTxs(txs: Tx[]) {
     this.slowCollection.foundTxs(txs);
     this.fastCollection.foundTxs(txs);
+    this.fileStoreSlowCollection.foundTxs(txs);
+    this.fileStoreFastCollection.foundTxs(txs);
   }
 
   /**
@@ -191,6 +284,8 @@ export class TxCollection {
   public stopCollectingForBlocksUpTo(blockNumber: BlockNumber): void {
     this.slowCollection.stopCollectingForBlocksUpTo(blockNumber);
     this.fastCollection.stopCollectingForBlocksUpTo(blockNumber);
+    this.fileStoreSlowCollection.clearPending();
+    this.fileStoreFastCollection.clearPending();
   }
 
   /**
@@ -200,6 +295,8 @@ export class TxCollection {
   public stopCollectingForBlocksAfter(blockNumber: BlockNumber): void {
     this.slowCollection.stopCollectingForBlocksAfter(blockNumber);
     this.fastCollection.stopCollectingForBlocksAfter(blockNumber);
+    this.fileStoreSlowCollection.clearPending();
+    this.fileStoreFastCollection.clearPending();
   }
 
   /** Every now and then, check if the pool has received one of the txs we are looking for, just to catch any race conditions */

package/src/services/tx_collection/tx_collection_sink.ts

@@ -1,24 +1,29 @@
 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 } 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/index.js';
 import { TxCollectionInstrumentation } from './instrumentation.js';
 import type { CollectionMethod } from './tx_collection.js';
+import type { TxSourceCollectionResult } from './tx_source.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,
   ) {
@@ -27,51 +32,37 @@ export class TxCollectionSink extends (EventEmitter as new () => TypedEventEmitt
   }
 
   public async collect(
-    collectValidTxsFn: (txHashes: TxHash[]) => Promise<(Tx | undefined)[]>,
-    requested: TxHash[],
+    collectValidTxsFn: () => Promise<TxSourceCollectionResult>,
+    requested: string[],
     info: Record<string, any> & { description: string; method: CollectionMethod },
+    context: TxAddContext,
   ) {
     this.log.trace(`Requesting ${requested.length} txs via ${info.description}`, {
       ...info,
-      requestedTxs: requested.map(t => t.toString()),
+      requestedTxs: requested,
     });
 
     // Execute collection function and measure the time taken, catching any errors.
-    const [duration, txs] = await elapsed(async () => {
+    const [duration, { validTxs, invalidTxHashes }] = await elapsed(async () => {
       try {
-        const response = await collectValidTxsFn(requested);
-        return response.filter(tx => tx !== undefined);
+        return await collectValidTxsFn();
       } catch (err) {
         this.log.error(`Error collecting txs via ${info.description}`, err, {
           ...info,
-          requestedTxs: requested.map(hash => hash.toString()),
+          requestedTxs: requested,
         });
-        return [] as Tx[];
+        return { validTxs: [] as Tx[], invalidTxHashes: [] as string[] };
       }
     });
 
-    if (txs.length === 0) {
+    if (validTxs.length === 0 && invalidTxHashes.length === 0) {
       this.log.trace(`No txs found via ${info.description}`, {
         ...info,
-        requestedTxs: requested.map(t => t.toString()),
+        requestedTxs: requested,
       });
-      return { txs, requested, duration };
+      return { txs: validTxs, requested, duration };
     }
 
-    // Validate tx hashes for all collected txs from external sources
-    const validTxs: Tx[] = [];
-    const invalidTxHashes: string[] = [];
-    await Promise.all(
-      txs.map(async tx => {
-        const isValid = await tx.validateTxHash();
-        if (isValid) {
-          validTxs.push(tx);
-        } else {
-          invalidTxHashes.push(tx.getTxHash().toString());
-        }
-      }),
-    );
-
     if (invalidTxHashes.length > 0) {
       this.log.warn(`Rejecting ${invalidTxHashes.length} txs with invalid hashes from ${info.description}`, {
         ...info,
@@ -82,7 +73,7 @@ export class TxCollectionSink extends (EventEmitter as new () => TypedEventEmitt
     if (validTxs.length === 0) {
       this.log.trace(`No valid txs found via ${info.description} after validation`, {
         ...info,
-        requestedTxs: requested.map(t => t.toString()),
+        requestedTxs: requested,
         invalidTxHashes,
       });
       return { txs: [], requested, duration };
@@ -94,17 +85,18 @@ export class TxCollectionSink extends (EventEmitter as new () => TypedEventEmitt
         ...info,
         duration,
         txs: validTxs.map(t => t.getTxHash().toString()),
-        requestedTxs: requested.map(t => t.toString()),
+        requestedTxs: requested,
         rejectedCount: invalidTxHashes.length,
       },
     );
 
-    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 +104,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_collection/tx_source.ts

@@ -6,9 +6,11 @@ import type { Tx, TxHash } from '@aztec/stdlib/tx';
 import { type ComponentsVersions, getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
 import { makeTracedFetch } from '@aztec/telemetry-client';
 
+export type TxSourceCollectionResult = { validTxs: Tx[]; invalidTxHashes: string[] };
+
 export interface TxSource {
   getInfo(): string;
-  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+  getTxsByHash(txHashes: TxHash[]): Promise<TxSourceCollectionResult>;
 }
 
 export class NodeRpcTxSource implements TxSource {
@@ -26,8 +28,25 @@ export class NodeRpcTxSource implements TxSource {
     return this.info;
   }
 
-  public getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
-    return this.client.getTxsByHash(txHashes);
+  public async getTxsByHash(txHashes: TxHash[]): Promise<TxSourceCollectionResult> {
+    return this.verifyTxs(await this.client.getTxsByHash(txHashes));
+  }
+
+  private async verifyTxs(txs: Tx[]): Promise<TxSourceCollectionResult> {
+    // Validate tx hashes for all collected txs from external sources
+    const validTxs: Tx[] = [];
+    const invalidTxHashes: string[] = [];
+    await Promise.all(
+      txs.map(async tx => {
+        const isValid = await tx.validateTxHash();
+        if (isValid) {
+          validTxs.push(tx);
+        } else {
+          invalidTxHashes.push(tx.getTxHash().toString());
+        }
+      }),
+    );
+    return { validTxs: validTxs, invalidTxHashes: invalidTxHashes };
   }
 }
 

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)) {
@@ -144,7 +146,7 @@ export class TxFileStore {
       }
 
       await retry(
-        () => this.fileStore.save(path, tx.toBuffer(), { compress: false }),
+        () => this.fileStore.save(path, tx.toBuffer(), { compress: true }),
         `Uploading tx ${txHash}`,
         makeBackoff([0.1, 0.5, 2]),
         this.log,

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,8 +24,8 @@ export class TxProvider implements ITxProvider {
 
   constructor(
     private txCollection: TxCollection,
-    private txPool: TxPool,
-    private txValidator: Pick<P2PClient, 'validate'>,
+    private txPool: TxPoolV2,
+    private blockProposalTransactionValidator: Pick<P2PClient, 'validateTxsReceivedInBlockProposal'>,
     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.blockProposalTransactionValidator.validateTxsReceivedInBlockProposal(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,