@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/services/reqresp/status.ts

@@ -5,17 +5,22 @@ export enum ReqRespStatus {
   SUCCESS = 0,
   RATE_LIMIT_EXCEEDED = 1,
   BADLY_FORMED_REQUEST = 2,
+  INTERNAL_ERROR = 3,
+  NOT_FOUND = 4,
+  FAILURE = 126,
   UNKNOWN = 127,
 }
 
+export type UnsuccessfulReqRespStatus = Exclude<ReqRespStatus, ReqRespStatus.SUCCESS>;
+
 export class ReqRespStatusError extends Error {
   /**
    * The status code
    */
-  status: ReqRespStatus;
+  readonly status: UnsuccessfulReqRespStatus;
 
-  constructor(status: ReqRespStatus) {
-    super(`ReqResp Error: ${prettyPrintReqRespStatus(status)}`);
+  constructor(status: UnsuccessfulReqRespStatus, cause?: { cause?: Error }) {
+    super(`ReqResp Error: ${prettyPrintReqRespStatus(status)}`, cause);
     this.status = status;
   }
 }
@@ -53,6 +58,10 @@ export function prettyPrintReqRespStatus(status: ReqRespStatus) {
       return 'RATE_LIMIT_EXCEEDED';
     case ReqRespStatus.BADLY_FORMED_REQUEST:
       return 'BADLY_FORMED_REQUEST';
+    case ReqRespStatus.FAILURE:
+      return 'FAILURE';
+    case ReqRespStatus.INTERNAL_ERROR:
+      return 'INTERNAL_ERROR';
     case ReqRespStatus.UNKNOWN:
       return 'UNKNOWN';
   }

package/src/services/service.ts

@@ -1,17 +1,34 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
 import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/stdlib/p2p';
+import type { Tx } from '@aztec/stdlib/tx';
 
-import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
+import type { ENR } from '@nethermindeth/enr';
 import type EventEmitter from 'events';
 
-import type { ReqRespSubProtocol, SubProtocolMap } from './reqresp/interface.js';
+import type { P2PReqRespConfig } from './reqresp/config.js';
+import type { StatusMessage } from './reqresp/index.js';
+import type {
+  ReqRespSubProtocol,
+  ReqRespSubProtocolHandler,
+  ReqRespSubProtocolValidators,
+  SubProtocolMap,
+} from './reqresp/interface.js';
+import type { AuthRequest, AuthResponse } from './reqresp/protocols/auth.js';
 
 export enum PeerDiscoveryState {
   RUNNING = 'running',
   STOPPED = 'stopped',
 }
 
+export type P2PBlockReceivedCallback = (
+  block: BlockProposal,
+  sender: PeerId,
+) => Promise<BlockAttestation[] | undefined>;
+
+export type AuthReceivedCallback = (peerId: PeerId, authRequest: AuthRequest) => Promise<AuthResponse | undefined>;
+
 /**
  * The interface for a P2P service implementation.
  */
@@ -32,19 +49,7 @@ export interface P2PService {
    * Called to have the given transaction propagated through the P2P network.
    * @param message - The message to be propagated.
    */
-  propagate<T extends Gossipable>(message: T): void;
-
-  /**
-   * Request information from peers via the request response protocol.
-   *
-   * @param protocol - The request response protocol to use
-   * @param request - The request type, corresponding to the protocol
-   * @returns The response type, corresponding to the protocol
-   */
-  sendRequest<Protocol extends ReqRespSubProtocol>(
-    protocol: Protocol,
-    request: InstanceType<SubProtocolMap[Protocol]['request']>,
-  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']> | undefined>;
+  propagate<T extends Gossipable>(message: T): Promise<void>;
 
   /**
    * Send a batch of requests to peers, and return the responses
@@ -56,14 +61,33 @@ export interface P2PService {
   sendBatchRequest<Protocol extends ReqRespSubProtocol>(
     protocol: Protocol,
     requests: InstanceType<SubProtocolMap[Protocol]['request']>[],
-  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[] | undefined>;
+    pinnedPeerId?: PeerId,
+    timeoutMs?: number,
+    maxPeers?: number,
+    maxRetryAttempts?: number,
+  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[]>;
 
   // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
-  registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation | undefined>): void;
+  registerBlockReceivedCallback(callback: P2PBlockReceivedCallback): void;
 
   getEnr(): ENR | undefined;
 
   getPeers(includePending?: boolean): PeerInfo[];
+
+  validate(txs: Tx[]): Promise<void>;
+
+  addReqRespSubProtocol(
+    subProtocol: ReqRespSubProtocol,
+    handler: ReqRespSubProtocolHandler,
+    validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
+  ): Promise<void>;
+
+  handleAuthRequestFromPeer(authRequest: AuthRequest, peerId: PeerId): Promise<StatusMessage>;
+
+  updateConfig(config: Partial<P2PReqRespConfig>): void;
+
+  /** If node running this P2P stack is validator, passes in validator address to P2P layer */
+  registerThisValidatorAddresses(address: EthAddress[]): void;
 }
 
 /**
@@ -81,10 +105,10 @@ export interface PeerDiscoveryService extends EventEmitter {
   stop(): Promise<void>;
 
   /**
-   * Gets all peers.
-   * @returns An array of peer ENRs.
+   * Gets all KadValues.
+   * @returns An array of ENRs.
    */
-  getAllPeers(): ENR[];
+  getKadValues(): ENR[];
 
   /**
    * Runs findRandomNode query.
@@ -108,5 +132,5 @@ export interface PeerDiscoveryService extends EventEmitter {
 
   getEnr(): ENR | undefined;
 
-  bootstrapNodes: string[];
+  bootstrapNodeEnrs: ENR[];
 }

package/src/services/tx_collection/config.ts

@@ -0,0 +1,84 @@
+import { type ConfigMappingsType, booleanConfigHelper, numberConfigHelper } from '@aztec/foundation/config';
+import { MAX_RPC_TXS_LEN } from '@aztec/stdlib/interfaces/server';
+
+export type TxCollectionConfig = {
+  /** How long to wait before starting reqresp for fast collection  */
+  txCollectionFastNodesTimeoutBeforeReqRespMs: number;
+  /** How often to collect from configured nodes */
+  txCollectionSlowNodesIntervalMs: number;
+  /** How ofter to collect from peers */
+  txCollectionSlowReqRespIntervalMs: number;
+  /** How long to wait for a reqresp response during slow collection */
+  txCollectionSlowReqRespTimeoutMs: number;
+  /** How often to reconcile found txs with the tx pool */
+  txCollectionReconcileIntervalMs: number;
+  /** Whether to disable the slow collection loop if we are dealing with any immediate requests */
+  txCollectionDisableSlowDuringFastRequests: boolean;
+  /** How many ms to wait between retried request to a node via RPC during fast collection */
+  txCollectionFastNodeIntervalMs: number;
+  /** A comma-separated list of Aztec node RPC URLs to use for tx collection */
+  txCollectionNodeRpcUrls: string[];
+  /** Maximum number of parallel requests to make to a node during fast collection */
+  txCollectionFastMaxParallelRequestsPerNode: number;
+  /** Maximum number of transactions to request from a node in a single batch */
+  txCollectionNodeRpcMaxBatchSize: number;
+};
+
+export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig> = {
+  txCollectionFastNodesTimeoutBeforeReqRespMs: {
+    env: 'TX_COLLECTION_FAST_NODES_TIMEOUT_BEFORE_REQ_RESP_MS',
+    description: 'How long to wait before starting reqresp for fast collection',
+    ...numberConfigHelper(200),
+  },
+  txCollectionSlowNodesIntervalMs: {
+    env: 'TX_COLLECTION_SLOW_NODES_INTERVAL_MS',
+    description: 'How often to collect from configured nodes in the slow collection loop',
+    ...numberConfigHelper(12_000),
+  },
+  txCollectionSlowReqRespIntervalMs: {
+    env: 'TX_COLLECTION_SLOW_REQ_RESP_INTERVAL_MS',
+    description: 'How often to collect from peers via reqresp in the slow collection loop',
+    ...numberConfigHelper(12_000),
+  },
+  txCollectionSlowReqRespTimeoutMs: {
+    env: 'TX_COLLECTION_SLOW_REQ_RESP_TIMEOUT_MS',
+    description: 'How long to wait for a reqresp response during slow collection',
+    ...numberConfigHelper(20_000),
+  },
+  txCollectionReconcileIntervalMs: {
+    env: 'TX_COLLECTION_RECONCILE_INTERVAL_MS',
+    description: 'How often to reconcile found txs from the tx pool',
+    ...numberConfigHelper(60_000),
+  },
+  txCollectionDisableSlowDuringFastRequests: {
+    env: 'TX_COLLECTION_DISABLE_SLOW_DURING_FAST_REQUESTS',
+    description: 'Whether to disable the slow collection loop if we are dealing with any immediate requests',
+    ...booleanConfigHelper(true),
+  },
+  txCollectionFastNodeIntervalMs: {
+    env: 'TX_COLLECTION_FAST_NODE_INTERVAL_MS',
+    description: 'How many ms to wait between retried request to a node via RPC during fast collection',
+    ...numberConfigHelper(500),
+  },
+  txCollectionNodeRpcUrls: {
+    env: 'TX_COLLECTION_NODE_RPC_URLS',
+    fallback: ['PROVER_COORDINATION_NODE_URLS'],
+    description: 'A comma-separated list of Aztec node RPC URLs to use for tx collection',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(url => url.trim().replace(/\/$/, ''))
+        .filter(url => url.length > 0),
+    defaultValue: [],
+  },
+  txCollectionFastMaxParallelRequestsPerNode: {
+    env: 'TX_COLLECTION_FAST_MAX_PARALLEL_REQUESTS_PER_NODE',
+    description: 'Maximum number of parallel requests to make to a node during fast collection',
+    ...numberConfigHelper(4),
+  },
+  txCollectionNodeRpcMaxBatchSize: {
+    env: 'TX_COLLECTION_NODE_RPC_MAX_BATCH_SIZE',
+    description: 'Maximum number of transactions to request from a node in a single batch',
+    ...numberConfigHelper(MAX_RPC_TXS_LEN),
+  },
+};

package/src/services/tx_collection/fast_tx_collection.ts

@@ -0,0 +1,340 @@
+import { times } from '@aztec/foundation/collection';
+import { AbortError, TimeoutError } from '@aztec/foundation/error';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { boundInclusive } from '@aztec/foundation/number';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { sleep } from '@aztec/foundation/sleep';
+import { DateProvider, elapsed } from '@aztec/foundation/timer';
+import type { L2BlockInfo } from '@aztec/stdlib/block';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+
+import { type ReqRespInterface, ReqRespSubProtocol } from '../reqresp/interface.js';
+import { chunkTxHashesRequest } from '../reqresp/protocols/tx.js';
+import type { TxCollectionConfig } from './config.js';
+import type { FastCollectionRequest, FastCollectionRequestInput } from './tx_collection.js';
+import type { TxCollectionSink } from './tx_collection_sink.js';
+import type { TxSource } from './tx_source.js';
+
+export class FastTxCollection {
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  protected requests: Set<FastCollectionRequest> = new Set();
+
+  constructor(
+    private reqResp: Pick<ReqRespInterface, 'sendBatchRequest'>,
+    private nodes: TxSource[],
+    private txCollectionSink: TxCollectionSink,
+    private config: TxCollectionConfig,
+    private dateProvider: DateProvider = new DateProvider(),
+    private log: Logger = createLogger('p2p:tx_collection_service'),
+  ) {}
+
+  public async stop() {
+    this.requests.forEach(request => request.promise.reject(new AbortError(`Stopped collection service`)));
+    await Promise.resolve();
+  }
+
+  public getFastCollectionRequests() {
+    return this.requests;
+  }
+
+  public async collectFastFor(
+    input: FastCollectionRequestInput,
+    txHashes: TxHash[] | string[],
+    opts: { deadline: Date; pinnedPeer?: PeerId },
+  ) {
+    const timeout = opts.deadline.getTime() - this.dateProvider.now();
+    if (timeout <= 0) {
+      this.log.warn(`Deadline for fast tx collection is in the past (${timeout}ms)`, {
+        deadline: opts.deadline.getTime(),
+        now: this.dateProvider.now(),
+      });
+      return [];
+    }
+
+    const blockInfo: L2BlockInfo =
+      input.type === 'proposal'
+        ? { ...input.blockProposal.toBlockInfo(), blockNumber: input.blockNumber }
+        : { ...input.block.toBlockInfo() };
+
+    // This promise is used to await for the collection to finish during the main collectFast method.
+    // It gets resolved in `foundTxs` when all txs have been collected, or rejected if the request is aborted or hits the deadline.
+    const promise = promiseWithResolvers<void>();
+    setTimeout(() => promise.reject(new TimeoutError(`Timed out while collecting txs`)), timeout);
+
+    const request: FastCollectionRequest = {
+      ...input,
+      blockInfo,
+      promise,
+      foundTxs: new Map<string, Tx>(),
+      missingTxHashes: new Set(txHashes.map(t => t.toString())),
+      deadline: opts.deadline,
+    };
+
+    const [duration] = await elapsed(() => this.collectFast(request, { ...opts }));
+
+    this.log.verbose(
+      `Collected ${request.foundTxs.size} txs out of ${txHashes.length} for ${input.type} at slot ${blockInfo.slotNumber}`,
+      {
+        ...blockInfo,
+        duration,
+        requestType: input.type,
+        missingTxs: [...request.missingTxHashes],
+      },
+    );
+    return [...request.foundTxs.values()];
+  }
+
+  protected async collectFast(
+    request: FastCollectionRequest,
+    opts: { proposal?: BlockProposal; deadline: Date; pinnedPeer?: PeerId },
+  ) {
+    this.requests.add(request);
+    const { blockInfo } = request;
+
+    this.log.debug(
+      `Starting fast collection of ${request.missingTxHashes.size} txs for ${request.type} at slot ${blockInfo.slotNumber}`,
+      { ...blockInfo, requestType: request.type, deadline: opts.deadline },
+    );
+
+    try {
+      // Start blasting all nodes for the txs. We give them a little time to respond before we start reqresp.
+      // And keep an eye on the request promise to ensure we don't wait longer than the deadline or return as soon
+      // as we have collected all txs, whatever the source.
+      const nodeCollectionPromise = this.collectFastFromNodes(request, opts);
+      const waitBeforeReqResp = sleep(this.config.txCollectionFastNodesTimeoutBeforeReqRespMs);
+      await Promise.race([request.promise.promise, waitBeforeReqResp]);
+
+      // If we have collected all txs, we can stop here
+      if (request.missingTxHashes.size === 0) {
+        this.log.debug(`All txs collected for slot ${blockInfo.slotNumber} without reqresp`, blockInfo);
+        return;
+      }
+
+      // Start blasting reqresp for the remaining txs. Note that node collection keeps running in parallel.
+      // We stop when we have collected all txs, timed out, or both node collection and reqresp have given up.
+      const collectionPromise = Promise.allSettled([this.collectFastViaReqResp(request, opts), nodeCollectionPromise]);
+      await Promise.race([collectionPromise, request.promise.promise]);
+    } catch (err) {
+      // Log and swallow all errors
+      const logCtx = {
+        ...blockInfo,
+        errorMessage: err instanceof Error ? err.message : undefined,
+        missingTxs: [...request.missingTxHashes].map(txHash => txHash.toString()),
+      };
+      if (err instanceof Error && err.name === 'TimeoutError') {
+        this.log.warn(`Timed out collecting txs for ${request.type} at slot ${blockInfo.slotNumber}`, logCtx);
+      } else if (err instanceof Error && err.name === 'AbortError') {
+        this.log.warn(`Aborted collecting txs for ${request.type} at slot ${blockInfo.slotNumber}`, logCtx);
+      } else {
+        this.log.error(`Error collecting txs for ${request.type} for slot ${blockInfo.slotNumber}`, err, logCtx);
+      }
+    } finally {
+      // Ensure no unresolved promises and remove the request from the set
+      request.promise.resolve();
+      this.requests.delete(request);
+    }
+  }
+
+  /**
+   * Starts collecting txs from all configured nodes. We send `txCollectionFastMaxParallelRequestsPerNode` requests
+   * in parallel to each node. We keep track of the number of attempts made to collect each tx, so we can prioritize
+   * the txs that have been requested less often whenever we need to send a new batch of requests. We ensure that no
+   * tx is requested more than once at the same time to the same node.
+   */
+  private async collectFastFromNodes(request: FastCollectionRequest, opts: { deadline: Date }): Promise<void> {
+    if (this.nodes.length === 0) {
+      return;
+    }
+
+    // Keep a shared priority queue of all txs pending to be requested, sorted by the number of attempts made to collect them.
+    const attemptsPerTx = [...request.missingTxHashes].map(txHash => ({ txHash, attempts: 0, found: false }));
+
+    // Returns once we have finished all node loops. Each loop finishes when the deadline is hit, or all txs have been collected.
+    await Promise.allSettled(this.nodes.map(node => this.collectFastFromNode(request, node, attemptsPerTx, opts)));
+  }
+
+  private async collectFastFromNode(
+    request: FastCollectionRequest,
+    node: TxSource,
+    attemptsPerTx: { txHash: string; attempts: number; found: boolean }[],
+    opts: { deadline: Date },
+  ) {
+    const notFinished = () =>
+      this.dateProvider.now() <= +opts.deadline && request.missingTxHashes.size > 0 && this.requests.has(request);
+
+    const maxParallelRequests = this.config.txCollectionFastMaxParallelRequestsPerNode;
+    const maxBatchSize = this.config.txCollectionNodeRpcMaxBatchSize;
+    const activeRequestsToThisNode = new Set<string>(); // Track the txs being actively requested to this node
+
+    const processBatch = async () => {
+      while (notFinished()) {
+        // Pull tx hashes from the attemptsPerTx array, which is sorted by attempts,
+        // so we prioritize txs that have been requested less often.
+        const batch = [];
+        let index = 0;
+        while (batch.length < maxBatchSize) {
+          const txToRequest = attemptsPerTx[index++];
+          if (!txToRequest) {
+            // No more txs to process
+            break;
+          } else if (!request.missingTxHashes.has(txToRequest.txHash)) {
+            // Mark as found if it was found somewhere else, we'll then remove it from the array.
+            // We don't delete it now since 'array.splice' is pretty expensive, so we do it after sorting.
+            txToRequest.found = true;
+          } else if (!activeRequestsToThisNode.has(txToRequest.txHash)) {
+            // If the tx is not alredy being requested to this node, add it to the current batch and increase attempts.
+            // Note that we increase the attempts *before* making the request, so the next `collectFastFromNode` that
+            // needs to grab txs to send, will pick txs that have been requested less often, instead of all requesting
+            // the same txs at the same time.
+            batch.push(txToRequest);
+            activeRequestsToThisNode.add(txToRequest.txHash);
+            txToRequest.attempts++;
+          }
+        }
+
+        // After modifying the array by removing txs or updating attempts, re-sort it and trim the found txs from the end.
+        attemptsPerTx.sort((a, b) =>
+          a.found === b.found ? a.attempts - b.attempts : Number(a.found) - Number(b.found),
+        );
+        const firstFoundTxIndex = attemptsPerTx.findIndex(tx => tx.found);
+        if (firstFoundTxIndex !== -1) {
+          attemptsPerTx.length = firstFoundTxIndex;
+        }
+
+        // If we see no more txs to request, we can stop this "process" loop
+        if (batch.length === 0) {
+          return;
+        }
+
+        // Collect this batch from the node
+        await this.txCollectionSink.collect(
+          txHashes => node.getTxsByHash(txHashes),
+          batch.map(({ txHash }) => TxHash.fromString(txHash)),
+          {
+            description: `fast ${node.getInfo()}`,
+            node: node.getInfo(),
+            method: 'fast-node-rpc',
+            ...request.blockInfo,
+          },
+        );
+
+        // Clear from the active requests the txs we just requested
+        for (const requestedTx of batch) {
+          activeRequestsToThisNode.delete(requestedTx.txHash);
+        }
+
+        // Sleep a bit until hitting the node again (or not, depending on config)
+        if (notFinished()) {
+          await sleep(this.config.txCollectionFastNodeIntervalMs);
+        }
+      }
+    };
+
+    // Kick off N parallel requests to the node, up to the maxParallelRequests limit
+    await Promise.all(times(maxParallelRequests, processBatch));
+  }
+
+  private async collectFastViaReqResp(request: FastCollectionRequest, opts: { pinnedPeer?: PeerId }) {
+    const timeoutMs = +request.deadline - this.dateProvider.now();
+    const pinnedPeer = opts.pinnedPeer;
+    const maxPeers = boundInclusive(Math.ceil(request.missingTxHashes.size / 2), 8, 32);
+    const maxRetryAttempts = 5;
+    const blockInfo = request.blockInfo;
+    const slotNumber = blockInfo.slotNumber;
+    if (timeoutMs < 100) {
+      this.log.warn(
+        `Not initiating fast reqresp for txs for ${request.type} at slot ${blockInfo.slotNumber} due to timeout`,
+        { timeoutMs, ...blockInfo },
+      );
+      return;
+    }
+
+    this.log.debug(
+      `Starting fast reqresp for ${request.missingTxHashes.size} txs for ${request.type} at slot ${blockInfo.slotNumber}`,
+      { ...blockInfo, timeoutMs, pinnedPeer },
+    );
+
+    try {
+      await this.txCollectionSink.collect(
+        async txHashes => {
+          const txs = await this.reqResp.sendBatchRequest<ReqRespSubProtocol.TX>(
+            ReqRespSubProtocol.TX,
+            chunkTxHashesRequest(txHashes),
+            pinnedPeer,
+            timeoutMs,
+            maxPeers,
+            maxRetryAttempts,
+          );
+
+          return txs.flat();
+        },
+        Array.from(request.missingTxHashes).map(txHash => TxHash.fromString(txHash)),
+        { description: `reqresp for slot ${slotNumber}`, method: 'fast-req-resp', ...opts, ...request.blockInfo },
+      );
+    } catch (err) {
+      this.log.error(`Error sending fast reqresp request for txs`, err, {
+        txs: [...request.missingTxHashes],
+        ...blockInfo,
+      });
+    }
+  }
+
+  /**
+   * Handle txs by marking them as found for the requests that are waiting for them, and resolves the request if all its txs have been found.
+   * Called internally and from the main tx collection manager whenever the tx pool emits a tx-added event.
+   */
+  public foundTxs(txs: Tx[]) {
+    for (const request of this.requests) {
+      for (const tx of txs) {
+        const txHash = tx.txHash.toString();
+        // Remove the tx hash from the missing set, and add it to the found set.
+        if (request.missingTxHashes.has(txHash)) {
+          request.missingTxHashes.delete(txHash);
+          request.foundTxs.set(txHash, tx);
+          this.log.trace(`Found tx ${txHash} for fast collection request`, {
+            ...request.blockInfo,
+            txHash: tx.txHash.toString(),
+            type: request.type,
+          });
+          // If we found all txs for this request, we resolve the promise
+          if (request.missingTxHashes.size === 0) {
+            this.log.trace(`All txs found for fast collection request`, {
+              ...request.blockInfo,
+              type: request.type,
+            });
+            request.promise.resolve();
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Stop collecting all txs for blocks less than or requal to the block number specified.
+   * To be called when we no longer care about gathering txs up to a certain block, eg when they become proven or finalized.
+   */
+  public stopCollectingForBlocksUpTo(blockNumber: number): void {
+    for (const request of this.requests) {
+      if (request.blockInfo.blockNumber <= blockNumber) {
+        request.promise.reject(new AbortError(`Stopped collecting txs up to block ${blockNumber}`));
+        this.requests.delete(request);
+      }
+    }
+  }
+
+  /**
+   * Stop collecting all txs for blocks greater than the block number specified.
+   * To be called when there is a chain prune and previously mined txs are no longer relevant.
+   */
+  public stopCollectingForBlocksAfter(blockNumber: number): void {
+    for (const request of this.requests) {
+      if (request.blockInfo.blockNumber > blockNumber) {
+        request.promise.reject(new AbortError(`Stopped collecting txs after block ${blockNumber}`));
+        this.requests.delete(request);
+      }
+    }
+  }
+}

package/src/services/tx_collection/index.ts

@@ -0,0 +1,2 @@
+export { TxCollection, type FastCollectionRequestInput } from './tx_collection.js';
+export { type TxSource, createNodeRpcTxSources, NodeRpcTxSource } from './tx_source.js';

package/src/services/tx_collection/instrumentation.ts

@@ -0,0 +1,43 @@
+import {
+  Attributes,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+import type { CollectionMethod } from './tx_collection.js';
+
+export class TxCollectionInstrumentation {
+  private txsCollected: UpDownCounter;
+  private collectionDurationPerTx: Histogram;
+  private collectionDurationPerRequest: Histogram;
+
+  constructor(client: TelemetryClient, name: string) {
+    const meter = client.getMeter(name);
+
+    this.txsCollected = meter.createUpDownCounter(Metrics.TX_COLLECTOR_COUNT, {
+      description: 'The number of txs collected',
+    });
+
+    this.collectionDurationPerTx = meter.createHistogram(Metrics.TX_COLLECTOR_DURATION_PER_TX, {
+      unit: 'ms',
+      description: 'Average duration per tx of an individual tx collection request',
+      valueType: ValueType.INT,
+    });
+
+    this.collectionDurationPerRequest = meter.createHistogram(Metrics.TX_COLLECTOR_DURATION_PER_REQUEST, {
+      unit: 'ms',
+      description: 'Total duration of an individual tx collection request',
+      valueType: ValueType.INT,
+    });
+  }
+
+  increaseTxsFor(what: CollectionMethod, count: number, duration: number) {
+    const durationPerTx = Math.ceil(duration / count);
+    this.collectionDurationPerTx.record(durationPerTx, { [Attributes.TX_COLLECTION_METHOD]: what });
+    this.collectionDurationPerRequest.record(Math.ceil(duration), { [Attributes.TX_COLLECTION_METHOD]: what });
+    this.txsCollected.add(count, { [Attributes.TX_COLLECTION_METHOD]: what });
+  }
+}