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

package/dest/public/{public_processor.d.ts → public_processor/public_processor.d.ts}

@@ -1,11 +1,13 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import { type FailedTx, type MerkleTreeWriteOperations, NestedProcessReturnValues, type ProcessedTx, Tx, type TxValidator } from '@aztec/circuit-types';
-import { type ContractDataSource, Gas, type GlobalVariables } from '@aztec/circuits.js';
 import { type DateProvider } from '@aztec/foundation/timer';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { Gas } from '@aztec/stdlib/gas';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { type FailedTx, GlobalVariables, NestedProcessReturnValues, type ProcessedTx, Tx, type TxValidator } from '@aztec/stdlib/tx';
 import { type TelemetryClient, type Traceable, type Tracer } from '@aztec/telemetry-client';
-import { WorldStateDB } from './public_db_sources.js';
-import { PublicTxSimulator } from './public_tx_simulator.js';
+import { WorldStateDB } from '../public_db_sources.js';
+import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
 /**
  * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
  */
@@ -18,11 +20,11 @@ export declare class PublicProcessorFactory {
      * 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.
+     * @param skipFeeEnforcement - Allows disabling balance checks for fee estimations.
      * @returns A new instance of a PublicProcessor.
      */
-    create(merkleTree: MerkleTreeWriteOperations, globalVariables: GlobalVariables, enforceFeePayment: boolean): PublicProcessor;
-    protected createPublicTxSimulator(db: MerkleTreeWriteOperations, worldStateDB: WorldStateDB, globalVariables: GlobalVariables, doMerkleOperations: boolean, enforceFeePayment: boolean, telemetryClient: TelemetryClient): PublicTxSimulator;
+    create(merkleTree: MerkleTreeWriteOperations, globalVariables: GlobalVariables, skipFeeEnforcement: boolean): PublicProcessor;
+    protected createPublicTxSimulator(db: MerkleTreeWriteOperations, worldStateDB: WorldStateDB, globalVariables: GlobalVariables, doMerkleOperations: boolean, skipFeeEnforcement: boolean, telemetryClient: TelemetryClient): PublicTxSimulator;
 }
 /**
  * Converts Txs lifted from the P2P module into ProcessedTx objects by executing
@@ -57,7 +59,7 @@ export declare class PublicProcessor implements Traceable {
         };
     }): Promise<[ProcessedTx[], FailedTx[], NestedProcessReturnValues[]]>;
     private processTx;
-    private commitTxState;
+    private doTreeInsertionsForPrivateOnlyTx;
     /** Processes the given tx within deadline. Returns timeout if deadline is hit. */
     private processTxWithinDeadline;
     /**

package/dest/public/public_processor/public_processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_processor.d.ts","sourceRoot":"","sources":["../../../src/public/public_processor/public_processor.ts"],"names":[],"mappings":";;AAIA,OAAO,EAAE,KAAK,YAAY,EAAkC,MAAM,yBAAyB,CAAC;AAM5F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AACxC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAEjF,OAAO,EACL,KAAK,QAAQ,EACb,eAAe,EACf,yBAAyB,EACzB,KAAK,WAAW,EAChB,EAAE,EAEF,KAAK,WAAW,EAGjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAGlF;;GAEG;AACH,qBAAa,sBAAsB;IAE/B,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,eAAe;gBAFf,kBAAkB,EAAE,kBAAkB,EACtC,YAAY,EAAE,YAAY,EAC1B,eAAe,GAAE,eAAsC;IAGjE;;;;;;OAMG;IACI,MAAM,CACX,UAAU,EAAE,yBAAyB,EACrC,eAAe,EAAE,eAAe,EAChC,kBAAkB,EAAE,OAAO,GAC1B,eAAe;IAqBlB,SAAS,CAAC,uBAAuB,CAC/B,EAAE,EAAE,yBAAyB,EAC7B,YAAY,EAAE,YAAY,EAC1B,eAAe,EAAE,eAAe,EAChC,kBAAkB,EAAE,OAAO,EAC3B,kBAAkB,EAAE,OAAO,EAC3B,eAAe,EAAE,eAAe;CAWnC;AASD;;;GAGG;AACH,qBAAa,eAAgB,YAAW,SAAS;IAG7C,SAAS,CAAC,EAAE,EAAE,yBAAyB;IACvC,SAAS,CAAC,eAAe,EAAE,eAAe;IAC1C,SAAS,CAAC,YAAY,EAAE,YAAY;IACpC,SAAS,CAAC,iBAAiB,EAAE,iBAAiB;IAC9C,OAAO,CAAC,YAAY;IAEpB,OAAO,CAAC,GAAG;IARb,OAAO,CAAC,OAAO,CAAyB;gBAE5B,EAAE,EAAE,yBAAyB,EAC7B,eAAe,EAAE,eAAe,EAChC,YAAY,EAAE,YAAY,EAC1B,iBAAiB,EAAE,iBAAiB,EACtC,YAAY,EAAE,YAAY,EAClC,eAAe,GAAE,eAAsC,EAC/C,GAAG,yCAA6C;IAK1D,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;OAKG;IACU,OAAO,CAClB,GAAG,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,EAAE,CAAC,EACrC,MAAM,GAAE;QACN,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,WAAW,CAAC,EAAE,GAAG,CAAC;QAClB,QAAQ,CAAC,EAAE,IAAI,CAAC;KACZ,EACN,UAAU,GAAE;QACV,mBAAmB,CAAC,EAAE,WAAW,CAAC,EAAE,CAAC,CAAC;QACtC,oBAAoB,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;QAChD,cAAc,CAAC,EAAE;YAAE,aAAa,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,IAAI,CAAA;SAAE,CAAC;KAC/D,GACL,OAAO,CAAC,CAAC,WAAW,EAAE,EAAE,QAAQ,EAAE,EAAE,yBAAyB,EAAE,CAAC,CAAC;YAwKtD,SAAS;YA2BT,gCAAgC;IAyC9C,kFAAkF;YACpE,uBAAuB;IA+BrC;;;;OAIG;YACW,4BAA4B;YAwB5B,oBAAoB;YA6BpB,wBAAwB;CA8CvC"}

package/dest/public/public_processor/public_processor.js

@@ -0,0 +1,379 @@
+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 { 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 { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
+import { PublicProcessorMetrics } from './public_processor_metrics.js';
+/**
+ * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
+ */ 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 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, skipFeeEnforcement, this.telemetryClient);
+        return new PublicProcessor(merkleTree, globalVariables, worldStateDB, publicTxSimulator, this.dateProvider, this.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'){
+        super(message);
+        this.name = 'PublicProcessorTimeoutError';
+    }
+}
+/**
+ * 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.
+ */ 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;
+            }
+            // 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.`);
+                }
+            }
+            // 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;
+                }
+                // 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 ${txHash.toString()} is valid post processing.`);
+                    }
+                }
+                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);
+                    // Add any contracts registered/deployed in this private-only tx to the block-level cache
+                    // (add to tx-level cache and then commit to block-level cache)
+                    await this.worldStateDB.addNewContracts(tx);
+                    this.worldStateDB.commitContractsForTx();
+                }
+                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 errorMessage = err instanceof Error ? err.message : 'Unknown error';
+                this.log.warn(`Failed to process tx ${txHash.toString()}: ${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();
+                // The tx-level contracts cache should not live on to the next tx
+                this.worldStateDB.clearContractsForTx();
+            }
+        }
+        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} failed 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}.`);
+            }
+        }
+        // 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.reverted) {
+                this.metrics.recordRevertedPhase(phase.phase);
+            } else {
+                this.metrics.recordPhaseDuration(phase.phase, phase.durationMs);
+            }
+        });
+        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);

package/dest/public/{public_processor_metrics.d.ts → public_processor/public_processor_metrics.d.ts}

@@ -1,6 +1,6 @@
-import { type TxExecutionPhase } from '@aztec/circuit-types';
-import { type Gas } from '@aztec/circuits.js';
-import { type ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import type { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import type { Gas } from '@aztec/stdlib/gas';
+import type { TxExecutionPhase } from '@aztec/stdlib/tx';
 import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
 export declare class PublicProcessorMetrics {
     readonly tracer: Tracer;

package/dest/public/public_processor/public_processor_metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_processor_metrics.d.ts","sourceRoot":"","sources":["../../../src/public/public_processor/public_processor_metrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,4CAA4C,CAAC;AAC/F,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAKL,KAAK,eAAe,EACpB,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAEjC,qBAAa,sBAAsB;IACjC,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,YAAY,CAAgB;IAEpC,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,UAAU,CAAgB;IAElC,OAAO,CAAC,gBAAgB,CAAY;IACpC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,iBAAiB,CAAY;IACrC,OAAO,CAAC,OAAO,CAAY;IAC3B,OAAO,CAAC,KAAK,CAAY;IAEzB,OAAO,CAAC,qBAAqB,CAAY;gBAE7B,MAAM,EAAE,eAAe,EAAE,IAAI,SAAoB;IA4D7D,mBAAmB,CAAC,SAAS,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM;IAKnE,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG;IAc7D,YAAY,CAAC,QAAQ,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM;IAkB3C,cAAc;IAMd,mBAAmB,CAAC,SAAS,EAAE,gBAAgB;IAI/C,uBAAuB,CAAC,GAAG,MAAM,EAAE,4BAA4B,EAAE;IAWjE,oBAAoB,CAAC,UAAU,EAAE,MAAM;CAGxC"}

package/dest/public/public_processor/public_processor_metrics.js

@@ -0,0 +1,125 @@
+import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+export class PublicProcessorMetrics {
+    tracer;
+    txDuration;
+    txCount;
+    txPhaseCount;
+    phaseDuration;
+    phaseCount;
+    bytecodeDeployed;
+    totalGas;
+    totalGasHistogram;
+    gasRate;
+    txGas;
+    treeInsertionDuration;
+    constructor(client, name = 'PublicProcessor'){
+        this.tracer = client.getTracer(name);
+        const meter = client.getMeter(name);
+        this.txDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TX_DURATION, {
+            description: 'How long it takes to process a transaction',
+            unit: 'ms',
+            valueType: ValueType.INT
+        });
+        this.txCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_TX_COUNT, {
+            description: 'Number of transactions processed'
+        });
+        this.txPhaseCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_TX_PHASE_COUNT, {
+            description: 'Number of phases processed'
+        });
+        this.phaseDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_PHASE_DURATION, {
+            description: 'How long it takes to process a phase',
+            unit: 'ms',
+            valueType: ValueType.INT
+        });
+        this.phaseCount = meter.createUpDownCounter(Metrics.PUBLIC_PROCESSOR_PHASE_COUNT, {
+            description: 'Number of failed phases'
+        });
+        this.bytecodeDeployed = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_DEPLOY_BYTECODE_SIZE, {
+            description: 'Size of deployed bytecode',
+            unit: 'By'
+        });
+        this.totalGas = meter.createGauge(Metrics.PUBLIC_PROCESSOR_TOTAL_GAS, {
+            description: 'Total gas used in block',
+            unit: 'gas'
+        });
+        this.totalGasHistogram = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TOTAL_GAS_HISTOGRAM, {
+            description: 'Total gas used in block as histogram',
+            unit: 'gas/block'
+        });
+        this.txGas = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TX_GAS, {
+            description: 'Gas used in transaction',
+            unit: 'gas/tx'
+        });
+        this.gasRate = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_GAS_RATE, {
+            description: 'L2 gas per second for complete block',
+            unit: 'gas/s'
+        });
+        this.treeInsertionDuration = meter.createHistogram(Metrics.PUBLIC_PROCESSOR_TREE_INSERTION, {
+            description: 'How long it takes for tree insertion',
+            unit: 'us',
+            valueType: ValueType.INT
+        });
+    }
+    recordPhaseDuration(phaseName, durationMs) {
+        this.phaseCount.add(1, {
+            [Attributes.TX_PHASE_NAME]: phaseName,
+            [Attributes.OK]: true
+        });
+        this.phaseDuration.record(Math.ceil(durationMs), {
+            [Attributes.TX_PHASE_NAME]: phaseName
+        });
+    }
+    recordTx(phaseCount, durationMs, gasUsed) {
+        this.txPhaseCount.add(phaseCount);
+        this.txDuration.record(Math.ceil(durationMs));
+        this.txCount.add(1, {
+            [Attributes.OK]: true
+        });
+        this.txGas.record(gasUsed.daGas, {
+            [Attributes.GAS_DIMENSION]: 'DA'
+        });
+        this.txGas.record(gasUsed.l2Gas, {
+            [Attributes.GAS_DIMENSION]: 'L2'
+        });
+    }
+    recordAllTxs(totalGas, gasRate) {
+        this.totalGas.record(totalGas.daGas, {
+            [Attributes.GAS_DIMENSION]: 'DA'
+        });
+        this.totalGas.record(totalGas.l2Gas, {
+            [Attributes.GAS_DIMENSION]: 'L2'
+        });
+        this.gasRate.record(gasRate, {
+            [Attributes.GAS_DIMENSION]: 'L2'
+        });
+        this.totalGasHistogram.record(totalGas.daGas, {
+            [Attributes.GAS_DIMENSION]: 'DA'
+        });
+        this.totalGasHistogram.record(totalGas.l2Gas, {
+            [Attributes.GAS_DIMENSION]: 'L2'
+        });
+    }
+    recordFailedTx() {
+        this.txCount.add(1, {
+            [Attributes.OK]: false
+        });
+    }
+    recordRevertedPhase(phaseName) {
+        this.phaseCount.add(1, {
+            [Attributes.TX_PHASE_NAME]: phaseName,
+            [Attributes.OK]: false
+        });
+    }
+    recordClassRegistration(...events) {
+        let totalBytecode = 0;
+        for (const event of events){
+            totalBytecode += event.packedPublicBytecode.length;
+        }
+        if (totalBytecode > 0) {
+            this.bytecodeDeployed.record(totalBytecode);
+        }
+    }
+    recordTreeInsertions(durationUs) {
+        this.treeInsertionDuration.record(Math.ceil(durationUs));
+    }
+}

package/dest/public/{public_tx_context.d.ts → public_tx_simulator/public_tx_context.d.ts}

@@ -1,8 +1,14 @@
-import { type AvmProvingRequest, type MerkleTreeReadOperations, type PublicExecutionRequest, type SimulationError, type Tx, TxExecutionPhase, type TxHash } from '@aztec/circuit-types';
-import { type AztecAddress, Fr, Gas, type GasSettings, type GlobalVariables, type PrivateToPublicAccumulatedData, PublicCallRequest, RevertCode, type StateReference } from '@aztec/circuits.js';
+import { Fr } from '@aztec/foundation/fields';
+import { type AvmProvingRequest, RevertCode } from '@aztec/stdlib/avm';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { SimulationError } from '@aztec/stdlib/errors';
+import { Gas, GasSettings } from '@aztec/stdlib/gas';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+import { type PrivateToPublicAccumulatedData, PublicCallRequest } from '@aztec/stdlib/kernel';
+import { type GlobalVariables, type PublicExecutionRequest, type StateReference, type Tx, TxExecutionPhase, type TxHash } from '@aztec/stdlib/tx';
 import { AvmPersistableStateManager } from '../avm/index.js';
-import { type WorldStateDB } from './public_db_sources.js';
-import { SideEffectTrace } from './side_effect_trace.js';
+import type { WorldStateDB } from '../public_db_sources.js';
+import { SideEffectTrace } from '../side_effect_trace.js';
 /**
  * The transaction-level context for public execution.
  */
@@ -38,7 +44,7 @@ export declare class PublicTxContext {
      * All phases have been processed.
      * Actual transaction fee and actual total consumed gas can now be queried.
      */
-    halt(): void;
+    halt(): Promise<void>;
     /**
      * Revert execution a phase. Populate revertReason & revertCode.
      * If in setup, throw an error (transaction will be thrown out).
@@ -121,11 +127,11 @@ declare class PhaseStateManager {
     private log;
     private currentlyActiveStateManager;
     constructor(txStateManager: AvmPersistableStateManager);
-    fork(): void;
+    fork(): Promise<void>;
     getActiveStateManager(): AvmPersistableStateManager;
     isForked(): boolean;
-    mergeForkedState(): void;
-    discardForkedState(): void;
+    mergeForkedState(): Promise<void>;
+    discardForkedState(): Promise<void>;
 }
 export {};
 //# sourceMappingURL=public_tx_context.d.ts.map

package/dest/public/public_tx_simulator/public_tx_context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_tx_context.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/public_tx_context.ts"],"names":[],"mappings":"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"}