@aztec/simulator 0.82.2 → 0.82.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.82.2",
+  "version": "0.82.3",
   "type": "module",
   "exports": {
     "./server": "./dest/server.js",
@@ -60,16 +60,16 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.82.2",
-    "@aztec/foundation": "0.82.2",
-    "@aztec/noir-acvm_js": "0.82.2",
-    "@aztec/noir-noirc_abi": "0.82.2",
-    "@aztec/noir-protocol-circuits-types": "0.82.2",
-    "@aztec/noir-types": "0.82.2",
-    "@aztec/protocol-contracts": "0.82.2",
-    "@aztec/stdlib": "0.82.2",
-    "@aztec/telemetry-client": "0.82.2",
-    "@aztec/world-state": "0.82.2",
+    "@aztec/constants": "0.82.3",
+    "@aztec/foundation": "0.82.3",
+    "@aztec/noir-acvm_js": "0.82.3",
+    "@aztec/noir-noirc_abi": "0.82.3",
+    "@aztec/noir-protocol-circuits-types": "0.82.3",
+    "@aztec/noir-types": "0.82.3",
+    "@aztec/protocol-contracts": "0.82.3",
+    "@aztec/stdlib": "0.82.3",
+    "@aztec/telemetry-client": "0.82.3",
+    "@aztec/world-state": "0.82.3",
     "levelup": "^5.1.1",
     "lodash.clonedeep": "^4.5.0",
     "lodash.merge": "^4.6.2",
@@ -77,9 +77,9 @@
     "tslib": "^2.4.0"
   },
   "devDependencies": {
-    "@aztec/kv-store": "0.82.2",
-    "@aztec/merkle-tree": "0.82.2",
-    "@aztec/noir-contracts.js": "0.82.2",
+    "@aztec/kv-store": "0.82.3",
+    "@aztec/merkle-tree": "0.82.3",
+    "@aztec/noir-contracts.js": "0.82.3",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/levelup": "^5.1.3",

package/src/private/acvm/oracle/oracle.ts

@@ -355,12 +355,12 @@ export class Oracle {
     return Promise.resolve([]);
   }
 
-  async getIndexedTaggingSecretAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[][]> {
+  async getIndexedTaggingSecretAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]> {
     const taggingSecret = await this.typedOracle.getIndexedTaggingSecretAsSender(
       AztecAddress.fromString(sender),
       AztecAddress.fromString(recipient),
     );
-    return [taggingSecret.toFields().map(toACVMField)];
+    return taggingSecret.toFields().map(toACVMField);
   }
 
   async incrementAppTaggingSecretIndexAsSender([sender]: ACVMField[], [recipient]: ACVMField[]): Promise<ACVMField[]> {

package/src/public/avm/avm_contract_call_result.ts

@@ -17,10 +17,13 @@ export class AvmContractCallResult {
     public output: Fr[],
     public gasLeft: AvmGas,
     public revertReason?: AvmRevertReason,
+    public totalInstructions: number = 0, // including nested calls
   ) {}
 
   toString(): string {
-    let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(this.gasLeft)}`;
+    let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(
+      this.gasLeft,
+    )}, totalInstructions: ${this.totalInstructions}`;
     if (this.revertReason) {
       resultsStr += `, revertReason: ${this.revertReason}`;
     }
@@ -29,7 +32,13 @@ export class AvmContractCallResult {
 
   finalize(): AvmFinalizedCallResult {
     const revertReason = this.revertReason ? createSimulationError(this.revertReason, this.output) : undefined;
-    return new AvmFinalizedCallResult(this.reverted, this.output, Gas.from(this.gasLeft), revertReason);
+    return new AvmFinalizedCallResult(
+      this.reverted,
+      this.output,
+      Gas.from(this.gasLeft),
+      revertReason,
+      this.totalInstructions,
+    );
   }
 }
 
@@ -43,10 +52,13 @@ export class AvmFinalizedCallResult {
     public output: Fr[],
     public gasLeft: Gas,
     public revertReason?: SimulationError,
+    public totalInstructions: number = 0, // including nested calls
   ) {}
 
   toString(): string {
-    let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(this.gasLeft)}`;
+    let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(
+      this.gasLeft,
+    )}, totalInstructions: ${this.totalInstructions}`;
     if (this.revertReason) {
       resultsStr += `, revertReason: ${this.revertReason}`;
     }

package/src/public/avm/avm_machine_state.ts

@@ -68,6 +68,11 @@ export class AvmMachineState {
   /** Output data must NOT be modified once it is set */
   private output: Fr[] = [];
 
+  // Metrics only - not needed for execution
+  /** instruction counter, including nested calls */
+  public instrCounter: number = 0;
+  // End metrics only
+
   constructor(gasLeft: Gas);
   constructor(l2GasLeft: number, daGasLeft: number);
   constructor(gasLeftOrL2GasLeft: Gas | number, daGasLeft?: number) {

package/src/public/avm/avm_simulator.ts

@@ -147,7 +147,6 @@ export class AvmSimulator {
     try {
       // Execute instruction pointed to by the current program counter
       // continuing until the machine state signifies a halt
-      let instrCounter = 0;
       while (!machineState.getHalted()) {
         // Get the instruction from cache, or deserialize for the first time
         let cachedInstruction = this.deserializedInstructionsCache.get(machineState.pc);
@@ -163,13 +162,11 @@ export class AvmSimulator {
         if (this.log.isLevelEnabled('trace')) {
           // Skip this entirely to avoid toStringing etc if trace is not enabled
           this.log.trace(
-            `[PC:${machineState.pc}] [IC:${instrCounter}] ${instruction.toString()} (gasLeft l2=${
+            `[PC:${machineState.pc}] [IC:${machineState.instrCounter}] ${instruction.toString()} (gasLeft l2=${
               machineState.l2GasLeft
             } da=${machineState.daGasLeft})`,
           );
         }
-        instrCounter++;
-
         machineState.nextPc = machineState.pc + bytesRead;
 
         // Execute the instruction.
@@ -181,6 +178,8 @@ export class AvmSimulator {
           machineState.pc += bytesRead;
         }
 
+        machineState.instrCounter++;
+
         // gas used by this instruction - used for profiling/tallying
         const gasUsed: Gas = {
           l2Gas: instrStartGas.l2Gas - machineState.l2GasLeft,
@@ -197,13 +196,19 @@ export class AvmSimulator {
       const output = machineState.getOutput();
       const reverted = machineState.getReverted();
       const revertReason = reverted ? await revertReasonFromExplicitRevert(output, this.context) : undefined;
-      const results = new AvmContractCallResult(reverted, output, machineState.gasLeft, revertReason);
+      const results = new AvmContractCallResult(
+        reverted,
+        output,
+        machineState.gasLeft,
+        revertReason,
+        machineState.instrCounter,
+      );
       this.log.debug(`Context execution results: ${results.toString()}`);
       const totalGasUsed: Gas = {
         l2Gas: callStartGas.l2Gas - machineState.l2GasLeft,
         daGas: callStartGas.daGas - machineState.daGasLeft,
       };
-      this.log.debug(`Executed ${instrCounter} instructions and consumed ${totalGasUsed.l2Gas} L2 Gas`);
+      this.log.debug(`Executed ${machineState.instrCounter} instructions and consumed ${totalGasUsed.l2Gas} L2 Gas`);
 
       this.tallyPrintFunction();
 
@@ -233,7 +238,13 @@ export class AvmSimulator {
       // Exceptional halts consume all allocated gas
       const noGasLeft = { l2Gas: 0, daGas: 0 };
       // Note: "exceptional halts" cannot return data, hence [].
-      const results = new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], noGasLeft, revertReason);
+      const results = new AvmContractCallResult(
+        /*reverted=*/ true,
+        /*output=*/ [],
+        noGasLeft,
+        revertReason,
+        machineState.instrCounter,
+      );
       this.log.debug(`Context execution results: ${results.toString()}`);
 
       this.tallyPrintFunction();

package/src/public/avm/fixtures/avm_simulation_tester.ts

@@ -9,6 +9,7 @@ import { NativeWorldStateService } from '@aztec/world-state';
 import { SideEffectTrace } from '../../../public/side_effect_trace.js';
 import type { AvmContractCallResult } from '../../avm/avm_contract_call_result.js';
 import {
+  DEFAULT_BLOCK_NUMBER,
   getContractFunctionAbi,
   getFunctionSelector,
   initContext,
@@ -16,7 +17,6 @@ import {
   resolveContractAssertionMessage,
 } from '../../avm/fixtures/index.js';
 import { AvmPersistableStateManager } from '../../avm/journal/journal.js';
-import { DEFAULT_BLOCK_NUMBER } from '../../fixtures/public_tx_simulation_tester.js';
 import { PublicContractsDB, PublicTreesDB } from '../../public_db_sources.js';
 import { AvmSimulator } from '../avm_simulator.js';
 import { BaseAvmSimulationTester } from './base_avm_simulation_tester.js';

package/src/public/avm/fixtures/base_avm_simulation_tester.ts

@@ -6,7 +6,7 @@ import { computeFeePayerBalanceStorageSlot, getCanonicalFeeJuice } from '@aztec/
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { computePublicDataTreeLeafSlot, siloNullifier } from '@aztec/stdlib/hash';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
@@ -86,12 +86,6 @@ export abstract class BaseAvmSimulationTester {
     return feeJuice.instance;
   }
 
-  addContractClass(contractClass: ContractClassPublic, contractArtifact: ContractArtifact): Promise<void> {
-    this.logger.debug(`Adding contract class with Id ${contractClass.id}`);
-    this.contractDataSource.addContractArtifact(contractClass.id, contractArtifact);
-    return this.contractDataSource.addContractClass(contractClass);
-  }
-
   async addContractInstance(contractInstance: ContractInstanceWithAddress, skipNullifierInsertion = false) {
     if (!skipNullifierInsertion) {
       await this.insertContractAddressNullifier(contractInstance.address);

package/src/public/avm/fixtures/index.ts

@@ -28,7 +28,6 @@ import { mock } from 'jest-mock-extended';
 import merge from 'lodash.merge';
 
 import { resolveAssertionMessageFromRevertData, traverseCauseChain } from '../../../common/index.js';
-import { DEFAULT_BLOCK_NUMBER } from '../../fixtures/public_tx_simulation_tester.js';
 import type { PublicContractsDB, PublicTreesDB } from '../../public_db_sources.js';
 import type { PublicSideEffectTraceInterface } from '../../side_effect_trace_interface.js';
 import { AvmContext } from '../avm_context.js';
@@ -42,6 +41,7 @@ import { NullifierManager } from '../journal/nullifiers.js';
 import { PublicStorage } from '../journal/public_storage.js';
 
 export const PUBLIC_DISPATCH_FN_NAME = 'public_dispatch';
+export const DEFAULT_BLOCK_NUMBER = 42;
 
 /**
  * Create a new AVM context with default values.

package/src/public/avm/fixtures/simple_contract_data_source.ts

@@ -4,7 +4,7 @@ import type { ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
-import { PUBLIC_DISPATCH_FN_NAME } from './index.js';
+import { getFunctionSelector } from './index.js';
 
 /**
  * This class is used during public/avm testing to function as a database of
@@ -22,6 +22,8 @@ export class SimpleContractDataSource implements ContractDataSource {
   private contractInstances: Map<string, ContractInstanceWithAddress> = new Map();
   // maps contract instance address to address
   private contractArtifacts: Map<string, ContractArtifact> = new Map();
+  // maps `${classID}:${fnSelector}` to name
+  private debugFunctionName: Map<string, string> = new Map();
 
   /////////////////////////////////////////////////////////////
   // Helper functions not in the contract data source interface
@@ -34,13 +36,25 @@ export class SimpleContractDataSource implements ContractDataSource {
     contractClass: ContractClassPublic,
     contractInstance: ContractInstanceWithAddress,
   ) {
-    this.addContractArtifact(contractClass.id, contractArtifact);
+    await this.addContractArtifact(contractClass.id, contractArtifact);
     await this.addContractClass(contractClass);
     await this.addContractInstance(contractInstance);
   }
 
-  addContractArtifact(classId: Fr, artifact: ContractArtifact): void {
+  async addContractArtifact(classId: Fr, artifact: ContractArtifact) {
     this.contractArtifacts.set(classId.toString(), artifact);
+    const classIdStr = classId.toString();
+    const publicFns = artifact.nonDispatchPublicFunctions;
+    if (publicFns.length !== 0) {
+      for (const fn of publicFns) {
+        const actualFnName = `${fn.name}`;
+        const fnSelector = await getFunctionSelector(actualFnName, artifact);
+        const key = `${classIdStr}:${fnSelector.toString()}`;
+
+        const longFnName = `${artifact.name}.${actualFnName}`;
+        this.debugFunctionName.set(key, longFnName);
+      }
+    }
   }
 
   /////////////////////////////////////////////////////////////
@@ -73,11 +87,24 @@ export class SimpleContractDataSource implements ContractDataSource {
     }
     this.logger.debug(`Retrieved contract artifact for address: ${address}`);
     this.logger.debug(`Contract class ID: ${contractInstance.currentContractClassId}`);
-    return Promise.resolve(this.contractArtifacts.get(contractInstance!.currentContractClassId.toString()));
+    return this.contractArtifacts.get(contractInstance!.currentContractClassId.toString());
   }
 
-  getDebugFunctionName(_address: AztecAddress, _selector: FunctionSelector): Promise<string> {
-    return Promise.resolve(PUBLIC_DISPATCH_FN_NAME);
+  async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string> {
+    const contractInstance = await this.getContract(address);
+    if (!contractInstance) {
+      this.logger.warn(
+        `Couldn't get fn name for debugging. Contract not in tester's ContractDataSource. Using selector:${selector} instead...`,
+      );
+      return `selector:${selector.toString()}`;
+    }
+    const key = `${contractInstance.currentContractClassId.toString()}:${selector.toString()}`;
+    const fnName = this.debugFunctionName.get(key);
+    if (!fnName) {
+      this.logger.warn(`Couldn't get fn name for debugging. Using selector:${selector} instead...`);
+      return selector.toString();
+    }
+    return fnName;
   }
 
   registerContractFunctionSignatures(_address: AztecAddress, _signatures: string[]): Promise<void> {

package/src/public/avm/opcodes/external_calls.ts

@@ -70,6 +70,9 @@ abstract class ExternalCall extends Instruction {
     // Track the success status directly
     context.machineState.nestedCallSuccess = success;
 
+    // Account for all instructions executed in the nested call
+    context.machineState.instrCounter += nestedCallResults.totalInstructions;
+
     // If the nested call reverted, we try to save the reason and the revert data.
     // This will be used by the caller to try to reconstruct the call stack.
     // This is only a heuristic and may not always work. It is intended to work

package/src/public/avm/opcodes/memory.ts

@@ -13,42 +13,42 @@ export class Set extends Instruction {
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
     OperandType.UINT8, // dstOffset
-    OperandType.UINT8, // tag
+    OperandType.TAG, // tag
     OperandType.UINT8, // const (value)
   ];
   public static readonly wireFormat16: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
     OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // tag
+    OperandType.TAG, // tag
     OperandType.UINT16, // const (value)
   ];
   public static readonly wireFormat32: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
     OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // tag
+    OperandType.TAG, // tag
     OperandType.UINT32, // const (value)
   ];
   public static readonly wireFormat64: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
     OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // tag
+    OperandType.TAG, // tag
     OperandType.UINT64, // const (value)
   ];
   public static readonly wireFormat128: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
     OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // tag
+    OperandType.TAG, // tag
     OperandType.UINT128, // const (value)
   ];
   public static readonly wireFormatFF: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
     OperandType.UINT16, // dstOffset
-    OperandType.UINT8, // tag
+    OperandType.TAG, // tag
     OperandType.FF, // const (value)
   ];
 
@@ -59,7 +59,6 @@ export class Set extends Instruction {
     private value: bigint | number,
   ) {
     super();
-    TaggedMemory.checkIsValidTag(inTag);
   }
 
   public async execute(context: AvmContext): Promise<void> {
@@ -85,19 +84,18 @@ export class Cast extends Instruction {
     OperandType.UINT8,
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT8,
+    OperandType.TAG,
   ];
   static readonly wireFormat16 = [
     OperandType.UINT8,
     OperandType.UINT8,
     OperandType.UINT16,
     OperandType.UINT16,
-    OperandType.UINT8,
+    OperandType.TAG,
   ];
 
   constructor(private indirect: number, private srcOffset: number, private dstOffset: number, private dstTag: number) {
     super();
-    TaggedMemory.checkIsValidTag(dstTag);
   }
 
   public async execute(context: AvmContext): Promise<void> {

package/src/public/avm/serialization/instruction_serialization.ts

@@ -1,5 +1,6 @@
 import { strict as assert } from 'assert';
 
+import { TaggedMemory } from '../avm_memory_types.js';
 import { BufferCursor } from './buffer_cursor.js';
 
 /**
@@ -103,8 +104,12 @@ export enum OperandType {
   UINT64,
   UINT128,
   FF,
+  TAG,
 }
 
+// Define a type that represents the possible types of the deserialized values.
+type DeserializedValue = number | bigint;
+
 type OperandNativeType = number | bigint;
 type OperandWriter = (value: any) => void;
 
@@ -116,6 +121,7 @@ const OPERAND_SPEC = new Map<OperandType, [number, (offset: number) => OperandNa
   [OperandType.UINT64, [8, Buffer.prototype.readBigInt64BE, Buffer.prototype.writeBigInt64BE]],
   [OperandType.UINT128, [16, readBigInt128BE, writeBigInt128BE]],
   [OperandType.FF, [32, readBigInt254BE, writeBigInt254BE]],
+  [OperandType.TAG, [1, Buffer.prototype.readUint8, Buffer.prototype.writeUint8]],
 ]);
 
 function readBigInt254BE(this: Buffer, offset: number): bigint {
@@ -160,19 +166,30 @@ function writeBigInt128BE(this: Buffer, value: bigint): void {
  * @param operands Specification of the operand types.
  * @returns An array as big as {@code operands}, with the converted TS values.
  */
-export function deserialize(cursor: BufferCursor | Buffer, operands: OperandType[]): (number | bigint)[] {
-  const argValues = [];
+export function deserialize(cursor: BufferCursor | Buffer, operands: OperandType[]): DeserializedValue[] {
+  const argValues: DeserializedValue[] = [];
   if (Buffer.isBuffer(cursor)) {
     cursor = new BufferCursor(cursor);
   }
 
-  for (const op of operands) {
-    const opType = op;
+  for (const opType of operands) {
     const [sizeBytes, reader, _writer] = OPERAND_SPEC.get(opType)!;
-    argValues.push(reader.call(cursor.buffer(), cursor.position()));
+    const value = reader.call(cursor.buffer(), cursor.position());
+    argValues.push(value);
     cursor.advance(sizeBytes);
   }
 
+  // We first want to detect other parsing errors (e.g., instruction size
+  // is longer than remaining bytes) first and therefore tag validation is done after completion
+  // of parsing above. Order of errors need to match with circuit.
+  for (let i = 0; i < operands.length; i++) {
+    if (operands[i] === OperandType.TAG) {
+      // We parsed a single byte (readUInt8()) and therefore value is of number type (not bigint)
+      // We need to cast to number because checkIsValidTag expects a number.
+      TaggedMemory.checkIsValidTag(Number(argValues[i]) ?? 0);
+    }
+  }
+
   return argValues;
 }
 

package/src/public/executor_metrics.ts

@@ -1,3 +1,4 @@
+import type { RevertCode } from '@aztec/stdlib/avm';
 import {
   Attributes,
   type Histogram,
@@ -8,11 +9,16 @@ import {
   ValueType,
 } from '@aztec/telemetry-client';
 
-export class ExecutorMetrics {
+import type { ExecutorMetricsInterface } from './executor_metrics_interface.js';
+
+export class ExecutorMetrics implements ExecutorMetricsInterface {
   public readonly tracer: Tracer;
   private fnCount: UpDownCounter;
   private fnDuration: Histogram;
   private manaPerSecond: Histogram;
+  private manaUsed: Histogram;
+  private totalInstructions: Histogram;
+  private txHashing: Histogram;
   private privateEffectsInsertions: Histogram;
 
   constructor(client: TelemetryClient, name = 'PublicExecutor') {
@@ -35,20 +41,53 @@ export class ExecutorMetrics {
       valueType: ValueType.INT,
     });
 
-    this.privateEffectsInsertions = meter.createHistogram(Metrics.PUBLIC_EXECUTION_PRIVATE_EFFECTS_INSERTION, {
+    this.manaUsed = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_MANA_USED, {
+      description: 'Total mana used',
+      unit: 'mana',
+      valueType: ValueType.INT,
+    });
+
+    this.totalInstructions = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_TOTAL_INSTRUCTIONS, {
+      description: 'Total number of instructions executed',
+      unit: 'instructions',
+      valueType: ValueType.INT,
+    });
+
+    this.txHashing = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_TX_HASHING, {
+      description: 'Tx hashing time',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
+
+    this.privateEffectsInsertions = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_PRIVATE_EFFECTS_INSERTION, {
       description: 'Private effects insertion time',
       unit: 'us',
       valueType: ValueType.INT,
     });
   }
 
-  recordFunctionSimulation(durationMs: number, manaUsed: number, fnName: string) {
+  startRecordingTxSimulation(_txLabel: string) {
+    // do nothing (unimplemented)
+  }
+
+  stopRecordingTxSimulation(_txLabel: string, _revertedCode?: RevertCode) {
+    // do nothing (unimplemented)
+  }
+
+  recordEnqueuedCallSimulation(fnName: string, durationMs: number, manaUsed: number, totalInstructions: number) {
     this.fnCount.add(1, {
       [Attributes.OK]: true,
       [Attributes.APP_CIRCUIT_NAME]: fnName,
-      [Attributes.MANA_USED]: manaUsed,
     });
-    this.fnDuration.record(Math.ceil(durationMs));
+    this.manaUsed.record(Math.ceil(manaUsed), {
+      [Attributes.APP_CIRCUIT_NAME]: fnName,
+    });
+    this.totalInstructions.record(Math.ceil(totalInstructions), {
+      [Attributes.APP_CIRCUIT_NAME]: fnName,
+    });
+    this.fnDuration.record(Math.ceil(durationMs), {
+      [Attributes.APP_CIRCUIT_NAME]: fnName,
+    });
     if (durationMs > 0 && manaUsed > 0) {
       const manaPerSecond = Math.round((manaUsed * 1000) / durationMs);
       this.manaPerSecond.record(manaPerSecond, {
@@ -57,12 +96,21 @@ export class ExecutorMetrics {
     }
   }
 
-  recordFunctionSimulationFailure() {
+  recordEnqueuedCallSimulationFailure(
+    _fnName: string,
+    _durationMs: number,
+    _manaUsed: number,
+    _totalInstructions: number,
+  ) {
     this.fnCount.add(1, {
       [Attributes.OK]: false,
     });
   }
 
+  recordTxHashComputation(durationMs: number) {
+    this.txHashing.record(Math.ceil(durationMs));
+  }
+
   recordPrivateEffectsInsertion(durationUs: number, type: 'revertible' | 'non-revertible') {
     this.privateEffectsInsertions.record(Math.ceil(durationUs), {
       [Attributes.REVERTIBILITY]: type,

package/src/public/executor_metrics_interface.ts

@@ -0,0 +1,15 @@
+import type { RevertCode } from '@aztec/stdlib/avm';
+
+export interface ExecutorMetricsInterface {
+  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;
+}