@aztec/aztec-node 0.0.1-commit.10bd49492 → 0.0.1-commit.11bf3dd6e

package/dest/aztec-node/server.js

@@ -372,19 +372,21 @@ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
 }
 var _dec, _initProto;
 import { createArchiver } from '@aztec/archiver';
-import { BBCircuitVerifier, QueuedIVCVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
+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 } from '@aztec/ethereum/client';
+import { getPublicClient, makeL1HttpTransport } from '@aztec/ethereum/client';
 import { RegistryContract, RollupContract } from '@aztec/ethereum/contracts';
-import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
-import { compactArray, pick, unique } from '@aztec/foundation/collection';
+import { BlockNumber } 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';
 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';
@@ -395,7 +397,7 @@ import { createP2PClient, createTxValidatorForAcceptingTxsOverRPC, getDefaultAll
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { createProverNode } from '@aztec/prover-node';
 import { createKeyStoreForProver } from '@aztec/prover-node/config';
-import { GlobalVariableBuilder, SequencerClient } from '@aztec/sequencer-client';
+import { FeeProviderImpl, GlobalVariableBuilder, SequencerClient } from '@aztec/sequencer-client';
 import { PublicProcessorFactory } from '@aztec/simulator/server';
 import { AttestationsBlockWatcher, EpochPruneWatcher, createSlasher } from '@aztec/slasher';
 import { CollectionLimitsConfig, PublicSimulatorConfig } from '@aztec/stdlib/avm';
@@ -411,9 +413,9 @@ import { MerkleTreeId, NullifierMembershipWitness, PublicDataWitness } from '@az
 import { PublicSimulationOutput, TxReceipt, 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, createBlockProposalHandler, createValidatorClient } from '@aztec/validator-client';
+import { FullNodeCheckpointsBuilder as CheckpointsBuilder, FullNodeCheckpointsBuilder, NodeKeystoreAdapter, ValidatorClient, createProposalHandler, createValidatorClient } from '@aztec/validator-client';
 import { createWorldStateSynchronizer } from '@aztec/world-state';
-import { createPublicClient, fallback, http } from 'viem';
+import { createPublicClient } from 'viem';
 import { createSentinel } from '../sentinel/factory.js';
 import { createKeyStoreForValidator } from './config.js';
 import { NodeMetrics } from './node_metrics.js';
@@ -438,9 +440,11 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     l1ChainId;
     version;
     globalVariableBuilder;
+    feeProvider;
     epochCache;
     packageVersion;
-    proofVerifier;
+    peerProofVerifier;
+    rpcProofVerifier;
     telemetry;
     log;
     blobClient;
@@ -461,7 +465,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     // Prevent two snapshot operations to happen simultaneously
     isUploadingSnapshot;
     tracer;
-    constructor(config, p2pClient, blockSource, logsSource, contractDataSource, l1ToL2MessageSource, worldStateSynchronizer, sequencer, proverNode, slasherClient, validatorsSentinel, epochPruneWatcher, l1ChainId, version, globalVariableBuilder, epochCache, packageVersion, proofVerifier, telemetry = getTelemetryClient(), log = createLogger('node'), blobClient, validatorClient, keyStoreManager, debugLogStore = new NullDebugLogStore()){
+    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()){
         this.config = config;
         this.p2pClient = p2pClient;
         this.blockSource = blockSource;
@@ -477,9 +481,11 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         this.l1ChainId = l1ChainId;
         this.version = version;
         this.globalVariableBuilder = globalVariableBuilder;
+        this.feeProvider = feeProvider;
         this.epochCache = epochCache;
         this.packageVersion = packageVersion;
-        this.proofVerifier = proofVerifier;
+        this.peerProofVerifier = peerProofVerifier;
+        this.rpcProofVerifier = rpcProofVerifier;
         this.telemetry = telemetry;
         this.log = log;
         this.blobClient = blobClient;
@@ -499,6 +505,9 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             throw new Error('debugLogStore should never be enabled when realProofs are set');
         }
     }
+    /** @internal Exposed for testing — returns the RPC proof verifier. */ getProofVerifier() {
+        return this.rpcProofVerifier;
+    }
     async getWorldStateSyncStatus() {
         const status = await this.worldStateSynchronizer.status();
         return status.syncSummary;
@@ -559,9 +568,9 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         }
         const publicClient = createPublicClient({
             chain: ethereumChain.chainInfo,
-            transport: fallback(config.l1RpcUrls.map((url)=>http(url, {
-                    batch: false
-                }))),
+            transport: makeL1HttpTransport(config.l1RpcUrls, {
+                timeout: config.l1HttpTimeoutMS
+            }),
             pollingInterval: config.viemPollingIntervalMS
         });
         const l1ContractsAddresses = await RegistryContract.collectAddresses(publicClient, config.l1Contracts.registryAddress, config.rollupVersion ?? 'canonical');
@@ -596,8 +605,18 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             blockUntilSync: !config.skipArchiverInitialSync
         });
         // now create the merkle trees and the world state synchronizer
-        const worldStateSynchronizer = await createWorldStateSynchronizer(config, archiver, options.prefilledPublicData, telemetry);
-        const circuitVerifier = config.realProofs || config.debugForceTxProofVerification ? await BBCircuitVerifier.new(config) : new TestCircuitVerifier(config.proverTestVerificationDelayMs);
+        const worldStateSynchronizer = await createWorldStateSynchronizer(config, archiver, options.genesis, telemetry);
+        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);
+        }
         let debugLogStore;
         if (!config.realProofs) {
             log.warn(`Aztec node is accepting fake proofs`);
@@ -606,13 +625,12 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         } else {
             debugLogStore = new NullDebugLogStore();
         }
-        const proofVerifier = new QueuedIVCVerifier(config, circuitVerifier);
         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, proofVerifier, worldStateSynchronizer, epochCache, packageVersion, dateProvider, telemetry, deps.p2pClientDeps);
+        const p2pClient = await createP2PClient(config, archiver, peerProofVerifier, worldStateSynchronizer, epochCache, packageVersion, dateProvider, telemetry, deps.p2pClientDeps);
         // We'll accumulate sentinel watchers here
         const watchers = [];
         // Create FullNodeCheckpointsBuilder for block proposal handling and tx validation.
@@ -637,34 +655,40 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                 blockSource: archiver,
                 l1ToL2MessageSource: archiver,
                 keyStoreManager,
-                blobClient
+                blobClient,
+                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 BlockProposalHandler to handle block proposals
+        // 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 block proposal handler` + (reexecute ? ' with reexecution of proposals' : ''));
-            createBlockProposalHandler(config, {
+            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
-            }).register(p2pClient, reexecute);
+            }).register(p2pClient, reexecute, archiver);
         }
         // Start world state and wait for it to sync to the archiver.
         await worldStateSynchronizer.start();
@@ -690,12 +714,20 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         }
         // Start p2p-related services once the archiver has completed sync
         void archiver.waitForInitialSync().then(async ()=>{
-            await p2pClient.start();
             await validatorsSentinel?.start();
             await epochPruneWatcher?.start();
             await attestationsBlockWatcher?.start();
             log.info(`All p2p services started`);
         }).catch((err)=>log.error('Failed to start p2p services after archiver sync', err));
+        const globalVariableBuilderConfig = {
+            l1Contracts: config.l1Contracts,
+            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);
         // Validator enabled, create/start relevant service
         let sequencer;
         let slasherClient;
@@ -722,6 +754,22 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                 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,
@@ -733,6 +781,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                 ...deps,
                 epochCache,
                 l1TxUtils,
+                funderL1TxUtils,
                 validatorClient,
                 p2pClient,
                 worldStateSynchronizer,
@@ -743,7 +792,8 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                 telemetry,
                 dateProvider,
                 blobClient,
-                nodeKeyStore: keyStoreManager
+                nodeKeyStore: keyStoreManager,
+                globalVariableBuilder
             });
         }
         if (!options.dontStartSequencer && sequencer) {
@@ -773,13 +823,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                 log.info(`Prover node subsystem created but not started`);
             }
         }
-        const globalVariableBuilder = new GlobalVariableBuilder({
-            ...config,
-            rollupVersion: BigInt(config.rollupVersion),
-            l1GenesisTime,
-            slotDuration: Number(slotDuration)
-        });
-        const node = new AztecNodeService(config, p2pClient, archiver, archiver, archiver, archiver, worldStateSynchronizer, sequencer, proverNode, slasherClient, validatorsSentinel, epochPruneWatcher, ethereumChain.chainInfo.id, config.rollupVersion, globalVariableBuilder, epochCache, packageVersion, proofVerifier, telemetry, log, blobClient, validatorClient, keyStoreManager, debugLogStore);
+        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);
         return node;
     }
     /**
@@ -894,11 +938,11 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     getCheckpointsDataForEpoch(epochNumber) {
         return this.blockSource.getCheckpointsDataForEpoch(epochNumber);
     }
-    /**
-   * Method to fetch the current min L2 fees.
-   * @returns The current min L2 fees.
-   */ async getCurrentMinFees() {
-        return await this.globalVariableBuilder.getCurrentMinFees();
+    async getCurrentMinFees() {
+        return await this.feeProvider.getCurrentMinFees();
+    }
+    /** Returns predicted min fees for the current slot and next N slots. */ async getPredictedMinFees(manaUsage) {
+        return await this.feeProvider.getPredictedMinFees(manaUsage);
     }
     async getMaxPriorityFees() {
         for await (const tx of this.p2pClient.iteratePendingTxs()){
@@ -949,28 +993,36 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         return this.contractDataSource.getContract(address);
     }
     async getPrivateLogsByTags(tags, page, referenceBlock) {
+        let upToBlockNumber;
         if (referenceBlock) {
             const initialBlockHash = await this.#getInitialHeaderHash();
-            if (!referenceBlock.equals(initialBlockHash)) {
+            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);
+        return this.logsSource.getPrivateLogsByTags(tags, page, upToBlockNumber);
     }
     async getPublicLogsByTagsFromContract(contractAddress, tags, page, referenceBlock) {
+        let upToBlockNumber;
         if (referenceBlock) {
             const initialBlockHash = await this.#getInitialHeaderHash();
-            if (!referenceBlock.equals(initialBlockHash)) {
+            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);
+        return this.logsSource.getPublicLogsByTagsFromContract(contractAddress, tags, page, upToBlockNumber);
     }
     /**
    * Gets public logs based on the provided filter.
@@ -1043,7 +1095,10 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         await tryStop(this.validatorsSentinel);
         await tryStop(this.epochPruneWatcher);
         await tryStop(this.slasherClient);
-        await tryStop(this.proofVerifier);
+        await Promise.all([
+            tryStop(this.peerProofVerifier),
+            tryStop(this.rpcProofVerifier)
+        ]);
         await tryStop(this.sequencer);
         await tryStop(this.proverNode);
         await tryStop(this.p2pClient);
@@ -1085,7 +1140,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         return compactArray(await Promise.all(txHashes.map((txHash)=>this.getTxByHash(txHash))));
     }
     async findLeavesIndexes(referenceBlock, treeId, leafValues) {
-        const committedDb = await this.#getWorldState(referenceBlock);
+        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);
@@ -1126,33 +1181,41 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             if (blockNumber === undefined) {
                 throw new Error(`Block number not found for leaf index ${index} in tree ${MerkleTreeId[treeId]}`);
             }
-            const blockHash = blockNumberToHash.get(blockNumber);
-            if (blockHash === undefined) {
+            const l2BlockHash = blockNumberToHash.get(blockNumber);
+            if (l2BlockHash === undefined) {
                 throw new Error(`Block hash not found for block number ${blockNumber}`);
             }
             return {
                 l2BlockNumber: blockNumber,
-                l2BlockHash: new BlockHash(blockHash),
+                l2BlockHash,
                 data: index
             };
         });
     }
     async getBlockHashMembershipWitness(referenceBlock, blockHash) {
-        const committedDb = await this.#getWorldState(referenceBlock);
+        // 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);
     }
     async getNoteHashMembershipWitness(referenceBlock, noteHash) {
-        const committedDb = await this.#getWorldState(referenceBlock);
+        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);
     }
     async getL1ToL2MessageMembershipWitness(referenceBlock, l1ToL2Message) {
-        const db = await this.#getWorldState(referenceBlock);
+        const db = await this.getWorldState(referenceBlock);
         const [witness] = await db.findSiblingPaths(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, [
             l1ToL2Message
         ]);
@@ -1184,23 +1247,11 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
    */ async getL2ToL1Messages(epoch) {
         // Assumes `getCheckpointedBlocksForEpoch` returns blocks in ascending order of block number.
         const checkpointedBlocks = await this.blockSource.getCheckpointedBlocksForEpoch(epoch);
-        const blocksInCheckpoints = [];
-        let previousSlotNumber = SlotNumber.ZERO;
-        let checkpointIndex = -1;
-        for (const checkpointedBlock of checkpointedBlocks){
-            const block = checkpointedBlock.block;
-            const slotNumber = block.header.globalVariables.slotNumber;
-            if (slotNumber !== previousSlotNumber) {
-                checkpointIndex++;
-                blocksInCheckpoints.push([]);
-                previousSlotNumber = slotNumber;
-            }
-            blocksInCheckpoints[checkpointIndex].push(block);
-        }
+        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)));
     }
     async getNullifierMembershipWitness(referenceBlock, nullifier) {
-        const db = await this.#getWorldState(referenceBlock);
+        const db = await this.getWorldState(referenceBlock);
         const [witness] = await db.findSiblingPaths(MerkleTreeId.NULLIFIER_TREE, [
             nullifier.toBuffer()
         ]);
@@ -1214,36 +1265,22 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         }
         return new NullifierMembershipWitness(index, leafPreimage, path);
     }
-    /**
-   * Returns a low nullifier membership witness for a given nullifier at a given block.
-   * @param referenceBlock - The block parameter (block number, block hash, or 'latest') at which to get the data
-   * (which contains the root of the nullifier tree in which we are searching for the nullifier).
-   * @param nullifier - Nullifier we try to find the low nullifier witness for.
-   * @returns The low nullifier membership witness (if found).
-   * @remarks Low nullifier witness can be used to perform a nullifier non-inclusion proof by leveraging the "linked
-   * list structure" of leaves and proving that a lower nullifier is pointing to a bigger next value than the nullifier
-   * we are trying to prove non-inclusion for.
-   *
-   * Note: This function returns the membership witness of the nullifier itself and not the low nullifier when
-   * the nullifier already exists in the tree. This is because the `getPreviousValueIndex` function returns the
-   * index of the nullifier itself when it already exists in the tree.
-   * TODO: This is a confusing behavior and we should eventually address that.
-   */ async getLowNullifierMembershipWitness(referenceBlock, nullifier) {
-        const committedDb = await this.#getWorldState(referenceBlock);
+    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) {
-            this.log.warn(`Nullifier ${nullifier.toBigInt()} already exists in the tree`);
+            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 committedDb = await this.getWorldState(referenceBlock);
         const lowLeafResult = await committedDb.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
         if (!lowLeafResult) {
             return undefined;
@@ -1254,7 +1291,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         }
     }
     async getPublicStorageAt(referenceBlock, contract, slot) {
-        const committedDb = await this.#getWorldState(referenceBlock);
+        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) {
@@ -1351,7 +1388,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     }
     async isValidTx(tx, { isSimulation, skipFeeEnforcement } = {}) {
         const db = this.worldStateSynchronizer.getCommitted();
-        const verifier = isSimulation ? undefined : this.proofVerifier;
+        const verifier = isSimulation ? undefined : this.rpcProofVerifier;
         // We accept transactions if they are not expired by the next slot (checked based on the ExpirationTimestamp field)
         const { ts: nextSlotTimestamp } = this.epochCache.getEpochAndSlotInNextL1Slot();
         const blockNumber = BlockNumber(await this.blockSource.getBlockNumber() + 1);
@@ -1393,7 +1430,18 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             archiver.updateConfig(config);
         }
         if (newConfig.realProofs !== this.config.realProofs) {
-            this.proofVerifier = config.realProofs ? await BBCircuitVerifier.new(newConfig) : new TestCircuitVerifier();
+            await Promise.all([
+                tryStop(this.peerProofVerifier),
+                tryStop(this.rpcProofVerifier)
+            ]);
+            if (newConfig.realProofs) {
+                this.peerProofVerifier = await BatchChonkVerifier.new(newConfig, newConfig.bbChonkVerifyMaxBatch, 'peer');
+                const rpcVerifier = await BBCircuitVerifier.new(newConfig);
+                this.rpcProofVerifier = new QueuedIVCVerifier(rpcVerifier, newConfig.numConcurrentIVCVerifiers);
+            } else {
+                this.peerProofVerifier = new TestCircuitVerifier();
+                this.rpcProofVerifier = new TestCircuitVerifier();
+            }
         }
         this.config = newConfig;
     }
@@ -1453,7 +1501,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         });
         return Promise.resolve();
     }
-    async rollbackTo(targetBlock, force) {
+    async rollbackTo(targetBlock, force, resumeSync = true) {
         const archiver = this.blockSource;
         if (!('rollbackTo' in archiver)) {
             throw new Error('Archiver implementation does not support rollbacks.');
@@ -1481,9 +1529,13 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             this.log.error(`Error during rollback`, err);
             throw err;
         } finally{
-            this.log.info(`Resuming world state and archiver sync.`);
-            this.worldStateSynchronizer.resumeSync();
-            archiver.resume();
+            if (resumeSync) {
+                this.log.info(`Resuming world state and archiver sync.`);
+                this.worldStateSynchronizer.resumeSync();
+                archiver.resume();
+            } else {
+                this.log.info(`Sync left paused after rollback (resumeSync=false).`);
+            }
         }
     }
     async pauseSync() {
@@ -1497,18 +1549,12 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         this.blockSource.resume();
         return Promise.resolve();
     }
-    getSlashPayloads() {
-        if (!this.slasherClient) {
-            throw new Error(`Slasher client not enabled`);
-        }
-        return this.slasherClient.getSlashPayloads();
-    }
     getSlashOffenses(round) {
         if (!this.slasherClient) {
             throw new Error(`Slasher client not enabled`);
         }
         if (round === 'all') {
-            return this.slasherClient.getPendingOffenses();
+            return this.slasherClient.getOffenses();
         } else {
             return this.slasherClient.gatherOffensesForRound(round === 'current' ? undefined : BigInt(round));
         }
@@ -1580,6 +1626,33 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         this.keyStoreManager = newManager;
         this.log.info('Keystore reloaded: coinbase, feeRecipient, and attester keys updated');
     }
+    async mineBlock() {
+        if (!this.sequencer) {
+            throw new BadRequestError('Cannot mine block: no sequencer is running');
+        }
+        const currentBlockNumber = await this.getBlockNumber();
+        // Use slot duration + 50% buffer as the timeout so this works on running networks too
+        const { slotDuration } = await this.blockSource.getL1Constants();
+        const timeoutSeconds = Math.ceil(slotDuration * 1.5);
+        // Temporarily set minTxsPerBlock to 0 so the sequencer produces a block even with no txs
+        const originalMinTxsPerBlock = this.sequencer.getSequencer().getConfig().minTxsPerBlock;
+        this.sequencer.updateConfig({
+            minTxsPerBlock: 0
+        });
+        try {
+            // Trigger the sequencer to produce a block immediately
+            void this.sequencer.trigger();
+            // Wait for the new L2 block to appear
+            await retryUntil(async ()=>{
+                const newBlockNumber = await this.getBlockNumber();
+                return newBlockNumber > currentBlockNumber ? true : undefined;
+            }, 'mineBlock', timeoutSeconds, 0.1);
+        } finally{
+            this.sequencer.updateConfig({
+                minTxsPerBlock: originalMinTxsPerBlock
+            });
+        }
+    }
     #getInitialHeaderHash() {
         if (!this.initialHeaderHashPromise) {
             this.initialHeaderHashPromise = this.worldStateSynchronizer.getCommitted().getInitialHeader().hash();
@@ -1590,7 +1663,7 @@ _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) {
+   */ async getWorldState(block) {
         let blockSyncedTo = BlockNumber.ZERO;
         try {
             // Attempt to sync the world state if necessary
@@ -1602,6 +1675,8 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             this.log.debug(`Using committed db for block 'latest', 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)) {
@@ -1612,19 +1687,41 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             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.`);
             }
-            const blockNumber = header.getBlockNumber();
-            this.log.debug(`Using snapshot for block ${blockNumber}, world state synced upto ${blockSyncedTo}`);
-            return this.worldStateSynchronizer.getSnapshot(blockNumber);
-        }
-        // Block number provided
-        {
-            const blockNumber = block;
-            if (blockNumber > blockSyncedTo) {
-                throw new Error(`Queried block ${block} not yet synced by the node (node is synced upto ${blockSyncedTo}).`);
+            blockNumber = header.getBlockNumber();
+        } else {
+            blockNumber = block;
+        }
+        // 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}).`);
+        }
+        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)) {
+            const blockHash = await snapshot.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(blockNumber));
+            if (!blockHash || !block.equals(blockHash)) {
+                throw new Error(`Block hash ${block.toString()} not found in world state at block number ${blockNumber}. 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;
+            }
+            const header = await this.blockSource.getBlockHeaderByHash(block);
+            if (!header) {
+                throw new Error(`Block hash ${block.toString()} not found.`);
             }
-            this.log.debug(`Using snapshot for block ${blockNumber}, world state synced upto ${blockSyncedTo}`);
-            return this.worldStateSynchronizer.getSnapshot(blockNumber);
+            return header.getBlockNumber();
         }
+        return block;
     }
     /**
    * Ensure we fully sync the world state