@aztec/simulator 0.82.2 → 0.82.3-nightly.20250403

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}` : ''}\``;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.82.2",
+  "version": "0.82.3-nightly.20250403",
   "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-nightly.20250403",
+    "@aztec/foundation": "0.82.3-nightly.20250403",
+    "@aztec/noir-acvm_js": "0.82.3-nightly.20250403",
+    "@aztec/noir-noirc_abi": "0.82.3-nightly.20250403",
+    "@aztec/noir-protocol-circuits-types": "0.82.3-nightly.20250403",
+    "@aztec/noir-types": "0.82.3-nightly.20250403",
+    "@aztec/protocol-contracts": "0.82.3-nightly.20250403",
+    "@aztec/stdlib": "0.82.3-nightly.20250403",
+    "@aztec/telemetry-client": "0.82.3-nightly.20250403",
+    "@aztec/world-state": "0.82.3-nightly.20250403",
     "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-nightly.20250403",
+    "@aztec/merkle-tree": "0.82.3-nightly.20250403",
+    "@aztec/noir-contracts.js": "0.82.3-nightly.20250403",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/levelup": "^5.1.3",

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

@@ -1,8 +1,9 @@
 import { Fr, Point } from '@aztec/foundation/fields';
-import { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
+import { EventSelector, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { ContractClassLog, LogWithTxData } from '@aztec/stdlib/logs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { TxHash } from '@aztec/stdlib/tx';
 
 import type { ACVMField } from '../acvm_types.js';
 import { fromBoundedVec, fromUintArray, fromUintBoundedVec } from '../deserialize.js';
@@ -355,12 +356,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[]> {
@@ -371,8 +372,8 @@ export class Oracle {
     return [];
   }
 
-  async syncNotes(): Promise<ACVMField[]> {
-    await this.typedOracle.syncNotes();
+  async syncNotes([pendingTaggedLogArrayBaseSlot]: ACVMField[]): Promise<ACVMField[]> {
+    await this.typedOracle.syncNotes(Fr.fromString(pendingTaggedLogArrayBaseSlot));
     return [];
   }
 
@@ -490,4 +491,24 @@ export class Oracle {
     );
     return secret.toFields().map(toACVMField);
   }
+
+  async storePrivateEventLog(
+    [contractAddress]: ACVMField[],
+    [recipient]: ACVMField[],
+    [eventSelector]: ACVMField[],
+    logContentBVecStorage: ACVMField[],
+    [logContentLength]: ACVMField[],
+    [txHash]: ACVMField[],
+    [logIndexInTx]: ACVMField[],
+  ) {
+    await this.typedOracle.storePrivateEventLog(
+      AztecAddress.fromField(Fr.fromString(contractAddress)),
+      AztecAddress.fromField(Fr.fromString(recipient)),
+      EventSelector.fromField(Fr.fromString(eventSelector)),
+      fromBoundedVec(logContentBVecStorage, logContentLength),
+      new TxHash(Fr.fromString(txHash)),
+      Fr.fromString(logIndexInTx).toNumber(),
+    );
+    return [];
+  }
 }

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

@@ -1,13 +1,13 @@
 import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
 import { Fr, Point } from '@aztec/foundation/fields';
-import type { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
+import type { EventSelector, FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
 import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
 import type { ContractClassLog, IndexedTaggingSecret, LogWithTxData } from '@aztec/stdlib/logs';
 import type { Note, NoteStatus } from '@aztec/stdlib/note';
 import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
-import type { BlockHeader } from '@aztec/stdlib/tx';
+import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
 
 import type { MessageLoadOracleInputs } from '../../../common/message_load_oracle_inputs.js';
 
@@ -214,7 +214,7 @@ export abstract class TypedOracle {
     return Promise.reject(new OracleMethodNotAvailableError('incrementAppTaggingSecretIndexAsSender'));
   }
 
-  syncNotes(): Promise<void> {
+  syncNotes(_pendingTaggedLogArrayBaseSlot: Fr): Promise<void> {
     return Promise.reject(new OracleMethodNotAvailableError('syncNotes'));
   }
 
@@ -258,4 +258,15 @@ export abstract class TypedOracle {
   getSharedSecret(_address: AztecAddress, _ephPk: Point): Promise<Point> {
     return Promise.reject(new OracleMethodNotAvailableError('getSharedSecret'));
   }
+
+  storePrivateEventLog(
+    _contractAddress: AztecAddress,
+    _recipient: AztecAddress,
+    _eventSelector: EventSelector,
+    _logContent: Fr[],
+    _txHash: TxHash,
+    _logIndexInTx: number,
+  ): Promise<void> {
+    return Promise.reject(new OracleMethodNotAvailableError('storePrivateEventLog'));
+  }
 }

package/src/private/execution_data_provider.ts

@@ -1,13 +1,18 @@
 import type { Fr, Point } from '@aztec/foundation/fields';
-import type { FunctionArtifact, FunctionArtifactWithContractName, FunctionSelector } from '@aztec/stdlib/abi';
+import type {
+  EventSelector,
+  FunctionArtifact,
+  FunctionArtifactWithContractName,
+  FunctionSelector,
+} from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { L2Block } from '@aztec/stdlib/block';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
 import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
-import { IndexedTaggingSecret, LogWithTxData, TxScopedL2Log } from '@aztec/stdlib/logs';
+import { IndexedTaggingSecret, LogWithTxData } from '@aztec/stdlib/logs';
 import type { NoteStatus } from '@aztec/stdlib/note';
 import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
-import type { BlockHeader } from '@aztec/stdlib/tx';
+import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
 
 import type { CommitmentsDBInterface } from '../common/db_interfaces.js';
 import type { NoteData } from './acvm/index.js';
@@ -221,25 +226,18 @@ export interface ExecutionDataProvider extends CommitmentsDBInterface {
   ): Promise<void>;
 
   /**
-   * Synchronizes the logs tagged with the recipient's address and all the senders in the address book.
-   * Returns the unsynched logs and updates the indexes of the secrets used to tag them until there are no more logs to sync.
-   * @param contractAddress - The address of the contract that the logs are tagged for
-   * @param recipient - The address of the recipient
-   * @returns A list of encrypted logs tagged with the recipient's address
+   * Synchronizes the logs tagged with scoped addresses and all the senders in the address book. Stores the found logs
+   * in CapsuleArray ready for a later retrieval in Aztec.nr.
+   * @param contractAddress - The address of the contract that the logs are tagged for.
+   * @param pendingTaggedLogArrayBaseSlot - The base slot of the pending tagged log capsule array in which found logs will be stored.
+   * @param scopes - The scoped addresses to sync logs for. If not provided, all accounts in the address book will be
+   * synced.
    */
   syncTaggedLogs(
     contractAddress: AztecAddress,
-    maxBlockNumber: number,
+    pendingTaggedLogArrayBaseSlot: Fr,
     scopes?: AztecAddress[],
-  ): Promise<Map<string, TxScopedL2Log[]>>;
-
-  /**
-   * Processes the tagged logs returned by syncTaggedLogs by decrypting them and storing them in the database.
-   * @param contractAddress - The address of the contract that emitted the logs.
-   * @param logs - The logs to process.
-   * @param recipient - The recipient of the logs.
-   */
-  processTaggedLogs(contractAddress: AztecAddress, logs: TxScopedL2Log[], recipient: AztecAddress): Promise<void>;
+  ): Promise<void>;
 
   /**
    * Delivers the preimage and metadata of a committed note so that it can be later requested via the `getNotes`
@@ -325,4 +323,22 @@ export interface ExecutionDataProvider extends CommitmentsDBInterface {
    * @returns The secret for the given address.
    */
   getSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point>;
+
+  /**
+   * Stores an event log in the database.
+   * @param contractAddress - The address of the contract that emitted the log.
+   * @param recipient - The address of the recipient.
+   * @param eventSelector - The event selector of the event.
+   * @param logContent - The content of the private event log.
+   * @param txHash - The hash of the transaction that emitted the log.
+   * @param logIndexInTx - The index of the log within the transaction.
+   */
+  storePrivateEventLog(
+    contractAddress: AztecAddress,
+    recipient: AztecAddress,
+    eventSelector: EventSelector,
+    logContent: Fr[],
+    txHash: TxHash,
+    logIndexInTx: number,
+  ): Promise<void>;
 }

package/src/private/private_execution_oracle.ts

@@ -500,19 +500,8 @@ export class PrivateExecutionOracle extends UnconstrainedExecutionOracle {
     await this.executionDataProvider.incrementAppTaggingSecretIndexAsSender(this.contractAddress, sender, recipient);
   }
 
-  public override async syncNotes() {
-    const taggedLogsByRecipient = await this.executionDataProvider.syncTaggedLogs(
-      this.contractAddress,
-      this.historicalHeader.globalVariables.blockNumber.toNumber(),
-      this.scopes,
-    );
-    for (const [recipient, taggedLogs] of taggedLogsByRecipient.entries()) {
-      await this.executionDataProvider.processTaggedLogs(
-        this.contractAddress,
-        taggedLogs,
-        AztecAddress.fromString(recipient),
-      );
-    }
+  public override async syncNotes(pendingTaggedLogArrayBaseSlot: Fr) {
+    await this.executionDataProvider.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot, this.scopes);
 
     await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);
   }

package/src/private/unconstrained_execution_oracle.ts

@@ -1,6 +1,7 @@
 import { Aes128 } from '@aztec/foundation/crypto';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
+import type { EventSelector } from '@aztec/stdlib/abi';
 import type { AuthWitness } from '@aztec/stdlib/auth-witness';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
@@ -9,7 +10,7 @@ import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
 import { IndexedTaggingSecret, LogWithTxData } from '@aztec/stdlib/logs';
 import type { NoteStatus } from '@aztec/stdlib/note';
 import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
-import type { BlockHeader, Capsule } from '@aztec/stdlib/tx';
+import type { BlockHeader, Capsule, TxHash } from '@aztec/stdlib/tx';
 
 import { type NoteData, TypedOracle } from './acvm/index.js';
 import type { ExecutionDataProvider } from './execution_data_provider.js';
@@ -277,20 +278,8 @@ export class UnconstrainedExecutionOracle extends TypedOracle {
     return await this.executionDataProvider.getIndexedTaggingSecretAsSender(this.contractAddress, sender, recipient);
   }
 
-  public override async syncNotes() {
-    const taggedLogsByRecipient = await this.executionDataProvider.syncTaggedLogs(
-      this.contractAddress,
-      await this.executionDataProvider.getBlockNumber(),
-      this.scopes,
-    );
-
-    for (const [recipient, taggedLogs] of taggedLogsByRecipient.entries()) {
-      await this.executionDataProvider.processTaggedLogs(
-        this.contractAddress,
-        taggedLogs,
-        AztecAddress.fromString(recipient),
-      );
-    }
+  public override async syncNotes(pendingTaggedLogArrayBaseSlot: Fr) {
+    await this.executionDataProvider.syncTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot, this.scopes);
 
     await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);
   }
@@ -376,4 +365,22 @@ export class UnconstrainedExecutionOracle extends TypedOracle {
   public override getSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point> {
     return this.executionDataProvider.getSharedSecret(address, ephPk);
   }
+
+  public override storePrivateEventLog(
+    contractAddress: AztecAddress,
+    recipient: AztecAddress,
+    eventSelector: EventSelector,
+    logContent: Fr[],
+    txHash: TxHash,
+    logIndexInTx: number,
+  ): Promise<void> {
+    return this.executionDataProvider.storePrivateEventLog(
+      contractAddress,
+      recipient,
+      eventSelector,
+      logContent,
+      txHash,
+      logIndexInTx,
+    );
+  }
 }

package/src/public/avm/avm_context.ts

@@ -1,11 +1,11 @@
 import type { Fr } from '@aztec/foundation/fields';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
+import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import type { AvmExecutionEnvironment } from './avm_execution_environment.js';
 import { type Gas, gasToGasLeft } from './avm_gas.js';
 import { AvmMachineState } from './avm_machine_state.js';
 import type { AvmSimulator } from './avm_simulator.js';
-import type { AvmPersistableStateManager } from './journal/journal.js';
 
 /**
  * An execution context includes the information necessary to initiate AVM
@@ -20,7 +20,7 @@ export class AvmContext {
    * @returns new AvmContext instance
    */
   constructor(
-    public persistableState: AvmPersistableStateManager,
+    public persistableState: PublicPersistableStateManager,
     public environment: AvmExecutionEnvironment,
     public machineState: AvmMachineState,
   ) {}

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

@@ -7,6 +7,7 @@ import type { GlobalVariables } from '@aztec/stdlib/tx';
 import { strict as assert } from 'assert';
 
 import { SideEffectLimitReachedError } from '../side_effect_errors.js';
+import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import { AvmContext } from './avm_context.js';
 import { AvmContractCallResult } from './avm_contract_call_result.js';
 import { AvmExecutionEnvironment } from './avm_execution_environment.js';
@@ -19,7 +20,6 @@ import {
   revertReasonFromExceptionalHalt,
   revertReasonFromExplicitRevert,
 } from './errors.js';
-import type { AvmPersistableStateManager } from './journal/journal.js';
 import type { Instruction } from './opcodes/instruction.js';
 import {
   INSTRUCTION_SET,
@@ -75,7 +75,7 @@ export class AvmSimulator {
   }
 
   public static async create(
-    stateManager: AvmPersistableStateManager,
+    stateManager: PublicPersistableStateManager,
     address: AztecAddress,
     sender: AztecAddress,
     transactionFee: Fr,
@@ -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();