@aztec/aztec-node 0.0.1-commit.b2a5d0dd1 → 0.0.1-commit.b3d3157a

package/dest/aztec-node/server.js

@@ -1,3 +1,68 @@
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
 function applyDecs2203RFactory() {
     function createAddInitializerMethod(initializers, decoratorFinishedRef) {
         return function addInitializer(initializer) {
@@ -371,7 +436,7 @@ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
     return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
 }
 var _dec, _initProto;
-import { createArchiver } from '@aztec/archiver';
+import { L1ToL2MessagesNotReadyError, createArchiver } from '@aztec/archiver';
 import { BBCircuitVerifier, BatchChonkVerifier, QueuedIVCVerifier } from '@aztec/bb-prover';
 import { TestCircuitVerifier } from '@aztec/bb-prover/test';
 import { createBlobClientWithFileStores } from '@aztec/blob-client/client';
@@ -380,7 +445,8 @@ import { EpochCache } from '@aztec/epoch-cache';
 import { createEthereumChain } from '@aztec/ethereum/chain';
 import { getPublicClient, makeL1HttpTransport } from '@aztec/ethereum/client';
 import { RegistryContract, RollupContract } from '@aztec/ethereum/contracts';
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import { pickL1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { chunkBy, compactArray, pick, unique } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -390,6 +456,7 @@ import { retryUntil } from '@aztec/foundation/retry';
 import { count } from '@aztec/foundation/string';
 import { DateProvider, Timer } from '@aztec/foundation/timer';
 import { MembershipWitness } from '@aztec/foundation/trees';
+import { isErrorClass } from '@aztec/foundation/types';
 import { KeystoreManager, loadKeystores, mergeKeystores } from '@aztec/node-keystore';
 import { trySnapshotSync, uploadSnapshot } from '@aztec/node-lib/actions';
 import { createForwarderL1TxUtilsFromSigners, createL1TxUtilsFromSigners } from '@aztec/node-lib/factories';
@@ -397,28 +464,34 @@ import { createP2PClient, createTxValidatorForAcceptingTxsOverRPC, getDefaultAll
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { createProverNode } from '@aztec/prover-node';
 import { createKeyStoreForProver } from '@aztec/prover-node/config';
-import { FeeProviderImpl, GlobalVariableBuilder, SequencerClient } from '@aztec/sequencer-client';
-import { PublicProcessorFactory } from '@aztec/simulator/server';
-import { AttestationsBlockWatcher, EpochPruneWatcher, createSlasher } from '@aztec/slasher';
+import { FeeProviderImpl, GlobalVariableBuilder, SequencerClient, createAutomineSequencer } from '@aztec/sequencer-client';
+import { PublicContractsDB, PublicProcessorFactory } from '@aztec/simulator/server';
+import { AttestationsBlockWatcher, AttestedInvalidProposalWatcher, BroadcastedInvalidCheckpointProposalWatcher, CheckpointEquivocationWatcher, DataWithholdingWatcher, createSlasher } from '@aztec/slasher';
+import { STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS } from '@aztec/standard-contracts/multi-call-entrypoint';
 import { CollectionLimitsConfig, PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { BlockHash, L2Block } from '@aztec/stdlib/block';
+import { BlockHash, BlockTag, inspectBlockParameter } from '@aztec/stdlib/block';
+import { CheckpointReexecutionTracker } from '@aztec/stdlib/checkpoint';
+import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 import { GasFees } from '@aztec/stdlib/gas';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
 import { AztecNodeAdminConfigSchema } from '@aztec/stdlib/interfaces/client';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { InMemoryDebugLogStore, NullDebugLogStore } from '@aztec/stdlib/logs';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
+import { InboxLeaf, appendL1ToL2MessagesToTree } from '@aztec/stdlib/messaging';
+import { MIN_EXECUTION_TIME } from '@aztec/stdlib/timetable';
 import { MerkleTreeId, NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
-import { PublicSimulationOutput, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+import { DroppedTxReceipt, MinedTxReceipt, PendingTxReceipt, PublicSimulationOutput, TxStatus } from '@aztec/stdlib/tx';
 import { getPackageVersion } from '@aztec/stdlib/update-checker';
 import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { FullNodeCheckpointsBuilder as CheckpointsBuilder, FullNodeCheckpointsBuilder, NodeKeystoreAdapter, ValidatorClient, createProposalHandler, createValidatorClient } from '@aztec/validator-client';
-import { createWorldStateSynchronizer } from '@aztec/world-state';
+import { createWorldState, createWorldStateSynchronizer } from '@aztec/world-state';
 import { createPublicClient } from 'viem';
 import { createSentinel } from '../sentinel/factory.js';
+import { blockResponseFromBlockData, blockResponseFromL2Block, checkpointResponseFromCheckpointData, checkpointResponseFromPublishedCheckpoint, projectProposedToCheckpointResponse } from './block_response_helpers.js';
 import { createKeyStoreForValidator } from './config.js';
 import { NodeMetrics } from './node_metrics.js';
+import { applyPublicDataOverrides } from './public_data_overrides.js';
 _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         [Attributes.TX_HASH]: tx.getTxHash().toString()
     }));
@@ -436,7 +509,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     proverNode;
     slasherClient;
     validatorsSentinel;
-    epochPruneWatcher;
+    stopStartedWatchers;
     l1ChainId;
     version;
     globalVariableBuilder;
@@ -451,6 +524,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     validatorClient;
     keyStoreManager;
     debugLogStore;
+    automineSequencer;
     static{
         ({ e: [_initProto] } = _apply_decs_2203_r(this, [
             [
@@ -461,11 +535,12 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         ], []));
     }
     metrics;
-    initialHeaderHashPromise;
     // Prevent two snapshot operations to happen simultaneously
     isUploadingSnapshot;
+    // Saved minTxsPerBlock used by `pauseSequencer` to restore production-sequencer config on resume.
+    sequencerPausedMinTxsPerBlock;
     tracer;
-    constructor(config, p2pClient, blockSource, logsSource, contractDataSource, l1ToL2MessageSource, worldStateSynchronizer, sequencer, proverNode, slasherClient, validatorsSentinel, epochPruneWatcher, l1ChainId, version, globalVariableBuilder, feeProvider, epochCache, packageVersion, peerProofVerifier, rpcProofVerifier, telemetry = getTelemetryClient(), log = createLogger('node'), blobClient, validatorClient, keyStoreManager, debugLogStore = new NullDebugLogStore()){
+    constructor(config, p2pClient, blockSource, logsSource, contractDataSource, l1ToL2MessageSource, worldStateSynchronizer, sequencer, proverNode, slasherClient, validatorsSentinel, stopStartedWatchers, l1ChainId, version, globalVariableBuilder, feeProvider, epochCache, packageVersion, peerProofVerifier, rpcProofVerifier, telemetry = getTelemetryClient(), log = createLogger('node'), blobClient, validatorClient, keyStoreManager, debugLogStore = new NullDebugLogStore(), automineSequencer){
         this.config = config;
         this.p2pClient = p2pClient;
         this.blockSource = blockSource;
@@ -477,7 +552,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         this.proverNode = proverNode;
         this.slasherClient = slasherClient;
         this.validatorsSentinel = validatorsSentinel;
-        this.epochPruneWatcher = epochPruneWatcher;
+        this.stopStartedWatchers = stopStartedWatchers;
         this.l1ChainId = l1ChainId;
         this.version = version;
         this.globalVariableBuilder = globalVariableBuilder;
@@ -492,12 +567,12 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         this.validatorClient = validatorClient;
         this.keyStoreManager = keyStoreManager;
         this.debugLogStore = debugLogStore;
-        this.initialHeaderHashPromise = (_initProto(this), undefined);
-        this.isUploadingSnapshot = false;
+        this.automineSequencer = automineSequencer;
+        this.isUploadingSnapshot = (_initProto(this), false);
         this.metrics = new NodeMetrics(telemetry, 'AztecNodeService');
         this.tracer = telemetry.getTracer('AztecNodeService');
         this.log.info(`Aztec Node version: ${this.packageVersion}`);
-        this.log.info(`Aztec Node started on chain 0x${l1ChainId.toString(16)}`, config.l1Contracts);
+        this.log.info(`Aztec Node started on chain 0x${l1ChainId.toString(16)}`, pickL1ContractAddresses(config));
         // A defensive check that protects us against introducing a bug in the complex `createAndSync` function. We must
         // never have debugLogStore enabled when not in test mode because then we would be accumulating debug logs in
         // memory which could be a DoS vector on the sequencer (since no fees are paid for debug logs).
@@ -512,8 +587,242 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         const status = await this.worldStateSynchronizer.status();
         return status.syncSummary;
     }
-    getL2Tips() {
-        return this.blockSource.getL2Tips();
+    async getChainTips() {
+        const { proposed, checkpointed, proven, finalized } = await this.blockSource.getL2Tips();
+        return {
+            proposed,
+            checkpointed,
+            proven,
+            finalized
+        };
+    }
+    getCheckpointsData(query) {
+        return this.blockSource.getCheckpointsData(query);
+    }
+    async getBlockNumber(tip) {
+        if (tip === undefined || tip === 'proposed') {
+            return this.blockSource.getBlockNumber();
+        }
+        return await this.blockSource.getBlockNumber({
+            tag: tip
+        }) ?? BlockNumber.ZERO;
+    }
+    async getCheckpointNumber(tip) {
+        const tips = await this.blockSource.getL2Tips();
+        switch(tip){
+            case undefined:
+            case 'checkpointed':
+                return tips.checkpointed.checkpoint.number;
+            case 'proposed':
+                return tips.proposedCheckpoint.checkpoint.number;
+            case 'proven':
+                return tips.proven.checkpoint.number;
+            case 'finalized':
+                return tips.finalized.checkpoint.number;
+        }
+    }
+    isChainTip(value) {
+        return value === 'proposed' || value === 'checkpointed' || value === 'proven' || value === 'finalized';
+    }
+    /**
+   * Normalizes a {@link BlockParameter} (which may be a bare value) into a
+   * {@link NormalizedBlockParameter} object form. Performs no chain-tip resolution — tag
+   * lookups are deferred to the underlying block source.
+   */ normalizeBlockParameter(param) {
+        if (BlockHash.isBlockHash(param)) {
+            return {
+                hash: param
+            };
+        }
+        if (typeof param === 'number') {
+            return {
+                number: param
+            };
+        }
+        if (typeof param === 'string') {
+            if (this.isBlockTag(param)) {
+                return {
+                    tag: param === 'latest' ? 'proposed' : param
+                };
+            }
+            throw new BadRequestError(`Invalid BlockParameter tag: ${param}`);
+        }
+        if (typeof param === 'object' && param !== null) {
+            if ('number' in param) {
+                return {
+                    number: param.number
+                };
+            }
+            if ('hash' in param) {
+                return {
+                    hash: param.hash
+                };
+            }
+            if ('archive' in param) {
+                return {
+                    archive: param.archive
+                };
+            }
+            if ('tag' in param) {
+                if (this.isBlockTag(param.tag)) {
+                    return {
+                        tag: param.tag
+                    };
+                }
+                throw new BadRequestError(`Invalid BlockParameter tag: ${param.tag}`);
+            }
+        }
+        throw new BadRequestError(`Invalid BlockParameter: ${JSON.stringify(param)}`);
+    }
+    isBlockTag(value) {
+        return BlockTag.includes(value);
+    }
+    /**
+   * Resolves a {@link CheckpointParameter} into a concrete `{ number }` or `{ slot }` query.
+   *
+   * Tag-based parameters (`'proposed'`, `'checkpointed'`, `'proven'`, `'finalized'`) are
+   * translated up-front to the corresponding tip's checkpoint number via {@link L2BlockSource.getL2Tips}.
+   * After resolution the unified {@link getCheckpoint} flow can perform a single
+   * confirmed→proposed lookup against either store.
+   */ async resolveCheckpointParameter(param) {
+        if (typeof param === 'number') {
+            return {
+                number: param
+            };
+        }
+        if (this.isChainTip(param)) {
+            const tips = await this.blockSource.getL2Tips();
+            switch(param){
+                case 'proposed':
+                    return {
+                        number: tips.proposedCheckpoint.checkpoint.number
+                    };
+                case 'checkpointed':
+                    return {
+                        number: tips.checkpointed.checkpoint.number
+                    };
+                case 'proven':
+                    return {
+                        number: tips.proven.checkpoint.number
+                    };
+                case 'finalized':
+                    return {
+                        number: tips.finalized.checkpoint.number
+                    };
+            }
+        }
+        if (typeof param === 'object' && param !== null) {
+            if ('number' in param) {
+                return {
+                    number: param.number
+                };
+            }
+            if ('slot' in param) {
+                return {
+                    slot: param.slot
+                };
+            }
+        }
+        throw new BadRequestError(`Invalid CheckpointParameter: ${JSON.stringify(param)}`);
+    }
+    /** Fetches checkpoint-level L1 and attestation data for use as block response context. */ async #getCheckpointContext(checkpointNumber) {
+        const checkpoint = await this.blockSource.getCheckpointData({
+            number: checkpointNumber
+        });
+        if (!checkpoint) {
+            return undefined;
+        }
+        return {
+            l1: checkpoint.l1,
+            attestations: checkpoint.attestations
+        };
+    }
+    async getBlock(param, options = {}) {
+        const query = this.normalizeBlockParameter(param);
+        const wantTxs = !!options.includeTransactions;
+        const wantContext = !!options.includeL1PublishInfo || !!options.includeAttestations;
+        if (wantTxs) {
+            const block = await this.blockSource.getBlock(query);
+            if (!block) {
+                return undefined;
+            }
+            const ctx = wantContext ? await this.#getCheckpointContext(block.checkpointNumber) : undefined;
+            return await blockResponseFromL2Block(block, options, ctx);
+        }
+        const data = await this.blockSource.getBlockData(query);
+        if (!data) {
+            return undefined;
+        }
+        const ctx = wantContext ? await this.#getCheckpointContext(data.checkpointNumber) : undefined;
+        return blockResponseFromBlockData(data, options, ctx);
+    }
+    getBlockData(param) {
+        const query = this.normalizeBlockParameter(param);
+        return this.blockSource.getBlockData(query);
+    }
+    async getBlocks(from, limit, options = {}) {
+        const wantTxs = !!options.includeTransactions;
+        const wantContext = !!options.includeL1PublishInfo || !!options.includeAttestations;
+        const onlyCheckpointed = !!options.onlyCheckpointed;
+        if (wantTxs) {
+            const blocks = await this.blockSource.getBlocks({
+                from,
+                limit,
+                onlyCheckpointed
+            });
+            const ctxByCheckpoint = await this.#getCheckpointContextsForBlocks(wantContext ? blocks : []);
+            return await Promise.all(blocks.map((block)=>blockResponseFromL2Block(block, options, ctxByCheckpoint.get(block.checkpointNumber))));
+        }
+        const dataItems = await this.blockSource.getBlocksData({
+            from,
+            limit,
+            onlyCheckpointed
+        });
+        const ctxByCheckpoint = await this.#getCheckpointContextsForBlocks(wantContext ? dataItems : []);
+        return await Promise.all(dataItems.map((data)=>blockResponseFromBlockData(data, options, ctxByCheckpoint.get(data.checkpointNumber))));
+    }
+    /** Fetches checkpoint context for a set of blocks, deduplicating shared checkpoints. */ async #getCheckpointContextsForBlocks(blocks) {
+        const unique = Array.from(new Set(blocks.map((b)=>b.checkpointNumber)));
+        const entries = await Promise.all(unique.map(async (n)=>[
+                n,
+                await this.#getCheckpointContext(n)
+            ]));
+        return new Map(entries);
+    }
+    async getCheckpoint(param, options = {}) {
+        const query = await this.resolveCheckpointParameter(param);
+        // Try the confirmed store first.
+        const confirmed = options.includeBlocks ? await this.blockSource.getCheckpoint(query) : await this.blockSource.getCheckpointData(query);
+        if (confirmed) {
+            return await (options.includeBlocks ? checkpointResponseFromPublishedCheckpoint(confirmed, options) : checkpointResponseFromCheckpointData(confirmed, options));
+        }
+        // Fall back to the proposed store.
+        const proposed = await this.blockSource.getProposedCheckpointData(query);
+        if (proposed) {
+            if (options.includeAttestations || options.includeL1PublishInfo) {
+                throw new BadRequestError(`Options includeL1PublishInfo or includeAttestations cannot be satisfied for a proposed checkpoint`);
+            }
+            const blocks = options.includeBlocks ? await this.blockSource.getBlocks({
+                from: proposed.startBlock,
+                limit: proposed.blockCount
+            }) : undefined;
+            return await projectProposedToCheckpointResponse(proposed, options, blocks);
+        }
+        return undefined;
+    }
+    async getCheckpoints(from, limit, options = {}) {
+        if (options.includeBlocks) {
+            const checkpoints = await this.blockSource.getCheckpoints({
+                from,
+                limit
+            });
+            return await Promise.all(checkpoints.map((cp)=>checkpointResponseFromPublishedCheckpoint(cp, options)));
+        }
+        const datas = await this.blockSource.getCheckpointsData({
+            from,
+            limit
+        });
+        return datas.map((d)=>checkpointResponseFromCheckpointData(d, options));
     }
     /**
    * initializes the Aztec Node, wait for component to sync.
@@ -524,7 +833,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             ...inputConfig
         }; // Copy the config so we dont mutate the input object
         const log = deps.logger ?? createLogger('node');
-        const packageVersion = getPackageVersion() ?? '';
+        const packageVersion = getPackageVersion();
         const telemetry = deps.telemetry ?? getTelemetryClient();
         const dateProvider = deps.dateProvider ?? new DateProvider();
         const ethereumChain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
@@ -573,13 +882,9 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             }),
             pollingInterval: config.viemPollingIntervalMS
         });
-        const l1ContractsAddresses = await RegistryContract.collectAddresses(publicClient, config.l1Contracts.registryAddress, config.rollupVersion ?? 'canonical');
-        // Overwrite the passed in vars.
-        config.l1Contracts = {
-            ...config.l1Contracts,
-            ...l1ContractsAddresses
-        };
-        const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
+        const l1ContractsAddresses = await RegistryContract.collectAddresses(publicClient, config.registryAddress, config.rollupVersion ?? 'canonical');
+        Object.assign(config, l1ContractsAddresses);
+        const rollupContract = new RollupContract(publicClient, config.rollupAddress.toString());
         const [l1GenesisTime, slotDuration, rollupVersionFromRollup, rollupManaLimit] = await Promise.all([
             rollupContract.getL1GenesisTime(),
             rollupContract.getSlotDuration(),
@@ -593,23 +898,33 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         const blobClient = await createBlobClientWithFileStores(config, log.createChild('blob-client'));
         // attempt snapshot sync if possible
         await trySnapshotSync(config, log);
-        const epochCache = await EpochCache.create(config.l1Contracts.rollupAddress, config, {
+        const epochCache = await EpochCache.create(config.rollupAddress, config, {
             dateProvider
         });
         // Track started resources so we can clean up on partial failure during node creation.
         const started = [];
         try {
+            // Default the orphan-prune grace window from the block build duration when unset, so the archiver
+            // waits roughly one build slot for a proposed checkpoint to arrive before pruning a block-only tip.
+            config.orphanProposedBlockPruneGraceSeconds ??= config.blockDurationMs !== undefined ? Math.ceil(config.blockDurationMs / 1000) : MIN_EXECUTION_TIME;
+            // Create world-state first so we can retrieve the initial header before constructing the archiver.
+            const nativeWs = await createWorldState(config, options.genesis);
+            const initialHeader = nativeWs.getInitialHeader();
+            const initialBlockHash = await initialHeader.hash();
             const archiver = await createArchiver(config, {
                 blobClient,
                 epochCache,
                 telemetry,
                 dateProvider
             }, {
-                blockUntilSync: !config.skipArchiverInitialSync
-            });
+                blockUntilSync: !config.skipArchiverInitialSync,
+                // The non-pipelined automine sequencer publishes each checkpoint in-slot, so it never
+                // leaves orphan proposed blocks; pruning would race its local push. See pruneOrphanProposedBlocks.
+                enableOrphanProposedBlockPruning: !config.useAutomineSequencer
+            }, initialHeader, initialBlockHash);
             started.push(archiver);
-            // now create the merkle trees and the world state synchronizer
-            const worldStateSynchronizer = await createWorldStateSynchronizer(config, archiver, options.genesis, telemetry);
+            // The synchronizer takes ownership of the native world-state from here
+            const worldStateSynchronizer = await createWorldStateSynchronizer(config, archiver, nativeWs, telemetry);
             started.push(worldStateSynchronizer);
             const useRealVerifiers = config.realProofs || config.debugForceTxProofVerification;
             let peerProofVerifier;
@@ -632,7 +947,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                 debugLogStore = new NullDebugLogStore();
             }
             const globalVariableBuilderConfig = {
-                l1Contracts: config.l1Contracts,
+                rollupAddress: config.rollupAddress,
                 ethereumSlotDuration: config.ethereumSlotDuration,
                 rollupVersion: BigInt(config.rollupVersion),
                 l1GenesisTime,
@@ -645,7 +960,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                 log.info('Starting in prover-only mode: skipping validator, sequencer, sentinel, and slasher subsystems');
             }
             // create the tx pool and the p2p client, which will need the l2 block source
-            const p2pClient = await createP2PClient(config, archiver, peerProofVerifier, worldStateSynchronizer, epochCache, feeProvider, packageVersion, dateProvider, telemetry, deps.p2pClientDeps);
+            const p2pClient = await createP2PClient(config, archiver, peerProofVerifier, worldStateSynchronizer, epochCache, feeProvider, packageVersion, dateProvider, telemetry, deps.p2pClientDeps, initialBlockHash);
             started.push(p2pClient);
             // We'll accumulate sentinel watchers here
             const watchers = [];
@@ -659,7 +974,9 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                 maxTxsPerCheckpoint: config.validateMaxTxsPerCheckpoint
             }, worldStateSynchronizer, archiver, dateProvider, telemetry);
             let validatorClient;
-            if (!proverOnly) {
+            // Tracks successful checkpoint re-execution by a checkpoint proposal handler.
+            const reexecutionTracker = new CheckpointReexecutionTracker();
+            if (!config.disableValidator) {
                 // Create validator client if required
                 validatorClient = await createValidatorClient(config, {
                     checkpointsBuilder: validatorCheckpointsBuilder,
@@ -672,6 +989,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                     l1ToL2MessageSource: archiver,
                     keyStoreManager,
                     blobClient,
+                    reexecutionTracker,
                     slashingProtectionDb: deps.slashingProtectionDb
                 });
                 // If we have a validator client, register it as a source of offenses for the slasher,
@@ -703,7 +1021,8 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                     p2pClient,
                     blobClient,
                     dateProvider,
-                    telemetry
+                    telemetry,
+                    reexecutionTracker
                 }).register(p2pClient, reexecute, archiver);
             }
             // Start world state and wait for it to sync to the archiver.
@@ -711,38 +1030,68 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             // Start p2p. Note that it depends on world state to be running.
             await p2pClient.start();
             let validatorsSentinel;
-            let epochPruneWatcher;
+            let dataWithholdingWatcher;
             let attestationsBlockWatcher;
+            let attestedInvalidProposalWatcher;
+            let broadcastedInvalidCheckpointProposalWatcher;
+            let checkpointEquivocationWatcher;
             if (!proverOnly) {
-                validatorsSentinel = await createSentinel(epochCache, archiver, p2pClient, config);
-                if (validatorsSentinel && config.slashInactivityPenalty > 0n) {
+                validatorsSentinel = await createSentinel(epochCache, archiver, p2pClient, reexecutionTracker, config);
+                if (validatorsSentinel) {
                     watchers.push(validatorsSentinel);
                 }
-                if (config.slashPrunePenalty > 0n || config.slashDataWithholdingPenalty > 0n) {
-                    epochPruneWatcher = new EpochPruneWatcher(archiver, archiver, epochCache, p2pClient.getTxProvider(), validatorCheckpointsBuilder, config);
-                    watchers.push(epochPruneWatcher);
-                }
-                // We assume we want to slash for invalid attestations unless all max penalties are set to 0
-                if (config.slashProposeInvalidAttestationsPenalty > 0n || config.slashAttestDescendantOfInvalidPenalty > 0n) {
-                    attestationsBlockWatcher = new AttestationsBlockWatcher(archiver, epochCache, config);
-                    watchers.push(attestationsBlockWatcher);
+                dataWithholdingWatcher = new DataWithholdingWatcher(epochCache, archiver, p2pClient.getTxProvider(), p2pClient, reexecutionTracker, {
+                    chainId: config.l1ChainId,
+                    rollupAddress: config.rollupAddress
+                }, config);
+                watchers.push(dataWithholdingWatcher);
+                broadcastedInvalidCheckpointProposalWatcher = new BroadcastedInvalidCheckpointProposalWatcher(p2pClient, archiver, epochCache, config);
+                watchers.push(broadcastedInvalidCheckpointProposalWatcher);
+                if (validatorClient) {
+                    attestedInvalidProposalWatcher = new AttestedInvalidProposalWatcher(p2pClient, validatorClient, archiver, epochCache, config, {
+                        log: log.createChild('attested-invalid-proposal-watcher')
+                    });
+                    watchers.push(attestedInvalidProposalWatcher);
                 }
+                checkpointEquivocationWatcher = new CheckpointEquivocationWatcher(archiver, epochCache, config);
+                watchers.push(checkpointEquivocationWatcher);
+                attestationsBlockWatcher = new AttestationsBlockWatcher(archiver, epochCache, config, log.getBindings());
+                watchers.push(attestationsBlockWatcher);
             }
+            const watchersToStart = compactArray([
+                validatorsSentinel,
+                dataWithholdingWatcher,
+                attestationsBlockWatcher,
+                broadcastedInvalidCheckpointProposalWatcher,
+                attestedInvalidProposalWatcher,
+                checkpointEquivocationWatcher
+            ]);
+            const startedWatchers = [];
+            const stopStartedWatchers = async ()=>{
+                for (const watcher of startedWatchers){
+                    await tryStop(watcher);
+                }
+            };
             // Start p2p-related services once the archiver has completed sync
             void archiver.waitForInitialSync().then(async ()=>{
-                await validatorsSentinel?.start();
-                await epochPruneWatcher?.start();
-                await attestationsBlockWatcher?.start();
+                for (const watcher of watchersToStart){
+                    await watcher.start();
+                    startedWatchers.push(watcher);
+                }
                 log.info(`All p2p services started`);
             }).catch((err)=>log.error('Failed to start p2p services after archiver sync', err));
+            started.push({
+                stop: stopStartedWatchers
+            });
             // Validator enabled, create/start relevant service
             let sequencer;
+            let automineSequencer;
             let slasherClient;
             if (!config.disableValidator && validatorClient) {
                 // We create a slasher only if we have a sequencer, since all slashing actions go through the sequencer publisher
                 // as they are executed when the node is selected as proposer.
                 const validatorAddresses = keyStoreManager ? NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager).getAddresses() : [];
-                slasherClient = await createSlasher(config, config.l1Contracts, getPublicClient(config), watchers, dateProvider, epochCache, validatorAddresses, undefined);
+                slasherClient = await createSlasher(config, pickL1ContractAddresses(config), getPublicClient(config), watchers, dateProvider, epochCache, validatorAddresses, undefined);
                 await slasherClient.start();
                 started.push(slasherClient);
                 const l1TxUtils = config.sequencerPublisherForwarderAddress ? await createForwarderL1TxUtilsFromSigners(publicClient, keyStoreManager.createAllValidatorPublisherSigners(), config.sequencerPublisherForwarderAddress, {
@@ -785,24 +1134,54 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                     slotDuration: Number(slotDuration),
                     rollupManaLimit
                 }, worldStateSynchronizer, archiver, dateProvider, telemetry, debugLogStore);
-                sequencer = await SequencerClient.new(config, {
-                    ...deps,
-                    epochCache,
-                    l1TxUtils,
-                    funderL1TxUtils,
-                    validatorClient,
-                    p2pClient,
-                    worldStateSynchronizer,
-                    slasherClient,
-                    checkpointsBuilder,
-                    l2BlockSource: archiver,
-                    l1ToL2MessageSource: archiver,
-                    telemetry,
-                    dateProvider,
-                    blobClient,
-                    nodeKeyStore: keyStoreManager,
-                    globalVariableBuilder
-                });
+                if (config.useAutomineSequencer) {
+                    // Test-only path: deterministic, queue-driven sequencer for non-block-building e2e tests.
+                    // See `AUTOMINE_E2E_OPTS` in `end-to-end/src/fixtures/fixtures.ts`.
+                    automineSequencer = await createAutomineSequencer({
+                        config,
+                        l1TxUtils,
+                        funderL1TxUtils,
+                        publicClient,
+                        rollupContract,
+                        epochCache,
+                        blobClient,
+                        telemetry,
+                        dateProvider,
+                        keyStoreManager: keyStoreManager,
+                        validatorClient,
+                        checkpointsBuilder,
+                        globalVariableBuilder,
+                        worldStateSynchronizer,
+                        archiver,
+                        p2pClient,
+                        l1Constants: {
+                            l1GenesisTime,
+                            slotDuration: Number(slotDuration),
+                            ethereumSlotDuration: config.ethereumSlotDuration,
+                            rollupManaLimit
+                        },
+                        log
+                    });
+                } else {
+                    sequencer = await SequencerClient.new(config, {
+                        ...deps,
+                        epochCache,
+                        l1TxUtils,
+                        funderL1TxUtils,
+                        validatorClient,
+                        p2pClient,
+                        worldStateSynchronizer,
+                        slasherClient,
+                        checkpointsBuilder,
+                        l2BlockSource: archiver,
+                        l1ToL2MessageSource: archiver,
+                        telemetry,
+                        dateProvider,
+                        blobClient,
+                        nodeKeyStore: keyStoreManager,
+                        globalVariableBuilder
+                    });
+                }
             }
             if (!options.dontStartSequencer && sequencer) {
                 await sequencer.start();
@@ -811,6 +1190,15 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             } else if (sequencer) {
                 log.warn(`Sequencer created but not started`);
             }
+            if (!options.dontStartSequencer && automineSequencer) {
+                await automineSequencer.start();
+                started.push({
+                    stop: ()=>automineSequencer.stop()
+                });
+                log.verbose(`AutomineSequencer started`);
+            } else if (automineSequencer) {
+                log.warn(`AutomineSequencer created but not started`);
+            }
             // Create prover node subsystem if enabled
             let proverNode;
             if (config.enableProverNode) {
@@ -833,7 +1221,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                     log.info(`Prover node subsystem created but not started`);
                 }
             }
-            const node = new AztecNodeService(config, p2pClient, archiver, archiver, archiver, archiver, worldStateSynchronizer, sequencer, proverNode, slasherClient, validatorsSentinel, epochPruneWatcher, ethereumChain.chainInfo.id, config.rollupVersion, globalVariableBuilder, feeProvider, epochCache, packageVersion, peerProofVerifier, rpcProofVerifier, telemetry, log, blobClient, validatorClient, keyStoreManager, debugLogStore);
+            const node = new AztecNodeService(config, p2pClient, archiver, archiver, archiver, archiver, worldStateSynchronizer, sequencer, proverNode, slasherClient, validatorsSentinel, stopStartedWatchers, ethereumChain.chainInfo.id, config.rollupVersion, globalVariableBuilder, feeProvider, epochCache, packageVersion, peerProofVerifier, rpcProofVerifier, telemetry, log, blobClient, validatorClient, keyStoreManager, debugLogStore, automineSequencer);
             return node;
         } catch (err) {
             log.error('Failed during node creation, stopping started resources', err);
@@ -849,6 +1237,9 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
    */ getSequencer() {
         return this.sequencer;
     }
+    /** Test-only: returns the AutomineSequencer when wired via `useAutomineSequencer`. */ getAutomineSequencer() {
+        return this.automineSequencer;
+    }
     /** Returns the prover node subsystem, if enabled. */ getProverNode() {
         return this.proverNode;
     }
@@ -865,7 +1256,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
    * Method to return the currently deployed L1 contract addresses.
    * @returns - The currently deployed L1 contract addresses.
    */ getL1ContractAddresses() {
-        return Promise.resolve(this.config.l1Contracts);
+        return Promise.resolve(pickL1ContractAddresses(this.config));
     }
     getEncodedEnr() {
         return Promise.resolve(this.p2pClient.getEnr()?.encodeTxt());
@@ -902,59 +1293,6 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         };
         return nodeInfo;
     }
-    /**
-   * Get a block specified by its block number, block hash, or 'latest'.
-   * @param block - The block parameter (block number, block hash, or 'latest').
-   * @returns The requested block.
-   */ async getBlock(block) {
-        if (BlockHash.isBlockHash(block)) {
-            return this.getBlockByHash(block);
-        }
-        const blockNumber = block === 'latest' ? await this.getBlockNumber() : block;
-        if (blockNumber === BlockNumber.ZERO) {
-            return this.buildInitialBlock();
-        }
-        return await this.blockSource.getL2Block(blockNumber);
-    }
-    /**
-   * Get a block specified by its hash.
-   * @param blockHash - The block hash being requested.
-   * @returns The requested block.
-   */ async getBlockByHash(blockHash) {
-        const initialBlockHash = await this.#getInitialHeaderHash();
-        if (blockHash.equals(initialBlockHash)) {
-            return this.buildInitialBlock();
-        }
-        return await this.blockSource.getL2BlockByHash(blockHash);
-    }
-    buildInitialBlock() {
-        const initialHeader = this.worldStateSynchronizer.getCommitted().getInitialHeader();
-        return L2Block.empty(initialHeader);
-    }
-    /**
-   * Get a block specified by its archive root.
-   * @param archive - The archive root being requested.
-   * @returns The requested block.
-   */ async getBlockByArchive(archive) {
-        return await this.blockSource.getL2BlockByArchive(archive);
-    }
-    /**
-   * Method to request blocks. Will attempt to return all requested blocks but will return only those available.
-   * @param from - The start of the range of blocks to return.
-   * @param limit - The maximum number of blocks to obtain.
-   * @returns The blocks requested.
-   */ async getBlocks(from, limit) {
-        return await this.blockSource.getBlocks(from, BlockNumber(limit)) ?? [];
-    }
-    async getCheckpoints(from, limit) {
-        return await this.blockSource.getCheckpoints(from, limit) ?? [];
-    }
-    async getCheckpointedBlocks(from, limit) {
-        return await this.blockSource.getCheckpointedBlocks(from, limit) ?? [];
-    }
-    getCheckpointsDataForEpoch(epochNumber) {
-        return this.blockSource.getCheckpointsDataForEpoch(epochNumber);
-    }
     async getCurrentMinFees() {
         return await this.feeProvider.getCurrentMinFees();
     }
@@ -971,21 +1309,6 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         });
     }
     /**
-   * Method to fetch the latest block number synchronized by the node.
-   * @returns The block number.
-   */ async getBlockNumber() {
-        return await this.blockSource.getBlockNumber();
-    }
-    async getProvenBlockNumber() {
-        return await this.blockSource.getProvenBlockNumber();
-    }
-    async getCheckpointedBlockNumber() {
-        return await this.blockSource.getCheckpointedL2BlockNumber();
-    }
-    getCheckpointNumber() {
-        return this.blockSource.getCheckpointNumber();
-    }
-    /**
    * Method to fetch the version of the package.
    * @returns The node package version
    */ getNodeVersion() {
@@ -1009,51 +1332,11 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     getContract(address) {
         return this.contractDataSource.getContract(address);
     }
-    async getPrivateLogsByTags(tags, page, referenceBlock) {
-        let upToBlockNumber;
-        if (referenceBlock) {
-            const initialBlockHash = await this.#getInitialHeaderHash();
-            if (referenceBlock.equals(initialBlockHash)) {
-                upToBlockNumber = BlockNumber(0);
-            } else {
-                const header = await this.blockSource.getBlockHeaderByHash(referenceBlock);
-                if (!header) {
-                    throw new Error(`Block ${referenceBlock.toString()} not found in the node. This might indicate a reorg has occurred.`);
-                }
-                upToBlockNumber = header.globalVariables.blockNumber;
-            }
-        }
-        return this.logsSource.getPrivateLogsByTags(tags, page, upToBlockNumber);
+    getPrivateLogsByTags(query) {
+        return this.logsSource.getPrivateLogsByTags(query);
     }
-    async getPublicLogsByTagsFromContract(contractAddress, tags, page, referenceBlock) {
-        let upToBlockNumber;
-        if (referenceBlock) {
-            const initialBlockHash = await this.#getInitialHeaderHash();
-            if (referenceBlock.equals(initialBlockHash)) {
-                upToBlockNumber = BlockNumber(0);
-            } else {
-                const header = await this.blockSource.getBlockHeaderByHash(referenceBlock);
-                if (!header) {
-                    throw new Error(`Block ${referenceBlock.toString()} not found in the node. This might indicate a reorg has occurred.`);
-                }
-                upToBlockNumber = header.globalVariables.blockNumber;
-            }
-        }
-        return this.logsSource.getPublicLogsByTagsFromContract(contractAddress, tags, page, upToBlockNumber);
-    }
-    /**
-   * Gets public logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */ getPublicLogs(filter) {
-        return this.logsSource.getPublicLogs(filter);
-    }
-    /**
-   * Gets contract class logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */ getContractClassLogs(filter) {
-        return this.logsSource.getContractClassLogs(filter);
+    getPublicLogsByTags(query) {
+        return this.logsSource.getPublicLogsByTags(query);
     }
     /**
    * Method to submit a transaction to the p2p pool.
@@ -1073,35 +1356,74 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             });
             throw new Error(`Invalid tx: ${reason}`);
         }
-        await this.p2pClient.sendTx(tx);
+        try {
+            await this.p2pClient.sendTx(tx);
+        } catch (err) {
+            this.metrics.receivedTx(timer.ms(), false);
+            this.log.warn(`Mempool rejected tx ${txHash}: ${err.message}`, {
+                txHash
+            });
+            throw err;
+        }
         const duration = timer.ms();
         this.metrics.receivedTx(duration, true);
         this.log.info(`Received tx ${txHash} in ${duration}ms`, {
             txHash
         });
     }
-    async getTxReceipt(txHash) {
+    async getTxReceipt(txHash, options) {
         // Check the tx pool status first. If the tx is known to the pool (pending or mined), we'll use that
-        // as a fallback if we don't find a settled receipt in the archiver.
+        // as a fallback if we don't find a mined tx effect in the archiver.
         const txPoolStatus = await this.p2pClient.getTxStatus(txHash);
         const isKnownToPool = txPoolStatus === 'pending' || txPoolStatus === 'mined';
-        // Then get the actual tx from the archiver, which tracks every tx in a mined block.
-        const settledTxReceipt = await this.blockSource.getSettledTxReceipt(txHash);
+        // Then get the raw tx effect from the archiver, which tracks every tx in a mined block.
+        const indexed = await this.blockSource.getTxEffect(txHash);
         let receipt;
-        if (settledTxReceipt) {
-            receipt = settledTxReceipt;
+        if (indexed) {
+            receipt = await this.#assembleMinedReceipt(indexed, options);
         } else if (isKnownToPool) {
             // If the tx is in the pool but not in the archiver, it's pending.
             // This handles race conditions between archiver and p2p, where the archiver
             // has pruned the block in which a tx was mined, but p2p has not caught up yet.
-            receipt = new TxReceipt(txHash, TxStatus.PENDING, undefined, undefined);
+            let tx;
+            if (options?.includePendingTx) {
+                // The tx may have left the pool since we checked its status (mined or dropped); in that case we
+                // leave `tx` unset and still return a pending receipt.
+                const pendingTx = await this.p2pClient.getTxByHashFromPool(txHash);
+                tx = pendingTx && !options.includeProof ? pendingTx.withoutProof() : pendingTx;
+            }
+            receipt = new PendingTxReceipt(txHash, tx);
         } else {
             // Otherwise, if we don't know the tx, we consider it dropped.
-            receipt = new TxReceipt(txHash, TxStatus.DROPPED, undefined, 'Tx dropped by P2P node');
+            receipt = new DroppedTxReceipt(txHash, 'Tx dropped by P2P node');
         }
         this.debugLogStore.decorateReceiptWithLogs(txHash.toString(), receipt);
         return receipt;
     }
+    /**
+   * Assembles a {@link MinedTxReceipt} from a raw {@link IndexedTxEffect}, deriving the finalization status from the
+   * cached L2 tips and the epoch from the block's slot number.
+   */ async #assembleMinedReceipt(indexed, options) {
+        const blockNumber = indexed.l2BlockNumber;
+        const [tips, l1Constants] = await Promise.all([
+            this.blockSource.getL2Tips(),
+            this.blockSource.getL1Constants()
+        ]);
+        const status = this.#deriveMinedStatus(blockNumber, tips);
+        const epochNumber = getEpochAtSlot(indexed.slotNumber, l1Constants);
+        return new MinedTxReceipt(indexed.data.txHash, status, MinedTxReceipt.executionResultFromRevertCode(indexed.data.revertCode), indexed.data.transactionFee.toBigInt(), indexed.l2BlockHash, blockNumber, indexed.slotNumber, indexed.txIndexInBlock, epochNumber, options?.includeTxEffect ? indexed.data : undefined, /*debugLogs=*/ undefined);
+    }
+    #deriveMinedStatus(blockNumber, tips) {
+        if (blockNumber <= tips.finalized.block.number) {
+            return TxStatus.FINALIZED;
+        } else if (blockNumber <= tips.proven.block.number) {
+            return TxStatus.PROVEN;
+        } else if (blockNumber <= tips.checkpointed.block.number) {
+            return TxStatus.CHECKPOINTED;
+        } else {
+            return TxStatus.PROPOSED;
+        }
+    }
     getTxEffect(txHash) {
         return this.blockSource.getTxEffect(txHash);
     }
@@ -1109,14 +1431,14 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
    * Method to stop the aztec node.
    */ async stop() {
         this.log.info(`Stopping Aztec Node`);
-        await tryStop(this.validatorsSentinel);
-        await tryStop(this.epochPruneWatcher);
+        await this.stopStartedWatchers();
         await tryStop(this.slasherClient);
         await Promise.all([
             tryStop(this.peerProofVerifier),
             tryStop(this.rpcProofVerifier)
         ]);
         await tryStop(this.sequencer);
+        await tryStop(this.automineSequencer);
         await tryStop(this.proverNode);
         await tryStop(this.p2pClient);
         await tryStop(this.worldStateSynchronizer);
@@ -1247,25 +1569,28 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     }
     async getL1ToL2MessageCheckpoint(l1ToL2Message) {
         const messageIndex = await this.l1ToL2MessageSource.getL1ToL2MessageIndex(l1ToL2Message);
-        return messageIndex ? InboxLeaf.checkpointNumberFromIndex(messageIndex) : undefined;
-    }
-    /**
-   * Returns whether an L1 to L2 message is synced by archiver and if it's ready to be included in a block.
-   * @param l1ToL2Message - The L1 to L2 message to check.
-   * @returns Whether the message is synced and ready to be included in a block.
-   */ async isL1ToL2MessageSynced(l1ToL2Message) {
-        const messageIndex = await this.l1ToL2MessageSource.getL1ToL2MessageIndex(l1ToL2Message);
-        return messageIndex !== undefined;
+        return messageIndex !== undefined ? InboxLeaf.checkpointNumberFromIndex(messageIndex) : undefined;
     }
     /**
    * Returns all the L2 to L1 messages in an epoch.
+   *
+   * @deprecated Use {@link getL2ToL1MembershipWitness} to get an L2-to-L1 message witness directly.
+   *
    * @param epoch - The epoch at which to get the data.
    * @returns The L2 to L1 messages (empty array if the epoch is not found).
    */ async getL2ToL1Messages(epoch) {
-        // Assumes `getCheckpointedBlocksForEpoch` returns blocks in ascending order of block number.
-        const checkpointedBlocks = await this.blockSource.getCheckpointedBlocksForEpoch(epoch);
-        const blocksInCheckpoints = chunkBy(checkpointedBlocks, (cb)=>cb.block.header.globalVariables.slotNumber).map((group)=>group.map((cb)=>cb.block));
-        return blocksInCheckpoints.map((blocks)=>blocks.map((block)=>block.body.txEffects.map((txEffect)=>txEffect.l2ToL1Msgs)));
+        const blocks = await this.blockSource.getBlocks({
+            epoch,
+            onlyCheckpointed: true
+        });
+        const blocksInCheckpoints = chunkBy(blocks, (block)=>block.header.globalVariables.slotNumber);
+        return blocksInCheckpoints.map((slotBlocks)=>slotBlocks.map((block)=>block.body.txEffects.map((txEffect)=>txEffect.l2ToL1Msgs)));
+    }
+    /**
+   * Returns the L2-to-L1 membership witness for a message in `txHash`. Passthrough to the
+   * archiver's locally-cached resolver — see {@link Archiver.getL2ToL1MembershipWitness}.
+   */ getL2ToL1MembershipWitness(txHash, message, messageIndexInTx) {
+        return this.blockSource.getL2ToL1MembershipWitness(txHash, message, messageIndexInTx);
     }
     async getNullifierMembershipWitness(referenceBlock, nullifier) {
         const db = await this.getWorldState(referenceBlock);
@@ -1317,64 +1642,62 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         const preimage = await committedDb.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
         return preimage.leaf.value;
     }
-    async getBlockHeader(block = 'latest') {
-        if (BlockHash.isBlockHash(block)) {
-            const initialBlockHash = await this.#getInitialHeaderHash();
-            if (block.equals(initialBlockHash)) {
-                // Block source doesn't handle initial header so we need to handle the case separately.
-                return this.worldStateSynchronizer.getCommitted().getInitialHeader();
-            }
-            return this.blockSource.getBlockHeaderByHash(block);
-        } else {
-            // Block source doesn't handle initial header so we need to handle the case separately.
-            const blockNumber = block === 'latest' ? await this.getBlockNumber() : block;
-            if (blockNumber === BlockNumber.ZERO) {
-                return this.worldStateSynchronizer.getCommitted().getInitialHeader();
-            }
-            return this.blockSource.getBlockHeader(block);
-        }
-    }
-    /**
-   * Get a block header specified by its archive root.
-   * @param archive - The archive root being requested.
-   * @returns The requested block header.
-   */ async getBlockHeaderByArchive(archive) {
-        return await this.blockSource.getBlockHeaderByArchive(archive);
-    }
-    getBlockData(number) {
-        return this.blockSource.getBlockData(number);
-    }
-    getBlockDataByArchive(archive) {
-        return this.blockSource.getBlockDataByArchive(archive);
-    }
     /**
    * Simulates the public part of a transaction with the current state.
    * @param tx - The transaction to simulate.
-   **/ async simulatePublicCalls(tx, skipFeeEnforcement = false) {
-        // Check total gas limit for simulation
-        const gasSettings = tx.data.constants.txContext.gasSettings;
-        const txGasLimit = gasSettings.gasLimits.l2Gas;
-        const teardownGasLimit = gasSettings.teardownGasLimits.l2Gas;
-        if (txGasLimit + teardownGasLimit > this.config.rpcSimulatePublicMaxGasLimit) {
-            throw new BadRequestError(`Transaction total gas limit ${txGasLimit + teardownGasLimit} (${txGasLimit} + ${teardownGasLimit}) exceeds maximum gas limit ${this.config.rpcSimulatePublicMaxGasLimit} for simulation`);
-        }
-        const txHash = tx.getTxHash();
-        const latestBlockNumber = await this.blockSource.getBlockNumber();
-        const blockNumber = BlockNumber.add(latestBlockNumber, 1);
-        // If sequencer is not initialized, we just set these values to zero for simulation.
-        const coinbase = EthAddress.ZERO;
-        const feeRecipient = AztecAddress.ZERO;
-        const newGlobalVariables = await this.globalVariableBuilder.buildGlobalVariables(blockNumber, coinbase, feeRecipient);
-        const publicProcessorFactory = new PublicProcessorFactory(this.contractDataSource, new DateProvider(), this.telemetry, this.log.getBindings());
-        this.log.verbose(`Simulating public calls for tx ${txHash}`, {
-            globalVariables: newGlobalVariables.toInspect(),
-            txHash,
-            blockNumber
-        });
-        // Ensure world-state has caught up with the latest block we loaded from the archiver
-        await this.worldStateSynchronizer.syncImmediate(latestBlockNumber);
-        const merkleTreeFork = await this.worldStateSynchronizer.fork();
+   * @param skipFeeEnforcement - If true, fee enforcement is skipped.
+   * @param overrides - Optional pre-simulation overrides applied to the ephemeral fork and contract DB.
+   **/ async simulatePublicCalls(tx, skipFeeEnforcement = false, overrides) {
+        const env = {
+            stack: [],
+            error: void 0,
+            hasError: false
+        };
         try {
+            // Check total gas limit for simulation
+            const gasSettings = tx.data.constants.txContext.gasSettings;
+            const txGasLimit = gasSettings.gasLimits.l2Gas;
+            const teardownGasLimit = gasSettings.teardownGasLimits.l2Gas;
+            if (txGasLimit + teardownGasLimit > this.config.rpcSimulatePublicMaxGasLimit) {
+                throw new BadRequestError(`Transaction total gas limit ${txGasLimit + teardownGasLimit} (${txGasLimit} + ${teardownGasLimit}) exceeds maximum gas limit ${this.config.rpcSimulatePublicMaxGasLimit} for simulation`);
+            }
+            const txHash = tx.getTxHash();
+            const l2Tips = await this.blockSource.getL2Tips();
+            const latestBlockNumber = l2Tips.proposed.number;
+            const blockNumber = BlockNumber.add(latestBlockNumber, 1);
+            // If sequencer is not initialized, we just set these values to zero for simulation.
+            const coinbase = EthAddress.ZERO;
+            const feeRecipient = AztecAddress.ZERO;
+            const newGlobalVariables = await this.globalVariableBuilder.buildGlobalVariables(blockNumber, coinbase, feeRecipient);
+            const publicProcessorFactory = new PublicProcessorFactory(this.contractDataSource, new DateProvider(), this.telemetry, this.log.getBindings());
+            this.log.verbose(`Simulating public calls for tx ${txHash}`, {
+                globalVariables: newGlobalVariables.toInspect(),
+                txHash,
+                blockNumber
+            });
+            // Ensure world-state has caught up with the latest block we loaded from the archiver
+            await this.worldStateSynchronizer.syncImmediate(latestBlockNumber);
+            // If we detect the next block would start a new checkpoint, then insert L1-to-L2 messages into
+            // the world state tree so simulation can take them into account. We detect if the next block would
+            // start a new checkpoint by checking if the proposed checkpoint's block number matches the latest block number,
+            // which means the next block would be the first block of the next checkpoint.
+            const targetCheckpoint = CheckpointNumber((l2Tips.proposedCheckpoint.checkpoint.number ?? CheckpointNumber.ZERO) + 1);
+            const nextCheckpointMessages = l2Tips.proposedCheckpoint.block.number === l2Tips.proposed.number ? await this.l1ToL2MessageSource.getL1ToL2Messages(targetCheckpoint).catch((err)=>{
+                if (isErrorClass(err, L1ToL2MessagesNotReadyError)) {
+                    this.log.warn(`L1-to-L2 messages for checkpoint ${targetCheckpoint} are not ready yet (simulating without them)`);
+                } else {
+                    this.log.error(`Failed to get L1-to-L2 messages for checkpoint ${targetCheckpoint} (simulating without them)`, err);
+                }
+                return undefined;
+            }) : undefined;
+            const merkleTreeFork = _ts_add_disposable_resource(env, await this.worldStateSynchronizer.fork(latestBlockNumber), true);
+            if (nextCheckpointMessages !== undefined) {
+                this.log.debug(`Appending ${nextCheckpointMessages.length} L1-to-L2 messages to the world state tree for the next checkpoint`, {
+                    checkpointNumber: l2Tips.proposedCheckpoint.checkpoint.number + 1
+                });
+                await appendL1ToL2MessagesToTree(merkleTreeFork, nextCheckpointMessages);
+            }
+            await applyPublicDataOverrides(merkleTreeFork, overrides?.publicStorage);
             const config = PublicSimulatorConfig.from({
                 skipFeeEnforcement,
                 collectDebugLogs: true,
@@ -1385,7 +1708,11 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                     maxDebugLogMemoryReads: this.config.rpcSimulatePublicMaxDebugLogMemoryReads
                 })
             });
-            const processor = publicProcessorFactory.create(merkleTreeFork, newGlobalVariables, config);
+            const contractsDB = new PublicContractsDB(this.contractDataSource, this.log.getBindings());
+            if (overrides?.contracts) {
+                contractsDB.addContracts(Object.values(overrides.contracts).map(({ instance })=>instance));
+            }
+            const processor = publicProcessorFactory.create(merkleTreeFork, newGlobalVariables, config, contractsDB);
             // REFACTOR: Consider merging ProcessReturnValues into ProcessedTx
             const [processedTxs, failedTxs, _usedTxs, returns, debugLogs] = await processor.process([
                 tx
@@ -1399,8 +1726,12 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             }
             const [processedTx] = processedTxs;
             return new PublicSimulationOutput(processedTx.revertReason, processedTx.globalVariables, processedTx.txEffect, returns, processedTx.gasUsed, debugLogs);
+        } catch (e) {
+            env.error = e;
+            env.hasError = true;
         } finally{
-            await merkleTreeFork.close();
+            const result = _ts_dispose_resources(env);
+            if (result) await result;
         }
     }
     async isValidTx(tx, { isSimulation, skipFeeEnforcement } = {}) {
@@ -1438,7 +1769,20 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             ...this.config,
             ...config
         };
-        this.sequencer?.updateConfig(config);
+        // If the sequencer is currently paused via pauseSequencer(), record the caller's desired
+        // minTxsPerBlock as the restore value (so resumeSequencer applies it) and keep the freeze
+        // (MAX_SAFE_INTEGER) applied to the underlying sequencer. Without this guard, forwarding
+        // the new minTxsPerBlock to the sequencer would silently unpause block production while
+        // pauseSequencer() still considers it paused.
+        const sequencerUpdate = {
+            ...config
+        };
+        if (this.sequencerPausedMinTxsPerBlock !== undefined && sequencerUpdate.minTxsPerBlock !== undefined) {
+            this.sequencerPausedMinTxsPerBlock = sequencerUpdate.minTxsPerBlock;
+            delete sequencerUpdate.minTxsPerBlock;
+        }
+        this.sequencer?.updateConfig(sequencerUpdate);
+        this.automineSequencer?.updateConfig(sequencerUpdate);
         this.slasherClient?.updateConfig(config);
         this.validatorsSentinel?.updateConfig(config);
         await this.p2pClient.updateP2PConfig(config);
@@ -1467,7 +1811,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             classRegistry: ProtocolContractAddress.ContractClassRegistry,
             feeJuice: ProtocolContractAddress.FeeJuice,
             instanceRegistry: ProtocolContractAddress.ContractInstanceRegistry,
-            multiCallEntrypoint: ProtocolContractAddress.MultiCallEntrypoint
+            multiCallEntrypoint: STANDARD_MULTI_CALL_ENTRYPOINT_ADDRESS
         });
     }
     registerContractFunctionSignatures(signatures) {
@@ -1566,6 +1910,45 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         this.blockSource.resume();
         return Promise.resolve();
     }
+    pauseSequencer() {
+        if (this.automineSequencer) {
+            this.automineSequencer.pause();
+            return Promise.resolve();
+        }
+        if (this.sequencer) {
+            if (this.sequencerPausedMinTxsPerBlock === undefined) {
+                this.sequencerPausedMinTxsPerBlock = this.sequencer.getSequencer().getConfig().minTxsPerBlock ?? 0;
+                this.sequencer.updateConfig({
+                    minTxsPerBlock: Number.MAX_SAFE_INTEGER
+                });
+                this.log.info(`Sequencer paused (minTxsPerBlock set to MAX_SAFE_INTEGER)`, {
+                    previousMinTxsPerBlock: this.sequencerPausedMinTxsPerBlock
+                });
+            }
+            return Promise.resolve();
+        }
+        throw new BadRequestError('Cannot pause sequencer: no sequencer is running');
+    }
+    resumeSequencer() {
+        if (this.automineSequencer) {
+            this.automineSequencer.resume();
+            return Promise.resolve();
+        }
+        if (this.sequencer) {
+            if (this.sequencerPausedMinTxsPerBlock !== undefined) {
+                const restored = this.sequencerPausedMinTxsPerBlock;
+                this.sequencerPausedMinTxsPerBlock = undefined;
+                this.sequencer.updateConfig({
+                    minTxsPerBlock: restored
+                });
+                this.log.info(`Sequencer resumed (minTxsPerBlock restored)`, {
+                    minTxsPerBlock: restored
+                });
+            }
+            return Promise.resolve();
+        }
+        throw new BadRequestError('Cannot resume sequencer: no sequencer is running');
+    }
     getSlashOffenses(round) {
         if (!this.slasherClient) {
             throw new Error(`Slasher client not enabled`);
@@ -1644,6 +2027,10 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         this.log.info('Keystore reloaded: coinbase, feeRecipient, and attester keys updated');
     }
     async mineBlock() {
+        if (this.automineSequencer) {
+            await this.automineSequencer.buildEmptyBlock();
+            return;
+        }
         if (!this.sequencer) {
             throw new BadRequestError('Cannot mine block: no sequencer is running');
         }
@@ -1670,85 +2057,73 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             });
         }
     }
-    #getInitialHeaderHash() {
-        if (!this.initialHeaderHashPromise) {
-            this.initialHeaderHashPromise = this.worldStateSynchronizer.getCommitted().getInitialHeader().hash();
-        }
-        return this.initialHeaderHashPromise;
-    }
     /**
    * Returns an instance of MerkleTreeOperations having first ensured the world state is fully synched
    * @param block - The block parameter (block number, block hash, or 'latest') at which to get the data.
    * @returns An instance of a committed MerkleTreeOperations
    */ async getWorldState(block) {
+        const query = this.normalizeBlockParameter(block);
+        // When the request anchors on a specific block hash, resolve it against the archiver up front and
+        // drive the world-state sync to that exact block number and hash. Resolving against the archiver
+        // first fails fast with a clear reorg error if the hash is unknown, and passing the hash to the
+        // synchronizer makes the sync reorg-aware: it barriers until the archive-tree commit for that block
+        // has landed and verifies it matches the requested fork, instead of syncing to bare latest height
+        // and then racing the snapshot read below against an in-flight archive-tree write.
+        const requestedHash = 'hash' in query ? query.hash : undefined;
+        const anchorBlockNumber = requestedHash !== undefined ? await this.resolveBlockNumber(query) : undefined;
         let blockSyncedTo = BlockNumber.ZERO;
         try {
             // Attempt to sync the world state if necessary
-            blockSyncedTo = await this.#syncWorldState();
+            blockSyncedTo = await this.#syncWorldState(anchorBlockNumber, requestedHash);
         } catch (err) {
             this.log.error(`Error getting world state: ${err}`);
         }
-        if (block === 'latest') {
-            this.log.debug(`Using committed db for block 'latest', world state synced upto ${blockSyncedTo}`);
+        if ('tag' in query && query.tag === 'proposed') {
+            this.log.debug(`Using committed db for latest block, world state synced upto ${blockSyncedTo}`);
             return this.worldStateSynchronizer.getCommitted();
         }
-        // Get the block number, either directly from the parameter or by quering the archiver with the block hash
-        let blockNumber;
-        if (BlockHash.isBlockHash(block)) {
-            const initialBlockHash = await this.#getInitialHeaderHash();
-            if (block.equals(initialBlockHash)) {
-                // Block 0 is a first-class historical block: its state lives in the trees' persisted
-                // block-0 payload. Resolving the genesis hash to block number 0 lets the snapshot path
-                // pin reads to genesis state even after the node has advanced past it.
-                blockNumber = BlockNumber.ZERO;
-            } else {
-                const header = await this.blockSource.getBlockHeaderByHash(block);
-                if (!header) {
-                    throw new Error(`Block hash ${block.toString()} not found when querying world state. If the node API has been queried with anchor block hash possibly a reorg has occurred.`);
-                }
-                blockNumber = header.getBlockNumber();
-            }
-        } else {
-            blockNumber = block;
-        }
+        const blockNumber = anchorBlockNumber ?? await this.resolveBlockNumber(query);
         // Check it's within world state sync range
         if (blockNumber > blockSyncedTo) {
-            throw new Error(`Queried block ${block} not yet synced by the node (node is synced upto ${blockSyncedTo}).`);
+            throw new Error(`Queried block ${inspectBlockParameter(block)} not yet synced by the node (node is synced upto ${blockSyncedTo}).`);
         }
         this.log.debug(`Using snapshot for block ${blockNumber}, world state synced upto ${blockSyncedTo}`);
         const snapshot = this.worldStateSynchronizer.getSnapshot(blockNumber);
-        // Double-check world-state synced to the same block hash as was requested
-        if (BlockHash.isBlockHash(block)) {
+        // Double-check world-state synced to the same block hash as was requested.
+        // Block 0 is skipped: the snapshot returned by `getSnapshot(0)` is the *pre*-genesis archive
+        // (size 0), so leaf 0 is not yet inserted from that snapshot's view even though block 0's hash
+        // does live at archive index 0 in the committed tree. The genesis hash is already validated by
+        // the archiver when it resolves the hash query to block number 0.
+        if (requestedHash !== undefined && blockNumber !== BlockNumber.ZERO) {
             const blockHash = await snapshot.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(blockNumber));
-            if (!blockHash || !block.equals(blockHash)) {
-                const initialBlockHash = await this.#getInitialHeaderHash();
-                throw new Error(`Block hash ${block.toString()} not found in world state at block number ${blockNumber} (world state has ${blockHash?.toString() ?? 'no hash'} at that index, genesis header hash is ${initialBlockHash.toString()}). If the node API has been queried with anchor block hash possibly a reorg has occurred.`);
+            if (!blockHash || !requestedHash.equals(blockHash)) {
+                throw new Error(`Block hash ${requestedHash.toString()} not found in world state at block number ${blockNumber} (world state has ${blockHash?.toString() ?? 'no hash'} at that index, genesis header hash is ${this.blockSource.getGenesisBlockHash().toString()}). If the node API has been queried with anchor block hash possibly a reorg has occurred.`);
             }
         }
         return snapshot;
     }
-    /** Resolves a block parameter to a block number. */ async resolveBlockNumber(block) {
-        if (block === 'latest') {
-            return BlockNumber(await this.blockSource.getBlockNumber());
-        }
-        if (BlockHash.isBlockHash(block)) {
-            const initialBlockHash = await this.#getInitialHeaderHash();
-            if (block.equals(initialBlockHash)) {
-                return BlockNumber.ZERO;
+    /** Resolves any {@link BlockParameter} variant to a concrete block number. */ async resolveBlockNumber(block) {
+        const query = this.normalizeBlockParameter(block);
+        const blockNumber = await this.blockSource.getBlockNumber(query);
+        if (blockNumber === undefined) {
+            if ('hash' in query) {
+                throw new Error(`Block hash ${query.hash.toString()} not found when querying world state. If the node API has been queried with anchor block hash possibly a reorg has occurred.`);
             }
-            const header = await this.blockSource.getBlockHeaderByHash(block);
-            if (!header) {
-                throw new Error(`Block hash ${block.toString()} not found.`);
+            if ('archive' in query) {
+                throw new Error(`Block with archive ${query.archive.toString()} not found.`);
             }
-            return header.getBlockNumber();
+            throw new Error(`Block not found for ${inspectBlockParameter(block)}.`);
         }
-        return block;
+        return blockNumber;
     }
     /**
-   * Ensure we fully sync the world state
+   * Ensure the world state is synced.
+   * @param targetBlockNumber - Block to sync up to. Defaults to the latest block known to the archiver.
+   * @param blockHash - If provided, the synchronizer verifies the block at `targetBlockNumber` matches this
+   * hash, resyncing (and so detecting reorgs) if it does not yet match or has been reorged away.
    * @returns A promise that fulfils once the world state is synced
-   */ async #syncWorldState() {
-        const blockSourceHeight = await this.blockSource.getBlockNumber();
-        return await this.worldStateSynchronizer.syncImmediate(blockSourceHeight);
+   */ async #syncWorldState(targetBlockNumber, blockHash) {
+        const target = targetBlockNumber ?? await this.blockSource.getBlockNumber();
+        return await this.worldStateSynchronizer.syncImmediate(target, blockHash);
     }
 }