@aztec/simulator 0.80.0 → 0.81.0

package/src/public/public_tx_simulator/public_tx_context.ts

@@ -10,18 +10,11 @@ import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { assertLength } from '@aztec/foundation/serialize';
-import {
-  AvmCircuitInputs,
-  type AvmCircuitPublicInputs,
-  type AvmProvingRequest,
-  PublicDataWrite,
-  RevertCode,
-} from '@aztec/stdlib/avm';
+import { type AvmCircuitPublicInputs, AvmExecutionHints, PublicDataWrite, RevertCode } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { SimulationError } from '@aztec/stdlib/errors';
 import { computeTransactionFee } from '@aztec/stdlib/fees';
 import { Gas, GasSettings } from '@aztec/stdlib/gas';
-import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
 import {
   PrivateToAvmAccumulatedData,
   PrivateToAvmAccumulatedDataArrayLengths,
@@ -30,7 +23,6 @@ import {
   countAccumulatedItems,
   mergeAccumulatedData,
 } from '@aztec/stdlib/kernel';
-import { ProvingRequestType } from '@aztec/stdlib/proofs';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
   type GlobalVariables,
@@ -45,8 +37,10 @@ import {
 import { strict as assert } from 'assert';
 import { inspect } from 'util';
 
+import type { PublicContractsDBInterface } from '../../server.js';
 import { AvmPersistableStateManager } from '../avm/index.js';
-import type { WorldStateDB } from '../public_db_sources.js';
+import { HintingPublicContractsDB } from '../hinting_db_sources.js';
+import type { PublicTreesDB } from '../public_db_sources.js';
 import { SideEffectArrayLengths, SideEffectTrace } from '../side_effect_trace.js';
 import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js';
 
@@ -68,9 +62,7 @@ export class PublicTxContext {
   /* What caused a revert (if one occurred)? */
   public revertReason: SimulationError | undefined;
 
-  public avmProvingRequest: AvmProvingRequest | undefined; // FIXME(dbanks12): remove
-
-  constructor(
+  private constructor(
     public readonly txHash: TxHash,
     public readonly state: PhaseStateManager,
     private readonly globalVariables: GlobalVariables,
@@ -87,14 +79,15 @@ export class PublicTxContext {
     public readonly nonRevertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public readonly revertibleAccumulatedDataFromPrivate: PrivateToPublicAccumulatedData,
     public readonly feePayer: AztecAddress,
-    public trace: SideEffectTrace, // FIXME(dbanks12): should be private
+    private readonly trace: SideEffectTrace,
+    public readonly hints: AvmExecutionHints, // This is public due to enqueued call hinting.
   ) {
     this.log = createLogger(`simulator:public_tx_context`);
   }
 
   public static async create(
-    db: MerkleTreeReadOperations,
-    worldStateDB: WorldStateDB,
+    treesDB: PublicTreesDB,
+    contractsDB: PublicContractsDBInterface,
     tx: Tx,
     globalVariables: GlobalVariables,
     doMerkleOperations: boolean,
@@ -114,8 +107,20 @@ export class PublicTxContext {
 
     const firstNullifier = nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
 
+    // We wrap the DB to collect AVM hints.
+    const hints = new AvmExecutionHints();
+    const hintingContractsDB = new HintingPublicContractsDB(contractsDB, hints);
+    // TODO: Wrap merkle db.
+
     // Transaction level state manager that will be forked for revertible phases.
-    const txStateManager = AvmPersistableStateManager.create(worldStateDB, trace, doMerkleOperations, firstNullifier);
+    const txStateManager = AvmPersistableStateManager.create(
+      treesDB,
+      hintingContractsDB,
+      trace,
+      doMerkleOperations,
+      firstNullifier,
+      globalVariables.blockNumber.toNumber(),
+    );
 
     const gasSettings = tx.data.constants.txContext.gasSettings;
     const gasUsedByPrivate = tx.data.gasUsed;
@@ -126,7 +131,7 @@ export class PublicTxContext {
       await tx.getTxHash(),
       new PhaseStateManager(txStateManager),
       globalVariables,
-      await db.getStateReference(),
+      await treesDB.getStateReference(),
       gasSettings,
       gasUsedByPrivate,
       gasAllocatedToPublic,
@@ -140,6 +145,7 @@ export class PublicTxContext {
       tx.data.forPublic!.revertibleAccumulatedData,
       tx.data.feePayer,
       trace,
+      hints,
     );
   }
 
@@ -322,7 +328,7 @@ export class PublicTxContext {
   /**
    * Generate the public inputs for the AVM circuit.
    */
-  private async generateAvmCircuitPublicInputs(endStateReference: StateReference): Promise<AvmCircuitPublicInputs> {
+  public async generateAvmCircuitPublicInputs(endStateReference: StateReference): Promise<AvmCircuitPublicInputs> {
     assert(this.halted, 'Can only get AvmCircuitPublicInputs after tx execution ends');
     const stateManager = this.state.getActiveStateManager();
 
@@ -406,16 +412,18 @@ export class PublicTxContext {
     );
     const numNoteHashesToPad =
       MAX_NOTE_HASHES_PER_TX - countAccumulatedItems(avmCircuitPublicInputs.accumulatedData.noteHashes);
-    await stateManager.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, padArrayEnd([], Fr.ZERO, numNoteHashesToPad));
+    await stateManager
+      .deprecatedGetTreesForPIGeneration()
+      .appendLeaves(MerkleTreeId.NOTE_HASH_TREE, padArrayEnd([], Fr.ZERO, numNoteHashesToPad));
     const numNullifiersToPad =
       MAX_NULLIFIERS_PER_TX - countAccumulatedItems(avmCircuitPublicInputs.accumulatedData.nullifiers);
-    await stateManager.db.batchInsert(
+    await stateManager.deprecatedGetTreesForPIGeneration().batchInsert(
       MerkleTreeId.NULLIFIER_TREE,
       padArrayEnd([], Fr.ZERO, numNullifiersToPad).map(nullifier => nullifier.toBuffer()),
       NULLIFIER_SUBTREE_HEIGHT,
     );
 
-    const paddedState = await stateManager.db.getStateReference();
+    const paddedState = await stateManager.deprecatedGetTreesForPIGeneration().getStateReference();
     avmCircuitPublicInputs.endTreeSnapshots = new TreeSnapshots(
       paddedState.l1ToL2MessageTree,
       paddedState.partial.noteHashTree,
@@ -425,22 +433,6 @@ export class PublicTxContext {
 
     return avmCircuitPublicInputs;
   }
-
-  /**
-   * Generate the proving request for the AVM circuit.
-   */
-  async generateProvingRequest(endStateReference: StateReference): Promise<AvmProvingRequest> {
-    const hints = this.trace.getAvmCircuitHints();
-    return {
-      type: ProvingRequestType.PUBLIC_VM,
-      inputs: new AvmCircuitInputs(
-        'public_dispatch',
-        [],
-        hints,
-        await this.generateAvmCircuitPublicInputs(endStateReference),
-      ),
-    };
-  }
 }
 
 /**

package/src/public/public_tx_simulator/public_tx_simulator.ts

@@ -3,11 +3,18 @@ import { type Logger, 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 type { AvmProvingRequest, RevertCode } from '@aztec/stdlib/avm';
+import {
+  AvmCircuitInputs,
+  AvmCircuitPublicInputs,
+  AvmEnqueuedCallHint,
+  AvmExecutionHints,
+  type AvmProvingRequest,
+  type RevertCode,
+} from '@aztec/stdlib/avm';
 import { SimulationError } from '@aztec/stdlib/errors';
 import type { Gas, GasUsed } from '@aztec/stdlib/gas';
-import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
 import type { PublicCallRequest } from '@aztec/stdlib/kernel';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
 import type { AvmSimulationStats } from '@aztec/stdlib/stats';
 import {
   type GlobalVariables,
@@ -25,7 +32,7 @@ import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js'
 import { type AvmPersistableStateManager, AvmSimulator } from '../avm/index.js';
 import { NullifierCollisionError } from '../avm/journal/nullifiers.js';
 import { ExecutorMetrics } from '../executor_metrics.js';
-import type { WorldStateDB } from '../public_db_sources.js';
+import type { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
 import { PublicTxContext } from './public_tx_context.js';
 
 export type ProcessedPhase = {
@@ -52,8 +59,8 @@ export class PublicTxSimulator {
   private log: Logger;
 
   constructor(
-    private db: MerkleTreeReadOperations,
-    private worldStateDB: WorldStateDB,
+    private treesDB: PublicTreesDB,
+    private contractsDB: PublicContractsDB,
     private globalVariables: GlobalVariables,
     private doMerkleOperations: boolean = false,
     private skipFeeEnforcement: boolean = false,
@@ -79,8 +86,8 @@ export class PublicTxSimulator {
       this.log.debug(`Simulating ${tx.enqueuedPublicFunctionCalls.length} public calls for tx ${txHash}`, { txHash });
 
       const context = await PublicTxContext.create(
-        this.db,
-        this.worldStateDB,
+        this.treesDB,
+        this.contractsDB,
         tx,
         this.globalVariables,
         this.doMerkleOperations,
@@ -90,7 +97,7 @@ export class PublicTxSimulator {
       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.worldStateDB.addNewNonRevertibleContracts(tx);
+      await this.contractsDB.addNewNonRevertibleContracts(tx);
       const nonRevertEnd = process.hrtime.bigint();
       this.metrics.recordPrivateEffectsInsertion(Number(nonRevertEnd - nonRevertStart) / 1_000, 'non-revertible');
 
@@ -104,7 +111,7 @@ export class PublicTxSimulator {
       const success = await this.insertRevertiblesFromPrivate(context);
       if (success) {
         // add new contracts to the contracts db so that their functions may be found and called
-        await this.worldStateDB.addNewRevertibleContracts(tx);
+        await this.contractsDB.addNewRevertibleContracts(tx);
         const revertEnd = process.hrtime.bigint();
         this.metrics.recordPrivateEffectsInsertion(Number(revertEnd - revertStart) / 1_000, 'revertible');
 
@@ -125,9 +132,8 @@ export class PublicTxSimulator {
       await context.halt();
       await this.payFee(context);
 
-      const endStateReference = await this.db.getStateReference();
-
-      const avmProvingRequest = await context.generateProvingRequest(endStateReference);
+      const publicInputs = await context.generateAvmCircuitPublicInputs(await this.treesDB.getStateReference());
+      const avmProvingRequest = PublicTxSimulator.generateProvingRequest(publicInputs, context.hints);
 
       const revertCode = context.getFinalRevertCode();
 
@@ -137,7 +143,7 @@ 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
-      this.worldStateDB.commitContractsForTx(/*onlyNonRevertibles=*/ !revertCode.isOK());
+      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`);
@@ -157,7 +163,7 @@ 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.
-      this.worldStateDB.clearContractsForTx();
+      this.contractsDB.clearContractsForTx();
     }
   }
 
@@ -288,10 +294,23 @@ export class PublicTxSimulator {
   ): Promise<AvmFinalizedCallResult> {
     const stateManager = context.state.getActiveStateManager();
     const address = executionRequest.callContext.contractAddress;
-    const fnName = await getPublicFunctionDebugName(this.worldStateDB, address, executionRequest.args);
+    const fnName = await getPublicFunctionDebugName(this.contractsDB, address, executionRequest.args);
 
     const allocatedGas = context.getGasLeftAtPhase(phase);
 
+    // The reason we need enqueued hints at all (and cannot just use the public inputs) is
+    // because they don't have the actual calldata, just the hash of it.
+    // If/when we pass the whole TX to C++, we can remove this class of hints.
+    stateManager.traceEnqueuedCall(callRequest);
+    context.hints.enqueuedCalls.push(
+      new AvmEnqueuedCallHint(
+        executionRequest.callContext.msgSender,
+        executionRequest.callContext.contractAddress,
+        executionRequest.args,
+        executionRequest.callContext.isStaticCall,
+      ),
+    );
+
     const result = await this.simulateEnqueuedCallInternal(
       context.state.getActiveStateManager(),
       executionRequest,
@@ -306,8 +325,6 @@ export class PublicTxSimulator {
       `Simulated enqueued public call (${fnName}) consumed ${gasUsed.l2Gas} L2 gas ending with ${result.gasLeft.l2Gas} L2 gas left.`,
     );
 
-    stateManager.traceEnqueuedCall(callRequest, executionRequest.args, result.reverted);
-
     if (result.reverted) {
       const culprit = `${executionRequest.callContext.contractAddress}:${executionRequest.callContext.functionSelector}`;
       context.revert(phase, result.revertReason, culprit); // throws if in setup (non-revertible) phase
@@ -471,4 +488,17 @@ export class PublicTxSimulator {
     const updatedBalance = currentBalance.sub(txFee);
     await stateManager.writeStorage(feeJuiceAddress, balanceSlot, updatedBalance, true);
   }
+
+  /**
+   * Generate the proving request for the AVM circuit.
+   */
+  private static generateProvingRequest(
+    publicInputs: AvmCircuitPublicInputs,
+    hints: AvmExecutionHints,
+  ): AvmProvingRequest {
+    return {
+      type: ProvingRequestType.PUBLIC_VM,
+      inputs: new AvmCircuitInputs('public_dispatch', [], hints, publicInputs),
+    };
+  }
 }

package/src/public/side_effect_trace.ts

@@ -1,5 +1,4 @@
 import {
-  L1_TO_L2_MSG_TREE_HEIGHT,
   MAX_ENQUEUED_CALLS_PER_TX,
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
@@ -8,10 +7,7 @@ import {
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MAX_PUBLIC_LOGS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  NOTE_HASH_TREE_HEIGHT,
-  NULLIFIER_TREE_HEIGHT,
   PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  PUBLIC_DATA_TREE_HEIGHT,
   PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
@@ -20,21 +16,11 @@ import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import {
   AvmAccumulatedData,
-  AvmAppendTreeHint,
   AvmCircuitPublicInputs,
-  AvmContractClassHint,
-  AvmContractInstanceHint,
-  AvmEnqueuedCallHint,
-  AvmExecutionHints,
-  AvmNullifierReadTreeHint,
-  AvmNullifierWriteTreeHint,
-  AvmPublicDataReadTreeHint,
-  AvmPublicDataWriteTreeHint,
   PublicDataUpdateRequest,
   PublicDataWrite,
 } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { type ContractClassWithCommitment, SerializableContractInstance } from '@aztec/stdlib/contract';
 import type { Gas, GasSettings } from '@aztec/stdlib/gas';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
 import {
@@ -46,7 +32,6 @@ import {
 } from '@aztec/stdlib/kernel';
 import { PublicLog } from '@aztec/stdlib/logs';
 import { L2ToL1Message, ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
-import { NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '@aztec/stdlib/trees';
 import type { GlobalVariables, TreeSnapshots } from '@aztec/stdlib/tx';
 
 import { strict as assert } from 'assert';
@@ -55,11 +40,6 @@ import { SideEffectLimitReachedError } from './side_effect_errors.js';
 import type { PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 import { UniqueClassIds } from './unique_class_ids.js';
 
-const emptyPublicDataPath = () => new Array(PUBLIC_DATA_TREE_HEIGHT).fill(Fr.zero());
-const emptyNoteHashPath = () => new Array(NOTE_HASH_TREE_HEIGHT).fill(Fr.zero());
-const emptyNullifierPath = () => new Array(NULLIFIER_TREE_HEIGHT).fill(Fr.zero());
-const emptyL1ToL2MessagePath = () => new Array(L1_TO_L2_MSG_TREE_HEIGHT).fill(Fr.zero());
-
 /**
  * A struct containing just the side effects as regular arrays
  * as opposed to "Tuple" arrays used by circuit public inputs.
@@ -67,12 +47,10 @@ const emptyL1ToL2MessagePath = () => new Array(L1_TO_L2_MSG_TREE_HEIGHT).fill(Fr
  **/
 export type SideEffects = {
   enqueuedCalls: PublicCallRequest[];
-
   publicDataWrites: PublicDataUpdateRequest[];
   noteHashes: NoteHash[];
   nullifiers: Nullifier[];
   l2ToL1Msgs: ScopedL2ToL1Message[];
-
   publicLogs: PublicLog[];
 };
 
@@ -101,7 +79,6 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
   private sideEffectCounter: number;
 
   private enqueuedCalls: PublicCallRequest[] = [];
-
   private publicDataWrites: PublicDataUpdateRequest[] = [];
   private protocolPublicDataWritesLength: number = 0;
   private userPublicDataWritesLength: number = 0;
@@ -110,8 +87,6 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
   private l2ToL1Messages: ScopedL2ToL1Message[] = [];
   private publicLogs: PublicLog[] = [];
 
-  private avmCircuitHints: AvmExecutionHints;
-
   /** Make sure a forked trace is never merged twice. */
   private alreadyMergedIntoParent = false;
 
@@ -126,7 +101,6 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     private uniqueClassIds: UniqueClassIds = new UniqueClassIds(),
   ) {
     this.sideEffectCounter = startSideEffectCounter;
-    this.avmCircuitHints = AvmExecutionHints.empty();
   }
 
   public fork() {
@@ -154,6 +128,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
 
     this.sideEffectCounter = forkedTrace.sideEffectCounter;
     this.enqueuedCalls.push(...forkedTrace.enqueuedCalls);
+    this.uniqueClassIds.acceptAndMerge(forkedTrace.uniqueClassIds);
 
     if (!reverted) {
       this.publicDataWrites.push(...forkedTrace.publicDataWrites);
@@ -162,21 +137,6 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
       this.l2ToL1Messages.push(...forkedTrace.l2ToL1Messages);
       this.publicLogs.push(...forkedTrace.publicLogs);
     }
-    this.mergeHints(forkedTrace);
-  }
-
-  private mergeHints(forkedTrace: this) {
-    this.uniqueClassIds.acceptAndMerge(forkedTrace.uniqueClassIds);
-    this.avmCircuitHints.enqueuedCalls.push(...forkedTrace.avmCircuitHints.enqueuedCalls);
-    this.avmCircuitHints.contractInstances.push(...forkedTrace.avmCircuitHints.contractInstances);
-    this.avmCircuitHints.contractClasses.push(...forkedTrace.avmCircuitHints.contractClasses);
-    this.avmCircuitHints.publicDataReads.push(...forkedTrace.avmCircuitHints.publicDataReads);
-    this.avmCircuitHints.publicDataWrites.push(...forkedTrace.avmCircuitHints.publicDataWrites);
-    this.avmCircuitHints.nullifierReads.push(...forkedTrace.avmCircuitHints.nullifierReads);
-    this.avmCircuitHints.nullifierWrites.push(...forkedTrace.avmCircuitHints.nullifierWrites);
-    this.avmCircuitHints.noteHashReads.push(...forkedTrace.avmCircuitHints.noteHashReads);
-    this.avmCircuitHints.noteHashWrites.push(...forkedTrace.avmCircuitHints.noteHashWrites);
-    this.avmCircuitHints.l1ToL2MessageReads.push(...forkedTrace.avmCircuitHints.l1ToL2MessageReads);
   }
 
   public getCounter() {
@@ -191,31 +151,11 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     return this.previousSideEffectArrayLengths.noteHashes + this.noteHashes.length;
   }
 
-  public tracePublicStorageRead(
-    contractAddress: AztecAddress,
-    slot: Fr,
-    value: Fr,
-    leafPreimage: PublicDataTreeLeafPreimage = PublicDataTreeLeafPreimage.empty(),
-    leafIndex: Fr = Fr.zero(),
-    path: Fr[] = emptyPublicDataPath(),
-  ) {
-    this.avmCircuitHints.publicDataReads.push(new AvmPublicDataReadTreeHint(leafPreimage, leafIndex, path));
-    this.log.trace(
-      `Tracing storage read (address=${contractAddress}, slot=${slot}): value=${value} (counter=${this.sideEffectCounter})`,
-    );
-    this.incrementSideEffectCounter();
-  }
-
   public async tracePublicStorageWrite(
     contractAddress: AztecAddress,
     slot: Fr,
     value: Fr,
     protocolWrite: boolean,
-    lowLeafPreimage: PublicDataTreeLeafPreimage = PublicDataTreeLeafPreimage.empty(),
-    lowLeafIndex: Fr = Fr.zero(),
-    lowLeafPath: Fr[] = emptyPublicDataPath(),
-    newLeafPreimage: PublicDataTreeLeafPreimage = PublicDataTreeLeafPreimage.empty(),
-    insertionPath: Fr[] = emptyPublicDataPath(),
   ): Promise<void> {
     if (protocolWrite) {
       if (
@@ -244,86 +184,33 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
     this.publicDataWrites.push(new PublicDataUpdateRequest(leafSlot, value, this.sideEffectCounter));
 
-    // New hinting
-    const readHint = new AvmPublicDataReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-    this.avmCircuitHints.publicDataWrites.push(
-      new AvmPublicDataWriteTreeHint(readHint, newLeafPreimage, insertionPath),
-    );
-
     this.log.trace(
       `Traced public data write (address=${contractAddress}, slot=${slot}): value=${value} (counter=${this.sideEffectCounter}, isProtocol:${protocolWrite})`,
     );
     this.incrementSideEffectCounter();
   }
 
-  // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
-  public traceNoteHashCheck(
-    _contractAddress: AztecAddress,
-    noteHash: Fr,
-    leafIndex: Fr,
-    _exists: boolean,
-    path: Fr[] = emptyNoteHashPath(),
-  ) {
-    // New Hinting
-    this.avmCircuitHints.noteHashReads.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
-    // NOTE: counter does not increment for note hash checks (because it doesn't rely on pending note hashes)
-    this.log.trace(`Tracing note hash check (counter=${this.sideEffectCounter})`);
-  }
-
-  public traceNewNoteHash(noteHash: Fr, leafIndex: Fr = Fr.zero(), path: Fr[] = emptyNoteHashPath()) {
+  public traceNewNoteHash(noteHash: Fr) {
     if (this.noteHashes.length + this.previousSideEffectArrayLengths.noteHashes >= MAX_NOTE_HASHES_PER_TX) {
       throw new SideEffectLimitReachedError('note hash', MAX_NOTE_HASHES_PER_TX);
     }
 
     this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter));
-    this.avmCircuitHints.noteHashWrites.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
     this.log.trace(`Tracing new note hash (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();
   }
 
-  public traceNullifierCheck(
-    _siloedNullifier: Fr,
-    _exists: boolean,
-    lowLeafPreimage: NullifierLeafPreimage = NullifierLeafPreimage.empty(),
-    lowLeafIndex: Fr = Fr.zero(),
-    lowLeafPath: Fr[] = emptyNullifierPath(),
-  ) {
-    this.avmCircuitHints.nullifierReads.push(new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath));
-    this.log.trace(`Tracing nullifier check (counter=${this.sideEffectCounter})`);
-    this.incrementSideEffectCounter();
-  }
-
-  public traceNewNullifier(
-    siloedNullifier: Fr,
-    lowLeafPreimage: NullifierLeafPreimage = NullifierLeafPreimage.empty(),
-    lowLeafIndex: Fr = Fr.zero(),
-    lowLeafPath: Fr[] = emptyNullifierPath(),
-    insertionPath: Fr[] = emptyNullifierPath(),
-  ) {
+  public traceNewNullifier(siloedNullifier: Fr) {
     if (this.nullifiers.length + this.previousSideEffectArrayLengths.nullifiers >= MAX_NULLIFIERS_PER_TX) {
       throw new SideEffectLimitReachedError('nullifier', MAX_NULLIFIERS_PER_TX);
     }
 
     this.nullifiers.push(new Nullifier(siloedNullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
 
-    const lowLeafReadHint = new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-    this.avmCircuitHints.nullifierWrites.push(new AvmNullifierWriteTreeHint(lowLeafReadHint, insertionPath));
     this.log.trace(`Tracing new nullifier (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();
   }
 
-  // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
-  public traceL1ToL2MessageCheck(
-    _contractAddress: AztecAddress,
-    msgHash: Fr,
-    msgLeafIndex: Fr,
-    _exists: boolean,
-    path: Fr[] = emptyL1ToL2MessagePath(),
-  ) {
-    this.avmCircuitHints.l1ToL2MessageReads.push(new AvmAppendTreeHint(msgLeafIndex, msgHash, path));
-    this.log.trace(`Tracing l1 to l2 message check (counter=${this.sideEffectCounter})`);
-  }
-
   public traceNewL2ToL1Message(contractAddress: AztecAddress, recipient: Fr, content: Fr) {
     if (this.l2ToL1Messages.length + this.previousSideEffectArrayLengths.l2ToL1Msgs >= MAX_L2_TO_L1_MSGS_PER_TX) {
       throw new SideEffectLimitReachedError('l2 to l1 message', MAX_L2_TO_L1_MSGS_PER_TX);
@@ -351,37 +238,9 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     this.incrementSideEffectCounter();
   }
 
-  public traceGetContractInstance(
-    contractAddress: AztecAddress,
-    exists: boolean,
-    instance: SerializableContractInstance = SerializableContractInstance.default(),
-    updateMembershipHint: AvmPublicDataReadTreeHint = AvmPublicDataReadTreeHint.empty(),
-    updatePreimage: Fr[] = [],
-  ) {
-    this.avmCircuitHints.contractInstances.push(
-      new AvmContractInstanceHint(
-        contractAddress,
-        exists,
-        instance.salt,
-        instance.deployer,
-        instance.currentContractClassId,
-        instance.originalContractClassId,
-        instance.initializationHash,
-        instance.publicKeys,
-        updateMembershipHint,
-        updatePreimage,
-      ),
-    );
-    this.log.trace(`Tracing contract instance retrieval (counter=${this.sideEffectCounter})`);
-    this.incrementSideEffectCounter();
-  }
-
-  public traceGetContractClass(contractClassId: Fr, exists: boolean, contractClass?: ContractClassWithCommitment) {
-    if (!exists) {
-      this.avmCircuitHints.contractClasses.push(
-        new AvmContractClassHint(contractClassId, exists, Fr.zero(), Fr.zero(), Fr.zero(), Buffer.alloc(0)),
-      );
-    } else if (!this.uniqueClassIds.has(contractClassId.toString())) {
+  public traceGetContractClass(contractClassId: Fr, exists: boolean) {
+    // We limit the number of unique contract class IDs due to hashing and the trace length limit.
+    if (exists && !this.uniqueClassIds.has(contractClassId.toString())) {
       if (this.uniqueClassIds.size() >= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS) {
         this.log.debug(`Bytecode retrieval failure for contract class ID ${contractClassId} (limit reached)`);
         throw new SideEffectLimitReachedError(
@@ -389,19 +248,8 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
           MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
         );
       }
-
+      this.log.trace(`Adding contract class ID ${contractClassId} (counter=${this.sideEffectCounter})`);
       this.uniqueClassIds.add(contractClassId.toString());
-      this.avmCircuitHints.contractClasses.push(
-        new AvmContractClassHint(
-          contractClassId,
-          exists,
-          contractClass!.artifactHash,
-          contractClass!.privateFunctionsRoot,
-          contractClass!.publicBytecodeCommitment,
-          contractClass!.packedBytecode,
-        ),
-      );
-
       this.incrementSideEffectCounter();
     }
   }
@@ -410,17 +258,9 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
    * Trace an enqueued call.
    * Accept some results from a finished call's trace into this one.
    */
-  public traceEnqueuedCall(
-    /** The call request from private that enqueued this call. */
-    publicCallRequest: PublicCallRequest,
-    /** The call's calldata */
-    calldata: Fr[],
-    /** Did the call revert? */
-    _reverted: boolean,
-  ) {
+  public traceEnqueuedCall(publicCallRequest: PublicCallRequest) {
     // TODO(4805): check if some threshold is reached for max enqueued or nested calls (to unique contracts?)
     this.enqueuedCalls.push(publicCallRequest);
-    this.avmCircuitHints.enqueuedCalls.push(new AvmEnqueuedCallHint(publicCallRequest.contractAddress, calldata));
   }
 
   public getSideEffects(): SideEffects {
@@ -488,10 +328,6 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     return this.publicLogs;
   }
 
-  public getAvmCircuitHints() {
-    return this.avmCircuitHints;
-  }
-
   private getAvmAccumulatedData() {
     return new AvmAccumulatedData(
       padArrayEnd(