feat: merge-train/spartan (#23714)

BEGIN_COMMIT_OVERRIDE
feat(stdlib): make empty ChonkProof hold an empty array (#23712)
test(e2e): l2-to-l1 mbps and anchor to checkpointed chain (#23717)
fix(sequencer): atomically query current and target slots (#23716)
test(e2e): restore both malicious nodes to honest in `invalidate_block`
(#23720)
test: exclude forge reserved addresses from setSlasher fuzz inputs
(#23721)
END_COMMIT_OVERRIDE

Author: PhilWindle

l1-contracts/test/staking/setSlasher.t.sol

@@ -19,6 +19,11 @@ contract SetSlasherTest is StakingBase {
   ///      queueSetSlasher accepts it. Tests that want to exercise the uninitialized-slasher
   ///      guard call queueSetSlasher directly without mocking.
   function _mockInitializedSlasher(address _slasher) internal {
+    // Foundry intercepts every call to the console address and dispatches it to its console
+    // handler, which bypasses vm.mockCall. A fuzzed slasher equal to that address therefore makes
+    // the PROPOSER() lookup revert with "unknown selector for ConsoleCalls" instead of returning
+    // the mocked value, so exclude the reserved forge addresses.
+    assumeNotForgeAddress(_slasher);
     vm.mockCall(_slasher, abi.encodeWithSignature("PROPOSER()"), abi.encode(address(0xBEEF)));
   }
 
@@ -140,6 +145,7 @@ contract SetSlasherTest is StakingBase {
     // Slasher.initializeProposer is permissionless and an attacker could claim the proposer
     // role during the 60-day delay.
     address owner = _owner(); // cache before expectRevert to avoid consuming it
+    assumeNotForgeAddress(_newSlasher);
     vm.mockCall(_newSlasher, abi.encodeWithSignature("PROPOSER()"), abi.encode(address(0)));
 
     vm.prank(owner);

yarn-project/end-to-end/src/e2e_cross_chain_messaging/l2_to_l1.test.ts

@@ -13,7 +13,7 @@ import {
   computeL2ToL1MembershipWitness,
   getL2ToL1MessageLeafId,
 } from '@aztec/stdlib/messaging';
-import type { TxHash } from '@aztec/stdlib/tx';
+import { type TxHash, TxStatus } from '@aztec/stdlib/tx';
 
 import { jest } from '@jest/globals';
 import { type Hex, decodeEventLog } from 'viem';
@@ -67,15 +67,18 @@ describe('e2e_cross_chain_messaging l2_to_l1', () => {
   let contract: TestContract;
 
   beforeAll(async () => {
-    await t.setup({ ...PIPELINING_SETUP_OPTS });
+    await t.setup({ ...PIPELINING_SETUP_OPTS }, { syncChainTip: 'checkpointed' });
 
     ({ crossChainTestHarness, aztecNode, aztecNodeAdmin, wallet, user1Address, rollup, outbox } = t);
 
     msgSender = EthAddress.fromString(t.deployL1ContractsValues.l1Client.account.address);
 
     version = BigInt(await rollup.getVersion());
 
-    ({ contract } = await TestContract.deploy(wallet).send({ from: user1Address }));
+    ({ contract } = await TestContract.deploy(wallet).send({
+      from: user1Address,
+      wait: { waitForStatus: TxStatus.CHECKPOINTED },
+    }));
   });
 
   afterAll(async () => {
@@ -250,7 +253,64 @@ describe('e2e_cross_chain_messaging l2_to_l1', () => {
     }
   });
 
-  // TODO(#17027): Add tests for multiple blocks per checkpoint.
+  // Two txs, each emitting one L2-to-L1 message, packed into separate blocks of a single checkpoint.
+  // This exercises the checkpoint level of the L2-to-L1 message tree (the block out hashes within a
+  // checkpoint), which the single-block-per-checkpoint cases above never reach. See #17027.
+  it('2 txs each with a message, in different blocks of the same checkpoint', async () => {
+    const recipient = msgSender;
+    const contents = [Fr.random(), Fr.random()];
+    const messages = contents.map(content => makeL2ToL1Message(recipient, content));
+
+    // Enable multiple-blocks-per-checkpoint: enforce the timetable so the sequencer splits the slot
+    // into per-block sub-slots, cap each block at a single tx, and require (and accept at most) two
+    // blocks before publishing the checkpoint. With the two txs below this yields one checkpoint
+    // holding two single-tx blocks.
+    await aztecNodeAdmin.setConfig({
+      enforceTimeTable: true,
+      blockDurationMs: 2000,
+      minTxsPerBlock: 1,
+      maxTxsPerBlock: 1,
+      minBlocksForCheckpoint: 2,
+      maxBlocksPerCheckpoint: 2,
+    });
+    await waitForSequencerIdle(t.context.sequencer!.getSequencer());
+
+    // Send the 2 txs. minBlocksForCheckpoint=2 keeps the sequencer from publishing until both have
+    // been packed (one per block), so they always end up in the same checkpoint.
+    const [{ receipt: receipt0 }, { receipt: receipt1 }] = await Promise.all([
+      contract.methods
+        .create_l2_to_l1_message_arbitrary_recipient_private(contents[0], recipient)
+        .send({ from: user1Address }),
+      contract.methods
+        .create_l2_to_l1_message_arbitrary_recipient_private(contents[1], recipient)
+        .send({ from: user1Address }),
+    ]);
+
+    // The 2 txs must land in different blocks...
+    expect(receipt0.blockNumber).not.toEqual(receipt1.blockNumber);
+
+    // ...that belong to the same checkpoint, at consecutive positions within it.
+    const block0 = (await aztecNode.getBlock(receipt0.blockNumber!, { includeTransactions: true }))!;
+    const block1 = (await aztecNode.getBlock(receipt1.blockNumber!, { includeTransactions: true }))!;
+    expect(block0.checkpointNumber).toEqual(block1.checkpointNumber);
+    expect([block0.indexWithinCheckpoint, block1.indexWithinCheckpoint].sort((a, b) => a - b)).toEqual([0, 1]);
+
+    // Each block carries exactly its own message.
+    expect(block0.body.txEffects.flatMap(txEffect => txEffect.l2ToL1Msgs)).toStrictEqual([
+      computeMessageLeaf(messages[0]),
+    ]);
+    expect(block1.body.txEffects.flatMap(txEffect => txEffect.l2ToL1Msgs)).toStrictEqual([
+      computeMessageLeaf(messages[1]),
+    ]);
+
+    // Advance the epoch until proven, since the messages are inserted to the outbox when the epoch is proven.
+    await t.advanceToEpochProven(receipt1);
+
+    // Consume both messages. The membership witnesses now span the checkpoint's block subtree, not just
+    // a single block.
+    await expectConsumeMessageToSucceed(messages[0], receipt0.txHash);
+    await expectConsumeMessageToSucceed(messages[1], receipt1.txHash);
+  });
 
   function makeL2ToL1Message(recipient: EthAddress, content: Fr = Fr.ZERO): ViemL2ToL1Msg {
     return {

yarn-project/end-to-end/src/e2e_epochs/epochs_invalidate_block.parallel.test.ts

@@ -661,9 +661,12 @@ describe('e2e_epochs/epochs_invalidate_block', () => {
     // P1 must have landed with insufficient attestations (the trigger for the archiver skip).
     await assertCheckpointInsufficientAttestations(p1Checkpoint);
 
-    // Restore P2 to a healthy config so a later proposer (or P2 in a future slot) can resume
-    // the chain by invalidating P1 and posting fresh checkpoints.
-    await p2Node.setConfig({ skipWaitForValidParentCheckpointOnL1: false, skipInvalidateBlockAsProposer: false });
+    // Restore the bad proposers to a healthy config so later slots can resume the chain by
+    // invalidating P1 and posting fresh checkpoints.
+    await Promise.all([
+      p1Node.setConfig({ skipCollectingAttestations: false, skipInvalidateBlockAsProposer: false }),
+      p2Node.setConfig({ skipWaitForValidParentCheckpointOnL1: false, skipInvalidateBlockAsProposer: false }),
+    ]);
 
     // The archiver should no longer stall: wait for the chain to advance past P2 within a
     // handful of slots. Note we wait on local checkpoint progress here (i.e. for the chain to

yarn-project/sequencer-client/src/client/sequencer-client.ts

@@ -145,7 +145,13 @@ export class SequencerClient {
 
     const { maxL2BlockGas, maxDABlockGas, maxTxsPerBlock } = capPerBlockLimits(config, rollupManaLimit, log);
 
-    const l1Constants = { l1GenesisTime, slotDuration: Number(slotDuration), ethereumSlotDuration, rollupManaLimit };
+    const l1Constants = {
+      l1GenesisTime,
+      slotDuration: Number(slotDuration),
+      ethereumSlotDuration,
+      rollupManaLimit,
+      epochDuration: config.aztecEpochDuration,
+    };
 
     const sequencer = new Sequencer(
       publisherFactory,

yarn-project/sequencer-client/src/sequencer/checkpoint_voter.ha.integration.test.ts

@@ -62,6 +62,7 @@ describe('CheckpointVoter HA Integration', () => {
     l1GenesisTime: 1n,
     slotDuration: 24,
     ethereumSlotDuration: DefaultL1ContractsConfig.ethereumSlotDuration,
+    epochDuration: DefaultL1ContractsConfig.aztecEpochDuration,
     rollupManaLimit: Number.MAX_SAFE_INTEGER,
   };
 

yarn-project/sequencer-client/src/sequencer/sequencer.test.ts

@@ -85,13 +85,14 @@ describe('sequencer', () => {
   let globalVariables: GlobalVariables;
   let l1Constants: Pick<
     L1RollupConstants,
-    'l1GenesisTime' | 'slotDuration' | 'ethereumSlotDuration' | 'rollupManaLimit'
+    'l1GenesisTime' | 'slotDuration' | 'ethereumSlotDuration' | 'rollupManaLimit' | 'epochDuration'
   >;
 
   let sequencer: TestSequencer;
 
   const slotDuration = 8;
   const ethereumSlotDuration = 4;
+  const epochDuration = 16;
 
   const chainId = new Fr(12345);
   const version = Fr.ZERO;
@@ -188,7 +189,13 @@ describe('sequencer', () => {
     );
 
     const l1GenesisTime = BigInt(Math.floor(Date.now() / 1000));
-    l1Constants = { l1GenesisTime, slotDuration, ethereumSlotDuration, rollupManaLimit: Number.MAX_SAFE_INTEGER };
+    l1Constants = {
+      l1GenesisTime,
+      slotDuration,
+      ethereumSlotDuration,
+      epochDuration,
+      rollupManaLimit: Number.MAX_SAFE_INTEGER,
+    };
 
     epochCache = mockDeep<EpochCache>();
     epochCache.isEscapeHatchOpen.mockResolvedValue(false);
@@ -1062,6 +1069,34 @@ describe('sequencer', () => {
       sequencer.skipExecute = false;
     });
 
+    it('derives the pipelined target slot from the same next-L1-slot snapshot', async () => {
+      await setupSingleTxBlock();
+
+      epochCache.getEpochAndSlotInNextL1Slot.mockReturnValue({
+        epoch: EpochNumber(1),
+        slot: SlotNumber(6),
+        ts: 1780066804n,
+        nowSeconds: 1780066811n,
+      });
+      epochCache.getTargetEpochAndSlotInNextL1Slot.mockReturnValue({
+        epoch: EpochNumber(1),
+        slot: SlotNumber(8),
+        ts: 1780066816n,
+        nowSeconds: 1780066812n,
+      });
+      publisher.canProposeAt.mockResolvedValue({
+        slot: SlotNumber(7),
+        checkpointNumber: CheckpointNumber.fromBlockNumber(newBlockNumber),
+        timeOfNextL1Slot: 1780066816n,
+      });
+
+      await sequencer.work();
+
+      expect(epochCache.getTargetEpochAndSlotInNextL1Slot).not.toHaveBeenCalled();
+      expect(epochCache.getProposerAttesterAddressInSlot).toHaveBeenCalledWith(SlotNumber(7));
+      expect(p2p.prepareForSlot).toHaveBeenCalledWith(SlotNumber(7));
+    });
+
     it('skips L1 check when proposed checkpoint exists', async () => {
       await setupSingleTxBlock();
 
@@ -1467,8 +1502,7 @@ class TestSequencer extends Sequencer {
     this.setState(SequencerState.IDLE, undefined, { force: true });
     if (this.skipExecute) {
       this.setState(SequencerState.SYNCHRONIZING, undefined);
-      const { slot, ts, nowSeconds, epoch } = this.epochCache.getEpochAndSlotInNextL1Slot();
-      const { slot: targetSlot, epoch: targetEpoch } = this.epochCache.getTargetEpochAndSlotInNextL1Slot();
+      const { slot, targetSlot, epoch, targetEpoch, ts, nowSeconds } = this.getSlotContextInNextL1Slot();
       await this.prepareCheckpointProposal(slot, targetSlot, epoch, targetEpoch, ts, nowSeconds);
       return;
     }

yarn-project/sequencer-client/src/sequencer/sequencer.ts

@@ -1,5 +1,5 @@
 import { getKzg } from '@aztec/blob-lib';
-import type { EpochCache } from '@aztec/epoch-cache';
+import { type EpochCache, PROPOSER_PIPELINING_SLOT_OFFSET } from '@aztec/epoch-cache';
 import { NoCommitteeError, type RollupContract } from '@aztec/ethereum/contracts';
 import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { merge, omit, pick } from '@aztec/foundation/collection';
@@ -20,7 +20,7 @@ import type {
 } from '@aztec/stdlib/block';
 import type { Checkpoint, ProposedCheckpointData } from '@aztec/stdlib/checkpoint';
 import type { ChainConfig } from '@aztec/stdlib/config';
-import { getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
+import { getEpochAtSlot, getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import {
   type ResolvedSequencerConfig,
   type SequencerConfig,
@@ -52,6 +52,16 @@ import { SequencerState } from './utils.js';
 
 export { SequencerState };
 
+/** Slot snapshot used to prepare a checkpoint proposal. */
+type SequencerSlotContext = {
+  slot: SlotNumber;
+  targetSlot: SlotNumber;
+  epoch: EpochNumber;
+  targetEpoch: EpochNumber;
+  ts: bigint;
+  nowSeconds: bigint;
+};
+
 /**
  * Sequencer client
  * - Checks whether it is elected as proposer for the next slot
@@ -220,8 +230,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
   @trackSpan('Sequencer.work')
   protected async work() {
     this.setState(SequencerState.SYNCHRONIZING, undefined);
-    const { slot, ts, nowSeconds, epoch } = this.epochCache.getEpochAndSlotInNextL1Slot();
-    const { slot: targetSlot, epoch: targetEpoch } = this.epochCache.getTargetEpochAndSlotInNextL1Slot();
+    const { slot, targetSlot, epoch, targetEpoch, ts, nowSeconds } = this.getSlotContextInNextL1Slot();
 
     // Check if we are synced and it's our slot, grab a publisher, check previous block invalidation, etc
     const checkpointProposalJob = await this.prepareCheckpointProposal(
@@ -259,6 +268,15 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     return checkpoint;
   }
 
+  /** Returns slot and target slot from a single clock snapshot. */
+  protected getSlotContextInNextL1Slot(): SequencerSlotContext {
+    const { slot, ts, nowSeconds, epoch } = this.epochCache.getEpochAndSlotInNextL1Slot();
+    const targetSlot = SlotNumber(
+      slot + (this.epochCache.isProposerPipeliningEnabled() ? PROPOSER_PIPELINING_SLOT_OFFSET : 0),
+    );
+    return { slot, targetSlot, epoch, targetEpoch: getEpochAtSlot(targetSlot, this.l1Constants), ts, nowSeconds };
+  }
+
   /**
    * Prepares the checkpoint proposal by performing all necessary checks and setup.
    * This is the initial step in the main loop.

yarn-project/sequencer-client/src/sequencer/types.ts

@@ -2,5 +2,5 @@ import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 
 export type SequencerRollupConstants = Pick<
   L1RollupConstants,
-  'ethereumSlotDuration' | 'l1GenesisTime' | 'slotDuration' | 'rollupManaLimit'
+  'ethereumSlotDuration' | 'l1GenesisTime' | 'slotDuration' | 'rollupManaLimit' | 'epochDuration'
 >;

yarn-project/stdlib/src/proofs/chonk_proof.test.ts

@@ -10,11 +10,22 @@ describe('ChonkProof', () => {
     expect(() => new ChonkProof(fields)).toThrow(`Invalid ChonkProof length: ${CHONK_PROOF_LENGTH + 1}`);
   });
 
+  it('empty proof holds an empty fields array', () => {
+    const proof = ChonkProof.empty();
+    expect(proof.fields).toEqual([]);
+  });
+
   it('isEmpty should return true for empty proof', () => {
     const proof = ChonkProof.empty();
     expect(proof.isEmpty()).toBe(true);
   });
 
+  it('serializes empty proof as a single zero length', () => {
+    const buffer = ChonkProof.empty().toBuffer();
+    expect(buffer).toEqual(numToUInt32BE(0));
+    expect(buffer.length).toBe(4);
+  });
+
   it('should serialize and deserialize empty proof', () => {
     const original = ChonkProof.empty();
     const buffer = original.toBuffer();
@@ -101,6 +112,15 @@ describe('ChonkProofWithPublicInputs', () => {
     expect(proof.isEmpty()).toBe(true);
   });
 
+  it('empty proof round-trips with an empty fields array', () => {
+    const original = ChonkProofWithPublicInputs.empty();
+    expect(original.fieldsWithPublicInputs).toEqual([]);
+
+    const deserialized = ChonkProofWithPublicInputs.fromBuffer(original.toBuffer());
+    expect(deserialized.fieldsWithPublicInputs).toEqual([]);
+    expect(deserialized.isEmpty()).toBe(true);
+  });
+
   it('should serialize and deserialize proof with public inputs', () => {
     const baseProof = ChonkProof.random();
     const publicInputs = Array.from({ length: 5 }, () => Fr.random());