@aztec/aztec-node 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/dest/aztec-node/server.js

@@ -1,68 +1,3 @@
-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) {
@@ -436,67 +371,59 @@ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
     return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
 }
 var _dec, _initProto;
-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';
-import { Blob } from '@aztec/blob-lib';
-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 { 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 { BlockNumber } from '@aztec/foundation/branded-types';
+import { compactArray, pick, unique } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { BadRequestError } from '@aztec/foundation/json-rpc';
 import { createLogger } from '@aztec/foundation/log';
 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 { Timer } from '@aztec/foundation/timer';
 import { KeystoreManager, loadKeystores, mergeKeystores } from '@aztec/node-keystore';
-import { trySnapshotSync, uploadSnapshot } from '@aztec/node-lib/actions';
-import { createForwarderL1TxUtilsFromSigners, createL1TxUtilsFromSigners } from '@aztec/node-lib/factories';
-import { createP2PClient, createTxValidatorForAcceptingTxsOverRPC, getDefaultAllowedSetupFunctions } from '@aztec/p2p';
+import { uploadSnapshot } from '@aztec/node-lib/actions';
+import { createTxValidatorForAcceptingTxsOverRPC, getDefaultAllowedSetupFunctions } from '@aztec/p2p';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { createProverNode } from '@aztec/prover-node';
-import { createKeyStoreForProver } from '@aztec/prover-node/config';
-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, BlockTag, inspectBlockParameter } from '@aztec/stdlib/block';
-import { CheckpointReexecutionTracker } from '@aztec/stdlib/checkpoint';
-import { GasFees } from '@aztec/stdlib/gas';
-import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
+import { inspectBlockParameter } from '@aztec/stdlib/block';
+import { GasFees, getNetworkTxGasLimits } from '@aztec/stdlib/gas';
 import { AztecNodeAdminConfigSchema } from '@aztec/stdlib/interfaces/client';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
-import { InMemoryDebugLogStore, NullDebugLogStore } from '@aztec/stdlib/logs';
-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 { getPackageVersion } from '@aztec/stdlib/update-checker';
+import { NullDebugLogStore } from '@aztec/stdlib/logs';
 import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
-import { FullNodeCheckpointsBuilder as CheckpointsBuilder, FullNodeCheckpointsBuilder, NodeKeystoreAdapter, ValidatorClient, createProposalHandler, createValidatorClient } from '@aztec/validator-client';
-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 { NodeKeystoreAdapter, ValidatorClient } from '@aztec/validator-client';
+import { NodeBlockProvider } from '../modules/node_block_provider.js';
+import { NodeTxReceiptBuilder } from '../modules/node_tx_receipt.js';
+import { NodeWorldStateQueries } from '../modules/node_world_state_queries.js';
 import { NodeMetrics } from './node_metrics.js';
-import { applyPublicDataOverrides } from './public_data_overrides.js';
+import { NodePublicCallsSimulator } from './node_public_calls_simulator.js';
 _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         [Attributes.TX_HASH]: tx.getTxHash().toString()
     }));
 /**
  * The aztec node.
  */ export class AztecNodeService {
+    static{
+        ({ e: [_initProto] } = _apply_decs_2203_r(this, [
+            [
+                _dec,
+                2,
+                "simulatePublicCalls"
+            ]
+        ], []));
+    }
+    metrics;
+    // Prevent two snapshot operations to happen simultaneously
+    isUploadingSnapshot = (_initProto(this), false);
+    // Saved minTxsPerBlock used by `pauseSequencer` to restore production-sequencer config on resume.
+    sequencerPausedMinTxsPerBlock;
+    nodePublicCallsSimulator;
+    worldStateQueries;
+    blockProvider;
+    txReceiptBuilder;
+    tracer;
     config;
     p2pClient;
     blockSource;
@@ -512,6 +439,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     l1ChainId;
     version;
     globalVariableBuilder;
+    rollupContract;
     feeProvider;
     epochCache;
     packageVersion;
@@ -524,58 +452,76 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     keyStoreManager;
     debugLogStore;
     automineSequencer;
-    static{
-        ({ e: [_initProto] } = _apply_decs_2203_r(this, [
-            [
-                _dec,
-                2,
-                "simulatePublicCalls"
-            ]
-        ], []));
-    }
-    metrics;
-    // 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, 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;
-        this.logsSource = logsSource;
-        this.contractDataSource = contractDataSource;
-        this.l1ToL2MessageSource = l1ToL2MessageSource;
-        this.worldStateSynchronizer = worldStateSynchronizer;
-        this.sequencer = sequencer;
-        this.proverNode = proverNode;
-        this.slasherClient = slasherClient;
-        this.validatorsSentinel = validatorsSentinel;
-        this.stopStartedWatchers = stopStartedWatchers;
-        this.l1ChainId = l1ChainId;
-        this.version = version;
-        this.globalVariableBuilder = globalVariableBuilder;
-        this.feeProvider = feeProvider;
-        this.epochCache = epochCache;
-        this.packageVersion = packageVersion;
-        this.peerProofVerifier = peerProofVerifier;
-        this.rpcProofVerifier = rpcProofVerifier;
-        this.telemetry = telemetry;
-        this.log = log;
-        this.blobClient = blobClient;
-        this.validatorClient = validatorClient;
-        this.keyStoreManager = keyStoreManager;
-        this.debugLogStore = debugLogStore;
-        this.automineSequencer = automineSequencer;
-        this.isUploadingSnapshot = (_initProto(this), false);
-        this.metrics = new NodeMetrics(telemetry, 'AztecNodeService');
-        this.tracer = telemetry.getTracer('AztecNodeService');
+    avmSimulator;
+    constructor(deps){
+        this.config = deps.config;
+        this.p2pClient = deps.p2pClient;
+        this.blockSource = deps.blockSource;
+        this.logsSource = deps.logsSource;
+        this.contractDataSource = deps.contractDataSource;
+        this.l1ToL2MessageSource = deps.l1ToL2MessageSource;
+        this.worldStateSynchronizer = deps.worldStateSynchronizer;
+        this.sequencer = deps.sequencer;
+        this.proverNode = deps.proverNode;
+        this.slasherClient = deps.slasherClient;
+        this.validatorsSentinel = deps.validatorsSentinel;
+        this.stopStartedWatchers = deps.stopStartedWatchers;
+        this.l1ChainId = deps.l1ChainId;
+        this.version = deps.version;
+        this.globalVariableBuilder = deps.globalVariableBuilder;
+        this.rollupContract = deps.rollupContract;
+        this.feeProvider = deps.feeProvider;
+        this.epochCache = deps.epochCache;
+        this.packageVersion = deps.packageVersion;
+        this.peerProofVerifier = deps.peerProofVerifier;
+        this.rpcProofVerifier = deps.rpcProofVerifier;
+        this.telemetry = deps.telemetry ?? getTelemetryClient();
+        this.log = deps.log ?? createLogger('node');
+        this.blobClient = deps.blobClient;
+        this.validatorClient = deps.validatorClient;
+        this.keyStoreManager = deps.keyStoreManager;
+        this.debugLogStore = deps.debugLogStore ?? new NullDebugLogStore();
+        this.automineSequencer = deps.automineSequencer;
+        this.avmSimulator = deps.avmSimulator;
+        this.metrics = new NodeMetrics(this.telemetry, 'AztecNodeService');
+        this.tracer = this.telemetry.getTracer('AztecNodeService');
+        // The node never represents a proposer's payout addresses, so the simulator zeroes coinbase and
+        // fee recipient. The signature context only needs chain id + rollup address (see signature_utils).
+        this.nodePublicCallsSimulator = new NodePublicCallsSimulator({
+            blockSource: this.blockSource,
+            worldStateSynchronizer: this.worldStateSynchronizer,
+            l1ToL2MessageSource: this.l1ToL2MessageSource,
+            contractDataSource: this.contractDataSource,
+            globalVariableBuilder: this.globalVariableBuilder,
+            rollupContract: this.rollupContract,
+            epochCache: this.epochCache,
+            signatureContext: {
+                chainId: this.l1ChainId,
+                rollupAddress: this.config.rollupAddress
+            },
+            config: this.config,
+            avmSimulator: this.avmSimulator,
+            telemetry: this.telemetry,
+            log: this.log.createChild('public-calls-simulator')
+        });
+        this.worldStateQueries = new NodeWorldStateQueries({
+            worldStateSynchronizer: this.worldStateSynchronizer,
+            blockSource: this.blockSource,
+            l1ToL2MessageSource: this.l1ToL2MessageSource,
+            log: this.log.createChild('world-state-queries')
+        });
+        this.blockProvider = new NodeBlockProvider(this.blockSource);
+        this.txReceiptBuilder = new NodeTxReceiptBuilder({
+            p2pClient: this.p2pClient,
+            blockSource: this.blockSource,
+            debugLogStore: this.debugLogStore
+        });
         this.log.info(`Aztec Node version: ${this.packageVersion}`);
-        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
+        this.log.info(`Aztec Node started on chain 0x${this.l1ChainId.toString(16)}`, pickL1ContractAddresses(this.config));
+        // A defensive check that protects us against introducing a bug in the complex node creation flow. 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).
-        if (debugLogStore.isEnabled && config.realProofs) {
+        if (this.debugLogStore.isEnabled && this.config.realProofs) {
             throw new Error('debugLogStore should never be enabled when realProofs are set');
         }
     }
@@ -586,14 +532,20 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         const status = await this.worldStateSynchronizer.status();
         return status.syncSummary;
     }
-    async getChainTips() {
-        const { proposed, checkpointed, proven, finalized } = await this.blockSource.getL2Tips();
-        return {
-            proposed,
-            checkpointed,
-            proven,
-            finalized
-        };
+    getChainTips() {
+        return this.blockSource.getL2Tips();
+    }
+    getL1Constants() {
+        return this.blockSource.getL1Constants();
+    }
+    getSyncedL2SlotNumber() {
+        return this.blockSource.getSyncedL2SlotNumber();
+    }
+    getSyncedL2EpochNumber() {
+        return this.blockSource.getSyncedL2EpochNumber();
+    }
+    getSyncedL1Timestamp() {
+        return this.blockSource.getL1Timestamp();
     }
     getCheckpointsData(query) {
         return this.blockSource.getCheckpointsData(query);
@@ -612,620 +564,26 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             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);
+    getBlock(param, options = {}) {
+        return this.blockProvider.getBlock(param, options);
     }
     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;
+        return this.blockProvider.getBlockData(param);
     }
-    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));
+    getBlocks(from, limit, options = {}) {
+        return this.blockProvider.getBlocks(from, limit, options);
     }
-    /**
-   * initializes the Aztec Node, wait for component to sync.
-   * @param config - The configuration to be used by the aztec node.
-   * @returns - A fully synced Aztec Node for use in development/testing.
-   */ static async createAndSync(inputConfig, deps = {}, options = {}) {
-        const config = {
-            ...inputConfig
-        }; // Copy the config so we dont mutate the input object
-        const log = deps.logger ?? createLogger('node');
-        const packageVersion = getPackageVersion();
-        const telemetry = deps.telemetry ?? getTelemetryClient();
-        const dateProvider = deps.dateProvider ?? new DateProvider();
-        const ethereumChain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
-        // Build a key store from file if given or from environment otherwise.
-        // We keep the raw KeyStore available so we can merge with prover keys if enableProverNode is set.
-        let keyStoreManager;
-        const keyStoreProvided = config.keyStoreDirectory !== undefined && config.keyStoreDirectory.length > 0;
-        if (keyStoreProvided) {
-            const keyStores = loadKeystores(config.keyStoreDirectory);
-            keyStoreManager = new KeystoreManager(mergeKeystores(keyStores));
-        } else {
-            const rawKeyStores = [];
-            const validatorKeyStore = createKeyStoreForValidator(config);
-            if (validatorKeyStore) {
-                rawKeyStores.push(validatorKeyStore);
-            }
-            if (config.enableProverNode) {
-                const proverKeyStore = createKeyStoreForProver(config);
-                if (proverKeyStore) {
-                    rawKeyStores.push(proverKeyStore);
-                }
-            }
-            if (rawKeyStores.length > 0) {
-                keyStoreManager = new KeystoreManager(rawKeyStores.length === 1 ? rawKeyStores[0] : mergeKeystores(rawKeyStores));
-            }
-        }
-        await keyStoreManager?.validateSigners();
-        // If we are a validator, verify our configuration before doing too much more.
-        if (!config.disableValidator) {
-            if (keyStoreManager === undefined) {
-                throw new Error('Failed to create key store, a requirement for running a validator');
-            }
-            if (!keyStoreProvided && process.env.NODE_ENV !== 'test') {
-                log.warn("Keystore created from env: it's recommended to use a file-based key store for production");
-            }
-            ValidatorClient.validateKeyStoreConfiguration(keyStoreManager, log);
-        }
-        // validate that the actual chain id matches that specified in configuration
-        if (config.l1ChainId !== ethereumChain.chainInfo.id) {
-            throw new Error(`RPC URL configured for chain id ${ethereumChain.chainInfo.id} but expected id ${config.l1ChainId}`);
-        }
-        const publicClient = createPublicClient({
-            chain: ethereumChain.chainInfo,
-            transport: makeL1HttpTransport(config.l1RpcUrls, {
-                timeout: config.l1HttpTimeoutMS
-            }),
-            pollingInterval: config.viemPollingIntervalMS
-        });
-        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(),
-            rollupContract.getVersion(),
-            rollupContract.getManaLimit().then(Number)
-        ]);
-        config.rollupVersion ??= Number(rollupVersionFromRollup);
-        if (config.rollupVersion !== Number(rollupVersionFromRollup)) {
-            log.warn(`Registry looked up and returned a rollup with version (${config.rollupVersion}), but this does not match with version detected from the rollup directly: (${rollupVersionFromRollup}).`);
-        }
-        const blobClient = await createBlobClientWithFileStores(config, log.createChild('blob-client'));
-        // attempt snapshot sync if possible
-        await trySnapshotSync(config, log);
-        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
-            }, initialHeader, initialBlockHash);
-            started.push(archiver);
-            // 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;
-            let rpcProofVerifier;
-            if (useRealVerifiers) {
-                peerProofVerifier = await BatchChonkVerifier.new(config, config.bbChonkVerifyMaxBatch, 'peer');
-                const rpcVerifier = await BBCircuitVerifier.new(config);
-                rpcProofVerifier = new QueuedIVCVerifier(rpcVerifier, config.numConcurrentIVCVerifiers);
-            } else {
-                peerProofVerifier = new TestCircuitVerifier(config.proverTestVerificationDelayMs);
-                rpcProofVerifier = new TestCircuitVerifier(config.proverTestVerificationDelayMs);
-            }
-            started.push(peerProofVerifier, rpcProofVerifier);
-            let debugLogStore;
-            if (!config.realProofs) {
-                log.warn(`Aztec node is accepting fake proofs`);
-                debugLogStore = new InMemoryDebugLogStore();
-                log.info('Aztec node started in test mode (realProofs set to false) hence debug logs from public functions will be collected and served');
-            } else {
-                debugLogStore = new NullDebugLogStore();
-            }
-            const globalVariableBuilderConfig = {
-                rollupAddress: config.rollupAddress,
-                ethereumSlotDuration: config.ethereumSlotDuration,
-                rollupVersion: BigInt(config.rollupVersion),
-                l1GenesisTime,
-                slotDuration: Number(slotDuration)
-            };
-            const globalVariableBuilder = new GlobalVariableBuilder(dateProvider, publicClient, globalVariableBuilderConfig);
-            const feeProvider = new FeeProviderImpl(dateProvider, publicClient, globalVariableBuilderConfig);
-            const proverOnly = config.enableProverNode && config.disableValidator;
-            if (proverOnly) {
-                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, initialBlockHash);
-            started.push(p2pClient);
-            // We'll accumulate sentinel watchers here
-            const watchers = [];
-            // Create FullNodeCheckpointsBuilder for block proposal handling and tx validation.
-            // Override maxTxsPerCheckpoint with the validator-specific limit if set.
-            const validatorCheckpointsBuilder = new FullNodeCheckpointsBuilder({
-                ...config,
-                l1GenesisTime,
-                slotDuration: Number(slotDuration),
-                rollupManaLimit,
-                maxTxsPerCheckpoint: config.validateMaxTxsPerCheckpoint
-            }, worldStateSynchronizer, archiver, dateProvider, telemetry);
-            let validatorClient;
-            // 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,
-                    worldState: worldStateSynchronizer,
-                    p2pClient,
-                    telemetry,
-                    dateProvider,
-                    epochCache,
-                    blockSource: archiver,
-                    l1ToL2MessageSource: archiver,
-                    keyStoreManager,
-                    blobClient,
-                    reexecutionTracker,
-                    slashingProtectionDb: deps.slashingProtectionDb
-                });
-                // If we have a validator client, register it as a source of offenses for the slasher,
-                // and have it register callbacks on the p2p client *before* we start it, otherwise messages
-                // like attestations or auths will fail.
-                if (validatorClient) {
-                    watchers.push(validatorClient);
-                    const vc = validatorClient;
-                    const getValidatorAddresses = ()=>vc.getValidatorAddresses().map((a)=>a.toString());
-                    validatorClient.getProposalHandler().register(p2pClient, true, archiver, getValidatorAddresses);
-                    if (!options.dontStartSequencer) {
-                        await validatorClient.registerHandlers();
-                    }
-                }
-            }
-            // If there's no validator client, create a ProposalHandler to handle block and checkpoint proposals
-            // for monitoring or reexecution. Reexecution (default) allows us to follow the pending chain,
-            // while non-reexecution is used for validating the proposals and collecting their txs.
-            // Checkpoint proposals rebuild blobs if the blob client can upload blobs.
-            if (!validatorClient) {
-                const reexecute = !!config.alwaysReexecuteBlockProposals;
-                log.info(`Setting up proposal handler` + (reexecute ? ' with reexecution of proposals' : ''));
-                createProposalHandler(config, {
-                    checkpointsBuilder: validatorCheckpointsBuilder,
-                    worldState: worldStateSynchronizer,
-                    epochCache,
-                    blockSource: archiver,
-                    l1ToL2MessageSource: archiver,
-                    p2pClient,
-                    blobClient,
-                    dateProvider,
-                    telemetry,
-                    reexecutionTracker
-                }).register(p2pClient, reexecute, archiver);
-            }
-            // Start world state and wait for it to sync to the archiver.
-            await worldStateSynchronizer.start();
-            // Start p2p. Note that it depends on world state to be running.
-            await p2pClient.start();
-            let validatorsSentinel;
-            let dataWithholdingWatcher;
-            let attestationsBlockWatcher;
-            let attestedInvalidProposalWatcher;
-            let broadcastedInvalidCheckpointProposalWatcher;
-            let checkpointEquivocationWatcher;
-            if (!proverOnly) {
-                validatorsSentinel = await createSentinel(epochCache, archiver, p2pClient, reexecutionTracker, config);
-                if (validatorsSentinel) {
-                    watchers.push(validatorsSentinel);
-                }
-                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 ()=>{
-                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, 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, {
-                    ...config,
-                    scope: 'sequencer'
-                }, {
-                    telemetry,
-                    logger: log.createChild('l1-tx-utils'),
-                    dateProvider,
-                    kzg: Blob.getViemKzgInstance()
-                }) : await createL1TxUtilsFromSigners(publicClient, keyStoreManager.createAllValidatorPublisherSigners(), {
-                    ...config,
-                    scope: 'sequencer'
-                }, {
-                    telemetry,
-                    logger: log.createChild('l1-tx-utils'),
-                    dateProvider,
-                    kzg: Blob.getViemKzgInstance()
-                });
-                // Create a funder L1TxUtils from the keystore funding account (if configured)
-                const fundingSigner = keyStoreManager?.createFundingSigner();
-                let funderL1TxUtils;
-                if (fundingSigner) {
-                    const [funder] = await createL1TxUtilsFromSigners(publicClient, [
-                        fundingSigner
-                    ], {
-                        ...config,
-                        scope: 'sequencer'
-                    }, {
-                        telemetry,
-                        logger: log.createChild('l1-tx-utils:funder'),
-                        dateProvider
-                    });
-                    funderL1TxUtils = funder;
-                }
-                // Create and start the sequencer client
-                const checkpointsBuilder = new CheckpointsBuilder({
-                    ...config,
-                    l1GenesisTime,
-                    slotDuration: Number(slotDuration),
-                    rollupManaLimit
-                }, worldStateSynchronizer, archiver, dateProvider, telemetry, debugLogStore);
-                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();
-                started.push(sequencer);
-                log.verbose(`Sequencer started`);
-            } 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) {
-                proverNode = await createProverNode(config, {
-                    ...deps.proverNodeDeps,
-                    telemetry,
-                    dateProvider,
-                    archiver,
-                    worldStateSynchronizer,
-                    p2pClient,
-                    epochCache,
-                    blobClient,
-                    keyStoreManager
-                });
-                if (!options.dontStartProverNode) {
-                    await proverNode.start();
-                    started.push(proverNode);
-                    log.info(`Prover node subsystem started`);
-                } else {
-                    log.info(`Prover node subsystem created but not started`);
-                }
-            }
-            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);
-            for (const resource of started.reverse()){
-                await tryStop(resource);
-            }
-            throw err;
-        }
+    getCheckpoint(param, options = {}) {
+        return this.blockProvider.getCheckpoint(param, options);
+    }
+    getCheckpoints(from, limit, options = {}) {
+        return this.blockProvider.getCheckpoints(from, limit, options);
     }
     /**
    * Returns the sequencer client instance.
@@ -1270,14 +628,20 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         return Promise.resolve(this.p2pClient.isReady() ?? false);
     }
     async getNodeInfo() {
-        const [nodeVersion, rollupVersion, chainId, enr, contractAddresses, protocolContractAddresses] = await Promise.all([
+        const [nodeVersion, rollupVersion, chainId, enr, contractAddresses, protocolContractAddresses, l1Constants] = await Promise.all([
             this.getNodeVersion(),
             this.getVersion(),
             this.getChainId(),
             this.getEncodedEnr(),
             this.getL1ContractAddresses(),
-            this.getProtocolContractAddresses()
+            this.getProtocolContractAddresses(),
+            this.blockSource.getL1Constants()
         ]);
+        // Gas limits a single tx may declare on this network, derived from network-wide constants only (the
+        // timetable's blocks-per-checkpoint and the network-minimum per-block multipliers) — never this node's
+        // local caps or configured multipliers, which can make the node stricter at block-building time but
+        // cannot define what the network accepts for relay. Clients read txsLimits to set fallback gas limits.
+        const maxTxGas = getNetworkTxGasLimits(this.config, l1Constants);
         const nodeInfo = {
             nodeVersion,
             l1ChainId: chainId,
@@ -1285,7 +649,13 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             enr,
             l1ContractAddresses: contractAddresses,
             protocolContractAddresses: protocolContractAddresses,
-            realProofs: !!this.config.realProofs
+            realProofs: !!this.config.realProofs,
+            txsLimits: {
+                gas: {
+                    daGas: maxTxGas.daGas,
+                    l2Gas: maxTxGas.l2Gas
+                }
+            }
         };
         return nodeInfo;
     }
@@ -1296,7 +666,9 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         return await this.feeProvider.getPredictedMinFees(manaUsage);
     }
     async getMaxPriorityFees() {
-        for await (const tx of this.p2pClient.iteratePendingTxs()){
+        for await (const tx of this.p2pClient.iteratePendingTxs({
+            includeProof: false
+        })){
             return tx.getGasSettings().maxPriorityFeesPerGas;
         }
         return GasFees.from({
@@ -1325,8 +697,12 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     getContractClass(id) {
         return this.contractDataSource.getContractClass(id);
     }
-    getContract(address) {
-        return this.contractDataSource.getContract(address);
+    async getContract(address, referenceBlock = 'latest') {
+        const blockData = await this.getBlockData(referenceBlock);
+        if (!blockData) {
+            throw new Error(`Reference block ${inspectBlockParameter(referenceBlock)} not found when querying contract ${address}. If the node API has been queried with an anchor block hash, possibly a reorg has occurred.`);
+        }
+        return this.contractDataSource.getContract(address, blockData.header.globalVariables.timestamp);
     }
     getPrivateLogsByTags(query) {
         return this.logsSource.getPrivateLogsByTags(query);
@@ -1367,27 +743,8 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             txHash
         });
     }
-    async getTxReceipt(txHash) {
-        // 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.
-        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);
-        let receipt;
-        if (settledTxReceipt) {
-            receipt = settledTxReceipt;
-        } 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, /*executionResult=*/ undefined, /*error=*/ undefined);
-        } else {
-            // Otherwise, if we don't know the tx, we consider it dropped.
-            receipt = new TxReceipt(txHash, TxStatus.DROPPED, /*executionResult=*/ undefined, /*error=*/ 'Tx dropped by P2P node');
-        }
-        this.debugLogStore.decorateReceiptWithLogs(txHash.toString(), receipt);
-        return receipt;
+    getTxReceipt(txHash, options) {
+        return this.txReceiptBuilder.getTxReceipt(txHash, options);
     }
     getTxEffect(txHash) {
         return this.blockSource.getTxEffect(txHash);
@@ -1406,6 +763,10 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         await tryStop(this.automineSequencer);
         await tryStop(this.proverNode);
         await tryStop(this.p2pClient);
+        // Dispose the AVM backend before world state: it kills the bb-avm-sim processes and closes the CDB IPC
+        // server, releasing their connections to the WSDB so it shuts down cleanly (and freeing the
+        // Server/Socket/ChildProcess handles that would otherwise keep the process alive after teardown).
+        await this.avmSimulator?.[Symbol.asyncDispose]();
         await tryStop(this.worldStateSynchronizer);
         await tryStop(this.blockSource);
         await tryStop(this.blobClient);
@@ -1423,272 +784,94 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
    * @param limit - The number of items to returns
    * @param after - The last known pending tx. Used for pagination
    * @returns - The pending txs.
-   */ getPendingTxs(limit, after) {
-        return this.p2pClient.getPendingTxs(limit, after);
+   */ getPendingTxs(limit, after, options) {
+        return this.p2pClient.getPendingTxs(limit, after, options);
     }
     getPendingTxCount() {
         return this.p2pClient.getPendingTxCount();
     }
+    getPeers(includePending) {
+        return this.p2pClient.getPeers(includePending);
+    }
+    getCheckpointAttestationsForSlot(slot, proposalPayloadHash) {
+        return this.p2pClient.getCheckpointAttestationsForSlot(slot, proposalPayloadHash);
+    }
+    getProposalsForSlot(slot) {
+        return this.p2pClient.getProposalsForSlot(slot);
+    }
     /**
-   * Method to retrieve a single tx from the mempool or unfinalized chain.
+   * Method to retrieve a single tx from the mempool or unfinalized chain. The tx's proof is only loaded and returned
+   * when `includeProof` is set.
    * @param txHash - The transaction hash to return.
+   * @param options - Options for the returned tx (eg whether to include its proof).
    * @returns - The tx if it exists.
-   */ getTxByHash(txHash) {
-        return Promise.resolve(this.p2pClient.getTxByHashFromPool(txHash));
+   */ getTxByHash(txHash, options) {
+        return this.p2pClient.getTxByHashFromPool(txHash, {
+            includeProof: !!options?.includeProof
+        });
     }
     /**
-   * Method to retrieve txs from the mempool or unfinalized chain.
+   * Method to retrieve txs from the mempool or unfinalized chain. The txs' proofs are only loaded and returned when
+   * `includeProof` is set.
    * @param txHash - The transaction hash to return.
+   * @param options - Options for the returned txs (eg whether to include their proofs).
    * @returns - The txs if it exists.
-   */ async getTxsByHash(txHashes) {
-        return compactArray(await Promise.all(txHashes.map((txHash)=>this.getTxByHash(txHash))));
-    }
-    async findLeavesIndexes(referenceBlock, treeId, leafValues) {
-        const committedDb = await this.getWorldState(referenceBlock);
-        const maybeIndices = await committedDb.findLeafIndices(treeId, leafValues.map((x)=>x.toBuffer()));
-        // Filter out undefined values to query block numbers only for found leaves
-        const definedIndices = maybeIndices.filter((x)=>x !== undefined);
-        // Now we find the block numbers for the defined indices
-        const blockNumbers = await committedDb.getBlockNumbersForLeafIndices(treeId, definedIndices);
-        // Build a map from leaf index to block number
-        const indexToBlockNumber = new Map();
-        for(let i = 0; i < definedIndices.length; i++){
-            const blockNumber = blockNumbers[i];
-            if (blockNumber === undefined) {
-                throw new Error(`Block number is undefined for leaf index ${definedIndices[i]} in tree ${MerkleTreeId[treeId]}`);
-            }
-            indexToBlockNumber.set(definedIndices[i], blockNumber);
-        }
-        // Get unique block numbers in order to optimize num calls to getLeafValue function.
-        const uniqueBlockNumbers = [
-            ...new Set(indexToBlockNumber.values())
-        ];
-        // Now we obtain the block hashes from the archive tree (block number = leaf index in archive tree).
-        const blockHashes = await Promise.all(uniqueBlockNumbers.map((blockNumber)=>{
-            return committedDb.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(blockNumber));
-        }));
-        // Build a map from block number to block hash
-        const blockNumberToHash = new Map();
-        for(let i = 0; i < uniqueBlockNumbers.length; i++){
-            const blockHash = blockHashes[i];
-            if (blockHash === undefined) {
-                throw new Error(`Block hash is undefined for block number ${uniqueBlockNumbers[i]}`);
-            }
-            blockNumberToHash.set(uniqueBlockNumbers[i], blockHash);
-        }
-        // Create DataInBlock objects by combining indices, blockNumbers and blockHashes and return them.
-        return maybeIndices.map((index)=>{
-            if (index === undefined) {
-                return undefined;
-            }
-            const blockNumber = indexToBlockNumber.get(index);
-            if (blockNumber === undefined) {
-                throw new Error(`Block number not found for leaf index ${index} in tree ${MerkleTreeId[treeId]}`);
-            }
-            const l2BlockHash = blockNumberToHash.get(blockNumber);
-            if (l2BlockHash === undefined) {
-                throw new Error(`Block hash not found for block number ${blockNumber}`);
-            }
-            return {
-                l2BlockNumber: blockNumber,
-                l2BlockHash,
-                data: index
-            };
+   */ async getTxsByHash(txHashes, options) {
+        const txs = await this.p2pClient.getTxsByHashFromPool(txHashes, {
+            includeProof: !!options?.includeProof
         });
+        return compactArray(txs);
     }
-    async getBlockHashMembershipWitness(referenceBlock, blockHash) {
-        // The Noir circuit checks the archive membership proof against `anchor_block_header.last_archive.root`,
-        // which is the archive tree root BEFORE the anchor block was added (i.e. the state after block N-1).
-        // So we need the world state at block N-1, not block N, to produce a sibling path matching that root.
-        const referenceBlockNumber = await this.resolveBlockNumber(referenceBlock);
-        if (referenceBlockNumber === BlockNumber.ZERO) {
-            // Block 0 (the initial block) has an empty archive, so no membership witness can exist.
-            return undefined;
-        }
-        const committedDb = await this.getWorldState(BlockNumber(referenceBlockNumber - 1));
-        const [pathAndIndex] = await committedDb.findSiblingPaths(MerkleTreeId.ARCHIVE, [
-            blockHash
-        ]);
-        return pathAndIndex === undefined ? undefined : MembershipWitness.fromSiblingPath(pathAndIndex.index, pathAndIndex.path);
+    findLeavesIndexes(referenceBlock, treeId, leafValues) {
+        return this.worldStateQueries.findLeavesIndexes(referenceBlock, treeId, leafValues);
     }
-    async getNoteHashMembershipWitness(referenceBlock, noteHash) {
-        const committedDb = await this.getWorldState(referenceBlock);
-        const [pathAndIndex] = await committedDb.findSiblingPaths(MerkleTreeId.NOTE_HASH_TREE, [
-            noteHash
-        ]);
-        return pathAndIndex === undefined ? undefined : MembershipWitness.fromSiblingPath(pathAndIndex.index, pathAndIndex.path);
+    getBlockHashMembershipWitness(referenceBlock, blockHash) {
+        return this.worldStateQueries.getBlockHashMembershipWitness(referenceBlock, blockHash);
     }
-    async getL1ToL2MessageMembershipWitness(referenceBlock, l1ToL2Message) {
-        const db = await this.getWorldState(referenceBlock);
-        const [witness] = await db.findSiblingPaths(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, [
-            l1ToL2Message
-        ]);
-        if (!witness) {
-            return undefined;
-        }
-        // REFACTOR: Return a MembershipWitness object
-        return [
-            witness.index,
-            witness.path
-        ];
+    getNoteHashMembershipWitness(referenceBlock, noteHash) {
+        return this.worldStateQueries.getNoteHashMembershipWitness(referenceBlock, noteHash);
     }
-    async getL1ToL2MessageCheckpoint(l1ToL2Message) {
-        const messageIndex = await this.l1ToL2MessageSource.getL1ToL2MessageIndex(l1ToL2Message);
-        return messageIndex !== undefined ? InboxLeaf.checkpointNumberFromIndex(messageIndex) : undefined;
+    getL1ToL2MessageMembershipWitness(referenceBlock, l1ToL2Message) {
+        return this.worldStateQueries.getL1ToL2MessageMembershipWitness(referenceBlock, l1ToL2Message);
+    }
+    getL1ToL2MessageCheckpoint(l1ToL2Message) {
+        return this.worldStateQueries.getL1ToL2MessageCheckpoint(l1ToL2Message);
     }
     /**
    * 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) {
-        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)));
+   */ getL2ToL1Messages(epoch) {
+        return this.worldStateQueries.getL2ToL1Messages(epoch);
     }
-    async getNullifierMembershipWitness(referenceBlock, nullifier) {
-        const db = await this.getWorldState(referenceBlock);
-        const [witness] = await db.findSiblingPaths(MerkleTreeId.NULLIFIER_TREE, [
-            nullifier.toBuffer()
-        ]);
-        if (!witness) {
-            return undefined;
-        }
-        const { index, path } = witness;
-        const leafPreimage = await db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
-        if (!leafPreimage) {
-            return undefined;
-        }
-        return new NullifierMembershipWitness(index, leafPreimage, path);
+    /**
+   * 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.worldStateQueries.getL2ToL1MembershipWitness(txHash, message, messageIndexInTx);
     }
-    async getLowNullifierMembershipWitness(referenceBlock, nullifier) {
-        const committedDb = await this.getWorldState(referenceBlock);
-        const findResult = await committedDb.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
-        if (!findResult) {
-            return undefined;
-        }
-        const { index, alreadyPresent } = findResult;
-        if (alreadyPresent) {
-            throw new Error(`Cannot prove nullifier non-inclusion: nullifier ${nullifier.toBigInt()} already exists in the tree`);
-        }
-        const preimageData = await committedDb.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
-        const siblingPath = await committedDb.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, BigInt(index));
-        return new NullifierMembershipWitness(BigInt(index), preimageData, siblingPath);
-    }
-    async getPublicDataWitness(referenceBlock, leafSlot) {
-        const committedDb = await this.getWorldState(referenceBlock);
-        const lowLeafResult = await committedDb.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
-        if (!lowLeafResult) {
-            return undefined;
-        } else {
-            const preimage = await committedDb.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
-            const path = await committedDb.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
-            return new PublicDataWitness(lowLeafResult.index, preimage, path);
-        }
+    getNullifierMembershipWitness(referenceBlock, nullifier) {
+        return this.worldStateQueries.getNullifierMembershipWitness(referenceBlock, nullifier);
     }
-    async getPublicStorageAt(referenceBlock, contract, slot) {
-        const committedDb = await this.getWorldState(referenceBlock);
-        const leafSlot = await computePublicDataTreeLeafSlot(contract, slot);
-        const lowLeafResult = await committedDb.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
-        if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
-            return Fr.ZERO;
-        }
-        const preimage = await committedDb.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
-        return preimage.leaf.value;
+    getLowNullifierMembershipWitness(referenceBlock, nullifier) {
+        return this.worldStateQueries.getLowNullifierMembershipWitness(referenceBlock, nullifier);
+    }
+    getPublicDataWitness(referenceBlock, leafSlot) {
+        return this.worldStateQueries.getPublicDataWitness(referenceBlock, leafSlot);
+    }
+    getPublicStorageAt(referenceBlock, contract, slot) {
+        return this.worldStateQueries.getPublicStorageAt(referenceBlock, contract, slot);
     }
     /**
    * Simulates the public part of a transaction with the current state.
    * @param tx - The transaction to simulate.
    * @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,
-                collectHints: false,
-                collectCallMetadata: true,
-                collectStatistics: false,
-                collectionLimits: CollectionLimitsConfig.from({
-                    maxDebugLogMemoryReads: this.config.rpcSimulatePublicMaxDebugLogMemoryReads
-                })
-            });
-            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
-            ]);
-            // REFACTOR: Consider returning the error rather than throwing
-            if (failedTxs.length) {
-                this.log.warn(`Simulated tx ${txHash} fails: ${failedTxs[0].error}`, {
-                    txHash
-                });
-                throw failedTxs[0].error;
-            }
-            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{
-            const result = _ts_dispose_resources(env);
-            if (result) await result;
-        }
+   **/ simulatePublicCalls(tx, skipFeeEnforcement = false, overrides) {
+        return this.nodePublicCallsSimulator.simulate(tx, skipFeeEnforcement, overrides);
     }
     async isValidTx(tx, { isSimulation, skipFeeEnforcement } = {}) {
         const db = this.worldStateSynchronizer.getCommitted();
@@ -1697,6 +880,9 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         const { ts: nextSlotTimestamp } = this.epochCache.getEpochAndSlotInNextL1Slot();
         const blockNumber = BlockNumber(await this.blockSource.getBlockNumber() + 1);
         const l1Constants = await this.blockSource.getL1Constants();
+        // Enforce the same network admission limit the node advertises in getNodeInfo (network-wide, not this
+        // node's local caps), so a tx the wallet sized against txsLimits is not rejected here.
+        const networkTxGasLimits = getNetworkTxGasLimits(this.config, l1Constants);
         const validator = createTxValidatorForAcceptingTxsOverRPC(db, this.contractDataSource, verifier, {
             timestamp: nextSlotTimestamp,
             blockNumber,
@@ -1708,10 +894,10 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             ],
             gasFees: await this.getCurrentMinFees(),
             skipFeeEnforcement,
+            isSimulation,
             txsPermitted: !this.config.disableTransactions,
-            rollupManaLimit: l1Constants.rollupManaLimit,
-            maxBlockL2Gas: this.config.validateMaxL2BlockGas,
-            maxBlockDAGas: this.config.validateMaxDABlockGas
+            maxTxL2Gas: networkTxGasLimits.l2Gas,
+            maxTxDAGas: networkTxGasLimits.daGas
         }, this.log.getBindings());
         return await validator.validateTx(tx);
     }
@@ -2013,73 +1199,29 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             });
         }
     }
-    /**
-   * 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(anchorBlockNumber, requestedHash);
-        } catch (err) {
-            this.log.error(`Error getting world state: ${err}`);
+    async prove(upToCheckpoint) {
+        if (!this.automineSequencer) {
+            throw new BadRequestError('Cannot prove checkpoint: no automine sequencer is running');
         }
-        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();
-        }
-        const blockNumber = anchorBlockNumber ?? await this.resolveBlockNumber(query);
-        // Check it's within world state sync range
-        if (blockNumber > 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.
-        // 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 || !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 await this.automineSequencer.prove(upToCheckpoint);
+    }
+    async warpL2TimeAtLeastTo(targetTimestamp) {
+        if (!this.automineSequencer) {
+            throw new BadRequestError('Cannot warp L2 time: no automine sequencer is running');
         }
-        return snapshot;
-    }
-    /** 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.`);
-            }
-            if ('archive' in query) {
-                throw new Error(`Block with archive ${query.archive.toString()} not found.`);
-            }
-            throw new Error(`Block not found for ${inspectBlockParameter(block)}.`);
+        await this.automineSequencer.warpTo(targetTimestamp);
+    }
+    async warpL2TimeAtLeastBy(duration) {
+        if (!this.automineSequencer) {
+            throw new BadRequestError('Cannot warp L2 time: no automine sequencer is running');
         }
-        return blockNumber;
+        await this.automineSequencer.warpBy(duration);
     }
     /**
-   * 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(targetBlockNumber, blockHash) {
-        const target = targetBlockNumber ?? await this.blockSource.getBlockNumber();
-        return await this.worldStateSynchronizer.syncImmediate(target, blockHash);
+   * Returns a committed world-state view at `block`, driving sync first. Delegates to
+   * {@link NodeWorldStateQueries.getWorldState}; kept as a protected method so subclasses and tests can
+   * exercise the node's block-resolution and reorg-aware sync behavior.
+   */ getWorldState(block) {
+        return this.worldStateQueries.getWorldState(block);
     }
 }