@aztec/simulator 0.64.0 → 0.65.1

package/src/public/enqueued_call_side_effect_trace.ts

@@ -8,7 +8,6 @@ import {
   AvmEnqueuedCallHint,
   AvmExecutionHints,
   AvmExternalCallHint,
-  AvmKeyValueHint,
   AvmNullifierReadTreeHint,
   AvmNullifierWriteTreeHint,
   AvmPublicDataReadTreeHint,
@@ -23,14 +22,9 @@ import {
   L2ToL1Message,
   LogHash,
   MAX_ENQUEUED_CALLS_PER_TX,
-  MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_TX,
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
-  MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
   MAX_NULLIFIERS_PER_TX,
-  MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
-  MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-  MAX_PUBLIC_DATA_READS_PER_TX,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MAX_UNENCRYPTED_LOGS_PER_TX,
   NOTE_HASH_TREE_HEIGHT,
@@ -42,22 +36,19 @@ import {
   PrivateToAvmAccumulatedData,
   PrivateToAvmAccumulatedDataArrayLengths,
   PublicCallRequest,
-  PublicDataRead,
   PublicDataTreeLeafPreimage,
   PublicDataUpdateRequest,
   PublicDataWrite,
-  ReadRequest,
   ScopedL2ToL1Message,
   ScopedLogHash,
   type ScopedNoteHash,
-  type ScopedReadRequest,
   SerializableContractInstance,
-  TreeLeafReadRequest,
   type TreeSnapshots,
 } from '@aztec/circuits.js';
-import { computePublicDataTreeLeafSlot, siloNullifier } from '@aztec/circuits.js/hash';
+import { computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import { assert } from 'console';
@@ -81,17 +72,9 @@ const emptyL1ToL2MessagePath = () => new Array(L1_TO_L2_MSG_TREE_HEIGHT).fill(Fr
 export type SideEffects = {
   enqueuedCalls: PublicCallRequest[];
 
-  publicDataReads: PublicDataRead[];
   publicDataWrites: PublicDataUpdateRequest[];
-
-  noteHashReadRequests: TreeLeafReadRequest[];
   noteHashes: ScopedNoteHash[];
-
-  nullifierReadRequests: ScopedReadRequest[];
-  nullifierNonExistentReadRequests: ScopedReadRequest[];
   nullifiers: Nullifier[];
-
-  l1ToL2MsgReadRequests: TreeLeafReadRequest[];
   l2ToL1Msgs: ScopedL2ToL1Message[];
 
   unencryptedLogs: UnencryptedL2Log[];
@@ -100,24 +83,15 @@ export type SideEffects = {
 
 export class SideEffectArrayLengths {
   constructor(
-    public readonly publicDataReads: number,
     public readonly publicDataWrites: number,
-
-    public readonly noteHashReadRequests: number,
     public readonly noteHashes: number,
-
-    public readonly nullifierReadRequests: number,
-    public readonly nullifierNonExistentReadRequests: number,
     public readonly nullifiers: number,
-
-    public readonly l1ToL2MsgReadRequests: number,
     public readonly l2ToL1Msgs: number,
-
     public readonly unencryptedLogs: number,
   ) {}
 
   static empty() {
-    return new this(0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    return new this(0, 0, 0, 0, 0);
   }
 }
 
@@ -132,19 +106,10 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
 
   private enqueuedCalls: PublicCallRequest[] = [];
 
-  private publicDataReads: PublicDataRead[] = [];
   private publicDataWrites: PublicDataUpdateRequest[] = [];
-
-  private noteHashReadRequests: TreeLeafReadRequest[] = [];
   private noteHashes: ScopedNoteHash[] = [];
-
-  private nullifierReadRequests: ScopedReadRequest[] = [];
-  private nullifierNonExistentReadRequests: ScopedReadRequest[] = [];
   private nullifiers: Nullifier[] = [];
-
-  private l1ToL2MsgReadRequests: TreeLeafReadRequest[] = [];
   private l2ToL1Messages: ScopedL2ToL1Message[] = [];
-
   private unencryptedLogs: UnencryptedL2Log[] = [];
   private unencryptedLogsHashes: ScopedLogHash[] = [];
 
@@ -170,15 +135,9 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     return new PublicEnqueuedCallSideEffectTrace(
       this.sideEffectCounter,
       new SideEffectArrayLengths(
-        this.previousSideEffectArrayLengths.publicDataReads + this.publicDataReads.length,
         this.previousSideEffectArrayLengths.publicDataWrites + this.publicDataWrites.length,
-        this.previousSideEffectArrayLengths.noteHashReadRequests + this.noteHashReadRequests.length,
         this.previousSideEffectArrayLengths.noteHashes + this.noteHashes.length,
-        this.previousSideEffectArrayLengths.nullifierReadRequests + this.nullifierReadRequests.length,
-        this.previousSideEffectArrayLengths.nullifierNonExistentReadRequests +
-          this.nullifierNonExistentReadRequests.length,
         this.previousSideEffectArrayLengths.nullifiers + this.nullifiers.length,
-        this.previousSideEffectArrayLengths.l1ToL2MsgReadRequests + this.l1ToL2MsgReadRequests.length,
         this.previousSideEffectArrayLengths.l2ToL1Msgs + this.l2ToL1Messages.length,
         this.previousSideEffectArrayLengths.unencryptedLogs + this.unencryptedLogs.length,
       ),
@@ -193,23 +152,42 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     );
     forkedTrace.alreadyMergedIntoParent = true;
 
-    // TODO(dbanks12): accept & merge forked trace's hints!
     this.sideEffectCounter = forkedTrace.sideEffectCounter;
     this.enqueuedCalls.push(...forkedTrace.enqueuedCalls);
 
     if (!reverted) {
-      this.publicDataReads.push(...forkedTrace.publicDataReads);
       this.publicDataWrites.push(...forkedTrace.publicDataWrites);
-      this.noteHashReadRequests.push(...forkedTrace.noteHashReadRequests);
       this.noteHashes.push(...forkedTrace.noteHashes);
-      this.nullifierReadRequests.push(...forkedTrace.nullifierReadRequests);
-      this.nullifierNonExistentReadRequests.push(...forkedTrace.nullifierNonExistentReadRequests);
       this.nullifiers.push(...forkedTrace.nullifiers);
-      this.l1ToL2MsgReadRequests.push(...forkedTrace.l1ToL2MsgReadRequests);
       this.l2ToL1Messages.push(...forkedTrace.l2ToL1Messages);
       this.unencryptedLogs.push(...forkedTrace.unencryptedLogs);
       this.unencryptedLogsHashes.push(...forkedTrace.unencryptedLogsHashes);
     }
+    this.mergeHints(forkedTrace);
+  }
+
+  private mergeHints(forkedTrace: this) {
+    this.avmCircuitHints.enqueuedCalls.items.push(...forkedTrace.avmCircuitHints.enqueuedCalls.items);
+
+    this.avmCircuitHints.storageValues.items.push(...forkedTrace.avmCircuitHints.storageValues.items);
+    this.avmCircuitHints.noteHashExists.items.push(...forkedTrace.avmCircuitHints.noteHashExists.items);
+    this.avmCircuitHints.nullifierExists.items.push(...forkedTrace.avmCircuitHints.nullifierExists.items);
+    this.avmCircuitHints.l1ToL2MessageExists.items.push(...forkedTrace.avmCircuitHints.l1ToL2MessageExists.items);
+
+    this.avmCircuitHints.externalCalls.items.push(...forkedTrace.avmCircuitHints.externalCalls.items);
+
+    this.avmCircuitHints.contractInstances.items.push(...forkedTrace.avmCircuitHints.contractInstances.items);
+    this.avmCircuitHints.contractBytecodeHints.items.push(...forkedTrace.avmCircuitHints.contractBytecodeHints.items);
+
+    this.avmCircuitHints.storageReadRequest.items.push(...forkedTrace.avmCircuitHints.storageReadRequest.items);
+    this.avmCircuitHints.storageUpdateRequest.items.push(...forkedTrace.avmCircuitHints.storageUpdateRequest.items);
+    this.avmCircuitHints.nullifierReadRequest.items.push(...forkedTrace.avmCircuitHints.nullifierReadRequest.items);
+    this.avmCircuitHints.nullifierWriteHints.items.push(...forkedTrace.avmCircuitHints.nullifierWriteHints.items);
+    this.avmCircuitHints.noteHashReadRequest.items.push(...forkedTrace.avmCircuitHints.noteHashReadRequest.items);
+    this.avmCircuitHints.noteHashWriteRequest.items.push(...forkedTrace.avmCircuitHints.noteHashWriteRequest.items);
+    this.avmCircuitHints.l1ToL2MessageReadRequest.items.push(
+      ...forkedTrace.avmCircuitHints.l1ToL2MessageReadRequest.items,
+    );
   }
 
   public getCounter() {
@@ -221,7 +199,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
   }
 
   public tracePublicStorageRead(
-    contractAddress: AztecAddress,
+    _contractAddress: AztecAddress,
     slot: Fr,
     value: Fr,
     leafPreimage: PublicDataTreeLeafPreimage = PublicDataTreeLeafPreimage.empty(),
@@ -232,21 +210,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
       // if we have real merkle hint content, make sure the value matches the the provided preimage
       assert(leafPreimage.value.equals(value), 'Value mismatch when tracing in public data write');
     }
-    // NOTE: exists and cached are unused for now but may be used for optimizations or kernel hints later
-    if (
-      this.publicDataReads.length + this.previousSideEffectArrayLengths.publicDataReads >=
-      MAX_PUBLIC_DATA_READS_PER_TX
-    ) {
-      throw new SideEffectLimitReachedError('public data (contract storage) read', MAX_PUBLIC_DATA_READS_PER_TX);
-    }
 
-    const leafSlot = computePublicDataTreeLeafSlot(contractAddress, slot);
-
-    this.publicDataReads.push(new PublicDataRead(leafSlot, value, this.sideEffectCounter));
-
-    this.avmCircuitHints.storageValues.items.push(
-      new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ value),
-    );
     this.avmCircuitHints.storageReadRequest.items.push(new AvmPublicDataReadTreeHint(leafPreimage, leafIndex, path));
     this.log.debug(`SLOAD cnt: ${this.sideEffectCounter} val: ${value} slot: ${slot}`);
     this.incrementSideEffectCounter();
@@ -296,22 +260,9 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     _contractAddress: AztecAddress,
     noteHash: Fr,
     leafIndex: Fr,
-    exists: boolean,
+    _exists: boolean,
     path: Fr[] = emptyNoteHashPath(),
   ) {
-    // NOTE: contractAddress is unused because noteHash is an already-siloed leaf
-    if (
-      this.noteHashReadRequests.length + this.previousSideEffectArrayLengths.noteHashReadRequests >=
-      MAX_NOTE_HASH_READ_REQUESTS_PER_TX
-    ) {
-      throw new SideEffectLimitReachedError('note hash read request', MAX_NOTE_HASH_READ_REQUESTS_PER_TX);
-    }
-
-    // note hash is already siloed here
-    this.noteHashReadRequests.push(new TreeLeafReadRequest(noteHash, leafIndex));
-    this.avmCircuitHints.noteHashExists.items.push(
-      new AvmKeyValueHint(/*key=*/ new Fr(leafIndex), /*value=*/ exists ? Fr.ONE : Fr.ZERO),
-    );
     // New Hinting
     this.avmCircuitHints.noteHashReadRequest.items.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
     // NOTE: counter does not increment for note hash checks (because it doesn't rely on pending note hashes)
@@ -336,29 +287,12 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
   }
 
   public traceNullifierCheck(
-    contractAddress: AztecAddress,
-    nullifier: Fr,
-    exists: boolean,
+    _siloedNullifier: Fr,
+    _exists: boolean,
     lowLeafPreimage: NullifierLeafPreimage = NullifierLeafPreimage.empty(),
     lowLeafIndex: Fr = Fr.zero(),
     lowLeafPath: Fr[] = emptyNullifierPath(),
   ) {
-    // NOTE: isPending and leafIndex are unused for now but may be used for optimizations or kernel hints later
-    this.enforceLimitOnNullifierChecks();
-
-    // TODO(dbanks12): use siloed nullifier instead of scoped once public kernel stops siloing
-    // and once VM public inputs are meant to contain siloed nullifiers.
-    //const siloedNullifier = siloNullifier(contractAddress, nullifier);
-    const readRequest = new ReadRequest(nullifier, this.sideEffectCounter).scope(contractAddress);
-    if (exists) {
-      this.nullifierReadRequests.push(readRequest);
-    } else {
-      this.nullifierNonExistentReadRequests.push(readRequest);
-    }
-    this.avmCircuitHints.nullifierExists.items.push(
-      new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ new Fr(exists ? 1 : 0)),
-    );
-    // New Hints
     this.avmCircuitHints.nullifierReadRequest.items.push(
       new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath),
     );
@@ -367,8 +301,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
   }
 
   public traceNewNullifier(
-    contractAddress: AztecAddress,
-    nullifier: Fr,
+    siloedNullifier: Fr,
     lowLeafPreimage: NullifierLeafPreimage = NullifierLeafPreimage.empty(),
     lowLeafIndex: Fr = Fr.zero(),
     lowLeafPath: Fr[] = emptyNullifierPath(),
@@ -378,10 +311,8 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
       throw new SideEffectLimitReachedError('nullifier', MAX_NULLIFIERS_PER_TX);
     }
 
-    const siloedNullifier = siloNullifier(contractAddress, nullifier);
     this.nullifiers.push(new Nullifier(siloedNullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
 
-    // New hinting
     const lowLeafReadHint = new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
     this.avmCircuitHints.nullifierWriteHints.items.push(new AvmNullifierWriteTreeHint(lowLeafReadHint, insertionPath));
     this.log.debug(`NEW_NULLIFIER cnt: ${this.sideEffectCounter}`);
@@ -393,22 +324,9 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     _contractAddress: AztecAddress,
     msgHash: Fr,
     msgLeafIndex: Fr,
-    exists: boolean,
+    _exists: boolean,
     path: Fr[] = emptyL1ToL2MessagePath(),
   ) {
-    // NOTE: contractAddress is unused because msgHash is an already-siloed leaf
-    if (
-      this.l1ToL2MsgReadRequests.length + this.previousSideEffectArrayLengths.l1ToL2MsgReadRequests >=
-      MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_TX
-    ) {
-      throw new SideEffectLimitReachedError('l1 to l2 message read request', MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_TX);
-    }
-
-    this.l1ToL2MsgReadRequests.push(new TreeLeafReadRequest(msgHash, msgLeafIndex));
-    this.avmCircuitHints.l1ToL2MessageExists.items.push(
-      new AvmKeyValueHint(/*key=*/ new Fr(msgLeafIndex), /*value=*/ exists ? Fr.ONE : Fr.ZERO),
-    );
-    // New Hinting
     this.avmCircuitHints.l1ToL2MessageReadRequest.items.push(new AvmAppendTreeHint(msgLeafIndex, msgHash, path));
   }
 
@@ -450,8 +368,6 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     exists: boolean,
     instance: SerializableContractInstance = SerializableContractInstance.default(),
   ) {
-    this.enforceLimitOnNullifierChecks('(contract address nullifier from GETCONTRACTINSTANCE)');
-
     this.avmCircuitHints.contractInstances.items.push(
       new AvmContractInstanceHint(
         contractAddress,
@@ -495,9 +411,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
       new AvmContractBytecodeHints(bytecode, instance, contractClass),
     );
     this.log.debug(
-      `Bytecode retrieval for contract execution traced: exists=${exists}, instance=${JSON.stringify(
-        contractInstance,
-      )}`,
+      `Bytecode retrieval for contract execution traced: exists=${exists}, instance=${jsonStringify(contractInstance)}`,
     );
   }
 
@@ -561,14 +475,9 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
   public getSideEffects(): SideEffects {
     return {
       enqueuedCalls: this.enqueuedCalls,
-      publicDataReads: this.publicDataReads,
       publicDataWrites: this.publicDataWrites,
-      noteHashReadRequests: this.noteHashReadRequests,
       noteHashes: this.noteHashes,
-      nullifierReadRequests: this.nullifierReadRequests,
-      nullifierNonExistentReadRequests: this.nullifierNonExistentReadRequests,
       nullifiers: this.nullifiers,
-      l1ToL2MsgReadRequests: this.l1ToL2MsgReadRequests,
       l2ToL1Msgs: this.l2ToL1Messages,
       unencryptedLogs: this.unencryptedLogs,
       unencryptedLogsHashes: this.unencryptedLogsHashes,
@@ -690,32 +599,4 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
       ),
     );
   }
-
-  private enforceLimitOnNullifierChecks(errorMsgOrigin: string = '') {
-    // NOTE: Why error if _either_ limit was reached? If user code emits either an existent or non-existent
-    // nullifier read request (NULLIFIEREXISTS, GETCONTRACTINSTANCE, *CALL), and one of the limits has been
-    // reached (MAX_NULLIFIER_NON_EXISTENT_RRS vs MAX_NULLIFIER_RRS), but not the other, we must prevent the
-    // sequencer from lying and saying "this nullifier exists, but MAX_NULLIFIER_RRS has been reached, so I'm
-    // going to skip the read request and just revert instead" when the nullifier actually doesn't exist
-    // (or vice versa). So, if either maximum has been reached, any nullifier-reading operation must error.
-    if (
-      this.nullifierReadRequests.length + this.previousSideEffectArrayLengths.nullifierReadRequests >=
-      MAX_NULLIFIER_READ_REQUESTS_PER_TX
-    ) {
-      throw new SideEffectLimitReachedError(
-        `nullifier read request ${errorMsgOrigin}`,
-        MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-      );
-    }
-    if (
-      this.nullifierNonExistentReadRequests.length +
-        this.previousSideEffectArrayLengths.nullifierNonExistentReadRequests >=
-      MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX
-    ) {
-      throw new SideEffectLimitReachedError(
-        `nullifier non-existent read request ${errorMsgOrigin}`,
-        MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
-      );
-    }
-  }
 }

package/src/public/executor_metrics.ts

@@ -3,15 +3,20 @@ import {
   type Histogram,
   Metrics,
   type TelemetryClient,
+  type Tracer,
   type UpDownCounter,
   ValueType,
+  linearBuckets,
 } from '@aztec/telemetry-client';
 
 export class ExecutorMetrics {
+  public readonly tracer: Tracer;
   private fnCount: UpDownCounter;
   private fnDuration: Histogram;
+  private manaPerSecond: Histogram;
 
   constructor(client: TelemetryClient, name = 'PublicExecutor') {
+    this.tracer = client.getTracer(name);
     const meter = client.getMeter(name);
 
     this.fnCount = meter.createUpDownCounter(Metrics.PUBLIC_EXECUTOR_SIMULATION_COUNT, {
@@ -23,13 +28,30 @@ export class ExecutorMetrics {
       unit: 'ms',
       valueType: ValueType.INT,
     });
+
+    this.manaPerSecond = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_MANA_PER_SECOND, {
+      description: 'Mana used per second',
+      unit: 'mana/s',
+      valueType: ValueType.INT,
+      advice: {
+        explicitBucketBoundaries: linearBuckets(0, 10_000_000, 10),
+      },
+    });
   }
 
-  recordFunctionSimulation(durationMs: number) {
+  recordFunctionSimulation(durationMs: number, manaUsed: number, fnName: string) {
     this.fnCount.add(1, {
       [Attributes.OK]: true,
+      [Attributes.APP_CIRCUIT_NAME]: fnName,
+      [Attributes.MANA_USED]: manaUsed,
     });
     this.fnDuration.record(Math.ceil(durationMs));
+    if (durationMs > 0 && manaUsed > 0) {
+      const manaPerSecond = Math.round((manaUsed * 1000) / durationMs);
+      this.manaPerSecond.record(manaPerSecond, {
+        [Attributes.APP_CIRCUIT_NAME]: fnName,
+      });
+    }
   }
 
   recordFunctionSimulationFailure() {

package/src/public/fixtures/index.ts

@@ -2,7 +2,10 @@ import { PublicExecutionRequest, Tx } from '@aztec/circuit-types';
 import {
   type AvmCircuitInputs,
   CallContext,
+  type ContractClassPublic,
+  type ContractInstanceWithAddress,
   DEFAULT_GAS_LIMIT,
+  type FunctionSelector,
   Gas,
   GasFees,
   GasSettings,
@@ -17,21 +20,19 @@ import {
   SerializableContractInstance,
   TxConstantData,
   TxContext,
+  computePublicBytecodeCommitment,
 } from '@aztec/circuits.js';
 import { makeContractClassPublic, makeContractInstanceFromClassId } from '@aztec/circuits.js/testing';
+import { type ContractArtifact } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { openTmpStore } from '@aztec/kv-store/utils';
-import { PublicTxSimulator, type WorldStateDB } from '@aztec/simulator';
+import { PublicTxSimulator, WorldStateDB } from '@aztec/simulator';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { MerkleTrees } from '@aztec/world-state';
 
-import { mock } from 'jest-mock-extended';
-
 import { getAvmTestContractBytecode, getAvmTestContractFunctionSelector } from '../../avm/fixtures/index.js';
 
-const TIMESTAMP = new Fr(99833);
-
 /**
  * If assertionErrString is set, we expect a (non exceptional halting) revert due to a failing assertion and
  * we check that the revert reason error contains this string. However, the circuit must correctly prove the
@@ -47,56 +48,31 @@ export async function simulateAvmTestContractGenerateCircuitInputs(
   calldata = [functionSelector.toField(), ...calldata];
 
   const globalVariables = GlobalVariables.empty();
-  globalVariables.gasFees = GasFees.default();
-  globalVariables.timestamp = TIMESTAMP;
+  globalVariables.gasFees = GasFees.empty();
+  globalVariables.timestamp = new Fr(99833);
 
-  const worldStateDB = mock<WorldStateDB>();
   const telemetry = new NoopTelemetryClient();
   const merkleTrees = await (await MerkleTrees.new(openTmpStore(), telemetry)).fork();
-  worldStateDB.getMerkleInterface.mockReturnValue(merkleTrees);
-
-  // Top level contract call
-  const bytecode = getAvmTestContractBytecode('public_dispatch');
-  const dispatchSelector = getAvmTestContractFunctionSelector('public_dispatch');
-  const publicFn: PublicFunction = { bytecode, selector: dispatchSelector };
-  const contractClass = makeContractClassPublic(0, publicFn);
-  const contractInstance = makeContractInstanceFromClassId(contractClass.id);
-
-  // The values here should match those in `avm_simulator.test.ts`
-  const instanceGet = new SerializableContractInstance({
-    version: 1,
-    salt: new Fr(0x123),
-    deployer: new AztecAddress(new Fr(0x456)),
-    contractClassId: new Fr(0x789),
-    initializationHash: new Fr(0x101112),
-    publicKeys: new PublicKeys(
-      new Point(new Fr(0x131415), new Fr(0x161718), false),
-      new Point(new Fr(0x192021), new Fr(0x222324), false),
-      new Point(new Fr(0x252627), new Fr(0x282930), false),
-      new Point(new Fr(0x313233), new Fr(0x343536), false),
-    ),
-  }).withAddress(contractInstance.address);
-  worldStateDB.getContractInstance
-    .mockResolvedValueOnce(contractInstance)
-    .mockResolvedValueOnce(instanceGet) // test gets deployer
-    .mockResolvedValueOnce(instanceGet) // test gets class id
-    .mockResolvedValueOnce(instanceGet) // test gets init hash
-    .mockResolvedValue(contractInstance);
-  worldStateDB.getContractClass.mockResolvedValue(contractClass);
-  worldStateDB.getBytecode.mockResolvedValue(bytecode);
-
-  const storageValue = new Fr(5);
-  worldStateDB.storageRead.mockResolvedValue(Promise.resolve(storageValue));
+  const contractDataSource = new MockedAvmTestContractDataSource();
+  const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
+
+  const contractInstance = contractDataSource.contractInstance;
 
   const simulator = new PublicTxSimulator(
     merkleTrees,
     worldStateDB,
     new NoopTelemetryClient(),
     globalVariables,
+    /*realAvmProving=*/ true,
     /*doMerkleOperations=*/ true,
   );
 
-  const callContext = new CallContext(sender, contractInstance.address, dispatchSelector, /*isStaticCall=*/ false);
+  const callContext = new CallContext(
+    sender,
+    contractInstance.address,
+    contractDataSource.fnSelector,
+    /*isStaticCall=*/ false,
+  );
   const executionRequest = new PublicExecutionRequest(callContext, calldata);
 
   const tx: Tx = createTxForPublicCall(executionRequest);
@@ -156,3 +132,81 @@ export function createTxForPublicCall(
 
   return tx;
 }
+
+class MockedAvmTestContractDataSource {
+  private fnName = 'public_dispatch';
+  private bytecode: Buffer;
+  public fnSelector: FunctionSelector;
+  private publicFn: PublicFunction;
+  private contractClass: ContractClassPublic;
+  public contractInstance: ContractInstanceWithAddress;
+  private bytecodeCommitment: Fr;
+  private otherContractInstance: ContractInstanceWithAddress;
+
+  constructor() {
+    this.bytecode = getAvmTestContractBytecode(this.fnName);
+    this.fnSelector = getAvmTestContractFunctionSelector(this.fnName);
+    this.publicFn = { bytecode: this.bytecode, selector: this.fnSelector };
+    this.contractClass = makeContractClassPublic(0, this.publicFn);
+    this.contractInstance = makeContractInstanceFromClassId(this.contractClass.id);
+    this.bytecodeCommitment = computePublicBytecodeCommitment(this.bytecode);
+    // The values here should match those in `avm_simulator.test.ts`
+    this.otherContractInstance = new SerializableContractInstance({
+      version: 1,
+      salt: new Fr(0x123),
+      deployer: new AztecAddress(new Fr(0x456)),
+      contractClassId: new Fr(0x789),
+      initializationHash: new Fr(0x101112),
+      publicKeys: new PublicKeys(
+        new Point(new Fr(0x131415), new Fr(0x161718), false),
+        new Point(new Fr(0x192021), new Fr(0x222324), false),
+        new Point(new Fr(0x252627), new Fr(0x282930), false),
+        new Point(new Fr(0x313233), new Fr(0x343536), false),
+      ),
+    }).withAddress(this.contractInstance.address);
+  }
+
+  getPublicFunction(_address: AztecAddress, _selector: FunctionSelector): Promise<PublicFunction> {
+    return Promise.resolve(this.publicFn);
+  }
+
+  getBlockNumber(): Promise<number> {
+    throw new Error('Method not implemented.');
+  }
+
+  getContractClass(_id: Fr): Promise<ContractClassPublic> {
+    return Promise.resolve(this.contractClass);
+  }
+
+  getBytecodeCommitment(_id: Fr): Promise<Fr> {
+    return Promise.resolve(this.bytecodeCommitment);
+  }
+
+  addContractClass(_contractClass: ContractClassPublic): Promise<void> {
+    return Promise.resolve();
+  }
+
+  getContract(address: AztecAddress): Promise<ContractInstanceWithAddress> {
+    if (address.equals(this.contractInstance.address)) {
+      return Promise.resolve(this.contractInstance);
+    } else {
+      return Promise.resolve(this.otherContractInstance);
+    }
+  }
+
+  getContractClassIds(): Promise<Fr[]> {
+    throw new Error('Method not implemented.');
+  }
+
+  getContractArtifact(_address: AztecAddress): Promise<ContractArtifact | undefined> {
+    throw new Error('Method not implemented.');
+  }
+
+  getContractFunctionName(_address: AztecAddress, _selector: FunctionSelector): Promise<string> {
+    return Promise.resolve(this.fnName);
+  }
+
+  addContractArtifact(_address: AztecAddress, _contract: ContractArtifact): Promise<void> {
+    return Promise.resolve();
+  }
+}

package/src/public/public_db_sources.ts

@@ -14,11 +14,12 @@ import {
   ContractInstanceDeployedEvent,
   type ContractInstanceWithAddress,
   Fr,
-  FunctionSelector,
+  type FunctionSelector,
   type L1_TO_L2_MSG_TREE_HEIGHT,
   type NULLIFIER_TREE_HEIGHT,
   type NullifierLeafPreimage,
   type PublicDataTreeLeafPreimage,
+  computePublicBytecodeCommitment,
 } from '@aztec/circuits.js';
 import { computeL1ToL2MessageNullifier, computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -38,11 +39,11 @@ import {
 export class ContractsDataSourcePublicDB implements PublicContractsDB {
   private instanceCache = new Map<string, ContractInstanceWithAddress>();
   private classCache = new Map<string, ContractClassPublic>();
+  private bytecodeCommitmentCache = new Map<string, Fr>();
 
   private log = createDebugLogger('aztec:sequencer:contracts-data-source');
 
   constructor(private dataSource: ContractDataSource) {}
-
   /**
    * Add new contracts from a transaction
    * @param tx - The transaction to add contracts from.
@@ -92,6 +93,31 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     return this.classCache.get(contractClassId.toString()) ?? (await this.dataSource.getContractClass(contractClassId));
   }
 
+  public async getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined> {
+    // Try and retrieve from cache
+    const key = contractClassId.toString();
+    const result = this.bytecodeCommitmentCache.get(key);
+    if (result !== undefined) {
+      return result;
+    }
+    // Now try from the store
+    const fromStore = await this.dataSource.getBytecodeCommitment(contractClassId);
+    if (fromStore !== undefined) {
+      this.bytecodeCommitmentCache.set(key, fromStore);
+      return fromStore;
+    }
+
+    // Not in either the store or the cache, build it here and cache
+    const contractClass = await this.getContractClass(contractClassId);
+    if (contractClass === undefined) {
+      return undefined;
+    }
+
+    const value = computePublicBytecodeCommitment(contractClass.packedBytecode);
+    this.bytecodeCommitmentCache.set(key, value);
+    return value;
+  }
+
   async getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
     const instance = await this.getContractInstance(address);
     if (!instance) {
@@ -105,19 +131,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
   }
 
   public async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
-    const artifact = await this.dataSource.getContractArtifact(address);
-    if (!artifact) {
-      return Promise.resolve(undefined);
-    }
-
-    const f = artifact.functions.find(f =>
-      FunctionSelector.fromNameAndParameters(f.name, f.parameters).equals(selector),
-    );
-    if (!f) {
-      return Promise.resolve(undefined);
-    }
-
-    return Promise.resolve(`${artifact.name}:${f.name}`);
+    return await this.dataSource.getContractFunctionName(address, selector);
   }
 }