chore: Persist validation status in archiver (#16869)

Adds the _pending chain validation status_ to the archiver store, so it
is persisted across node restarts. The pending chain validation status
is whether the last block seen in the pending chain is valid or not, as
in it having valid attestations or not.

Also, this PR fixes the condition in which it's updated: if a new block
with the same number and still invalid is detected, the validation
status is updated. This is tested in
#16836.

This PR also changes that shape of the validation result, so instead of
storing a full L2 block, we only store the identifiers and attestations
needed to invalidate it. It also adds serialization and static `random`
methods to some adjacent classes.

Author: spalladino

yarn-project/archiver/src/archiver/archiver.test.ts

@@ -415,7 +415,9 @@ describe('Archiver', () => {
       return [badBlock, badBlockRollupTx, badBlockBlobHashes, badBlockBlobs] as const;
     };
 
+    // We create two bad blocks with blocknumber 2, and one bad block with blocknumber 3
     const [badBlock2, badBlock2RollupTx, badBlock2BlobHashes, badBlock2Blobs] = await makeBadBlock(2);
+    const [badBlock2b, badBlock2bRollupTx, badBlock2bBlobHashes, badBlock2bBlobs] = await makeBadBlock(2);
     const [badBlock3, badBlock3RollupTx, badBlock3BlobHashes, badBlock3Blobs] = await makeBadBlock(3);
 
     // Return the archive root for the bad block 2 when L1 is queried
@@ -428,7 +430,7 @@ describe('Archiver', () => {
     logger.warn(`Created invalid block 3 with root ${badBlock3.archive.root.toString()}`);
 
     // During the first archiver loop, we fetch block 1 and the block 2 with bad attestations
-    publicClient.getBlockNumber.mockResolvedValue(85n);
+    publicClient.getBlockNumber.mockResolvedValue(82n);
     makeL2BlockProposedEvent(70n, 1n, blocks[0].archive.root.toString(), blobHashes[0]);
     makeL2BlockProposedEvent(80n, 2n, badBlock2.archive.root.toString(), badBlock2BlobHashes);
     mockRollup.read.status.mockResolvedValue([0n, GENESIS_ROOT, 2n, badBlock2.archive.root.toString(), GENESIS_ROOT]);
@@ -456,10 +458,33 @@ describe('Archiver', () => {
       }),
     );
 
+    // Another loop, where a proposer invalidates the invalid block 2, but proposes another invalid block 2 (2b)
+    logger.warn(`Adding new block 2 with bad attestations`);
+    publicClient.getBlockNumber.mockResolvedValue(85n);
+    makeL2BlockProposedEvent(85n, 2n, badBlock2b.archive.root.toString(), badBlock2bBlobHashes);
+    mockRollup.read.status.mockResolvedValue([
+      0n,
+      GENESIS_ROOT,
+      2n,
+      badBlock2b.archive.root.toString(),
+      blocks[0].archive.root.toString(),
+    ]);
+    publicClient.getTransaction.mockResolvedValueOnce(badBlock2bRollupTx);
+    blobSinkClient.getBlobSidecar.mockResolvedValueOnce(badBlock2bBlobs);
+
+    // Our chain validation status should be updated to point to the new bad block 2b
+    await archiver.syncImmediate();
+    latestBlockNum = await archiver.getBlockNumber();
+    expect(latestBlockNum).toEqual(1);
+    let validationStatus = await archiver.getPendingChainValidationStatus();
+    assert(!validationStatus.valid);
+    expect(validationStatus.block.blockNumber).toEqual(2);
+    expect(validationStatus.block.archive.toString()).toEqual(badBlock2b.archive.root.toString());
+
     // Now another loop, where we propose a block 3 with bad attestations
     logger.warn(`Adding new block 3 with bad attestations`);
     publicClient.getBlockNumber.mockResolvedValue(90n);
-    makeL2BlockProposedEvent(85n, 3n, badBlock3.archive.root.toString(), badBlock3BlobHashes);
+    makeL2BlockProposedEvent(88n, 3n, badBlock3.archive.root.toString(), badBlock3BlobHashes);
     mockRollup.read.status.mockResolvedValue([
       0n,
       GENESIS_ROOT,
@@ -475,10 +500,10 @@ describe('Archiver', () => {
     await archiver.syncImmediate();
     latestBlockNum = await archiver.getBlockNumber();
     expect(latestBlockNum).toEqual(1);
-    const validationStatus = await archiver.getPendingChainValidationStatus();
+    validationStatus = await archiver.getPendingChainValidationStatus();
     assert(!validationStatus.valid);
-    expect(validationStatus.block.block.number).toEqual(2);
-    expect(validationStatus.block.block.archive.root.toString()).toEqual(badBlock2.archive.root.toString());
+    expect(validationStatus.block.blockNumber).toEqual(2);
+    expect(validationStatus.block.archive.toString()).toEqual(badBlock2.archive.root.toString());
 
     // Check that InvalidBlockDetected event was also emitted for bad block 3
     expect(invalidBlockDetectedSpy).toHaveBeenCalledWith(

yarn-project/archiver/src/archiver/archiver.ts

@@ -120,7 +120,6 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
 
   private l1BlockNumber: bigint | undefined;
   private l1Timestamp: bigint | undefined;
-  private pendingChainValidationStatus: ValidateBlockResult = { valid: true };
   private initialSyncComplete: boolean = false;
 
   public readonly tracer: Tracer;
@@ -342,7 +341,8 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
 
     // ********** Events that are processed per L2 block **********
     if (currentL1BlockNumber > blocksSynchedTo) {
-      // First we retrieve new L2 blocks
+      // First we retrieve new L2 blocks and store them in the DB. This will also update the
+      // pending chain validation status, proven block number, and synched L1 block number.
       const rollupStatus = await this.handleL2blocks(blocksSynchedTo, currentL1BlockNumber);
       // Then we prune the current epoch if it'd reorg on next submission.
       // Note that we don't do this before retrieving L2 blocks because we may need to retrieve
@@ -355,21 +355,11 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
         currentL1Timestamp,
       );
 
-      // Update the pending chain validation status with the last block validation result.
-      // Again, we only update if validation status changed, so in a sequence of invalid blocks
-      // we keep track of the first invalid block so we can invalidate that one if needed.
-      if (
-        rollupStatus.validationResult &&
-        rollupStatus.validationResult?.valid !== this.pendingChainValidationStatus.valid
-      ) {
-        this.pendingChainValidationStatus = rollupStatus.validationResult;
-      }
-
       // And lastly we check if we are missing any L2 blocks behind us due to a possible L1 reorg.
       // We only do this if rollup cant prune on the next submission. Otherwise we will end up
       // re-syncing the blocks we have just unwound above. We also dont do this if the last block is invalid,
       // since the archiver will rightfully refuse to sync up to it.
-      if (!rollupCanPrune && this.pendingChainValidationStatus.valid) {
+      if (!rollupCanPrune && rollupStatus.validationResult?.valid) {
         await this.checkForNewBlocksBeforeL1SyncPoint(rollupStatus, blocksSynchedTo, currentL1BlockNumber);
       }
 
@@ -623,14 +613,15 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
 
   private async handleL2blocks(blocksSynchedTo: bigint, currentL1BlockNumber: bigint) {
     const localPendingBlockNumber = await this.getBlockNumber();
+    const initialValidationResult: ValidateBlockResult | undefined = await this.store.getPendingChainValidationStatus();
     const [provenBlockNumber, provenArchive, pendingBlockNumber, pendingArchive, archiveForLocalPendingBlockNumber] =
       await this.rollup.status(BigInt(localPendingBlockNumber), { blockNumber: currentL1BlockNumber });
     const rollupStatus = {
       provenBlockNumber: Number(provenBlockNumber),
       provenArchive,
       pendingBlockNumber: Number(pendingBlockNumber),
       pendingArchive,
-      validationResult: undefined as ValidateBlockResult | undefined,
+      validationResult: initialValidationResult,
     };
     this.log.trace(`Retrieved rollup status at current L1 block ${currentL1BlockNumber}.`, {
       localPendingBlockNumber,
@@ -809,7 +800,15 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
 
         // Only update the validation result if it has changed, so we can keep track of the first invalid block
         // in case there is a sequence of more than one invalid block, as we need to invalidate the first one.
-        if (rollupStatus.validationResult?.valid !== validationResult.valid) {
+        // There is an exception though: if an invalid block is invalidated and replaced with another invalid block,
+        // we need to update the validation result, since we need to be able to invalidate the new one.
+        // See test 'chain progresses if an invalid block is invalidated with an invalid one' for more info.
+        if (
+          rollupStatus.validationResult?.valid !== validationResult.valid ||
+          (!rollupStatus.validationResult.valid &&
+            !validationResult.valid &&
+            rollupStatus.validationResult.block.blockNumber === validationResult.block.blockNumber)
+        ) {
           rollupStatus.validationResult = validationResult;
         }
 
@@ -828,6 +827,7 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
 
           // We keep consuming blocks if we find an invalid one, since we do not listen for BlockInvalidated events
           // We just pretend the invalid ones are not there and keep consuming the next blocks
+          // Note that this breaks if the committee ever attests to a descendant of an invalid block
           continue;
         }
 
@@ -841,7 +841,9 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
       }
 
       try {
-        const [processDuration] = await elapsed(() => this.store.addBlocks(validBlocks));
+        const updatedValidationResult =
+          rollupStatus.validationResult === initialValidationResult ? undefined : rollupStatus.validationResult;
+        const [processDuration] = await elapsed(() => this.store.addBlocks(validBlocks, updatedValidationResult));
         this.instrumentation.processNewBlocks(
           processDuration / validBlocks.length,
           validBlocks.map(b => b.block),
@@ -1228,12 +1230,12 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
     return this.store.getDebugFunctionName(address, selector);
   }
 
-  getPendingChainValidationStatus(): Promise<ValidateBlockResult> {
-    return Promise.resolve(this.pendingChainValidationStatus);
+  async getPendingChainValidationStatus(): Promise<ValidateBlockResult> {
+    return (await this.store.getPendingChainValidationStatus()) ?? { valid: true };
   }
 
   isPendingChainInvalid(): Promise<boolean> {
-    return Promise.resolve(this.pendingChainValidationStatus.valid === false);
+    return this.getPendingChainValidationStatus().then(status => !status.valid);
   }
 
   async getL2Tips(): Promise<L2Tips> {
@@ -1351,6 +1353,7 @@ export class ArchiverStoreHelper
       | 'backupTo'
       | 'close'
       | 'transactionAsync'
+      | 'addBlocks'
     >
 {
   #log = createLogger('archiver:block-helper');
@@ -1493,13 +1496,16 @@ export class ArchiverStoreHelper
     return true;
   }
 
-  public addBlocks(blocks: PublishedL2Block[]): Promise<boolean> {
+  public addBlocks(blocks: PublishedL2Block[], pendingChainValidationStatus?: ValidateBlockResult): Promise<boolean> {
     // Add the blocks to the store. Store will throw if the blocks are not in order, there are gaps,
     // or if the previous block is not in the store.
     return this.store.transactionAsync(async () => {
       await this.store.addBlocks(blocks);
 
       const opResults = await Promise.all([
+        // Update the pending chain validation status if provided
+        pendingChainValidationStatus && this.store.setPendingChainValidationStatus(pendingChainValidationStatus),
+        // Add any logs emitted during the retrieved blocks
         this.store.addLogs(blocks.map(block => block.block)),
         // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
         ...blocks.map(async block => {
@@ -1539,6 +1545,8 @@ export class ArchiverStoreHelper
     const blocks = await this.getPublishedBlocks(from - blocksToUnwind + 1, blocksToUnwind);
 
     const opResults = await Promise.all([
+      // Prune rolls back to the last proven block, which is by definition valid
+      this.store.setPendingChainValidationStatus({ valid: true }),
       // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
       ...blocks.map(async block => {
         const contractClassLogs = block.block.body.txEffects.flatMap(txEffect => txEffect.contractClassLogs);
@@ -1656,4 +1664,11 @@ export class ArchiverStoreHelper
   getLastL1ToL2Message(): Promise<InboxMessage | undefined> {
     return this.store.getLastL1ToL2Message();
   }
+  getPendingChainValidationStatus(): Promise<ValidateBlockResult | undefined> {
+    return this.store.getPendingChainValidationStatus();
+  }
+  setPendingChainValidationStatus(status: ValidateBlockResult | undefined): Promise<void> {
+    this.#log.debug(`Setting pending chain validation status to valid ${status?.valid}`, status);
+    return this.store.setPendingChainValidationStatus(status);
+  }
 }

yarn-project/archiver/src/archiver/archiver_store.ts

@@ -3,7 +3,7 @@ import type { Fr } from '@aztec/foundation/fields';
 import type { CustomRange } from '@aztec/kv-store';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2Block } from '@aztec/stdlib/block';
+import type { L2Block, ValidateBlockResult } from '@aztec/stdlib/block';
 import type {
   ContractClassPublic,
   ContractInstanceUpdateWithAddress,
@@ -272,4 +272,10 @@ export interface ArchiverDataStore {
 
   /** Returns the last L1 to L2 message stored. */
   getLastL1ToL2Message(): Promise<InboxMessage | undefined>;
+
+  /** Returns the last synced validation status of the pending chain. */
+  getPendingChainValidationStatus(): Promise<ValidateBlockResult | undefined>;
+
+  /** Sets the last synced validation status of the pending chain. */
+  setPendingChainValidationStatus(status: ValidateBlockResult | undefined): Promise<void>;
 }