@aztec/p2p 0.0.0-test.0 → 0.0.1-commit.24de95ac

package/dest/client/p2p_client.js

@@ -6,23 +6,24 @@ function _ts_decorate(decorators, target, key, desc) {
 }
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { Attributes, TraceableL2BlockStream, WithTracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { getP2PDefaultConfig } from '../config.js';
 import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
-/**
- * Enum defining the possible states of the p2p client.
- */ export var P2PClientState = /*#__PURE__*/ function(P2PClientState) {
-    P2PClientState[P2PClientState["IDLE"] = 0] = "IDLE";
-    P2PClientState[P2PClientState["SYNCHING"] = 1] = "SYNCHING";
-    P2PClientState[P2PClientState["RUNNING"] = 2] = "RUNNING";
-    P2PClientState[P2PClientState["STOPPED"] = 3] = "STOPPED";
-    return P2PClientState;
-}({});
+import { chunkTxHashesRequest } from '../services/reqresp/protocols/tx.js';
+import { TxProvider } from '../services/tx_provider.js';
+import { P2PClientState } from './interface.js';
 /**
  * The P2P client implementation.
  */ export class P2PClient extends WithTracer {
+    store;
     l2BlockSource;
     p2pService;
+    txCollection;
+    _dateProvider;
+    telemetry;
     log;
     /** The JS promise that will be running to keep the client's data in sync. Can be interrupted if the client is stopped. */ runningPromise;
     currentState;
@@ -30,71 +31,115 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
     syncResolve;
     latestBlockNumberAtStart;
     provenBlockNumberAtStart;
+    finalizedBlockNumberAtStart;
     synchedBlockHashes;
     synchedLatestBlockNumber;
     synchedProvenBlockNumber;
+    synchedFinalizedBlockNumber;
+    synchedLatestSlot;
     txPool;
     attestationPool;
-    /** How many slots to keep attestations for. */ keepAttestationsInPoolFor;
-    /** How many slots to keep proven txs for. */ keepProvenTxsFor;
+    config;
     blockStream;
+    txProvider;
+    validatorAddresses;
     /**
    * In-memory P2P client constructor.
    * @param store - The client's instance of the KV store.
    * @param l2BlockSource - P2P client's source for fetching existing blocks.
    * @param txPool - The client's instance of a transaction pool. Defaults to in-memory implementation.
    * @param p2pService - The concrete instance of p2p networking to use.
-   * @param keepProvenTxsFor - How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven).
    * @param log - A logger.
-   */ constructor(_clientType, store, l2BlockSource, mempools, p2pService, config = {}, telemetry = getTelemetryClient(), log = createLogger('p2p')){
-        super(telemetry, 'P2PClient'), this.l2BlockSource = l2BlockSource, this.p2pService = p2pService, this.log = log, this.currentState = 0, this.syncPromise = Promise.resolve(), this.syncResolve = undefined, this.latestBlockNumberAtStart = -1, this.provenBlockNumberAtStart = -1;
-        const { keepProvenTxsInPoolFor, blockCheckIntervalMS, blockRequestBatchSize, keepAttestationsInPoolFor } = {
+   */ constructor(_clientType, store, l2BlockSource, mempools, p2pService, txCollection, config = {}, _dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('p2p')){
+        super(telemetry, 'P2PClient'), this.store = store, this.l2BlockSource = l2BlockSource, this.p2pService = p2pService, this.txCollection = txCollection, this._dateProvider = _dateProvider, this.telemetry = telemetry, this.log = log, this.currentState = P2PClientState.IDLE, this.syncPromise = Promise.resolve(), this.syncResolve = undefined, this.latestBlockNumberAtStart = -1, this.provenBlockNumberAtStart = -1, this.finalizedBlockNumberAtStart = -1, this.validatorAddresses = [];
+        this.config = {
             ...getP2PDefaultConfig(),
             ...config
         };
-        this.keepProvenTxsFor = keepProvenTxsInPoolFor;
-        this.keepAttestationsInPoolFor = keepAttestationsInPoolFor;
-        const tracer = telemetry.getTracer('P2PL2BlockStream');
-        const logger = createLogger('p2p:l2-block-stream');
-        this.blockStream = new TraceableL2BlockStream(l2BlockSource, this, this, tracer, 'P2PL2BlockStream', logger, {
-            batchSize: blockRequestBatchSize,
-            pollIntervalMS: blockCheckIntervalMS
+        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 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()}`);
+            // 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);
+            const parentBlock = await this.l2BlockSource.getBlockHeaderByArchive(block.payload.header.lastArchiveRoot);
+            if (!parentBlock) {
+                this.log.debug(`Cannot collect txs for proposal as parent block not found`);
+                return;
+            }
+            const blockNumber = parentBlock.getBlockNumber() + 1;
+            await this.txProvider.getTxsForBlockProposal(block, blockNumber, {
+                pinnedPeer: sender,
+                deadline
+            });
+            return undefined;
         });
+        // REFACTOR: Try replacing these with an L2TipsStore
         this.synchedBlockHashes = store.openMap('p2p_pool_block_hashes');
         this.synchedLatestBlockNumber = store.openSingleton('p2p_pool_last_l2_block');
         this.synchedProvenBlockNumber = store.openSingleton('p2p_pool_last_proven_l2_block');
-        this.txPool = mempools.txPool;
-        this.attestationPool = mempools.attestationPool;
+        this.synchedFinalizedBlockNumber = store.openSingleton('p2p_pool_last_finalized_l2_block');
+        this.synchedLatestSlot = store.openSingleton('p2p_pool_last_l2_slot');
+    }
+    registerThisValidatorAddresses(addresses) {
+        this.validatorAddresses = [
+            ...addresses
+        ];
+        this.p2pService.registerThisValidatorAddresses(this.validatorAddresses);
+    }
+    clear() {
+        return this.store.clear();
     }
     isP2PClient() {
         return true;
     }
+    getTxProvider() {
+        return this.txProvider;
+    }
     getPeers(includePending) {
         return Promise.resolve(this.p2pService.getPeers(includePending));
     }
     getL2BlockHash(number) {
         return this.synchedBlockHashes.getAsync(number);
     }
+    updateP2PConfig(config) {
+        this.txPool.updateConfig(config);
+        this.p2pService.updateConfig(config);
+        return Promise.resolve();
+    }
     async getL2Tips() {
         const latestBlockNumber = await this.getSyncedLatestBlockNum();
         let latestBlockHash;
         const provenBlockNumber = await this.getSyncedProvenBlockNum();
         let provenBlockHash;
+        const finalizedBlockNumber = await this.getSyncedFinalizedBlockNum();
+        let finalizedBlockHash;
         if (latestBlockNumber > 0) {
             latestBlockHash = await this.synchedBlockHashes.getAsync(latestBlockNumber);
             if (typeof latestBlockHash === 'undefined') {
-                this.log.warn(`Block hash for latest block ${latestBlockNumber} not found`);
-                throw new Error();
+                throw new Error(`Block hash for latest block ${latestBlockNumber} not found in p2p client`);
             }
         }
         if (provenBlockNumber > 0) {
             provenBlockHash = await this.synchedBlockHashes.getAsync(provenBlockNumber);
             if (typeof provenBlockHash === 'undefined') {
-                this.log.warn(`Block hash for proven block ${provenBlockNumber} not found`);
-                throw new Error();
+                throw new Error(`Block hash for proven block ${provenBlockNumber} not found in p2p client`);
             }
         }
-        return Promise.resolve({
+        if (finalizedBlockNumber > 0) {
+            finalizedBlockHash = await this.synchedBlockHashes.getAsync(finalizedBlockNumber);
+            if (typeof finalizedBlockHash === 'undefined') {
+                throw new Error(`Block hash for finalized block ${finalizedBlockNumber} not found in p2p client`);
+            }
+        }
+        return {
             latest: {
                 hash: latestBlockHash,
                 number: latestBlockNumber
@@ -104,10 +149,10 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
                 number: provenBlockNumber
             },
             finalized: {
-                hash: provenBlockHash,
-                number: provenBlockNumber
+                hash: finalizedBlockHash,
+                number: finalizedBlockNumber
             }
-        });
+        };
     }
     async handleBlockStreamEvent(event) {
         this.log.debug(`Handling block stream event ${event.type}`);
@@ -116,16 +161,27 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
                 await this.handleLatestL2Blocks(event.blocks);
                 break;
             case 'chain-finalized':
-                break;
+                {
+                    // TODO (alexg): I think we can prune the block hashes map here
+                    await this.setBlockHash(event.block);
+                    const from = await this.getSyncedFinalizedBlockNum() + 1;
+                    const limit = event.block.number - from + 1;
+                    if (limit > 0) {
+                        await this.handleFinalizedL2Blocks(await this.l2BlockSource.getBlocks(from, limit));
+                    }
+                    break;
+                }
             case 'chain-proven':
                 {
-                    const from = await this.getSyncedProvenBlockNum() + 1;
-                    const limit = event.blockNumber - from + 1;
-                    await this.handleProvenL2Blocks(await this.l2BlockSource.getBlocks(from, limit));
+                    await this.setBlockHash(event.block);
+                    this.txCollection.stopCollectingForBlocksUpTo(event.block.number);
+                    await this.synchedProvenBlockNumber.set(event.block.number);
                     break;
                 }
             case 'chain-pruned':
-                await this.handlePruneL2Blocks(event.blockNumber);
+                await this.setBlockHash(event.block);
+                this.txCollection.stopCollectingForBlocksAfter(event.block.number);
+                await this.handlePruneL2Blocks(event.block.number);
                 break;
             default:
                 {
@@ -134,6 +190,11 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
                 }
         }
     }
+    async setBlockHash(block) {
+        if (block.hash !== undefined) {
+            await this.synchedBlockHashes.set(block.number, block.hash.toString());
+        }
+    }
     #assertIsReady() {
         // this.log.info('Checking if p2p client is ready, current state: ', this.currentState);
         if (!this.isReady()) {
@@ -144,54 +205,102 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
    * Starts the P2P client.
    * @returns An empty promise signalling the synching process.
    */ async start() {
-        if (this.currentState === 3) {
+        if (this.currentState === P2PClientState.STOPPED) {
             throw new Error('P2P client already stopped');
         }
-        if (this.currentState !== 0) {
+        if (this.currentState !== P2PClientState.IDLE) {
             return this.syncPromise;
         }
         // get the current latest block numbers
-        this.latestBlockNumberAtStart = await this.l2BlockSource.getBlockNumber();
-        this.provenBlockNumberAtStart = await this.l2BlockSource.getProvenBlockNumber();
+        const latestBlockNumbers = await this.l2BlockSource.getL2Tips();
+        this.latestBlockNumberAtStart = latestBlockNumbers.latest.number;
+        this.provenBlockNumberAtStart = latestBlockNumbers.proven.number;
+        this.finalizedBlockNumberAtStart = latestBlockNumbers.finalized.number;
         const syncedLatestBlock = await this.getSyncedLatestBlockNum() + 1;
         const syncedProvenBlock = await this.getSyncedProvenBlockNum() + 1;
-        // if there are blocks to be retrieved, go to a synching state
-        if (syncedLatestBlock <= this.latestBlockNumberAtStart || syncedProvenBlock <= this.provenBlockNumberAtStart) {
-            this.setCurrentState(1);
+        const syncedFinalizedBlock = await this.getSyncedFinalizedBlockNum() + 1;
+        if (await this.txPool.isEmpty() && (this.attestationPool === undefined || await this.attestationPool?.isEmpty())) {
+            // if mempools are empty, we don't care about syncing prior blocks
+            this.initBlockStream(this.latestBlockNumberAtStart);
+            this.setCurrentState(P2PClientState.RUNNING);
+            this.syncPromise = Promise.resolve();
+            await this.p2pService.start();
+            this.log.info(`Starting p2p client from block ${this.latestBlockNumberAtStart} with empty mempools`);
+        } else if (syncedLatestBlock <= this.latestBlockNumberAtStart || syncedProvenBlock <= this.provenBlockNumberAtStart || syncedFinalizedBlock <= this.finalizedBlockNumberAtStart) {
+            // if there are blocks to be retrieved, go to a synching state
+            // this gets resolved on `startServiceIfSynched`
+            this.initBlockStream();
+            this.setCurrentState(P2PClientState.SYNCHING);
             this.syncPromise = new Promise((resolve)=>{
                 this.syncResolve = resolve;
             });
-            this.log.verbose(`Starting sync from ${syncedLatestBlock} (last proven ${syncedProvenBlock})`);
+            this.log.info(`Initiating p2p sync from ${syncedLatestBlock}`, {
+                syncedLatestBlock,
+                syncedProvenBlock,
+                syncedFinalizedBlock
+            });
         } else {
             // if no blocks to be retrieved, go straight to running
-            this.setCurrentState(2);
+            this.initBlockStream();
+            this.setCurrentState(P2PClientState.RUNNING);
             this.syncPromise = Promise.resolve();
             await this.p2pService.start();
-            this.log.debug(`Block ${syncedLatestBlock} (proven ${syncedProvenBlock}) already beyond current block`);
+            this.log.info(`Starting P2P client synced to ${syncedLatestBlock}`, {
+                syncedLatestBlock,
+                syncedProvenBlock,
+                syncedFinalizedBlock
+            });
         }
         this.blockStream.start();
-        this.log.verbose(`Started block downloader from block ${syncedLatestBlock}`);
+        await this.txCollection.start();
         return this.syncPromise;
     }
+    addReqRespSubProtocol(subProtocol, handler, validator) {
+        return this.p2pService.addReqRespSubProtocol(subProtocol, handler, validator);
+    }
+    initBlockStream(startingBlock) {
+        if (!this.blockStream) {
+            const { blockRequestBatchSize: batchSize, blockCheckIntervalMS: pollIntervalMS } = this.config;
+            this.blockStream = new TraceableL2BlockStream(this.l2BlockSource, this, this, this.telemetry.getTracer('P2PL2BlockStream'), 'P2PL2BlockStream', createLogger(`${this.log.module}:l2-block-stream`), {
+                batchSize,
+                pollIntervalMS,
+                startingBlock
+            });
+        }
+    }
     /**
    * Allows consumers to stop the instance of the P2P client.
    * 'ready' will now return 'false' and the running promise that keeps the client synced is interrupted.
    */ 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();
+        await this.blockStream?.stop();
         this.log.debug('Stopped block downloader');
         await this.runningPromise;
-        this.setCurrentState(3);
-        this.log.info('P2P client stopped.');
+        this.setCurrentState(P2PClientState.STOPPED);
+        this.log.info('P2P client stopped');
+    }
+    /** Triggers a sync to the archiver. Used for testing. */ async sync() {
+        this.initBlockStream();
+        await this.blockStream.sync();
     }
     broadcastProposal(proposal) {
         this.log.verbose(`Broadcasting proposal for slot ${proposal.slotNumber.toNumber()} to peers`);
         return this.p2pService.propagate(proposal);
     }
     async getAttestationsForSlot(slot, proposalId) {
-        return await this.attestationPool?.getAttestationsForSlot(slot, proposalId) ?? [];
+        return await (proposalId ? this.attestationPool?.getAttestationsForSlotAndProposal(slot, proposalId) : this.attestationPool?.getAttestationsForSlot(slot)) ?? [];
+    }
+    addAttestations(attestations) {
+        return this.attestationPool?.addAttestations(attestations) ?? Promise.resolve();
+    }
+    deleteAttestation(attestation) {
+        return this.attestationPool?.deleteAttestations([
+            attestation
+        ]) ?? Promise.resolve();
     }
     // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
     // ^ This pattern is not my favorite (md)
@@ -199,52 +308,27 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
         this.p2pService.registerBlockReceivedCallback(handler);
     }
     /**
-   * Requests the transactions with the given hashes from the network.
-   *
-   * If a transaction can be retrieved, it will be returned, if not an undefined
-   * will be returned. In place.
-   *
-   * @param txHashes - The hashes of the transactions to request.
-   * @returns A promise that resolves to an array of transactions or undefined.
-   */ async requestTxs(txHashes) {
-        const res = await this.p2pService.sendBatchRequest(ReqRespSubProtocol.TX, txHashes);
-        return Promise.resolve(res ?? []);
-    }
-    /**
-   * 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.
-   */ async requestTxByHash(txHash) {
-        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.
-   */ async requestTxsByHash(txHashes) {
-        const txs = await this.p2pService.sendBatchRequest(ReqRespSubProtocol.TX, txHashes) ?? [];
-        await this.txPool.addTxs(txs);
+   */ async requestTxsByHash(txHashes, pinnedPeerId) {
+        const timeoutMs = 8000; // Longer timeout for now
+        const maxRetryAttempts = 10; // Keep retrying within the timeout
+        const requests = chunkTxHashesRequest(txHashes);
+        const maxPeers = Math.min(Math.ceil(requests.length / 3), 10);
+        const txBatches = await this.p2pService.sendBatchRequest(ReqRespSubProtocol.TX, requests, pinnedPeerId, timeoutMs, maxPeers, maxRetryAttempts);
+        const txs = txBatches.flat();
+        if (txs.length > 0) {
+            await this.txPool.addTxs(txs);
+        }
         const txHashesStr = txHashes.map((tx)=>tx.toString()).join(', ');
-        this.log.debug(`Received batched txs ${txHashesStr} (${txs.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;
     }
-    getPendingTxs() {
-        return Promise.resolve(this.getTxs('pending'));
+    getPendingTxs(limit, after) {
+        return this.getTxs('pending', limit, after);
     }
-    async getPendingTxCount() {
-        const pendingTxs = await this.txPool.getPendingTxHashes();
-        return pendingTxs.length;
+    getPendingTxCount() {
+        return this.txPool.getPendingTxCount();
     }
     async *iteratePendingTxs() {
         for (const txHash of (await this.txPool.getPendingTxHashes())){
@@ -256,22 +340,50 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
     }
     /**
    * Returns all transactions in the transaction pool.
+   * @param filter - The type of txs to return
+   * @param limit - How many txs to return
+   * @param after - If paginating, the last known tx hash. Will return txs after this hash
    * @returns An array of Txs.
-   */ async getTxs(filter) {
+   */ async getTxs(filter, limit, after) {
+        if (limit !== undefined && limit <= 0) {
+            throw new TypeError('limit must be greater than 0');
+        }
+        let txs = undefined;
+        let txHashes;
         if (filter === 'all') {
-            return this.txPool.getAllTxs();
+            txs = await this.txPool.getAllTxs();
+            txHashes = await Promise.all(txs.map((tx)=>tx.getTxHash()));
         } else if (filter === 'mined') {
-            const minedHashes = await this.txPool.getMinedTxHashes();
-            const minedTx = await Promise.all(minedHashes.map(([txHash])=>this.txPool.getTxByHash(txHash)));
-            return minedTx.filter((tx)=>!!tx);
+            const minedTxHashes = await this.txPool.getMinedTxHashes();
+            txHashes = minedTxHashes.map(([txHash])=>txHash);
         } else if (filter === 'pending') {
-            const pendingHashses = await this.txPool.getPendingTxHashes();
-            const pendingTxs = await Promise.all(pendingHashses.map((txHash)=>this.txPool.getTxByHash(txHash)));
-            return pendingTxs.filter((tx)=>!!tx);
+            txHashes = await this.txPool.getPendingTxHashes();
         } else {
             const _ = filter;
             throw new Error(`Unknown filter ${filter}`);
         }
+        let startIndex = 0;
+        let endIndex = undefined;
+        if (after) {
+            startIndex = txHashes.findIndex((txHash)=>after.equals(txHash));
+            // if we can't find the last tx in our set then return an empty array as pagination is no longer valid.
+            if (startIndex === -1) {
+                return [];
+            }
+            // increment by one because we don't want to return the same tx again
+            startIndex++;
+        }
+        if (limit !== undefined) {
+            endIndex = startIndex + limit;
+        }
+        txHashes = txHashes.slice(startIndex, endIndex);
+        if (txs) {
+            txs = txs.slice(startIndex, endIndex);
+        } else {
+            const maybeTxs = await Promise.all(txHashes.map((txHash)=>this.txPool.getTxByHash(txHash)));
+            txs = maybeTxs.filter((tx)=>!!tx);
+        }
+        return txs;
     }
     /**
    * Returns a transaction in the transaction pool by its hash.
@@ -281,23 +393,21 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
         return this.txPool.getTxByHash(txHash);
     }
     /**
-   * 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) {
-        const tx = await this.txPool.getTxByHash(txHash);
-        if (tx) {
-            return tx;
-        }
-        return this.requestTxByHash(txHash);
+   * Returns transactions in the transaction pool by hash.
+   * @param txHashes - Hashes of the transactions to look for.
+   * @returns The txs found, in the same order as the requested hashes. If a tx is not found, it will be undefined.
+   */ getTxsByHashFromPool(txHashes) {
+        return this.txPool.getTxsByHash(txHashes);
+    }
+    hasTxsInPool(txHashes) {
+        return this.txPool.hasTxs(txHashes);
     }
     /**
    * Returns transactions in the transaction pool by hash.
    * If a transaction is not in the pool, it will be requested from the network.
    * @param txHashes - Hashes of the transactions to look for.
-   * @returns The txs found, not necessarily on the same order as the hashes.
-   */ async getTxsByHash(txHashes) {
+   * @returns The txs found, or undefined if not found in the order requested.
+   */ async getTxsByHash(txHashes, pinnedPeerId) {
         const txs = await Promise.all(txHashes.map((txHash)=>this.txPool.getTxByHash(txHash)));
         const missingTxHashes = txs.map((tx, index)=>[
                 tx,
@@ -306,8 +416,27 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
         if (missingTxHashes.length === 0) {
             return txs;
         }
-        const missingTxs = await this.requestTxsByHash(missingTxHashes);
-        return txs.filter((tx)=>!!tx).concat(missingTxs);
+        const missingTxs = await this.requestTxsByHash(missingTxHashes, pinnedPeerId);
+        // TODO: optimize
+        // Merge the found txs in order
+        const mergingTxs = txHashes.map((txHash)=>{
+            // Is it in the txs list from the mempool?
+            for (const tx of txs){
+                if (tx !== undefined && tx.getTxHash().equals(txHash)) {
+                    return tx;
+                }
+            }
+            // Is it in the fetched missing txs?
+            // 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;
+                }
+            }
+            // Otherwise return undefined
+            return undefined;
+        });
+        return mergingTxs;
     }
     /**
    * Returns an archived transaction in the transaction pool by its hash.
@@ -321,11 +450,20 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
    * @param tx - The tx to verify.
    * @returns Empty promise.
    **/ async sendTx(tx) {
-        this.#assertIsReady();
-        await this.txPool.addTxs([
+        const addedCount = await this.addTxsToPool([
             tx
         ]);
-        this.p2pService.propagate(tx);
+        const txAddedSuccessfully = addedCount === 1;
+        if (txAddedSuccessfully) {
+            await this.p2pService.propagate(tx);
+        }
+    }
+    /**
+   * Adds transactions to the pool. Does not send to peers or validate the txs.
+   * @param txs - The transactions.
+   **/ async addTxsToPool(txs) {
+        this.#assertIsReady();
+        return await this.txPool.addTxs(txs);
     }
     /**
    * Returns whether the given tx hash is flagged as pending or mined.
@@ -353,7 +491,7 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
    * Public function to check if the p2p client is fully synced and ready to receive txs.
    * @returns True if the P2P client is ready to receive txs.
    */ isReady() {
-        return this.currentState === 2;
+        return this.currentState === P2PClientState.RUNNING;
     }
     /**
    * Public function to check the latest block number that the P2P client is synced to.
@@ -367,6 +505,12 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
    */ async getSyncedProvenBlockNum() {
         return await this.synchedProvenBlockNumber.getAsync() ?? INITIAL_L2_BLOCK_NUM - 1;
     }
+    async getSyncedFinalizedBlockNum() {
+        return await this.synchedFinalizedBlockNumber.getAsync() ?? INITIAL_L2_BLOCK_NUM - 1;
+    }
+    /** Returns latest L2 slot for which we have seen an L2 block. */ async getSyncedLatestSlot() {
+        return await this.synchedLatestSlot.getAsync() ?? BigInt(0);
+    }
     /**
    * Method to check the status the p2p client.
    * @returns Information about p2p client status: state & syncedToBlockNum.
@@ -388,18 +532,7 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
    */ async markTxsAsMinedFromBlocks(blocks) {
         for (const block of blocks){
             const txHashes = block.body.txEffects.map((txEffect)=>txEffect.txHash);
-            await this.txPool.markAsMined(txHashes, block.number);
-        }
-    }
-    /**
-   * Deletes txs from these blocks.
-   * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
-   * @returns Empty promise.
-   */ async deleteTxsFromBlocks(blocks) {
-        this.log.debug(`Deleting txs from blocks ${blocks[0].number} to ${blocks[blocks.length - 1].number}`);
-        for (const block of blocks){
-            const txHashes = block.body.txEffects.map((txEffect)=>txEffect.txHash);
-            await this.txPool.deleteTxs(txHashes);
+            await this.txPool.markAsMined(txHashes, block.getBlockHeader());
         }
     }
     /**
@@ -410,76 +543,123 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
         if (!blocks.length) {
             return Promise.resolve();
         }
-        await this.markTxsAsMinedFromBlocks(blocks);
-        const lastBlockNum = blocks[blocks.length - 1].number;
-        await Promise.all(blocks.map(async (block)=>this.synchedBlockHashes.set(block.number, (await block.hash()).toString())));
-        await this.synchedLatestBlockNumber.set(lastBlockNum);
-        this.log.verbose(`Synched to latest block ${lastBlockNum}`);
+        await this.markTxsAsMinedFromBlocks(blocks.map((b)=>b.block));
+        await this.startCollectingMissingTxs(blocks.map((b)=>b.block));
+        const lastBlock = blocks.at(-1).block;
+        await Promise.all(blocks.map(async (block)=>this.setBlockHash({
+                number: block.block.number,
+                hash: await block.block.hash().then((h)=>h.toString())
+            })));
+        await this.synchedLatestBlockNumber.set(lastBlock.number);
+        await this.synchedLatestSlot.set(lastBlock.header.getSlot());
+        this.log.verbose(`Synched to latest block ${lastBlock.number}`);
         await this.startServiceIfSynched();
     }
+    /** Request txs for unproven blocks so the prover node has more chances to get them. */ async startCollectingMissingTxs(blocks) {
+        try {
+            // 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);
+            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 while starting collection of missing txs for unproven blocks`, err);
+        }
+    }
     /**
-   * Handles new proven blocks by deleting the txs in them, or by deleting the txs in blocks `keepProvenTxsFor` ago.
-   * @param blocks - A list of proven L2 blocks.
+   * Handles new finalized blocks by deleting the txs and attestations in them.
+   * @param blocks - A list of finalized L2 blocks.
    * @returns Empty promise.
-   */ async handleProvenL2Blocks(blocks) {
+   */ async handleFinalizedL2Blocks(blocks) {
         if (!blocks.length) {
             return Promise.resolve();
         }
-        const firstBlockNum = blocks[0].number;
+        this.log.debug(`Handling finalized blocks ${blocks.length} up to ${blocks.at(-1)?.number}`);
         const lastBlockNum = blocks[blocks.length - 1].number;
-        const lastBlockSlot = blocks[blocks.length - 1].header.globalVariables.slotNumber.toBigInt();
-        // If keepProvenTxsFor is 0, we delete all txs from all proven blocks.
-        if (this.keepProvenTxsFor === 0) {
-            await this.deleteTxsFromBlocks(blocks);
-        } else if (lastBlockNum - this.keepProvenTxsFor >= INITIAL_L2_BLOCK_NUM) {
-            const fromBlock = Math.max(INITIAL_L2_BLOCK_NUM, firstBlockNum - this.keepProvenTxsFor);
-            const toBlock = lastBlockNum - this.keepProvenTxsFor;
-            const limit = toBlock - fromBlock + 1;
-            const blocksToDeleteTxsFrom = await this.l2BlockSource.getBlocks(fromBlock, limit, true);
-            await this.deleteTxsFromBlocks(blocksToDeleteTxsFrom);
-        }
-        // We delete attestations older than the last block slot minus the number of slots we want to keep in the pool.
-        const lastBlockSlotMinusKeepAttestationsInPoolFor = lastBlockSlot - BigInt(this.keepAttestationsInPoolFor);
-        if (lastBlockSlotMinusKeepAttestationsInPoolFor >= BigInt(INITIAL_L2_BLOCK_NUM)) {
-            await this.attestationPool?.deleteAttestationsOlderThan(lastBlockSlotMinusKeepAttestationsInPoolFor);
-        }
-        await this.synchedProvenBlockNumber.set(lastBlockNum);
-        this.log.debug(`Synched to proven block ${lastBlockNum}`);
+        const lastBlockSlot = blocks[blocks.length - 1].header.getSlot();
+        const txHashes = blocks.flatMap((block)=>block.body.txEffects.map((txEffect)=>txEffect.txHash));
+        this.log.debug(`Deleting ${txHashes.length} txs from pool from finalized blocks up to ${lastBlockNum}`);
+        await this.txPool.deleteTxs(txHashes, {
+            permanently: true
+        });
+        await this.txPool.cleanupDeletedMinedTxs(lastBlockNum);
+        await this.attestationPool?.deleteAttestationsOlderThan(lastBlockSlot);
+        await this.synchedFinalizedBlockNumber.set(lastBlockNum);
+        this.log.debug(`Synched to finalized block ${lastBlockNum} at slot ${lastBlockSlot}`);
         await this.startServiceIfSynched();
     }
     /**
    * Updates the tx pool after a chain prune.
    * @param latestBlock - The block number the chain was pruned to.
    */ async handlePruneL2Blocks(latestBlock) {
-        const txsToDelete = [];
+        const txsToDelete = new Map();
+        const minedTxs = await this.txPool.getMinedTxHashes();
+        // 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.toNumber() > latestBlock) {
-                txsToDelete.push(await tx.getTxHash());
+            if (tx.data.constants.anchorBlockHeader.globalVariables.blockNumber > latestBlock) {
+                const txHash = tx.getTxHash();
+                txsToDelete.set(txHash.toString(), txHash);
             }
         }
-        this.log.info(`Detected chain prune. Removing invalid txs count=${txsToDelete.length} newLatestBlock=${latestBlock} previousLatestBlock=${this.getSyncedLatestBlockNum()}`);
+        this.log.info(`Detected chain prune. Removing ${txsToDelete.size} txs built against pruned blocks.`, {
+            newLatestBlock: latestBlock,
+            previousLatestBlock: await this.getSyncedLatestBlockNum(),
+            txsToDelete: Array.from(txsToDelete.keys())
+        });
         // delete invalid txs (both pending and mined)
-        await this.txPool.deleteTxs(txsToDelete);
+        await this.txPool.deleteTxs(Array.from(txsToDelete.values()));
         // everything left in the mined set was built against a block on the proven chain so its still valid
-        // move back to pending the txs that were reorged out of the chain
+        // move back to pending the txs that were reorged out of the chain, unless txPoolDeleteTxsAfterReorg is set,
+        // in which case we clean them up to avoid potential reorg loops
         // 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)
-        const txsToMoveToPending = [];
-        for (const [txHash, blockNumber] of (await this.txPool.getMinedTxHashes())){
-            if (blockNumber > latestBlock) {
-                txsToMoveToPending.push(txHash);
+        const minedTxsFromReorg = [];
+        for (const [txHash, blockNumber] of minedTxs){
+            // We keep the txsToDelete out of this list as they have already been deleted above
+            if (blockNumber > latestBlock && !txsToDelete.has(txHash.toString())) {
+                minedTxsFromReorg.push(txHash);
             }
         }
-        this.log.info(`Moving ${txsToMoveToPending.length} mined txs back to pending`);
-        await this.txPool.markMinedAsPending(txsToMoveToPending);
+        if (this.config.txPoolDeleteTxsAfterReorg) {
+            this.log.info(`Deleting ${minedTxsFromReorg.length} mined txs from reorg`);
+            await this.txPool.deleteTxs(minedTxsFromReorg);
+        } else {
+            this.log.info(`Moving ${minedTxsFromReorg.length} mined txs from reorg back to pending`);
+            await this.txPool.markMinedAsPending(minedTxsFromReorg);
+        }
         await this.synchedLatestBlockNumber.set(latestBlock);
     // no need to update block hashes, as they will be updated as new blocks are added
     }
     async startServiceIfSynched() {
-        if (this.currentState === 1 && await this.getSyncedLatestBlockNum() >= this.latestBlockNumberAtStart && await this.getSyncedProvenBlockNum() >= this.provenBlockNumberAtStart) {
-            this.log.debug(`Synched to blocks at start`);
-            this.setCurrentState(2);
+        if (this.currentState !== P2PClientState.SYNCHING) {
+            return;
+        }
+        const syncedFinalizedBlock = await this.getSyncedFinalizedBlockNum();
+        const syncedProvenBlock = await this.getSyncedProvenBlockNum();
+        const syncedLatestBlock = await this.getSyncedLatestBlockNum();
+        if (syncedLatestBlock >= this.latestBlockNumberAtStart && syncedProvenBlock >= this.provenBlockNumberAtStart && syncedFinalizedBlock >= this.finalizedBlockNumberAtStart) {
+            this.log.info(`Completed P2P client sync to block ${syncedLatestBlock}. Starting service.`, {
+                syncedLatestBlock,
+                syncedProvenBlock,
+                syncedFinalizedBlock
+            });
+            this.setCurrentState(P2PClientState.RUNNING);
             if (this.syncResolve !== undefined) {
                 this.syncResolve();
                 await this.p2pService.start();
@@ -494,10 +674,21 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
         this.currentState = newState;
         this.log.debug(`Moved from state ${P2PClientState[oldState]} to ${P2PClientState[this.currentState]}`);
     }
+    validate(txs) {
+        return this.p2pService.validate(txs);
+    }
+    /**
+   * Marks transactions as non-evictable in the pool.
+   * @param txHashes - Hashes of the transactions to mark as non-evictable.
+   */ markTxsAsNonEvictable(txHashes) {
+        return this.txPool.markTxsAsNonEvictable(txHashes);
+    }
+    handleAuthRequestFromPeer(authRequest, peerId) {
+        return this.p2pService.handleAuthRequestFromPeer(authRequest, peerId);
+    }
 }
 _ts_decorate([
     trackSpan('p2pClient.broadcastProposal', async (proposal)=>({
-            [Attributes.BLOCK_NUMBER]: proposal.blockNumber.toNumber(),
             [Attributes.SLOT_NUMBER]: proposal.slotNumber.toNumber(),
             [Attributes.BLOCK_ARCHIVE]: proposal.archive.toString(),
             [Attributes.P2P_ID]: (await proposal.p2pMessageIdentifier()).toString()