@aztec/aztec-node 5.3.0-nightly.20260909 → 5.3.0-nightly.20260910

package/src/aztec-node/next_block/next_block_predictor.ts

@@ -0,0 +1,158 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { L1SyncPoint, L2BlockSource, L2Frontier } from '@aztec/stdlib/block';
+import type { GasFees } from '@aztec/stdlib/gas';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+
+import { NextBlockFeeCache, type NextBlockFeeCacheDeps } from './next_block_fee_cache.js';
+import { type NextBlockPlan, computeBoundaryFeeKey, getClockSlot, planNextBlock } from './next_block_planner.js';
+
+/**
+ * How long a fee quote waits for a boundary refresh before answering with what it already has. Long enough for
+ * a slow but alive L1 RPC; short enough that an L1 outage does not turn every quote into a multi-second RPC.
+ */
+export const QUOTE_MAX_WAIT_MS = 5000;
+
+/** The next block as this node predicts it: how it sits on the chain, plus the globals it would carry. */
+export type NextBlockPrediction = {
+  plan: NextBlockPlan;
+  /** Snapshot the plan was derived from, so callers can pin their own reads to the same instant. */
+  frontier: L2Frontier;
+  globals: GlobalVariables;
+};
+
+/** Dependencies required to build a {@link NextBlockPredictor}. */
+export interface NextBlockPredictorDeps {
+  blockSource: L2BlockSource;
+  feeCache: NextBlockFeeCache;
+  epochCache: EpochCacheInterface;
+  log?: Logger;
+}
+
+/**
+ * Answers "what would the next block look like" for everything on the RPC side: the public simulation forks and
+ * executes against this prediction, and the fee quote reports the fee it carries.
+ *
+ * The plan is re-derived from a fresh archiver snapshot on every call — it is a handful of in-memory reads, and
+ * a stale plan would fork the wrong block, target the wrong checkpoint's L1-to-L2 messages, or miss that an
+ * in-progress checkpoint froze a different fee. Only the L1-derived part, the checkpoint globals of a block that
+ * opens a fresh checkpoint, is cached (see {@link NextBlockFeeCache}).
+ *
+ * Deliberately not used by the sequencer: its slot policy is stricter (it declines to build rather than
+ * predicting inclusion) and a stale fee would make L1 reject its checkpoint.
+ */
+export class NextBlockPredictor {
+  private readonly blockSource: L2BlockSource;
+  private readonly feeCache: NextBlockFeeCache;
+  private readonly epochCache: EpochCacheInterface;
+  private readonly log: Logger;
+
+  constructor(deps: NextBlockPredictorDeps) {
+    this.blockSource = deps.blockSource;
+    this.feeCache = deps.feeCache;
+    this.epochCache = deps.epochCache;
+    this.log = deps.log ?? createLogger('node:next-block-predictor');
+  }
+
+  /**
+   * Builds a predictor together with the fee cache it reads from. It takes the cache's dependencies rather than
+   * {@link NextBlockPredictorDeps} because the cache is constructed here; everything the predictor itself needs is
+   * a subset of them.
+   */
+  public static create(deps: NextBlockFeeCacheDeps): NextBlockPredictor {
+    const feeCache = new NextBlockFeeCache({ ...deps, log: deps.log?.createChild('fee-cache') });
+    return new NextBlockPredictor({
+      blockSource: deps.blockSource,
+      feeCache,
+      epochCache: deps.epochCache,
+      log: deps.log,
+    });
+  }
+
+  public start(pollingIntervalMs?: number): void {
+    this.feeCache.start(pollingIntervalMs);
+  }
+
+  public stop(): Promise<void> {
+    return this.feeCache.stop();
+  }
+
+  /**
+   * Plans the next block and builds the globals it would carry, in one of two ways, mirroring how the sequencer
+   * builds the next block:
+   *
+   * - **Continuing an in-progress checkpoint**: every block in a checkpoint shares the same
+   *   `CheckpointGlobalVariables`, so the latest proposed block's globals are copied verbatim — including the
+   *   proposer's real coinbase and fee recipient — with only the block number bumped. No L1 involved.
+   * - **Opening a new checkpoint**: the globals are priced for the slot the next block will land in, under the
+   *   same overrides plan the sequencer applies, so the simulated mana min fee matches what the sequencer will
+   *   write into the block header. Coinbase and fee recipient stay zero: the future proposer's payout addresses
+   *   are unknowable.
+   *
+   * Waits without a bound for a boundary fee it does not have cached, and surfaces the L1 failure if that read
+   * fails, as a simulation did before this cache existed.
+   */
+  public async predict(): Promise<NextBlockPrediction> {
+    const { frontier, plan, key } = await this.planFromFrontier();
+    const blockNumber = BlockNumber.add(plan.latestBlockNumber, 1);
+    if (!key) {
+      return { plan, frontier, globals: this.copyGlobalsFromLatestBlock(frontier, blockNumber) };
+    }
+
+    const checkpointGlobals = await this.feeCache.getBoundaryGlobals(key, frontier);
+    if (!checkpointGlobals) {
+      throw new Error(`Could not price the next block at slot ${key.targetSlot}: no boundary fee available`);
+    }
+    return { plan, frontier, globals: GlobalVariables.from({ blockNumber, ...checkpointGlobals }) };
+  }
+
+  /**
+   * The mana min fee the next block will charge, for wallets to pad and pay. Mid-checkpoint this is the fee the
+   * in-progress checkpoint froze into its first block, which no forward-looking L1 projection can see. At a
+   * boundary it is the cached L1 price, waited on for at most {@link QUOTE_MAX_WAIT_MS}; undefined when the node
+   * has nothing usable, in which case the caller falls back to the fee provider's projections alone.
+   *
+   * Returns the L1 block the answer describes so the caller can tag its own fee reads with the same anchor.
+   */
+  public async quoteMinFees(): Promise<{ fees: GasFees; l1SyncPoint: L1SyncPoint | undefined } | undefined> {
+    const { frontier, plan, key } = await this.planFromFrontier();
+    if (!key) {
+      const fees = frontier.latestBlockHeader?.globalVariables.gasFees;
+      if (!fees) {
+        this.log.warn(`Cannot quote the next block fee: frontier reports no header for its proposed tip`, {
+          blockNumber: plan.latestBlockNumber,
+        });
+        return undefined;
+      }
+      return { fees, l1SyncPoint: frontier.l1SyncPoint };
+    }
+
+    const checkpointGlobals = await this.feeCache.getBoundaryGlobals(key, frontier, { maxWaitMs: QUOTE_MAX_WAIT_MS });
+    return checkpointGlobals ? { fees: checkpointGlobals.gasFees, l1SyncPoint: frontier.l1SyncPoint } : undefined;
+  }
+
+  /** Plans the next block from a fresh archiver snapshot; `key` is set only when that block opens a checkpoint. */
+  private async planFromFrontier() {
+    const frontier = await this.blockSource.getL2Frontier();
+    const plan = planNextBlock(frontier, getClockSlot(this.epochCache));
+    const key = computeBoundaryFeeKey(plan, frontier.pendingChainValidationStatus);
+    return { frontier, plan, key };
+  }
+
+  /**
+   * The header comes from the same snapshot as the tips, so it cannot describe a different block than the
+   * proposed tip. A missing header at a non-genesis proposed tip is an invariant violation and throws rather
+   * than falling through to the new-checkpoint path: a fork at the proposed tip already contains the ongoing
+   * checkpoint's L1-to-L2 messages, so a caller inserting the next checkpoint's messages would append them a
+   * second time.
+   */
+  private copyGlobalsFromLatestBlock(frontier: L2Frontier, blockNumber: BlockNumber): GlobalVariables {
+    if (!frontier.latestBlockHeader) {
+      throw new Error(
+        `Cannot predict the next block: frontier reports proposed tip ${frontier.tips.proposed.number} but carries no header`,
+      );
+    }
+    return GlobalVariables.from({ ...frontier.latestBlockHeader.globalVariables, blockNumber });
+  }
+}

package/src/aztec-node/next_block/test_helpers.ts

@@ -0,0 +1,115 @@
+import type { FeeHeader } from '@aztec/ethereum/contracts';
+import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import {
+  BlockHash,
+  type L1SyncPoint,
+  type L2Frontier,
+  type L2Tips,
+  type ValidateCheckpointResult,
+} from '@aztec/stdlib/block';
+import { L1PublishedData, type ProposedCheckpointData } from '@aztec/stdlib/checkpoint';
+import { GasFees } from '@aztec/stdlib/gas';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
+
+/** Shape of the frontier snapshot a next-block test wants; every field has a sensible default. */
+export type L2FrontierArgs = {
+  proposed: BlockNumber;
+  checkpointedBlock: BlockNumber;
+  checkpointed: CheckpointNumber;
+  /** Slot of the checkpointed checkpoint, the floor for the next block's slot. Omit for the genesis shape. */
+  checkpointedTipSlot?: SlotNumber;
+  proposedCheckpoint?: ProposedCheckpointData;
+  /** Globals of the proposed tip's header, copied verbatim when the next block continues a checkpoint. */
+  latestBlockGlobals?: { slotNumber: SlotNumber; gasFees?: GasFees };
+  /** Omit the proposed tip's header from the snapshot, an invariant violation the predictor must reject. */
+  omitLatestBlockHeader?: boolean;
+  pendingChainValidationStatus?: ValidateCheckpointResult;
+  /** L1 block the archiver's snapshot reflects; fee reads must be pinned to it. */
+  l1SyncPoint?: L1SyncPoint;
+};
+
+/** Stable per-block hash, so tips and the frontier agree on block identity. */
+export const blockHashOf = (blockNumber: BlockNumber): BlockHash => new BlockHash(new Fr(1000 + blockNumber));
+
+const makeTips = (args: L2FrontierArgs): L2Tips => {
+  const blockId = (number: BlockNumber) => ({ number, hash: blockHashOf(number).toString() });
+  const checkpointId = (number: CheckpointNumber) => ({ number, hash: `0xc${number}` });
+  return {
+    proposed: blockId(args.proposed),
+    checkpointed: { block: blockId(args.checkpointedBlock), checkpoint: checkpointId(args.checkpointed) },
+    proven: { block: blockId(BlockNumber.ZERO), checkpoint: checkpointId(args.checkpointed) },
+    finalized: { block: blockId(BlockNumber.ZERO), checkpoint: checkpointId(args.checkpointed) },
+  };
+};
+
+export const makeFrontier = (args: L2FrontierArgs): L2Frontier => ({
+  tips: makeTips(args),
+  proposedCheckpoint: args.proposedCheckpoint,
+  l1SyncPoint: args.l1SyncPoint,
+  latestBlockHeader:
+    args.omitLatestBlockHeader || !args.latestBlockGlobals
+      ? undefined
+      : BlockHeader.empty({
+          globalVariables: GlobalVariables.empty({
+            blockNumber: args.proposed,
+            slotNumber: args.latestBlockGlobals.slotNumber,
+            gasFees: args.latestBlockGlobals.gasFees ?? GasFees.empty(),
+          }),
+        }),
+  checkpointedCheckpoint:
+    args.checkpointedTipSlot === undefined
+      ? undefined
+      : {
+          header: CheckpointHeader.empty({ slotNumber: args.checkpointedTipSlot }),
+          l1: new L1PublishedData(1n, 0n, `0x`),
+        },
+  pendingChainValidationStatus: args.pendingChainValidationStatus ?? { valid: true },
+});
+
+export function makeFeeHeader(): FeeHeader {
+  return { excessMana: 0n, manaUsed: 0n, ethPerFeeAsset: 0n, congestionCost: 0n, proverCost: 0n };
+}
+
+export function makeProposedCheckpointData(args: {
+  checkpointNumber: CheckpointNumber;
+  lastBlock: BlockNumber;
+  slotNumber?: SlotNumber;
+  archiveRoot?: Fr;
+  totalManaUsed?: bigint;
+  feeAssetPriceModifier?: bigint;
+  checkpointOutHash?: Fr;
+}): ProposedCheckpointData {
+  return {
+    checkpointNumber: args.checkpointNumber,
+    header: CheckpointHeader.empty({ slotNumber: args.slotNumber ?? SlotNumber(0) }),
+    startBlock: args.lastBlock,
+    blockCount: 1,
+    totalManaUsed: args.totalManaUsed ?? 555n,
+    feeAssetPriceModifier: args.feeAssetPriceModifier ?? 7n,
+    archive: new AppendOnlyTreeSnapshot(args.archiveRoot ?? Fr.ZERO, 0),
+    checkpointOutHash: args.checkpointOutHash ?? Fr.fromString('0xfeed'),
+  };
+}
+
+export function makeInvalidStatus(firstInvalid: CheckpointNumber): ValidateCheckpointResult {
+  return {
+    valid: false,
+    checkpoint: {
+      archive: Fr.random(),
+      lastArchive: Fr.random(),
+      slotNumber: SlotNumber(10),
+      checkpointNumber: firstInvalid,
+      timestamp: 0n,
+    },
+    committee: [],
+    epoch: EpochNumber.ZERO,
+    seed: 0n,
+    attestors: [],
+    attestations: [],
+    verbatimAttestations: { signatureIndices: '0x', signaturesOrAddresses: '0x' },
+    reason: 'insufficient-attestations',
+  };
+}

package/src/aztec-node/node_public_calls_simulator.ts

@@ -1,39 +1,26 @@
 import { L1ToL2MessagesNotReadyError } from '@aztec/archiver';
-import { PROPOSER_PIPELINING_SLOT_OFFSET } from '@aztec/epoch-cache';
-import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import {
-  type RollupContract,
-  SimulationOverridesBuilder,
-  type SimulationOverridesPlan,
-} from '@aztec/ethereum/contracts';
-import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
-import { compactArray } from '@aztec/foundation/collection';
+import type { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { EthAddress } from '@aztec/foundation/eth-address';
 import { BadRequestError } from '@aztec/foundation/json-rpc';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 import { isErrorClass } from '@aztec/foundation/types';
 import { PublicContractsDB, PublicProcessorFactory } from '@aztec/simulator/server';
 import { CollectionLimitsConfig, PublicSimulatorConfig } from '@aztec/stdlib/avm';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockSource, L2Tips } from '@aztec/stdlib/block';
-import { type ProposedCheckpointData, buildCheckpointSimulationOverridesPlan } from '@aztec/stdlib/checkpoint';
+import { BlockHash } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { type L1ToL2MessageSource, appendL1ToL2MessagesToTree } from '@aztec/stdlib/messaging';
-import type { CoordinationSignatureContext } from '@aztec/stdlib/p2p';
-import {
-  type GlobalVariableBuilder,
-  GlobalVariables,
-  PublicSimulationOutput,
-  type SimulationOverrides,
-  type Tx,
-} from '@aztec/stdlib/tx';
+import { type GlobalVariables, PublicSimulationOutput, type SimulationOverrides, type Tx } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+import { WorldStateSynchronizerError } from '@aztec/world-state';
 
+import type { NextBlockPlan, NextBlockPredictor } from './next_block/index.js';
 import { applyPublicDataOverrides } from './public_data_overrides.js';
 
+/** Attempts at planning the next block on a chain the world state agrees with, before giving up. */
+const MAX_PREDICTION_ATTEMPTS = 2;
+
 /** Config fields the simulator needs — a narrow subset of `AztecNodeConfig`. */
 export interface NodePublicCallsSimulatorConfig {
   /** Maximum total gas limit accepted for an incoming simulation. */
@@ -44,63 +31,45 @@ export interface NodePublicCallsSimulatorConfig {
 
 /** Dependencies required to build a {@link NodePublicCallsSimulator}. */
 export interface NodePublicCallsSimulatorDeps {
-  blockSource: L2BlockSource;
   worldStateSynchronizer: WorldStateSynchronizer;
   l1ToL2MessageSource: L1ToL2MessageSource;
   contractDataSource: ContractDataSource;
-  globalVariableBuilder: GlobalVariableBuilder;
-  /**
-   * Rollup contract used to build the fee-relevant L1 state overrides when opening a new checkpoint.
-   * Only needed when a proposed parent checkpoint exists (pipelining) or the pending chain is invalid;
-   * may be omitted in environments that never reach those states (e.g. TXE). When omitted, those paths
-   * degrade to a pinned-tips plan (non-pipelined fees) instead.
-   */
-  rollupContract?: RollupContract;
-  epochCache: EpochCacheInterface;
-  signatureContext: CoordinationSignatureContext;
+  predictor: NextBlockPredictor;
   config: NodePublicCallsSimulatorConfig;
   telemetry?: TelemetryClient;
   log?: Logger;
 }
 
+/** The next block, planned and priced, on a chain the world state has caught up with. */
+type PreparedNextBlock = {
+  plan: NextBlockPlan;
+  globals: GlobalVariables;
+  /** L1-to-L2 messages of the checkpoint the next block opens; undefined when it continues one. */
+  messages: Fr[] | undefined;
+};
+
 /**
  * Simulates the public part of a transaction against a fresh world-state fork.
  *
- * Extracted from `AztecNodeService` so the slot/globals selection can be unit-tested without
- * standing up the whole node, and to keep `server.ts` smaller.
- *
- * The simulator picks globals in one of two ways, mirroring how the sequencer builds the next block:
- * - **When the next block continues an in-progress checkpoint** (the latest proposed block is ahead of
- *   the proposed-checkpoint frontier): every block in a checkpoint shares the same
- *   `CheckpointGlobalVariables`, so we copy the latest proposed block's globals verbatim and only
- *   bump the block number. No L1 calls, no L1-to-L2 message insertion.
- * - **When the next block opens a new checkpoint** (the latest proposed block coincides with the
- *   proposed-checkpoint frontier): we compute fresh globals for the slot the next block will land in,
- *   applying the same `SimulationOverridesPlan` the sequencer applies so the simulated mana min fee
- *   matches what the sequencer will write into the block header.
+ * Extracted from `AztecNodeService` so forking and execution can be unit-tested without standing up the whole
+ * node, and to keep `server.ts` smaller. Which block is simulated, and the globals it carries, are decided by
+ * the {@link NextBlockPredictor}: the simulator's job is to fork the chain that plan describes, insert the
+ * L1-to-L2 messages a checkpoint-opening block would see, and run the processor.
  */
 export class NodePublicCallsSimulator {
-  private readonly blockSource: L2BlockSource;
   private readonly worldStateSynchronizer: WorldStateSynchronizer;
   private readonly l1ToL2MessageSource: L1ToL2MessageSource;
   private readonly contractDataSource: ContractDataSource;
-  private readonly globalVariableBuilder: GlobalVariableBuilder;
-  private readonly rollupContract: RollupContract | undefined;
-  private readonly epochCache: EpochCacheInterface;
-  private readonly signatureContext: CoordinationSignatureContext;
+  private readonly predictor: NextBlockPredictor;
   private readonly config: NodePublicCallsSimulatorConfig;
   private readonly telemetry: TelemetryClient;
   private readonly log: Logger;
 
   constructor(deps: NodePublicCallsSimulatorDeps) {
-    this.blockSource = deps.blockSource;
     this.worldStateSynchronizer = deps.worldStateSynchronizer;
     this.l1ToL2MessageSource = deps.l1ToL2MessageSource;
     this.contractDataSource = deps.contractDataSource;
-    this.globalVariableBuilder = deps.globalVariableBuilder;
-    this.rollupContract = deps.rollupContract;
-    this.epochCache = deps.epochCache;
-    this.signatureContext = deps.signatureContext;
+    this.predictor = deps.predictor;
     this.config = deps.config;
     this.telemetry = deps.telemetry ?? getTelemetryClient();
     this.log = deps.log ?? createLogger('node:public-calls-simulator');
@@ -132,29 +101,7 @@ export class NodePublicCallsSimulator {
     }
 
     const txHash = tx.getTxHash();
-    const [l2Tips, proposedCheckpointData] = await Promise.all([
-      this.blockSource.getL2Tips(),
-      this.blockSource.getProposedCheckpointData(),
-    ]);
-    const latestBlockNumber = l2Tips.proposed.number;
-    const blockNumber = BlockNumber.add(latestBlockNumber, 1);
-
-    // Terminating block of the proposed-checkpoint frontier. `getProposedCheckpointData()` returns the
-    // leading proposed (not-yet-L1-confirmed) checkpoint, whose last block is `startBlock + blockCount
-    // - 1`; with no proposed checkpoint the frontier coincides with the checkpointed tip.
-    const proposedCheckpointLastBlock = proposedCheckpointData
-      ? BlockNumber.add(proposedCheckpointData.startBlock, proposedCheckpointData.blockCount - 1)
-      : l2Tips.checkpointed.block.number;
-
-    // The next block continues the in-progress checkpoint when the latest proposed block is ahead of
-    // the proposed-checkpoint terminating block; it opens a new checkpoint when they coincide.
-    const atCheckpointBoundary = proposedCheckpointLastBlock === l2Tips.proposed.number;
-
-    // `targetCheckpoint` is the checkpoint whose L1-to-L2 messages must be inserted into the fork
-    // before simulation. Only set when opening a new checkpoint, where the next block is its first block.
-    const { globalVariables: newGlobalVariables, targetCheckpoint } = atCheckpointBoundary
-      ? await this.buildGlobalVariablesForNewCheckpoint(l2Tips, proposedCheckpointData, blockNumber)
-      : { globalVariables: await this.copyGlobalVariablesFromLatestProposedBlock(latestBlockNumber, blockNumber) };
+    const { plan, globals, messages } = await this.prepareNextBlock();
 
     const publicProcessorFactory = new PublicProcessorFactory(
       this.contractDataSource,
@@ -164,26 +111,20 @@ export class NodePublicCallsSimulator {
     );
 
     this.log.verbose(`Simulating public calls for tx ${txHash}`, {
-      globalVariables: newGlobalVariables.toInspect(),
+      globalVariables: globals.toInspect(),
       txHash,
-      blockNumber,
-      atCheckpointBoundary,
+      blockNumber: globals.blockNumber,
+      atCheckpointBoundary: plan.newCheckpoint !== undefined,
     });
 
-    // Ensure world-state has caught up with the latest block we loaded from the archiver
-    await this.worldStateSynchronizer.syncImmediate(latestBlockNumber);
-
-    const nextCheckpointMessages = await this.getNextCheckpointMessages(targetCheckpoint);
-
     // Request a new fork of the world state at the latest block number, and apply any overrides and next checkpoint messages to it before simulation
-    await using merkleTreeFork = await this.worldStateSynchronizer.fork(latestBlockNumber);
+    await using merkleTreeFork = await this.worldStateSynchronizer.fork(plan.latestBlockNumber);
 
-    if (nextCheckpointMessages !== undefined) {
-      this.log.debug(
-        `Appending ${nextCheckpointMessages.length} L1-to-L2 messages to the world state tree for the next checkpoint`,
-        { checkpointNumber: targetCheckpoint },
-      );
-      await appendL1ToL2MessagesToTree(merkleTreeFork, nextCheckpointMessages);
+    if (messages !== undefined) {
+      this.log.debug(`Appending ${messages.length} L1-to-L2 messages to the world state tree for the next checkpoint`, {
+        checkpointNumber: plan.newCheckpoint?.targetCheckpoint,
+      });
+      await appendL1ToL2MessagesToTree(merkleTreeFork, messages);
     }
 
     await applyPublicDataOverrides(merkleTreeFork, overrides?.publicStorage);
@@ -203,7 +144,7 @@ export class NodePublicCallsSimulator {
     if (overrides?.contracts) {
       contractsDB.addContracts(Object.values(overrides.contracts).map(({ instance }) => instance));
     }
-    const processor = publicProcessorFactory.create(merkleTreeFork, newGlobalVariables, config, contractsDB);
+    const processor = publicProcessorFactory.create(merkleTreeFork, globals, config, contractsDB);
 
     // REFACTOR: Consider merging ProcessReturnValues into ProcessedTx
     const [processedTxs, failedTxs, _usedTxs, returns, debugLogs] = await processor.process([tx]);
@@ -224,6 +165,40 @@ export class NodePublicCallsSimulator {
     );
   }
 
+  /**
+   * Plans and prices the next block, and brings the world state up to the block that plan builds on. Retries
+   * once when the world state reaches the planned height with a different block: a prune between the archiver
+   * read and the sync leaves the two disagreeing, and forking anyway would simulate against state the plan's
+   * globals do not belong to. Any other sync failure propagates as is.
+   */
+  private async prepareNextBlock(): Promise<PreparedNextBlock> {
+    for (let attempt = 0; attempt < MAX_PREDICTION_ATTEMPTS; attempt++) {
+      const { plan, globals } = await this.predictor.predict();
+      try {
+        const [, messages] = await Promise.all([
+          // Passing the hash makes the sync fork-aware: it waits for the block the plan builds on and throws if
+          // the world state ended up with a different block at that height.
+          this.worldStateSynchronizer.syncImmediate(plan.latestBlockNumber, BlockHash.fromString(plan.latestBlockHash)),
+          this.getNextCheckpointMessages(plan.newCheckpoint?.targetCheckpoint),
+        ]);
+        return { plan, globals, messages };
+      } catch (err) {
+        if (!isBlockHashMismatch(err)) {
+          throw err;
+        }
+        this.log.warn(`World state disagrees with the planned next block, replanning`, {
+          blockNumber: plan.latestBlockNumber,
+          blockHash: plan.latestBlockHash,
+          error: err.message,
+        });
+      }
+    }
+
+    throw new Error(
+      `Cannot simulate public calls: world state and archiver disagree on the latest block (prune race), retry`,
+    );
+  }
+
   /**
    * Fetches the next checkpoint's L1-to-L2 messages to insert into the fork before simulation. Only set
    * when opening a new checkpoint; when continuing an in-progress checkpoint the ongoing checkpoint's
@@ -254,130 +229,15 @@ export class NodePublicCallsSimulator {
       return undefined;
     }
   }
+}
 
-  /**
-   * Continues an in-progress checkpoint: the next block extends the checkpoint the latest proposed
-   * block belongs to. Every block in a checkpoint shares the same `CheckpointGlobalVariables`, so the
-   * next block's globals are the latest proposed block's globals with only the block number bumped —
-   * including the proposer's real coinbase/feeRecipient. No L1 reads and no L1-to-L2 message insertion
-   * happen here.
-   *
-   * A missing header means the archiver reported a proposed tip via `getL2Tips` but no longer has its
-   * data (a torn snapshot). We throw a transient/retryable error rather than treating the next block as
-   * opening a new checkpoint: the fork at `latestBlockNumber` already contains the ongoing checkpoint's
-   * L1-to-L2 messages, so inserting the next checkpoint's messages would append them a second time.
-   */
-  private async copyGlobalVariablesFromLatestProposedBlock(
-    latestBlockNumber: BlockNumber,
-    blockNumber: BlockNumber,
-  ): Promise<GlobalVariables> {
-    const latestBlockData = await this.blockSource.getBlockData({ number: latestBlockNumber });
-    if (!latestBlockData) {
-      throw new Error(
-        `Cannot simulate public calls: latest proposed block ${latestBlockNumber} has no header on this node ` +
-          `(torn archiver snapshot); retry`,
-      );
-    }
-    return GlobalVariables.from({ ...latestBlockData.header.globalVariables, blockNumber });
-  }
-
-  /**
-   * Opens a new checkpoint: the next block is the first of a fresh checkpoint. Picks the slot the next
-   * block will land in, mirroring the sequencer, and builds the same `SimulationOverridesPlan` the
-   * sequencer applies so the simulated mana min fee matches what the sequencer will write into the
-   * block header. Coinbase and fee recipient stay zero (we cannot know the future proposer's payout
-   * addresses), unlike continuing an in-progress checkpoint which inherits the real ones from the
-   * proposed header. Returns the target checkpoint so the caller inserts that checkpoint's L1-to-L2
-   * messages into the fork.
-   */
-  private async buildGlobalVariablesForNewCheckpoint(
-    l2Tips: L2Tips,
-    proposedCheckpointData: ProposedCheckpointData | undefined,
-    blockNumber: BlockNumber,
-  ): Promise<{ globalVariables: GlobalVariables; targetCheckpoint: CheckpointNumber }> {
-    const checkpointedCheckpointNumber = l2Tips.checkpointed.checkpoint.number;
-    // The new checkpoint sits on top of the proposed one when pipelining, otherwise on the
-    // checkpointed tip. The target slot and the overrides plan both derive from the single
-    // `proposedCheckpointData` read, so they cannot disagree about the proposed parent.
-    const proposedCheckpointNumber = proposedCheckpointData?.checkpointNumber ?? checkpointedCheckpointNumber;
-
-    const targetSlot = this.computeTargetSlot(proposedCheckpointData);
-    const plan = await this.buildSimulationOverridesPlan(proposedCheckpointData, checkpointedCheckpointNumber);
-
-    const checkpointGlobalVariables = await this.globalVariableBuilder.buildCheckpointGlobalVariables(
-      EthAddress.ZERO,
-      AztecAddress.ZERO,
-      targetSlot,
-      plan,
-    );
-
-    return {
-      globalVariables: GlobalVariables.from({ blockNumber, ...checkpointGlobalVariables }),
-      targetCheckpoint: CheckpointNumber(proposedCheckpointNumber + 1),
-    };
-  }
-
-  /**
-   * Slot the next block will land in. The first term is the sequencer's exact formula
-   * (`getEpochAndSlotInNextL1Slot().slot + PROPOSER_PIPELINING_SLOT_OFFSET`). The `max` with
-   * `proposedCheckpointSlot + 1` is an RPC-side approximation of the next build: when a proposed
-   * checkpoint is gossiped before its L1 slot starts, the next build (once its wall clock arrives)
-   * will target `parentSlot + 1`. The sequencer never advances its own target past wall clock — it
-   * just declines to build — so this is a prediction of inclusion globals, not literal sequencer
-   * behavior. The parent slot comes from the proposed checkpoint header so the slot and the
-   * overrides plan cannot derive from different snapshots.
-   */
-  private computeTargetSlot(proposedCheckpointData: ProposedCheckpointData | undefined): SlotNumber {
-    const slotFromNextL1Timestamp =
-      this.epochCache.getEpochAndSlotInNextL1Slot().slot + PROPOSER_PIPELINING_SLOT_OFFSET;
-    const slotAfterProposedCheckpoint = proposedCheckpointData
-      ? proposedCheckpointData.header.slotNumber + 1
-      : undefined;
-    return SlotNumber(Math.max(...compactArray([slotFromNextL1Timestamp, slotAfterProposedCheckpoint])));
-  }
-
-  /**
-   * Builds the chain-state overrides plan the simulator passes to `buildCheckpointGlobalVariables`,
-   * mirroring the sequencer (which always pins tips to neutralize prunes). When pipelining, the plan
-   * carries the proposed parent's archive, temp-checkpoint-log cell, and locally-derived fee header.
-   *
-   * Both the pipelining and invalid-pending-chain paths need a rollup contract for the L1 fee reads.
-   * Environments that omit it (e.g. TXE, which never has a proposed checkpoint and whose pending chain
-   * is always valid) fall back to pinning both pending and proven tips to the checkpointed tip, which
-   * neutralizes prunes in fee computation at the cost of non-pipelined fees.
-   */
-  private async buildSimulationOverridesPlan(
-    proposedCheckpointData: ProposedCheckpointData | undefined,
-    checkpointedCheckpointNumber: CheckpointNumber,
-  ): Promise<SimulationOverridesPlan | undefined> {
-    const rollup = this.rollupContract;
-    if (rollup) {
-      if (proposedCheckpointData) {
-        return buildCheckpointSimulationOverridesPlan({
-          checkpointNumber: CheckpointNumber(proposedCheckpointData.checkpointNumber + 1),
-          proposedCheckpointData,
-          checkpointedCheckpointNumber,
-          rollup,
-          signatureContext: this.signatureContext,
-          log: this.log,
-        });
-      }
-
-      const validationStatus = await this.blockSource.getPendingChainValidationStatus();
-      if (!validationStatus.valid) {
-        return buildCheckpointSimulationOverridesPlan({
-          checkpointNumber: CheckpointNumber(checkpointedCheckpointNumber + 1),
-          invalidateToPendingCheckpointNumber: CheckpointNumber(validationStatus.checkpoint.checkpointNumber - 1),
-          checkpointedCheckpointNumber,
-          rollup,
-          signatureContext: this.signatureContext,
-          log: this.log,
-        });
-      }
-    }
-
-    return new SimulationOverridesBuilder()
-      .withChainTips({ pending: checkpointedCheckpointNumber, proven: checkpointedCheckpointNumber })
-      .build();
-  }
+/** The sync reached the planned height but found a different block there, so the chain moved under the plan. */
+function isBlockHashMismatch(err: unknown): err is WorldStateSynchronizerError {
+  return (
+    isErrorClass(err, WorldStateSynchronizerError) &&
+    typeof err.cause === 'object' &&
+    err.cause !== null &&
+    'reason' in err.cause &&
+    err.cause.reason === 'block_hash_mismatch'
+  );
 }