@aztec/simulator 0.82.2-alpha-testnet.4 → 0.82.3

package/dest/public/public_tx_simulator/public_tx_context.js

@@ -12,7 +12,7 @@ import { TreeSnapshots, TxExecutionPhase } from '@aztec/stdlib/tx';
 import { strict as assert } from 'assert';
 import { inspect } from 'util';
 import { AvmPersistableStateManager } from '../avm/index.js';
-import { HintingPublicContractsDB } from '../hinting_db_sources.js';
+import { HintingPublicContractsDB, HintingPublicTreesDB } from '../hinting_db_sources.js';
 import { SideEffectArrayLengths, SideEffectTrace } from '../side_effect_trace.js';
 import { getCallRequestsWithCalldataByPhase } from '../utils.js';
 /**
@@ -69,9 +69,9 @@ import { getCallRequestsWithCalldataByPhase } from '../utils.js';
         // We wrap the DB to collect AVM hints.
         const hints = new AvmExecutionHints();
         const hintingContractsDB = new HintingPublicContractsDB(contractsDB, hints);
-        // TODO: Wrap merkle db.
+        const hintingTreesDB = new HintingPublicTreesDB(treesDB, hints);
         // Transaction level state manager that will be forked for revertible phases.
-        const txStateManager = AvmPersistableStateManager.create(treesDB, hintingContractsDB, trace, doMerkleOperations, firstNullifier, globalVariables.blockNumber.toNumber());
+        const txStateManager = AvmPersistableStateManager.create(hintingTreesDB, hintingContractsDB, trace, doMerkleOperations, firstNullifier, globalVariables.blockNumber.toNumber());
         const gasSettings = tx.data.constants.txContext.gasSettings;
         const gasUsedByPrivate = tx.data.gasUsed;
         // Gas allocated to public is "whatever's left" after private, but with some max applied.
@@ -215,13 +215,15 @@ import { getCallRequestsWithCalldataByPhase } from '../utils.js';
     }
     /**
    * Generate the public inputs for the AVM circuit.
-   */ async generateAvmCircuitPublicInputs(endStateReference) {
+   */ async generateAvmCircuitPublicInputs() {
         assert(this.halted, 'Can only get AvmCircuitPublicInputs after tx execution ends');
         const stateManager = this.state.getActiveStateManager();
         const startTreeSnapshots = new TreeSnapshots(this.startStateReference.l1ToL2MessageTree, this.startStateReference.partial.noteHashTree, this.startStateReference.partial.nullifierTree, this.startStateReference.partial.publicDataTree);
-        // Will be patched/padded at the end of this fn
-        const endTreeSnapshots = new TreeSnapshots(endStateReference.l1ToL2MessageTree, endStateReference.partial.noteHashTree, endStateReference.partial.nullifierTree, endStateReference.partial.publicDataTree);
-        const avmCircuitPublicInputs = this.trace.toAvmCircuitPublicInputs(this.globalVariables, startTreeSnapshots, /*startGasUsed=*/ this.gasUsedByPrivate, this.gasSettings, this.feePayer, this.setupCallRequests.map((r)=>r.request), this.appLogicCallRequests.map((r)=>r.request), /*teardownCallRequest=*/ this.teardownCallRequests.length ? this.teardownCallRequests[0].request : PublicCallRequest.empty(), endTreeSnapshots, /*endGasUsed=*/ this.getTotalGasUsed(), /*transactionFee=*/ this.getTransactionFeeUnsafe(), /*reverted=*/ !this.revertCode.isOK());
+        // FIXME: We are first creating the PIs with the wrong endTreeSnapshots, then patching them.
+        // This is because we need to know the lengths of the accumulated data arrays to pad them.
+        // We should refactor this to avoid this hack.
+        // We should just get the info we need from the trace, and create the rest of the PIs here.
+        const avmCircuitPublicInputs = this.trace.toAvmCircuitPublicInputs(this.globalVariables, startTreeSnapshots, /*startGasUsed=*/ this.gasUsedByPrivate, this.gasSettings, this.feePayer, this.setupCallRequests.map((r)=>r.request), this.appLogicCallRequests.map((r)=>r.request), /*teardownCallRequest=*/ this.teardownCallRequests.length ? this.teardownCallRequests[0].request : PublicCallRequest.empty(), /*endTreeSnapshots=*/ TreeSnapshots.empty(), /*endGasUsed=*/ this.getTotalGasUsed(), /*transactionFee=*/ this.getTransactionFeeUnsafe(), /*reverted=*/ !this.revertCode.isOK());
         const getArrayLengths = (from)=>new PrivateToAvmAccumulatedDataArrayLengths(countAccumulatedItems(from.noteHashes), countAccumulatedItems(from.nullifiers), countAccumulatedItems(from.l2ToL1Msgs));
         const convertAccumulatedData = (from)=>new PrivateToAvmAccumulatedData(from.noteHashes, from.nullifiers, from.l2ToL1Msgs);
         // Temporary overrides as these entries aren't yet populated in trace

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

@@ -1,14 +1,16 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { type Logger } from '@aztec/foundation/log';
 import { type AvmProvingRequest, type RevertCode } from '@aztec/stdlib/avm';
 import { SimulationError } from '@aztec/stdlib/errors';
-import type { GasUsed } from '@aztec/stdlib/gas';
-import { type GlobalVariables, NestedProcessReturnValues, Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
-import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
-import { ExecutorMetrics } from '../executor_metrics.js';
+import type { Gas, GasUsed } from '@aztec/stdlib/gas';
+import { type GlobalVariables, NestedProcessReturnValues, PublicCallRequestWithCalldata, Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
+import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
+import { type AvmPersistableStateManager } from '../avm/index.js';
 import type { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
 import { PublicTxContext } from './public_tx_context.js';
 export type ProcessedPhase = {
     phase: TxExecutionPhase;
-    durationMs: number;
+    durationMs?: number;
     returnValues: NestedProcessReturnValues[];
     reverted: boolean;
     revertReason?: SimulationError;
@@ -24,20 +26,19 @@ export type PublicTxResult = {
 };
 export declare class PublicTxSimulator {
     private treesDB;
-    private contractsDB;
+    protected contractsDB: PublicContractsDB;
     private globalVariables;
     private doMerkleOperations;
     private skipFeeEnforcement;
-    metrics: ExecutorMetrics;
-    private log;
-    constructor(treesDB: PublicTreesDB, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, doMerkleOperations?: boolean, skipFeeEnforcement?: boolean, telemetryClient?: TelemetryClient);
-    get tracer(): Tracer;
+    protected log: Logger;
+    constructor(treesDB: PublicTreesDB, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, doMerkleOperations?: boolean, skipFeeEnforcement?: boolean);
     /**
      * Simulate a transaction's public portion including all of its phases.
      * @param tx - The transaction to simulate.
      * @returns The result of the transaction's public execution.
      */
     simulate(tx: Tx): Promise<PublicTxResult>;
+    protected computeTxHash(tx: Tx): Promise<import("@aztec/stdlib/tx").TxHash>;
     /**
      * Simulate the setup phase of a transaction's public execution.
      * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
@@ -62,7 +63,7 @@ export declare class PublicTxSimulator {
      * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
      * @returns The phase result.
      */
-    private simulatePhase;
+    protected simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase>;
     /**
      * Simulate an enqueued public call.
      * @param phase - The current phase of public execution
@@ -70,7 +71,7 @@ export declare class PublicTxSimulator {
      * @param callRequest - The public function call request, including the calldata.
      * @returns The result of execution.
      */
-    private simulateEnqueuedCall;
+    protected simulateEnqueuedCall(phase: TxExecutionPhase, context: PublicTxContext, callRequest: PublicCallRequestWithCalldata): Promise<AvmFinalizedCallResult>;
     /**
      * Simulate an enqueued public call, without modifying the context (PublicTxContext).
      * Resulting modifications to the context can be applied by the caller.
@@ -79,22 +80,21 @@ export declare class PublicTxSimulator {
      * while still simulating phases and generating a proving request.
      *
      * @param stateManager - The state manager for AvmSimulation
-     * @param context - The context of the currently executing public transaction portion
      * @param callRequest - The public function call request, including the calldata.
      * @param allocatedGas - The gas allocated to the enqueued call
      * @param fnName - The name of the function
      * @returns The result of execution.
      */
-    private simulateEnqueuedCallInternal;
+    protected simulateEnqueuedCallInternal(stateManager: AvmPersistableStateManager, { request, calldata }: PublicCallRequestWithCalldata, allocatedGas: Gas, transactionFee: Fr, fnName: string): Promise<AvmFinalizedCallResult>;
     /**
      * Insert the non-revertible accumulated data from private into the public state.
      */
-    insertNonRevertiblesFromPrivate(context: PublicTxContext): Promise<void>;
+    protected insertNonRevertiblesFromPrivate(context: PublicTxContext, tx: Tx): Promise<void>;
     /**
      * Insert the revertible accumulated data from private into the public state.
      * Start by forking state so we can rollback to the end of setup if app logic or teardown reverts.
      */
-    insertRevertiblesFromPrivate(context: PublicTxContext): Promise<boolean>;
+    protected insertRevertiblesFromPrivate(context: PublicTxContext, tx: Tx): Promise<boolean>;
     private payFee;
     /**
      * Generate the proving request for the AVM circuit.

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

@@ -1 +1 @@
-{"version":3,"file":"public_tx_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/public_tx_simulator.ts"],"names":[],"mappings":"AAKA,OAAO,EAKL,KAAK,iBAAiB,EACtB,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAO,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAGtD,OAAO,EACL,KAAK,eAAe,EACpB,yBAAyB,EAEzB,EAAE,EACF,gBAAgB,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAc,KAAK,eAAe,EAAE,KAAK,MAAM,EAAiC,MAAM,yBAAyB,CAAC;AAQvH,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,gBAAgB,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,yBAAyB,EAAE,CAAC;IAC1C,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,eAAe,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,+CAA+C;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,UAAU,CAAC;IACvB,4BAA4B;IAC5B,YAAY,CAAC,EAAE,eAAe,CAAC;IAC/B,eAAe,EAAE,cAAc,EAAE,CAAC;CACnC,CAAC;AAEF,qBAAa,iBAAiB;IAM1B,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,kBAAkB;IAT5B,OAAO,EAAE,eAAe,CAAC;IAEzB,OAAO,CAAC,GAAG,CAAS;gBAGV,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EAChC,kBAAkB,GAAE,OAAe,EACnC,kBAAkB,GAAE,OAAe,EAC3C,eAAe,GAAE,eAAsC;IAMzD,IAAI,MAAM,IAAI,MAAM,CAEnB;IACD;;;;OAIG;IACU,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAyFtD;;;;OAIG;YACW,kBAAkB;IAIhC;;;;OAIG;YACW,qBAAqB;IAkBnC;;;;OAIG;YACW,qBAAqB;IAoBnC;;;;;OAKG;YACW,aAAa;IAuC3B;;;;;;OAMG;YAOW,oBAAoB;IA8ClC;;;;;;;;;;;;;OAaG;YAOW,4BAA4B;IAgD1C;;OAEG;IACU,+BAA+B,CAAC,OAAO,EAAE,eAAe;IAkBrE;;;OAGG;IACU,4BAA4B,CAAC,OAAO,EAAE,eAAe,GAAgB,OAAO,CAAC,OAAO,CAAC;YA+BpF,MAAM;IAgCpB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;CAStC"}
+{"version":3,"file":"public_tx_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/public_tx_simulator.ts"],"names":[],"mappings":"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"}

package/dest/public/public_tx_simulator/public_tx_simulator.js

@@ -1,23 +1,14 @@
-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 { createLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
 import { AvmCircuitInputs, AvmEnqueuedCallHint } from '@aztec/stdlib/avm';
 import { SimulationError } from '@aztec/stdlib/errors';
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 import { NestedProcessReturnValues, TxExecutionPhase } from '@aztec/stdlib/tx';
-import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { strict as assert } from 'assert';
 import { getPublicFunctionDebugName } from '../../common/debug_fn_name.js';
 import { AvmSimulator } from '../avm/index.js';
 import { NullifierCollisionError } from '../avm/journal/nullifiers.js';
-import { ExecutorMetrics } from '../executor_metrics.js';
 import { PublicTxContext } from './public_tx_context.js';
 export class PublicTxSimulator {
     treesDB;
@@ -25,19 +16,14 @@ export class PublicTxSimulator {
     globalVariables;
     doMerkleOperations;
     skipFeeEnforcement;
-    metrics;
     log;
-    constructor(treesDB, contractsDB, globalVariables, doMerkleOperations = false, skipFeeEnforcement = false, telemetryClient = getTelemetryClient()){
+    constructor(treesDB, contractsDB, globalVariables, doMerkleOperations = false, skipFeeEnforcement = false){
         this.treesDB = treesDB;
         this.contractsDB = contractsDB;
         this.globalVariables = globalVariables;
         this.doMerkleOperations = doMerkleOperations;
         this.skipFeeEnforcement = skipFeeEnforcement;
         this.log = createLogger(`simulator:public_tx_simulator`);
-        this.metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
-    }
-    get tracer() {
-        return this.metrics.tracer;
     }
     /**
    * Simulate a transaction's public portion including all of its phases.
@@ -45,31 +31,19 @@ export class PublicTxSimulator {
    * @returns The result of the transaction's public execution.
    */ async simulate(tx) {
         try {
-            const startTime = process.hrtime.bigint();
-            const txHash = await tx.getTxHash();
+            const txHash = await this.computeTxHash(tx);
             this.log.debug(`Simulating ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, {
                 txHash
             });
             const context = await PublicTxContext.create(this.treesDB, this.contractsDB, tx, this.globalVariables, this.doMerkleOperations);
-            const nonRevertStart = process.hrtime.bigint();
-            await this.insertNonRevertiblesFromPrivate(context);
-            // add new contracts to the contracts db so that their functions may be found and called
-            // TODO(#6464): Should we allow emitting contracts in the private setup phase?
-            await this.contractsDB.addNewNonRevertibleContracts(tx);
-            const nonRevertEnd = process.hrtime.bigint();
-            this.metrics.recordPrivateEffectsInsertion(Number(nonRevertEnd - nonRevertStart) / 1_000, 'non-revertible');
+            await this.insertNonRevertiblesFromPrivate(context, tx);
             const processedPhases = [];
             if (context.hasPhase(TxExecutionPhase.SETUP)) {
                 const setupResult = await this.simulateSetupPhase(context);
                 processedPhases.push(setupResult);
             }
-            const revertStart = process.hrtime.bigint();
-            const success = await this.insertRevertiblesFromPrivate(context);
+            const success = await this.insertRevertiblesFromPrivate(context, tx);
             if (success) {
-                // add new contracts to the contracts db so that their functions may be found and called
-                await this.contractsDB.addNewRevertibleContracts(tx);
-                const revertEnd = process.hrtime.bigint();
-                this.metrics.recordPrivateEffectsInsertion(Number(revertEnd - revertStart) / 1_000, 'revertible');
                 // Only proceed with app logic if there was no revert during revertible insertion
                 if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
                     const appLogicResult = await this.simulateAppLogicPhase(context);
@@ -84,7 +58,7 @@ export class PublicTxSimulator {
             }
             await context.halt();
             await this.payFee(context);
-            const publicInputs = await context.generateAvmCircuitPublicInputs(await this.treesDB.getStateReference());
+            const publicInputs = await context.generateAvmCircuitPublicInputs();
             const avmProvingRequest = PublicTxSimulator.generateProvingRequest(publicInputs, context.hints);
             const revertCode = context.getFinalRevertCode();
             if (!revertCode.isOK()) {
@@ -93,9 +67,9 @@ export class PublicTxSimulator {
             // Commit contracts from this TX to the block-level cache and clear tx cache
             // If the tx reverted, only commit non-revertible contracts
             // NOTE: You can't create contracts in public, so this is only relevant for private-created contracts
+            // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
+            // However things should work as they are now because the hinted db would still pick up the new contracts.
             this.contractsDB.commitContractsForTx(/*onlyNonRevertibles=*/ !revertCode.isOK());
-            const endTime = process.hrtime.bigint();
-            this.log.debug(`Public TX simulator took ${Number(endTime - startTime) / 1_000_000} ms\n`);
             return {
                 avmProvingRequest,
                 gasUsed: {
@@ -111,9 +85,14 @@ export class PublicTxSimulator {
         } finally{
             // Make sure there are no new contracts in the tx-level cache.
             // They should either be committed to block-level cache or cleared.
+            // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
+            // However things should work as they are now because the hinted db would still pick up the new contracts.
             this.contractsDB.clearContractsForTx();
         }
     }
+    async computeTxHash(tx) {
+        return await tx.getTxHash();
+    }
     /**
    * Simulate the setup phase of a transaction's public execution.
    * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
@@ -174,7 +153,6 @@ export class PublicTxSimulator {
         const returnValues = [];
         let reverted = false;
         let revertReason;
-        const phaseTimer = new Timer();
         for(let i = callRequests.length - 1; i >= 0; i--){
             if (reverted) {
                 break;
@@ -189,7 +167,6 @@ export class PublicTxSimulator {
         }
         return {
             phase,
-            durationMs: phaseTimer.ms(),
             returnValues,
             reverted,
             revertReason
@@ -229,7 +206,6 @@ export class PublicTxSimulator {
    * while still simulating phases and generating a proving request.
    *
    * @param stateManager - The state manager for AvmSimulation
-   * @param context - The context of the currently executing public transaction portion
    * @param callRequest - The public function call request, including the calldata.
    * @param allocatedGas - The gas allocated to the enqueued call
    * @param fnName - The name of the function
@@ -238,25 +214,13 @@ export class PublicTxSimulator {
         const address = request.contractAddress;
         const sender = request.msgSender;
         this.log.debug(`Executing enqueued public call to external function ${fnName}@${address} with ${allocatedGas.l2Gas} allocated L2 gas.`);
-        const timer = new Timer();
         const simulator = await AvmSimulator.create(stateManager, address, sender, transactionFee, this.globalVariables, request.isStaticCall, calldata, allocatedGas);
         const avmCallResult = await simulator.execute();
-        const result = avmCallResult.finalize();
-        this.log.verbose(result.reverted ? `Simulation of enqueued public call ${fnName} reverted with reason ${result.revertReason}.` : `Simulation of enqueued public call ${fnName} completed successfully.`, {
-            eventName: 'avm-simulation',
-            appCircuitName: fnName,
-            duration: timer.ms()
-        });
-        if (result.reverted) {
-            this.metrics.recordFunctionSimulationFailure();
-        } else {
-            this.metrics.recordFunctionSimulation(timer.ms(), allocatedGas.sub(result.gasLeft).l2Gas, fnName);
-        }
-        return result;
+        return avmCallResult.finalize();
     }
     /**
    * Insert the non-revertible accumulated data from private into the public state.
-   */ async insertNonRevertiblesFromPrivate(context) {
+   */ async insertNonRevertiblesFromPrivate(context, tx) {
         const stateManager = context.state.getActiveStateManager();
         try {
             await stateManager.writeSiloedNullifiersFromPrivate(context.nonRevertibleAccumulatedDataFromPrivate.nullifiers);
@@ -270,11 +234,16 @@ export class PublicTxSimulator {
                 await stateManager.writeUniqueNoteHash(noteHash);
             }
         }
+        // add new contracts to the contracts db so that their functions may be found and called
+        // TODO(#6464): Should we allow emitting contracts in the private setup phase?
+        // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
+        // However things should work as they are now because the hinted db would still pick up the new contracts.
+        await this.contractsDB.addNewNonRevertibleContracts(tx);
     }
     /**
    * Insert the revertible accumulated data from private into the public state.
    * Start by forking state so we can rollback to the end of setup if app logic or teardown reverts.
-   */ async insertRevertiblesFromPrivate(context) {
+   */ async insertRevertiblesFromPrivate(context, tx) {
         // Fork the state manager so we can rollback to end of setup if app logic reverts.
         await context.state.fork();
         const stateManager = context.state.getActiveStateManager();
@@ -295,6 +264,10 @@ export class PublicTxSimulator {
                 await stateManager.writeSiloedNoteHash(noteHash);
             }
         }
+        // add new contracts to the contracts db so that their functions may be found and called
+        // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
+        // However things should work as they are now because the hinted db would still pick up the new contracts.
+        await this.contractsDB.addNewRevertibleContracts(tx);
         return /*success=*/ true;
     }
     async payFee(context) {
@@ -329,16 +302,3 @@ export class PublicTxSimulator {
         };
     }
 }
-_ts_decorate([
-    trackSpan('PublicTxSimulator.simulateEnqueuedCall', (phase, context, callRequest)=>({
-            [Attributes.TX_HASH]: context.txHash.toString(),
-            [Attributes.TARGET_ADDRESS]: callRequest.request.contractAddress.toString(),
-            [Attributes.SENDER_ADDRESS]: callRequest.request.msgSender.toString(),
-            [Attributes.SIMULATOR_PHASE]: TxExecutionPhase[phase].toString()
-        }))
-], PublicTxSimulator.prototype, "simulateEnqueuedCall", null);
-_ts_decorate([
-    trackSpan('PublicTxSimulator.simulateEnqueuedCallInternal', (_stateManager, _callRequest, _allocatedGas, _transactionFee, fnName)=>({
-            [Attributes.APP_CIRCUIT_NAME]: fnName
-        }))
-], PublicTxSimulator.prototype, "simulateEnqueuedCallInternal", null);

package/dest/public/public_tx_simulator/telemetry_public_tx_simulator.d.ts

@@ -0,0 +1,19 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { Gas } from '@aztec/stdlib/gas';
+import { type GlobalVariables, PublicCallRequestWithCalldata, TxExecutionPhase } from '@aztec/stdlib/tx';
+import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
+import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
+import type { AvmPersistableStateManager } from '../avm/index.js';
+import type { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
+import { MeasuredPublicTxSimulator } from './measured_public_tx_simulator.js';
+import { PublicTxContext } from './public_tx_context.js';
+/**
+ * A public tx simulator that tracks runtime/production metrics with telemetry.
+ */
+export declare class TelemetryPublicTxSimulator extends MeasuredPublicTxSimulator {
+    readonly tracer: Tracer;
+    constructor(treesDB: PublicTreesDB, contractsDB: PublicContractsDB, globalVariables: GlobalVariables, doMerkleOperations?: boolean, skipFeeEnforcement?: boolean, telemetryClient?: TelemetryClient);
+    protected simulateEnqueuedCall(phase: TxExecutionPhase, context: PublicTxContext, callRequest: PublicCallRequestWithCalldata): Promise<AvmFinalizedCallResult>;
+    protected simulateEnqueuedCallInternal(stateManager: AvmPersistableStateManager, callRequest: PublicCallRequestWithCalldata, allocatedGas: Gas, transactionFee: Fr, fnName: string): Promise<AvmFinalizedCallResult>;
+}
+//# sourceMappingURL=telemetry_public_tx_simulator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry_public_tx_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/telemetry_public_tx_simulator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,KAAK,eAAe,EAAE,6BAA6B,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzG,OAAO,EAAc,KAAK,eAAe,EAAE,KAAK,MAAM,EAAiC,MAAM,yBAAyB,CAAC;AAEvH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AACjF,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAElE,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAChF,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD;;GAEG;AACH,qBAAa,0BAA2B,SAAQ,yBAAyB;IAEvE,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAG7B,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,iBAAiB,EAC9B,eAAe,EAAE,eAAe,EAChC,kBAAkB,GAAE,OAAe,EACnC,kBAAkB,GAAE,OAAe,EACnC,eAAe,GAAE,eAAsC;cAahC,oBAAoB,CAC3C,KAAK,EAAE,gBAAgB,EACvB,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,6BAA6B,GACzC,OAAO,CAAC,sBAAsB,CAAC;cAUT,4BAA4B,CACnD,YAAY,EAAE,0BAA0B,EACxC,WAAW,EAAE,6BAA6B,EAC1C,YAAY,EAAE,GAAG,EACjB,cAAc,EAAE,EAAE,EAClB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,sBAAsB,CAAC;CAGnC"}

package/dest/public/public_tx_simulator/telemetry_public_tx_simulator.js

@@ -0,0 +1,39 @@
+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 { TxExecutionPhase } from '@aztec/stdlib/tx';
+import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { ExecutorMetrics } from '../executor_metrics.js';
+import { MeasuredPublicTxSimulator } from './measured_public_tx_simulator.js';
+/**
+ * A public tx simulator that tracks runtime/production metrics with telemetry.
+ */ export class TelemetryPublicTxSimulator extends MeasuredPublicTxSimulator {
+    /* tracer needed by trackSpans */ tracer;
+    constructor(treesDB, contractsDB, globalVariables, doMerkleOperations = false, skipFeeEnforcement = false, telemetryClient = getTelemetryClient()){
+        const metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
+        super(treesDB, contractsDB, globalVariables, doMerkleOperations, skipFeeEnforcement, metrics);
+        this.tracer = metrics.tracer;
+    }
+    async simulateEnqueuedCall(phase, context, callRequest) {
+        return await super.simulateEnqueuedCall(phase, context, callRequest);
+    }
+    async simulateEnqueuedCallInternal(stateManager, callRequest, allocatedGas, transactionFee, fnName) {
+        return await super.simulateEnqueuedCallInternal(stateManager, callRequest, allocatedGas, transactionFee, fnName);
+    }
+}
+_ts_decorate([
+    trackSpan('PublicTxSimulator.simulateEnqueuedCall', (phase, context, callRequest)=>({
+            [Attributes.TX_HASH]: context.txHash.toString(),
+            [Attributes.TARGET_ADDRESS]: callRequest.request.contractAddress.toString(),
+            [Attributes.SENDER_ADDRESS]: callRequest.request.msgSender.toString(),
+            [Attributes.SIMULATOR_PHASE]: TxExecutionPhase[phase].toString()
+        }))
+], TelemetryPublicTxSimulator.prototype, "simulateEnqueuedCall", null);
+_ts_decorate([
+    trackSpan('PublicTxSimulator.simulateEnqueuedCallInternal', (_stateManager, _callRequest, _allocatedGas, _transactionFee, fnName)=>({
+            [Attributes.APP_CIRCUIT_NAME]: fnName
+        }))
+], TelemetryPublicTxSimulator.prototype, "simulateEnqueuedCallInternal", null);

package/dest/public/test_executor_metrics.d.ts

@@ -0,0 +1,43 @@
+import type { RevertCode } from '@aztec/stdlib/avm';
+import type { ExecutorMetricsInterface } from './executor_metrics_interface.js';
+export interface PublicEnqueuedCallMetrics {
+    fnName: string;
+    durationMs: number;
+    manaUsed: number;
+    totalInstructions: number;
+    reverted: boolean;
+}
+export interface PublicTxMetrics {
+    totalDurationMs: number;
+    manaUsed: number;
+    totalInstructions: number;
+    txHashMs: number | undefined;
+    nonRevertiblePrivateInsertionsUs: number | undefined;
+    revertiblePrivateInsertionsUs: number | undefined;
+    enqueuedCalls: PublicEnqueuedCallMetrics[];
+    revertedCode: RevertCode | undefined;
+}
+export declare enum PublicTxMetricsFilter {
+    ALL = 0,
+    TOTALS = 1,
+    DURATIONS = 2,
+    INSTRUCTIONS = 3
+}
+export declare class TestExecutorMetrics implements ExecutorMetricsInterface {
+    #private;
+    private logger;
+    private txMetrics;
+    private currentTxLabel;
+    private txTimer;
+    constructor();
+    startRecordingTxSimulation(txLabel: string): void;
+    stopRecordingTxSimulation(txLabel: string, revertedCode?: RevertCode): void;
+    recordEnqueuedCallSimulation(fnName: string, durationMs: number, manaUsed: number, totalInstructions: number): void;
+    recordEnqueuedCallSimulationFailure(fnName: string, durationMs: number, manaUsed: number, totalInstructions: number): void;
+    recordTxHashComputation(durationMs: number): void;
+    recordPrivateEffectsInsertion(durationUs: number, type: 'revertible' | 'non-revertible'): void;
+    prettyPrint(filter?: PublicTxMetricsFilter): void;
+    toPrettyString(filter?: PublicTxMetricsFilter): string;
+    toJSON(indent?: number): string;
+}
+//# sourceMappingURL=test_executor_metrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test_executor_metrics.d.ts","sourceRoot":"","sources":["../../src/public/test_executor_metrics.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIpD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAEhF,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,gCAAgC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrD,6BAA6B,EAAE,MAAM,GAAG,SAAS,CAAC;IAClD,aAAa,EAAE,yBAAyB,EAAE,CAAC;IAC3C,YAAY,EAAE,UAAU,GAAG,SAAS,CAAC;CACtC;AAWD,oBAAY,qBAAqB;IAC/B,GAAG,IAAA;IACH,MAAM,IAAA;IACN,SAAS,IAAA;IACT,YAAY,IAAA;CACb;AAED,qBAAa,mBAAoB,YAAW,wBAAwB;;IAClE,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,SAAS,CAA2C;IAC5D,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,OAAO,CAAoB;;IAMnC,0BAA0B,CAAC,OAAO,EAAE,MAAM;IAiB1C,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,UAAU;IAkBpE,4BAA4B,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM;IAI5G,mCAAmC,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM;IAsBnH,uBAAuB,CAAC,UAAU,EAAE,MAAM;IAO1C,6BAA6B,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,gBAAgB;IAkBvF,WAAW,CAAC,MAAM,GAAE,qBAAiD;IAIrE,cAAc,CAAC,MAAM,GAAE,qBAAiD;IAqExE,MAAM,CAAC,MAAM,SAAI;CAGlB"}

package/dest/public/test_executor_metrics.js

@@ -0,0 +1,158 @@
+import { sum } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { strict as assert } from 'assert';
+const NUM_SPACES = 4;
+const H1 = '# ';
+const H2 = '\n## ';
+const INDENT = ' '.repeat(NUM_SPACES);
+const INDENT0 = '- ';
+const INDENT1 = INDENT + '- ';
+const INDENT2 = INDENT + INDENT + '- ';
+const H_LINE = '\n---------------------------------------------------------------------';
+export var PublicTxMetricsFilter = /*#__PURE__*/ function(PublicTxMetricsFilter) {
+    PublicTxMetricsFilter[PublicTxMetricsFilter["ALL"] = 0] = "ALL";
+    PublicTxMetricsFilter[PublicTxMetricsFilter["TOTALS"] = 1] = "TOTALS";
+    PublicTxMetricsFilter[PublicTxMetricsFilter["DURATIONS"] = 2] = "DURATIONS";
+    PublicTxMetricsFilter[PublicTxMetricsFilter["INSTRUCTIONS"] = 3] = "INSTRUCTIONS";
+    return PublicTxMetricsFilter;
+}({});
+export class TestExecutorMetrics {
+    logger;
+    // tx label -> tx metrics
+    txMetrics = new Map();
+    currentTxLabel;
+    txTimer;
+    constructor(){
+        this.logger = createLogger(`simulator:test_executor_metrics`);
+    }
+    startRecordingTxSimulation(txLabel) {
+        assert(!this.currentTxLabel, 'Cannot start recording tx simulation when another is live');
+        assert(!this.txMetrics.has(txLabel), 'Cannot start recording metrics for tx with duplicate label');
+        this.txMetrics.set(txLabel, {
+            totalDurationMs: 0,
+            manaUsed: 0,
+            totalInstructions: 0,
+            txHashMs: undefined,
+            nonRevertiblePrivateInsertionsUs: undefined,
+            revertiblePrivateInsertionsUs: undefined,
+            enqueuedCalls: [],
+            revertedCode: undefined
+        });
+        this.currentTxLabel = txLabel;
+        this.txTimer = new Timer();
+    }
+    stopRecordingTxSimulation(txLabel, revertedCode) {
+        assert(this.currentTxLabel === txLabel, 'Cannot stop recording metrics for tx when another is live');
+        const txMetrics = this.txMetrics.get(txLabel);
+        // total duration of tx
+        txMetrics.totalDurationMs = this.txTimer.ms();
+        this.logger.debug(`Public TX simulation of ${txLabel} took ${txMetrics.totalDurationMs}ms`);
+        // add manaUsed across all enqueued calls
+        txMetrics.manaUsed = sum(txMetrics.enqueuedCalls.map((call)=>call.manaUsed));
+        // add totalInstructions across all enqueued calls
+        txMetrics.totalInstructions = sum(txMetrics.enqueuedCalls.map((call)=>call.totalInstructions));
+        txMetrics.revertedCode = revertedCode;
+        this.currentTxLabel = undefined;
+    }
+    recordEnqueuedCallSimulation(fnName, durationMs, manaUsed, totalInstructions) {
+        this.#recordEnqueuedCallSimulation(fnName, durationMs, manaUsed, totalInstructions, false);
+    }
+    recordEnqueuedCallSimulationFailure(fnName, durationMs, manaUsed, totalInstructions) {
+        this.#recordEnqueuedCallSimulation(fnName, durationMs, manaUsed, totalInstructions, true);
+    }
+    #recordEnqueuedCallSimulation(fnName, durationMs, manaUsed, totalInstructions, reverted) {
+        assert(this.currentTxLabel, 'Cannot record enqueued call simulation when no tx is live');
+        const txMetrics = this.txMetrics.get(this.currentTxLabel);
+        txMetrics.enqueuedCalls.push({
+            fnName,
+            durationMs,
+            manaUsed,
+            totalInstructions,
+            reverted
+        });
+    }
+    recordTxHashComputation(durationMs) {
+        assert(this.currentTxLabel, 'Cannot record tx hash computation time when no tx is live');
+        const txMetrics = this.txMetrics.get(this.currentTxLabel);
+        assert(txMetrics.txHashMs === undefined, 'Cannot RE-record tx hash computation time');
+        txMetrics.txHashMs = durationMs;
+    }
+    recordPrivateEffectsInsertion(durationUs, type) {
+        assert(this.currentTxLabel, 'Cannot record private effects insertion when no tx is live');
+        const txMetrics = this.txMetrics.get(this.currentTxLabel);
+        if (type === 'revertible') {
+            assert(txMetrics.revertiblePrivateInsertionsUs === undefined, 'Cannot RE-record revertible insertions of private effects');
+            txMetrics.revertiblePrivateInsertionsUs = durationUs;
+        } else {
+            assert(txMetrics.nonRevertiblePrivateInsertionsUs === undefined, 'Cannot RE-record non-revertible insertions of private effects');
+            txMetrics.nonRevertiblePrivateInsertionsUs = durationUs;
+        }
+    }
+    prettyPrint(filter = 0) {
+        this.logger.info(this.toPrettyString(filter));
+    }
+    toPrettyString(filter = 0) {
+        let pretty = '';
+        //pretty += H_LINE + '\n';
+        pretty += `${H1}Public TX Simulation Metrics (${PublicTxMetricsFilter[filter]})\n`;
+        for (const [txLabel, txMetrics] of this.txMetrics.entries()){
+            //pretty += H_LINE + '\n';
+            pretty += `${H2}TX Label: ${txLabel}\n`;
+            if (filter == 2 || filter === 1 || filter === 0) {
+                pretty += `${INDENT0}Total duration: ${fmtNum(txMetrics.totalDurationMs, 'ms')}\n`;
+            }
+            if (filter === 1 || filter === 0) {
+                pretty += `${INDENT0}Total mana used: ${fmtNum(txMetrics.manaUsed)}\n`;
+                const manaPerSecond = Math.round(txMetrics.manaUsed * 1000 / txMetrics.totalDurationMs);
+                pretty += `${INDENT0}Mana per second: ${fmtNum(manaPerSecond)}\n`;
+            }
+            if (filter === 3 || filter === 1 || filter === 0) {
+                pretty += `${INDENT0}Total instructions executed: ${fmtNum(txMetrics.totalInstructions)}\n`;
+            }
+            if (filter === 2 || filter === 0) {
+                pretty += `${INDENT0}Tx hash computation: ${fmtNum(txMetrics.txHashMs, 'ms')}\n`;
+                pretty += `${INDENT0}Private insertions:\n`;
+                pretty += `${INDENT1}Non-revertible: ${fmtNum(txMetrics.nonRevertiblePrivateInsertionsUs / 1_000, 'ms')}\n`;
+                pretty += `${INDENT1}Revertible: ${fmtNum(txMetrics.revertiblePrivateInsertionsUs / 1_000, 'ms')}\n`;
+            }
+            if (filter !== 1) {
+                // totals exclude enqueued calls
+                pretty += this.#enqueuedCallsToPrettyString(txMetrics, filter);
+            }
+            if (txMetrics.revertedCode !== undefined && !txMetrics.revertedCode.isOK()) {
+                pretty += `${INDENT0}Reverted code: ${txMetrics.revertedCode?.getDescription()}\n`;
+            }
+            pretty += H_LINE + '\n';
+        }
+        return pretty;
+    }
+    #enqueuedCallsToPrettyString(txMetrics, filter) {
+        let pretty = '';
+        pretty += `${INDENT0}Enqueued public calls:\n`;
+        for (const enqueuedCall of txMetrics.enqueuedCalls){
+            pretty += `${INDENT1}**Fn: ${enqueuedCall.fnName}**\n`;
+            if (filter === 2 || filter === 0) {
+                pretty += `${INDENT2}Duration: ${fmtNum(enqueuedCall.durationMs, 'ms')}\n`;
+            }
+            if (filter === 0) {
+                pretty += `${INDENT2}Mana used: ${fmtNum(enqueuedCall.manaUsed)}\n`;
+                const manaPerSecond = Math.round(enqueuedCall.manaUsed * 1000 / enqueuedCall.durationMs);
+                pretty += `${INDENT2}Mana per second: ${fmtNum(manaPerSecond)}\n`;
+            }
+            if (filter === 3 || filter === 0) {
+                pretty += `${INDENT2}Instructions executed: ${fmtNum(enqueuedCall.totalInstructions)}\n`;
+            }
+            if (enqueuedCall.reverted) {
+                pretty += `${INDENT2}Reverted!\n`;
+            }
+        }
+        return pretty;
+    }
+    toJSON(indent = 2) {
+        return JSON.stringify(Object.fromEntries(this.txMetrics.entries()), null, indent);
+    }
+}
+function fmtNum(num, unit) {
+    return `\`${num.toLocaleString()}${unit ? ` ${unit}` : ''}\``;
+}