@aztec/archiver 0.0.1-commit.d117d021b → 0.0.1-commit.d1da697d6

package/dest/modules/l1_synchronizer.d.ts

@@ -42,7 +42,6 @@ export declare class ArchiverL1Synchronizer implements Traceable {
     }, blobClient: BlobClientInterface, epochCache: EpochCache, dateProvider: DateProvider, instrumentation: ArchiverInstrumentation, l1Constants: L1RollupConstants & {
         l1StartBlockHash: Buffer32;
         genesisArchiveRoot: Fr;
-        rollupManaLimit?: number;
     }, events: ArchiverEmitter, tracer: Tracer, l2TipsCache?: L2TipsCache, log?: Logger);
     /** Sets new config */
     setConfig(newConfig: {
@@ -57,16 +56,18 @@ export declare class ArchiverL1Synchronizer implements Traceable {
     /** Checks that the ethereum node we are connected to has a latest timestamp no more than the allowed drift. Throw if not. */
     testEthereumNodeSynced(): Promise<void>;
     syncFromL1(initialSyncComplete: boolean): Promise<void>;
+    private updateFinalizedCheckpoint;
     private pruneUncheckpointedBlocks;
     private canPrune;
     private handleEpochPrune;
     private nextRange;
     private handleL1ToL2Messages;
-    private retrieveL1ToL2Message;
+    private localStateMatches;
+    private retrieveAndStoreMessages;
     private rollbackL1ToL2Messages;
     private getL1BlockHash;
     private handleCheckpoints;
     private checkForNewCheckpointsBeforeL1SyncPoint;
     private getCheckpointHeader;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/modules/l1_synchronizer.d.ts.map

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

package/dest/modules/l1_synchronizer.js

@@ -371,20 +371,23 @@ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
     return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
 }
 var _dec, _dec1, _dec2, _dec3, _initProto;
+import { asyncPool } from '@aztec/foundation/async-pool';
 import { maxBigint } from '@aztec/foundation/bigint';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
-import { Buffer32 } from '@aztec/foundation/buffer';
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
 import { pick } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
+import { retryTimes } from '@aztec/foundation/retry';
 import { count } from '@aztec/foundation/string';
 import { Timer, elapsed } from '@aztec/foundation/timer';
-import { isDefined } from '@aztec/foundation/types';
+import { isDefined, isErrorClass } from '@aztec/foundation/types';
 import { L2BlockSourceEvents } from '@aztec/stdlib/block';
 import { getEpochAtSlot, getSlotAtNextL1Block } from '@aztec/stdlib/epoch-helpers';
 import { computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import { execInSpan, trackSpan } from '@aztec/telemetry-client';
 import { InitialCheckpointNumberNotSequentialError } from '../errors.js';
 import { retrieveCheckpointsFromRollup, retrieveL1ToL2Message, retrieveL1ToL2Messages, retrievedToPublishedCheckpoint } from '../l1/data_retrieval.js';
+import { MessageStoreError } from '../store/message_store.js';
 import { ArchiverDataStoreUpdater } from './data_store_updater.js';
 import { validateCheckpointAttestations } from './validation.js';
 _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.handleEpochPrune'), _dec2 = trackSpan('Archiver.handleL1ToL2Messages'), _dec3 = trackSpan('Archiver.handleCheckpoints');
@@ -477,12 +480,20 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.handleEpoch
         }
     }
     async syncFromL1(initialSyncComplete) {
+        // In between the various calls to L1, the block number can move meaning some of the following
+        // calls will return data for blocks that were not present during earlier calls. To combat this
+        // we ensure that all data retrieval methods only retrieve data up to the currentBlockNumber
+        // captured at the top of this function.
         const currentL1Block = await this.publicClient.getBlock({
             includeTransactions: false
         });
         const currentL1BlockNumber = currentL1Block.number;
         const currentL1BlockHash = Buffer32.fromString(currentL1Block.hash);
         const currentL1Timestamp = currentL1Block.timestamp;
+        const currentL1BlockData = {
+            l1BlockNumber: currentL1BlockNumber,
+            l1BlockHash: currentL1BlockHash
+        };
         if (this.l1BlockHash && currentL1BlockHash.equals(this.l1BlockHash)) {
             this.log.trace(`No new L1 blocks since last sync at L1 block ${this.l1BlockNumber}`);
             return;
@@ -498,36 +509,16 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.handleEpoch
                 maxAllowedDelay
             });
         }
-        // Load sync point for blocks and messages defaulting to start block
-        const { blocksSynchedTo = this.l1Constants.l1StartBlock, messagesSynchedTo = {
-            l1BlockNumber: this.l1Constants.l1StartBlock,
-            l1BlockHash: this.l1Constants.l1StartBlockHash
-        } } = await this.store.getSynchPoint();
+        // Load sync point for blocks defaulting to start block
+        const { blocksSynchedTo = this.l1Constants.l1StartBlock } = await this.store.getSynchPoint();
         this.log.debug(`Starting new archiver sync iteration`, {
             blocksSynchedTo,
-            messagesSynchedTo,
-            currentL1BlockNumber,
-            currentL1BlockHash
+            currentL1BlockData
         });
-        // ********** Ensuring Consistency of data pulled from L1 **********
-        /**
-     * There are a number of calls in this sync operation to L1 for retrieving
-     * events and transaction data. There are a couple of things we need to bear in mind
-     * to ensure that data is read exactly once.
-     *
-     * The first is the problem of eventually consistent ETH service providers like Infura.
-     * Each L1 read operation will query data from the last L1 block that it saw emit its kind of data.
-     * (so pending L1 to L2 messages will read from the last L1 block that emitted a message and so  on)
-     * This will mean the archiver will lag behind L1 and will only advance when there's L2-relevant activity on the chain.
-     *
-     * The second is that in between the various calls to L1, the block number can move meaning some
-     * of the following calls will return data for blocks that were not present during earlier calls.
-     * To combat this for the time being we simply ensure that all data retrieval methods only retrieve
-     * data up to the currentBlockNumber captured at the top of this function. We might want to improve on this
-     * in future but for the time being it should give us the guarantees that we need
-     */ // ********** Events that are processed per L1 block **********
-        await this.handleL1ToL2Messages(messagesSynchedTo, currentL1BlockNumber);
-        // ********** Events that are processed per checkpoint **********
+        // Sync L1 to L2 messages. We retry this a few times since there are error conditions that reset the sync point, requiring a new iteration.
+        // Note that we cannot just wait for the l1 synchronizer to loop again, since the synchronizer would report as synced up to the current L1
+        // block, when that wouldn't be the case, since L1 to L2 messages would need another iteration.
+        await retryTimes(()=>this.handleL1ToL2Messages(currentL1BlockData), 'Handling L1 to L2 messages', 3, 0.1);
         if (currentL1BlockNumber > blocksSynchedTo) {
             // First we retrieve new checkpoints and L2 blocks and store them in the DB. This will also update the
             // pending chain validation status, proven checkpoint number, and synched L1 block number.
@@ -555,6 +546,8 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.handleEpoch
             }
             this.instrumentation.updateL1BlockHeight(currentL1BlockNumber);
         }
+        // Update the finalized L2 checkpoint based on L1 finality.
+        await this.updateFinalizedCheckpoint();
         // After syncing has completed, update the current l1 block number and timestamp,
         // otherwise we risk announcing to the world that we've synced to a given point,
         // but the corresponding blocks have not been processed (see #12631).
@@ -568,6 +561,31 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.handleEpoch
             l1BlockNumberAtEnd
         });
     }
+    /** Query L1 for its finalized block and update the finalized checkpoint accordingly. */ async updateFinalizedCheckpoint() {
+        try {
+            const finalizedL1Block = await this.publicClient.getBlock({
+                blockTag: 'finalized',
+                includeTransactions: false
+            });
+            const finalizedL1BlockNumber = finalizedL1Block.number;
+            const finalizedCheckpointNumber = await this.rollup.getProvenCheckpointNumber({
+                blockNumber: finalizedL1BlockNumber
+            });
+            const localFinalizedCheckpointNumber = await this.store.getFinalizedCheckpointNumber();
+            if (localFinalizedCheckpointNumber !== finalizedCheckpointNumber) {
+                await this.updater.setFinalizedCheckpointNumber(finalizedCheckpointNumber);
+                this.log.info(`Updated finalized chain to checkpoint ${finalizedCheckpointNumber}`, {
+                    finalizedCheckpointNumber,
+                    finalizedL1BlockNumber
+                });
+            }
+        } catch (err) {
+            // The rollup contract may not exist at the finalized L1 block right after deployment.
+            if (!err?.message?.includes('returned no data')) {
+                this.log.warn(`Failed to update finalized checkpoint: ${err}`);
+            }
+        }
+    }
     /** Prune all proposed local blocks that should have been checkpointed by now. */ async pruneUncheckpointedBlocks(currentL1Timestamp) {
         const [lastCheckpointedBlockNumber, lastProposedBlockNumber] = await Promise.all([
             this.store.getCheckpointedL2BlockNumber(),
@@ -578,26 +596,28 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.handleEpoch
             this.log.trace(`No uncheckpointed blocks to prune.`);
             return;
         }
-        // What's the slot of the first uncheckpointed block?
+        // What's the slot at the next L1 block? All blocks for slots strictly before this one should've been checkpointed by now.
+        const slotAtNextL1Block = getSlotAtNextL1Block(currentL1Timestamp, this.l1Constants);
         const firstUncheckpointedBlockNumber = BlockNumber(lastCheckpointedBlockNumber + 1);
+        // What's the slot of the first uncheckpointed block?
         const [firstUncheckpointedBlockHeader] = await this.store.getBlockHeaders(firstUncheckpointedBlockNumber, 1);
         const firstUncheckpointedBlockSlot = firstUncheckpointedBlockHeader?.getSlot();
-        // What's the slot at the next L1 block? All blocks for slots strictly before this one should've been checkpointed by now.
-        const slotAtNextL1Block = getSlotAtNextL1Block(currentL1Timestamp, this.l1Constants);
-        // Prune provisional blocks from slots that have ended without being checkpointed
-        if (firstUncheckpointedBlockSlot !== undefined && firstUncheckpointedBlockSlot < slotAtNextL1Block) {
-            this.log.warn(`Pruning blocks after block ${lastCheckpointedBlockNumber} due to slot ${firstUncheckpointedBlockSlot} not being checkpointed`, {
-                firstUncheckpointedBlockHeader: firstUncheckpointedBlockHeader.toInspect(),
-                slotAtNextL1Block
+        if (firstUncheckpointedBlockSlot === undefined || firstUncheckpointedBlockSlot >= slotAtNextL1Block) {
+            return;
+        }
+        // Prune provisional blocks from slots that have ended without being checkpointed.
+        // This also clears any proposed checkpoint whose blocks are being pruned.
+        this.log.warn(`Pruning blocks after block ${lastCheckpointedBlockNumber} due to slot ${firstUncheckpointedBlockSlot} not being checkpointed`, {
+            firstUncheckpointedBlockHeader: firstUncheckpointedBlockHeader.toInspect(),
+            slotAtNextL1Block
+        });
+        const prunedBlocks = await this.updater.removeUncheckpointedBlocksAfter(lastCheckpointedBlockNumber);
+        if (prunedBlocks.length > 0) {
+            this.events.emit(L2BlockSourceEvents.L2PruneUncheckpointed, {
+                type: L2BlockSourceEvents.L2PruneUncheckpointed,
+                slotNumber: firstUncheckpointedBlockSlot,
+                blocks: prunedBlocks
             });
-            const prunedBlocks = await this.updater.removeUncheckpointedBlocksAfter(lastCheckpointedBlockNumber);
-            if (prunedBlocks.length > 0) {
-                this.events.emit(L2BlockSourceEvents.L2PruneUncheckpointed, {
-                    type: L2BlockSourceEvents.L2PruneUncheckpointed,
-                    slotNumber: firstUncheckpointedBlockSlot,
-                    blocks: prunedBlocks
-                });
-            }
         }
     }
     /** Queries the rollup contract on whether a prune can be executed on the immediate next L1 block. */ async canPrune(currentL1BlockNumber, currentL1Timestamp) {
@@ -628,12 +648,14 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.handleEpoch
             const pruneFromSlotNumber = header.slotNumber;
             const pruneFromEpochNumber = getEpochAtSlot(pruneFromSlotNumber, this.l1Constants);
             const checkpointsToUnwind = localPendingCheckpointNumber - provenCheckpointNumber;
-            const checkpointPromises = Array.from({
+            // Fetch checkpoints and blocks in bounded batches to avoid unbounded concurrent
+            // promises when the gap between local pending and proven checkpoint numbers is large.
+            const BATCH_SIZE = 10;
+            const indices = Array.from({
                 length: checkpointsToUnwind
-            }).fill(0).map((_, i)=>this.store.getCheckpointData(CheckpointNumber(i + pruneFrom)));
-            const checkpoints = await Promise.all(checkpointPromises);
-            const blockPromises = await Promise.all(checkpoints.filter(isDefined).map((cp)=>this.store.getBlocksForCheckpoint(CheckpointNumber(cp.checkpointNumber))));
-            const newBlocks = blockPromises.filter(isDefined).flat();
+            }, (_, i)=>CheckpointNumber(i + pruneFrom));
+            const checkpoints = (await asyncPool(BATCH_SIZE, indices, (idx)=>this.store.getCheckpointData(idx))).filter(isDefined);
+            const newBlocks = (await asyncPool(BATCH_SIZE, checkpoints, (cp)=>this.store.getBlocksForCheckpoint(CheckpointNumber(cp.checkpointNumber)))).filter(isDefined).flat();
             // Emit an event for listening services to react to the chain prune
             this.events.emit(L2BlockSourceEvents.L2PruneUnproven, {
                 type: L2BlockSourceEvents.L2PruneUnproven,
@@ -667,55 +689,75 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.handleEpoch
             nextEnd
         ];
     }
-    async handleL1ToL2Messages(messagesSyncPoint, currentL1BlockNumber) {
-        this.log.trace(`Handling L1 to L2 messages from ${messagesSyncPoint.l1BlockNumber} to ${currentL1BlockNumber}.`);
-        if (currentL1BlockNumber <= messagesSyncPoint.l1BlockNumber) {
-            return;
+    async handleL1ToL2Messages(currentL1Block) {
+        // Load the syncpoint, which may have been updated in a previous iteration
+        const { messagesSynchedTo = {
+            l1BlockNumber: this.l1Constants.l1StartBlock,
+            l1BlockHash: this.l1Constants.l1StartBlockHash
+        } } = await this.store.getSynchPoint();
+        // Nothing to do if L1 block number has not moved forward
+        const currentL1BlockNumber = currentL1Block.l1BlockNumber;
+        if (currentL1BlockNumber <= messagesSynchedTo.l1BlockNumber) {
+            return true;
         }
-        // Load remote and local inbox states.
-        const localMessagesInserted = await this.store.getTotalL1ToL2MessageCount();
-        const localLastMessage = await this.store.getLastL1ToL2Message();
+        // Compare local message store state with the remote. If they match, we just advance the match pointer.
         const remoteMessagesState = await this.inbox.getState({
             blockNumber: currentL1BlockNumber
         });
-        this.log.trace(`Retrieved remote inbox state at L1 block ${currentL1BlockNumber}.`, {
-            localMessagesInserted,
-            localLastMessage,
-            remoteMessagesState
-        });
-        // Compare message count and rolling hash. If they match, no need to retrieve anything.
-        if (remoteMessagesState.totalMessagesInserted === localMessagesInserted && remoteMessagesState.messagesRollingHash.equals(localLastMessage?.rollingHash ?? Buffer32.ZERO)) {
-            this.log.trace(`No L1 to L2 messages to query between L1 blocks ${messagesSyncPoint.l1BlockNumber} and ${currentL1BlockNumber}.`);
-            return;
+        const localLastMessage = await this.store.getLastL1ToL2Message();
+        if (await this.localStateMatches(localLastMessage, remoteMessagesState)) {
+            this.log.trace(`Local L1 to L2 messages are already in sync with remote at L1 block ${currentL1BlockNumber}`);
+            await this.store.setMessageSyncState(currentL1Block, remoteMessagesState.treeInProgress);
+            return true;
         }
-        // Check if our syncpoint is still valid. If not, there was an L1 reorg and we need to re-retrieve messages.
-        // Note that we need to fetch it from logs and not from inbox state at the syncpoint l1 block number, since it
-        // could be older than 128 blocks and non-archive nodes cannot resolve it.
-        if (localLastMessage) {
-            const remoteLastMessage = await this.retrieveL1ToL2Message(localLastMessage.leaf);
-            this.log.trace(`Retrieved remote message for local last`, {
-                remoteLastMessage,
-                localLastMessage
-            });
-            if (!remoteLastMessage || !remoteLastMessage.rollingHash.equals(localLastMessage.rollingHash)) {
-                this.log.warn(`Rolling back L1 to L2 messages due to hash mismatch or msg not found.`, {
-                    remoteLastMessage,
-                    messagesSyncPoint,
-                    localLastMessage
-                });
-                messagesSyncPoint = await this.rollbackL1ToL2Messages(localLastMessage, messagesSyncPoint);
-                this.log.debug(`Rolled back L1 to L2 messages to L1 block ${messagesSyncPoint.l1BlockNumber}.`, {
-                    messagesSyncPoint
+        // If not, then we are out of sync. Most likely there are new messages on the inbox, so we try retrieving them.
+        // However, it could also be the case that there was an L1 reorg and our syncpoint is no longer valid.
+        // If that's the case, we'd get an exception out of the message store since the rolling hash of the first message
+        // we try to insert would not match the one in the db, in which case we rollback to the last common message with L1.
+        try {
+            await this.retrieveAndStoreMessages(messagesSynchedTo.l1BlockNumber, currentL1BlockNumber);
+        } catch (error) {
+            if (isErrorClass(error, MessageStoreError)) {
+                this.log.warn(`Failed to store L1 to L2 messages retrieved from L1: ${error.message}. Rolling back syncpoint to retry.`, {
+                    inboxMessage: error.inboxMessage
                 });
+                await this.rollbackL1ToL2Messages(remoteMessagesState.treeInProgress);
+                return false;
             }
+            throw error;
         }
-        // Retrieve and save messages in batches. Each batch is estimated to acommodate up to L2 'blockBatchSize' blocks,
+        // Note that, if there are no new messages to insert, but there was an L1 reorg that pruned out last messages,
+        // we'd notice by comparing our local state with the remote one again, and seeing they don't match even after
+        // our sync attempt. In this case, we also rollback our syncpoint, and trigger a retry.
+        const localLastMessageAfterSync = await this.store.getLastL1ToL2Message();
+        if (!await this.localStateMatches(localLastMessageAfterSync, remoteMessagesState)) {
+            this.log.warn(`Local L1 to L2 messages state does not match remote after sync attempt. Rolling back syncpoint to retry.`, {
+                localLastMessageAfterSync,
+                remoteMessagesState
+            });
+            await this.rollbackL1ToL2Messages(remoteMessagesState.treeInProgress);
+            return false;
+        }
+        // Advance the syncpoint after a successful sync
+        await this.store.setMessageSyncState(currentL1Block, remoteMessagesState.treeInProgress);
+        return true;
+    }
+    /** Checks if the local rolling hash and message count matches the remote state */ async localStateMatches(localLastMessage, remoteState) {
+        const localMessageCount = await this.store.getTotalL1ToL2MessageCount();
+        this.log.trace(`Comparing local and remote inbox state`, {
+            localMessageCount,
+            localLastMessage,
+            remoteState
+        });
+        return remoteState.totalMessagesInserted === localMessageCount && remoteState.messagesRollingHash.equals(localLastMessage?.rollingHash ?? Buffer16.ZERO);
+    }
+    /** Retrieves L1 to L2 messages from L1 in batches and stores them. */ async retrieveAndStoreMessages(fromL1Block, toL1Block) {
         let searchStartBlock = 0n;
-        let searchEndBlock = messagesSyncPoint.l1BlockNumber;
+        let searchEndBlock = fromL1Block;
         let lastMessage;
         let messageCount = 0;
         do {
-            [searchStartBlock, searchEndBlock] = this.nextRange(searchEndBlock, currentL1BlockNumber);
+            [searchStartBlock, searchEndBlock] = this.nextRange(searchEndBlock, toL1Block);
             this.log.trace(`Retrieving L1 to L2 messages in L1 blocks ${searchStartBlock}-${searchEndBlock}`);
             const messages = await retrieveL1ToL2Messages(this.inbox, searchStartBlock, searchEndBlock);
             const timer = new Timer();
@@ -730,74 +772,65 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.handleEpoch
                 lastMessage = msg;
                 messageCount++;
             }
-        }while (searchEndBlock < currentL1BlockNumber)
-        // Log stats for messages retrieved (if any).
+        }while (searchEndBlock < toL1Block)
         if (messageCount > 0) {
             this.log.info(`Retrieved ${messageCount} new L1 to L2 messages up to message with index ${lastMessage?.index} for checkpoint ${lastMessage?.checkpointNumber}`, {
                 lastMessage,
                 messageCount
             });
         }
-        // Warn if the resulting rolling hash does not match the remote state we had retrieved.
-        if (lastMessage && !lastMessage.rollingHash.equals(remoteMessagesState.messagesRollingHash)) {
-            this.log.warn(`Last message retrieved rolling hash does not match remote state.`, {
-                lastMessage,
-                remoteMessagesState
-            });
-        }
-    }
-    async retrieveL1ToL2Message(leaf) {
-        const currentL1BlockNumber = await this.publicClient.getBlockNumber();
-        let searchStartBlock = 0n;
-        let searchEndBlock = this.l1Constants.l1StartBlock - 1n;
-        do {
-            [searchStartBlock, searchEndBlock] = this.nextRange(searchEndBlock, currentL1BlockNumber);
-            const message = await retrieveL1ToL2Message(this.inbox, leaf, searchStartBlock, searchEndBlock);
-            if (message) {
-                return message;
-            }
-        }while (searchEndBlock < currentL1BlockNumber)
-        return undefined;
     }
-    async rollbackL1ToL2Messages(localLastMessage, messagesSyncPoint) {
+    /**
+   * Rolls back local L1 to L2 messages to the last common message with L1, and updates the syncpoint to the L1 block of that message.
+   * If no common message is found, rolls back all messages and sets the syncpoint to the start block.
+   */ async rollbackL1ToL2Messages(remoteTreeInProgress) {
         // Slowly go back through our messages until we find the last common message.
         // We could query the logs in batch as an optimization, but the depth of the reorg should not be deep, and this
         // is a very rare case, so it's fine to query one log at a time.
         let commonMsg;
-        this.log.verbose(`Searching most recent common L1 to L2 message at or before index ${localLastMessage.index}`);
-        for await (const msg of this.store.iterateL1ToL2Messages({
-            reverse: true,
-            end: localLastMessage.index
+        let messagesToDelete = 0;
+        this.log.verbose(`Searching most recent common L1 to L2 message`);
+        for await (const localMsg of this.store.iterateL1ToL2Messages({
+            reverse: true
         })){
-            const remoteMsg = await this.retrieveL1ToL2Message(msg.leaf);
+            const remoteMsg = await retrieveL1ToL2Message(this.inbox, localMsg);
             const logCtx = {
                 remoteMsg,
-                localMsg: msg
+                localMsg: localMsg
             };
-            if (remoteMsg && remoteMsg.rollingHash.equals(msg.rollingHash)) {
-                this.log.verbose(`Found most recent common L1 to L2 message at index ${msg.index} on L1 block ${msg.l1BlockNumber}`, logCtx);
+            if (remoteMsg && remoteMsg.rollingHash.equals(localMsg.rollingHash)) {
+                this.log.verbose(`Found most recent common L1 to L2 message at index ${localMsg.index} on L1 block ${localMsg.l1BlockNumber}`, logCtx);
                 commonMsg = remoteMsg;
                 break;
             } else if (remoteMsg) {
-                this.log.debug(`Local L1 to L2 message with index ${msg.index} has different rolling hash`, logCtx);
+                this.log.debug(`Local L1 to L2 message with index ${localMsg.index} has different rolling hash`, logCtx);
+                messagesToDelete++;
             } else {
-                this.log.debug(`Local L1 to L2 message with index ${msg.index} not found on L1`, logCtx);
+                this.log.debug(`Local L1 to L2 message with index ${localMsg.index} not found on L1`, logCtx);
+                messagesToDelete++;
             }
         }
-        // Delete everything after the common message we found.
-        const lastGoodIndex = commonMsg?.index;
-        this.log.warn(`Deleting all local L1 to L2 messages after index ${lastGoodIndex ?? 'undefined'}`);
-        await this.store.removeL1ToL2Messages(lastGoodIndex !== undefined ? lastGoodIndex + 1n : 0n);
+        // Delete everything after the common message we found, if anything needs to be deleted.
+        // Do not exit early if there are no messages to delete, we still want to update the syncpoint.
+        if (messagesToDelete > 0) {
+            const lastGoodIndex = commonMsg?.index;
+            this.log.warn(`Rolling back all local L1 to L2 messages after index ${lastGoodIndex ?? 'initial'}`);
+            await this.store.removeL1ToL2Messages(lastGoodIndex !== undefined ? lastGoodIndex + 1n : 0n);
+        }
         // Update the syncpoint so the loop below reprocesses the changed messages. We go to the block before
         // the last common one, so we force reprocessing it, in case new messages were added on that same L1 block
         // after the last common message.
         const syncPointL1BlockNumber = commonMsg ? commonMsg.l1BlockNumber - 1n : this.l1Constants.l1StartBlock;
         const syncPointL1BlockHash = await this.getL1BlockHash(syncPointL1BlockNumber);
-        messagesSyncPoint = {
+        const messagesSyncPoint = {
             l1BlockNumber: syncPointL1BlockNumber,
             l1BlockHash: syncPointL1BlockHash
         };
-        await this.store.setMessageSynchedL1Block(messagesSyncPoint);
+        await this.store.setMessageSyncState(messagesSyncPoint, remoteTreeInProgress);
+        this.log.verbose(`Updated messages syncpoint to L1 block ${syncPointL1BlockNumber}`, {
+            ...messagesSyncPoint,
+            remoteTreeInProgress
+        });
         return messagesSyncPoint;
     }
     async getL1BlockHash(l1BlockNumber) {
@@ -1023,7 +1056,7 @@ _dec = trackSpan('Archiver.syncFromL1'), _dec1 = trackSpan('Archiver.handleEpoch
                 if (result.prunedBlocks && result.prunedBlocks.length > 0) {
                     const prunedCheckpointNumber = result.prunedBlocks[0].checkpointNumber;
                     const prunedSlotNumber = result.prunedBlocks[0].header.globalVariables.slotNumber;
-                    this.log.warn(`Pruned ${result.prunedBlocks.length} mismatching blocks for checkpoint ${prunedCheckpointNumber}`, {
+                    this.log.info(`Pruned ${result.prunedBlocks.length} mismatching blocks for checkpoint ${prunedCheckpointNumber}`, {
                         prunedBlocks: result.prunedBlocks.map((b)=>b.toBlockInfo()),
                         prunedSlotNumber,
                         prunedCheckpointNumber

package/dest/modules/validation.d.ts

@@ -14,4 +14,4 @@ export declare function getAttestationInfoFromPublishedCheckpoint({ checkpoint,
  * Returns true if the attestations are valid and sufficient, false otherwise.
  */
 export declare function validateCheckpointAttestations(publishedCheckpoint: PublishedCheckpoint, epochCache: EpochCache, constants: Pick<L1RollupConstants, 'epochDuration'>, logger?: Logger): Promise<ValidateCheckpointResult>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21vZHVsZXMvdmFsaWRhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUdyRCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNwRCxPQUFPLEVBQ0wsS0FBSyxlQUFlLEVBRXBCLEtBQUssd0JBQXdCLEVBRTlCLE1BQU0scUJBQXFCLENBQUM7QUFDN0IsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUNwRSxPQUFPLEVBQUUsS0FBSyxpQkFBaUIsRUFBa0IsTUFBTSw2QkFBNkIsQ0FBQztBQUdyRixZQUFZLEVBQUUsd0JBQXdCLEVBQUUsQ0FBQztBQUV6Qzs7O0dBR0c7QUFDSCx3QkFBZ0IseUNBQXlDLENBQUMsRUFDeEQsVUFBVSxFQUNWLFlBQVksRUFDYixFQUFFLG1CQUFtQixHQUFHLGVBQWUsRUFBRSxDQUd6QztBQUVEOzs7R0FHRztBQUNILHdCQUFzQiw4QkFBOEIsQ0FDbEQsbUJBQW1CLEVBQUUsbUJBQW1CLEVBQ3hDLFVBQVUsRUFBRSxVQUFVLEVBQ3RCLFNBQVMsRUFBRSxJQUFJLENBQUMsaUJBQWlCLEVBQUUsZUFBZSxDQUFDLEVBQ25ELE1BQU0sQ0FBQyxFQUFFLE1BQU0sR0FDZCxPQUFPLENBQUMsd0JBQXdCLENBQUMsQ0EyRm5DIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21vZHVsZXMvdmFsaWRhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUdyRCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNwRCxPQUFPLEVBQ0wsS0FBSyxlQUFlLEVBRXBCLEtBQUssd0JBQXdCLEVBRTlCLE1BQU0scUJBQXFCLENBQUM7QUFDN0IsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUNwRSxPQUFPLEVBQUUsS0FBSyxpQkFBaUIsRUFBaUMsTUFBTSw2QkFBNkIsQ0FBQztBQUdwRyxZQUFZLEVBQUUsd0JBQXdCLEVBQUUsQ0FBQztBQUV6Qzs7O0dBR0c7QUFDSCx3QkFBZ0IseUNBQXlDLENBQUMsRUFDeEQsVUFBVSxFQUNWLFlBQVksRUFDYixFQUFFLG1CQUFtQixHQUFHLGVBQWUsRUFBRSxDQUd6QztBQUVEOzs7R0FHRztBQUNILHdCQUFzQiw4QkFBOEIsQ0FDbEQsbUJBQW1CLEVBQUUsbUJBQW1CLEVBQ3hDLFVBQVUsRUFBRSxVQUFVLEVBQ3RCLFNBQVMsRUFBRSxJQUFJLENBQUMsaUJBQWlCLEVBQUUsZUFBZSxDQUFDLEVBQ25ELE1BQU0sQ0FBQyxFQUFFLE1BQU0sR0FDZCxPQUFPLENBQUMsd0JBQXdCLENBQUMsQ0EyRm5DIn0=

package/dest/modules/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/modules/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,wBAAwB,EAE9B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,KAAK,iBAAiB,EAAkB,MAAM,6BAA6B,CAAC;AAGrF,YAAY,EAAE,wBAAwB,EAAE,CAAC;AAEzC;;;GAGG;AACH,wBAAgB,yCAAyC,CAAC,EACxD,UAAU,EACV,YAAY,EACb,EAAE,mBAAmB,GAAG,eAAe,EAAE,CAGzC;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,mBAAmB,EAAE,mBAAmB,EACxC,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EACnD,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,wBAAwB,CAAC,CA2FnC"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/modules/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,wBAAwB,EAE9B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,KAAK,iBAAiB,EAAiC,MAAM,6BAA6B,CAAC;AAGpG,YAAY,EAAE,wBAAwB,EAAE,CAAC;AAEzC;;;GAGG;AACH,wBAAgB,yCAAyC,CAAC,EACxD,UAAU,EACV,YAAY,EACb,EAAE,mBAAmB,GAAG,eAAe,EAAE,CAGzC;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,mBAAmB,EAAE,mBAAmB,EACxC,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,EACnD,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,wBAAwB,CAAC,CA2FnC"}

package/dest/modules/validation.js

@@ -1,6 +1,6 @@
 import { compactArray } from '@aztec/foundation/collection';
 import { getAttestationInfoFromPayload } from '@aztec/stdlib/block';
-import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { computeQuorum, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 import { ConsensusPayload } from '@aztec/stdlib/p2p';
 /**
  * Extracts attestation information from a published checkpoint.
@@ -46,7 +46,7 @@ import { ConsensusPayload } from '@aztec/stdlib/p2p';
             valid: true
         };
     }
-    const requiredAttestationCount = Math.floor(committee.length * 2 / 3) + 1;
+    const requiredAttestationCount = computeQuorum(committee.length);
     const failedValidationResult = (reason)=>({
             valid: false,
             reason,