@aztec/p2p 1.2.1 → 2.0.0-nightly.20250813

package/src/client/factory.ts

@@ -1,9 +1,11 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
-import { createStore } from '@aztec/kv-store/lmdb-v2';
+import { AztecLMDBStoreV2, createStore } from '@aztec/kv-store/lmdb-v2';
 import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { ChainConfig } from '@aztec/stdlib/config';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { P2PClientType } from '@aztec/stdlib/p2p';
@@ -17,6 +19,8 @@ import type { MemPools } from '../mem_pools/interface.js';
 import { AztecKVTxPool, type TxPool } from '../mem_pools/tx_pool/index.js';
 import { DummyP2PService } from '../services/dummy_service.js';
 import { LibP2PService } from '../services/index.js';
+import { TxCollection } from '../services/tx_collection/tx_collection.js';
+import { type TxSource, createNodeRpcTxSources } from '../services/tx_collection/tx_source.js';
 import { configureP2PClientAddresses, createLibP2PPeerIdFromPrivateKey, getPeerIdPrivateKey } from '../util.js';
 
 export type P2PClientDeps<T extends P2PClientType> = {
@@ -24,6 +28,7 @@ export type P2PClientDeps<T extends P2PClientType> = {
   store?: AztecAsyncKVStore;
   attestationPool?: T extends P2PClientType.Full ? AttestationPool : undefined;
   logger?: Logger;
+  txCollectionNodeSources?: TxSource[];
   p2pServiceFactory?: (...args: Parameters<(typeof LibP2PService)['new']>) => Promise<LibP2PService<T>>;
 };
 
@@ -31,22 +36,28 @@ export const P2P_STORE_NAME = 'p2p';
 export const P2P_ARCHIVE_STORE_NAME = 'p2p-archive';
 export const P2P_PEER_STORE_NAME = 'p2p-peers';
 
-export const createP2PClient = async <T extends P2PClientType>(
+export async function createP2PClient<T extends P2PClientType>(
   clientType: T,
-  _config: P2PConfig & DataStoreConfig,
+  inputConfig: P2PConfig & DataStoreConfig & ChainConfig,
   archiver: L2BlockSource & ContractDataSource,
   proofVerifier: ClientProtocolCircuitVerifier,
   worldStateSynchronizer: WorldStateSynchronizer,
   epochCache: EpochCacheInterface,
   packageVersion: string,
+  dateProvider: DateProvider = new DateProvider(),
   telemetry: TelemetryClient = getTelemetryClient(),
   deps: P2PClientDeps<T> = {},
-) => {
-  let config = { ..._config, dataStoreMapSizeKB: _config.p2pStoreMapSizeKb ?? _config.dataStoreMapSizeKB };
+) {
+  const config = await configureP2PClientAddresses({
+    ...inputConfig,
+    dataStoreMapSizeKB: inputConfig.p2pStoreMapSizeKb ?? inputConfig.dataStoreMapSizeKB,
+  });
+
   const logger = deps.logger ?? createLogger('p2p');
   const store = deps.store ?? (await createStore(P2P_STORE_NAME, 2, config, createLogger('p2p:lmdb-v2')));
   const archive = await createStore(P2P_ARCHIVE_STORE_NAME, 1, config, createLogger('p2p-archive:lmdb-v2'));
   const peerStore = await createStore(P2P_PEER_STORE_NAME, 1, config, createLogger('p2p-peer:lmdb-v2'));
+  const l1Constants = await archiver.getL1Constants();
 
   const mempools: MemPools<T> = {
     txPool:
@@ -63,19 +74,83 @@ export const createP2PClient = async <T extends P2PClientType>(
         : undefined,
   };
 
-  if (!_config.p2pEnabled) {
+  const p2pService = await createP2PService<T>(
+    config,
+    clientType,
+    archiver,
+    proofVerifier,
+    worldStateSynchronizer,
+    epochCache,
+    store,
+    peerStore,
+    mempools,
+    deps.p2pServiceFactory,
+    packageVersion,
+    logger.createChild('libp2p_service'),
+    telemetry,
+  );
+
+  const nodeSources = [
+    ...createNodeRpcTxSources(config.txCollectionNodeRpcUrls, config),
+    ...(deps.txCollectionNodeSources ?? []),
+  ];
+  if (nodeSources.length > 0) {
+    logger.info(`Using ${nodeSources.length} node RPC sources for tx collection.`, {
+      nodes: nodeSources.map(n => n.getInfo()),
+    });
+  }
+
+  const txCollection = new TxCollection(
+    p2pService,
+    nodeSources,
+    l1Constants,
+    mempools.txPool,
+    config,
+    dateProvider,
+    telemetry,
+    logger.createChild('tx-collection'),
+  );
+
+  return new P2PClient(
+    clientType,
+    store,
+    archiver,
+    mempools,
+    p2pService,
+    txCollection,
+    config,
+    dateProvider,
+    telemetry,
+  );
+}
+
+async function createP2PService<T extends P2PClientType>(
+  config: P2PConfig & DataStoreConfig,
+  clientType: T,
+  archiver: L2BlockSource & ContractDataSource,
+  proofVerifier: ClientProtocolCircuitVerifier,
+  worldStateSynchronizer: WorldStateSynchronizer,
+  epochCache: EpochCacheInterface,
+  store: AztecAsyncKVStore,
+  peerStore: AztecLMDBStoreV2,
+  mempools: MemPools<T>,
+  p2pServiceFactory: P2PClientDeps<T>['p2pServiceFactory'],
+  packageVersion: string,
+  logger: Logger,
+  telemetry: TelemetryClient,
+) {
+  if (!config.p2pEnabled) {
     logger.verbose('P2P is disabled. Using dummy P2P service.');
-    return new P2PClient(clientType, store, archiver, mempools, new DummyP2PService(), config, telemetry);
+    return new DummyP2PService();
   }
 
   logger.verbose('P2P is enabled. Using LibP2P service.');
-  config = await configureP2PClientAddresses(_config);
 
   // Create peer discovery service
   const peerIdPrivateKey = await getPeerIdPrivateKey(config, store, logger);
   const peerId = await createLibP2PPeerIdFromPrivateKey(peerIdPrivateKey.getValue());
 
-  const p2pService = await (deps.p2pServiceFactory ?? LibP2PService.new<T>)(clientType, config, peerId, {
+  const p2pService = await (p2pServiceFactory ?? LibP2PService.new<T>)(clientType, config, peerId, {
     packageVersion,
     mempools,
     l2BlockSource: archiver,
@@ -84,8 +159,8 @@ export const createP2PClient = async <T extends P2PClientType>(
     worldStateSynchronizer,
     peerStore,
     telemetry,
-    logger: createLogger(`${logger.module}:libp2p_service`),
+    logger: logger.createChild(`libp2p_service`),
   });
 
-  return new P2PClient(clientType, store, archiver, mempools, p2pService, config, telemetry);
-};
+  return p2pService;
+}

package/src/client/interface.ts

@@ -1,4 +1,4 @@
-import type { L2BlockId } from '@aztec/stdlib/block';
+import type { EthAddress, L2BlockId } from '@aztec/stdlib/block';
 import type { P2PApiFull } from '@aztec/stdlib/interfaces/server';
 import type { BlockProposal, P2PClientType } from '@aztec/stdlib/p2p';
 import type { Tx, TxHash } from '@aztec/stdlib/tx';
@@ -7,6 +7,12 @@ import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
 
 import type { P2PConfig } from '../config.js';
+import type { AuthRequest, StatusMessage } from '../services/index.js';
+import type {
+  ReqRespSubProtocol,
+  ReqRespSubProtocolHandler,
+  ReqRespSubProtocolValidators,
+} from '../services/reqresp/interface.js';
 import type { P2PBlockReceivedCallback } from '../services/service.js';
 
 /**
@@ -60,13 +66,7 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
    * @param pinnedPeerId - An optional peer id that will be used to request the tx from (in addition to other random peers).
    * @returns A list of transactions or undefined if the transactions are not found.
    */
-  requestTxsByHash(txHashes: TxHash[], pinnedPeerId: PeerId): Promise<(Tx | undefined)[]>;
-
-  /**
-   * Request a transaction from another peer by its tx hash.
-   * @param txHash - Hash of the tx to query.
-   */
-  requestTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+  requestTxsByHash(txHashes: TxHash[], pinnedPeerId: PeerId): Promise<Tx[]>;
 
   /**
    * Verifies the 'tx' and, if valid, adds it to local tx pool and forwards it to other peers.
@@ -109,13 +109,6 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
    */
   hasTxsInPool(txHashes: TxHash[]): Promise<boolean[]>;
 
-  /**
-   * Returns a transaction in the transaction pool by its hash, requesting it from the network if it is not found.
-   * @param txHash  - Hash of tx to return.
-   * @returns A single tx or undefined.
-   */
-  getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
-
   /**
    * Returns transactions in the transaction pool by hash, requesting from the network if not found.
    * @param txHashes  - Hashes of tx to return.
@@ -188,4 +181,15 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
 
   /** Clears the db. */
   clear(): Promise<void>;
+
+  addReqRespSubProtocol(
+    subProtocol: ReqRespSubProtocol,
+    handler: ReqRespSubProtocolHandler,
+    validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
+  ): Promise<void>;
+
+  handleAuthRequestFromPeer(authRequest: AuthRequest, peerId: PeerId): Promise<StatusMessage>;
+
+  /** If node running this P2P stack is validator, passes in validator address to P2P layer */
+  registerThisValidatorAddresses(address: EthAddress[]): void;
 };

package/src/client/p2p_client.ts

@@ -1,7 +1,9 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton } from '@aztec/kv-store';
 import type {
+  EthAddress,
   L2Block,
   L2BlockId,
   L2BlockSource,
@@ -11,7 +13,8 @@ import type {
   PublishedL2Block,
 } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
-import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
+import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { type PeerInfo, tryStop } from '@aztec/stdlib/interfaces/server';
 import { BlockAttestation, type BlockProposal, type P2PClientType } from '@aztec/stdlib/p2p';
 import type { Tx, TxHash } from '@aztec/stdlib/tx';
 import {
@@ -30,9 +33,16 @@ import { type P2PConfig, getP2PDefaultConfig } from '../config.js';
 import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
 import type { MemPools } from '../mem_pools/interface.js';
 import type { TxPool } from '../mem_pools/tx_pool/index.js';
-import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
+import type { AuthRequest, StatusMessage } from '../services/index.js';
+import {
+  ReqRespSubProtocol,
+  type ReqRespSubProtocolHandler,
+  type ReqRespSubProtocolValidators,
+} from '../services/reqresp/interface.js';
+import { chunkTxHashesRequest } from '../services/reqresp/protocols/tx.js';
 import type { P2PBlockReceivedCallback, P2PService } from '../services/service.js';
-import { TxCollector } from '../services/tx_collector.js';
+import { TxCollection } from '../services/tx_collection/tx_collection.js';
+import { TxProvider } from '../services/tx_provider.js';
 import { type P2P, P2PClientState, type P2PSyncState } from './interface.js';
 
 /**
@@ -65,6 +75,10 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
 
   private blockStream: L2BlockStream | undefined;
 
+  private txProvider: TxProvider;
+
+  private validatorAddresses: EthAddress[] = [];
+
   /**
    * In-memory P2P client constructor.
    * @param store - The client's instance of the KV store.
@@ -79,7 +93,9 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     private l2BlockSource: L2BlockSource & ContractDataSource,
     mempools: MemPools<T>,
     private p2pService: P2PService,
+    private txCollection: TxCollection,
     config: Partial<P2PConfig> = {},
+    private _dateProvider: DateProvider = new DateProvider(),
     private telemetry: TelemetryClient = getTelemetryClient(),
     private log = createLogger('p2p'),
   ) {
@@ -89,12 +105,25 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     this.txPool = mempools.txPool;
     this.attestationPool = mempools.attestationPool!;
 
+    this.txProvider = new TxProvider(
+      this.txCollection,
+      this.txPool,
+      this,
+      this.log.createChild('tx-provider'),
+      this.telemetry,
+    );
+
     // Default to collecting all txs when we see a valid proposal
-    // This can be overridden by the validator client to attest, and it will call collectForBlockProposal on its own
-    const txCollector = new TxCollector(this, this.log);
+    // This can be overridden by the validator client to attest, and it will call getTxsForBlockProposal on its own
+    // TODO(palla/txs): We should not trigger a request for txs on a proposal before fully validating it. We need to bring
+    // validator-client code into here so we can validate a proposal is reasonable.
     this.registerBlockProposalHandler(async (block, sender) => {
       this.log.debug(`Received block proposal from ${sender.toString()}`);
-      await txCollector.collectForBlockProposal(block, sender);
+      // TODO(palla/txs): Need to subtract validatorReexecuteDeadlineMs from this deadline (see ValidatorClient.getReexecutionDeadline)
+      const constants = this.txCollection.getConstants();
+      const nextSlotTimestampSeconds = Number(getTimestampForSlot(block.slotNumber.toBigInt() + 1n, constants));
+      const deadline = new Date(nextSlotTimestampSeconds * 1000);
+      await this.txProvider.getTxsForBlockProposal(block, { pinnedPeer: sender, deadline });
       return undefined;
     });
 
@@ -106,6 +135,11 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     this.synchedLatestSlot = store.openSingleton('p2p_pool_last_l2_slot');
   }
 
+  public registerThisValidatorAddresses(addresses: EthAddress[]): void {
+    this.validatorAddresses = [...addresses];
+    this.p2pService.registerThisValidatorAddresses(this.validatorAddresses);
+  }
+
   public clear(): Promise<void> {
     return this.store.clear();
   }
@@ -114,6 +148,10 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     return true;
   }
 
+  public getTxProvider(): TxProvider {
+    return this.txProvider;
+  }
+
   public getPeers(includePending?: boolean): Promise<PeerInfo[]> {
     return Promise.resolve(this.p2pService.getPeers(includePending));
   }
@@ -184,11 +222,13 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
       }
       case 'chain-proven': {
         await this.setBlockHash(event.block);
+        this.txCollection.stopCollectingForBlocksUpTo(event.block.number);
         await this.synchedProvenBlockNumber.set(event.block.number);
         break;
       }
       case 'chain-pruned':
         await this.setBlockHash(event.block);
+        this.txCollection.stopCollectingForBlocksAfter(event.block.number);
         await this.handlePruneL2Blocks(event.block.number);
         break;
       default: {
@@ -274,9 +314,18 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     }
 
     this.blockStream!.start();
+    await this.txCollection.start();
     return this.syncPromise;
   }
 
+  addReqRespSubProtocol(
+    subProtocol: ReqRespSubProtocol,
+    handler: ReqRespSubProtocolHandler,
+    validator: ReqRespSubProtocolValidators[ReqRespSubProtocol],
+  ): Promise<void> {
+    return this.p2pService.addReqRespSubProtocol(subProtocol, handler, validator);
+  }
+
   private initBlockStream(startingBlock?: number) {
     if (!this.blockStream) {
       const { blockRequestBatchSize: batchSize, blockCheckIntervalMS: pollIntervalMS } = this.config;
@@ -298,6 +347,8 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
    */
   public async stop() {
     this.log.debug('Stopping p2p client...');
+    await tryStop(this.txCollection);
+    this.log.debug('Stopped tx collection service');
     await this.p2pService.stop();
     this.log.debug('Stopped p2p service');
     await this.blockStream?.stop();
@@ -342,52 +393,31 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     this.p2pService.registerBlockReceivedCallback(handler);
   }
 
-  /**
-   * Uses the Request Response protocol to request a transaction from the network.
-   *
-   * If the underlying request response protocol fails, then we return undefined.
-   * If it succeeds then we add the transaction to our transaction pool and return.
-   *
-   * @param txHash - The hash of the transaction to request.
-   * @returns A promise that resolves to a transaction or undefined.
-   */
-  public async requestTxByHash(txHash: TxHash): Promise<Tx | undefined> {
-    const tx = await this.p2pService.sendRequest(ReqRespSubProtocol.TX, txHash);
-
-    if (tx) {
-      this.log.debug(`Received tx ${txHash.toString()} from peer`);
-      await this.txPool.addTxs([tx]);
-    } else {
-      this.log.debug(`Failed to receive tx ${txHash.toString()} from peer`);
-    }
-
-    return tx;
-  }
-
   /**
    * Uses the batched Request Response protocol to request a set of transactions from the network.
    */
-  public async requestTxsByHash(txHashes: TxHash[], pinnedPeerId: PeerId | undefined): Promise<(Tx | undefined)[]> {
+  public async requestTxsByHash(txHashes: TxHash[], pinnedPeerId: PeerId | undefined): Promise<Tx[]> {
     const timeoutMs = 8000; // Longer timeout for now
-    const maxPeers = Math.min(Math.ceil(txHashes.length / 3), 10);
     const maxRetryAttempts = 10; // Keep retrying within the timeout
+    const requests = chunkTxHashesRequest(txHashes);
+    const maxPeers = Math.min(Math.ceil(requests.length / 3), 10);
 
-    const txs = await this.p2pService.sendBatchRequest(
+    const txBatches = await this.p2pService.sendBatchRequest(
       ReqRespSubProtocol.TX,
-      txHashes,
+      requests,
       pinnedPeerId,
       timeoutMs,
       maxPeers,
       maxRetryAttempts,
     );
 
-    // Some transactions may return undefined, so we filter them out
-    const filteredTxs = txs.filter((tx): tx is Tx => !!tx);
-    if (filteredTxs.length > 0) {
-      await this.txPool.addTxs(filteredTxs);
+    const txs = txBatches.flat();
+    if (txs.length > 0) {
+      await this.txPool.addTxs(txs);
     }
+
     const txHashesStr = txHashes.map(tx => tx.toString()).join(', ');
-    this.log.debug(`Requested txs ${txHashesStr} (${filteredTxs.length} / ${txHashes.length}) from peers`);
+    this.log.debug(`Requested txs ${txHashesStr} (${txs.length} / ${txHashes.length}) from peers`);
 
     // We return all transactions, even the not found ones to the caller, such they can handle missing items themselves.
     return txs;
@@ -490,20 +520,6 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     return this.txPool.hasTxs(txHashes);
   }
 
-  /**
-   * Returns a transaction in the transaction pool by its hash.
-   * If the transaction is not in the pool, it will be requested from the network.
-   * @param txHash - Hash of the transaction to look for in the pool.
-   * @returns A single tx or undefined.
-   */
-  async getTxByHash(txHash: TxHash): Promise<Tx | undefined> {
-    const tx = await this.txPool.getTxByHash(txHash);
-    if (tx) {
-      return tx;
-    }
-    return this.requestTxByHash(txHash);
-  }
-
   /**
    * Returns transactions in the transaction pool by hash.
    * If a transaction is not in the pool, it will be requested from the network.
@@ -522,21 +538,20 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     }
 
     const missingTxs = await this.requestTxsByHash(missingTxHashes, pinnedPeerId);
-    const fetchedMissingTxs = missingTxs.filter((tx): tx is Tx => !!tx);
-
     // TODO: optimize
     // Merge the found txs in order
-    const mergingTxsPromises = txHashes.map(async txHash => {
+    const mergingTxs = txHashes.map(txHash => {
       // Is it in the txs list from the mempool?
       for (const tx of txs) {
-        if (tx !== undefined && (await tx.getTxHash()).equals(txHash)) {
+        if (tx !== undefined && tx.getTxHash().equals(txHash)) {
           return tx;
         }
       }
 
       // Is it in the fetched missing txs?
-      for (const tx of fetchedMissingTxs) {
-        if (tx !== undefined && (await tx.getTxHash()).equals(txHash)) {
+      // Note: this is an O(n^2) operation, but we expect the number of missing txs to be small.
+      for (const tx of missingTxs) {
+        if (tx.getTxHash().equals(txHash)) {
           return tx;
         }
       }
@@ -545,7 +560,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
       return undefined;
     });
 
-    return await Promise.all(mergingTxsPromises);
+    return mergingTxs;
   }
 
   /**
@@ -696,7 +711,7 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     }
 
     await this.markTxsAsMinedFromBlocks(blocks.map(b => b.block));
-    void this.requestMissingTxsFromUnprovenBlocks(blocks.map(b => b.block));
+    await this.startCollectingMissingTxs(blocks.map(b => b.block));
 
     const lastBlock = blocks.at(-1)!.block;
 
@@ -716,25 +731,31 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
   }
 
   /** Request txs for unproven blocks so the prover node has more chances to get them. */
-  private async requestMissingTxsFromUnprovenBlocks(blocks: L2Block[]): Promise<void> {
+  private async startCollectingMissingTxs(blocks: L2Block[]): Promise<void> {
     try {
-      const provenBlockNumber = Math.max(await this.getSyncedProvenBlockNum(), this.provenBlockNumberAtStart);
+      // TODO(#15435): If the archiver has lagged behind L1, the reported proven block number may
+      // be much lower than the actual one, and it does not update until the pending chain is
+      // fully synced. This could lead to a ton of tx collection requests for blocks that
+      // are already proven, but the archiver has not yet updated its state. Until this is properly
+      // fixed, it is mitigated by the expiration date of collection requests, which depends on
+      // the slot number of the block.
+      const provenBlockNumber = await this.l2BlockSource.getProvenBlockNumber();
       const unprovenBlocks = blocks.filter(block => block.number > provenBlockNumber);
-      const txHashes = unprovenBlocks.flatMap(block => block.body.txEffects.map(txEffect => txEffect.txHash));
-      const missingTxHashes = await this.txPool
-        .hasTxs(txHashes)
-        .then(availability => txHashes.filter((_, index) => !availability[index]));
-      if (missingTxHashes.length > 0) {
-        this.log.verbose(
-          `Requesting ${missingTxHashes.length} missing txs from peers for ${unprovenBlocks.length} unproven mined blocks`,
-          { missingTxHashes, unprovenBlockNumbers: unprovenBlocks.map(block => block.number) },
-        );
-        await this.requestTxsByHash(missingTxHashes, undefined);
+      for (const block of unprovenBlocks) {
+        const txHashes = block.body.txEffects.map(txEffect => txEffect.txHash);
+        const missingTxHashes = await this.txPool
+          .hasTxs(txHashes)
+          .then(availability => txHashes.filter((_, index) => !availability[index]));
+        if (missingTxHashes.length > 0) {
+          this.log.verbose(
+            `Starting collection of ${missingTxHashes.length} missing txs for unproven mined block ${block.number}`,
+            { missingTxHashes, blockNumber: block.number, blockHash: await block.hash().then(h => h.toString()) },
+          );
+          this.txCollection.startCollecting(block, missingTxHashes);
+        }
       }
     } catch (err) {
-      this.log.error(`Error requesting missing txs from unproven blocks`, err, {
-        blocks: blocks.map(block => block.number),
-      });
+      this.log.error(`Error while starting collection of missing txs for unproven blocks`, err);
     }
   }
 
@@ -766,21 +787,14 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
    * @param latestBlock - The block number the chain was pruned to.
    */
   private async handlePruneL2Blocks(latestBlock: number): Promise<void> {
-    // NOTE: temporary fix for alphanet, deleting ALL txs that were in the epoch from the pool #13723
-    // TODO: undo once fixed: #13770
     const txsToDelete = new Map<string, TxHash>();
     const minedTxs = await this.txPool.getMinedTxHashes();
-    for (const [txHash, blockNumber] of minedTxs) {
-      if (blockNumber > latestBlock) {
-        txsToDelete.set(txHash.toString(), txHash);
-      }
-    }
 
     // Find transactions that reference pruned blocks in their historical header
     for (const tx of await this.txPool.getAllTxs()) {
       // every tx that's been generated against a block that has now been pruned is no longer valid
       if (tx.data.constants.historicalHeader.globalVariables.blockNumber > latestBlock) {
-        const txHash = await tx.getTxHash();
+        const txHash = tx.getTxHash();
         txsToDelete.set(txHash.toString(), txHash);
       }
     }
@@ -799,17 +813,15 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     // NOTE: we can't move _all_ txs back to pending because the tx pool could keep hold of mined txs for longer
     // (see this.keepProvenTxsFor)
 
-    // NOTE: given current fix for alphanet, the code below is redundant as all these txs will be deleted.
-    // TODO: bring back once fixed: #13770
-    // const txsToMoveToPending: TxHash[] = [];
-    // for (const [txHash, blockNumber] of minedTxs) {
-    //   if (blockNumber > latestBlock) {
-    //     txsToMoveToPending.push(txHash);
-    //   }
-    // }
+    const txsToMoveToPending: TxHash[] = [];
+    for (const [txHash, blockNumber] of minedTxs) {
+      if (blockNumber > latestBlock) {
+        txsToMoveToPending.push(txHash);
+      }
+    }
 
-    // this.log.info(`Moving ${txsToMoveToPending.length} mined txs back to pending`);
-    // await this.txPool.markMinedAsPending(txsToMoveToPending);
+    this.log.info(`Moving ${txsToMoveToPending.length} mined txs back to pending`);
+    await this.txPool.markMinedAsPending(txsToMoveToPending);
 
     await this.synchedLatestBlockNumber.set(latestBlock);
     // no need to update block hashes, as they will be updated as new blocks are added
@@ -862,4 +874,8 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
   public markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void> {
     return this.txPool.markTxsAsNonEvictable(txHashes);
   }
+
+  public handleAuthRequestFromPeer(authRequest: AuthRequest, peerId: PeerId): Promise<StatusMessage> {
+    return this.p2pService.handleAuthRequestFromPeer(authRequest, peerId);
+  }
 }