@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.017a351

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,78 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+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 {
+  BlockProposal,
+  CheckpointAttestation,
+  CheckpointProposalCore,
+  Gossipable,
+  TopicType,
+} 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 { BatchTxRequesterLibP2PService } from './reqresp/batch-tx-requester/interface.js';
+import type { P2PReqRespConfig } from './reqresp/config.js';
+import type { StatusMessage } from './reqresp/index.js';
+import type { ReqRespSubProtocol, ReqRespSubProtocolHandler } from './reqresp/interface.js';
+import type { AuthRequest, AuthResponse } from './reqresp/protocols/auth.js';
 
 export enum PeerDiscoveryState {
   RUNNING = 'running',
   STOPPED = 'stopped',
 }
 
+/**
+ * Callback for when a block proposal is received.
+ * Validators validate but DO NOT attest to individual blocks - attestations are only for checkpoints.
+ * @returns true if the proposal is valid, false otherwise
+ */
+export type P2PBlockReceivedCallback = (block: BlockProposal, sender: PeerId) => Promise<boolean>;
+
+/**
+ * Callback for when a checkpoint proposal is received.
+ * The checkpoint proposal is passed as CheckpointProposalCore (without lastBlock) since
+ * the lastBlock is extracted and stored separately as a BlockProposal, and the block
+ * callback is invoked and awaited before this checkpoint callback.
+ */
+export type P2PCheckpointReceivedCallback = (
+  checkpoint: CheckpointProposalCore,
+  sender: PeerId,
+) => Promise<CheckpointAttestation[] | undefined>;
+
+export type AuthReceivedCallback = (peerId: PeerId, authRequest: AuthRequest) => Promise<AuthResponse | undefined>;
+
+/** Minimal info passed to the duplicate proposal callback. */
+export type DuplicateProposalInfo = {
+  slot: SlotNumber;
+  proposer: EthAddress;
+  type: 'checkpoint' | 'block';
+};
+
+/**
+ * Callback for when a duplicate proposal is detected (equivocation).
+ * Invoked on the first duplicate (when count goes from 1 to 2).
+ */
+export type P2PDuplicateProposalCallback = (info: DuplicateProposalInfo) => void;
+
+/** Minimal info passed to the duplicate attestation callback. */
+export type DuplicateAttestationInfo = {
+  slot: SlotNumber;
+  attester: EthAddress;
+};
+
+/**
+ * Callback for when a duplicate attestation is detected (equivocation).
+ * A validator signing attestations for different proposals at the same slot.
+ * Invoked on the first duplicate (when count goes from 1 to 2).
+ */
+export type P2PDuplicateAttestationCallback = (info: DuplicateAttestationInfo) => void;
+
+export type P2PCheckpointAttestationCallback = (attestation: CheckpointAttestation) => void;
+
 /**
  * The interface for a P2P service implementation.
  */
@@ -32,38 +93,50 @@ 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;
+  propagate<T extends Gossipable>(message: T): Promise<void>;
+
+  // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
+  registerBlockReceivedCallback(callback: P2PBlockReceivedCallback): void;
+
+  registerValidatorCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback): void;
+
+  registerAllNodesCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback): 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
+   * Registers a callback invoked when a duplicate proposal is detected (equivocation).
+   * The callback is triggered on the first duplicate (when count goes from 1 to 2).
    */
-  sendRequest<Protocol extends ReqRespSubProtocol>(
-    protocol: Protocol,
-    request: InstanceType<SubProtocolMap[Protocol]['request']>,
-  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']> | undefined>;
+  registerDuplicateProposalCallback(callback: P2PDuplicateProposalCallback): void;
 
   /**
-   * Send a batch of requests to peers, and return the responses
-   *
-   * @param protocol - The request response protocol to use
-   * @param requests - The requests to send to the peers
-   * @returns The responses to the requests
+   * Registers a callback invoked when a duplicate attestation is detected (equivocation).
+   * A validator signing attestations for different proposals at the same slot.
+   * The callback is triggered on the first duplicate (when count goes from 1 to 2).
    */
-  sendBatchRequest<Protocol extends ReqRespSubProtocol>(
-    protocol: Protocol,
-    requests: InstanceType<SubProtocolMap[Protocol]['request']>[],
-  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[] | undefined>;
+  registerDuplicateAttestationCallback(callback: P2PDuplicateAttestationCallback): void;
 
-  // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
-  registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation | undefined>): void;
+  registerCheckpointAttestationCallback(callback: P2PCheckpointAttestationCallback): void;
 
   getEnr(): ENR | undefined;
 
   getPeers(includePending?: boolean): PeerInfo[];
+
+  /** Returns the number of peers in the GossipSub mesh for a given topic type. */
+  getGossipMeshPeerCount(topicType: TopicType): number;
+
+  validateTxsReceivedInBlockProposal(txs: Tx[]): Promise<void>;
+
+  addReqRespSubProtocol(subProtocol: ReqRespSubProtocol, handler: ReqRespSubProtocolHandler): 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;
+
+  /** Get BatchTxRequester service dependencies */
+  getBatchTxRequesterService(): BatchTxRequesterLibP2PService;
 }
 
 /**
@@ -81,10 +154,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.
@@ -104,9 +177,12 @@ export interface PeerDiscoveryService extends EventEmitter {
   on(event: 'peer:discovered', listener: (enr: ENR) => void): this;
   emit(event: 'peer:discovered', enr: ENR): boolean;
 
+  on(event: 'ip:changed', listener: (ip: string) => void): this;
+  emit(event: 'ip:changed', ip: string): boolean;
+
   getStatus(): PeerDiscoveryState;
 
   getEnr(): ENR | undefined;
 
-  bootstrapNodes: string[];
+  bootstrapNodeEnrs: ENR[];
 }

package/src/services/tx_collection/config.ts

@@ -0,0 +1,89 @@
+import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
+import { MAX_RPC_TXS_LEN } from '@aztec/stdlib/interfaces/api-limit';
+
+export type TxCollectionConfig = {
+  /** How long to wait before starting reqresp for fast collection  */
+  txCollectionFastNodesTimeoutBeforeReqRespMs: number;
+  /** 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;
+  /** A comma-separated list of file store URLs (s3://, gs://, file://, http://) for tx collection */
+  txCollectionFileStoreUrls: string[];
+  /** Delay in ms from reqresp start before file store collection begins */
+  txCollectionFileStoreFastDelayMs: number;
+  /** Number of concurrent workers for fast file store collection */
+  txCollectionFileStoreFastWorkerCount: number;
+  /** Base backoff time in ms for fast file store collection retries */
+  txCollectionFileStoreFastBackoffBaseMs: number;
+  /** Max backoff time in ms for fast file store collection retries */
+  txCollectionFileStoreFastBackoffMaxMs: 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),
+  },
+  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),
+  },
+  txCollectionFileStoreUrls: {
+    env: 'TX_COLLECTION_FILE_STORE_URLS',
+    description: 'A comma-separated list of file store URLs (s3://, gs://, file://, http://) for tx collection',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(url => url.trim())
+        .filter(url => url.length > 0),
+    defaultValue: [],
+  },
+  txCollectionFileStoreFastDelayMs: {
+    env: 'TX_COLLECTION_FILE_STORE_FAST_DELAY_MS',
+    description: 'Delay in ms from reqresp start before file store collection begins',
+    ...numberConfigHelper(2_000),
+  },
+  txCollectionFileStoreFastWorkerCount: {
+    env: 'TX_COLLECTION_FILE_STORE_FAST_WORKER_COUNT',
+    description: 'Number of concurrent workers for fast file store collection',
+    ...numberConfigHelper(5),
+  },
+  txCollectionFileStoreFastBackoffBaseMs: {
+    env: 'TX_COLLECTION_FILE_STORE_FAST_BACKOFF_BASE_MS',
+    description: 'Base backoff time in ms for fast file store collection retries',
+    ...numberConfigHelper(1_000),
+  },
+  txCollectionFileStoreFastBackoffMaxMs: {
+    env: 'TX_COLLECTION_FILE_STORE_FAST_BACKOFF_MAX_MS',
+    description: 'Max backoff time in ms for fast file store collection retries',
+    ...numberConfigHelper(5_000),
+  },
+};

package/src/services/tx_collection/file_store_tx_collection.ts

@@ -0,0 +1,153 @@
+import { times } from '@aztec/foundation/collection';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import { DateProvider } from '@aztec/foundation/timer';
+import { TxHash } from '@aztec/stdlib/tx';
+
+import type { FileStoreTxSource } from './file_store_tx_source.js';
+import type { IRequestTracker } from './request_tracker.js';
+import type { TxAddContext, TxCollectionSink } from './tx_collection_sink.js';
+
+/** Configuration for a FileStoreTxCollection instance. */
+export type FileStoreCollectionConfig = {
+  workerCount: number;
+  backoffBaseMs: number;
+  backoffMaxMs: number;
+};
+
+type FileStoreTxEntry = {
+  txHash: string;
+  attempts: number;
+  lastAttemptTime: number;
+  nextSourceIndex: number;
+};
+
+/**
+ * Collects txs from file stores as a fallback after P2P methods have been tried.
+ * Each call to startCollecting spins up its own worker pool which pulls entries with priority
+ * (fewest attempts first), retries with round-robin across sources, and applies exponential
+ * backoff between full cycles through all sources. Workers self-terminate when the request
+ * tracker is cancelled (deadline / all-fetched / external) or when there is nothing left to do.
+ */
+export class FileStoreTxCollection {
+  constructor(
+    private readonly sources: FileStoreTxSource[],
+    private readonly txCollectionSink: TxCollectionSink,
+    private readonly config: FileStoreCollectionConfig,
+    private readonly dateProvider: DateProvider = new DateProvider(),
+    private readonly log: Logger = createLogger('p2p:file_store_tx_collection'),
+  ) {}
+
+  /**
+   * Spins up workers to download all txs still missing from the tracker, racing across the
+   * configured file store sources. Resolves once all workers settle.
+   */
+  public async startCollecting(requestTracker: IRequestTracker, context: TxAddContext): Promise<void> {
+    if (this.sources.length === 0 || requestTracker.checkCancelled()) {
+      return;
+    }
+
+    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+    const entries: Set<FileStoreTxEntry> = new Set();
+    for (const hashStr of requestTracker.missingTxHashes) {
+      entries.add({
+        txHash: hashStr,
+        attempts: 0,
+        lastAttemptTime: 0,
+        nextSourceIndex: Math.floor(Math.random() * this.sources.length),
+      });
+    }
+
+    // Yield before spawning so the synchronous caller can finish any follow-up (eg. marking a tx
+    // as fetched on the tracker, or cancelling it) before workers begin scanning entries.
+    await Promise.resolve();
+    if (requestTracker.checkCancelled()) {
+      return;
+    }
+
+    await Promise.allSettled(times(this.config.workerCount, () => this.workerLoop(entries, requestTracker, context)));
+  }
+
+  private async workerLoop(
+    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+    entries: Set<FileStoreTxEntry>,
+    requestTracker: IRequestTracker,
+    context: TxAddContext,
+  ): Promise<void> {
+    while (!requestTracker.checkCancelled() && entries.size > 0) {
+      const action = this.getNextAction(entries, requestTracker);
+      if (action.type === 'sleep') {
+        await Promise.race([sleep(action.ms), requestTracker.cancellationToken]);
+        continue;
+      }
+
+      const entry = action.entry;
+      const source = this.sources[entry.nextSourceIndex % this.sources.length];
+      entry.nextSourceIndex++;
+      entry.attempts++;
+      entry.lastAttemptTime = this.dateProvider.now();
+
+      try {
+        const result = await this.txCollectionSink.collect(
+          () => source.getTxsByHash([TxHash.fromString(entry.txHash)]),
+          [entry.txHash],
+          {
+            description: `file-store ${source.getInfo()}`,
+            method: 'file-store',
+            fileStore: source.getInfo(),
+          },
+          context,
+        );
+        if (result.txs.length > 0) {
+          entries.delete(entry);
+        }
+      } catch (err) {
+        this.log.trace(`Error downloading tx ${entry.txHash} from ${source.getInfo()}`, { err });
+      }
+    }
+  }
+
+  /** Single-pass scan: removes stale entries, finds the best ready entry, or computes sleep time. */
+  private getNextAction(
+    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+    entries: Set<FileStoreTxEntry>,
+    requestTracker: IRequestTracker,
+  ): { type: 'process'; entry: FileStoreTxEntry } | { type: 'sleep'; ms: number } {
+    const now = this.dateProvider.now();
+    let best: FileStoreTxEntry | undefined;
+    let earliestReadyAt = Infinity;
+
+    for (const entry of entries) {
+      // Drop entries whose tx was already found via another collection path.
+      if (!requestTracker.isMissing(entry.txHash)) {
+        entries.delete(entry);
+        continue;
+      }
+      const backoffMs = this.getBackoffMs(entry);
+      const readyAt = entry.lastAttemptTime + backoffMs;
+      if (readyAt > now) {
+        earliestReadyAt = Math.min(earliestReadyAt, readyAt);
+        continue;
+      }
+      if (!best || entry.attempts < best.attempts) {
+        best = entry;
+      }
+    }
+
+    if (best) {
+      return { type: 'process', entry: best };
+    }
+    // earliestReadyAt is finite whenever there are surviving entries; if entries became empty,
+    // the outer worker loop will exit on its next iteration via entries.size === 0.
+    return { type: 'sleep', ms: earliestReadyAt === Infinity ? 0 : earliestReadyAt - now };
+  }
+
+  /** Computes backoff for an entry. Backoff applies after a full cycle through all sources. */
+  private getBackoffMs(entry: FileStoreTxEntry): number {
+    const fullCycles = Math.floor(entry.attempts / this.sources.length);
+    if (fullCycles === 0) {
+      return 0;
+    }
+    return Math.min(this.config.backoffBaseMs * Math.pow(2, fullCycles - 1), this.config.backoffMaxMs);
+  }
+}

package/src/services/tx_collection/file_store_tx_source.ts

@@ -0,0 +1,129 @@
+import { partitionAsync } from '@aztec/foundation/collection';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { type ReadOnlyFileStore, createReadOnlyFileStore } from '@aztec/stdlib/file-store';
+import { Tx, type TxHash, type TxValidator } from '@aztec/stdlib/tx';
+import {
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  getTelemetryClient,
+} from '@aztec/telemetry-client';
+
+import type { TxSource, TxSourceCollectionResult } from './tx_source.js';
+
+/** TxSource implementation that downloads txs from a file store. */
+export class FileStoreTxSource implements TxSource {
+  private downloadsSuccess: UpDownCounter;
+  private downloadsFailed: UpDownCounter;
+  private downloadDuration: Histogram;
+  private downloadSize: Histogram;
+
+  private constructor(
+    private readonly fileStore: ReadOnlyFileStore,
+    private readonly baseUrl: string,
+    private readonly basePath: string,
+    private readonly txValidator: TxValidator,
+    private readonly log: Logger,
+    telemetry: TelemetryClient,
+  ) {
+    const meter = telemetry.getMeter('file-store-tx-source');
+    this.downloadsSuccess = meter.createUpDownCounter(Metrics.TX_FILE_STORE_DOWNLOADS_SUCCESS);
+    this.downloadsFailed = meter.createUpDownCounter(Metrics.TX_FILE_STORE_DOWNLOADS_FAILED);
+    this.downloadDuration = meter.createHistogram(Metrics.TX_FILE_STORE_DOWNLOAD_DURATION);
+    this.downloadSize = meter.createHistogram(Metrics.TX_FILE_STORE_DOWNLOAD_SIZE);
+  }
+
+  /**
+   * Creates a FileStoreTxSource from a URL.
+   * @param url - The file store URL (s3://, gs://, file://, http://, https://).
+   * @param basePath - Base path for tx files within the store.
+   * @param log - Optional logger.
+   * @param telemetry - Optional telemetry client.
+   * @returns The FileStoreTxSource instance, or undefined if creation fails.
+   */
+  public static async create(
+    url: string,
+    basePath: string,
+    txValidator: TxValidator,
+    log: Logger = createLogger('p2p:file_store_tx_source'),
+    telemetry: TelemetryClient = getTelemetryClient(),
+  ): Promise<FileStoreTxSource | undefined> {
+    try {
+      const fileStore = await createReadOnlyFileStore(url, log);
+      if (!fileStore) {
+        log.warn(`Failed to create file store for URL: ${url}`);
+        return undefined;
+      }
+      return new FileStoreTxSource(fileStore, url, basePath, txValidator, log, telemetry);
+    } catch (err) {
+      log.warn(`Error creating file store for URL: ${url}`, { error: err });
+      return undefined;
+    }
+  }
+
+  public getInfo(): string {
+    return `file-store:${this.baseUrl}`;
+  }
+
+  public async getTxsByHash(txHashes: TxHash[]): Promise<TxSourceCollectionResult> {
+    const results = await Promise.all(
+      txHashes.map(async txHash => {
+        const path = `${this.basePath}/txs/${txHash.toString()}.bin`;
+        const timer = new Timer();
+        try {
+          const buffer = await this.fileStore.read(path);
+          const tx = Tx.fromBuffer(buffer);
+          return { tx, downloadDuration: timer.ms(), downloadSize: buffer.length };
+        } catch {
+          this.downloadsFailed.add(1);
+          return undefined;
+        }
+      }),
+    );
+
+    const txs = results.filter(tx => tx !== undefined);
+    const [validTxs, invalidTxs] = await partitionAsync(
+      txs,
+      async ({ tx, downloadDuration, downloadSize }): Promise<boolean> => {
+        const valid = await this.txValidator.validateTx(tx);
+        if (valid.result === 'valid') {
+          this.downloadsSuccess.add(1);
+          this.downloadDuration.record(Math.ceil(downloadDuration));
+          this.downloadSize.record(downloadSize);
+          return true;
+        } else {
+          this.downloadsFailed.add(1);
+          return false;
+        }
+      },
+    );
+
+    return {
+      validTxs: validTxs.map(({ tx }) => tx),
+      invalidTxHashes: invalidTxs.map(({ tx }) => tx.getTxHash().toString()),
+    };
+  }
+}
+
+/**
+ * Creates FileStoreTxSource instances from URLs.
+ * @param urls - Array of file store URLs.
+ * @param basePath - Base path for tx files within each store.
+ * @param log - Optional logger.
+ * @param telemetry - Optional telemetry client.
+ * @returns Array of successfully created FileStoreTxSource instances.
+ */
+export async function createFileStoreTxSources(
+  urls: string[],
+  basePath: string,
+  txValidator: TxValidator,
+  log: Logger = createLogger('p2p:file_store_tx_source'),
+  telemetry: TelemetryClient = getTelemetryClient(),
+): Promise<FileStoreTxSource[]> {
+  const sources = await Promise.all(
+    urls.map(url => FileStoreTxSource.create(url, basePath, txValidator, log, telemetry)),
+  );
+  return sources.filter((s): s is FileStoreTxSource => s !== undefined);
+}

package/src/services/tx_collection/index.ts

@@ -0,0 +1,3 @@
+export { TxCollection, type FastCollectionRequestInput, type IReqRespTxsCollector } from './tx_collection.js';
+export { type TxSource, createNodeRpcTxSources, NodeRpcTxSource } from './tx_source.js';
+export { FileStoreTxSource, createFileStoreTxSources } from './file_store_tx_source.js';

package/src/services/tx_collection/instrumentation.ts

@@ -0,0 +1,35 @@
+import {
+  Attributes,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  createUpDownCounterWithDefault,
+} 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 = createUpDownCounterWithDefault(meter, Metrics.TX_COLLECTOR_COUNT, {
+      [Attributes.TX_COLLECTION_METHOD]: ['fast-req-resp', 'fast-node-rpc', 'file-store'],
+    });
+
+    this.collectionDurationPerTx = meter.createHistogram(Metrics.TX_COLLECTOR_DURATION_PER_TX);
+
+    this.collectionDurationPerRequest = meter.createHistogram(Metrics.TX_COLLECTOR_DURATION_PER_REQUEST);
+  }
+
+  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 });
+  }
+}