feat: Proposer invalidates previous block if needed

If the previous pending block on L1 has invalid attestations, the
proposer for the next slot invalidates it as part of its multicall.

Next step is for the prover to invalidate the last block in the epoch it
wants to prove.

Author: spalladino

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

@@ -10,6 +10,7 @@ import {
 } from '@aztec/ethereum';
 import { maxBigint } from '@aztec/foundation/bigint';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { pick } from '@aztec/foundation/collection';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
@@ -87,7 +88,7 @@ import { InitialBlockNumberNotSequentialError, NoBlobBodiesFoundError } from './
 import { ArchiverInstrumentation } from './instrumentation.js';
 import type { InboxMessage } from './structs/inbox_message.js';
 import type { PublishedL2Block } from './structs/published.js';
-import { validateBlockAttestations } from './validation.js';
+import { type ValidateBlockResult, validateBlockAttestations } from './validation.js';
 
 /**
  * Helper interface to combine all sources this archiver implementation provides.
@@ -119,6 +120,7 @@ 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;
@@ -356,10 +358,11 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
       // 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 && !rollupStatus.lastBlockIsInvalid) {
+      if (!rollupCanPrune && !rollupStatus.lastBlockValidationResult.valid) {
         await this.checkForNewBlocksBeforeL1SyncPoint(rollupStatus, blocksSynchedTo, currentL1BlockNumber);
       }
 
+      this.pendingChainValidationStatus = rollupStatus.lastBlockValidationResult;
       this.instrumentation.updateL1BlockHeight(currentL1BlockNumber);
     }
 
@@ -617,7 +620,7 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
       provenArchive,
       pendingBlockNumber: Number(pendingBlockNumber),
       pendingArchive,
-      lastBlockIsInvalid: false,
+      lastBlockValidationResult: { valid: true } as ValidateBlockResult,
     };
     this.log.trace(`Retrieved rollup status at current L1 block ${currentL1BlockNumber}.`, {
       localPendingBlockNumber,
@@ -793,16 +796,19 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
 
       for (const block of publishedBlocks) {
         const isProven = block.block.number <= provenBlockNumber;
-        if (!isProven && !(await validateBlockAttestations(block, this.epochCache, this.l1constants, this.log))) {
+        rollupStatus.lastBlockValidationResult = isProven
+          ? { valid: true }
+          : await validateBlockAttestations(block, this.epochCache, this.l1constants, this.log);
+
+        if (!rollupStatus.lastBlockValidationResult.valid) {
           this.log.warn(`Skipping block ${block.block.number} due to invalid attestations`, {
             blockHash: block.block.hash(),
             l1BlockNumber: block.l1.blockNumber,
+            ...pick(rollupStatus.lastBlockValidationResult, 'reason'),
           });
-          rollupStatus.lastBlockIsInvalid = true;
           continue;
         }
 
-        rollupStatus.lastBlockIsInvalid = false;
         validBlocks.push(block);
         this.log.debug(`Ingesting new L2 block ${block.block.number} with ${block.block.body.txEffects.length} txs`, {
           blockHash: block.block.hash(),
@@ -1200,6 +1206,14 @@ export class Archiver extends (EventEmitter as new () => ArchiverEmitter) implem
     return this.store.getDebugFunctionName(address, selector);
   }
 
+  getPendingChainValidationStatus(): Promise<ValidateBlockResult> {
+    return Promise.resolve(this.pendingChainValidationStatus);
+  }
+
+  isPendingChainInvalid(): Promise<boolean> {
+    return Promise.resolve(this.pendingChainValidationStatus.valid === false);
+  }
+
   async getL2Tips(): Promise<L2Tips> {
     const [latestBlockNumber, provenBlockNumber] = await Promise.all([
       this.getBlockNumber(),

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

@@ -45,15 +45,17 @@ describe('validateBlockAttestations', () => {
       const block = await makeBlock([], []);
       const result = await validateBlockAttestations(block, epochCache, constants, logger);
 
-      expect(result).toBe(true);
+      expect(result.valid).toBe(true);
+      expect(result.block).toBe(block);
       expect(epochCache.getCommitteeForEpoch).toHaveBeenCalledWith(0n);
     });
 
     it('validates a block with no attestations if no committee is found', async () => {
       const block = await makeBlock(signers, committee);
       const result = await validateBlockAttestations(block, epochCache, constants, logger);
 
-      expect(result).toBe(true);
+      expect(result.valid).toBe(true);
+      expect(result.block).toBe(block);
       expect(epochCache.getCommitteeForEpoch).toHaveBeenCalledWith(0n);
     });
   });
@@ -73,19 +75,33 @@ describe('validateBlockAttestations', () => {
       const badSigner = Secp256k1Signer.random();
       const block = await makeBlock([...signers, badSigner], [...committee, badSigner.address]);
       const result = await validateBlockAttestations(block, epochCache, constants, logger);
-      expect(result).toBe(false);
+      expect(result.valid).toBe(false);
+      if (!result.valid) {
+        expect(result.reason).toBe('invalid-attestation');
+        expect(result.block).toBe(block);
+        expect(result.committee).toEqual(committee);
+        if (result.reason === 'invalid-attestation') {
+          expect(result.invalidIndex).toBe(5); // The bad signer is at index 5
+        }
+      }
     });
 
     it('returns false if insufficient attestations', async () => {
       const block = await makeBlock(signers.slice(0, 2), committee);
       const result = await validateBlockAttestations(block, epochCache, constants, logger);
-      expect(result).toBe(false);
+      expect(result.valid).toBe(false);
+      if (!result.valid) {
+        expect(result.reason).toBe('insufficient-attestations');
+        expect(result.block).toBe(block);
+        expect(result.committee).toEqual(committee);
+      }
     });
 
     it('returns true if all attestations are valid and sufficient', async () => {
       const block = await makeBlock(signers.slice(0, 4), committee);
       const result = await validateBlockAttestations(block, epochCache, constants, logger);
-      expect(result).toBe(true);
+      expect(result.valid).toBe(true);
+      expect(result.block).toBe(block);
     });
   });
 });

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

@@ -1,18 +1,24 @@
 import type { EpochCache } from '@aztec/epoch-cache';
 import type { Logger } from '@aztec/foundation/log';
-import { type PublishedL2Block, getAttestationsFromPublishedL2Block } from '@aztec/stdlib/block';
+import {
+  type PublishedL2Block,
+  type ValidateBlockResult,
+  getAttestationsFromPublishedL2Block,
+} from '@aztec/stdlib/block';
 import { type L1RollupConstants, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 
+export type { ValidateBlockResult };
+
 /**
  * Validates the attestations submitted for the given block.
  * Returns true if the attestations are valid and sufficient, false otherwise.
  */
 export async function validateBlockAttestations(
-  publishedBlock: Pick<PublishedL2Block, 'attestations' | 'block'>,
+  publishedBlock: PublishedL2Block,
   epochCache: EpochCache,
   constants: Pick<L1RollupConstants, 'epochDuration'>,
   logger?: Logger,
-): Promise<boolean> {
+): Promise<ValidateBlockResult> {
   const attestations = getAttestationsFromPublishedL2Block(publishedBlock);
   const { block } = publishedBlock;
   const blockHash = await block.hash().then(hash => hash.toString());
@@ -33,17 +39,18 @@ export async function validateBlockAttestations(
   if (!committee || committee.length === 0) {
     // Q: Should we accept blocks with no committee?
     logger?.warn(`No committee found for epoch ${epoch} at slot ${slot}. Accepting block without validation.`, logData);
-    return true;
+    return { valid: true, block: publishedBlock };
   }
 
   const committeeSet = new Set(committee.map(member => member.toString()));
   const requiredAttestationCount = Math.floor((committee.length * 2) / 3) + 1;
 
-  for (const attestation of attestations) {
+  for (let i = 0; i < attestations.length; i++) {
+    const attestation = attestations[i];
     const signer = attestation.getSender().toString();
     if (!committeeSet.has(signer)) {
       logger?.warn(`Attestation from non-committee member ${signer} at slot ${slot}`, { committee });
-      return false;
+      return { valid: false, reason: 'invalid-attestation', invalidIndex: i, block: publishedBlock, committee };
     }
   }
 
@@ -53,9 +60,9 @@ export async function validateBlockAttestations(
       actualAttestations: attestations.length,
       ...logData,
     });
-    return false;
+    return { valid: false, reason: 'insufficient-attestations', block: publishedBlock, committee };
   }
 
   logger?.debug(`Block attestations validated successfully for block ${block.number} at slot ${slot}`, logData);
-  return true;
+  return { valid: true, block: publishedBlock };
 }

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

@@ -5,7 +5,7 @@ import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { L2Block, L2BlockHash, type L2BlockSource, type L2Tips } from '@aztec/stdlib/block';
+import { L2Block, L2BlockHash, type L2BlockSource, type L2Tips, type ValidateBlockResult } from '@aztec/stdlib/block';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { EmptyL1RollupConstants, type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import { type BlockHeader, TxHash, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
@@ -271,4 +271,12 @@ export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
   syncImmediate(): Promise<void> {
     return Promise.resolve();
   }
+
+  isPendingChainInvalid(): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  getPendingChainValidationStatus(): Promise<ValidateBlockResult> {
+    return Promise.resolve({ valid: true });
+  }
 }

yarn-project/ethereum/src/contracts/empire_base.ts

@@ -1,3 +1,4 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { EmpireBaseAbi } from '@aztec/l1-artifacts/EmpireBaseAbi';
 
@@ -6,6 +7,7 @@ import { type Hex, type TypedDataDefinition, encodeFunctionData } from 'viem';
 import type { L1TxRequest } from '../l1_tx_utils.js';
 
 export interface IEmpireBase {
+  get address(): EthAddress;
   getRoundInfo(
     rollupAddress: Hex,
     round: bigint,

yarn-project/ethereum/src/contracts/rollup.test.ts

@@ -0,0 +1,110 @@
+import { getPublicClient } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+
+import type { Anvil } from '@viem/anvil';
+import type { Abi } from 'viem';
+import { type PrivateKeyAccount, privateKeyToAccount } from 'viem/accounts';
+import { foundry } from 'viem/chains';
+
+import { DefaultL1ContractsConfig } from '../config.js';
+import { deployL1Contracts } from '../deploy_l1_contracts.js';
+import { EthCheatCodes } from '../test/eth_cheat_codes.js';
+import { startAnvil } from '../test/start_anvil.js';
+import type { ViemClient } from '../types.js';
+import { RollupContract } from './rollup.js';
+
+describe('Rollup', () => {
+  let anvil: Anvil;
+  let rpcUrl: string;
+  let privateKey: PrivateKeyAccount;
+  let logger: Logger;
+  let publicClient: ViemClient;
+  let cheatCodes: EthCheatCodes;
+
+  let vkTreeRoot: Fr;
+  let protocolContractTreeRoot: Fr;
+  let rollupAddress: `0x${string}`;
+  let rollup: RollupContract;
+
+  beforeAll(async () => {
+    logger = createLogger('ethereum:test:rollup');
+    // this is the 6th address that gets funded by the junk mnemonic
+    privateKey = privateKeyToAccount('0x8b3a350cf5c34c9194ca85829a2df0ec3153be0318b5e2d3348e872092edffba');
+    vkTreeRoot = Fr.random();
+    protocolContractTreeRoot = Fr.random();
+
+    ({ anvil, rpcUrl } = await startAnvil());
+
+    publicClient = getPublicClient({ l1RpcUrls: [rpcUrl], l1ChainId: 31337 });
+    cheatCodes = new EthCheatCodes([rpcUrl]);
+
+    const deployed = await deployL1Contracts([rpcUrl], privateKey, foundry, logger, {
+      ...DefaultL1ContractsConfig,
+      salt: undefined,
+      vkTreeRoot,
+      protocolContractTreeRoot,
+      genesisArchiveRoot: Fr.random(),
+      realVerifier: false,
+    });
+
+    rollupAddress = deployed.l1ContractAddresses.rollupAddress.toString();
+    rollup = new RollupContract(publicClient, rollupAddress);
+  });
+
+  afterAll(async () => {
+    await cheatCodes.setIntervalMining(0);
+    await anvil?.stop().catch(err => createLogger('cleanup').error(err));
+  });
+
+  describe('makePendingBlockNumberOverride', () => {
+    it('creates state override that correctly overrides pending block number', async () => {
+      const testProvenBlockNumber = 42n;
+      const testPendingBlockNumber = 100n;
+      const newPendingBlockNumber = 150;
+
+      // Set storage directly using cheat codes
+      // The storage slot stores both values: pending (high 128 bits) | proven (low 128 bits)
+      const storageSlot = RollupContract.stfStorageSlot;
+      const packedValue = (testPendingBlockNumber << 128n) | testProvenBlockNumber;
+      await cheatCodes.store(EthAddress.fromString(rollupAddress), BigInt(storageSlot), packedValue);
+
+      // Verify the values were set correctly by calling the getters directly
+      const provenBlockNumber = await rollup.getProvenBlockNumber();
+      const pendingBlockNumber = await rollup.getBlockNumber();
+
+      expect(provenBlockNumber).toBe(testProvenBlockNumber);
+      expect(pendingBlockNumber).toBe(testPendingBlockNumber);
+
+      // Create the override
+      const stateOverride = await rollup.makePendingBlockNumberOverride(newPendingBlockNumber);
+
+      // Test the override using simulateContract
+      const { result: overriddenPendingBlockNumber } = await publicClient.simulateContract({
+        address: rollupAddress,
+        abi: RollupAbi as Abi,
+        functionName: 'getPendingBlockNumber',
+        stateOverride,
+      });
+
+      // The overridden value should be the new pending block number
+      expect(overriddenPendingBlockNumber).toBe(BigInt(newPendingBlockNumber));
+
+      // Verify that the proven block number is preserved in the override
+      const { result: overriddenProvenBlockNumber } = await publicClient.simulateContract({
+        address: rollupAddress,
+        abi: RollupAbi as Abi,
+        functionName: 'getProvenBlockNumber',
+        stateOverride,
+      });
+
+      expect(overriddenProvenBlockNumber).toBe(testProvenBlockNumber);
+
+      // Verify the actual storage hasn't changed
+      const actualPendingBlockNumber = await rollup.getBlockNumber();
+      expect(actualPendingBlockNumber).toBe(testPendingBlockNumber);
+    });
+  });
+});