@aztec-labs/p2p 6.0.0-nightly.20260829

package/src/services/tx_collection/tx_collection_sink.ts

@@ -0,0 +1,124 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import { elapsed } from '@aztec-labs/foundation/timer';
+import type { TypedEventEmitter } from '@aztec-labs/foundation/types';
+import type { L2Block } from '@aztec-labs/stdlib/block';
+import type { BlockHeader, Tx } from '@aztec-labs/stdlib/tx';
+import type { TelemetryClient } from '@aztec-labs/telemetry-client';
+import EventEmitter from 'node:events';
+
+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 fast collection paths, 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<TxPoolV2Events>) {
+  private readonly instrumentation: TxCollectionInstrumentation;
+
+  constructor(
+    private readonly txPool: TxPoolV2,
+    telemetryClient: TelemetryClient,
+    private readonly log: Logger,
+  ) {
+    super();
+    this.instrumentation = new TxCollectionInstrumentation(telemetryClient, 'TxCollection');
+  }
+
+  public async collect(
+    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,
+    });
+
+    // Execute collection function and measure the time taken, catching any errors.
+    const [duration, { validTxs, invalidTxHashes }] = await elapsed(async () => {
+      try {
+        return await collectValidTxsFn();
+      } catch (err) {
+        this.log.error(`Error collecting txs via ${info.description}`, err, {
+          ...info,
+          requestedTxs: requested,
+        });
+        return { validTxs: [] as Tx[], invalidTxHashes: [] as string[] };
+      }
+    });
+
+    if (validTxs.length === 0 && invalidTxHashes.length === 0) {
+      this.log.trace(`No txs found via ${info.description}`, {
+        ...info,
+        requestedTxs: requested,
+      });
+      return { txs: validTxs, requested, duration };
+    }
+
+    if (invalidTxHashes.length > 0) {
+      this.log.warn(`Rejecting ${invalidTxHashes.length} txs with invalid hashes from ${info.description}`, {
+        ...info,
+        invalidTxHashes,
+      });
+    }
+
+    if (validTxs.length === 0) {
+      this.log.trace(`No valid txs found via ${info.description} after validation`, {
+        ...info,
+        requestedTxs: requested,
+        invalidTxHashes,
+      });
+      return { txs: [], requested, duration };
+    }
+
+    this.log.verbose(
+      `Collected ${validTxs.length} txs out of ${requested.length} requested via ${info.description} in ${duration}ms`,
+      {
+        ...info,
+        duration,
+        txs: validTxs.map(t => t.getTxHash().toString()),
+        requestedTxs: requested,
+        rejectedCount: invalidTxHashes.length,
+      },
+    );
+
+    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);
+
+    // Mark txs as found in all in-flight collection requests
+    this.emit('txs-added', { txs });
+
+    // Add the txs to the tx pool using the appropriate method based on context
+    try {
+      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,
+        txs: txs.map(tx => tx.txHash.toString()),
+      });
+      // Return no txs since none have been added
+      return { txs: [] };
+    }
+
+    return { txs };
+  }
+}

package/src/services/tx_collection/tx_source.ts

@@ -0,0 +1,61 @@
+import { getVKTreeRoot } from '@aztec-labs/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec-labs/protocol-contracts';
+import type { ChainConfig } from '@aztec-labs/stdlib/config';
+import { type AztecNode, createAztecNodeClient } from '@aztec-labs/stdlib/interfaces/client';
+import type { Tx, TxHash, TxValidator } from '@aztec-labs/stdlib/tx';
+import { type ComponentsVersions, getComponentsVersionsFromConfig } from '@aztec-labs/stdlib/versioning';
+import { makeTracedFetch } from '@aztec-labs/telemetry-client';
+
+export type TxSourceCollectionResult = { validTxs: Tx[]; invalidTxHashes: string[] };
+
+export interface TxSource {
+  getInfo(): string;
+  getTxsByHash(txHashes: TxHash[]): Promise<TxSourceCollectionResult>;
+}
+
+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, txValidator: TxValidator, versions: ComponentsVersions): NodeRpcTxSource {
+    const client = createAztecNodeClient(nodeUrl, {
+      versions,
+      fetch: makeTracedFetch([1, 2, 3], false),
+    });
+    return new NodeRpcTxSource(client, txValidator, nodeUrl);
+  }
+
+  public getInfo() {
+    return this.info;
+  }
+
+  public async getTxsByHash(txHashes: TxHash[]): Promise<TxSourceCollectionResult> {
+    // Collected txs feed block validation and proving, so we need their proofs.
+    return this.verifyTxs(await this.client.getTxsByHash(txHashes, { includeProof: true }));
+  }
+
+  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 validation = await this.txValidator.validateTx(tx);
+        if (validation.result === 'valid') {
+          validTxs.push(tx);
+        } else {
+          invalidTxHashes.push(tx.getTxHash().toString());
+        }
+      }),
+    );
+    return { validTxs: validTxs, invalidTxHashes: invalidTxHashes };
+  }
+}
+
+export function createNodeRpcTxSources(urls: string[], txValidator: TxValidator, chainConfig: ChainConfig) {
+  const versions = getComponentsVersionsFromConfig(chainConfig, protocolContractsHash, getVKTreeRoot());
+  return urls.map(url => NodeRpcTxSource.fromUrl(url, txValidator, versions));
+}

package/src/services/tx_file_store/config.ts

@@ -0,0 +1,37 @@
+import { type ConfigMappingsType, booleanConfigHelper, numberConfigHelper } from '@aztec-labs/foundation/config';
+
+/**
+ * Configuration for the TxFileStore service.
+ */
+export type TxFileStoreConfig = {
+  /** URL for uploading txs to file storage (s3://, gs://, file://) */
+  txFileStoreUrl?: string;
+  /** Max concurrent uploads */
+  txFileStoreUploadConcurrency: number;
+  /** Max queue size to prevent unbounded memory growth */
+  txFileStoreMaxQueueSize: number;
+  /** Enable tx file store upload */
+  txFileStoreEnabled: boolean;
+};
+
+export const txFileStoreConfigMappings: ConfigMappingsType<TxFileStoreConfig> = {
+  txFileStoreUrl: {
+    env: 'TX_FILE_STORE_URL',
+    description: 'URL for uploading txs to file storage (s3://, gs://, file://)',
+  },
+  txFileStoreUploadConcurrency: {
+    env: 'TX_FILE_STORE_UPLOAD_CONCURRENCY',
+    description: 'Maximum number of concurrent tx uploads',
+    ...numberConfigHelper(10),
+  },
+  txFileStoreMaxQueueSize: {
+    env: 'TX_FILE_STORE_MAX_QUEUE_SIZE',
+    description: 'Maximum queue size for pending uploads (oldest dropped when exceeded)',
+    ...numberConfigHelper(1000),
+  },
+  txFileStoreEnabled: {
+    env: 'TX_FILE_STORE_ENABLED',
+    description: 'Enable uploading transactions to file storage',
+    ...booleanConfigHelper(false),
+  },
+};

package/src/services/tx_file_store/index.ts

@@ -0,0 +1,3 @@
+export { TxFileStore } from './tx_file_store.js';
+export { TxFileStoreInstrumentation } from './instrumentation.js';
+export { type TxFileStoreConfig, txFileStoreConfigMappings } from './config.js';

package/src/services/tx_file_store/instrumentation.ts

@@ -0,0 +1,42 @@
+import {
+  type Gauge,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+} from '@aztec-labs/telemetry-client';
+
+/** Instrumentation for the TxFileStore service. */
+export class TxFileStoreInstrumentation {
+  private uploadsSuccess: UpDownCounter;
+  private uploadsFailed: UpDownCounter;
+  private uploadsSkipped: UpDownCounter;
+  private uploadDuration: Histogram;
+  private queueSize: Gauge;
+
+  constructor(client: TelemetryClient, name: string) {
+    const meter = client.getMeter(name);
+    this.uploadsSuccess = meter.createUpDownCounter(Metrics.TX_FILE_STORE_UPLOADS_SUCCESS);
+    this.uploadsFailed = meter.createUpDownCounter(Metrics.TX_FILE_STORE_UPLOADS_FAILED);
+    this.uploadsSkipped = meter.createUpDownCounter(Metrics.TX_FILE_STORE_UPLOADS_SKIPPED);
+    this.uploadDuration = meter.createHistogram(Metrics.TX_FILE_STORE_UPLOAD_DURATION);
+    this.queueSize = meter.createGauge(Metrics.TX_FILE_STORE_QUEUE_SIZE);
+  }
+
+  recordUploadSuccess(durationMs: number) {
+    this.uploadsSuccess.add(1);
+    this.uploadDuration.record(durationMs);
+  }
+
+  recordUploadFailed() {
+    this.uploadsFailed.add(1);
+  }
+
+  recordUploadSkipped() {
+    this.uploadsSkipped.add(1);
+  }
+
+  recordQueueSize(size: number) {
+    this.queueSize.record(size);
+  }
+}

package/src/services/tx_file_store/tx_file_store.ts

@@ -0,0 +1,163 @@
+import { FifoSet } from '@aztec-labs/foundation/fifo-set';
+import { type Logger, createLogger } from '@aztec-labs/foundation/log';
+import { RunningPromise } from '@aztec-labs/foundation/promise';
+import { makeBackoff, retry } from '@aztec-labs/foundation/retry';
+import { Timer } from '@aztec-labs/foundation/timer';
+import { type FileStore, createFileStore } from '@aztec-labs/stdlib/file-store';
+import type { Tx } from '@aztec-labs/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec-labs/telemetry-client';
+
+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.
+ */
+export class TxFileStore {
+  private uploadQueue: Tx[] = [];
+  private activeUploads = 0;
+  private readonly queueProcessor: RunningPromise;
+  private readonly handleTxsAdded: (args: { txs: Tx[]; source?: string }) => void;
+
+  /** Recently uploaded tx hashes for deduplication. */
+  private recentUploads = FifoSet.withLimit<string>(MAX_RECENT_UPLOADS);
+
+  private constructor(
+    private readonly fileStore: FileStore,
+    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);
+    };
+    this.queueProcessor = new RunningPromise(() => this.processQueueBatch(), this.log, 100);
+  }
+
+  /**
+   * Creates and initializes the file store.
+   * @param txPool - The transaction pool to listen to.
+   * @param config - The file store configuration.
+   * @param log - Optional logger.
+   * @param telemetry - Optional telemetry client.
+   * @param fileStoreOverride - Optional FileStore for testing (bypasses createFileStore).
+   * @returns The file store instance, or undefined if not configured/enabled.
+   */
+  static async create(
+    txPool: TxPoolV2,
+    config: TxFileStoreConfig,
+    basePath: string,
+    log: Logger = createLogger('p2p:tx_file_store'),
+    telemetry: TelemetryClient = getTelemetryClient(),
+    fileStoreOverride?: FileStore,
+  ): Promise<TxFileStore | undefined> {
+    if (!config.txFileStoreEnabled) {
+      log.debug('Tx file store is disabled');
+      return undefined;
+    }
+
+    if (!config.txFileStoreUrl) {
+      log.warn('Tx file store is enabled but URL is not configured');
+      return undefined;
+    }
+
+    const fileStore = fileStoreOverride ?? (await createFileStore(config.txFileStoreUrl, log));
+    if (!fileStore) {
+      log.warn('Failed to create file store for tx file store');
+      return undefined;
+    }
+
+    const instrumentation = new TxFileStoreInstrumentation(telemetry, 'TxFileStore');
+    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. */
+  public start(): void {
+    this.queueProcessor.start();
+    this.txPool.on('txs-added', this.handleTxsAdded);
+    this.log.info('Started tx file store', {
+      concurrency: this.config.txFileStoreUploadConcurrency,
+      maxQueueSize: this.config.txFileStoreMaxQueueSize,
+    });
+  }
+
+  /** Stops listening and waits for pending uploads to complete. */
+  public async stop(): Promise<void> {
+    this.txPool.removeListener('txs-added', this.handleTxsAdded);
+    await this.queueProcessor.stop();
+    this.log.info('Stopped tx file store');
+  }
+
+  private enqueueTxs(txs: Tx[]): void {
+    this.uploadQueue.push(...txs);
+
+    // Enforce max queue size by dropping oldest entries
+    const overflow = this.uploadQueue.length - this.config.txFileStoreMaxQueueSize;
+    if (overflow > 0) {
+      this.log.warn(`Upload queue overflow, dropping ${overflow} oldest txs`);
+      this.uploadQueue.splice(0, overflow);
+    }
+
+    this.instrumentation.recordQueueSize(this.uploadQueue.length);
+
+    // Immediately start uploading txs
+    void this.queueProcessor.trigger();
+  }
+
+  private async processQueueBatch(): Promise<void> {
+    const batch = this.uploadQueue.splice(0, this.config.txFileStoreUploadConcurrency);
+    this.instrumentation.recordQueueSize(this.uploadQueue.length);
+
+    this.activeUploads += batch.length;
+    try {
+      await Promise.all(batch.map(tx => this.uploadTx(tx)));
+    } finally {
+      this.activeUploads -= batch.length;
+    }
+  }
+
+  private async uploadTx(tx: Tx): Promise<void> {
+    const txHash = tx.getTxHash().toString();
+    const path = `${this.basePath}/txs/${txHash}.bin`;
+    const timer = new Timer();
+
+    if (!this.recentUploads.addIfAbsent(txHash)) {
+      return;
+    }
+
+    try {
+      await retry(
+        () => this.fileStore.save(path, tx.toBuffer(), { compress: true }),
+        `Uploading tx ${txHash}`,
+        makeBackoff([0.1, 0.5, 2]),
+        this.log,
+        true, // failSilently - don't log errors during retries
+      );
+      const durationMs = Math.trunc(timer.ms());
+      this.log.debug(`Uploaded tx to file store`, { txHash, path, durationMs });
+      this.instrumentation.recordUploadSuccess(durationMs);
+    } catch (err) {
+      this.log.warn(`Failed to upload tx to file store after retries`, { txHash, error: err });
+      this.instrumentation.recordUploadFailed();
+    }
+  }
+
+  /** Waits for all queued and in-flight uploads to complete. For testing. */
+  public async flush(): Promise<void> {
+    while (this.uploadQueue.length > 0 || this.activeUploads > 0) {
+      await this.queueProcessor.trigger();
+    }
+  }
+
+  /** Returns the number of pending uploads (queued + in-flight). */
+  public getPendingUploadCount(): number {
+    return this.uploadQueue.length + this.activeUploads;
+  }
+}

package/src/services/tx_provider.ts

@@ -0,0 +1,237 @@
+import { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import { compactArray } from '@aztec-labs/foundation/collection';
+import { type Logger, createLogger } from '@aztec-labs/foundation/log';
+import { elapsed } from '@aztec-labs/foundation/timer';
+import type { L2Block, L2BlockInfo } from '@aztec-labs/stdlib/block';
+import type { ITxProvider } from '@aztec-labs/stdlib/interfaces/server';
+import type { BlockProposal } from '@aztec-labs/stdlib/p2p';
+import { type BlockHeader, Tx, TxHash } from '@aztec-labs/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec-labs/telemetry-client';
+import type { PeerId } from '@libp2p/interface';
+
+import type { P2PClient } from '../client/p2p_client.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';
+
+/**
+ * Gathers and returns txs given a block proposal, block, or their hashes.
+ * Loads available txs from the tx pool, and  relies on a TxCollection service to collect txs from the network and other nodes.
+ */
+export class TxProvider implements ITxProvider {
+  protected instrumentation: TxProviderInstrumentation;
+
+  constructor(
+    private txCollection: TxCollection,
+    private txPool: TxPoolV2,
+    private blockProposalTransactionValidator: Pick<P2PClient, 'validateTxsReceivedInBlockProposal'>,
+    private log: Logger = createLogger('p2p:tx-collector'),
+    client: TelemetryClient = getTelemetryClient(),
+  ) {
+    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);
+    if (response.length !== txHashes.length) {
+      throw new Error(`Unexpected response size from tx pool: expected ${txHashes.length} but got ${response.length}`);
+    }
+    const txs: Tx[] = [];
+    const missingTxs: TxHash[] = [];
+
+    for (let i = 0; i < txHashes.length; i++) {
+      const tx = response[i];
+      if (tx === undefined) {
+        missingTxs.push(txHashes[i]);
+      } else {
+        txs.push(tx);
+      }
+    }
+
+    return { txs, missingTxs };
+  }
+
+  /** Gathers txs from the tx pool, proposal body, remote rpc nodes, and reqresp. */
+  public getTxsForBlockProposal(
+    blockProposal: BlockProposal,
+    blockNumber: BlockNumber,
+    opts: { pinnedPeer: PeerId | undefined; deadline: Date },
+  ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    return this.getOrderedTxsFromAllSources(
+      { type: 'proposal', blockProposal, blockNumber },
+      { ...blockProposal.toBlockInfo(), blockNumber },
+      blockProposal.txHashes,
+      { ...opts, pinnedPeer: opts.pinnedPeer },
+    );
+  }
+
+  /** Gathers txs from the tx pool, remote rpc nodes, and reqresp. */
+  public getTxsForBlock(block: L2Block, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    return this.getOrderedTxsFromAllSources(
+      { type: 'block', block },
+      block.toBlockInfo(),
+      block.body.txEffects.map(tx => tx.txHash),
+      { ...opts, pinnedPeer: undefined },
+    );
+  }
+
+  private async getOrderedTxsFromAllSources(
+    request: FastCollectionRequestInput,
+    blockInfo: L2BlockInfo,
+    txHashes: TxHash[],
+    opts: { pinnedPeer: PeerId | undefined; deadline: Date },
+  ) {
+    const [durationMs, result] = await elapsed(() => this.getTxsFromAllSources(request, blockInfo, txHashes, opts));
+    const { missingTxHashes, txsFromMempool, txsFromNetwork, txsFromProposal } = result;
+
+    const txs = [...(txsFromMempool ?? []), ...(txsFromProposal ?? []), ...(txsFromNetwork ?? [])];
+    const missingTxs = missingTxHashes?.length ?? 0;
+
+    const level = missingTxs === 0 ? 'verbose' : 'warn';
+    this.log[level](`Retrieved ${txs.length} out of ${blockInfo.txCount} txs for ${request.type}`, {
+      ...blockInfo,
+      txsFromProposal: txsFromProposal?.length,
+      txsFromMempool: txsFromMempool?.length,
+      txsFromNetwork: txsFromNetwork?.length,
+      missingTxs,
+      durationMs,
+    });
+
+    const orderedTxs = this.orderTxs(txs, txHashes);
+    if (orderedTxs.length + missingTxs !== txHashes.length) {
+      throw new Error(
+        `Error collecting txs for ${request.type} with ${txHashes.length} txs: found ${orderedTxs.length} and flagged ${missingTxs} as missing`,
+      );
+    }
+
+    return { txs: orderedTxs, missingTxs: (missingTxHashes ?? []).map(TxHash.fromString), durationMs };
+  }
+
+  private orderTxs(txs: Tx[], order: TxHash[]): Tx[] {
+    const txsMap = new Map(txs.map(tx => [tx.txHash.toString(), tx]));
+    return order.map(hash => txsMap.get(hash.toString())!).filter(tx => tx !== undefined);
+  }
+
+  private async getTxsFromAllSources(
+    request: FastCollectionRequestInput,
+    blockInfo: L2BlockInfo,
+    txHashes: TxHash[],
+    opts: { pinnedPeer: PeerId | undefined; deadline: Date },
+  ) {
+    const missingTxHashes = new Set(txHashes.map(txHash => txHash.toString()));
+    if (missingTxHashes.size === 0) {
+      this.log.debug(`Received request with no transactions`, blockInfo);
+      return {};
+    }
+
+    // First go to our tx pool and fetch whatever txs we have there
+    // We go to the mempool first since those txs are already validated
+    const txsFromMempool = compactArray(await this.txPool.getTxsByHash(txHashes));
+    txsFromMempool.forEach(tx => missingTxHashes.delete(tx.getTxHash().toString()));
+    this.instrumentation.incTxsFromMempool(txsFromMempool.length);
+    this.log.debug(
+      `Retrieved ${txsFromMempool.length} txs from mempool for block proposal (${missingTxHashes.size} pending)`,
+      { ...blockInfo, missingTxHashes: [...missingTxHashes] },
+    );
+
+    if (missingTxHashes.size === 0) {
+      this.instrumentation.incTxsFromP2P(0, txHashes.length);
+      return { txsFromMempool };
+    }
+
+    // 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);
+      txsFromProposal.forEach(tx => missingTxHashes.delete(tx.txHash.toString()));
+      this.log.debug(`Retrieved ${txsFromProposal.length} txs from proposal body (${missingTxHashes.size} pending)`, {
+        ...blockInfo,
+        missingTxHashes: [...missingTxHashes],
+      });
+    }
+
+    if (missingTxHashes.size === 0) {
+      await this.processProposalTxs(txsFromProposal, proposalBlockHeader!);
+      this.instrumentation.incTxsFromP2P(0, txHashes.length);
+      return { txsFromMempool, txsFromProposal };
+    }
+
+    // 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, proposalBlockHeader!),
+    ] as const);
+
+    if (txsFromNetwork.length > 0) {
+      txsFromNetwork.forEach(tx => missingTxHashes.delete(tx.txHash.toString()));
+      this.log.debug(
+        `Retrieved ${txsFromNetwork.length} txs from network for block proposal (${missingTxHashes.size} pending)`,
+        { ...blockInfo, missingTxHashes: [...missingTxHashes] },
+      );
+    }
+
+    this.instrumentation.incTxsFromP2P(txsFromNetwork.length, txHashes.length);
+
+    if (missingTxHashes.size === 0) {
+      return { txsFromNetwork, txsFromMempool, txsFromProposal };
+    }
+
+    // We are still missing txs, make one last attempt to collect them from our pool, in case they showed up somehow else
+    const moreTxsFromPool = compactArray(await this.txPool.getTxsByHash([...missingTxHashes].map(TxHash.fromString)));
+
+    if (moreTxsFromPool.length > 0) {
+      this.instrumentation.incTxsFromMempool(moreTxsFromPool.length);
+      this.log.debug(
+        `Retrieved ${moreTxsFromPool.length} txs from pool retry for block proposal (${missingTxHashes.size} pending)`,
+        { ...blockInfo, missingTxHashes: [...missingTxHashes] },
+      );
+    }
+
+    if (missingTxHashes.size > 0) {
+      this.instrumentation.incMissingTxs(missingTxHashes.size);
+    }
+
+    return {
+      txsFromNetwork,
+      txsFromMempool: [...txsFromMempool, ...moreTxsFromPool],
+      txsFromProposal,
+      missingTxHashes: [...missingTxHashes],
+    };
+  }
+
+  private async collectFromP2P(
+    input: FastCollectionRequestInput,
+    txHashes: TxHash[] | string[],
+    opts: { deadline: Date; pinnedPeer?: PeerId },
+  ): Promise<Tx[]> {
+    const requestedAt = Date.now();
+    const result = await this.txCollection.collectFastFor(input, txHashes, opts);
+    const requestProcessedAt = Date.now();
+    this.instrumentation.recordTxsRequestDelay(requestProcessedAt - requestedAt);
+    return result;
+  }
+
+  private extractFromProposal(proposal: BlockProposal | undefined, missingTxHashes: string[]): Tx[] {
+    if (!proposal) {
+      return [];
+    }
+    return compactArray(proposal.txs ?? []).filter(tx => missingTxHashes.includes(tx.getTxHash().toString()));
+  }
+
+  private async processProposalTxs(txs: Tx[], blockHeader: BlockHeader): Promise<void> {
+    if (txs.length === 0) {
+      return;
+    }
+    await this.blockProposalTransactionValidator.validateTxsReceivedInBlockProposal(txs);
+    await this.txPool.addProtectedTxs(txs, blockHeader);
+  }
+}