@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.001888fc

package/src/services/tx_collection/tx_collection.ts

@@ -0,0 +1,313 @@
+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 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 { 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 { 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' | 'file-store';
+
+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 & {
+  missingTxTracker: IMissingTxsTracker;
+  deadline: Date;
+  blockInfo: L2BlockInfo;
+  promise: PromiseWithResolvers<void>;
+};
+
+/**
+ * Coordinates tx collection from remote RPC nodes and reqresp.
+ *
+ * The slow collection loops are used for periodically collecting missing txs from mined blocks,
+ * from remote RPC nodes and via reqresp. The fast collection methods are used to quickly gather
+ * txs, usually for attesting to block proposals or preparing to prove an epoch. The slow and fast
+ * collection instances both send their txs to the collection sink, which handles metrics and adds
+ * them to the tx pool. Whenever a tx is added to either the sink or the pool, this service is notified
+ * via events and notifies the slow and fast collection loops to stop collecting that tx, so that we don't
+ * collect the same tx multiple times.
+ */
+export class TxCollection {
+  /** Slow collection background loops */
+  protected readonly slowCollection: SlowTxCollection;
+
+  /** 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;
+
+  /** Handles txs found by the slow and fast collection loops */
+  private readonly txCollectionSink: TxCollectionSink;
+
+  /** Handler for the txs-added event from the tx pool */
+  protected readonly handleTxsAddedToPool: TxPoolV2Events['txs-added'];
+
+  /** Handler for the txs-added event from the tx collection sink */
+  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: 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'),
+  ) {
+    this.txCollectionSink = new TxCollectionSink(this.txPool, telemetryClient, this.log);
+
+    this.fastCollection = new FastTxCollection(
+      this.p2pService,
+      this.nodes,
+      this.txCollectionSink,
+      this.config,
+      this.dateProvider,
+      this.log,
+    );
+
+    this.slowCollection = new SlowTxCollection(
+      this.p2pService.reqResp,
+      this.nodes,
+      this.txCollectionSink,
+      this.fastCollection,
+      constants,
+      this.config,
+      this.dateProvider,
+      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<TxPoolV2Events['txs-added']>[0]) => {
+      this.foundTxs(args.txs);
+    };
+    this.txCollectionSink.on('txs-added', this.handleTxsFound);
+
+    this.handleTxsAddedToPool = (args: Parameters<TxPoolV2Events['txs-added']>[0]) => {
+      const { txs, source } = args;
+      if (source !== 'tx-collection') {
+        this.foundTxs(txs);
+      }
+    };
+    this.txPool.on('txs-added', this.handleTxsAddedToPool);
+  }
+
+  /** 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
+    return Promise.resolve();
+  }
+
+  /** Stops all activity. */
+  public async 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);
+  }
+
+  /** Force trigger the slow collection and reconciliation loops */
+  public async trigger() {
+    await Promise.all([this.reconcileFoundTxsLoop.trigger(), this.slowCollection.trigger()]);
+  }
+
+  /** Returns L1 rollup constants. */
+  public getConstants(): L1RollupConstants {
+    return this.constants;
+  }
+
+  /** Starts collecting the given tx hashes for the given L2Block in the slow loop */
+  public startCollecting(block: L2Block, txHashes: TxHash[]) {
+    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 */
+  public collectFastForProposal(
+    blockProposal: BlockProposal,
+    blockNumber: BlockNumber,
+    txHashes: TxHash[] | string[],
+    opts: { deadline: Date; pinnedPeer?: PeerId },
+  ) {
+    return this.collectFastFor({ type: 'proposal', blockProposal, blockNumber }, txHashes, opts);
+  }
+
+  /** Collects the set of txs for the given mined block as fast as possible */
+  public collectFastForBlock(
+    block: L2Block,
+    txHashes: TxHash[] | string[],
+    opts: { deadline: Date; pinnedPeer?: PeerId },
+  ) {
+    return this.collectFastFor({ type: 'block', block }, txHashes, opts);
+  }
+
+  /** Collects the set of txs for the given proposal or block as fast as possible */
+  public collectFastFor(
+    input: FastCollectionRequestInput,
+    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);
+  }
+
+  /**
+   * 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: BlockNumber): void {
+    this.slowCollection.stopCollectingForBlocksUpTo(blockNumber);
+    this.fastCollection.stopCollectingForBlocksUpTo(blockNumber);
+    this.fileStoreSlowCollection.clearPending();
+    this.fileStoreFastCollection.clearPending();
+  }
+
+  /**
+   * 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: 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 */
+  private async reconcileFoundTxsWithPool() {
+    const missingTxHashes = this.slowCollection.getMissingTxHashes();
+    const foundTxs = compactArray(await this.txPool.getTxsByHash(missingTxHashes));
+    if (foundTxs.length > 0) {
+      this.log.verbose(`Found ${foundTxs.length} txs in the pool during reconciliation`, {
+        foundTxs: foundTxs.map(t => t.getTxHash().toString()),
+      });
+      this.foundTxs(foundTxs);
+    }
+  }
+}

package/src/services/tx_collection/tx_collection_sink.ts

@@ -0,0 +1,125 @@
+import type { Logger } from '@aztec/foundation/log';
+import { elapsed } from '@aztec/foundation/timer';
+import type { TypedEventEmitter } from '@aztec/foundation/types';
+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 { 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<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 the slow missing txs set and all fast 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,56 @@
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import type { ChainConfig } from '@aztec/stdlib/config';
+import { type AztecNode, createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+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<TxSourceCollectionResult>;
+}
+
+export class NodeRpcTxSource implements TxSource {
+  constructor(
+    private readonly client: Pick<AztecNode, 'getTxsByHash'>,
+    private readonly info: string,
+  ) {}
+
+  public static fromUrl(nodeUrl: string, versions: ComponentsVersions): NodeRpcTxSource {
+    const client = createAztecNodeClient(nodeUrl, versions, makeTracedFetch([1, 2, 3], false));
+    return new NodeRpcTxSource(client, nodeUrl);
+  }
+
+  public getInfo() {
+    return this.info;
+  }
+
+  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 };
+  }
+}
+
+export function createNodeRpcTxSources(urls: string[], chainConfig: ChainConfig) {
+  const versions = getComponentsVersionsFromConfig(chainConfig, protocolContractsHash, getVKTreeRoot());
+  return urls.map(url => NodeRpcTxSource.fromUrl(url, versions));
+}

package/src/services/tx_file_store/config.ts

@@ -0,0 +1,37 @@
+import { type ConfigMappingsType, booleanConfigHelper, numberConfigHelper } from '@aztec/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,36 @@
+import { type Gauge, type Histogram, Metrics, type TelemetryClient, type UpDownCounter } from '@aztec/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);
+  }
+}