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

package/src/services/tx_collection/file_store_tx_source.ts

@@ -0,0 +1,117 @@
+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 } 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 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,
+    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, 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 invalidTxHashes: string[] = [];
+    return {
+      validTxs: (
+        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);
+              if ((await tx.validateTxHash()) && txHash.equals(tx.txHash)) {
+                this.downloadsSuccess.add(1);
+                this.downloadDuration.record(Math.ceil(timer.ms()));
+                this.downloadSize.record(buffer.length);
+                return tx;
+              } else {
+                invalidTxHashes.push(tx.txHash.toString());
+                this.downloadsFailed.add(1);
+                return undefined;
+              }
+            } catch {
+              // Tx not found or error reading - return undefined
+              this.downloadsFailed.add(1);
+              return undefined;
+            }
+          }),
+        )
+      ).filter(tx => tx !== undefined),
+      invalidTxHashes: invalidTxHashes,
+    };
+  }
+}
+
+/**
+ * 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,
+  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, log, telemetry)));
+  return sources.filter((s): s is FileStoreTxSource => s !== undefined);
+}

package/src/services/tx_collection/index.ts

@@ -0,0 +1,8 @@
+export { TxCollection, type FastCollectionRequestInput } from './tx_collection.js';
+export { type TxSource, createNodeRpcTxSources, NodeRpcTxSource } from './tx_source.js';
+export {
+  type MissingTxsCollector,
+  BatchTxRequesterCollector,
+  SendBatchRequestCollector,
+} from './proposal_tx_collector.js';
+export { FileStoreTxSource, createFileStoreTxSources } from './file_store_tx_source.js';

package/src/services/tx_collection/instrumentation.ts

@@ -0,0 +1,41 @@
+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',
+        'slow-req-resp',
+        'slow-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 });
+  }
+}

package/src/services/tx_collection/missing_txs_tracker.ts

@@ -0,0 +1,52 @@
+import { TxHash } from '@aztec/stdlib/tx';
+import type { Tx } from '@aztec/stdlib/tx';
+
+/**
+ * Tracks which transactions are still missing and need to be fetched.
+ * Allows external code to mark transactions as fetched, enabling coordination
+ * between multiple fetching mechanisms (e.g., BatchTxRequester and Rpc Node requests).
+ */
+export interface IMissingTxsTracker {
+  /** Returns the set of transaction hashes that are still missing. */
+  get missingTxHashes(): Set<string>;
+  /** Size of this.missingTxHashes */
+  get numberOfMissingTxs(): number;
+  /** Are all requested txs are fetched */
+  allFetched(): boolean;
+  /** Checks that transaction is still missing */
+  isMissing(txHash: string): boolean;
+  /** Marks a transaction as fetched. Returns true if it was previously missing. */
+  markFetched(tx: Tx): boolean;
+  /** Get list of collected txs */
+  get collectedTxs(): Tx[];
+}
+
+export class MissingTxsTracker implements IMissingTxsTracker {
+  public readonly collectedTxs: Tx[] = [];
+
+  private constructor(public readonly missingTxHashes: Set<string>) {}
+
+  public static fromArray(hashes: TxHash[] | string[]) {
+    return new MissingTxsTracker(new Set(hashes.map(hash => hash.toString())));
+  }
+
+  markFetched(tx: Tx): boolean {
+    if (this.missingTxHashes.delete(tx.txHash.toString())) {
+      this.collectedTxs.push(tx);
+      return true;
+    }
+    return false;
+  }
+
+  get numberOfMissingTxs(): number {
+    return this.missingTxHashes.size;
+  }
+
+  allFetched(): boolean {
+    return this.numberOfMissingTxs === 0;
+  }
+
+  isMissing(txHash: string): boolean {
+    return this.missingTxHashes.has(txHash.toString());
+  }
+}

package/src/services/tx_collection/proposal_tx_collector.ts

@@ -0,0 +1,113 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { DateProvider } from '@aztec/foundation/timer';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+
+import { BatchTxRequester } from '../reqresp/batch-tx-requester/batch_tx_requester.js';
+import type { BatchTxRequesterConfig } from '../reqresp/batch-tx-requester/config.js';
+import type { BatchTxRequesterLibP2PService } from '../reqresp/batch-tx-requester/interface.js';
+import type { IBatchRequestTxValidator } from '../reqresp/batch-tx-requester/tx_validator.js';
+import { type BlockTxsSource, ReqRespSubProtocol, chunkTxHashesRequest } from '../reqresp/index.js';
+import type { IMissingTxsTracker } from './missing_txs_tracker.js';
+
+/**
+ * Strategy interface for collecting missing transactions for a block or proposal.
+ * Allows swapping between different tx collection implementations for benchmarking.
+ */
+export interface MissingTxsCollector {
+  /**
+   * Collect missing transactions for a block or proposal.
+   * @param missingTxsTracker - The missing transactions tracker
+   * @param blockTxsSource - The block or proposal containing the transactions
+   * @param pinnedPeer - Optional peer expected to have the transactions
+   * @param timeoutMs - Timeout in milliseconds
+   * @returns The collected transactions
+   */
+  collectTxs(
+    missingTxsTracker: IMissingTxsTracker,
+    blockTxsSource: BlockTxsSource,
+    pinnedPeer: PeerId | undefined,
+    timeoutMs: number,
+  ): Promise<Tx[]>;
+}
+
+/**
+ * Collects transactions using the BatchTxRequester implementation.
+ * This uses a smart/dumb peer strategy with parallel workers.
+ */
+export class BatchTxRequesterCollector implements MissingTxsCollector {
+  constructor(
+    private p2pService: BatchTxRequesterLibP2PService,
+    private log: Logger,
+    private dateProvider: DateProvider,
+    private txValidator?: IBatchRequestTxValidator,
+    private batchTxRequesterConfig?: Partial<BatchTxRequesterConfig>,
+  ) {}
+
+  async collectTxs(
+    missingTxsTracker: IMissingTxsTracker,
+    blockTxsSource: BlockTxsSource,
+    pinnedPeer: PeerId | undefined,
+    timeoutMs: number,
+  ): Promise<Tx[]> {
+    const {
+      batchTxRequesterSmartParallelWorkerCount: smartParallelWorkerCount,
+      batchTxRequesterDumbParallelWorkerCount: dumbParallelWorkerCount,
+      batchTxRequesterTxBatchSize: txBatchSize,
+      batchTxRequesterBadPeerThreshold: badPeerThreshold,
+    } = this.batchTxRequesterConfig ?? {};
+
+    const batchRequester = new BatchTxRequester(
+      missingTxsTracker,
+      blockTxsSource,
+      pinnedPeer,
+      timeoutMs,
+      this.p2pService,
+      this.log,
+      this.dateProvider,
+      {
+        smartParallelWorkerCount,
+        dumbParallelWorkerCount,
+        txBatchSize,
+        badPeerThreshold,
+        txValidator: this.txValidator,
+      },
+    );
+
+    return await BatchTxRequester.collectAllTxs(batchRequester.run());
+  }
+}
+
+const DEFAULT_MAX_PEERS = 10;
+const DEFAULT_MAX_RETRY_ATTEMPTS = 3;
+
+/**
+ * Collects transactions using the sendBatchRequest implementation from ReqResp.
+ * This is the original implementation that balances requests across peers.
+ */
+export class SendBatchRequestCollector implements MissingTxsCollector {
+  constructor(
+    private p2pService: BatchTxRequesterLibP2PService,
+    private maxPeers: number = DEFAULT_MAX_PEERS,
+    private maxRetryAttempts: number = DEFAULT_MAX_RETRY_ATTEMPTS,
+  ) {}
+
+  async collectTxs(
+    missingTxsTracker: IMissingTxsTracker,
+    _blockTxsSource: BlockTxsSource,
+    pinnedPeer: PeerId | undefined,
+    timeoutMs: number,
+  ): Promise<Tx[]> {
+    const txs = await this.p2pService.reqResp.sendBatchRequest<ReqRespSubProtocol.TX>(
+      ReqRespSubProtocol.TX,
+      chunkTxHashesRequest(Array.from(missingTxsTracker.missingTxHashes).map(TxHash.fromString)),
+      pinnedPeer,
+      timeoutMs,
+      this.maxPeers,
+      this.maxRetryAttempts,
+    );
+
+    return txs.flat();
+  }
+}

package/src/services/tx_collection/slow_tx_collection.ts

@@ -0,0 +1,266 @@
+import { BlockNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { chunk } from '@aztec/foundation/collection';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { boundInclusive } from '@aztec/foundation/number';
+import { RunningPromise } from '@aztec/foundation/promise';
+import { DateProvider } from '@aztec/foundation/timer';
+import type { L2Block } from '@aztec/stdlib/block';
+import { type L1RollupConstants, getEpochAtSlot, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+
+import { type ReqRespInterface, ReqRespSubProtocol, chunkTxHashesRequest } from '../reqresp/index.js';
+import type { TxCollectionConfig } from './config.js';
+import type { FastTxCollection } from './fast_tx_collection.js';
+import type { MissingTxInfo } from './tx_collection.js';
+import type { TxCollectionSink } from './tx_collection_sink.js';
+import type { TxSource } from './tx_source.js';
+
+export class SlowTxCollection {
+  /** Map from tx hash to missing tx info to collect via slow loop */
+  private missingTxs: Map<string, MissingTxInfo> = new Map();
+
+  /** One slow collection loop for each node tx source we have */
+  private nodesSlowCollectionLoops: RunningPromise[];
+
+  /** Slow collection loop for reqresp which collects txs from peers */
+  private reqrespSlowCollectionLoop: RunningPromise;
+
+  constructor(
+    private reqResp: Pick<ReqRespInterface, 'sendBatchRequest'>,
+    private nodes: TxSource[],
+    private txCollectionSink: TxCollectionSink,
+    private fastCollection: Pick<FastTxCollection, 'getFastCollectionRequests'>,
+    private constants: L1RollupConstants,
+    private config: TxCollectionConfig,
+    private dateProvider: DateProvider = new DateProvider(),
+    private log: Logger = createLogger('p2p:tx_collection_service'),
+  ) {
+    this.nodesSlowCollectionLoops = this.nodes.map(
+      node =>
+        new RunningPromise(
+          () => this.collectMissingTxsFromNode(node),
+          this.log,
+          this.config.txCollectionSlowNodesIntervalMs,
+        ),
+    );
+
+    this.reqrespSlowCollectionLoop = new RunningPromise(
+      () => this.collectMissingTxsViaReqResp(),
+      this.log,
+      this.config.txCollectionSlowReqRespIntervalMs,
+    );
+  }
+
+  public getMissingTxHashes() {
+    return Array.from(this.missingTxs.keys()).map(TxHash.fromString);
+  }
+
+  public start() {
+    this.nodesSlowCollectionLoops.forEach(loop => loop.start());
+    this.reqrespSlowCollectionLoop.start();
+  }
+
+  public async stop() {
+    await Promise.all([
+      this.reqrespSlowCollectionLoop.stop(),
+      ...this.nodesSlowCollectionLoops.map(loop => loop.stop()),
+    ]);
+  }
+
+  public async trigger() {
+    await Promise.all([
+      this.reqrespSlowCollectionLoop.trigger(),
+      ...this.nodesSlowCollectionLoops.map(loop => loop.trigger()),
+    ]);
+  }
+
+  /** Starts collecting the given tx hashes for the given L2Block in the slow loop */
+  public startCollecting(block: L2Block, txHashes: TxHash[]) {
+    const slot = block.header.getSlot();
+    const deadline = this.getDeadlineForSlot(slot);
+    if (+deadline < this.dateProvider.now()) {
+      this.log.debug(`Skipping collection of txs for block ${block.number} at slot ${slot} as it is already expired`, {
+        blockNumber: block.number,
+        slot: slot.toString(),
+        txHashes: txHashes.map(txHash => txHash.toString()),
+        deadline: +deadline,
+        now: this.dateProvider.now(),
+      });
+    }
+
+    for (const txHash of txHashes) {
+      this.missingTxs.set(txHash.toString(), {
+        block,
+        blockNumber: block.number,
+        deadline: this.getDeadlineForSlot(block.header.getSlot()),
+        readyForReqResp: this.nodes.length === 0, // If we have no nodes, we can start reqresp immediately
+      });
+    }
+  }
+
+  /** Entrypoint for the node slow collection loop */
+  private async collectMissingTxsFromNode(node: TxSource) {
+    // If we have any fast requests, we skip the slow collection for this node if configured to do so
+    const requests = this.fastCollection.getFastCollectionRequests();
+    if (this.config.txCollectionDisableSlowDuringFastRequests && requests.size > 0) {
+      this.log.trace(`Skipping node slow collection due to active fast requests`);
+      return;
+    }
+
+    // Gather all missing txs that are not in fast collection and request them from the node
+    const missingTxs = this.getMissingTxsForSlowCollection();
+    if (missingTxs.length === 0) {
+      return;
+    }
+
+    // Group by block so we pass the correct mined context to the sink
+    for (const entries of this.groupByBlock(missingTxs)) {
+      const block = entries[0][1].block;
+      const txHashes = entries.map(([txHash]) => TxHash.fromString(txHash));
+      for (const batch of chunk(txHashes, this.config.txCollectionNodeRpcMaxBatchSize)) {
+        await this.txCollectionSink.collect(
+          () => node.getTxsByHash(batch),
+          batch.map(h => h.toString()),
+          {
+            description: `node ${node.getInfo()}`,
+            node: node.getInfo(),
+            method: 'slow-node-rpc',
+          },
+          { type: 'mined', block },
+        );
+      }
+    }
+
+    // Mark every tx that is still missing as ready for reqresp.
+    // Note that we can just mark all requested txs as ready for reqresp, without filtering out the ones
+    // we retrieved, since the ones already found will have been removed from `missingTxs`.
+    missingTxs.forEach(([_txHash, info]) => {
+      info.readyForReqResp = true;
+    });
+  }
+
+  /** Entrypoint for the reqresp slow collection loop */
+  private async collectMissingTxsViaReqResp() {
+    // If we have any fast requests, we skip the slow collection if configured to do so
+    const requests = this.fastCollection.getFastCollectionRequests();
+    if (this.config.txCollectionDisableSlowDuringFastRequests && requests.size > 0) {
+      this.log.trace(`Skipping reqresp slow collection due to active fast requests`);
+      return;
+    }
+
+    // Gather all missing txs that are not in fast collection and are ready for reqresp
+    // A tx is flagged as ready for reqresp if it has been requested from a node at least once
+    const missingTxs = this.getMissingTxsForSlowCollection({ onlyReqRespReady: true });
+    if (missingTxs.length === 0) {
+      return;
+    }
+
+    const pinnedPeer = undefined;
+    const timeoutMs = this.config.txCollectionSlowReqRespTimeoutMs;
+    const maxRetryAttempts = 3;
+
+    // Group by block so we pass the correct mined context to the sink
+    for (const entries of this.groupByBlock(missingTxs)) {
+      const block = entries[0][1].block;
+      const txHashes = entries.map(([txHash]) => TxHash.fromString(txHash));
+      const maxPeers = boundInclusive(Math.ceil(txHashes.length / 3), 4, 16);
+      await this.txCollectionSink.collect(
+        async () => {
+          const txs = await this.reqResp.sendBatchRequest<ReqRespSubProtocol.TX>(
+            ReqRespSubProtocol.TX,
+            chunkTxHashesRequest(txHashes),
+            pinnedPeer,
+            timeoutMs,
+            maxPeers,
+            maxRetryAttempts,
+          );
+          return { validTxs: txs.flat(), invalidTxHashes: [] };
+        },
+        txHashes.map(h => h.toString()),
+        { description: 'slow reqresp', timeoutMs, method: 'slow-req-resp' },
+        { type: 'mined', block },
+      );
+    }
+  }
+
+  /** Retrieves all missing txs for the slow collection process. This is, all missing txs that are not part of a fast request. */
+  private getMissingTxsForSlowCollection(opts: { onlyReqRespReady?: boolean } = {}): [string, MissingTxInfo][] {
+    // Remove expired txs from missingTxs
+    const now = this.dateProvider.now();
+    const expiredTxs = Array.from(this.missingTxs.entries()).filter(([_, value]) => +value.deadline < now);
+    expiredTxs.forEach(([txHash]) => this.missingTxs.delete(txHash));
+
+    // Gather all txs that are marked for fast collection, we do not want to collect them via slow collection.
+    // There are some situations where a tx is in both slow and fast collection, for example when a prover node
+    // is fast-collecting missing txs for proving an epoch, and still has the tx in the slow collection loops
+    // from mined unproven blocks it has seen in the past.
+    const fastRequests = this.fastCollection.getFastCollectionRequests();
+    const fastCollectionTxs: Set<string> = new Set(
+      fastRequests.values().flatMap(r => Array.from(r.missingTxTracker.missingTxHashes)),
+    );
+
+    // Return all missing txs that are not in fastCollectionTxs and are ready for reqresp if requested
+    return Array.from(this.missingTxs.entries())
+      .filter(([txHash, _]) => !fastCollectionTxs.has(txHash))
+      .filter(([_, value]) => !opts.onlyReqRespReady || value.readyForReqResp);
+  }
+
+  /** Stop collecting the given txs since we have found them. Called whenever tx pool emits a tx-added event. */
+  public foundTxs(txs: Tx[]): void {
+    for (const txHash of txs.map(tx => tx.txHash)) {
+      this.missingTxs.delete(txHash.toString());
+    }
+  }
+
+  /**
+   * 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 [txHash, info] of this.missingTxs.entries()) {
+      if (info.blockNumber <= blockNumber) {
+        this.missingTxs.delete(txHash);
+      }
+    }
+  }
+
+  /**
+   * 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 [txHash, info] of this.missingTxs.entries()) {
+      if (info.blockNumber > blockNumber) {
+        this.missingTxs.delete(txHash);
+      }
+    }
+  }
+
+  /** Groups missing tx entries by block number. */
+  private groupByBlock(entries: [string, MissingTxInfo][]): [string, MissingTxInfo][][] {
+    const groups = new Map<number, [string, MissingTxInfo][]>();
+    for (const entry of entries) {
+      const bn = +entry[1].blockNumber;
+      let group = groups.get(bn);
+      if (!group) {
+        group = [];
+        groups.set(bn, group);
+      }
+      group.push(entry);
+    }
+    return [...groups.values()];
+  }
+
+  /** Computes the proof submission deadline for a given slot, a tx mined in this slot is no longer interesting after this deadline */
+  private getDeadlineForSlot(slotNumber: SlotNumber): Date {
+    return getProofDeadlineForSlot(slotNumber, this.constants);
+  }
+}
+
+/** Computes the proof submission deadline for a given slot. A tx mined in this slot is no longer interesting after this deadline. */
+export function getProofDeadlineForSlot(slotNumber: SlotNumber, constants: L1RollupConstants): Date {
+  const epoch = getEpochAtSlot(slotNumber, constants);
+  const submissionEndEpoch = EpochNumber(epoch + constants.proofSubmissionEpochs);
+  const submissionEndTimestamp = getTimestampRangeForEpoch(submissionEndEpoch, constants)[1];
+  return new Date(Number(submissionEndTimestamp) * 1000);
+}