fix(aztec-node): pipelining-aware slot and fee simulation in simulatePublicCalls (#24031)

## Motivation

`AztecNodeService.simulatePublicCalls` built globals for a fictional
next block using "the L2 slot at the next L1 slot" with no pipelining
offset and no L1 state overrides. Under proposer pipelining this
simulates one slot too early and computes the mana min fee against the
current L1 state, ignoring the gossiped proposed checkpoint that will
land before the simulated block does — producing wrong L1-to-L2 message
sets and wrong fees for wallet-side estimation.

## Approach

The simulation now mirrors how the sequencer picks the build slot and
fee inputs (`sequencer.ts` / `checkpoint_proposal_job.ts` / the
checkpoint simulation overrides builder), split into two cases:

- **Mid-checkpoint continuation** (proposed blocks past the last
checkpoint proposal): every block in a checkpoint shares the same
checkpoint-wide globals, so the next block's globals are copied verbatim
from the latest proposed block header with only the block number bumped.
No L1 reads, no L1-to-L2 message insertion. A missing header fails the
request rather than falling through, since the fork already contains the
ongoing checkpoint's messages and a fall-through would insert them
twice.
- **Opening a new checkpoint**: the target slot is the sequencer's
formula (`next-L1-slot L2 slot + PROPOSER_PIPELINING_SLOT_OFFSET`),
maxed with `proposedCheckpointSlot + 1` when a checkpoint proposal is
pending L1. The same `SimulationOverridesPlan` the sequencer uses is
always applied: parent archive/temp-log/fee-header overrides derived
from the proposed checkpoint when pipelining, tips pinned to the
rollback target when the pending chain is invalid, and tips pinned to
the checkpointed tip otherwise (neutralizing prunes in fee computation).
Both the target slot and the plan derive from a single
`ProposedCheckpointData` read so they cannot disagree about the parent.

The simulator trusts archiver tips verbatim — no staleness guards. Stale
proposed blocks and checkpoints are the archiver's responsibility
(orphan pruning and L1-authoritative eviction), so a stale tip
mis-simulates only transiently.

The logic moves out of `AztecNodeService` into a new
`NodePublicCallsSimulator` class so the slot/globals selection is
unit-testable without standing up a node. Supersedes #23389.

Caching of the L1 fee queries introduced here is tracked separately in
A-1208.

**Structured for commit-by-commit review:**
1. `refactor(aztec-node)`: pure move of the existing
`simulatePublicCalls` code (and its tests) into
`NodePublicCallsSimulator` — no behavior change.
2. `fix(aztec-node)`: the actual behavior changes described above.
3. `refactor`: moves the checkpoint simulation overrides builder from
sequencer-client to `@aztec/stdlib/checkpoint` so the node consumes it
from a shared home.

## API changes

- `GlobalVariableBuilder.buildGlobalVariables` is removed from the
stdlib interface and its implementations (sequencer-client, TXE); slot
selection is now the caller's job and only
`buildCheckpointGlobalVariables` remains.
- `buildCheckpointSimulationOverridesPlan` and
`computePipelinedParentFeeHeader` move from sequencer-client internals
to `@aztec/stdlib/checkpoint`, shared by the sequencer and the node
simulator.
- `AztecNodeService` constructor takes an optional `RollupContract`;
environments that never see a proposed checkpoint or an invalid pending
chain (TXE) may omit it, and the simulator fails loudly if those paths
are reached without it.

## Changes

- **aztec-node**: new `NodePublicCallsSimulator` with the two-case
globals selection and always-on overrides plan; `simulatePublicCalls`
reduced to a thin delegate.
- **aztec-node (tests)**: 12 unit tests covering verbatim mid-checkpoint
continuation, the missing-header guard, the pipelining offset,
parent-slot/override derivation from the proposed checkpoint data,
torn-snapshot fallback, invalid-pending-chain tips pinning, message
insertion semantics, and the rollup-contract invariant.
- **stdlib**: gains `checkpoint/simulation_overrides.ts` (moved from
sequencer-client, with its unit tests); `buildGlobalVariables` removed
from the `GlobalVariableBuilder` interface.
- **sequencer-client**: imports the overrides builder from stdlib;
`buildGlobalVariables` removed from the implementation.
- **txe**: `buildGlobalVariables` removed; TXE node construction passes
no rollup contract.

Fixes A-1063

Author: spalladino

yarn-project/aztec-node/src/aztec-node/node_public_calls_simulator.test.ts

@@ -242,6 +242,7 @@ describe('aztec node', () => {
       12345,
       rollupVersion.toNumber(),
       globalVariablesBuilder,
+      rollupContract,
       feeProvider,
       epochCache,
       getPackageVersion(),
@@ -709,220 +710,6 @@ describe('aztec node', () => {
     });
   });
 
-  describe('simulatePublicCalls', () => {
-    const mockNextL1Slot = (slot: SlotNumber) => {
-      jest.spyOn(epochCache, 'getEpochAndSlotInNextL1Slot').mockReturnValue({
-        epoch: EpochNumber(0),
-        slot,
-        ts: 0n,
-        nowSeconds: BigInt(NOW_S),
-      });
-    };
-
-    const makeSimulationBlockData = (
-      blockNumber: BlockNumber,
-      slotNumber: SlotNumber,
-      checkpointNumber = CheckpointNumber(1),
-    ): BlockData => ({
-      header: BlockHeader.empty({
-        globalVariables: GlobalVariables.empty({ blockNumber, slotNumber }),
-      }),
-      archive: L2Block.empty().archive,
-      blockHash: BlockHash.random(),
-      checkpointNumber,
-      indexWithinCheckpoint: IndexWithinCheckpoint(0),
-    });
-
-    it('refuses to simulate public calls if the gas limit is too high', async () => {
-      const tx = await mockTxForRollup(0x10000);
-      unfreeze(tx.data.constants.txContext.gasSettings.gasLimits).l2Gas = 1e12;
-      await expect(node.simulatePublicCalls(tx)).rejects.toThrow(/gas/i);
-    });
-
-    it('uses the slot after the proposed checkpoint when it is later than the next L1 timestamp slot', async () => {
-      const tx = await mockTxForRollup(0x10000);
-      const checkpointNumber = CheckpointNumber(1);
-      const proposedCheckpointBlockNumber = BlockNumber(9);
-      const targetSlot = SlotNumber(10);
-      l2BlockSource.getL2Tips.mockResolvedValue(makeTips({ proposed: proposedCheckpointBlockNumber }));
-      l2BlockSource.getProposedCheckpointData.mockResolvedValue(
-        makeProposedCheckpoint({
-          checkpointNumber,
-          blockNumber: proposedCheckpointBlockNumber,
-          slotNumber: SlotNumber(9),
-        }),
-      );
-      mockNextL1Slot(SlotNumber(5));
-      globalVariablesBuilder.buildCheckpointGlobalVariables.mockResolvedValue({
-        chainId,
-        version: rollupVersion,
-        slotNumber: targetSlot,
-        timestamp: 0n,
-        coinbase: EthAddress.ZERO,
-        feeRecipient: AztecAddress.ZERO,
-        gasFees: GasFees.empty(),
-      });
-
-      await expect(node.simulatePublicCalls(tx)).rejects.toThrow();
-
-      // Slot is read from the proposed checkpoint payload header, so no block fetch is needed for it.
-      expect(globalVariablesBuilder.buildGlobalVariables).not.toHaveBeenCalled();
-      expect(globalVariablesBuilder.buildCheckpointGlobalVariables).toHaveBeenCalledWith(
-        EthAddress.ZERO,
-        AztecAddress.ZERO,
-        targetSlot,
-      );
-    });
-
-    it('uses the next L1 timestamp slot when it is later than the slot after the proposed checkpoint', async () => {
-      const tx = await mockTxForRollup(0x10000);
-      const checkpointNumber = CheckpointNumber(1);
-      const proposedCheckpointBlockNumber = BlockNumber(9);
-      const targetSlot = SlotNumber(12);
-      l2BlockSource.getL2Tips.mockResolvedValue(makeTips({ proposed: proposedCheckpointBlockNumber }));
-      l2BlockSource.getProposedCheckpointData.mockResolvedValue(
-        makeProposedCheckpoint({
-          checkpointNumber,
-          blockNumber: proposedCheckpointBlockNumber,
-          slotNumber: SlotNumber(9),
-        }),
-      );
-      mockNextL1Slot(targetSlot);
-      globalVariablesBuilder.buildCheckpointGlobalVariables.mockResolvedValue({
-        chainId,
-        version: rollupVersion,
-        slotNumber: targetSlot,
-        timestamp: 0n,
-        coinbase: EthAddress.ZERO,
-        feeRecipient: AztecAddress.ZERO,
-        gasFees: GasFees.empty(),
-      });
-
-      await expect(node.simulatePublicCalls(tx)).rejects.toThrow();
-
-      expect(globalVariablesBuilder.buildGlobalVariables).not.toHaveBeenCalled();
-      expect(globalVariablesBuilder.buildCheckpointGlobalVariables).toHaveBeenCalledWith(
-        EthAddress.ZERO,
-        AztecAddress.ZERO,
-        targetSlot,
-      );
-    });
-
-    it('uses the latest proposed block slot when it is ahead of the proposed checkpoint', async () => {
-      const tx = await mockTxForRollup(0x10000);
-      const checkpointNumber = CheckpointNumber(1);
-      const proposedCheckpointBlockNumber = BlockNumber(9);
-      const latestProposedBlockNumber = BlockNumber(12);
-      const targetSlot = SlotNumber(12);
-      l2BlockSource.getL2Tips.mockResolvedValue(makeTips({ proposed: latestProposedBlockNumber }));
-      l2BlockSource.getProposedCheckpointData.mockResolvedValue(
-        makeProposedCheckpoint({
-          checkpointNumber,
-          blockNumber: proposedCheckpointBlockNumber,
-          slotNumber: SlotNumber(9),
-        }),
-      );
-      l2BlockSource.getBlockData.mockResolvedValue(
-        makeSimulationBlockData(latestProposedBlockNumber, targetSlot, checkpointNumber),
-      );
-      mockNextL1Slot(SlotNumber(5));
-      globalVariablesBuilder.buildCheckpointGlobalVariables.mockResolvedValue({
-        chainId,
-        version: rollupVersion,
-        slotNumber: targetSlot,
-        timestamp: 0n,
-        coinbase: EthAddress.ZERO,
-        feeRecipient: AztecAddress.ZERO,
-        gasFees: GasFees.empty(),
-      });
-
-      await expect(node.simulatePublicCalls(tx)).rejects.toThrow();
-
-      // The latest proposed block is ahead of the proposed checkpoint, so its slot is fetched.
-      expect(l2BlockSource.getBlockData).toHaveBeenCalledWith({ number: latestProposedBlockNumber });
-      expect(globalVariablesBuilder.buildGlobalVariables).not.toHaveBeenCalled();
-      expect(globalVariablesBuilder.buildCheckpointGlobalVariables).toHaveBeenCalledWith(
-        EthAddress.ZERO,
-        AztecAddress.ZERO,
-        targetSlot,
-      );
-    });
-
-    it('disregards missing proposed block slots and uses the next L1 timestamp slot', async () => {
-      const tx = await mockTxForRollup(0x10000);
-      const checkpointNumber = CheckpointNumber(1);
-      const proposedCheckpointBlockNumber = BlockNumber(9);
-      const latestProposedBlockNumber = BlockNumber(12);
-      const targetSlot = SlotNumber(13);
-      l2BlockSource.getL2Tips.mockResolvedValue(makeTips({ proposed: latestProposedBlockNumber }));
-      l2BlockSource.getProposedCheckpointData.mockResolvedValue(
-        makeProposedCheckpoint({
-          checkpointNumber,
-          blockNumber: proposedCheckpointBlockNumber,
-          slotNumber: SlotNumber(9),
-        }),
-      );
-      l2BlockSource.getBlockData.mockResolvedValue(undefined);
-      mockNextL1Slot(targetSlot);
-      globalVariablesBuilder.buildCheckpointGlobalVariables.mockResolvedValue({
-        chainId,
-        version: rollupVersion,
-        slotNumber: targetSlot,
-        timestamp: 0n,
-        coinbase: EthAddress.ZERO,
-        feeRecipient: AztecAddress.ZERO,
-        gasFees: GasFees.empty(),
-      });
-
-      await expect(node.simulatePublicCalls(tx)).rejects.toThrow();
-
-      // Latest proposed block slot is unavailable; falls back to the next L1 timestamp slot.
-      expect(l2BlockSource.getBlockData).toHaveBeenCalledWith({ number: latestProposedBlockNumber });
-      expect(globalVariablesBuilder.buildGlobalVariables).not.toHaveBeenCalled();
-      expect(globalVariablesBuilder.buildCheckpointGlobalVariables).toHaveBeenCalledWith(
-        EthAddress.ZERO,
-        AztecAddress.ZERO,
-        targetSlot,
-      );
-    });
-
-    it('treats slot zero as a valid proposed checkpoint slot', async () => {
-      const tx = await mockTxForRollup(0x10000);
-      const checkpointNumber = CheckpointNumber(0);
-      const proposedCheckpointBlockNumber = BlockNumber(0);
-      const targetSlot = SlotNumber(1);
-      // No proposed checkpoint leads the frontier; the proposed-checkpoint frontier falls back to the
-      // checkpointed tip (block 0, slot 0), whose slot is read via getBlockData.
-      l2BlockSource.getL2Tips.mockResolvedValue(
-        makeTips({ proposed: proposedCheckpointBlockNumber, checkpointed: checkpointNumber }),
-      );
-      l2BlockSource.getProposedCheckpointData.mockResolvedValue(undefined);
-      l2BlockSource.getBlockData.mockResolvedValue(
-        makeSimulationBlockData(proposedCheckpointBlockNumber, SlotNumber(0), checkpointNumber),
-      );
-      mockNextL1Slot(SlotNumber(0));
-      globalVariablesBuilder.buildCheckpointGlobalVariables.mockResolvedValue({
-        chainId,
-        version: rollupVersion,
-        slotNumber: targetSlot,
-        timestamp: 0n,
-        coinbase: EthAddress.ZERO,
-        feeRecipient: AztecAddress.ZERO,
-        gasFees: GasFees.empty(),
-      });
-
-      await expect(node.simulatePublicCalls(tx)).rejects.toThrow();
-
-      expect(l2BlockSource.getBlockData).toHaveBeenCalledWith({ number: proposedCheckpointBlockNumber });
-      expect(globalVariablesBuilder.buildGlobalVariables).not.toHaveBeenCalled();
-      expect(globalVariablesBuilder.buildCheckpointGlobalVariables).toHaveBeenCalledWith(
-        EthAddress.ZERO,
-        AztecAddress.ZERO,
-        targetSlot,
-      );
-    });
-  });
-
   describe('reloadKeystore', () => {
     it('throws BadRequestError if no file-based keystore directory is configured', async () => {
       // Default node has no keyStoreDirectory set
@@ -985,6 +772,7 @@ describe('aztec node', () => {
           12345,
           rollupVersion.toNumber(),
           globalVariablesBuilder,
+          undefined,
           feeProvider,
           epochCache,
           getPackageVersion(),
@@ -1175,6 +963,7 @@ describe('aztec node', () => {
           12345,
           rollupVersion.toNumber(),
           globalVariablesBuilder,
+          undefined,
           feeProvider,
           epochCache,
           getPackageVersion(),
@@ -1246,6 +1035,7 @@ describe('aztec node', () => {
         12345,
         rollupVersion.toNumber(),
         globalVariablesBuilder,
+        undefined,
         mock<FeeProvider>(),
         epochCache,
         getPackageVersion(),
@@ -1299,6 +1089,7 @@ describe('aztec node', () => {
         12345,
         rollupVersion.toNumber(),
         globalVariablesBuilder,
+        undefined,
         mock<FeeProvider>(),
         epochCache,
         getPackageVersion(),
@@ -1411,24 +1202,6 @@ describe('aztec node', () => {
     };
   }
 
-  /** Builds the payload of the atomic leading-proposed-checkpoint read (last block = startBlock). */
-  function makeProposedCheckpoint(args: {
-    checkpointNumber: CheckpointNumber;
-    blockNumber: BlockNumber;
-    slotNumber: SlotNumber;
-  }): ProposedCheckpointData {
-    return {
-      checkpointNumber: args.checkpointNumber,
-      header: CheckpointHeader.random({ slotNumber: args.slotNumber }),
-      archive: AppendOnlyTreeSnapshot.empty(),
-      checkpointOutHash: Fr.ZERO,
-      startBlock: args.blockNumber,
-      blockCount: 1,
-      totalManaUsed: 0n,
-      feeAssetPriceModifier: 0n,
-    };
-  }
-
   describe('getCheckpoint', () => {
     /** Builds a minimal ProposedCheckpointData stub. */
     function makeProposedCheckpointData(