@aztec/validator-client 0.0.1-commit.24de95ac → 0.0.1-commit.3469e52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/validator-client",
-  "version": "0.0.1-commit.24de95ac",
+  "version": "0.0.1-commit.3469e52",
   "main": "dest/index.js",
   "type": "module",
   "exports": {
@@ -18,8 +18,8 @@
   },
   "scripts": {
     "start": "node --no-warnings ./dest/bin",
-    "build": "yarn clean && tsc -b",
-    "build:dev": "tsc -b --watch",
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
@@ -64,25 +64,33 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.0.1-commit.24de95ac",
-    "@aztec/epoch-cache": "0.0.1-commit.24de95ac",
-    "@aztec/ethereum": "0.0.1-commit.24de95ac",
-    "@aztec/foundation": "0.0.1-commit.24de95ac",
-    "@aztec/node-keystore": "0.0.1-commit.24de95ac",
-    "@aztec/p2p": "0.0.1-commit.24de95ac",
-    "@aztec/prover-client": "0.0.1-commit.24de95ac",
-    "@aztec/slasher": "0.0.1-commit.24de95ac",
-    "@aztec/stdlib": "0.0.1-commit.24de95ac",
-    "@aztec/telemetry-client": "0.0.1-commit.24de95ac",
+    "@aztec/blob-client": "0.0.1-commit.3469e52",
+    "@aztec/blob-lib": "0.0.1-commit.3469e52",
+    "@aztec/constants": "0.0.1-commit.3469e52",
+    "@aztec/epoch-cache": "0.0.1-commit.3469e52",
+    "@aztec/ethereum": "0.0.1-commit.3469e52",
+    "@aztec/foundation": "0.0.1-commit.3469e52",
+    "@aztec/node-keystore": "0.0.1-commit.3469e52",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.3469e52",
+    "@aztec/p2p": "0.0.1-commit.3469e52",
+    "@aztec/protocol-contracts": "0.0.1-commit.3469e52",
+    "@aztec/prover-client": "0.0.1-commit.3469e52",
+    "@aztec/simulator": "0.0.1-commit.3469e52",
+    "@aztec/slasher": "0.0.1-commit.3469e52",
+    "@aztec/stdlib": "0.0.1-commit.3469e52",
+    "@aztec/telemetry-client": "0.0.1-commit.3469e52",
+    "@aztec/validator-ha-signer": "0.0.1-commit.3469e52",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "tslib": "^2.4.0",
-    "viem": "npm:@spalladino/viem@2.38.2-eip7594.0"
+    "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
+    "@electric-sql/pglite": "^0.3.14",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
     "jest": "^30.0.0",
     "jest-mock-extended": "^4.0.0",
     "ts-node": "^10.9.1",

package/src/block_proposal_handler.ts

@@ -1,19 +1,24 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import type { EpochCache } from '@aztec/epoch-cache';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { TimeoutError } from '@aztec/foundation/error';
-import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { DateProvider, Timer } from '@aztec/foundation/timer';
 import type { P2P, PeerId } from '@aztec/p2p';
 import { TxProvider } from '@aztec/p2p';
 import { BlockProposalValidator } from '@aztec/p2p/msg_validators';
-import { computeInHashFromL1ToL2Messages } from '@aztec/prover-client/helpers';
-import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
-import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
-import type { IFullNodeBlockBuilder, ValidatorClientFullConfig } from '@aztec/stdlib/interfaces/server';
-import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
-import { type BlockProposal, ConsensusPayload } from '@aztec/stdlib/p2p';
-import { BlockHeader, type FailedTx, GlobalVariables, type Tx } from '@aztec/stdlib/tx';
+import type { L2BlockNew, L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
+import { getEpochAtSlot, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import type { ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import {
+  type L1ToL2MessageSource,
+  computeCheckpointOutHash,
+  computeInHashFromL1ToL2Messages,
+} from '@aztec/stdlib/messaging';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import { BlockHeader, type CheckpointGlobalVariables, type FailedTx, type Tx } from '@aztec/stdlib/tx';
 import {
   ReExFailedTxsError,
   ReExStateMismatchError,
@@ -22,6 +27,7 @@ import {
 } from '@aztec/stdlib/validators';
 import { type TelemetryClient, type Tracer, getTelemetryClient } from '@aztec/telemetry-client';
 
+import type { FullNodeCheckpointsBuilder } from './checkpoint_builder.js';
 import type { ValidatorMetrics } from './metrics.js';
 
 export type BlockProposalValidationFailureReason =
@@ -29,6 +35,7 @@ export type BlockProposalValidationFailureReason =
   | 'parent_block_not_found'
   | 'parent_block_wrong_slot'
   | 'in_hash_mismatch'
+  | 'global_variables_mismatch'
   | 'block_number_already_exists'
   | 'txs_not_available'
   | 'state_mismatch'
@@ -37,7 +44,7 @@ export type BlockProposalValidationFailureReason =
   | 'unknown_error';
 
 type ReexecuteTransactionsResult = {
-  block: L2Block;
+  block: L2BlockNew;
   failedTxs: FailedTx[];
   reexecutionTimeMs: number;
   totalManaUsed: number;
@@ -45,58 +52,71 @@ type ReexecuteTransactionsResult = {
 
 export type BlockProposalValidationSuccessResult = {
   isValid: true;
-  blockNumber: number;
+  blockNumber: BlockNumber;
   reexecutionResult?: ReexecuteTransactionsResult;
 };
 
 export type BlockProposalValidationFailureResult = {
   isValid: false;
   reason: BlockProposalValidationFailureReason;
-  blockNumber?: number;
+  blockNumber?: BlockNumber;
   reexecutionResult?: ReexecuteTransactionsResult;
 };
 
 export type BlockProposalValidationResult = BlockProposalValidationSuccessResult | BlockProposalValidationFailureResult;
 
+type CheckpointComputationResult =
+  | { checkpointNumber: CheckpointNumber; reason?: undefined }
+  | { checkpointNumber?: undefined; reason: 'invalid_proposal' | 'global_variables_mismatch' };
+
 export class BlockProposalHandler {
   public readonly tracer: Tracer;
 
   constructor(
-    private blockBuilder: IFullNodeBlockBuilder,
-    private blockSource: L2BlockSource,
+    private checkpointsBuilder: FullNodeCheckpointsBuilder,
+    private worldState: WorldStateSynchronizer,
+    private blockSource: L2BlockSource & L2BlockSink,
     private l1ToL2MessageSource: L1ToL2MessageSource,
     private txProvider: TxProvider,
     private blockProposalValidator: BlockProposalValidator,
+    private epochCache: EpochCache,
     private config: ValidatorClientFullConfig,
     private metrics?: ValidatorMetrics,
     private dateProvider: DateProvider = new DateProvider(),
     telemetry: TelemetryClient = getTelemetryClient(),
     private log = createLogger('validator:block-proposal-handler'),
   ) {
+    if (config.fishermanMode) {
+      this.log = this.log.createChild('[FISHERMAN]');
+    }
     this.tracer = telemetry.getTracer('BlockProposalHandler');
   }
 
   registerForReexecution(p2pClient: P2P): BlockProposalHandler {
-    const handler = async (proposal: BlockProposal, proposalSender: PeerId) => {
+    // Non-validator handler that re-executes for monitoring but does not attest.
+    // Returns boolean indicating whether the proposal was valid.
+    const handler = async (proposal: BlockProposal, proposalSender: PeerId): Promise<boolean> => {
       try {
         const result = await this.handleBlockProposal(proposal, proposalSender, true);
         if (result.isValid) {
-          this.log.info(`Non-validator reexecution completed for slot ${proposal.slotNumber.toBigInt()}`, {
+          this.log.info(`Non-validator reexecution completed for slot ${proposal.slotNumber}`, {
             blockNumber: result.blockNumber,
             reexecutionTimeMs: result.reexecutionResult?.reexecutionTimeMs,
             totalManaUsed: result.reexecutionResult?.totalManaUsed,
             numTxs: result.reexecutionResult?.block?.body?.txEffects?.length ?? 0,
           });
+          return true;
         } else {
-          this.log.warn(`Non-validator reexecution failed for slot ${proposal.slotNumber.toBigInt()}`, {
+          this.log.warn(`Non-validator reexecution failed for slot ${proposal.slotNumber}`, {
             blockNumber: result.blockNumber,
             reason: result.reason,
           });
+          return false;
         }
       } catch (error) {
         this.log.error('Error processing block proposal in non-validator handler', error);
+        return false;
       }
-      return undefined; // Non-validator nodes don't return attestations
     };
 
     p2pClient.registerBlockProposalHandler(handler);
@@ -108,9 +128,9 @@ export class BlockProposalHandler {
     proposalSender: PeerId,
     shouldReexecute: boolean,
   ): Promise<BlockProposalValidationResult> {
-    const slotNumber = proposal.slotNumber.toBigInt();
+    const slotNumber = proposal.slotNumber;
     const proposer = proposal.getSender();
-    const config = this.blockBuilder.getConfig();
+    const config = this.checkpointsBuilder.getConfig();
 
     // Reject proposals with invalid signatures
     if (!proposer) {
@@ -150,7 +170,10 @@ export class BlockProposalHandler {
     }
 
     // Compute the block number based on the parent block
-    const blockNumber = parentBlockHeader === 'genesis' ? INITIAL_L2_BLOCK_NUM : parentBlockHeader.getBlockNumber() + 1;
+    const blockNumber =
+      parentBlockHeader === 'genesis'
+        ? BlockNumber(INITIAL_L2_BLOCK_NUM)
+        : BlockNumber(parentBlockHeader.getBlockNumber() + 1);
 
     // Check that this block number does not exist already
     const existingBlock = await this.blockSource.getBlockHeader(blockNumber);
@@ -166,10 +189,17 @@ export class BlockProposalHandler {
       deadline: this.getReexecutionDeadline(slotNumber, config),
     });
 
+    // Compute the checkpoint number for this block and validate checkpoint consistency
+    const checkpointResult = await this.computeCheckpointNumber(proposal, parentBlockHeader, proposalInfo);
+    if (checkpointResult.reason) {
+      return { isValid: false, blockNumber, reason: checkpointResult.reason };
+    }
+    const checkpointNumber = checkpointResult.checkpointNumber;
+
     // Check that I have the same set of l1ToL2Messages as the proposal
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(blockNumber);
-    const computedInHash = await computeInHashFromL1ToL2Messages(l1ToL2Messages);
-    const proposalInHash = proposal.payload.header.contentCommitment.inHash;
+    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
+    const computedInHash = computeInHashFromL1ToL2Messages(l1ToL2Messages);
+    const proposalInHash = proposal.inHash;
     if (!computedInHash.equals(proposalInHash)) {
       this.log.warn(`L1 to L2 messages in hash mismatch, skipping processing`, {
         proposalInHash: proposalInHash.toString(),
@@ -188,9 +218,28 @@ export class BlockProposalHandler {
     // Try re-executing the transactions in the proposal if needed
     let reexecutionResult;
     if (shouldReexecute) {
+      // Compute the previous checkpoint out hashes for the epoch.
+      // TODO(mbps): This assumes one block per checkpoint, which is only true for now.
+      // TODO: There can be a more efficient way to get the previous checkpoint out hashes without having to fetch all
+      // the blocks.
+      const epoch = getEpochAtSlot(slotNumber, this.epochCache.getL1Constants());
+      const previousBlocks = (await this.blockSource.getBlocksForEpoch(epoch))
+        .filter(b => b.number < blockNumber)
+        .sort((a, b) => a.number - b.number);
+      const previousCheckpointOutHashes = previousBlocks.map(b =>
+        computeCheckpointOutHash([b.body.txEffects.map(tx => tx.l2ToL1Msgs)]),
+      );
+
       try {
         this.log.verbose(`Re-executing transactions in the proposal`, proposalInfo);
-        reexecutionResult = await this.reexecuteTransactions(proposal, blockNumber, txs, l1ToL2Messages);
+        reexecutionResult = await this.reexecuteTransactions(
+          proposal,
+          blockNumber,
+          checkpointNumber,
+          txs,
+          l1ToL2Messages,
+          previousCheckpointOutHashes,
+        );
       } catch (error) {
         this.log.error(`Error reexecuting txs while processing block proposal`, error, proposalInfo);
         const reason = this.getReexecuteFailureReason(error);
@@ -198,14 +247,24 @@ export class BlockProposalHandler {
       }
     }
 
-    this.log.info(`Successfully processed proposal for slot ${slotNumber}`, proposalInfo);
+    // If we succeeded, push this block into the archiver (unless disabled)
+    // TODO(palla/mbps): Change default to false once block sync is stable.
+    if (reexecutionResult?.block && this.config.skipPushProposedBlocksToArchiver === false) {
+      await this.blockSource.addBlock(reexecutionResult?.block);
+    }
+
+    this.log.info(
+      `Successfully processed block ${blockNumber} proposal at index ${proposal.indexWithinCheckpoint} on slot ${slotNumber}`,
+      proposalInfo,
+    );
+
     return { isValid: true, blockNumber, reexecutionResult };
   }
 
   private async getParentBlock(proposal: BlockProposal): Promise<'genesis' | BlockHeader | undefined> {
-    const parentArchive = proposal.payload.header.lastArchiveRoot;
-    const slot = proposal.slotNumber.toBigInt();
-    const config = this.blockBuilder.getConfig();
+    const parentArchive = proposal.blockHeader.lastArchive.root;
+    const slot = proposal.slotNumber;
+    const config = this.checkpointsBuilder.getConfig();
     const { genesisArchiveRoot } = await this.blockSource.getGenesisValues();
 
     if (parentArchive.equals(genesisArchiveRoot)) {
@@ -239,10 +298,165 @@ export class BlockProposalHandler {
     }
   }
 
-  private getReexecutionDeadline(slot: bigint, config: { l1GenesisTime: bigint; slotDuration: number }): Date {
-    const nextSlotTimestampSeconds = Number(getTimestampForSlot(slot + 1n, config));
-    const msNeededForPropagationAndPublishing = this.config.validatorReexecuteDeadlineMs;
-    return new Date(nextSlotTimestampSeconds * 1000 - msNeededForPropagationAndPublishing);
+  private async computeCheckpointNumber(
+    proposal: BlockProposal,
+    parentBlockHeader: 'genesis' | BlockHeader,
+    proposalInfo: object,
+  ): Promise<CheckpointComputationResult> {
+    if (parentBlockHeader === 'genesis') {
+      // First block is in checkpoint 1
+      if (proposal.indexWithinCheckpoint !== 0) {
+        this.log.warn(`First block proposal has non-zero indexWithinCheckpoint`, proposalInfo);
+        return { reason: 'invalid_proposal' };
+      }
+      return { checkpointNumber: CheckpointNumber.INITIAL };
+    }
+
+    // Get the parent block to find its checkpoint number
+    // TODO(palla/mbps): The block header should include the checkpoint number to avoid this lookup,
+    // or at least the L2BlockSource should return a different struct that includes it.
+    const parentBlockNumber = parentBlockHeader.getBlockNumber();
+    const parentBlock = await this.blockSource.getL2BlockNew(parentBlockNumber);
+    if (!parentBlock) {
+      this.log.warn(`Parent block ${parentBlockNumber} not found in archiver`, proposalInfo);
+      return { reason: 'invalid_proposal' };
+    }
+
+    if (proposal.indexWithinCheckpoint === 0) {
+      // If this is the first block in a new checkpoint, increment the checkpoint number
+      if (!(proposal.blockHeader.getSlot() > parentBlockHeader.getSlot())) {
+        this.log.warn(`Slot should be greater than parent block slot for first block in checkpoint`, proposalInfo);
+        return { reason: 'invalid_proposal' };
+      }
+      return { checkpointNumber: CheckpointNumber(parentBlock.checkpointNumber + 1) };
+    }
+
+    // Otherwise it should follow the previous block in the same checkpoint
+    if (proposal.indexWithinCheckpoint !== parentBlock.indexWithinCheckpoint + 1) {
+      this.log.warn(`Non-sequential indexWithinCheckpoint`, proposalInfo);
+      return { reason: 'invalid_proposal' };
+    }
+    if (proposal.blockHeader.getSlot() !== parentBlockHeader.getSlot()) {
+      this.log.warn(`Slot should be equal to parent block slot for non-first block in checkpoint`, proposalInfo);
+      return { reason: 'invalid_proposal' };
+    }
+
+    // For non-first blocks in a checkpoint, validate global variables match parent (except blockNumber)
+    const validationResult = this.validateNonFirstBlockInCheckpoint(proposal, parentBlock, proposalInfo);
+    if (validationResult) {
+      return validationResult;
+    }
+
+    return { checkpointNumber: parentBlock.checkpointNumber };
+  }
+
+  /**
+   * Validates that a non-first block in a checkpoint has consistent global variables with its parent.
+   * For blocks with indexWithinCheckpoint > 0, all global variables except blockNumber must match the parent.
+   * @returns A failure result if validation fails, undefined if validation passes
+   */
+  private validateNonFirstBlockInCheckpoint(
+    proposal: BlockProposal,
+    parentBlock: L2BlockNew,
+    proposalInfo: object,
+  ): CheckpointComputationResult | undefined {
+    const proposalGlobals = proposal.blockHeader.globalVariables;
+    const parentGlobals = parentBlock.header.globalVariables;
+
+    // All global variables except blockNumber should match the parent
+    // blockNumber naturally increments between blocks
+    if (!proposalGlobals.chainId.equals(parentGlobals.chainId)) {
+      this.log.warn(`Non-first block in checkpoint has mismatched chainId`, {
+        ...proposalInfo,
+        proposalChainId: proposalGlobals.chainId.toString(),
+        parentChainId: parentGlobals.chainId.toString(),
+      });
+      return { reason: 'global_variables_mismatch' };
+    }
+
+    if (!proposalGlobals.version.equals(parentGlobals.version)) {
+      this.log.warn(`Non-first block in checkpoint has mismatched version`, {
+        ...proposalInfo,
+        proposalVersion: proposalGlobals.version.toString(),
+        parentVersion: parentGlobals.version.toString(),
+      });
+      return { reason: 'global_variables_mismatch' };
+    }
+
+    if (proposalGlobals.slotNumber !== parentGlobals.slotNumber) {
+      this.log.warn(`Non-first block in checkpoint has mismatched slotNumber`, {
+        ...proposalInfo,
+        proposalSlotNumber: proposalGlobals.slotNumber,
+        parentSlotNumber: parentGlobals.slotNumber,
+      });
+      return { reason: 'global_variables_mismatch' };
+    }
+
+    if (proposalGlobals.timestamp !== parentGlobals.timestamp) {
+      this.log.warn(`Non-first block in checkpoint has mismatched timestamp`, {
+        ...proposalInfo,
+        proposalTimestamp: proposalGlobals.timestamp.toString(),
+        parentTimestamp: parentGlobals.timestamp.toString(),
+      });
+      return { reason: 'global_variables_mismatch' };
+    }
+
+    if (!proposalGlobals.coinbase.equals(parentGlobals.coinbase)) {
+      this.log.warn(`Non-first block in checkpoint has mismatched coinbase`, {
+        ...proposalInfo,
+        proposalCoinbase: proposalGlobals.coinbase.toString(),
+        parentCoinbase: parentGlobals.coinbase.toString(),
+      });
+      return { reason: 'global_variables_mismatch' };
+    }
+
+    if (!proposalGlobals.feeRecipient.equals(parentGlobals.feeRecipient)) {
+      this.log.warn(`Non-first block in checkpoint has mismatched feeRecipient`, {
+        ...proposalInfo,
+        proposalFeeRecipient: proposalGlobals.feeRecipient.toString(),
+        parentFeeRecipient: parentGlobals.feeRecipient.toString(),
+      });
+      return { reason: 'global_variables_mismatch' };
+    }
+
+    if (!proposalGlobals.gasFees.equals(parentGlobals.gasFees)) {
+      this.log.warn(`Non-first block in checkpoint has mismatched gasFees`, {
+        ...proposalInfo,
+        proposalGasFees: proposalGlobals.gasFees.toInspect(),
+        parentGasFees: parentGlobals.gasFees.toInspect(),
+      });
+      return { reason: 'global_variables_mismatch' };
+    }
+
+    return undefined;
+  }
+
+  private getReexecutionDeadline(slot: SlotNumber, config: { l1GenesisTime: bigint; slotDuration: number }): Date {
+    const nextSlotTimestampSeconds = Number(getTimestampForSlot(SlotNumber(slot + 1), config));
+    return new Date(nextSlotTimestampSeconds * 1000);
+  }
+
+  /**
+   * Gets all prior blocks in the same checkpoint (same slot and checkpoint number) up to but not including upToBlockNumber.
+   */
+  private async getBlocksInCheckpoint(
+    slot: SlotNumber,
+    upToBlockNumber: BlockNumber,
+    checkpointNumber: CheckpointNumber,
+  ): Promise<L2BlockNew[]> {
+    const blocks: L2BlockNew[] = [];
+    let currentBlockNumber = BlockNumber(upToBlockNumber - 1);
+
+    while (currentBlockNumber >= INITIAL_L2_BLOCK_NUM) {
+      const block = await this.blockSource.getL2BlockNew(currentBlockNumber);
+      if (!block || block.header.getSlot() !== slot || block.checkpointNumber !== checkpointNumber) {
+        break;
+      }
+      blocks.unshift(block);
+      currentBlockNumber = BlockNumber(currentBlockNumber - 1);
+    }
+
+    return blocks;
   }
 
   private getReexecuteFailureReason(err: any) {
@@ -259,12 +473,13 @@ export class BlockProposalHandler {
 
   async reexecuteTransactions(
     proposal: BlockProposal,
-    blockNumber: number,
+    blockNumber: BlockNumber,
+    checkpointNumber: CheckpointNumber,
     txs: Tx[],
     l1ToL2Messages: Fr[],
+    previousCheckpointOutHashes: Fr[],
   ): Promise<ReexecuteTransactionsResult> {
-    const { header } = proposal.payload;
-    const { txHashes } = proposal;
+    const { blockHeader, txHashes } = proposal;
 
     // If we do not have all of the transactions, then we should fail
     if (txs.length !== txHashes.length) {
@@ -273,28 +488,47 @@ export class BlockProposalHandler {
       throw new TransactionsNotAvailableError(missingTxHashes);
     }
 
-    // Use the sequencer's block building logic to re-execute the transactions
     const timer = new Timer();
-    const config = this.blockBuilder.getConfig();
-
-    // We source most global variables from the proposal
-    const globalVariables = GlobalVariables.from({
-      slotNumber: proposal.payload.header.slotNumber, // checked in the block proposal validator
-      coinbase: proposal.payload.header.coinbase, // set arbitrarily by the proposer
-      feeRecipient: proposal.payload.header.feeRecipient, // set arbitrarily by the proposer
-      gasFees: proposal.payload.header.gasFees, // validated by the rollup contract
-      blockNumber, // computed from the parent block and checked it does not exist in archiver
-      timestamp: header.timestamp, // checked in the rollup contract against the slot number
+    const slot = proposal.slotNumber;
+    const config = this.checkpointsBuilder.getConfig();
+
+    // Get prior blocks in this checkpoint (same slot and checkpoint number)
+    const priorBlocks = await this.getBlocksInCheckpoint(slot, blockNumber, checkpointNumber);
+
+    // Fork before the block to be built
+    const parentBlockNumber = BlockNumber(blockNumber - 1);
+    using fork = await this.worldState.fork(parentBlockNumber);
+
+    // Build checkpoint constants from proposal (excludes blockNumber and timestamp which are per-block)
+    const constants: CheckpointGlobalVariables = {
       chainId: new Fr(config.l1ChainId),
       version: new Fr(config.rollupVersion),
-    });
+      slotNumber: slot,
+      coinbase: blockHeader.globalVariables.coinbase,
+      feeRecipient: blockHeader.globalVariables.feeRecipient,
+      gasFees: blockHeader.globalVariables.gasFees,
+    };
 
-    const { block, failedTxs } = await this.blockBuilder.buildBlock(txs, l1ToL2Messages, globalVariables, {
-      deadline: this.getReexecutionDeadline(proposal.payload.header.slotNumber.toBigInt(), config),
+    // Create checkpoint builder with prior blocks
+    const checkpointBuilder = await this.checkpointsBuilder.openCheckpoint(
+      checkpointNumber,
+      constants,
+      l1ToL2Messages,
+      previousCheckpointOutHashes,
+      fork,
+      priorBlocks,
+    );
+
+    // Build the new block
+    const deadline = this.getReexecutionDeadline(slot, config);
+    const result = await checkpointBuilder.buildBlock(txs, blockNumber, blockHeader.globalVariables.timestamp, {
+      deadline,
+      expectedEndState: blockHeader.state,
     });
 
+    const { block, failedTxs } = result;
     const numFailedTxs = failedTxs.length;
-    const slot = proposal.slotNumber.toBigInt();
+
     this.log.verbose(`Transaction re-execution complete for slot ${slot}`, {
       numFailedTxs,
       numProposalTxs: txHashes.length,
@@ -313,19 +547,18 @@ export class BlockProposalHandler {
     }
 
     // Throw a ReExStateMismatchError error if state updates do not match
-    const blockPayload = ConsensusPayload.fromBlock(block);
-    if (!blockPayload.equals(proposal.payload)) {
+    // Compare the full block structure (archive and header) from the built block with the proposal
+    const archiveMatches = proposal.archive.equals(block.archive.root);
+    const headerMatches = proposal.blockHeader.equals(block.header);
+    if (!archiveMatches || !headerMatches) {
       this.log.warn(`Re-execution state mismatch for slot ${slot}`, {
-        expected: blockPayload.toInspect(),
-        actual: proposal.payload.toInspect(),
+        expectedArchive: block.archive.root.toString(),
+        actualArchive: proposal.archive.toString(),
+        expectedHeader: block.header.toInspect(),
+        actualHeader: proposal.blockHeader.toInspect(),
       });
       this.metrics?.recordFailedReexecution(proposal);
-      throw new ReExStateMismatchError(
-        proposal.archive,
-        block.archive.root,
-        proposal.payload.stateReference,
-        block.header.state,
-      );
+      throw new ReExStateMismatchError(proposal.archive, block.archive.root);
     }
 
     const reexecutionTimeMs = timer.ms();