@aztec/aztec-node 0.0.1-commit.f504929 → 0.0.1-commit.f650c0a5c

package/dest/aztec-node/server.js

@@ -372,15 +372,16 @@ 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';
@@ -411,9 +412,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';
@@ -440,7 +441,8 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     globalVariableBuilder;
     epochCache;
     packageVersion;
-    proofVerifier;
+    peerProofVerifier;
+    rpcProofVerifier;
     telemetry;
     log;
     blobClient;
@@ -461,7 +463,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, epochCache, packageVersion, peerProofVerifier, rpcProofVerifier, telemetry = getTelemetryClient(), log = createLogger('node'), blobClient, validatorClient, keyStoreManager, debugLogStore = new NullDebugLogStore()){
         this.config = config;
         this.p2pClient = p2pClient;
         this.blockSource = blockSource;
@@ -479,7 +481,8 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
         this.globalVariableBuilder = globalVariableBuilder;
         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 +502,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 +565,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');
@@ -571,10 +577,11 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             ...l1ContractsAddresses
         };
         const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
-        const [l1GenesisTime, slotDuration, rollupVersionFromRollup] = await Promise.all([
+        const [l1GenesisTime, slotDuration, rollupVersionFromRollup, rollupManaLimit] = await Promise.all([
             rollupContract.getL1GenesisTime(),
             rollupContract.getSlotDuration(),
-            rollupContract.getVersion()
+            rollupContract.getVersion(),
+            rollupContract.getManaLimit().then(Number)
         ]);
         config.rollupVersion ??= Number(rollupVersionFromRollup);
         if (config.rollupVersion !== Number(rollupVersionFromRollup)) {
@@ -595,8 +602,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`);
@@ -605,20 +622,22 @@ _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
+        // 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)
+            slotDuration: Number(slotDuration),
+            rollupManaLimit,
+            maxTxsPerCheckpoint: config.validateMaxTxsPerCheckpoint
         }, worldStateSynchronizer, archiver, dateProvider, telemetry);
         let validatorClient;
         if (!proverOnly) {
@@ -633,32 +652,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 but alwaysReexecuteBlockProposals is enabled,
-            // create a BlockProposalHandler to reexecute block proposals for monitoring
-            if (!validatorClient && config.alwaysReexecuteBlockProposals) {
-                log.info('Setting up block proposal reexecution for monitoring');
-                createBlockProposalHandler(config, {
-                    checkpointsBuilder: validatorCheckpointsBuilder,
-                    worldState: worldStateSynchronizer,
-                    epochCache,
-                    blockSource: archiver,
-                    l1ToL2MessageSource: archiver,
-                    p2pClient,
-                    dateProvider,
-                    telemetry
-                }).registerForReexecution(p2pClient);
-            }
+        }
+        // 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
+            }).register(p2pClient, reexecute, archiver);
         }
         // Start world state and wait for it to sync to the archiver.
         await worldStateSynchronizer.start();
@@ -690,6 +717,13 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             await attestationsBlockWatcher?.start();
             log.info(`All p2p services started`);
         }).catch((err)=>log.error('Failed to start p2p services after archiver sync', err));
+        const globalVariableBuilder = new GlobalVariableBuilder(dateProvider, publicClient, {
+            l1Contracts: config.l1Contracts,
+            ethereumSlotDuration: config.ethereumSlotDuration,
+            rollupVersion: BigInt(config.rollupVersion),
+            l1GenesisTime,
+            slotDuration: Number(slotDuration)
+        });
         // Validator enabled, create/start relevant service
         let sequencer;
         let slasherClient;
@@ -716,16 +750,34 @@ _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,
                 l1GenesisTime,
-                slotDuration: Number(slotDuration)
+                slotDuration: Number(slotDuration),
+                rollupManaLimit
             }, worldStateSynchronizer, archiver, dateProvider, telemetry, debugLogStore);
             sequencer = await SequencerClient.new(config, {
                 ...deps,
                 epochCache,
                 l1TxUtils,
+                funderL1TxUtils,
                 validatorClient,
                 p2pClient,
                 worldStateSynchronizer,
@@ -736,7 +788,8 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
                 telemetry,
                 dateProvider,
                 blobClient,
-                nodeKeyStore: keyStoreManager
+                nodeKeyStore: keyStoreManager,
+                globalVariableBuilder
             });
         }
         if (!options.dontStartSequencer && sequencer) {
@@ -766,13 +819,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, epochCache, packageVersion, peerProofVerifier, rpcProofVerifier, telemetry, log, blobClient, validatorClient, keyStoreManager, debugLogStore);
         return node;
     }
     /**
@@ -884,6 +931,9 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     async getCheckpointedBlocks(from, limit) {
         return await this.blockSource.getCheckpointedBlocks(from, limit) ?? [];
     }
+    getCheckpointsDataForEpoch(epochNumber) {
+        return this.blockSource.getCheckpointsDataForEpoch(epochNumber);
+    }
     /**
    * Method to fetch the current min L2 fees.
    * @returns The current min L2 fees.
@@ -911,6 +961,9 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
     async getCheckpointedBlockNumber() {
         return await this.blockSource.getCheckpointedL2BlockNumber();
     }
+    getCheckpointNumber() {
+        return this.blockSource.getCheckpointNumber();
+    }
     /**
    * Method to fetch the version of the package.
    * @returns The node package version
@@ -936,28 +989,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.
@@ -1030,7 +1091,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);
@@ -1072,70 +1136,82 @@ _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()));
-        // We filter out undefined values
-        const indices = maybeIndices.filter((x)=>x !== undefined);
-        // Now we find the block numbers for the indices
-        const blockNumbers = await committedDb.getBlockNumbersForLeafIndices(treeId, indices);
-        // If any of the block numbers are undefined, we throw an error.
-        for(let i = 0; i < indices.length; i++){
-            if (blockNumbers[i] === undefined) {
-                throw new Error(`Block number is undefined for leaf index ${indices[i]} in tree ${MerkleTreeId[treeId]}`);
+        // 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(blockNumbers.filter((x)=>x !== undefined))
+            ...new Set(indexToBlockNumber.values())
         ];
-        // Now we obtain the block hashes from the archive tree by calling await `committedDb.getLeafValue(treeId, index)`
-        // (note that block number corresponds to the leaf index in the archive tree).
+        // 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));
         }));
-        // If any of the block hashes are undefined, we throw an error.
+        // Build a map from block number to block hash
+        const blockNumberToHash = new Map();
         for(let i = 0; i < uniqueBlockNumbers.length; i++){
-            if (blockHashes[i] === undefined) {
+            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, i)=>{
+        return maybeIndices.map((index)=>{
             if (index === undefined) {
                 return undefined;
             }
-            const blockNumber = blockNumbers[i];
+            const blockNumber = indexToBlockNumber.get(index);
             if (blockNumber === undefined) {
-                return undefined;
+                throw new Error(`Block number not found for leaf index ${index} in tree ${MerkleTreeId[treeId]}`);
             }
-            const blockHashIndex = uniqueBlockNumbers.indexOf(blockNumber);
-            const blockHash = blockHashes[blockHashIndex];
-            if (!blockHash) {
-                return undefined;
+            const blockHash = blockNumberToHash.get(blockNumber);
+            if (blockHash === undefined) {
+                throw new Error(`Block hash not found for block number ${blockNumber}`);
             }
             return {
-                l2BlockNumber: BlockNumber(Number(blockNumber)),
+                l2BlockNumber: blockNumber,
                 l2BlockHash: new BlockHash(blockHash),
                 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
         ]);
@@ -1148,9 +1224,9 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             witness.path
         ];
     }
-    async getL1ToL2MessageBlock(l1ToL2Message) {
+    async getL1ToL2MessageCheckpoint(l1ToL2Message) {
         const messageIndex = await this.l1ToL2MessageSource.getL1ToL2MessageIndex(l1ToL2Message);
-        return messageIndex ? BlockNumber.fromCheckpointNumber(InboxLeaf.checkpointNumberFromIndex(messageIndex)) : undefined;
+        return messageIndex ? InboxLeaf.checkpointNumberFromIndex(messageIndex) : undefined;
     }
     /**
    * Returns whether an L1 to L2 message is synced by archiver and if it's ready to be included in a block.
@@ -1167,23 +1243,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()
         ]);
@@ -1197,36 +1261,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;
@@ -1237,7 +1287,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) {
@@ -1316,7 +1366,7 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             });
             const processor = publicProcessorFactory.create(merkleTreeFork, newGlobalVariables, config);
             // REFACTOR: Consider merging ProcessReturnValues into ProcessedTx
-            const [processedTxs, failedTxs, _usedTxs, returns, _blobFields, debugLogs] = await processor.process([
+            const [processedTxs, failedTxs, _usedTxs, returns, debugLogs] = await processor.process([
                 tx
             ]);
             // REFACTOR: Consider returning the error rather than throwing
@@ -1334,10 +1384,11 @@ _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);
+        const l1Constants = await this.blockSource.getL1Constants();
         const validator = createTxValidatorForAcceptingTxsOverRPC(db, this.contractDataSource, verifier, {
             timestamp: nextSlotTimestamp,
             blockNumber,
@@ -1349,7 +1400,10 @@ _dec = trackSpan('AztecNodeService.simulatePublicCalls', (tx)=>({
             ],
             gasFees: await this.getCurrentMinFees(),
             skipFeeEnforcement,
-            txsPermitted: !this.config.disableTransactions
+            txsPermitted: !this.config.disableTransactions,
+            rollupManaLimit: l1Constants.rollupManaLimit,
+            maxBlockL2Gas: this.config.validateMaxL2BlockGas,
+            maxBlockDAGas: this.config.validateMaxDABlockGas
         }, this.log.getBindings());
         return await validator.validateTx(tx);
     }
@@ -1372,7 +1426,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;
     }
@@ -1432,7 +1497,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.');
@@ -1460,9 +1525,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() {
@@ -1476,18 +1545,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));
         }
@@ -1569,7 +1632,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
@@ -1581,6 +1644,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)) {
@@ -1591,19 +1656,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 || !new BlockHash(blockHash).equals(block)) {
+                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