@aztec/p2p 0.86.0 → 0.87.0

package/dest/client/p2p_client.js

@@ -6,24 +6,17 @@ function _ts_decorate(decorators, target, key, desc) {
 }
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
-import { BlockAttestation, ConsensusPayload } from '@aztec/stdlib/p2p';
 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 { P2PClientState } from './interface.js';
 /**
  * The P2P client implementation.
  */ export class P2PClient extends WithTracer {
+    store;
     l2BlockSource;
     p2pService;
+    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;
@@ -31,45 +24,40 @@ 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;
-    blockStream;
     config;
+    blockStream;
     /**
    * 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;
+        super(telemetry, 'P2PClient'), this.store = store, this.l2BlockSource = l2BlockSource, this.p2pService = p2pService, 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.config = {
             ...getP2PDefaultConfig(),
             ...config
         };
-        const { keepProvenTxsInPoolFor, blockCheckIntervalMS, blockRequestBatchSize, keepAttestationsInPoolFor } = this.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;
+        // 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.synchedFinalizedBlockNumber = store.openSingleton('p2p_pool_last_finalized_l2_block');
         this.synchedLatestSlot = store.openSingleton('p2p_pool_last_l2_slot');
-        this.txPool = mempools.txPool;
-        this.attestationPool = mempools.attestationPool;
+    }
+    clear() {
+        return this.store.clear();
     }
     isP2PClient() {
         return true;
@@ -91,21 +79,27 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
         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`);
+            }
+        }
+        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 Promise.resolve({
+        return {
             latest: {
                 hash: latestBlockHash,
                 number: latestBlockNumber
@@ -115,10 +109,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}`);
@@ -127,15 +121,24 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
                 await this.handleLatestL2Blocks(event.blocks);
                 break;
             case 'chain-finalized':
-                break;
-            case 'chain-proven':
                 {
-                    const from = await this.getSyncedProvenBlockNum() + 1;
+                    // 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;
-                    await this.handleProvenL2Blocks(await this.l2BlockSource.getBlocks(from, limit));
+                    if (limit > 0) {
+                        await this.handleFinalizedL2Blocks(await this.l2BlockSource.getBlocks(from, limit));
+                    }
+                    break;
+                }
+            case 'chain-proven':
+                {
+                    await this.setBlockHash(event.block);
+                    await this.synchedProvenBlockNumber.set(event.block.number);
                     break;
                 }
             case 'chain-pruned':
+                await this.setBlockHash(event.block);
                 await this.handlePruneL2Blocks(event.block.number);
                 break;
             default:
@@ -145,6 +148,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()) {
@@ -155,35 +163,65 @@ 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}`);
         return this.syncPromise;
     }
+    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('p2p: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.
@@ -191,13 +229,14 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
         this.log.debug('Stopping p2p client...');
         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.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) {
@@ -218,18 +257,6 @@ 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.
@@ -252,21 +279,25 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
     /**
    * 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);
+        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 txs = await this.p2pService.sendBatchRequest(ReqRespSubProtocol.TX, txHashes, timeoutMs, maxPeers, maxRetryAttempts);
         // Some transactions may return undefined, so we filter them out
         const filteredTxs = txs.filter((tx)=>!!tx);
-        await this.txPool.addTxs(filteredTxs);
+        if (filteredTxs.length > 0) {
+            await this.txPool.addTxs(filteredTxs);
+        }
         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} (${filteredTxs.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'));
+        return this.getTxs('pending');
     }
-    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())){
@@ -328,7 +359,7 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
    * 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.
+   * @returns The txs found, or undefined if not found in the order requested.
    */ async getTxsByHash(txHashes) {
         const txs = await Promise.all(txHashes.map((txHash)=>this.txPool.getTxByHash(txHash)));
         const missingTxHashes = txs.map((tx, index)=>[
@@ -340,7 +371,25 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
         }
         const missingTxs = await this.requestTxsByHash(missingTxHashes);
         const fetchedMissingTxs = missingTxs.filter((tx)=>!!tx);
-        return txs.filter((tx)=>!!tx).concat(fetchedMissingTxs);
+        // TODO: optimize
+        // Merge the found txs in order
+        const mergingTxsPromises = txHashes.map(async (txHash)=>{
+            // Is it in the txs list from the mempool?
+            for (const tx of txs){
+                if (tx !== undefined && (await 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)) {
+                    return tx;
+                }
+            }
+            // Otherwise return undefined
+            return undefined;
+        });
+        return await Promise.all(mergingTxsPromises);
     }
     /**
    * Returns an archived transaction in the transaction pool by its hash.
@@ -357,7 +406,7 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
         await this.addTxs([
             tx
         ]);
-        this.p2pService.propagate(tx);
+        await this.p2pService.propagate(tx);
     }
     /**
    * Adds transactions to the pool. Does not send to peers or validate the txs.
@@ -392,7 +441,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.
@@ -406,6 +455,9 @@ 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);
     }
@@ -433,15 +485,6 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
             await this.txPool.markAsMined(txHashes, block.number);
         }
     }
-    async addAttestationsToPool(blocks) {
-        const attestations = blocks.flatMap((block)=>{
-            const payload = ConsensusPayload.fromBlock(block.block);
-            return block.signatures.filter((sig)=>!sig.isEmpty).map((signature)=>new BlockAttestation(payload, signature));
-        });
-        await this.attestationPool?.addAttestations(attestations);
-        const slots = blocks.map((b)=>b.block.header.getSlot()).sort((a, b)=>Number(a - b));
-        this.log.debug(`Added ${attestations.length} attestations for slots ${slots[0]}-${slots.at(-1)} to the pool`);
-    }
     /**
    * 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.
@@ -462,42 +505,51 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
             return Promise.resolve();
         }
         await this.markTxsAsMinedFromBlocks(blocks.map((b)=>b.block));
-        await this.addAttestationsToPool(blocks);
+        void this.requestMissingTxsFromUnprovenBlocks(blocks.map((b)=>b.block));
         const lastBlock = blocks.at(-1).block;
-        await Promise.all(blocks.map(async (block)=>this.synchedBlockHashes.set(block.block.number, (await block.block.hash()).toString())));
+        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 requestMissingTxsFromUnprovenBlocks(blocks) {
+        try {
+            const provenBlockNumber = Math.max(await this.getSyncedProvenBlockNum(), this.provenBlockNumberAtStart);
+            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);
+            }
+        } catch (err) {
+            this.log.error(`Error requesting missing txs from unproven blocks`, err, {
+                blocks: blocks.map((block)=>block.number)
+            });
+        }
+    }
     /**
-   * 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) {
+        this.log.trace(`Handling finalized blocks ${blocks.length} up to ${blocks.at(-1)?.number}`);
         if (!blocks.length) {
             return Promise.resolve();
         }
-        const firstBlockNum = blocks[0].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();
+        await this.deleteTxsFromBlocks(blocks);
+        await this.attestationPool?.deleteAttestationsOlderThan(lastBlockSlot);
+        await this.synchedFinalizedBlockNumber.set(lastBlockNum);
+        this.log.debug(`Synched to finalized block ${lastBlockNum}`);
         await this.startServiceIfSynched();
     }
     /**
@@ -506,11 +558,11 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
    */ async handlePruneL2Blocks(latestBlock) {
         // 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 Set();
+        const txsToDelete = new Map();
         const minedTxs = await this.txPool.getMinedTxHashes();
         for (const [txHash, blockNumber] of minedTxs){
             if (blockNumber > latestBlock) {
-                txsToDelete.add(txHash);
+                txsToDelete.set(txHash.toString(), txHash);
             }
         }
         // Find transactions that reference pruned blocks in their historical header
@@ -518,12 +570,12 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
             // 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) {
                 const txHash = await tx.getTxHash();
-                txsToDelete.add(txHash);
+                txsToDelete.set(txHash.toString(), txHash);
             }
         }
         this.log.info(`Detected chain prune. Removing invalid txs count=${txsToDelete.size} newLatestBlock=${latestBlock} previousLatestBlock=${await this.getSyncedLatestBlockNum()}`);
         // delete invalid txs (both pending and mined)
-        await this.txPool.deleteTxs(Array.from(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
         // NOTE: we can't move _all_ txs back to pending because the tx pool could keep hold of mined txs for longer
@@ -542,9 +594,19 @@ import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
     // 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();
@@ -559,6 +621,15 @@ 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);
+    }
 }
 _ts_decorate([
     trackSpan('p2pClient.broadcastProposal', async (proposal)=>({

package/dest/config.d.ts

@@ -70,10 +70,6 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
      * If announceUdpAddress or announceTcpAddress are not provided, query for the IP address of the machine. Default is false.
      */
     queryForIp: boolean;
-    /** How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven) */
-    keepProvenTxsInPoolFor: number;
-    /** How many slots to keep attestations for. */
-    keepAttestationsInPoolFor: number;
     /**
      * The interval of the gossipsub heartbeat to perform maintenance tasks.
      */
@@ -106,6 +102,10 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
      * How many message cache windows to include when gossiping with other pears.
      */
     gossipsubMcacheGossip: number;
+    /**
+     * How long to keep message IDs in the seen cache (ms).
+     */
+    gossipsubSeenTTL: number;
     /**
      * The 'age' (in # of L2 blocks) of a processed tx after which we heavily penalize a peer for re-sending it.
      */
@@ -186,8 +186,6 @@ export declare const bootnodeConfigMappings: ConfigMappingsType<Pick<{
     bootstrapNodesAsFullPeers: unknown;
     maxPeerCount: unknown;
     queryForIp: unknown;
-    keepProvenTxsInPoolFor: unknown;
-    keepAttestationsInPoolFor: unknown;
     gossipsubInterval: unknown;
     gossipsubD: unknown;
     gossipsubDlo: unknown;
@@ -196,6 +194,7 @@ export declare const bootnodeConfigMappings: ConfigMappingsType<Pick<{
     gossipsubFloodPublish: unknown;
     gossipsubMcacheLength: unknown;
     gossipsubMcacheGossip: unknown;
+    gossipsubSeenTTL: unknown;
     doubleSpendSeverePeerPenaltyWindow: unknown;
     gossipsubTxTopicWeight: unknown;
     gossipsubTxInvalidMessageDeliveriesWeight: unknown;

package/dest/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}

package/dest/config.js

@@ -84,16 +84,6 @@ export const p2pConfigMappings = {
         description: 'If announceUdpAddress or announceTcpAddress are not provided, query for the IP address of the machine. Default is false.',
         ...booleanConfigHelper()
     },
-    keepProvenTxsInPoolFor: {
-        env: 'P2P_TX_POOL_KEEP_PROVEN_FOR',
-        description: 'How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven)',
-        ...numberConfigHelper(0)
-    },
-    keepAttestationsInPoolFor: {
-        env: 'P2P_ATTESTATION_POOL_KEEP_FOR',
-        description: 'How many slots to keep attestations for.',
-        ...numberConfigHelper(96)
-    },
     gossipsubInterval: {
         env: 'P2P_GOSSIPSUB_INTERVAL_MS',
         description: 'The interval of the gossipsub heartbeat to perform maintenance tasks.',
@@ -131,9 +121,14 @@ export const p2pConfigMappings = {
     },
     gossipsubMcacheGossip: {
         env: 'P2P_GOSSIPSUB_MCACHE_GOSSIP',
-        description: 'How many message cache windows to include when gossiping with other pears.',
+        description: 'How many message cache windows to include when gossiping with other peers.',
         ...numberConfigHelper(3)
     },
+    gossipsubSeenTTL: {
+        env: 'P2P_GOSSIPSUB_SEEN_TTL',
+        description: 'How long to keep message IDs in the seen cache.',
+        ...numberConfigHelper(20 * 60 * 1000)
+    },
     gossipsubTxTopicWeight: {
         env: 'P2P_GOSSIPSUB_TX_TOPIC_WEIGHT',
         description: 'The weight of the tx topic for the gossipsub protocol.',

package/dest/enr/generate-enr.d.ts

@@ -1,9 +1,17 @@
 import type { LogFn } from '@aztec/foundation/log';
-import { SignableENR } from '@chainsafe/enr';
+import { type ChainConfig } from '@aztec/stdlib/config';
+import type { ComponentsVersions } from '@aztec/stdlib/versioning';
+import { ENR, SignableENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
+import { type Multiaddr } from '@multiformats/multiaddr';
+export { ENR };
 export declare function createBootnodeENRandPeerId(privateKey: string, p2pIp: string, p2pBroadcastPort: number, l1ChainId: number): Promise<{
     enr: SignableENR;
     peerId: PeerId;
 }>;
+export declare function createNodeENR(peerId: PeerId, multiAddrUdp: Multiaddr | undefined, multiAddrTcp: Multiaddr | undefined, chainConfig: ChainConfig, packageVersion: string): {
+    enr: SignableENR;
+    versions: ComponentsVersions;
+};
 export declare function printENR(enr: string, log: LogFn): Promise<void>;
 //# sourceMappingURL=generate-enr.d.ts.map

package/dest/enr/generate-enr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-enr.d.ts","sourceRoot":"","sources":["../../src/enr/generate-enr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGnD,OAAO,EAAO,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAOhD,wBAAsB,0BAA0B,CAC9C,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,gBAAgB,EAAE,MAAM,EACxB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,GAAG,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAa/C;AAED,wBAAsB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,iBAQrD"}
+{"version":3,"file":"generate-enr.d.ts","sourceRoot":"","sources":["../../src/enr/generate-enr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,KAAK,WAAW,EAAoB,MAAM,sBAAsB,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,yBAAyB,CAAC;AAMpE,OAAO,EAAE,GAAG,EAAE,CAAC;AAEf,wBAAsB,0BAA0B,CAC9C,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,gBAAgB,EAAE,MAAM,EACxB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,GAAG,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAa/C;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,SAAS,GAAG,SAAS,EACnC,YAAY,EAAE,SAAS,GAAG,SAAS,EACnC,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,MAAM,GACrB;IAAE,GAAG,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,kBAAkB,CAAA;CAAE,CAiBpD;AAED,wBAAsB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,iBAYrD"}