@aztec/archiver 0.0.1-commit.c2eed6949 → 0.0.1-commit.c52d6e7

package/dest/modules/data_store_updater.js

@@ -11,12 +11,12 @@ import { computeContractAddressFromInstance, computeContractClassId } from '@azt
     return Operation;
 }(Operation || {});
 /** Archiver helper module to handle updates to the data store. */ export class ArchiverDataStoreUpdater {
-    store;
+    stores;
     l2TipsCache;
     opts;
     log;
-    constructor(store, l2TipsCache, opts = {}){
-        this.store = store;
+    constructor(stores, l2TipsCache, opts = {}){
+        this.stores = stores;
         this.l2TipsCache = l2TipsCache;
         this.opts = opts;
         this.log = createLogger('archiver:store_updater');
@@ -30,21 +30,21 @@ import { computeContractAddressFromInstance, computeContractClassId } from '@azt
    * @param pendingChainValidationStatus - Optional validation status to set.
    * @returns True if the operation is successful.
    */ async addProposedBlock(block, pendingChainValidationStatus) {
-        const result = await this.store.transactionAsync(async ()=>{
-            await this.store.addProposedBlock(block);
+        const result = await this.stores.db.transactionAsync(async ()=>{
+            await this.stores.blocks.addProposedBlock(block);
             const opResults = await Promise.all([
                 // Update the pending chain validation status if provided
-                pendingChainValidationStatus && this.store.setPendingChainValidationStatus(pendingChainValidationStatus),
+                pendingChainValidationStatus && this.stores.blocks.setPendingChainValidationStatus(pendingChainValidationStatus),
                 // Add any logs emitted during the retrieved block
-                this.store.addLogs([
+                this.stores.logs.addLogs([
                     block
                 ]),
                 // Unroll all logs emitted during the retrieved block and extract any contract classes and instances from it
                 this.addContractDataToDb(block)
             ]);
-            await this.l2TipsCache?.refresh();
             return opResults.every(Boolean);
         });
+        await this.l2TipsCache?.refresh();
         return result;
     }
     /**
@@ -52,47 +52,75 @@ import { computeContractAddressFromInstance, computeContractClassId } from '@azt
    * Adds new checkpoints to the store with contract class/instance extraction from logs.
    * Prunes any local blocks that conflict with checkpoint data (by comparing archive roots).
    * Extracts ContractClassPublished, ContractInstancePublished, ContractInstanceUpdated events from the checkpoint block logs.
+   * If `promoteProposed` is supplied, the proposed-checkpoint promotion runs inside the same transaction
+   * as the added checkpoints so both updates are applied atomically.
    *
-   * @param checkpoints - The published checkpoints to add.
+   * @param checkpoints - The published checkpoints to add (excluding any being promoted from proposed).
    * @param pendingChainValidationStatus - Optional validation status to set.
+   * @param promoteProposed - Optional promotion of the current proposed checkpoint (fast path when blocks are already local).
    * @returns Result with information about any pruned blocks.
-   */ async addCheckpoints(checkpoints, pendingChainValidationStatus) {
+   */ async addCheckpoints(checkpoints, pendingChainValidationStatus, promoteProposed, evictProposedFrom) {
         for (const checkpoint of checkpoints){
             validateCheckpoint(checkpoint.checkpoint, {
                 rollupManaLimit: this.opts?.rollupManaLimit
             });
         }
-        const result = await this.store.transactionAsync(async ()=>{
+        if (promoteProposed) {
+            validateCheckpoint(promoteProposed.checkpoint.checkpoint, {
+                rollupManaLimit: this.opts?.rollupManaLimit
+            });
+        }
+        const result = await this.stores.db.transactionAsync(async ()=>{
             // Before adding checkpoints, check for conflicts with local blocks if any
             const { prunedBlocks, lastAlreadyInsertedBlockNumber } = await this.pruneMismatchingLocalBlocks(checkpoints);
-            await this.store.addCheckpoints(checkpoints);
-            // Filter out blocks that were already inserted via addProposedBlock() to avoid duplicating logs/contract data
-            const newBlocks = checkpoints.flatMap((ch)=>ch.checkpoint.blocks).filter((b)=>lastAlreadyInsertedBlockNumber === undefined || b.number > lastAlreadyInsertedBlockNumber);
+            const insertedCheckpoints = await this.stores.blocks.addCheckpoints(checkpoints);
+            // Skip blocks already inserted via addProposedBlock() and blocks of already-stored checkpoints
+            // re-included by an L1 reorg: their logs/contract data were extracted when first inserted.
+            const newBlocks = insertedCheckpoints.flatMap((ch)=>ch.checkpoint.blocks).filter((b)=>lastAlreadyInsertedBlockNumber === undefined || b.number > lastAlreadyInsertedBlockNumber);
             await Promise.all([
                 // Update the pending chain validation status if provided
-                pendingChainValidationStatus && this.store.setPendingChainValidationStatus(pendingChainValidationStatus),
+                pendingChainValidationStatus && this.stores.blocks.setPendingChainValidationStatus(pendingChainValidationStatus),
                 // Add any logs emitted during the retrieved blocks
-                this.store.addLogs(newBlocks),
+                this.stores.logs.addLogs(newBlocks),
                 // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
-                ...newBlocks.map((block)=>this.addContractDataToDb(block))
+                ...newBlocks.map((block)=>this.addContractDataToDb(block)),
+                // Promote the proposed checkpoint if requested (uses explicit checkpoint number)
+                promoteProposed ? this.stores.blocks.promoteProposedToCheckpointed(promoteProposed.checkpoint.checkpoint.number, promoteProposed.l1, promoteProposed.attestations, promoteProposed.checkpoint.checkpoint.archive.root) : undefined,
+                // Evict pending checkpoints that diverged from what L1 mined
+                evictProposedFrom !== undefined ? this.stores.blocks.evictProposedCheckpointsFrom(evictProposedFrom) : undefined
             ]);
-            await this.l2TipsCache?.refresh();
             return {
                 prunedBlocks,
                 lastAlreadyInsertedBlockNumber
             };
         });
+        await this.l2TipsCache?.refresh();
+        return result;
+    }
+    async addProposedCheckpoint(proposedCheckpoint) {
+        const result = await this.stores.db.transactionAsync(async ()=>{
+            await this.stores.blocks.addProposedCheckpoint(proposedCheckpoint);
+        });
+        await this.l2TipsCache?.refresh();
         return result;
     }
     /**
    * Checks for local proposed blocks that do not match the ones to be checkpointed and prunes them.
-   * This method handles multiple checkpoints but returns after pruning the first conflict found.
-   * This is correct because pruning from the first conflict point removes all subsequent blocks,
-   * and when checkpoints are added afterward, they include all the correct blocks.
+   * Conflict detection is keyed on `blockNumber`: when a local proposed block and an L1
+   * checkpointed block share a block number but live at different slots (e.g. a different proposer
+   * mined the same block number one slot earlier), we still treat them as a conflict and prune.
+   * The trailing per-checkpoint prune that handles "local has extra trailing blocks within the
+   * same slot as the published checkpoint" remains scoped by slot to preserve pipelining: local
+   * blocks that live at a later slot than the checkpoint being processed represent speculation
+   * atop the just-confirmed tip (and may be referenced by a pending proposed checkpoint), so we
+   * leave them in place. This method handles multiple checkpoints but returns after pruning the
+   * first conflict found. This is correct because pruning from the first conflict point removes
+   * all subsequent blocks, and when checkpoints are added afterward, they include all the correct
+   * blocks.
    */ async pruneMismatchingLocalBlocks(checkpoints) {
         const [lastCheckpointedBlockNumber, lastBlockNumber] = await Promise.all([
-            this.store.getCheckpointedL2BlockNumber(),
-            this.store.getLatestBlockNumber()
+            this.stores.blocks.getCheckpointedL2BlockNumber(),
+            this.stores.blocks.getLatestL2BlockNumber()
         ]);
         // Exit early if there are no local uncheckpointed blocks
         if (lastBlockNumber === lastCheckpointedBlockNumber) {
@@ -102,22 +130,25 @@ import { computeContractAddressFromInstance, computeContractClassId } from '@azt
             };
         }
         // Get all uncheckpointed local blocks
-        const uncheckpointedLocalBlocks = await this.store.getBlocks(BlockNumber.add(lastCheckpointedBlockNumber, 1), lastBlockNumber - lastCheckpointedBlockNumber);
+        const uncheckpointedLocalBlocks = await this.stores.blocks.getBlocksData({
+            from: BlockNumber.add(lastCheckpointedBlockNumber, 1),
+            limit: lastBlockNumber - lastCheckpointedBlockNumber
+        });
         let lastAlreadyInsertedBlockNumber;
         for (const publishedCheckpoint of checkpoints){
             const checkpointBlocks = publishedCheckpoint.checkpoint.blocks;
             const slot = publishedCheckpoint.checkpoint.slot;
-            const localBlocksInSlot = uncheckpointedLocalBlocks.filter((b)=>b.slot === slot);
             if (checkpointBlocks.length === 0) {
                 this.log.warn(`Checkpoint ${publishedCheckpoint.checkpoint.number} for slot ${slot} has no blocks`);
                 continue;
             }
-            // Find the first checkpoint block that conflicts with an existing local block and prune local afterwards
+            // Find the first checkpoint block that conflicts with an existing local block and prune local afterwards.
+            // Conflict detection joins on block number only — same block number at a different slot is still a conflict.
             for (const checkpointBlock of checkpointBlocks){
                 const blockNumber = checkpointBlock.number;
-                const existingBlock = localBlocksInSlot.find((b)=>b.number === blockNumber);
+                const existingBlock = uncheckpointedLocalBlocks.find((b)=>b.header.getBlockNumber() === blockNumber);
                 const blockInfos = {
-                    existingBlock: existingBlock?.toBlockInfo(),
+                    existingBlock: existingBlock?.header.toInspect(),
                     checkpointBlock: checkpointBlock.toBlockInfo()
                 };
                 if (!existingBlock) {
@@ -128,19 +159,23 @@ import { computeContractAddressFromInstance, computeContractClassId } from '@azt
                 } else {
                     this.log.info(`Conflict detected at block ${blockNumber} between checkpointed and local block`, blockInfos);
                     const prunedBlocks = await this.removeBlocksAfter(BlockNumber(blockNumber - 1));
+                    await this.evictProposedCheckpointsForPrunedBlocks(prunedBlocks);
                     return {
                         prunedBlocks,
                         lastAlreadyInsertedBlockNumber
                     };
                 }
             }
-            // If local has more blocks than the checkpoint (e.g., local has [2,3,4] but checkpoint has [2,3]),
-            // we need to prune the extra local blocks so they match what was checkpointed
+            // If the sequencer locally proposed extra blocks within this checkpoint's slot (e.g. local has
+            // [N, N+1] but L1 confirmed just [N]), prune the extras. Scoped to the checkpoint's slot so we
+            // do not throw away speculative blocks at later slots that belong to a pending proposed checkpoint.
             const lastCheckpointBlockNumber = checkpointBlocks.at(-1).number;
-            const lastLocalBlockNumber = localBlocksInSlot.at(-1)?.number;
+            const localBlocksInSlot = uncheckpointedLocalBlocks.filter((b)=>b.header.getSlot() === slot);
+            const lastLocalBlockNumber = localBlocksInSlot.at(-1)?.header.getBlockNumber();
             if (lastLocalBlockNumber !== undefined && lastLocalBlockNumber > lastCheckpointBlockNumber) {
                 this.log.warn(`Local chain for slot ${slot} ends at block ${lastLocalBlockNumber} but checkpoint ends at ${lastCheckpointBlockNumber}. Pruning blocks after block ${lastCheckpointBlockNumber}.`);
                 const prunedBlocks = await this.removeBlocksAfter(lastCheckpointBlockNumber);
+                await this.evictProposedCheckpointsForPrunedBlocks(prunedBlocks);
                 return {
                     prunedBlocks,
                     lastAlreadyInsertedBlockNumber
@@ -161,27 +196,60 @@ import { computeContractAddressFromInstance, computeContractClassId } from '@azt
    * @returns The removed blocks.
    * @throws Error if any block to be removed is checkpointed.
    */ async removeUncheckpointedBlocksAfter(blockNumber) {
-        const result = await this.store.transactionAsync(async ()=>{
+        const result = await this.stores.db.transactionAsync(async ()=>{
             // Verify we're only removing uncheckpointed blocks
-            const lastCheckpointedBlockNumber = await this.store.getCheckpointedL2BlockNumber();
+            const lastCheckpointedBlockNumber = await this.stores.blocks.getCheckpointedL2BlockNumber();
             if (blockNumber < lastCheckpointedBlockNumber) {
                 throw new Error(`Cannot remove blocks after ${blockNumber} because checkpointed blocks exist up to ${lastCheckpointedBlockNumber}`);
             }
-            const result = await this.removeBlocksAfter(blockNumber);
-            await this.l2TipsCache?.refresh();
-            return result;
+            const prunedBlocks = await this.removeBlocksAfter(blockNumber);
+            await this.evictProposedCheckpointsForPrunedBlocks(prunedBlocks);
+            return prunedBlocks;
         });
+        await this.l2TipsCache?.refresh();
         return result;
     }
     /**
+   * Removes all blocks without a proposed checkpoint strictly after the specified block number and cleans up associated contract data.
+   * This handles removal of provisionally added blocks along with their contract classes/instances.
+   * Verifies that each block being removed is not part of a stored checkpoint (proposed or not).
+   * This differs from `removeUncheckpointedBlocksAfter` in that it also checks proposed checkpoints.
+   *
+   * @param blockNumber - Remove all blocks with number greater than this.
+   * @returns The removed blocks.
+   * @throws Error if any block to be removed is checkpointed.
+   */ async removeBlocksWithoutProposedCheckpointAfter(blockNumber) {
+        const result = await this.stores.db.transactionAsync(async ()=>{
+            // Verify we're only removing uncheckpointed blocks
+            const lastCheckpointedBlockNumber = await this.stores.blocks.getProposedCheckpointL2BlockNumber();
+            if (blockNumber < lastCheckpointedBlockNumber) {
+                throw new Error(`Cannot remove blocks after ${blockNumber} because proposed checkpointed blocks exist up to ${lastCheckpointedBlockNumber}`);
+            }
+            return await this.removeBlocksAfter(blockNumber);
+        });
+        await this.l2TipsCache?.refresh();
+        return result;
+    }
+    /**
+   * Evicts pending proposed checkpoints that referenced any of the just-pruned blocks. Pruned
+   * blocks invalidate all proposed checkpoints from the lowest pruned block's checkpoint number
+   * onwards: those checkpoints either reference the pruned blocks directly or chain off them.
+   */ async evictProposedCheckpointsForPrunedBlocks(prunedBlocks) {
+        if (prunedBlocks.length === 0) {
+            return;
+        }
+        const fromCheckpointNumber = prunedBlocks[0].checkpointNumber;
+        await this.stores.blocks.evictProposedCheckpointsFrom(fromCheckpointNumber);
+    }
+    /**
    * Removes all blocks strictly after the given block number along with any logs and contract data.
    * Does not remove their checkpoints.
    */ async removeBlocksAfter(blockNumber) {
         // First get the blocks to be removed so we can clean up contract data
-        const removedBlocks = await this.store.removeBlocksAfter(blockNumber);
+        const removedBlocks = await this.stores.blocks.removeBlocksAfter(blockNumber);
         // Clean up contract data and logs for the removed blocks
         await Promise.all([
-            this.store.deleteLogs(removedBlocks),
+            this.stores.logs.deleteLogs(removedBlocks),
             ...removedBlocks.map((block)=>this.removeContractDataFromDb(block))
         ]);
         return removedBlocks;
@@ -195,38 +263,39 @@ import { computeContractAddressFromInstance, computeContractClassId } from '@azt
    * @param checkpointNumber - Remove all checkpoints strictly after this one.
    * @returns True if the operation is successful.
    */ async removeCheckpointsAfter(checkpointNumber) {
-        return await this.store.transactionAsync(async ()=>{
-            const { blocksRemoved = [] } = await this.store.removeCheckpointsAfter(checkpointNumber);
+        const result = await this.stores.db.transactionAsync(async ()=>{
+            const { blocksRemoved = [] } = await this.stores.blocks.removeCheckpointsAfter(checkpointNumber);
             const opResults = await Promise.all([
                 // Prune rolls back to the last proven block, which is by definition valid
-                this.store.setPendingChainValidationStatus({
+                this.stores.blocks.setPendingChainValidationStatus({
                     valid: true
                 }),
                 // Remove contract data for all blocks being removed
                 ...blocksRemoved.map((block)=>this.removeContractDataFromDb(block)),
-                this.store.deleteLogs(blocksRemoved)
+                this.stores.logs.deleteLogs(blocksRemoved)
             ]);
-            await this.l2TipsCache?.refresh();
             return opResults.every(Boolean);
         });
+        await this.l2TipsCache?.refresh();
+        return result;
     }
     /**
    * Updates the proven checkpoint number and refreshes the L2 tips cache.
    * @param checkpointNumber - The checkpoint number to set as proven.
    */ async setProvenCheckpointNumber(checkpointNumber) {
-        await this.store.transactionAsync(async ()=>{
-            await this.store.setProvenCheckpointNumber(checkpointNumber);
-            await this.l2TipsCache?.refresh();
+        await this.stores.db.transactionAsync(async ()=>{
+            await this.stores.blocks.setProvenCheckpointNumber(checkpointNumber);
         });
+        await this.l2TipsCache?.refresh();
     }
     /**
    * Updates the finalized checkpoint number and refreshes the L2 tips cache.
    * @param checkpointNumber - The checkpoint number to set as finalized.
    */ async setFinalizedCheckpointNumber(checkpointNumber) {
-        await this.store.transactionAsync(async ()=>{
-            await this.store.setFinalizedCheckpointNumber(checkpointNumber);
-            await this.l2TipsCache?.refresh();
+        await this.stores.db.transactionAsync(async ()=>{
+            await this.stores.blocks.setFinalizedCheckpointNumber(checkpointNumber);
         });
+        await this.l2TipsCache?.refresh();
     }
     /** Extracts and stores contract data from a single block. */ addContractDataToDb(block) {
         return this.updateContractDataOnDb(block, 0);
@@ -252,7 +321,7 @@ import { computeContractAddressFromInstance, computeContractClassId } from '@azt
             const contractClasses = contractClassPublishedEvents.map((e)=>e.toContractClassPublic());
             if (contractClasses.length > 0) {
                 contractClasses.forEach((c)=>this.log.verbose(`${Operation[operation]} contract class ${c.id.toString()}`));
-                return await this.store.deleteContractClasses(contractClasses, blockNum);
+                return await this.stores.contractClasses.deleteContractClasses(contractClasses, blockNum);
             }
             return true;
         }
@@ -276,7 +345,7 @@ import { computeContractAddressFromInstance, computeContractClassId } from '@azt
         }
         if (contractClasses.length > 0) {
             contractClasses.forEach((c)=>this.log.verbose(`${Operation[operation]} contract class ${c.id.toString()}`));
-            return await this.store.addContractClasses(contractClasses, blockNum);
+            return await this.stores.contractClasses.addContractClasses(contractClasses, blockNum);
         }
         return true;
     }
@@ -300,9 +369,9 @@ import { computeContractAddressFromInstance, computeContractClassId } from '@azt
         if (contractInstances.length > 0) {
             contractInstances.forEach((c)=>this.log.verbose(`${Operation[operation]} contract instance at ${c.address.toString()}`));
             if (operation == 0) {
-                return await this.store.addContractInstances(contractInstances, blockNum);
+                return await this.stores.contractInstances.addContractInstances(contractInstances, blockNum);
             } else if (operation == 1) {
-                return await this.store.deleteContractInstances(contractInstances, blockNum);
+                return await this.stores.contractInstances.deleteContractInstances(contractInstances);
             }
         }
         return true;
@@ -314,9 +383,9 @@ import { computeContractAddressFromInstance, computeContractClassId } from '@azt
         if (contractUpdates.length > 0) {
             contractUpdates.forEach((c)=>this.log.verbose(`${Operation[operation]} contract instance update at ${c.address.toString()}`));
             if (operation == 0) {
-                return await this.store.addContractInstanceUpdates(contractUpdates, timestamp);
+                return await this.stores.contractInstances.addContractInstanceUpdates(contractUpdates, timestamp);
             } else if (operation == 1) {
-                return await this.store.deleteContractInstanceUpdates(contractUpdates, timestamp);
+                return await this.stores.contractInstances.deleteContractInstanceUpdates(contractUpdates, timestamp);
             }
         }
         return true;

package/dest/modules/instrumentation.d.ts

@@ -16,6 +16,7 @@ export declare class ArchiverInstrumentation {
     private pruneDuration;
     private pruneCount;
     private syncDurationPerBlock;
+    private syncDurationPerCheckpoint;
     private syncBlockCount;
     private manaPerBlock;
     private txsPerBlock;
@@ -23,13 +24,23 @@ export declare class ArchiverInstrumentation {
     private syncMessageCount;
     private blockProposalTxTargetCount;
     private checkpointL1InclusionDelay;
+    private checkpointPromotedCount;
     private log;
     private constructor();
     static new(telemetry: TelemetryClient, lmdbStats?: LmdbStatsCallback): Promise<ArchiverInstrumentation>;
     isEnabled(): boolean;
-    processNewBlocks(syncTimePerBlock: number, blocks: L2Block[]): void;
+    processNewProposedBlock(syncTimePerBlock: number, block: L2Block): void;
+    processNewCheckpointedBlocks(syncTimePerCheckpoint: number, blocks: L2Block[]): void;
     processNewMessages(count: number, syncPerMessageMs: number): void;
     processPrune(duration: number): void;
+    /**
+     * Records a pending-chain reorg, where the archiver dropped proposed blocks (and world-state follows by pruning). The
+     * type distinguishes the cause: 'uncheckpointed' (slot ended without a checkpoint), 'l1_conflict' (proposed blocks
+     * conflicting with an L1 checkpoint), 'orphan' (no matching proposed checkpoint arrived before the deadline), or
+     * 'l1_mismatch' (the local checkpointed tip diverged from L1 — an L1 reorg or a pruned/missed-proof checkpoint — so
+     * already-checkpointed blocks were rewound).
+     */
+    recordPrune(pruneType: 'uncheckpointed' | 'l1_conflict' | 'orphan' | 'l1_mismatch'): void;
     updateLastProvenCheckpoint(checkpoint: CheckpointData): void;
     processProofsVerified(logs: {
         proverId: string;
@@ -38,6 +49,8 @@ export declare class ArchiverInstrumentation {
     }[]): void;
     updateL1BlockHeight(blockNumber: bigint): void;
     recordBlockProposalTxTarget(target: string, usedTrace: boolean): void;
+    /** Records a checkpoint promoted from proposed (blob fetch skipped). */
+    processCheckpointPromoted(): void;
     /**
      * Records L1 inclusion timing for a checkpoint observed on L1 (seconds into the L2 slot).
      */
@@ -47,4 +60,4 @@ export declare class ArchiverInstrumentation {
         l1Constants: Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>;
     }): void;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/modules/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAErE,OAAO,EAKL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EACpB,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,uBAAuB;IA6BhC,OAAO,CAAC,SAAS;IA5BnB,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,oBAAoB,CAAY;IACxC,OAAO,CAAC,oBAAoB,CAAgB;IAC5C,OAAO,CAAC,SAAS,CAAc;IAE/B,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,UAAU,CAAgB;IAElC,OAAO,CAAC,oBAAoB,CAAY;IACxC,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,YAAY,CAAY;IAChC,OAAO,CAAC,WAAW,CAAY;IAE/B,OAAO,CAAC,sBAAsB,CAAY;IAC1C,OAAO,CAAC,gBAAgB,CAAgB;IAExC,OAAO,CAAC,0BAA0B,CAAgB;IAElD,OAAO,CAAC,0BAA0B,CAAY;IAE9C,OAAO,CAAC,GAAG,CAA4C;IAEvD,OAAO,eAsDN;IAED,OAAoB,GAAG,CAAC,SAAS,EAAE,eAAe,EAAE,SAAS,CAAC,EAAE,iBAAiB,oCAMhF;IAEM,SAAS,IAAI,OAAO,CAE1B;IAEM,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAWlE;IAEM,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,QAMhE;IAEM,YAAY,CAAC,QAAQ,EAAE,MAAM,QAGnC;IAEM,0BAA0B,CAAC,UAAU,EAAE,cAAc,QAI3D;IAEM,qBAAqB,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,QAW9F;IAEM,mBAAmB,CAAC,WAAW,EAAE,MAAM,QAE7C;IAEM,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,QAKpE;IAED;;OAEG;IACI,yBAAyB,CAAC,IAAI,EAAE;QACrC,UAAU,EAAE,UAAU,CAAC;QACvB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,GAAG,cAAc,CAAC,CAAC;KACxE,GAAG,IAAI,CAIP;CACF"}
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/modules/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAErE,OAAO,EAKL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EACpB,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,uBAAuB;IA+BhC,OAAO,CAAC,SAAS;IA9BnB,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,oBAAoB,CAAY;IACxC,OAAO,CAAC,oBAAoB,CAAgB;IAC5C,OAAO,CAAC,SAAS,CAAc;IAE/B,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,UAAU,CAAgB;IAElC,OAAO,CAAC,oBAAoB,CAAY;IACxC,OAAO,CAAC,yBAAyB,CAAY;IAC7C,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,YAAY,CAAY;IAChC,OAAO,CAAC,WAAW,CAAY;IAE/B,OAAO,CAAC,sBAAsB,CAAY;IAC1C,OAAO,CAAC,gBAAgB,CAAgB;IAExC,OAAO,CAAC,0BAA0B,CAAgB;IAElD,OAAO,CAAC,0BAA0B,CAAY;IAC9C,OAAO,CAAC,uBAAuB,CAAgB;IAE/C,OAAO,CAAC,GAAG,CAA4C;IAEvD,OAAO,eA4DN;IAED,OAAoB,GAAG,CAAC,SAAS,EAAE,eAAe,EAAE,SAAS,CAAC,EAAE,iBAAiB,oCAMhF;IAEM,SAAS,IAAI,OAAO,CAE1B;IAEM,uBAAuB,CAAC,gBAAgB,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,QAStE;IAEM,4BAA4B,CAAC,qBAAqB,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QASnF;IAEM,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,QAMhE;IAEM,YAAY,CAAC,QAAQ,EAAE,MAAM,QAGnC;IAED;;;;;;OAMG;IACI,WAAW,CAAC,SAAS,EAAE,gBAAgB,GAAG,aAAa,GAAG,QAAQ,GAAG,aAAa,QAExF;IAEM,0BAA0B,CAAC,UAAU,EAAE,cAAc,QAI3D;IAEM,qBAAqB,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,QAW9F;IAEM,mBAAmB,CAAC,WAAW,EAAE,MAAM,QAE7C;IAEM,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,QAKpE;IAED,wEAAwE;IACjE,yBAAyB,SAE/B;IAED;;OAEG;IACI,yBAAyB,CAAC,IAAI,EAAE;QACrC,UAAU,EAAE,UAAU,CAAC;QACvB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,GAAG,cAAc,CAAC,CAAC;KACxE,GAAG,IAAI,CAIP;CACF"}

package/dest/modules/instrumentation.js

@@ -14,6 +14,7 @@ export class ArchiverInstrumentation {
     pruneDuration;
     pruneCount;
     syncDurationPerBlock;
+    syncDurationPerCheckpoint;
     syncBlockCount;
     manaPerBlock;
     txsPerBlock;
@@ -21,6 +22,7 @@ export class ArchiverInstrumentation {
     syncMessageCount;
     blockProposalTxTargetCount;
     checkpointL1InclusionDelay;
+    checkpointPromotedCount;
     log;
     constructor(telemetry, lmdbStats){
         this.telemetry = telemetry;
@@ -39,13 +41,22 @@ export class ArchiverInstrumentation {
         });
         this.proofsSubmittedDelay = meter.createHistogram(Metrics.ARCHIVER_ROLLUP_PROOF_DELAY);
         this.syncDurationPerBlock = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_BLOCK);
+        this.syncDurationPerCheckpoint = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_CHECKPOINT);
         this.syncBlockCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_SYNC_BLOCK_COUNT);
         this.manaPerBlock = meter.createHistogram(Metrics.ARCHIVER_MANA_PER_BLOCK);
         this.txsPerBlock = meter.createHistogram(Metrics.ARCHIVER_TXS_PER_BLOCK);
         this.syncDurationPerMessage = meter.createHistogram(Metrics.ARCHIVER_SYNC_PER_MESSAGE);
         this.syncMessageCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_SYNC_MESSAGE_COUNT);
         this.pruneDuration = meter.createHistogram(Metrics.ARCHIVER_PRUNE_DURATION);
-        this.pruneCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_PRUNE_COUNT);
+        this.pruneCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_PRUNE_COUNT, {
+            [Attributes.PRUNE_TYPE]: [
+                'unproven',
+                'uncheckpointed',
+                'l1_conflict',
+                'orphan',
+                'l1_mismatch'
+            ]
+        });
         this.blockProposalTxTargetCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_BLOCK_PROPOSAL_TX_TARGET_COUNT, {
             [Attributes.L1_BLOCK_PROPOSAL_USED_TRACE]: [
                 true,
@@ -53,6 +64,7 @@ export class ArchiverInstrumentation {
             ]
         });
         this.checkpointL1InclusionDelay = meter.createHistogram(Metrics.ARCHIVER_CHECKPOINT_L1_INCLUSION_DELAY);
+        this.checkpointPromotedCount = createUpDownCounterWithDefault(meter, Metrics.ARCHIVER_CHECKPOINT_PROMOTED_COUNT);
         this.dbMetrics = new LmdbMetrics(meter, {
             [Attributes.DB_DATA_TYPE]: 'archiver'
         }, lmdbStats);
@@ -65,16 +77,27 @@ export class ArchiverInstrumentation {
     isEnabled() {
         return this.telemetry.isEnabled();
     }
-    processNewBlocks(syncTimePerBlock, blocks) {
+    processNewProposedBlock(syncTimePerBlock, block) {
+        const attrs = {
+            [Attributes.STATUS]: 'proposed'
+        };
+        this.blockHeight.record(block.number, attrs);
         this.syncDurationPerBlock.record(Math.ceil(syncTimePerBlock));
-        this.blockHeight.record(Math.max(...blocks.map((b)=>b.number)));
+        // Per block metrics
+        this.txCount.add(block.body.txEffects.length);
+        this.txsPerBlock.record(block.body.txEffects.length);
+        this.manaPerBlock.record(block.header.totalManaUsed.toNumber() / 1e6);
+    }
+    processNewCheckpointedBlocks(syncTimePerCheckpoint, blocks) {
+        if (blocks.length === 0) {
+            return;
+        }
+        this.syncDurationPerCheckpoint.record(Math.ceil(syncTimePerCheckpoint));
+        this.blockHeight.record(Math.max(...blocks.map((b)=>b.number)), {
+            [Attributes.STATUS]: 'checkpointed'
+        });
         this.checkpointHeight.record(Math.max(...blocks.map((b)=>b.checkpointNumber)));
         this.syncBlockCount.add(blocks.length);
-        for (const block of blocks){
-            this.txCount.add(block.body.txEffects.length);
-            this.txsPerBlock.record(block.body.txEffects.length);
-            this.manaPerBlock.record(block.header.totalManaUsed.toNumber() / 1e6);
-        }
     }
     processNewMessages(count, syncPerMessageMs) {
         if (count === 0) {
@@ -84,9 +107,22 @@ export class ArchiverInstrumentation {
         this.syncDurationPerMessage.record(Math.ceil(syncPerMessageMs));
     }
     processPrune(duration) {
-        this.pruneCount.add(1);
+        this.pruneCount.add(1, {
+            [Attributes.PRUNE_TYPE]: 'unproven'
+        });
         this.pruneDuration.record(Math.ceil(duration));
     }
+    /**
+   * Records a pending-chain reorg, where the archiver dropped proposed blocks (and world-state follows by pruning). The
+   * type distinguishes the cause: 'uncheckpointed' (slot ended without a checkpoint), 'l1_conflict' (proposed blocks
+   * conflicting with an L1 checkpoint), 'orphan' (no matching proposed checkpoint arrived before the deadline), or
+   * 'l1_mismatch' (the local checkpointed tip diverged from L1 — an L1 reorg or a pruned/missed-proof checkpoint — so
+   * already-checkpointed blocks were rewound).
+   */ recordPrune(pruneType) {
+        this.pruneCount.add(1, {
+            [Attributes.PRUNE_TYPE]: pruneType
+        });
+    }
     updateLastProvenCheckpoint(checkpoint) {
         const lastBlockNumberInCheckpoint = checkpoint.startBlock + checkpoint.blockCount - 1;
         this.blockHeight.record(lastBlockNumberInCheckpoint, {
@@ -117,6 +153,9 @@ export class ArchiverInstrumentation {
             [Attributes.L1_BLOCK_PROPOSAL_USED_TRACE]: usedTrace
         });
     }
+    /** Records a checkpoint promoted from proposed (blob fetch skipped). */ processCheckpointPromoted() {
+        this.checkpointPromotedCount.add(1);
+    }
     /**
    * Records L1 inclusion timing for a checkpoint observed on L1 (seconds into the L2 slot).
    */ processCheckpointL1Timing(data) {

package/dest/modules/l1_synchronizer.d.ts

@@ -6,22 +6,22 @@ import { Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
-import { type ArchiverEmitter } from '@aztec/stdlib/block';
+import { type ArchiverEmitter, type L2Block } from '@aztec/stdlib/block';
 import { type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { type Traceable, type Tracer } from '@aztec/telemetry-client';
-import type { KVArchiverDataStore } from '../store/kv_archiver_store.js';
+import { type ArchiverDataStores } from '../store/data_stores.js';
 import type { L2TipsCache } from '../store/l2_tips_cache.js';
 import type { ArchiverInstrumentation } from './instrumentation.js';
 /**
  * Handles L1 synchronization for the archiver.
- * Responsible for fetching checkpoints, L1→L2 messages, and handling L1 reorgs.
+ * Responsible for fetching checkpoints, L1 to L2 messages, and handling L1 reorgs.
  */
 export declare class ArchiverL1Synchronizer implements Traceable {
     private readonly publicClient;
     private readonly debugClient;
     private readonly rollup;
     private readonly inbox;
-    private readonly store;
+    private readonly stores;
     private config;
     private readonly blobClient;
     private readonly epochCache;
@@ -35,9 +35,10 @@ export declare class ArchiverL1Synchronizer implements Traceable {
     private l1Timestamp;
     private readonly updater;
     readonly tracer: Tracer;
-    constructor(publicClient: ViemPublicClient, debugClient: ViemPublicDebugClient, rollup: RollupContract, inbox: InboxContract, store: KVArchiverDataStore, config: {
+    constructor(publicClient: ViemPublicClient, debugClient: ViemPublicDebugClient, rollup: RollupContract, inbox: InboxContract, stores: ArchiverDataStores, config: {
         batchSize: number;
         skipValidateCheckpointAttestations?: boolean;
+        skipPromoteProposedCheckpointDuringL1Sync?: boolean;
         maxAllowedEthClientDriftSeconds: number;
     }, blobClient: BlobClientInterface, epochCache: EpochCache, dateProvider: DateProvider, instrumentation: ArchiverInstrumentation, l1Constants: L1RollupConstants & {
         l1StartBlockHash: Buffer32;
@@ -47,26 +48,30 @@ export declare class ArchiverL1Synchronizer implements Traceable {
     setConfig(newConfig: {
         batchSize: number;
         skipValidateCheckpointAttestations?: boolean;
+        skipPromoteProposedCheckpointDuringL1Sync?: boolean;
         maxAllowedEthClientDriftSeconds: number;
     }): void;
     /** Returns the last L1 block number that was synced. */
     getL1BlockNumber(): bigint | undefined;
     /** Returns the last L1 timestamp that was synced. */
     getL1Timestamp(): bigint | undefined;
+    private getSignatureContext;
     /** 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>;
+    syncFromL1(initialSyncComplete: boolean): Promise<L2Block[]>;
     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 tryBuildPublishedCheckpointFromProposed;
     private checkForNewCheckpointsBeforeL1SyncPoint;
     private getCheckpointHeader;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDFfc3luY2hyb25pemVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbW9kdWxlcy9sMV9zeW5jaHJvbml6ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNyRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDaEQsT0FBTyxFQUFFLGFBQWEsRUFBMkIsY0FBYyxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFHbkcsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUlyRixPQUFPLEVBQVksUUFBUSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFOUQsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXBELE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUdsRSxPQUFPLEVBQUUsWUFBWSxFQUFrQixNQUFNLHlCQUF5QixDQUFDO0FBRXZFLE9BQU8sRUFDTCxLQUFLLGVBQWUsRUFDcEIsS0FBSyxPQUFPLEVBR2IsTUFBTSxxQkFBcUIsQ0FBQztBQVE3QixPQUFPLEVBQUUsS0FBSyxpQkFBaUIsRUFBd0MsTUFBTSw2QkFBNkIsQ0FBQztBQUczRyxPQUFPLEVBQUUsS0FBSyxTQUFTLEVBQUUsS0FBSyxNQUFNLEVBQXlCLE1BQU0seUJBQXlCLENBQUM7QUFZN0YsT0FBTyxFQUFFLEtBQUssa0JBQWtCLEVBQXlCLE1BQU0seUJBQXlCLENBQUM7QUFDekYsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFJN0QsT0FBTyxLQUFLLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQWlCcEU7OztHQUdHO0FBQ0gscUJBQWEsc0JBQXVCLFlBQVcsU0FBUztJQVNwRCxPQUFPLENBQUMsUUFBUSxDQUFDLFlBQVk7SUFDN0IsT0FBTyxDQUFDLFFBQVEsQ0FBQyxXQUFXO0lBQzVCLE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTTtJQUN2QixPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUs7SUFDdEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNO0lBQ3ZCLE9BQU8sQ0FBQyxNQUFNO0lBTWQsT0FBTyxDQUFDLFFBQVEsQ0FBQyxVQUFVO0lBQzNCLE9BQU8sQ0FBQyxRQUFRLENBQUMsVUFBVTtJQUMzQixPQUFPLENBQUMsUUFBUSxDQUFDLFlBQVk7SUFDN0IsT0FBTyxDQUFDLFFBQVEsQ0FBQyxlQUFlO0lBQ2hDLE9BQU8sQ0FBQyxRQUFRLENBQUMsV0FBVztJQUk1QixPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU07SUFHdkIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHO0lBOUJ0QixPQUFPLENBQUMsYUFBYSxDQUFxQjtJQUMxQyxPQUFPLENBQUMsV0FBVyxDQUF1QjtJQUMxQyxPQUFPLENBQUMsV0FBVyxDQUFxQjtJQUV4QyxPQUFPLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBMkI7SUFDbkQsU0FBZ0IsTUFBTSxFQUFFLE1BQU0sQ0FBQztJQUUvQixZQUNtQixZQUFZLEVBQUUsZ0JBQWdCLEVBQzlCLFdBQVcsRUFBRSxxQkFBcUIsRUFDbEMsTUFBTSxFQUFFLGNBQWMsRUFDdEIsS0FBSyxFQUFFLGFBQWEsRUFDcEIsTUFBTSxFQUFFLGtCQUFrQixFQUNuQyxNQUFNLEVBQUU7UUFDZCxTQUFTLEVBQUUsTUFBTSxDQUFDO1FBQ2xCLGtDQUFrQyxDQUFDLEVBQUUsT0FBTyxDQUFDO1FBQzdDLHlDQUF5QyxDQUFDLEVBQUUsT0FBTyxDQUFDO1FBQ3BELCtCQUErQixFQUFFLE1BQU0sQ0FBQztLQUN6QyxFQUNnQixVQUFVLEVBQUUsbUJBQW1CLEVBQy9CLFVBQVUsRUFBRSxVQUFVLEVBQ3RCLFlBQVksRUFBRSxZQUFZLEVBQzFCLGVBQWUsRUFBRSx1QkFBdUIsRUFDeEMsV0FBVyxFQUFFLGlCQUFpQixHQUFHO1FBQ2hELGdCQUFnQixFQUFFLFFBQVEsQ0FBQztRQUMzQixrQkFBa0IsRUFBRSxFQUFFLENBQUM7S0FDeEIsRUFDZ0IsTUFBTSxFQUFFLGVBQWUsRUFDeEMsTUFBTSxFQUFFLE1BQU0sRUFDZCxXQUFXLENBQUMsRUFBRSxXQUFXLEVBQ1IsR0FBRyxHQUFFLE1BQXlDLEVBTWhFO0lBRUQsc0JBQXNCO0lBQ2YsU0FBUyxDQUFDLFNBQVMsRUFBRTtRQUMxQixTQUFTLEVBQUUsTUFBTSxDQUFDO1FBQ2xCLGtDQUFrQyxDQUFDLEVBQUUsT0FBTyxDQUFDO1FBQzdDLHlDQUF5QyxDQUFDLEVBQUUsT0FBTyxDQUFDO1FBQ3BELCtCQUErQixFQUFFLE1BQU0sQ0FBQztLQUN6QyxRQUVBO0lBRUQsd0RBQXdEO0lBQ2pELGdCQUFnQixJQUFJLE1BQU0sR0FBRyxTQUFTLENBRTVDO0lBRUQscURBQXFEO0lBQzlDLGNBQWMsSUFBSSxNQUFNLEdBQUcsU0FBUyxDQUUxQztJQUVELE9BQU8sQ0FBQyxtQkFBbUI7SUFPM0IsNkhBQTZIO0lBQ2hILHNCQUFzQixJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FZbkQ7SUFHWSxVQUFVLENBQUMsbUJBQW1CLEVBQUUsT0FBTyxHQUFHLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQWlHeEU7WUFHYSx5QkFBeUI7WUEyQnpCLHlCQUF5QjtZQTZDekIsUUFBUTtZQWVSLGdCQUFnQjtJQStEOUIsT0FBTyxDQUFDLFNBQVM7WUFXSCxvQkFBb0I7WUF3RXBCLGlCQUFpQjtZQVdqQix3QkFBd0I7WUFrQ3hCLHNCQUFzQjtZQTJGdEIsY0FBYztZQVNkLGlCQUFpQjtZQTZoQmpCLHVDQUF1QztZQW9GdkMsdUNBQXVDO1lBdUR2QyxtQkFBbUI7Q0FPbEMifQ==