@aztec/p2p 0.0.1-commit.7d4e6cd → 0.0.1-commit.8afd444

package/src/services/tx_collection/proposal_tx_collector.ts

@@ -0,0 +1,114 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+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 { ReqRespSubProtocol } from '../reqresp/interface.js';
+import { chunkTxHashesRequest } from '../reqresp/protocols/tx.js';
+
+/**
+ * Strategy interface for collecting transactions for block proposals.
+ * Allows swapping between different tx collection implementations for benchmarking.
+ */
+export interface ProposalTxCollector {
+  /**
+   * Collect transactions for a block proposal.
+   * @param txHashes - The transaction hashes to collect
+   * @param blockProposal - The block proposal containing the transactions
+   * @param pinnedPeer - Optional peer that sent the proposal (expected to have all txs)
+   * @param timeoutMs - Timeout in milliseconds
+   * @returns The collected transactions
+   */
+  collectTxs(
+    txHashes: TxHash[],
+    blockProposal: BlockProposal,
+    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 ProposalTxCollector {
+  constructor(
+    private p2pService: BatchTxRequesterLibP2PService,
+    private log: Logger,
+    private dateProvider: DateProvider,
+    private txValidator?: IBatchRequestTxValidator,
+    private batchTxRequesterConfig?: Partial<BatchTxRequesterConfig>,
+  ) {}
+
+  async collectTxs(
+    txHashes: TxHash[],
+    blockProposal: BlockProposal,
+    pinnedPeer: PeerId | undefined,
+    timeoutMs: number,
+  ): Promise<Tx[]> {
+    const {
+      batchTxRequesterSmartParallelWorkerCount: smartParallelWorkerCount,
+      batchTxRequesterDumbParallelWorkerCount: dumbParallelWorkerCount,
+      batchTxRequesterTxBatchSize: txBatchSize,
+      batchTxRequesterBadPeerThreshold: badPeerThreshold,
+    } = this.batchTxRequesterConfig ?? {};
+
+    const batchRequester = new BatchTxRequester(
+      txHashes,
+      blockProposal,
+      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 ProposalTxCollector {
+  constructor(
+    private p2pService: BatchTxRequesterLibP2PService,
+    private maxPeers: number = DEFAULT_MAX_PEERS,
+    private maxRetryAttempts: number = DEFAULT_MAX_RETRY_ATTEMPTS,
+  ) {}
+
+  async collectTxs(
+    txHashes: TxHash[],
+    _blockProposal: BlockProposal,
+    pinnedPeer: PeerId | undefined,
+    timeoutMs: number,
+  ): Promise<Tx[]> {
+    const txs = await this.p2pService.reqResp.sendBatchRequest<ReqRespSubProtocol.TX>(
+      ReqRespSubProtocol.TX,
+      chunkTxHashesRequest(txHashes),
+      pinnedPeer,
+      timeoutMs,
+      this.maxPeers,
+      this.maxRetryAttempts,
+    );
+
+    return txs.flat();
+  }
+}

package/src/services/tx_collection/slow_tx_collection.ts

@@ -4,7 +4,7 @@ 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 { L2BlockNew } from '@aztec/stdlib/block';
+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';
 
@@ -76,7 +76,7 @@ export class SlowTxCollection {
   }
 
   /** Starts collecting the given tx hashes for the given L2Block in the slow loop */
-  public startCollecting(block: L2BlockNew, txHashes: TxHash[]) {
+  public startCollecting(block: L2Block, txHashes: TxHash[]) {
     const slot = block.header.getSlot();
     const deadline = this.getDeadlineForSlot(slot);
     if (+deadline < this.dateProvider.now()) {

package/src/services/tx_collection/tx_collection.ts

@@ -3,7 +3,7 @@ import { compactArray } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type PromiseWithResolvers, RunningPromise } from '@aztec/foundation/promise';
 import { DateProvider } from '@aztec/foundation/timer';
-import type { L2BlockInfo, L2BlockNew } from '@aztec/stdlib/block';
+import type { L2Block, L2BlockInfo } from '@aztec/stdlib/block';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
@@ -13,7 +13,7 @@ import type { PeerId } from '@libp2p/interface';
 
 import type { TxPool } from '../../mem_pools/index.js';
 import type { TxPoolEvents } from '../../mem_pools/tx_pool/tx_pool.js';
-import type { ReqRespInterface } from '../reqresp/interface.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 { SlowTxCollection } from './slow_tx_collection.js';
@@ -25,7 +25,7 @@ export type CollectionMethod = 'fast-req-resp' | 'fast-node-rpc' | 'slow-req-res
 export type MissingTxInfo = { blockNumber: BlockNumber; deadline: Date; readyForReqResp: boolean };
 
 export type FastCollectionRequestInput =
-  | { type: 'block'; block: L2BlockNew }
+  | { type: 'block'; block: L2Block }
   | { type: 'proposal'; blockProposal: BlockProposal; blockNumber: BlockNumber };
 
 export type FastCollectionRequest = FastCollectionRequestInput & {
@@ -67,7 +67,7 @@ export class TxCollection {
   protected readonly handleTxsFound: TxPoolEvents['txs-added'];
 
   constructor(
-    private readonly reqResp: Pick<ReqRespInterface, 'sendBatchRequest'>,
+    private readonly p2pService: BatchTxRequesterLibP2PService,
     private readonly nodes: TxSource[],
     private readonly constants: L1RollupConstants,
     private readonly txPool: TxPool,
@@ -79,7 +79,7 @@ export class TxCollection {
     this.txCollectionSink = new TxCollectionSink(this.txPool, telemetryClient, this.log);
 
     this.fastCollection = new FastTxCollection(
-      this.reqResp,
+      this.p2pService,
       this.nodes,
       this.txCollectionSink,
       this.config,
@@ -88,7 +88,7 @@ export class TxCollection {
     );
 
     this.slowCollection = new SlowTxCollection(
-      this.reqResp,
+      this.p2pService.reqResp,
       this.nodes,
       this.txCollectionSink,
       this.fastCollection,
@@ -146,7 +146,7 @@ export class TxCollection {
   }
 
   /** Starts collecting the given tx hashes for the given L2Block in the slow loop */
-  public startCollecting(block: L2BlockNew, txHashes: TxHash[]) {
+  public startCollecting(block: L2Block, txHashes: TxHash[]) {
     return this.slowCollection.startCollecting(block, txHashes);
   }
 
@@ -162,7 +162,7 @@ export class TxCollection {
 
   /** Collects the set of txs for the given mined block as fast as possible */
   public collectFastForBlock(
-    block: L2BlockNew,
+    block: L2Block,
     txHashes: TxHash[] | string[],
     opts: { deadline: Date; pinnedPeer?: PeerId },
   ) {

package/src/services/tx_file_store/config.ts

@@ -0,0 +1,43 @@
+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;
+  /** URL for downloading txs from file storage */
+  txFileStoreDownloadUrl?: 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://)',
+  },
+  txFileStoreDownloadUrl: {
+    env: 'TX_FILE_STORE_DOWNLOAD_URL',
+    description: 'URL for downloading txs from file storage',
+  },
+  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);
+  }
+}

package/src/services/tx_file_store/tx_file_store.ts

@@ -0,0 +1,173 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/promise';
+import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { Timer } from '@aztec/foundation/timer';
+import { type FileStore, createFileStore } from '@aztec/stdlib/file-store';
+import type { Tx } from '@aztec/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import type { TxPool, TxPoolEvents } from '../../mem_pools/tx_pool/index.js';
+import type { TxFileStoreConfig } from './config.js';
+import { TxFileStoreInstrumentation } from './instrumentation.js';
+
+/**
+ * Uploads validated transactions to a file store as a fallback retrieval mechanism.
+ * Listens to TxPool txs-added events and uploads txs asynchronously with bounded concurrency.
+ */
+export class TxFileStore {
+  private uploadQueue: Tx[] = [];
+  private activeUploads = 0;
+  private readonly queueProcessor: RunningPromise;
+  private readonly handleTxsAdded: TxPoolEvents['txs-added'];
+
+  /** Recently uploaded tx hashes for deduplication. */
+  private recentUploads: Set<string> = new Set();
+  private recentUploadsOrder: string[] = [];
+  private readonly maxRecentUploads = 1000;
+
+  private constructor(
+    private readonly fileStore: FileStore,
+    private readonly txPool: TxPool,
+    private readonly config: TxFileStoreConfig,
+    private readonly instrumentation: TxFileStoreInstrumentation,
+    private readonly log: Logger,
+  ) {
+    this.handleTxsAdded = (args: { txs: Tx[]; source?: string }) => {
+      this.enqueueTxs(args.txs);
+    };
+    this.queueProcessor = new RunningPromise(() => this.processQueueBatch(), this.log, 100);
+  }
+
+  /**
+   * Creates and initializes the file store.
+   * @param txPool - The transaction pool to listen to.
+   * @param config - The file store configuration.
+   * @param log - Optional logger.
+   * @param telemetry - Optional telemetry client.
+   * @param fileStoreOverride - Optional FileStore for testing (bypasses createFileStore).
+   * @returns The file store instance, or undefined if not configured/enabled.
+   */
+  static async create(
+    txPool: TxPool,
+    config: TxFileStoreConfig,
+    log: Logger = createLogger('p2p:tx_file_store'),
+    telemetry: TelemetryClient = getTelemetryClient(),
+    fileStoreOverride?: FileStore,
+  ): Promise<TxFileStore | undefined> {
+    if (!config.txFileStoreEnabled) {
+      log.debug('Tx file store is disabled');
+      return undefined;
+    }
+
+    if (!config.txFileStoreUrl) {
+      log.warn('Tx file store is enabled but URL is not configured');
+      return undefined;
+    }
+
+    const fileStore = fileStoreOverride ?? (await createFileStore(config.txFileStoreUrl, log));
+    if (!fileStore) {
+      log.warn('Failed to create file store for tx file store');
+      return undefined;
+    }
+
+    const instrumentation = new TxFileStoreInstrumentation(telemetry, 'TxFileStore');
+    log.info('Created tx file store', { url: config.txFileStoreUrl });
+    return new TxFileStore(fileStore, txPool, config, instrumentation, log);
+  }
+
+  /** Starts listening to TxPool events and uploading txs. */
+  public start(): void {
+    this.queueProcessor.start();
+    this.txPool.on('txs-added', this.handleTxsAdded);
+    this.log.info('Started tx file store', {
+      concurrency: this.config.txFileStoreUploadConcurrency,
+      maxQueueSize: this.config.txFileStoreMaxQueueSize,
+    });
+  }
+
+  /** Stops listening and waits for pending uploads to complete. */
+  public async stop(): Promise<void> {
+    this.txPool.removeListener('txs-added', this.handleTxsAdded);
+    await this.queueProcessor.stop();
+    this.log.info('Stopped tx file store');
+  }
+
+  private enqueueTxs(txs: Tx[]): void {
+    this.uploadQueue.push(...txs);
+
+    // Enforce max queue size by dropping oldest entries
+    const overflow = this.uploadQueue.length - this.config.txFileStoreMaxQueueSize;
+    if (overflow > 0) {
+      this.log.warn(`Upload queue overflow, dropping ${overflow} oldest txs`);
+      this.uploadQueue.splice(0, overflow);
+    }
+
+    this.instrumentation.recordQueueSize(this.uploadQueue.length);
+
+    // Immediately start uploading txs
+    void this.queueProcessor.trigger();
+  }
+
+  private async processQueueBatch(): Promise<void> {
+    const batch = this.uploadQueue.splice(0, this.config.txFileStoreUploadConcurrency);
+    this.instrumentation.recordQueueSize(this.uploadQueue.length);
+
+    this.activeUploads += batch.length;
+    try {
+      await Promise.all(batch.map(tx => this.uploadTx(tx)));
+    } finally {
+      this.activeUploads -= batch.length;
+    }
+  }
+
+  private async uploadTx(tx: Tx): Promise<void> {
+    const txHash = tx.getTxHash().toString();
+    const path = `txs/${txHash}.bin`;
+    const timer = new Timer();
+
+    if (this.recentUploads.has(txHash)) {
+      return;
+    }
+
+    try {
+      this.recentUploads.add(txHash);
+      this.recentUploadsOrder.push(txHash);
+
+      if (this.recentUploadsOrder.length > this.maxRecentUploads) {
+        // delete old entries in recentUploads
+        for (const txHashToRemove of this.recentUploadsOrder.splice(
+          0,
+          this.recentUploadsOrder.length - this.maxRecentUploads,
+        )) {
+          this.recentUploads.delete(txHashToRemove);
+        }
+      }
+
+      await retry(
+        () => this.fileStore.save(path, tx.toBuffer(), { compress: false }),
+        `Uploading tx ${txHash}`,
+        makeBackoff([0.1, 0.5, 2]),
+        this.log,
+        true, // failSilently - don't log errors during retries
+      );
+      const durationMs = Math.trunc(timer.ms());
+      this.log.debug(`Uploaded tx to file store`, { txHash, path, durationMs });
+      this.instrumentation.recordUploadSuccess(durationMs);
+    } catch (err) {
+      this.log.warn(`Failed to upload tx to file store after retries`, { txHash, error: err });
+      this.instrumentation.recordUploadFailed();
+    }
+  }
+
+  /** Waits for all queued and in-flight uploads to complete. For testing. */
+  public async flush(): Promise<void> {
+    while (this.uploadQueue.length > 0 || this.activeUploads > 0) {
+      await this.queueProcessor.trigger();
+    }
+  }
+
+  /** Returns the number of pending uploads (queued + in-flight). */
+  public getPendingUploadCount(): number {
+    return this.uploadQueue.length + this.activeUploads;
+  }
+}

package/src/services/tx_provider.ts

@@ -2,7 +2,7 @@ import { BlockNumber } from '@aztec/foundation/branded-types';
 import { compactArray } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
-import type { L2BlockInfo, L2BlockNew } from '@aztec/stdlib/block';
+import type { L2Block, L2BlockInfo } from '@aztec/stdlib/block';
 import type { ITxProvider } from '@aztec/stdlib/interfaces/server';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
@@ -68,7 +68,7 @@ export class TxProvider implements ITxProvider {
   }
 
   /** Gathers txs from the tx pool, remote rpc nodes, and reqresp. */
-  public getTxsForBlock(block: L2BlockNew, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+  public getTxsForBlock(block: L2Block, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
     return this.getOrderedTxsFromAllSources(
       { type: 'block', block },
       block.toBlockInfo(),

package/src/services/tx_provider_instrumentation.ts

@@ -1,4 +1,10 @@
-import { type Histogram, Metrics, type TelemetryClient, type UpDownCounter } from '@aztec/telemetry-client';
+import {
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  createUpDownCounterWithDefault,
+} from '@aztec/telemetry-client';
 
 export class TxProviderInstrumentation {
   private txFromProposalCount: UpDownCounter;
@@ -12,13 +18,13 @@ export class TxProviderInstrumentation {
   constructor(client: TelemetryClient, name: string) {
     const meter = client.getMeter(name);
 
-    this.txFromProposalCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_PROPOSALS_COUNT);
+    this.txFromProposalCount = createUpDownCounterWithDefault(meter, Metrics.TX_PROVIDER_TXS_FROM_PROPOSALS_COUNT);
 
-    this.txFromMempoolCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_MEMPOOL_COUNT);
+    this.txFromMempoolCount = createUpDownCounterWithDefault(meter, Metrics.TX_PROVIDER_TXS_FROM_MEMPOOL_COUNT);
 
-    this.txFromP2PCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_P2P_COUNT);
+    this.txFromP2PCount = createUpDownCounterWithDefault(meter, Metrics.TX_PROVIDER_TXS_FROM_P2P_COUNT);
 
-    this.missingTxsCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_MISSING_TXS_COUNT);
+    this.missingTxsCount = createUpDownCounterWithDefault(meter, Metrics.TX_PROVIDER_MISSING_TXS_COUNT);
 
     this.fractionOfTxsRequestedFromP2P = meter.createHistogram(Metrics.TX_PROVIDER_P2P_TXS_REQUESTED_FRACTION);
 

package/src/test-helpers/index.ts

@@ -4,3 +4,5 @@ export * from './make-enrs.js';
 export * from './make-test-p2p-clients.js';
 export * from './reqresp-nodes.js';
 export * from './mock-pubsub.js';
+export * from './test_tx_provider.js';
+export * from './testbench-utils.js';

package/src/test-helpers/test_tx_provider.ts

@@ -0,0 +1,64 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { L2Block } from '@aztec/stdlib/block';
+import type { ITxProvider } from '@aztec/stdlib/interfaces/server';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+
+/**
+ * Test transaction provider that can be seeded with transactions.
+ * Returns seeded txs when requested by hash, useful for testing block
+ * proposal handling without requiring a full P2P network.
+ */
+export class TestTxProvider implements ITxProvider {
+  private txs: Map<string, Tx> = new Map();
+
+  /** Seed transactions that will be returned when requested. */
+  seed(txs: Tx[]) {
+    for (const tx of txs) {
+      this.txs.set(tx.getTxHash().toString(), tx);
+    }
+  }
+
+  /** Clear all seeded transactions. */
+  clear() {
+    this.txs.clear();
+  }
+
+  /** Returns txs from the seeded collection given their hashes. */
+  getAvailableTxs(txHashes: TxHash[]): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    return this.getTxsByHashes(txHashes);
+  }
+
+  /** Get txs for a block proposal, returning any seeded txs that match the requested hashes. */
+  getTxsForBlockProposal(
+    blockProposal: BlockProposal,
+    _blockNumber: BlockNumber,
+    _opts: { pinnedPeer: PeerId | undefined; deadline: Date },
+  ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    return this.getTxsByHashes(blockProposal.txHashes);
+  }
+
+  /** Get txs for a block, returning any seeded txs that match the tx effects in the block. */
+  getTxsForBlock(block: L2Block, _opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    const txHashes = block.body.txEffects.map(txEffect => txEffect.txHash);
+    return this.getTxsByHashes(txHashes);
+  }
+
+  private getTxsByHashes(txHashes: TxHash[]): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    const txs: Tx[] = [];
+    const missingTxs: TxHash[] = [];
+
+    for (const txHash of txHashes) {
+      const tx = this.txs.get(txHash.toString());
+      if (tx) {
+        txs.push(tx);
+      } else {
+        missingTxs.push(txHash);
+      }
+    }
+
+    return Promise.resolve({ txs, missingTxs });
+  }
+}