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

package/src/services/tx_collection/fast_tx_collection.ts

@@ -0,0 +1,387 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { times } from '@aztec/foundation/collection';
+import { AbortError, TimeoutError } from '@aztec/foundation/error';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+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 { BatchTxRequesterConfig } from '../reqresp/batch-tx-requester/config.js';
+import type { BatchTxRequesterLibP2PService } from '../reqresp/batch-tx-requester/interface.js';
+import type { TxCollectionConfig } from './config.js';
+import { MissingTxsTracker } from './missing_txs_tracker.js';
+import {
+  BatchTxRequesterCollector,
+  type MissingTxsCollector,
+  SendBatchRequestCollector,
+} from './proposal_tx_collector.js';
+import type { FastCollectionRequest, FastCollectionRequestInput } from './tx_collection.js';
+import type { TxAddContext, 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();
+  private missingTxsCollector: MissingTxsCollector;
+
+  constructor(
+    p2pService: BatchTxRequesterLibP2PService,
+    private nodes: TxSource[],
+    private txCollectionSink: TxCollectionSink,
+    private config: TxCollectionConfig,
+    private dateProvider: DateProvider = new DateProvider(),
+    private log: Logger = createLogger('p2p:tx_collection_service'),
+    missingTxsCollector?: MissingTxsCollector,
+  ) {
+    const batchTxRequesterConfig = this.config as Partial<BatchTxRequesterConfig>;
+    const missingTxsCollectorType = this.config.txCollectionMissingTxsCollectorType;
+    this.missingTxsCollector =
+      missingTxsCollector ??
+      (missingTxsCollectorType === 'old'
+        ? new SendBatchRequestCollector(p2pService)
+        : new BatchTxRequesterCollector(p2pService, log, dateProvider, undefined, batchTxRequesterConfig));
+  }
+
+  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>();
+    const timeoutTimer = setTimeout(() => promise.reject(new TimeoutError(`Timed out while collecting txs`)), timeout);
+
+    const request: FastCollectionRequest = {
+      ...input,
+      blockInfo,
+      promise,
+      missingTxTracker: MissingTxsTracker.fromArray(txHashes),
+      deadline: opts.deadline,
+    };
+
+    const [duration] = await elapsed(() => this.collectFast(request, { ...opts }));
+    clearTimeout(timeoutTimer);
+
+    this.log.verbose(
+      `Collected ${request.missingTxTracker.collectedTxs.length} txs out of ${txHashes.length} for ${input.type} at slot ${blockInfo.slotNumber}`,
+      {
+        ...blockInfo,
+        duration,
+        requestType: input.type,
+        missingTxs: [...request.missingTxTracker.missingTxHashes],
+      },
+    );
+    return request.missingTxTracker.collectedTxs;
+  }
+
+  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.missingTxTracker.numberOfMissingTxs} 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.missingTxTracker.allFetched()) {
+        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.missingTxTracker.missingTxHashes.values().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.missingTxTracker.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.missingTxTracker.allFetched() && 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.missingTxTracker.isMissing(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;
+        }
+
+        const txHashes = batch.map(({ txHash }) => txHash);
+        // Collect this batch from the node
+        await this.txCollectionSink.collect(
+          async () => {
+            const result = await node.getTxsByHash(txHashes.map(TxHash.fromString));
+            for (const tx of result.validTxs) {
+              request.missingTxTracker.markFetched(tx);
+            }
+            return result;
+          },
+          txHashes,
+          {
+            description: `fast ${node.getInfo()}`,
+            node: node.getInfo(),
+            method: 'fast-node-rpc',
+            ...request.blockInfo,
+          },
+          this.getAddContext(request),
+        );
+
+        // 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 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.missingTxTracker.numberOfMissingTxs} txs for ${request.type} at slot ${blockInfo.slotNumber}`,
+      { ...blockInfo, timeoutMs, pinnedPeer },
+    );
+
+    try {
+      await this.txCollectionSink.collect(
+        async () => {
+          let result: Tx[];
+          if (request.type === 'proposal') {
+            result = await this.missingTxsCollector.collectTxs(
+              request.missingTxTracker,
+              request.blockProposal,
+              pinnedPeer,
+              timeoutMs,
+            );
+          } else if (request.type === 'block') {
+            const blockTxsSource = {
+              txHashes: request.block.body.txEffects.map(e => e.txHash),
+              archive: request.block.archive.root,
+            };
+            result = await this.missingTxsCollector.collectTxs(
+              request.missingTxTracker,
+              blockTxsSource,
+              pinnedPeer,
+              timeoutMs,
+            );
+          } else {
+            throw new Error(`Unknown request type: ${(request as any).type}`);
+          }
+          return { validTxs: result, invalidTxHashes: [] };
+        },
+        Array.from(request.missingTxTracker.missingTxHashes),
+        { description: `reqresp for slot ${slotNumber}`, method: 'fast-req-resp', ...opts, ...request.blockInfo },
+        this.getAddContext(request),
+      );
+    } catch (err) {
+      this.log.error(`Error sending fast reqresp request for txs`, err, {
+        txs: [...request.missingTxTracker.missingTxHashes],
+        ...blockInfo,
+      });
+    }
+  }
+
+  /** Returns the TxAddContext for the given request, used by the sink to add txs to the pool correctly. */
+  private getAddContext(request: FastCollectionRequest): TxAddContext {
+    if (request.type === 'proposal') {
+      return { type: 'proposal', blockHeader: request.blockProposal.blockHeader };
+    } else {
+      return { type: 'mined', block: request.block };
+    }
+  }
+
+  /**
+   * 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.missingTxTracker.markFetched(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.missingTxTracker.allFetched()) {
+          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: BlockNumber): 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: BlockNumber): 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/file_store_tx_collection.ts

@@ -0,0 +1,202 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { type PromiseWithResolvers, promiseWithResolvers } from '@aztec/foundation/promise';
+import { sleep } from '@aztec/foundation/sleep';
+import { DateProvider } from '@aztec/foundation/timer';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { FileStoreTxSource } from './file_store_tx_source.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;
+  context: TxAddContext;
+  deadline: Date;
+  attempts: number;
+  lastAttemptTime: number;
+  nextSourceIndex: number;
+};
+
+/**
+ * Collects txs from file stores as a fallback after P2P methods have been tried.
+ * Uses a shared worker pool that pulls entries with priority (fewest attempts first),
+ * retries with round-robin across sources, and applies exponential backoff between
+ * full cycles through all sources.
+ */
+export class FileStoreTxCollection {
+  /** Map from tx hash string to entry for all pending downloads. */
+  private entries = new Map<string, FileStoreTxEntry>();
+
+  /** Worker promises for the shared worker pool. */
+  private workers: Promise<void>[] = [];
+
+  /** Whether the worker pool is running. */
+  private running = false;
+
+  /** Signal used to wake sleeping workers when new entries arrive or stop is called. */
+  private wakeSignal: PromiseWithResolvers<void>;
+
+  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'),
+  ) {
+    this.wakeSignal = promiseWithResolvers<void>();
+  }
+
+  /** Starts the shared worker pool. */
+  public start(): void {
+    if (this.sources.length === 0) {
+      this.log.debug('No file store sources configured');
+      return;
+    }
+    this.running = true;
+    for (let i = 0; i < this.config.workerCount; i++) {
+      this.workers.push(this.workerLoop());
+    }
+  }
+
+  /** Stops all workers and clears state. */
+  public async stop(): Promise<void> {
+    this.running = false;
+    this.wake();
+    await Promise.all(this.workers);
+    this.workers = [];
+    this.entries.clear();
+  }
+
+  /** Adds entries to the shared map and wakes workers. */
+  public startCollecting(txHashes: TxHash[], context: TxAddContext, deadline: Date): void {
+    if (this.sources.length === 0 || txHashes.length === 0) {
+      return;
+    }
+    if (+deadline <= this.dateProvider.now()) {
+      return;
+    }
+
+    for (const txHash of txHashes) {
+      const hashStr = txHash.toString();
+      if (!this.entries.has(hashStr)) {
+        this.entries.set(hashStr, {
+          txHash: hashStr,
+          context,
+          deadline,
+          attempts: 0,
+          lastAttemptTime: 0,
+          nextSourceIndex: Math.floor(Math.random() * this.sources.length),
+        });
+      }
+    }
+    this.wake();
+  }
+
+  /** Removes entries for txs that have been found elsewhere. */
+  public foundTxs(txs: Tx[]): void {
+    for (const tx of txs) {
+      this.entries.delete(tx.getTxHash().toString());
+    }
+  }
+
+  /** Clears all pending entries. */
+  public clearPending(): void {
+    this.entries.clear();
+  }
+
+  private async workerLoop(): Promise<void> {
+    while (this.running) {
+      const action = this.getNextAction();
+      if (action.type === 'sleep') {
+        await action.promise;
+        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(),
+          },
+          entry.context,
+        );
+        if (result.txs.length > 0) {
+          this.entries.delete(entry.txHash);
+        }
+      } catch (err) {
+        this.log.trace(`Error downloading tx ${entry.txHash} from ${source.getInfo()}`, { err });
+      }
+    }
+  }
+
+  /** Single-pass scan: removes expired entries, finds the best ready entry, or computes sleep time. */
+  private getNextAction(): { type: 'process'; entry: FileStoreTxEntry } | { type: 'sleep'; promise: Promise<void> } {
+    const now = this.dateProvider.now();
+    let best: FileStoreTxEntry | undefined;
+    let earliestReadyAt = Infinity;
+
+    for (const [key, entry] of this.entries) {
+      if (+entry.deadline <= now) {
+        this.entries.delete(key);
+        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 };
+    }
+    if (earliestReadyAt < Infinity) {
+      return { type: 'sleep', promise: this.sleepOrWake(earliestReadyAt - now) };
+    }
+    return { type: 'sleep', promise: this.waitForWake() };
+  }
+
+  /** 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);
+  }
+
+  /** Resolves the current wake signal and creates a new one. */
+  private wake(): void {
+    this.wakeSignal.resolve();
+    this.wakeSignal = promiseWithResolvers<void>();
+  }
+
+  /** Waits until the wake signal is resolved. */
+  private async waitForWake(): Promise<void> {
+    await this.wakeSignal.promise;
+  }
+
+  /** Sleeps for the given duration or until the wake signal is resolved. */
+  private async sleepOrWake(ms: number): Promise<void> {
+    await Promise.race([sleep(ms), this.wakeSignal.promise]);
+  }
+}