@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.17

package/dest/public/public_processor.js

@@ -1,44 +1,54 @@
-import { __esDecorate, __runInitializers } from "tslib";
-import { MerkleTreeId, NestedProcessReturnValues, Tx, TxExecutionPhase, makeProcessedTxFromPrivateOnlyTx, makeProcessedTxFromTxWithPublicCalls, } from '@aztec/circuit-types';
-import { Fr, Gas, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT, PublicDataWrite, } from '@aztec/circuits.js';
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NULLIFIER_SUBTREE_HEIGHT } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { Timer, elapsed, executeTimeout } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
-import { Attributes, getTelemetryClient, trackSpan, } from '@aztec/telemetry-client';
-import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from './fee_payment.js';
+import { computeFeePayerBalanceLeafSlot, computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { Gas } from '@aztec/stdlib/gas';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { NestedProcessReturnValues, Tx, TxExecutionPhase, makeProcessedTxFromPrivateOnlyTx, makeProcessedTxFromTxWithPublicCalls } from '@aztec/stdlib/tx';
+import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { ForkCheckpoint } from '@aztec/world-state/native';
 import { WorldStateDB } from './public_db_sources.js';
 import { PublicProcessorMetrics } from './public_processor_metrics.js';
 import { PublicTxSimulator } from './public_tx_simulator.js';
 /**
  * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
- */
-export class PublicProcessorFactory {
-    constructor(contractDataSource, dateProvider, telemetryClient = getTelemetryClient()) {
+ */ export class PublicProcessorFactory {
+    contractDataSource;
+    dateProvider;
+    telemetryClient;
+    constructor(contractDataSource, dateProvider, telemetryClient = getTelemetryClient()){
         this.contractDataSource = contractDataSource;
         this.dateProvider = dateProvider;
         this.telemetryClient = telemetryClient;
     }
     /**
-     * Creates a new instance of a PublicProcessor.
-     * @param historicalHeader - The header of a block previous to the one in which the tx is included.
-     * @param globalVariables - The global variables for the block being processed.
-     * @param enforceFeePayment - Allows disabling balance checks for fee estimations.
-     * @returns A new instance of a PublicProcessor.
-     */
-    create(merkleTree, globalVariables, enforceFeePayment) {
+   * Creates a new instance of a PublicProcessor.
+   * @param historicalHeader - The header of a block previous to the one in which the tx is included.
+   * @param globalVariables - The global variables for the block being processed.
+   * @param skipFeeEnforcement - Allows disabling balance checks for fee estimations.
+   * @returns A new instance of a PublicProcessor.
+   */ create(merkleTree, globalVariables, skipFeeEnforcement) {
         const worldStateDB = new WorldStateDB(merkleTree, this.contractDataSource);
-        const publicTxSimulator = this.createPublicTxSimulator(merkleTree, worldStateDB, globalVariables, 
-        /*doMerkleOperations=*/ true, enforceFeePayment, this.telemetryClient);
+        const publicTxSimulator = this.createPublicTxSimulator(merkleTree, worldStateDB, globalVariables, /*doMerkleOperations=*/ true, skipFeeEnforcement, this.telemetryClient);
         return new PublicProcessor(merkleTree, globalVariables, worldStateDB, publicTxSimulator, this.dateProvider, this.telemetryClient);
     }
-    createPublicTxSimulator(db, worldStateDB, globalVariables, doMerkleOperations, enforceFeePayment, telemetryClient) {
-        return new PublicTxSimulator(db, worldStateDB, globalVariables, doMerkleOperations, enforceFeePayment, telemetryClient);
+    createPublicTxSimulator(db, worldStateDB, globalVariables, doMerkleOperations, skipFeeEnforcement, telemetryClient) {
+        return new PublicTxSimulator(db, worldStateDB, globalVariables, doMerkleOperations, skipFeeEnforcement, telemetryClient);
     }
 }
 class PublicProcessorTimeoutError extends Error {
-    constructor(message = 'Timed out while processing tx') {
+    constructor(message = 'Timed out while processing tx'){
         super(message);
         this.name = 'PublicProcessorTimeoutError';
     }
@@ -46,307 +56,318 @@ class PublicProcessorTimeoutError extends Error {
 /**
  * Converts Txs lifted from the P2P module into ProcessedTx objects by executing
  * any public function calls in them. Txs with private calls only are unaffected.
- */
-let PublicProcessor = (() => {
-    var _a;
-    let _instanceExtraInitializers = [];
-    let _processTx_decorators;
-    let _processPrivateOnlyTx_decorators;
-    let _processTxWithPublicCalls_decorators;
-    return _a = class PublicProcessor {
-            constructor(db, globalVariables, worldStateDB, publicTxSimulator, dateProvider, telemetryClient = getTelemetryClient(), log = createLogger('simulator:public-processor')) {
-                this.db = (__runInitializers(this, _instanceExtraInitializers), db);
-                this.globalVariables = globalVariables;
-                this.worldStateDB = worldStateDB;
-                this.publicTxSimulator = publicTxSimulator;
-                this.dateProvider = dateProvider;
-                this.log = log;
-                this.metrics = new PublicProcessorMetrics(telemetryClient, 'PublicProcessor');
+ */ export class PublicProcessor {
+    db;
+    globalVariables;
+    worldStateDB;
+    publicTxSimulator;
+    dateProvider;
+    log;
+    metrics;
+    constructor(db, globalVariables, worldStateDB, publicTxSimulator, dateProvider, telemetryClient = getTelemetryClient(), log = createLogger('simulator:public-processor')){
+        this.db = db;
+        this.globalVariables = globalVariables;
+        this.worldStateDB = worldStateDB;
+        this.publicTxSimulator = publicTxSimulator;
+        this.dateProvider = dateProvider;
+        this.log = log;
+        this.metrics = new PublicProcessorMetrics(telemetryClient, 'PublicProcessor');
+    }
+    get tracer() {
+        return this.metrics.tracer;
+    }
+    /**
+   * Run each tx through the public circuit and the public kernel circuit if needed.
+   * @param txs - Txs to process.
+   * @param processedTxHandler - Handler for processed txs in the context of block building or proving.
+   * @returns The list of processed txs with their circuit simulation outputs.
+   */ async process(txs, limits = {}, validators = {}) {
+        const { maxTransactions, maxBlockSize, deadline, maxBlockGas } = limits;
+        const { preprocessValidator, postprocessValidator, nullifierCache } = validators;
+        const result = [];
+        const failed = [];
+        const timer = new Timer();
+        let totalSizeInBytes = 0;
+        let returns = [];
+        let totalPublicGas = new Gas(0, 0);
+        let totalBlockGas = new Gas(0, 0);
+        for await (const origTx of txs){
+            // Only process up to the max tx limit
+            if (maxTransactions !== undefined && result.length >= maxTransactions) {
+                this.log.debug(`Stopping tx processing due to reaching the max tx limit.`);
+                break;
             }
-            get tracer() {
-                return this.metrics.tracer;
+            // Bail if we've hit the deadline
+            if (deadline && this.dateProvider.now() > +deadline) {
+                this.log.warn(`Stopping tx processing due to timeout.`);
+                break;
             }
-            /**
-             * Run each tx through the public circuit and the public kernel circuit if needed.
-             * @param txs - Txs to process.
-             * @param processedTxHandler - Handler for processed txs in the context of block building or proving.
-             * @returns The list of processed txs with their circuit simulation outputs.
-             */
-            async process(txs, limits = {}, validators = {}) {
-                const { maxTransactions, maxBlockSize, deadline, maxBlockGas } = limits;
-                const { preprocessValidator, postprocessValidator, nullifierCache } = validators;
-                const result = [];
-                const failed = [];
-                const timer = new Timer();
-                let totalSizeInBytes = 0;
-                let returns = [];
-                let totalPublicGas = new Gas(0, 0);
-                let totalBlockGas = new Gas(0, 0);
-                for await (const origTx of txs) {
-                    // Only process up to the max tx limit
-                    if (maxTransactions !== undefined && result.length >= maxTransactions) {
-                        this.log.debug(`Stopping tx processing due to reaching the max tx limit.`);
-                        break;
-                    }
-                    // Bail if we've hit the deadline
-                    if (deadline && this.dateProvider.now() > +deadline) {
-                        this.log.warn(`Stopping tx processing due to timeout.`);
-                        break;
-                    }
-                    // Skip this tx if it'd exceed max block size
-                    const txHash = (await origTx.getTxHash()).toString();
-                    const preTxSizeInBytes = origTx.getEstimatedPrivateTxEffectsSize();
-                    if (maxBlockSize !== undefined && totalSizeInBytes + preTxSizeInBytes > maxBlockSize) {
-                        this.log.warn(`Skipping processing of tx ${txHash} sized ${preTxSizeInBytes} bytes due to block size limit`, {
-                            txHash,
-                            sizeInBytes: preTxSizeInBytes,
-                            totalSizeInBytes,
-                            maxBlockSize,
-                        });
-                        continue;
-                    }
-                    // Skip this tx if its gas limit would exceed the block gas limit
-                    const txGasLimit = origTx.data.constants.txContext.gasSettings.gasLimits;
-                    if (maxBlockGas !== undefined && totalBlockGas.add(txGasLimit).gtAny(maxBlockGas)) {
-                        this.log.warn(`Skipping processing of tx ${txHash} due to block gas limit`, {
-                            txHash,
-                            txGasLimit,
-                            totalBlockGas,
-                            maxBlockGas,
-                        });
-                        continue;
-                    }
-                    // The processor modifies the tx objects in place, so we need to clone them.
-                    const tx = Tx.clone(origTx);
-                    // We validate the tx before processing it, to avoid unnecessary work.
-                    if (preprocessValidator) {
-                        const result = await preprocessValidator.validateTx(tx);
-                        const txHash = await tx.getTxHash();
-                        if (result.result === 'invalid') {
-                            const reason = result.reason.join(', ');
-                            this.log.warn(`Rejecting tx ${txHash.toString()} due to pre-process validation fail: ${reason}`);
-                            failed.push({ tx, error: new Error(`Tx failed preprocess validation: ${reason}`) });
-                            returns.push(new NestedProcessReturnValues([]));
-                            continue;
-                        }
-                        else if (result.result === 'skipped') {
-                            const reason = result.reason.join(', ');
-                            this.log.warn(`Skipping tx ${txHash.toString()} due to pre-process validation: ${reason}`);
-                            returns.push(new NestedProcessReturnValues([]));
-                            continue;
-                        }
-                        else {
-                            this.log.trace(`Tx ${txHash.toString()} is valid before processing.`);
-                        }
-                    }
-                    try {
-                        const [processedTx, returnValues] = await this.processTx(tx, deadline);
-                        // If the actual size of this tx would exceed block size, skip it
-                        const txSize = processedTx.txEffect.getDASize();
-                        if (maxBlockSize !== undefined && totalSizeInBytes + txSize > maxBlockSize) {
-                            this.log.warn(`Skipping processed tx ${txHash} sized ${txSize} due to max block size.`, {
-                                txHash,
-                                sizeInBytes: txSize,
-                                totalSizeInBytes,
-                                maxBlockSize,
-                            });
-                            continue;
-                        }
-                        // Re-validate the transaction
-                        if (postprocessValidator) {
-                            // Only accept processed transactions that are not double-spends,
-                            // public functions emitting nullifiers would pass earlier check but fail here.
-                            // Note that we're checking all nullifiers generated in the private execution twice,
-                            // we could store the ones already checked and skip them here as an optimization.
-                            // TODO(palla/txs): Can we get into this case? AVM validates this. We should be able to remove it.
-                            const result = await postprocessValidator.validateTx(processedTx);
-                            if (result.result !== 'valid') {
-                                const reason = result.reason.join(', ');
-                                this.log.error(`Rejecting tx ${processedTx.hash} after processing: ${reason}.`);
-                                failed.push({ tx, error: new Error(`Tx failed post-process validation: ${reason}`) });
-                                continue;
-                            }
-                            else {
-                                this.log.trace(`Tx ${(await tx.getTxHash()).toString()} is valid post processing.`);
-                            }
-                        }
-                        // Otherwise, commit tx state for the next tx to be processed
-                        await this.commitTxState(processedTx);
-                        nullifierCache?.addNullifiers(processedTx.txEffect.nullifiers.map(n => n.toBuffer()));
-                        result.push(processedTx);
-                        returns = returns.concat(returnValues);
-                        totalPublicGas = totalPublicGas.add(processedTx.gasUsed.publicGas);
-                        totalBlockGas = totalBlockGas.add(processedTx.gasUsed.totalGas);
-                        totalSizeInBytes += txSize;
-                    }
-                    catch (err) {
-                        if (err?.name === 'PublicProcessorTimeoutError') {
-                            this.log.warn(`Stopping tx processing due to timeout.`);
-                            break;
-                        }
-                        const errorMessage = err instanceof Error ? err.message : 'Unknown error';
-                        this.log.warn(`Failed to process tx ${tx.getTxHash()}: ${errorMessage} ${err?.stack}`);
-                        failed.push({ tx, error: err instanceof Error ? err : new Error(errorMessage) });
-                        returns.push(new NestedProcessReturnValues([]));
-                    }
-                }
-                const duration = timer.s();
-                const rate = duration > 0 ? totalPublicGas.l2Gas / duration : 0;
-                this.metrics.recordAllTxs(totalPublicGas, rate);
-                this.log.info(`Processed ${result.length} successful txs and ${failed.length} txs in ${duration}s`, {
-                    duration,
-                    rate,
-                    totalPublicGas,
-                    totalBlockGas,
+            // Skip this tx if it'd exceed max block size
+            const txHash = (await origTx.getTxHash()).toString();
+            const preTxSizeInBytes = origTx.getEstimatedPrivateTxEffectsSize();
+            if (maxBlockSize !== undefined && totalSizeInBytes + preTxSizeInBytes > maxBlockSize) {
+                this.log.warn(`Skipping processing of tx ${txHash} sized ${preTxSizeInBytes} bytes due to block size limit`, {
+                    txHash,
+                    sizeInBytes: preTxSizeInBytes,
                     totalSizeInBytes,
+                    maxBlockSize
                 });
-                return [result, failed, returns];
+                continue;
             }
-            async processTx(tx, deadline) {
-                const [time, [processedTx, returnValues]] = await elapsed(() => this.processTxWithinDeadline(tx, deadline));
-                this.log.verbose(!tx.hasPublicCalls()
-                    ? `Processed tx ${processedTx.hash} with no public calls in ${time}ms`
-                    : `Processed tx ${processedTx.hash} with ${tx.enqueuedPublicFunctionCalls.length} public calls in ${time}ms`, {
-                    txHash: processedTx.hash,
-                    txFee: processedTx.txEffect.transactionFee.toBigInt(),
-                    revertCode: processedTx.txEffect.revertCode.getCode(),
-                    revertReason: processedTx.revertReason,
-                    gasUsed: processedTx.gasUsed,
-                    publicDataWriteCount: processedTx.txEffect.publicDataWrites.length,
-                    nullifierCount: processedTx.txEffect.nullifiers.length,
-                    noteHashCount: processedTx.txEffect.noteHashes.length,
-                    contractClassLogCount: processedTx.txEffect.contractClassLogs.getTotalLogCount(),
-                    publicLogCount: processedTx.txEffect.publicLogs.length,
-                    privateLogCount: processedTx.txEffect.privateLogs.length,
-                    l2ToL1MessageCount: processedTx.txEffect.l2ToL1Msgs.length,
-                    durationMs: time,
+            // Skip this tx if its gas limit would exceed the block gas limit
+            const txGasLimit = origTx.data.constants.txContext.gasSettings.gasLimits;
+            if (maxBlockGas !== undefined && totalBlockGas.add(txGasLimit).gtAny(maxBlockGas)) {
+                this.log.warn(`Skipping processing of tx ${txHash} due to block gas limit`, {
+                    txHash,
+                    txGasLimit,
+                    totalBlockGas,
+                    maxBlockGas
                 });
-                return [processedTx, returnValues ?? []];
+                continue;
             }
-            async commitTxState(processedTx, txValidator) {
-                // Commit the state updates from this transaction
-                // TODO(palla/txs): It seems like this doesn't do anything...?
-                await this.worldStateDB.commit();
-                // Update the state so that the next tx in the loop has the correct .startState
-                // NB: before this change, all .startStates were actually incorrect, but the issue was never caught because we either:
-                // a) had only 1 tx with public calls per block, so this loop had len 1
-                // b) always had a txHandler with the same db passed to it as this.db, which updated the db in buildBaseRollupHints in this loop
-                // To see how this ^ happens, move back to one shared db in test_context and run orchestrator_multi_public_functions.test.ts
-                // The below is taken from buildBaseRollupHints:
-                const treeInsertionStart = process.hrtime.bigint();
-                await this.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, padArrayEnd(processedTx.txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX));
-                try {
-                    await this.db.batchInsert(MerkleTreeId.NULLIFIER_TREE, padArrayEnd(processedTx.txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map(n => n.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
-                }
-                catch (error) {
-                    if (txValidator) {
-                        // Ideally the validator has already caught this above, but just in case:
-                        throw new Error(`Transaction ${processedTx.hash} invalid after processing public functions`);
-                    }
-                    else {
-                        // We have no validator and assume this call should blindly process txs with duplicates being caught later
-                        this.log.warn(`Detected duplicate nullifier after public processing for: ${processedTx.hash}.`);
-                    }
+            // The processor modifies the tx objects in place, so we need to clone them.
+            const tx = Tx.clone(origTx);
+            // We validate the tx before processing it, to avoid unnecessary work.
+            if (preprocessValidator) {
+                const result = await preprocessValidator.validateTx(tx);
+                const txHash = await tx.getTxHash();
+                if (result.result === 'invalid') {
+                    const reason = result.reason.join(', ');
+                    this.log.warn(`Rejecting tx ${txHash.toString()} due to pre-process validation fail: ${reason}`);
+                    failed.push({
+                        tx,
+                        error: new Error(`Tx failed preprocess validation: ${reason}`)
+                    });
+                    returns.push(new NestedProcessReturnValues([]));
+                    continue;
+                } else if (result.result === 'skipped') {
+                    const reason = result.reason.join(', ');
+                    this.log.warn(`Skipping tx ${txHash.toString()} due to pre-process validation: ${reason}`);
+                    returns.push(new NestedProcessReturnValues([]));
+                    continue;
+                } else {
+                    this.log.trace(`Tx ${txHash.toString()} is valid before processing.`);
                 }
-                await this.db.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, processedTx.txEffect.publicDataWrites.map(x => x.toBuffer()));
-                const treeInsertionEnd = process.hrtime.bigint();
-                this.metrics.recordTreeInsertions(Number(treeInsertionEnd - treeInsertionStart) / 1000);
             }
-            /** Processes the given tx within deadline. Returns timeout if deadline is hit. */
-            async processTxWithinDeadline(tx, deadline) {
-                const processFn = tx.hasPublicCalls()
-                    ? () => this.processTxWithPublicCalls(tx)
-                    : () => this.processPrivateOnlyTx(tx);
-                if (!deadline) {
-                    return await processFn();
+            // We checkpoint the transaction here, then within the try/catch we
+            // 1. Revert the checkpoint if the tx fails or needs to be discarded for any reason
+            // 2. Commit the transaction in the finally block. Note that by using the ForkCheckpoint lifecycle only the first commit/revert takes effect
+            const checkpoint = await ForkCheckpoint.new(this.worldStateDB);
+            try {
+                const [processedTx, returnValues] = await this.processTx(tx, deadline);
+                // If the actual size of this tx would exceed block size, skip it
+                const txSize = processedTx.txEffect.getDASize();
+                if (maxBlockSize !== undefined && totalSizeInBytes + txSize > maxBlockSize) {
+                    this.log.warn(`Skipping processed tx ${txHash} sized ${txSize} due to max block size.`, {
+                        txHash,
+                        sizeInBytes: txSize,
+                        totalSizeInBytes,
+                        maxBlockSize
+                    });
+                    // Need to revert the checkpoint here and don't go any further
+                    await checkpoint.revert();
+                    continue;
                 }
-                const txHash = await tx.getTxHash();
-                const timeout = +deadline - this.dateProvider.now();
-                if (timeout <= 0) {
-                    throw new PublicProcessorTimeoutError();
+                // Re-validate the transaction
+                if (postprocessValidator) {
+                    // Only accept processed transactions that are not double-spends,
+                    // public functions emitting nullifiers would pass earlier check but fail here.
+                    // Note that we're checking all nullifiers generated in the private execution twice,
+                    // we could store the ones already checked and skip them here as an optimization.
+                    // TODO(palla/txs): Can we get into this case? AVM validates this. We should be able to remove it.
+                    const result = await postprocessValidator.validateTx(processedTx);
+                    if (result.result !== 'valid') {
+                        const reason = result.reason.join(', ');
+                        this.log.error(`Rejecting tx ${processedTx.hash} after processing: ${reason}.`);
+                        failed.push({
+                            tx,
+                            error: new Error(`Tx failed post-process validation: ${reason}`)
+                        });
+                        // Need to revert the checkpoint here and don't go any further
+                        await checkpoint.revert();
+                        continue;
+                    } else {
+                        this.log.trace(`Tx ${(await tx.getTxHash()).toString()} is valid post processing.`);
+                    }
                 }
-                this.log.debug(`Processing tx ${txHash.toString()} within ${timeout}ms`, {
-                    deadline: deadline.toISOString(),
-                    now: new Date(this.dateProvider.now()).toISOString(),
-                    txHash,
-                });
-                return await executeTimeout(() => processFn(), timeout, () => new PublicProcessorTimeoutError());
-            }
-            /**
-             * Creates the public data write for paying the tx fee.
-             * This is used in private only txs, since for txs with public calls
-             * the avm handles the fee payment itself.
-             */
-            async getFeePaymentPublicDataWrite(txFee, feePayer) {
-                if (feePayer.isZero()) {
-                    this.log.debug(`No one is paying the fee of ${txFee.toBigInt()}`);
-                    return;
+                if (!tx.hasPublicCalls()) {
+                    // If there are no public calls, perform all tree insertions for side effects from private
+                    // When there are public calls, the PublicTxSimulator & AVM handle tree insertions.
+                    await this.doTreeInsertionsForPrivateOnlyTx(processedTx);
                 }
-                const feeJuiceAddress = ProtocolContractAddress.FeeJuice;
-                const balanceSlot = await computeFeePayerBalanceStorageSlot(feePayer);
-                const leafSlot = await computeFeePayerBalanceLeafSlot(feePayer);
-                this.log.debug(`Deducting ${txFee.toBigInt()} balance in Fee Juice for ${feePayer}`);
-                const balance = await this.worldStateDB.storageRead(feeJuiceAddress, balanceSlot);
-                if (balance.lt(txFee)) {
-                    throw new Error(`Not enough balance for fee payer to pay for transaction (got ${balance.toBigInt()} needs ${txFee.toBigInt()})`);
+                nullifierCache?.addNullifiers(processedTx.txEffect.nullifiers.map((n)=>n.toBuffer()));
+                result.push(processedTx);
+                returns = returns.concat(returnValues);
+                totalPublicGas = totalPublicGas.add(processedTx.gasUsed.publicGas);
+                totalBlockGas = totalBlockGas.add(processedTx.gasUsed.totalGas);
+                totalSizeInBytes += txSize;
+            } catch (err) {
+                // Roll back state to start of TX before proceeding to next TX
+                await checkpoint.revert();
+                if (err?.name === 'PublicProcessorTimeoutError') {
+                    this.log.warn(`Stopping tx processing due to timeout.`);
+                    break;
                 }
-                const updatedBalance = balance.sub(txFee);
-                await this.worldStateDB.storageWrite(feeJuiceAddress, balanceSlot, updatedBalance);
-                return new PublicDataWrite(leafSlot, updatedBalance);
+                const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+                this.log.warn(`Failed to process tx ${tx.getTxHash()}: ${errorMessage} ${err?.stack}`);
+                failed.push({
+                    tx,
+                    error: err instanceof Error ? err : new Error(errorMessage)
+                });
+                returns.push(new NestedProcessReturnValues([]));
+            } finally{
+                // Base case is we always commit the checkpoint. Using the ForkCheckpoint means this has no effect if the tx was reverted
+                await checkpoint.commit();
             }
-            async processPrivateOnlyTx(tx) {
-                const gasFees = this.globalVariables.gasFees;
-                const transactionFee = tx.data.gasUsed.computeFee(gasFees);
-                const feePaymentPublicDataWrite = await this.getFeePaymentPublicDataWrite(transactionFee, tx.data.feePayer);
-                const processedTx = await makeProcessedTxFromPrivateOnlyTx(tx, transactionFee, feePaymentPublicDataWrite, this.globalVariables);
-                this.metrics.recordClassRegistration(...tx.contractClassLogs
-                    .unrollLogs()
-                    .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log.data))
-                    .map(log => ContractClassRegisteredEvent.fromLog(log.data)));
-                return [processedTx, undefined];
+        }
+        const duration = timer.s();
+        const rate = duration > 0 ? totalPublicGas.l2Gas / duration : 0;
+        this.metrics.recordAllTxs(totalPublicGas, rate);
+        this.log.info(`Processed ${result.length} successful txs and ${failed.length} txs in ${duration}s`, {
+            duration,
+            rate,
+            totalPublicGas,
+            totalBlockGas,
+            totalSizeInBytes
+        });
+        return [
+            result,
+            failed,
+            returns
+        ];
+    }
+    async processTx(tx, deadline) {
+        const [time, [processedTx, returnValues]] = await elapsed(()=>this.processTxWithinDeadline(tx, deadline));
+        this.log.verbose(!tx.hasPublicCalls() ? `Processed tx ${processedTx.hash} with no public calls in ${time}ms` : `Processed tx ${processedTx.hash} with ${tx.enqueuedPublicFunctionCalls.length} public calls in ${time}ms`, {
+            txHash: processedTx.hash,
+            txFee: processedTx.txEffect.transactionFee.toBigInt(),
+            revertCode: processedTx.txEffect.revertCode.getCode(),
+            revertReason: processedTx.revertReason,
+            gasUsed: processedTx.gasUsed,
+            publicDataWriteCount: processedTx.txEffect.publicDataWrites.length,
+            nullifierCount: processedTx.txEffect.nullifiers.length,
+            noteHashCount: processedTx.txEffect.noteHashes.length,
+            contractClassLogCount: processedTx.txEffect.contractClassLogs.length,
+            publicLogCount: processedTx.txEffect.publicLogs.length,
+            privateLogCount: processedTx.txEffect.privateLogs.length,
+            l2ToL1MessageCount: processedTx.txEffect.l2ToL1Msgs.length,
+            durationMs: time
+        });
+        return [
+            processedTx,
+            returnValues ?? []
+        ];
+    }
+    async doTreeInsertionsForPrivateOnlyTx(processedTx, txValidator) {
+        const treeInsertionStart = process.hrtime.bigint();
+        // Update the state so that the next tx in the loop has the correct .startState
+        // NB: before this change, all .startStates were actually incorrect, but the issue was never caught because we either:
+        // a) had only 1 tx with public calls per block, so this loop had len 1
+        // b) always had a txHandler with the same db passed to it as this.db, which updated the db in buildBaseRollupHints in this loop
+        // To see how this ^ happens, move back to one shared db in test_context and run orchestrator_multi_public_functions.test.ts
+        // The below is taken from buildBaseRollupHints:
+        await this.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, padArrayEnd(processedTx.txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX));
+        try {
+            await this.db.batchInsert(MerkleTreeId.NULLIFIER_TREE, padArrayEnd(processedTx.txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map((n)=>n.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
+        } catch (error) {
+            if (txValidator) {
+                // Ideally the validator has already caught this above, but just in case:
+                throw new Error(`Transaction ${processedTx.hash} invalid after processing public functions`);
+            } else {
+                // We have no validator and assume this call should blindly process txs with duplicates being caught later
+                this.log.warn(`Detected duplicate nullifier after public processing for: ${processedTx.hash}.`);
             }
-            async processTxWithPublicCalls(tx) {
-                const timer = new Timer();
-                const { avmProvingRequest, gasUsed, revertCode, revertReason, processedPhases } = await this.publicTxSimulator.simulate(tx);
-                if (!avmProvingRequest) {
-                    this.metrics.recordFailedTx();
-                    throw new Error('Avm proving result was not generated.');
-                }
-                processedPhases.forEach(phase => {
-                    if (phase.revertReason) {
-                        this.metrics.recordRevertedPhase(phase.phase);
-                    }
-                    else {
-                        this.metrics.recordPhaseDuration(phase.phase, phase.durationMs);
-                    }
-                });
-                this.metrics.recordClassRegistration(...tx.contractClassLogs
-                    .unrollLogs()
-                    .filter(log => ContractClassRegisteredEvent.isContractClassRegisteredEvent(log.data))
-                    .map(log => ContractClassRegisteredEvent.fromLog(log.data)));
-                const phaseCount = processedPhases.length;
-                const durationMs = timer.ms();
-                this.metrics.recordTx(phaseCount, durationMs, gasUsed.publicGas);
-                const processedTx = await makeProcessedTxFromTxWithPublicCalls(tx, avmProvingRequest, gasUsed, revertCode, revertReason);
-                const returnValues = processedPhases.find(({ phase }) => phase === TxExecutionPhase.APP_LOGIC)?.returnValues ?? [];
-                return [processedTx, returnValues];
+        }
+        // The only public data write should be for fee payment
+        await this.db.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, processedTx.txEffect.publicDataWrites.map((x)=>x.toBuffer()));
+        const treeInsertionEnd = process.hrtime.bigint();
+        this.metrics.recordTreeInsertions(Number(treeInsertionEnd - treeInsertionStart) / 1_000);
+    }
+    /** Processes the given tx within deadline. Returns timeout if deadline is hit. */ async processTxWithinDeadline(tx, deadline) {
+        const processFn = tx.hasPublicCalls() ? ()=>this.processTxWithPublicCalls(tx) : ()=>this.processPrivateOnlyTx(tx);
+        if (!deadline) {
+            return await processFn();
+        }
+        const txHash = await tx.getTxHash();
+        const timeout = +deadline - this.dateProvider.now();
+        if (timeout <= 0) {
+            throw new PublicProcessorTimeoutError();
+        }
+        this.log.debug(`Processing tx ${txHash.toString()} within ${timeout}ms`, {
+            deadline: deadline.toISOString(),
+            now: new Date(this.dateProvider.now()).toISOString(),
+            txHash
+        });
+        return await executeTimeout(()=>processFn(), timeout, ()=>new PublicProcessorTimeoutError());
+    }
+    /**
+   * Creates the public data write for paying the tx fee.
+   * This is used in private only txs, since for txs with public calls
+   * the avm handles the fee payment itself.
+   */ async getFeePaymentPublicDataWrite(txFee, feePayer) {
+        const feeJuiceAddress = ProtocolContractAddress.FeeJuice;
+        const balanceSlot = await computeFeePayerBalanceStorageSlot(feePayer);
+        const leafSlot = await computeFeePayerBalanceLeafSlot(feePayer);
+        this.log.debug(`Deducting ${txFee.toBigInt()} balance in Fee Juice for ${feePayer}`);
+        const balance = await this.worldStateDB.storageRead(feeJuiceAddress, balanceSlot);
+        if (balance.lt(txFee)) {
+            throw new Error(`Not enough balance for fee payer to pay for transaction (got ${balance.toBigInt()} needs ${txFee.toBigInt()})`);
+        }
+        const updatedBalance = balance.sub(txFee);
+        await this.worldStateDB.storageWrite(feeJuiceAddress, balanceSlot, updatedBalance);
+        return new PublicDataWrite(leafSlot, updatedBalance);
+    }
+    async processPrivateOnlyTx(tx) {
+        const gasFees = this.globalVariables.gasFees;
+        const transactionFee = tx.data.gasUsed.computeFee(gasFees);
+        const feePaymentPublicDataWrite = await this.getFeePaymentPublicDataWrite(transactionFee, tx.data.feePayer);
+        const processedTx = await makeProcessedTxFromPrivateOnlyTx(tx, transactionFee, feePaymentPublicDataWrite, this.globalVariables);
+        const siloedContractClassLogs = await tx.filterContractClassLogs(tx.data.getNonEmptyContractClassLogsHashes(), true);
+        this.metrics.recordClassRegistration(...siloedContractClassLogs.filter((log)=>ContractClassRegisteredEvent.isContractClassRegisteredEvent(log)).map((log)=>ContractClassRegisteredEvent.fromLog(log)));
+        return [
+            processedTx,
+            undefined
+        ];
+    }
+    async processTxWithPublicCalls(tx) {
+        const timer = new Timer();
+        const { avmProvingRequest, gasUsed, revertCode, revertReason, processedPhases } = await this.publicTxSimulator.simulate(tx);
+        if (!avmProvingRequest) {
+            this.metrics.recordFailedTx();
+            throw new Error('Avm proving result was not generated.');
+        }
+        processedPhases.forEach((phase)=>{
+            if (phase.revertReason) {
+                this.metrics.recordRevertedPhase(phase.phase);
+            } else {
+                this.metrics.recordPhaseDuration(phase.phase, phase.durationMs);
             }
-        },
-        (() => {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _processTx_decorators = [trackSpan('PublicProcessor.processTx', async (tx) => ({ [Attributes.TX_HASH]: (await tx.getTxHash()).toString() }))];
-            _processPrivateOnlyTx_decorators = [trackSpan('PublicProcessor.processPrivateOnlyTx', async (tx) => ({
-                    [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
-                }))];
-            _processTxWithPublicCalls_decorators = [trackSpan('PublicProcessor.processTxWithPublicCalls', async (tx) => ({
-                    [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
-                }))];
-            __esDecorate(_a, null, _processTx_decorators, { kind: "method", name: "processTx", static: false, private: false, access: { has: obj => "processTx" in obj, get: obj => obj.processTx }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _processPrivateOnlyTx_decorators, { kind: "method", name: "processPrivateOnlyTx", static: false, private: false, access: { has: obj => "processPrivateOnlyTx" in obj, get: obj => obj.processPrivateOnlyTx }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _processTxWithPublicCalls_decorators, { kind: "method", name: "processTxWithPublicCalls", static: false, private: false, access: { has: obj => "processTxWithPublicCalls" in obj, get: obj => obj.processTxWithPublicCalls }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        })(),
-        _a;
-})();
-export { PublicProcessor };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public_processor.js","sourceRoot":"","sources":["../../src/public/public_processor.ts"],"names":[],"mappings":"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"}
+        });
+        const siloedContractClassLogs = await tx.filterContractClassLogs(tx.data.getNonEmptyContractClassLogsHashes(), true);
+        this.metrics.recordClassRegistration(...siloedContractClassLogs.filter((log)=>ContractClassRegisteredEvent.isContractClassRegisteredEvent(log)).map((log)=>ContractClassRegisteredEvent.fromLog(log)));
+        const phaseCount = processedPhases.length;
+        const durationMs = timer.ms();
+        this.metrics.recordTx(phaseCount, durationMs, gasUsed.publicGas);
+        const processedTx = await makeProcessedTxFromTxWithPublicCalls(tx, avmProvingRequest, gasUsed, revertCode, revertReason);
+        const returnValues = processedPhases.find(({ phase })=>phase === TxExecutionPhase.APP_LOGIC)?.returnValues ?? [];
+        return [
+            processedTx,
+            returnValues
+        ];
+    }
+}
+_ts_decorate([
+    trackSpan('PublicProcessor.processTx', async (tx)=>({
+            [Attributes.TX_HASH]: (await tx.getTxHash()).toString()
+        }))
+], PublicProcessor.prototype, "processTx", null);
+_ts_decorate([
+    trackSpan('PublicProcessor.processPrivateOnlyTx', async (tx)=>({
+            [Attributes.TX_HASH]: (await tx.getTxHash()).toString()
+        }))
+], PublicProcessor.prototype, "processPrivateOnlyTx", null);
+_ts_decorate([
+    trackSpan('PublicProcessor.processTxWithPublicCalls', async (tx)=>({
+            [Attributes.TX_HASH]: (await tx.getTxHash()).toString()
+        }))
+], PublicProcessor.prototype, "processTxWithPublicCalls", null);