@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.21

package/src/public/{public_tx_simulator.ts → public_tx_simulator/public_tx_simulator.ts}

@@ -1,29 +1,31 @@
-import {
-  type AvmProvingRequest,
-  type GasUsed,
-  type MerkleTreeReadOperations,
-  NestedProcessReturnValues,
-  type PublicExecutionRequest,
-  type SimulationError,
-  type Tx,
-  TxExecutionPhase,
-} from '@aztec/circuit-types';
-import { type AvmSimulationStats } from '@aztec/circuit-types/stats';
-import { type Fr, type Gas, type GlobalVariables, type PublicCallRequest, type RevertCode } from '@aztec/circuits.js';
+import type { Fr } from '@aztec/foundation/fields';
 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 type { 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 type { AvmSimulationStats } from '@aztec/stdlib/stats';
+import {
+  type GlobalVariables,
+  NestedProcessReturnValues,
+  PublicExecutionRequest,
+  Tx,
+  TxExecutionPhase,
+} from '@aztec/stdlib/tx';
 import { Attributes, type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { strict as assert } from 'assert';
 
-import { type AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
+import { getPublicFunctionDebugName } from '../../common/debug_fn_name.js';
+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 { getPublicFunctionDebugName } from '../common/debug_fn_name.js';
-import { ExecutorMetrics } from './executor_metrics.js';
-import { computeFeePayerBalanceStorageSlot } from './fee_payment.js';
-import { type WorldStateDB } from './public_db_sources.js';
+import { ExecutorMetrics } from '../executor_metrics.js';
+import type { WorldStateDB } from '../public_db_sources.js';
 import { PublicTxContext } from './public_tx_context.js';
 
 export type ProcessedPhase = {
@@ -54,7 +56,7 @@ export class PublicTxSimulator {
     private worldStateDB: WorldStateDB,
     private globalVariables: GlobalVariables,
     private doMerkleOperations: boolean = false,
-    private enforceFeePayment: boolean = true,
+    private skipFeeEnforcement: boolean = false,
     telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {
     this.log = createLogger(`simulator:public_tx_simulator`);
@@ -70,79 +72,89 @@ export class PublicTxSimulator {
    * @returns The result of the transaction's public execution.
    */
   public async simulate(tx: Tx): Promise<PublicTxResult> {
-    const txHash = await tx.getTxHash();
-    this.log.debug(`Simulating ${tx.enqueuedPublicFunctionCalls.length} public calls for tx ${txHash}`, { txHash });
-
-    const context = await PublicTxContext.create(
-      this.db,
-      this.worldStateDB,
-      tx,
-      this.globalVariables,
-      this.doMerkleOperations,
-    );
+    try {
+      const startTime = process.hrtime.bigint();
+
+      const txHash = await tx.getTxHash();
+      this.log.debug(`Simulating ${tx.enqueuedPublicFunctionCalls.length} public calls for tx ${txHash}`, { txHash });
+
+      const context = await PublicTxContext.create(
+        this.db,
+        this.worldStateDB,
+        tx,
+        this.globalVariables,
+        this.doMerkleOperations,
+      );
+
+      const nonRevertStart = process.hrtime.bigint();
+      await this.insertNonRevertiblesFromPrivate(context);
+      // add new contracts to the contracts db so that their functions may be found and called
+      // TODO(#6464): Should we allow emitting contracts in the private setup phase?
+      await this.worldStateDB.addNewNonRevertibleContracts(tx);
+      const nonRevertEnd = process.hrtime.bigint();
+      this.metrics.recordPrivateEffectsInsertion(Number(nonRevertEnd - nonRevertStart) / 1_000, 'non-revertible');
+
+      const processedPhases: ProcessedPhase[] = [];
+      if (context.hasPhase(TxExecutionPhase.SETUP)) {
+        const setupResult: ProcessedPhase = await this.simulateSetupPhase(context);
+        processedPhases.push(setupResult);
+      }
 
-    // add new contracts to the contracts db so that their functions may be found and called
-    // TODO(#4073): This is catching only private deployments, when we add public ones, we'll
-    // have to capture contracts emitted in that phase as well.
-    // TODO(@spalladino): Should we allow emitting contracts in the fee preparation phase?
-    // TODO(#6464): Should we allow emitting contracts in the private setup phase?
-    // if so, this should only add contracts that were deployed during private app logic.
-    // FIXME: we shouldn't need to directly modify worldStateDb here!
-    await this.worldStateDB.addNewContracts(tx);
-
-    const nonRevertStart = process.hrtime.bigint();
-    await this.insertNonRevertiblesFromPrivate(context);
-    const nonRevertEnd = process.hrtime.bigint();
-    this.metrics.recordPrivateEffectsInsertion(Number(nonRevertEnd - nonRevertStart) / 1_000, 'non-revertible');
-    const processedPhases: ProcessedPhase[] = [];
-    if (context.hasPhase(TxExecutionPhase.SETUP)) {
-      const setupResult: ProcessedPhase = await this.simulateSetupPhase(context);
-      processedPhases.push(setupResult);
-    }
+      const revertStart = process.hrtime.bigint();
+      // FIXME(#12375): TX shouldn't die if revertible insertions fail. Should just revert to snapshot.
+      await this.insertRevertiblesFromPrivate(context);
+      // add new contracts to the contracts db so that their functions may be found and called
+      await this.worldStateDB.addNewRevertibleContracts(tx);
+      const revertEnd = process.hrtime.bigint();
+      this.metrics.recordPrivateEffectsInsertion(Number(revertEnd - revertStart) / 1_000, 'revertible');
+
+      if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
+        const appLogicResult: ProcessedPhase = await this.simulateAppLogicPhase(context);
+        processedPhases.push(appLogicResult);
+      }
 
-    const revertStart = process.hrtime.bigint();
-    await this.insertRevertiblesFromPrivate(context);
-    const revertEnd = process.hrtime.bigint();
-    this.metrics.recordPrivateEffectsInsertion(Number(revertEnd - revertStart) / 1_000, 'revertible');
-    if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
-      const appLogicResult: ProcessedPhase = await this.simulateAppLogicPhase(context);
-      processedPhases.push(appLogicResult);
-    }
+      if (context.hasPhase(TxExecutionPhase.TEARDOWN)) {
+        const teardownResult: ProcessedPhase = await this.simulateTeardownPhase(context);
+        processedPhases.push(teardownResult);
+      }
 
-    if (context.hasPhase(TxExecutionPhase.TEARDOWN)) {
-      const teardownResult: ProcessedPhase = await this.simulateTeardownPhase(context);
-      processedPhases.push(teardownResult);
-    }
+      await context.halt();
+      await this.payFee(context);
 
-    context.halt();
-    await this.payFee(context);
+      const endStateReference = await this.db.getStateReference();
 
-    const endStateReference = await this.db.getStateReference();
+      const avmProvingRequest = await context.generateProvingRequest(endStateReference);
 
-    const avmProvingRequest = await context.generateProvingRequest(endStateReference);
+      const revertCode = context.getFinalRevertCode();
 
-    const revertCode = context.getFinalRevertCode();
-    if (!revertCode.isOK()) {
-      // TODO(#6464): Should we allow emitting contracts in the private setup phase?
-      // if so, this is removing contracts deployed in private setup
-      // You can't submit contracts in public, so this is only relevant for private-created side effects
-      // FIXME: we shouldn't need to directly modify worldStateDb here!
-      await this.worldStateDB.removeNewContracts(tx, true);
-      // FIXME(dbanks12): should not be changing immutable tx
-      tx.filterRevertedLogs(tx.data.forPublic!.nonRevertibleAccumulatedData);
+      if (!revertCode.isOK()) {
+        await tx.filterRevertedLogs();
+      }
+      // 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());
+
+      const endTime = process.hrtime.bigint();
+      this.log.debug(`Public TX simulator took ${Number(endTime - startTime) / 1_000_000} ms\n`);
+
+      return {
+        avmProvingRequest,
+        gasUsed: {
+          totalGas: context.getActualGasUsed(),
+          teardownGas: context.teardownGasUsed,
+          publicGas: context.getActualPublicGasUsed(),
+          billedGas: context.getTotalGasUsed(),
+        },
+        revertCode,
+        revertReason: context.revertReason,
+        processedPhases: processedPhases,
+      };
+    } 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();
     }
-
-    return {
-      avmProvingRequest,
-      gasUsed: {
-        totalGas: context.getActualGasUsed(),
-        teardownGas: context.teardownGasUsed,
-        publicGas: context.getActualPublicGasUsed(),
-      },
-      revertCode,
-      revertReason: context.revertReason,
-      processedPhases: processedPhases,
-    };
   }
 
   /**
@@ -166,11 +178,11 @@ export class PublicTxSimulator {
 
     if (result.reverted) {
       // Drop the currently active forked state manager and rollback to end of setup.
-      context.state.discardForkedState();
+      await context.state.discardForkedState();
     } else {
       if (!context.hasPhase(TxExecutionPhase.TEARDOWN)) {
         // Nothing to do after this (no teardown), so merge state updates now instead of letting teardown handle it.
-        context.state.mergeForkedState();
+        await context.state.mergeForkedState();
       }
     }
 
@@ -186,17 +198,17 @@ export class PublicTxSimulator {
     if (!context.state.isForked()) {
       // If state isn't forked (app logic reverted), fork now
       // so we can rollback to the end of setup if teardown reverts.
-      context.state.fork();
+      await context.state.fork();
     }
 
     const result = await this.simulatePhase(TxExecutionPhase.TEARDOWN, context);
 
     if (result.reverted) {
       // Drop the currently active forked state manager and rollback to end of setup.
-      context.state.discardForkedState();
+      await context.state.discardForkedState();
     } else {
       // Merge state updates from teardown,
-      context.state.mergeForkedState();
+      await context.state.mergeForkedState();
     }
 
     return result;
@@ -302,7 +314,7 @@ export class PublicTxSimulator {
 
   /**
    * Simulate an enqueued public call, without modifying the context (PublicTxContext).
-   * Resulting modifcations to the context can be applied by the caller.
+   * Resulting modifications to the context can be applied by the caller.
    *
    * This function can be mocked for testing to skip actual AVM simulation
    * while still simulating phases and generating a proving request.
@@ -395,12 +407,13 @@ export class PublicTxSimulator {
    */
   public async insertRevertiblesFromPrivate(context: PublicTxContext) {
     // Fork the state manager so we can rollback to end of setup if app logic reverts.
-    context.state.fork();
+    await context.state.fork();
     const stateManager = context.state.getActiveStateManager();
     try {
       await stateManager.writeSiloedNullifiersFromPrivate(context.revertibleAccumulatedDataFromPrivate.nullifiers);
     } catch (e) {
       if (e instanceof NullifierCollisionError) {
+        // FIXME(#12375): simulator should be able to recover from this and just revert to snapshot.
         throw new NullifierCollisionError(
           `Nullifier collision encountered when inserting revertible nullifiers from private. Details:\n${e.message}\n.Stack:${e.stack}`,
         );
@@ -433,7 +446,7 @@ export class PublicTxSimulator {
     // When mocking the balance of the fee payer, the circuit should not be able to prove the simulation
 
     if (currentBalance.lt(txFee)) {
-      if (this.enforceFeePayment) {
+      if (!this.skipFeeEnforcement) {
         throw new Error(
           `Not enough balance for fee payer to pay for transaction (got ${currentBalance.toBigInt()} needs ${txFee.toBigInt()})`,
         );

package/src/public/side_effect_trace.ts

@@ -1,23 +1,5 @@
 import {
-  AvmAccumulatedData,
-  AvmAppendTreeHint,
-  AvmCircuitPublicInputs,
-  AvmContractBytecodeHints,
-  AvmContractInstanceHint,
-  AvmEnqueuedCallHint,
-  AvmExecutionHints,
-  AvmNullifierReadTreeHint,
-  AvmNullifierWriteTreeHint,
-  AvmPublicDataReadTreeHint,
-  AvmPublicDataWriteTreeHint,
-  type AztecAddress,
-  type ContractClassIdPreimage,
-  EthAddress,
-  type Gas,
-  type GasSettings,
-  type GlobalVariables,
   L1_TO_L2_MSG_TREE_HEIGHT,
-  L2ToL1Message,
   MAX_ENQUEUED_CALLS_PER_TX,
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
@@ -28,33 +10,49 @@ import {
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   NOTE_HASH_TREE_HEIGHT,
   NULLIFIER_TREE_HEIGHT,
-  NoteHash,
-  Nullifier,
-  NullifierLeafPreimage,
   PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   PUBLIC_DATA_TREE_HEIGHT,
   PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
-  PrivateToAvmAccumulatedData,
-  PrivateToAvmAccumulatedDataArrayLengths,
-  PublicCallRequest,
-  PublicDataTreeLeafPreimage,
-  PublicDataUpdateRequest,
-  PublicDataWrite,
-  PublicLog,
-  ScopedL2ToL1Message,
-  SerializableContractInstance,
-  type TreeSnapshots,
-} from '@aztec/circuits.js';
-import { computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
+} from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
-import { jsonStringify } from '@aztec/foundation/json-rpc';
 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 {
+  NoteHash,
+  Nullifier,
+  PrivateToAvmAccumulatedData,
+  PrivateToAvmAccumulatedDataArrayLengths,
+  PublicCallRequest,
+} 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';
 
 import { SideEffectLimitReachedError } from './side_effect_errors.js';
-import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.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());
@@ -124,8 +122,8 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
      *  otherwise the public kernel can fail to prove because TX limits are breached.
      */
     private readonly previousSideEffectArrayLengths: SideEffectArrayLengths = SideEffectArrayLengths.empty(),
-    /** We need to track the set of class IDs used for bytecode retrieval to deduplicate and enforce limits. */
-    private gotBytecodeFromClassIds: UniqueClassIds = new UniqueClassIds(),
+    /** We need to track the set of class IDs used, to enforce limits. */
+    private uniqueClassIds: UniqueClassIds = new UniqueClassIds(),
   ) {
     this.sideEffectCounter = startSideEffectCounter;
     this.avmCircuitHints = AvmExecutionHints.empty();
@@ -142,7 +140,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
         this.previousSideEffectArrayLengths.l2ToL1Msgs + this.l2ToL1Messages.length,
         this.previousSideEffectArrayLengths.publicLogs + this.publicLogs.length,
       ),
-      this.gotBytecodeFromClassIds.fork(),
+      this.uniqueClassIds.fork(),
     );
   }
 
@@ -168,29 +166,17 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
   }
 
   private mergeHints(forkedTrace: this) {
-    this.gotBytecodeFromClassIds.acceptAndMerge(forkedTrace.gotBytecodeFromClassIds);
-
-    this.avmCircuitHints.enqueuedCalls.items.push(...forkedTrace.avmCircuitHints.enqueuedCalls.items);
-
-    this.avmCircuitHints.contractInstances.items.push(...forkedTrace.avmCircuitHints.contractInstances.items);
-
-    // merge in contract bytecode hints
-    // UniqueClassIds should prevent duplication
-    for (const [contractClassId, bytecodeHint] of forkedTrace.avmCircuitHints.contractBytecodeHints) {
-      assert(
-        !this.avmCircuitHints.contractBytecodeHints.has(contractClassId),
-        'Bug preventing duplication of contract bytecode hints',
-      );
-      this.avmCircuitHints.contractBytecodeHints.set(contractClassId, bytecodeHint);
-    }
-
-    this.avmCircuitHints.publicDataReads.items.push(...forkedTrace.avmCircuitHints.publicDataReads.items);
-    this.avmCircuitHints.publicDataWrites.items.push(...forkedTrace.avmCircuitHints.publicDataWrites.items);
-    this.avmCircuitHints.nullifierReads.items.push(...forkedTrace.avmCircuitHints.nullifierReads.items);
-    this.avmCircuitHints.nullifierWrites.items.push(...forkedTrace.avmCircuitHints.nullifierWrites.items);
-    this.avmCircuitHints.noteHashReads.items.push(...forkedTrace.avmCircuitHints.noteHashReads.items);
-    this.avmCircuitHints.noteHashWrites.items.push(...forkedTrace.avmCircuitHints.noteHashWrites.items);
-    this.avmCircuitHints.l1ToL2MessageReads.items.push(...forkedTrace.avmCircuitHints.l1ToL2MessageReads.items);
+    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() {
@@ -213,7 +199,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     leafIndex: Fr = Fr.zero(),
     path: Fr[] = emptyPublicDataPath(),
   ) {
-    this.avmCircuitHints.publicDataReads.items.push(new AvmPublicDataReadTreeHint(leafPreimage, leafIndex, path));
+    this.avmCircuitHints.publicDataReads.push(new AvmPublicDataReadTreeHint(leafPreimage, leafIndex, path));
     this.log.trace(
       `Tracing storage read (address=${contractAddress}, slot=${slot}): value=${value} (counter=${this.sideEffectCounter})`,
     );
@@ -260,7 +246,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
 
     // New hinting
     const readHint = new AvmPublicDataReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-    this.avmCircuitHints.publicDataWrites.items.push(
+    this.avmCircuitHints.publicDataWrites.push(
       new AvmPublicDataWriteTreeHint(readHint, newLeafPreimage, insertionPath),
     );
 
@@ -279,7 +265,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     path: Fr[] = emptyNoteHashPath(),
   ) {
     // New Hinting
-    this.avmCircuitHints.noteHashReads.items.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
+    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})`);
   }
@@ -290,7 +276,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     }
 
     this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter));
-    this.avmCircuitHints.noteHashWrites.items.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
+    this.avmCircuitHints.noteHashWrites.push(new AvmAppendTreeHint(leafIndex, noteHash, path));
     this.log.trace(`Tracing new note hash (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();
   }
@@ -302,9 +288,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     lowLeafIndex: Fr = Fr.zero(),
     lowLeafPath: Fr[] = emptyNullifierPath(),
   ) {
-    this.avmCircuitHints.nullifierReads.items.push(
-      new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath),
-    );
+    this.avmCircuitHints.nullifierReads.push(new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath));
     this.log.trace(`Tracing nullifier check (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();
   }
@@ -323,7 +307,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     this.nullifiers.push(new Nullifier(siloedNullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
 
     const lowLeafReadHint = new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-    this.avmCircuitHints.nullifierWrites.items.push(new AvmNullifierWriteTreeHint(lowLeafReadHint, insertionPath));
+    this.avmCircuitHints.nullifierWrites.push(new AvmNullifierWriteTreeHint(lowLeafReadHint, insertionPath));
     this.log.trace(`Tracing new nullifier (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();
   }
@@ -336,7 +320,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     _exists: boolean,
     path: Fr[] = emptyL1ToL2MessagePath(),
   ) {
-    this.avmCircuitHints.l1ToL2MessageReads.items.push(new AvmAppendTreeHint(msgLeafIndex, msgHash, path));
+    this.avmCircuitHints.l1ToL2MessageReads.push(new AvmAppendTreeHint(msgLeafIndex, msgHash, path));
     this.log.trace(`Tracing l1 to l2 message check (counter=${this.sideEffectCounter})`);
   }
 
@@ -371,114 +355,55 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     contractAddress: AztecAddress,
     exists: boolean,
     instance: SerializableContractInstance = SerializableContractInstance.default(),
-    lowLeafPreimage: NullifierLeafPreimage = NullifierLeafPreimage.empty(),
-    lowLeafIndex: Fr = Fr.zero(),
-    lowLeafPath: Fr[] = emptyNullifierPath(),
+    updateMembershipHint: AvmPublicDataReadTreeHint = AvmPublicDataReadTreeHint.empty(),
+    updatePreimage: Fr[] = [],
   ) {
-    const membershipHint = new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-    this.avmCircuitHints.contractInstances.items.push(
+    this.avmCircuitHints.contractInstances.push(
       new AvmContractInstanceHint(
         contractAddress,
         exists,
         instance.salt,
         instance.deployer,
-        instance.contractClassId,
+        instance.currentContractClassId,
+        instance.originalContractClassId,
         instance.initializationHash,
         instance.publicKeys,
-        membershipHint,
+        updateMembershipHint,
+        updatePreimage,
       ),
     );
     this.log.trace(`Tracing contract instance retrieval (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();
   }
 
-  // This tracing function gets called everytime we start simulation/execution.
-  // This happens both when starting a new top-level trace and the start of every forked trace
-  // We use this to collect the AvmContractBytecodeHints
-  public traceGetBytecode(
-    contractAddress: AztecAddress,
-    exists: boolean,
-    bytecode: Buffer = Buffer.alloc(0),
-    contractInstance: SerializableContractInstance = SerializableContractInstance.default(),
-    contractClass: ContractClassIdPreimage = {
-      artifactHash: Fr.zero(),
-      privateFunctionsRoot: Fr.zero(),
-      publicBytecodeCommitment: Fr.zero(),
-    },
-    lowLeafPreimage: NullifierLeafPreimage = NullifierLeafPreimage.empty(),
-    lowLeafIndex: Fr = Fr.zero(),
-    lowLeafPath: Fr[] = emptyNullifierPath(),
-  ) {
-    // FIXME: The way we are hinting contract bytecodes is fundamentally broken.
-    // We are mapping contract class ID to a bytecode hint
-    // But a bytecode hint is tied to a contract INSTANCE.
-    // What if you encounter another contract instance with the same class ID?
-    // We can't hint that instance too since there is already an entry in the hints set that class ID.
-    // But without that instance hinted, the circuit can't prove that the called contract address
-    // actually corresponds to any class ID.
-
-    const membershipHint = new AvmNullifierReadTreeHint(lowLeafPreimage, lowLeafIndex, lowLeafPath);
-    const instance = new AvmContractInstanceHint(
-      contractAddress,
-      exists,
-      contractInstance.salt,
-      contractInstance.deployer,
-      contractInstance.contractClassId,
-      contractInstance.initializationHash,
-      contractInstance.publicKeys,
-      membershipHint,
-    );
-
-    // Always hint the contract instance separately from the bytecode hint.
-    // Since the bytecode hints are keyed by class ID, we need to hint the instance separately
-    // since there might be multiple instances hinted for the same class ID.
-    this.avmCircuitHints.contractInstances.items.push(instance);
-    this.log.trace(
-      `Tracing contract instance for bytecode retrieval: exists=${exists}, instance=${jsonStringify(contractInstance)}`,
-    );
-
+  public traceGetContractClass(contractClassId: Fr, exists: boolean, contractClass?: ContractClassWithCommitment) {
     if (!exists) {
-      // this ensures there are no duplicates
-      this.log.debug(`Contract address ${contractAddress} does not exist. Not tracing bytecode & class ID.`);
-      return;
-    }
-    // We already hinted this bytecode. No need to
-    // Don't we still need to hint if the class ID already exists?
-    // Because the circuit needs to prove that the called contract address corresponds to the class ID.
-    // To do so, the circuit needs to know the class ID in the
-    if (this.gotBytecodeFromClassIds.has(contractInstance.contractClassId.toString())) {
-      // this ensures there are no duplicates
-      this.log.trace(
-        `Contract class id ${contractInstance.contractClassId.toString()} already exists in previous hints`,
+      this.avmCircuitHints.contractClasses.push(
+        new AvmContractClassHint(contractClassId, exists, Fr.zero(), Fr.zero(), Fr.zero(), Buffer.alloc(0)),
       );
-      return;
-    }
+    } else if (!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(
+          'contract calls to unique class IDs',
+          MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
+        );
+      }
 
-    // If we could actually allow contract calls after the limit was reached, we would hint even if we have
-    // surpassed the limit of unique class IDs (still trace the failed bytecode retrieval)
-    // because the circuit needs to know the class ID to know when the limit is hit.
-    // BUT, the issue with this approach is that the sequencer could lie and say "this call was to a new class ID",
-    // and the circuit cannot prove that it's not true without deriving the class ID from bytecode,
-    // proving that it corresponds to the called contract address, and proving that the class ID wasn't already
-    // present/used. That would require more bytecode hashing which is exactly what this limit exists to avoid.
-    if (this.gotBytecodeFromClassIds.size() >= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS) {
-      this.log.debug(
-        `Bytecode retrieval failure for contract class ID ${contractInstance.contractClassId.toString()} (limit reached)`,
+      this.uniqueClassIds.add(contractClassId.toString());
+      this.avmCircuitHints.contractClasses.push(
+        new AvmContractClassHint(
+          contractClassId,
+          exists,
+          contractClass!.artifactHash,
+          contractClass!.privateFunctionsRoot,
+          contractClass!.publicBytecodeCommitment,
+          contractClass!.packedBytecode,
+        ),
       );
-      throw new SideEffectLimitReachedError(
-        'contract calls to unique class IDs',
-        MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
-      );
-    }
 
-    this.log.trace(`Tracing bytecode & contract class for bytecode retrieval: class=${jsonStringify(contractClass)}`);
-    this.avmCircuitHints.contractBytecodeHints.set(
-      contractInstance.contractClassId.toString(),
-      new AvmContractBytecodeHints(bytecode, instance, contractClass),
-    );
-    // After adding the bytecode hint, mark the classId as retrieved to avoid duplication.
-    // The above map alone isn't sufficient because we need to check the parent trace's (and its parent) as well.
-    this.gotBytecodeFromClassIds.add(contractInstance.contractClassId.toString());
+      this.incrementSideEffectCounter();
+    }
   }
 
   /**
@@ -495,7 +420,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
   ) {
     // TODO(4805): check if some threshold is reached for max enqueued or nested calls (to unique contracts?)
     this.enqueuedCalls.push(publicCallRequest);
-    this.avmCircuitHints.enqueuedCalls.items.push(new AvmEnqueuedCallHint(publicCallRequest.contractAddress, calldata));
+    this.avmCircuitHints.enqueuedCalls.push(new AvmEnqueuedCallHint(publicCallRequest.contractAddress, calldata));
   }
 
   public getSideEffects(): SideEffects {