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

package/dest/aztec-node/next_block/next_block_predictor.js

@@ -0,0 +1,146 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { createLogger } from '@aztec/foundation/log';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+import { NextBlockFeeCache } from './next_block_fee_cache.js';
+import { 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;
+/**
+ * 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 {
+    blockSource;
+    feeCache;
+    epochCache;
+    log;
+    constructor(deps){
+        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.
+   */ static create(deps) {
+        const feeCache = new NextBlockFeeCache({
+            ...deps,
+            log: deps.log?.createChild('fee-cache')
+        });
+        return new NextBlockPredictor({
+            blockSource: deps.blockSource,
+            feeCache,
+            epochCache: deps.epochCache,
+            log: deps.log
+        });
+    }
+    start(pollingIntervalMs) {
+        this.feeCache.start(pollingIntervalMs);
+    }
+    stop() {
+        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.
+   */ async predict() {
+        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.
+   */ async quoteMinFees() {
+        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. */ 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.
+   */ copyGlobalsFromLatestBlock(frontier, blockNumber) {
+        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/dest/aztec-node/next_block/test_helpers.d.ts

@@ -0,0 +1,40 @@
+import type { FeeHeader } from '@aztec/ethereum/contracts';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BlockHash, type L1SyncPoint, type L2Frontier, type ValidateCheckpointResult } from '@aztec/stdlib/block';
+import { type ProposedCheckpointData } from '@aztec/stdlib/checkpoint';
+import { GasFees } from '@aztec/stdlib/gas';
+/** 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 declare const blockHashOf: (blockNumber: BlockNumber) => BlockHash;
+export declare const makeFrontier: (args: L2FrontierArgs) => L2Frontier;
+export declare function makeFeeHeader(): FeeHeader;
+export declare function makeProposedCheckpointData(args: {
+    checkpointNumber: CheckpointNumber;
+    lastBlock: BlockNumber;
+    slotNumber?: SlotNumber;
+    archiveRoot?: Fr;
+    totalManaUsed?: bigint;
+    feeAssetPriceModifier?: bigint;
+    checkpointOutHash?: Fr;
+}): ProposedCheckpointData;
+export declare function makeInvalidStatus(firstInvalid: CheckpointNumber): ValidateCheckpointResult;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdF9oZWxwZXJzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXp0ZWMtbm9kZS9uZXh0X2Jsb2NrL3Rlc3RfaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsV0FBVyxFQUFFLGdCQUFnQixFQUFlLFVBQVUsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ3pHLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEVBQ0wsU0FBUyxFQUNULEtBQUssV0FBVyxFQUNoQixLQUFLLFVBQVUsRUFFZixLQUFLLHdCQUF3QixFQUM5QixNQUFNLHFCQUFxQixDQUFDO0FBQzdCLE9BQU8sRUFBbUIsS0FBSyxzQkFBc0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3hGLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUs1QyxrR0FBa0c7QUFDbEcsTUFBTSxNQUFNLGNBQWMsR0FBRztJQUMzQixRQUFRLEVBQUUsV0FBVyxDQUFDO0lBQ3RCLGlCQUFpQixFQUFFLFdBQVcsQ0FBQztJQUMvQixZQUFZLEVBQUUsZ0JBQWdCLENBQUM7SUFDL0IsNEdBQTRHO0lBQzVHLG1CQUFtQixDQUFDLEVBQUUsVUFBVSxDQUFDO0lBQ2pDLGtCQUFrQixDQUFDLEVBQUUsc0JBQXNCLENBQUM7SUFDNUMsd0dBQXdHO0lBQ3hHLGtCQUFrQixDQUFDLEVBQUU7UUFBRSxVQUFVLEVBQUUsVUFBVSxDQUFDO1FBQUMsT0FBTyxDQUFDLEVBQUUsT0FBTyxDQUFBO0tBQUUsQ0FBQztJQUNuRSwwR0FBMEc7SUFDMUcscUJBQXFCLENBQUMsRUFBRSxPQUFPLENBQUM7SUFDaEMsNEJBQTRCLENBQUMsRUFBRSx3QkFBd0IsQ0FBQztJQUN4RCxpRkFBaUY7SUFDakYsV0FBVyxDQUFDLEVBQUUsV0FBVyxDQUFDO0NBQzNCLENBQUM7QUFFRiwrRUFBK0U7QUFDL0UsZUFBTyxNQUFNLFdBQVcseUNBQXFGLENBQUM7QUFhOUcsZUFBTyxNQUFNLFlBQVksc0NBc0J2QixDQUFDO0FBRUgsd0JBQWdCLGFBQWEsSUFBSSxTQUFTLENBRXpDO0FBRUQsd0JBQWdCLDBCQUEwQixDQUFDLElBQUksRUFBRTtJQUMvQyxnQkFBZ0IsRUFBRSxnQkFBZ0IsQ0FBQztJQUNuQyxTQUFTLEVBQUUsV0FBVyxDQUFDO0lBQ3ZCLFVBQVUsQ0FBQyxFQUFFLFVBQVUsQ0FBQztJQUN4QixXQUFXLENBQUMsRUFBRSxFQUFFLENBQUM7SUFDakIsYUFBYSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3ZCLHFCQUFxQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQy9CLGlCQUFpQixDQUFDLEVBQUUsRUFBRSxDQUFDO0NBQ3hCLEdBQUcsc0JBQXNCLENBV3pCO0FBRUQsd0JBQWdCLGlCQUFpQixDQUFDLFlBQVksRUFBRSxnQkFBZ0IsR0FBRyx3QkFBd0IsQ0FrQjFGIn0=

package/dest/aztec-node/next_block/test_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_helpers.d.ts","sourceRoot":"","sources":["../../../src/aztec-node/next_block/test_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAe,UAAU,EAAE,MAAM,iCAAiC,CAAC;AACzG,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EACL,SAAS,EACT,KAAK,WAAW,EAChB,KAAK,UAAU,EAEf,KAAK,wBAAwB,EAC9B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAmB,KAAK,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AACxF,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAK5C,kGAAkG;AAClG,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,WAAW,CAAC;IACtB,iBAAiB,EAAE,WAAW,CAAC;IAC/B,YAAY,EAAE,gBAAgB,CAAC;IAC/B,4GAA4G;IAC5G,mBAAmB,CAAC,EAAE,UAAU,CAAC;IACjC,kBAAkB,CAAC,EAAE,sBAAsB,CAAC;IAC5C,wGAAwG;IACxG,kBAAkB,CAAC,EAAE;QAAE,UAAU,EAAE,UAAU,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IACnE,0GAA0G;IAC1G,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,4BAA4B,CAAC,EAAE,wBAAwB,CAAC;IACxD,iFAAiF;IACjF,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,WAAW,yCAAqF,CAAC;AAa9G,eAAO,MAAM,YAAY,sCAsBvB,CAAC;AAEH,wBAAgB,aAAa,IAAI,SAAS,CAEzC;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,SAAS,EAAE,WAAW,CAAC;IACvB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,WAAW,CAAC,EAAE,EAAE,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,iBAAiB,CAAC,EAAE,EAAE,CAAC;CACxB,GAAG,sBAAsB,CAWzB;AAED,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,gBAAgB,GAAG,wBAAwB,CAkB1F"}

package/dest/aztec-node/next_block/test_helpers.js

@@ -0,0 +1,100 @@
+import { BlockNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BlockHash } from '@aztec/stdlib/block';
+import { L1PublishedData } 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';
+/** Stable per-block hash, so tips and the frontier agree on block identity. */ export const blockHashOf = (blockNumber)=>new BlockHash(new Fr(1000 + blockNumber));
+const makeTips = (args)=>{
+    const blockId = (number)=>({
+            number,
+            hash: blockHashOf(number).toString()
+        });
+    const checkpointId = (number)=>({
+            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)=>({
+        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() {
+    return {
+        excessMana: 0n,
+        manaUsed: 0n,
+        ethPerFeeAsset: 0n,
+        congestionCost: 0n,
+        proverCost: 0n
+    };
+}
+export function makeProposedCheckpointData(args) {
+    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) {
+    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/dest/aztec-node/node_public_calls_simulator.d.ts

@@ -1,13 +1,10 @@
-import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { type RollupContract } from '@aztec/ethereum/contracts';
 import { type Logger } from '@aztec/foundation/log';
-import type { L2BlockSource } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { type L1ToL2MessageSource } from '@aztec/stdlib/messaging';
-import type { CoordinationSignatureContext } from '@aztec/stdlib/p2p';
-import { type GlobalVariableBuilder, PublicSimulationOutput, type SimulationOverrides, type Tx } from '@aztec/stdlib/tx';
+import { PublicSimulationOutput, type SimulationOverrides, type Tx } from '@aztec/stdlib/tx';
 import { type TelemetryClient } from '@aztec/telemetry-client';
+import type { NextBlockPredictor } from './next_block/index.js';
 /** Config fields the simulator needs — a narrow subset of `AztecNodeConfig`. */
 export interface NodePublicCallsSimulatorConfig {
     /** Maximum total gas limit accepted for an incoming simulation. */
@@ -17,20 +14,10 @@ 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;
@@ -38,28 +25,16 @@ export interface NodePublicCallsSimulatorDeps {
 /**
  * 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 declare class NodePublicCallsSimulator {
-    private readonly blockSource;
     private readonly worldStateSynchronizer;
     private readonly l1ToL2MessageSource;
     private readonly contractDataSource;
-    private readonly globalVariableBuilder;
-    private readonly rollupContract;
-    private readonly epochCache;
-    private readonly signatureContext;
+    private readonly predictor;
     private readonly config;
     private readonly telemetry;
     private readonly log;
@@ -71,20 +46,7 @@ export declare class NodePublicCallsSimulator {
      * @param overrides - Optional pre-simulation overrides applied to the ephemeral fork and contract DB.
      */
     simulate(tx: Tx, skipFeeEnforcement?: boolean, overrides?: SimulationOverrides): Promise<PublicSimulationOutput>;
+    private prepareNextBlock;
     private getNextCheckpointMessages;
-    private copyGlobalVariablesFromLatestProposedBlock;
-    private buildGlobalVariablesForNewCheckpoint;
-    /**
-     * 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;
-    private buildSimulationOverridesPlan;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZV9wdWJsaWNfY2FsbHNfc2ltdWxhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp0ZWMtbm9kZS9ub2RlX3B1YmxpY19jYWxsc19zaW11bGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBTWxFLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM5RSxPQUFPLEVBQUUsS0FBSyxtQkFBbUIsRUFBOEIsTUFBTSx5QkFBeUIsQ0FBQztBQUMvRixPQUFPLEVBQXdCLHNCQUFzQixFQUFFLEtBQUssbUJBQW1CLEVBQUUsS0FBSyxFQUFFLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNuSCxPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQXNCLE1BQU0seUJBQXlCLENBQUM7QUFHbkYsT0FBTyxLQUFLLEVBQWlCLGtCQUFrQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFNL0Usa0ZBQWdGO0FBQ2hGLE1BQU0sV0FBVyw4QkFBOEI7SUFDN0MsbUVBQW1FO0lBQ25FLDRCQUE0QixFQUFFLE1BQU0sQ0FBQztJQUNyQyw0RUFBNEU7SUFDNUUsdUNBQXVDLEVBQUUsTUFBTSxDQUFDO0NBQ2pEO0FBRUQseUVBQXlFO0FBQ3pFLE1BQU0sV0FBVyw0QkFBNEI7SUFDM0Msc0JBQXNCLEVBQUUsc0JBQXNCLENBQUM7SUFDL0MsbUJBQW1CLEVBQUUsbUJBQW1CLENBQUM7SUFDekMsa0JBQWtCLEVBQUUsa0JBQWtCLENBQUM7SUFDdkMsU0FBUyxFQUFFLGtCQUFrQixDQUFDO0lBQzlCLE1BQU0sRUFBRSw4QkFBOEIsQ0FBQztJQUN2QyxTQUFTLENBQUMsRUFBRSxlQUFlLENBQUM7SUFDNUIsR0FBRyxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ2Q7QUFVRDs7Ozs7OztHQU9HO0FBQ0gscUJBQWEsd0JBQXdCO0lBQ25DLE9BQU8sQ0FBQyxRQUFRLENBQUMsc0JBQXNCLENBQXlCO0lBQ2hFLE9BQU8sQ0FBQyxRQUFRLENBQUMsbUJBQW1CLENBQXNCO0lBQzFELE9BQU8sQ0FBQyxRQUFRLENBQUMsa0JBQWtCLENBQXFCO0lBQ3hELE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFxQjtJQUMvQyxPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBaUM7SUFDeEQsT0FBTyxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQWtCO0lBQzVDLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFTO0lBRTdCLFlBQVksSUFBSSxFQUFFLDRCQUE0QixFQVE3QztJQUVEOzs7OztPQUtHO0lBQ1UsUUFBUSxDQUNuQixFQUFFLEVBQUUsRUFBRSxFQUNOLGtCQUFrQixVQUFRLEVBQzFCLFNBQVMsQ0FBQyxFQUFFLG1CQUFtQixHQUM5QixPQUFPLENBQUMsc0JBQXNCLENBQUMsQ0E4RWpDO1lBUWEsZ0JBQWdCO1lBb0NoQix5QkFBeUI7Q0FzQnhDIn0=

package/dest/aztec-node/node_public_calls_simulator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node_public_calls_simulator.d.ts","sourceRoot":"","sources":["../../src/aztec-node/node_public_calls_simulator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,2BAA2B,CAAC;AAMnC,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAMlE,OAAO,KAAK,EAAE,aAAa,EAAU,MAAM,qBAAqB,CAAC;AAEjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EAAE,KAAK,mBAAmB,EAA8B,MAAM,yBAAyB,CAAC;AAC/F,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EACL,KAAK,qBAAqB,EAE1B,sBAAsB,EACtB,KAAK,mBAAmB,EACxB,KAAK,EAAE,EACR,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAInF,kFAAgF;AAChF,MAAM,WAAW,8BAA8B;IAC7C,mEAAmE;IACnE,4BAA4B,EAAE,MAAM,CAAC;IACrC,4EAA4E;IAC5E,uCAAuC,EAAE,MAAM,CAAC;CACjD;AAED,yEAAyE;AACzE,MAAM,WAAW,4BAA4B;IAC3C,WAAW,EAAE,aAAa,CAAC;IAC3B,sBAAsB,EAAE,sBAAsB,CAAC;IAC/C,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,qBAAqB,EAAE,qBAAqB,CAAC;IAC7C;;;;;OAKG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,UAAU,EAAE,mBAAmB,CAAC;IAChC,gBAAgB,EAAE,4BAA4B,CAAC;IAC/C,MAAM,EAAE,8BAA8B,CAAC;IACvC,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAgB;IAC5C,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAyB;IAChE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAsB;IAC1D,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqB;IACxD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAwB;IAC9D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6B;IAC5D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA+B;IAChE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YAAY,IAAI,EAAE,4BAA4B,EAY7C;IAED;;;;;OAKG;IACU,QAAQ,CACnB,EAAE,EAAE,EAAE,EACN,kBAAkB,UAAQ,EAC1B,SAAS,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,sBAAsB,CAAC,CA0GjC;YAUa,yBAAyB;YAmCzB,0CAA0C;YAuB1C,oCAAoC;IA2BlD;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;YAmBX,4BAA4B;CAkC3C"}
+{"version":3,"file":"node_public_calls_simulator.d.ts","sourceRoot":"","sources":["../../src/aztec-node/node_public_calls_simulator.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAMlE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EAAE,KAAK,mBAAmB,EAA8B,MAAM,yBAAyB,CAAC;AAC/F,OAAO,EAAwB,sBAAsB,EAAE,KAAK,mBAAmB,EAAE,KAAK,EAAE,EAAE,MAAM,kBAAkB,CAAC;AACnH,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAGnF,OAAO,KAAK,EAAiB,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAM/E,kFAAgF;AAChF,MAAM,WAAW,8BAA8B;IAC7C,mEAAmE;IACnE,4BAA4B,EAAE,MAAM,CAAC;IACrC,4EAA4E;IAC5E,uCAAuC,EAAE,MAAM,CAAC;CACjD;AAED,yEAAyE;AACzE,MAAM,WAAW,4BAA4B;IAC3C,sBAAsB,EAAE,sBAAsB,CAAC;IAC/C,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,SAAS,EAAE,kBAAkB,CAAC;IAC9B,MAAM,EAAE,8BAA8B,CAAC;IACvC,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAUD;;;;;;;GAOG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAyB;IAChE,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAsB;IAC1D,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqB;IACxD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,YAAY,IAAI,EAAE,4BAA4B,EAQ7C;IAED;;;;;OAKG;IACU,QAAQ,CACnB,EAAE,EAAE,EAAE,EACN,kBAAkB,UAAQ,EAC1B,SAAS,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,sBAAsB,CAAC,CA8EjC;YAQa,gBAAgB;YAoChB,yBAAyB;CAsBxC"}