@aztec/simulator 0.0.1-commit.b655e406 → 0.0.1-commit.d1f2d6c

package/src/public/public_tx_simulator/public_tx_simulator.ts

@@ -1,24 +1,16 @@
-import { AVM_MAX_PROCESSABLE_L2_GAS, DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { AVM_MAX_PROCESSABLE_L2_GAS } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress, ProtocolContractsList } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
-import {
-  AvmCircuitInputs,
-  AvmCircuitPublicInputs,
-  AvmExecutionHints,
-  type AvmProvingRequest,
-  AvmTxHint,
-  type RevertCode,
-} from '@aztec/stdlib/avm';
+import { AvmExecutionHints, AvmTxHint, PublicSimulatorConfig, PublicTxEffect, PublicTxResult } from '@aztec/stdlib/avm';
 import { SimulationError } from '@aztec/stdlib/errors';
-import type { Gas, GasUsed } from '@aztec/stdlib/gas';
-import type { DebugLog } from '@aztec/stdlib/logs';
-import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import { Gas } from '@aztec/stdlib/gas';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
 import {
   type GlobalVariables,
   NestedProcessReturnValues,
+  ProtocolContracts,
   PublicCallRequestWithCalldata,
   Tx,
   TxExecutionPhase,
@@ -41,33 +33,6 @@ import type { PublicPersistableStateManager } from '../state_manager/state_manag
 import { PublicTxContext } from './public_tx_context.js';
 import type { PublicTxSimulatorInterface } from './public_tx_simulator_interface.js';
 
-export type ProcessedPhase = {
-  phase: TxExecutionPhase;
-  durationMs?: number;
-  returnValues: NestedProcessReturnValues[];
-  reverted: boolean;
-  revertReason?: SimulationError;
-};
-
-export type PublicTxResult = {
-  avmProvingRequest: AvmProvingRequest;
-  /** Gas used during the execution of this tx */
-  gasUsed: GasUsed;
-  revertCode: RevertCode;
-  /** Revert reason, if any */
-  revertReason?: SimulationError;
-  processedPhases: ProcessedPhase[];
-  logs: DebugLog[];
-};
-
-export type PublicTxSimulatorConfig = {
-  proverId: Fr;
-  doMerkleOperations: boolean;
-  skipFeeEnforcement: boolean;
-  clientInitiatedSimulation: boolean;
-  maxDebugLogMemoryReads: number;
-};
-
 // The errors below are only thrown here in the public tx simulator,
 // and only during revertible phases (revertible insertions, app logic and teardown).
 // These are strictly "checked" errors (not exported and never propagated).
@@ -103,23 +68,27 @@ class TxSimTeardownRevert extends Error {
   }
 }
 
+/** Only used internally. */
+type ProcessedPhase = {
+  phase: TxExecutionPhase;
+  durationMs?: number;
+  returnValues: NestedProcessReturnValues[];
+  reverted: boolean;
+  revertReason?: SimulationError;
+};
+
 export class PublicTxSimulator implements PublicTxSimulatorInterface {
   protected log: Logger;
-  private config: PublicTxSimulatorConfig;
+  protected readonly config: PublicSimulatorConfig;
 
   constructor(
     protected merkleTree: MerkleTreeWriteOperations,
     protected contractsDB: PublicContractsDB,
     protected globalVariables: GlobalVariables,
-    config?: Partial<PublicTxSimulatorConfig>,
+    config?: Partial<PublicSimulatorConfig>,
+    protected protocolContracts: ProtocolContracts = ProtocolContractsList,
   ) {
-    this.config = {
-      proverId: config?.proverId ?? Fr.ZERO,
-      doMerkleOperations: config?.doMerkleOperations ?? false,
-      skipFeeEnforcement: config?.skipFeeEnforcement ?? false,
-      clientInitiatedSimulation: config?.clientInitiatedSimulation ?? false,
-      maxDebugLogMemoryReads: config?.maxDebugLogMemoryReads ?? DEFAULT_MAX_DEBUG_LOG_MEMORY_READS,
-    };
+    this.config = PublicSimulatorConfig.from(config ?? {});
     this.log = createLogger(`simulator:public_tx_simulator`);
   }
 
@@ -129,136 +98,143 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
    * @returns The result of the transaction's public execution.
    */
   public async simulate(tx: Tx): Promise<PublicTxResult> {
-    try {
-      const txHash = this.computeTxHash(tx);
-      this.log.debug(`Simulating ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, { txHash });
-
-      // Create hinting DBs.
-      const hints = new AvmExecutionHints(
-        this.globalVariables,
-        AvmTxHint.fromTx(tx, this.globalVariables.gasFees),
-        ProtocolContractsList, // imported from file
-      );
-      const hintingMerkleTree = await HintingMerkleWriteOperations.create(this.merkleTree, hints);
-      const hintingTreesDB = new PublicTreesDB(hintingMerkleTree);
-      const hintingContractsDB = new HintingPublicContractsDB(this.contractsDB, hints);
-
-      const context = await PublicTxContext.create(
-        hintingTreesDB,
-        hintingContractsDB,
-        tx,
-        this.globalVariables,
-        ProtocolContractsList, // imported from file
-        this.config.doMerkleOperations,
-        this.config.proverId,
-      );
+    const txHash = this.computeTxHash(tx);
+    this.log.debug(`Simulating ${tx.publicFunctionCalldata.length} public calls for tx ${txHash}`, { txHash });
 
-      // This will throw if there is a nullifier collision.
+    // Create hinting DBs.
+    const hints = new AvmExecutionHints(
+      this.globalVariables,
+      AvmTxHint.fromTx(tx, this.globalVariables.gasFees),
+      this.protocolContracts,
+    );
+    const hintingMerkleTree = await HintingMerkleWriteOperations.create(this.merkleTree, hints);
+    const hintingTreesDB = new PublicTreesDB(hintingMerkleTree);
+    const hintingContractsDB = new HintingPublicContractsDB(this.contractsDB, hints);
+
+    const context = await PublicTxContext.create(
+      hintingTreesDB,
+      hintingContractsDB,
+      tx,
+      this.globalVariables,
+      this.protocolContracts,
+      this.config.proverId,
+    );
+
+    // This will throw if there is a nullifier collision.
+    // In that case the transaction will be thrown out.
+    await this.insertNonRevertiblesFromPrivate(context);
+
+    const processedPhases: ProcessedPhase[] = [];
+    if (context.hasPhase(TxExecutionPhase.SETUP)) {
+      // This will throw if the setup phase reverts.
       // In that case the transaction will be thrown out.
-      await this.insertNonRevertiblesFromPrivate(context, tx);
-
-      const processedPhases: ProcessedPhase[] = [];
-      if (context.hasPhase(TxExecutionPhase.SETUP)) {
-        // This will throw if the setup phase reverts.
-        // In that case the transaction will be thrown out.
-        const setupResult = await this.simulatePhase(TxExecutionPhase.SETUP, context);
-        if (setupResult.reverted) {
-          throw new Error(
-            `Setup phase reverted! The transaction will be thrown out. ${setupResult.revertReason?.message}`,
-          );
-        }
-        processedPhases.push(setupResult);
+      const setupResult = await this.simulatePhase(TxExecutionPhase.SETUP, context);
+      if (setupResult.reverted) {
+        throw new Error(
+          `[SETUP] UNRECOVERABLE ERROR! The transaction will be thrown out. ${setupResult.revertReason?.message}`,
+        );
       }
+      processedPhases.push(setupResult);
+    }
 
-      // The checkpoint we should go back to if anything from now on reverts.
-      await context.state.fork();
-
-      try {
-        // This will throw if there is a nullifier collision or other insertion error (limit reached).
-        await this.insertRevertiblesFromPrivate(context, tx);
+    // The checkpoint we should go back to if anything from now on reverts.
+    await context.state.fork();
+    hintingContractsDB.createCheckpoint();
 
-        // Only proceed with app logic if there was no revert during revertible insertion.
-        if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
-          const appLogicResult = await this.simulatePhase(TxExecutionPhase.APP_LOGIC, context);
-          processedPhases.push(appLogicResult);
-          if (appLogicResult.reverted) {
-            throw new TxSimAppLogicRevert();
-          }
-        }
-      } catch (e: any) {
-        if (e instanceof TxSimRevertibleInsertionsRevert || e instanceof TxSimAppLogicRevert) {
-          // We revert to the post-setup state.
-          await context.state.discardForkedState();
-          // But we also create a new fork so that the teardown phase can transparently
-          // commit or rollback at the end of teardown.
-          await context.state.fork();
-        } else {
-          // Unchecked/unknown error - re-throw as-is
-          throw e;
+    try {
+      // This will throw if there is a nullifier collision or other insertion error (limit reached).
+      await this.insertRevertiblesFromPrivate(context);
+
+      // Only proceed with app logic if there was no revert during revertible insertion.
+      if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
+        const appLogicResult = await this.simulatePhase(TxExecutionPhase.APP_LOGIC, context);
+        processedPhases.push(appLogicResult);
+        if (appLogicResult.reverted) {
+          throw new TxSimAppLogicRevert();
         }
       }
+    } catch (e: any) {
+      if (e instanceof TxSimRevertibleInsertionsRevert || e instanceof TxSimAppLogicRevert) {
+        // We revert to the post-setup state.
+        await context.state.discardForkedState();
+        hintingContractsDB.revertCheckpoint();
+        // But we also create a new fork so that the teardown phase can transparently
+        // commit or rollback at the end of teardown.
+        await context.state.fork();
+        hintingContractsDB.createCheckpoint();
+      } else {
+        // Unchecked/unknown error - re-throw as-is
+        throw e;
+      }
+    }
 
-      try {
-        if (context.hasPhase(TxExecutionPhase.TEARDOWN)) {
-          const teardownResult = await this.simulatePhase(TxExecutionPhase.TEARDOWN, context);
-          processedPhases.push(teardownResult);
-          if (teardownResult.reverted) {
-            throw new TxSimTeardownRevert();
-          }
-        }
-        // We commit the forked state and we are done.
-        await context.state.mergeForkedState();
-      } catch (e: any) {
-        if (e instanceof TxSimTeardownRevert) {
-          // We revert to the post-setup state and we are done.
-          await context.state.discardForkedState();
-        } else {
-          // Unchecked/unknown error - re-throw as-is
-          throw e;
+    try {
+      if (context.hasPhase(TxExecutionPhase.TEARDOWN)) {
+        const teardownResult = await this.simulatePhase(TxExecutionPhase.TEARDOWN, context);
+        processedPhases.push(teardownResult);
+        if (teardownResult.reverted) {
+          throw new TxSimTeardownRevert();
         }
       }
+      // We commit the forked state and we are done.
+      await context.state.mergeForkedState();
+      hintingContractsDB.commitCheckpoint();
+    } catch (e: any) {
+      if (e instanceof TxSimTeardownRevert) {
+        // We revert to the post-setup state and we are done.
+        await context.state.discardForkedState();
+        hintingContractsDB.revertCheckpoint();
+      } else {
+        // Unchecked/unknown error - re-throw as-is
+        throw e;
+      }
+    }
 
-      context.halt();
+    context.halt();
 
-      // Such transactions should be filtered by GasTxValidator.
-      assert(
-        context.getActualGasUsed().l2Gas <= AVM_MAX_PROCESSABLE_L2_GAS,
-        `Transaction consumes ${context.getActualGasUsed().l2Gas} L2 gas, which exceeds the AVM maximum processable gas of ${AVM_MAX_PROCESSABLE_L2_GAS}`,
-      );
-      await this.payFee(context);
-
-      const publicInputs = await context.generateAvmCircuitPublicInputs();
-      const avmProvingRequest = PublicTxSimulator.generateProvingRequest(publicInputs, hints);
-
-      const revertCode = context.getFinalRevertCode();
-
-      // 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
-      // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
-      // However things should work as they are now because the hinted db would still pick up the new contracts.
-      this.contractsDB.commitContractsForTx(/*onlyNonRevertibles=*/ !revertCode.isOK());
-
-      return {
-        avmProvingRequest,
-        gasUsed: {
-          totalGas: context.getActualGasUsed(),
-          teardownGas: context.teardownGasUsed,
-          publicGas: context.getActualPublicGasUsed(),
-          billedGas: context.getTotalGasUsed(),
-        },
-        revertCode,
-        revertReason: context.revertReason,
-        processedPhases: processedPhases,
-        logs: context.state.getActiveStateManager().getLogs(),
-      };
-    } finally {
-      // Make sure there are no new contracts in the tx-level cache.
-      // They should either be committed to block-level cache or cleared.
-      // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
-      // However things should work as they are now because the hinted db would still pick up the new contracts.
-      this.contractsDB.clearContractsForTx();
+    // Such transactions should be filtered by GasTxValidator.
+    assert(
+      context.getActualGasUsed().l2Gas <= AVM_MAX_PROCESSABLE_L2_GAS,
+      `Transaction consumes ${context.getActualGasUsed().l2Gas} L2 gas, which exceeds the AVM maximum processable gas of ${AVM_MAX_PROCESSABLE_L2_GAS}`,
+    );
+    await this.payFee(context);
+
+    const publicInputs = await context.generateAvmCircuitPublicInputs();
+    const revertCode = context.getFinalRevertCode();
+
+    // We only return the app logic phase information, and only 1 per phase.
+    const appLogicReturnValues: NestedProcessReturnValues[] =
+      processedPhases.find(({ phase }) => phase === TxExecutionPhase.APP_LOGIC)?.returnValues ?? [];
+
+    // TODO(fcarreiro): This is a temporary backwards compatibility layer until we migrate to the C++ simulator.
+    if (context.revertReason !== undefined) {
+      (appLogicReturnValues as any).revertReason = context.revertReason;
     }
+
+    // Create PublicTxEffect from PublicInputs.
+    const publicTxEffect = new PublicTxEffect(
+      publicInputs.transactionFee,
+      publicInputs.accumulatedData.noteHashes.filter(h => !h.isEmpty()),
+      publicInputs.accumulatedData.nullifiers.filter(n => !n.isEmpty()),
+      publicInputs.accumulatedData.l2ToL1Msgs.filter(m => !m.isEmpty()),
+      publicInputs.accumulatedData.publicLogs.toLogs(),
+      publicInputs.accumulatedData.publicDataWrites.filter(w => !w.isEmpty()),
+    );
+
+    return new PublicTxResult(
+      /*gasUsed=*/ {
+        totalGas: context.getActualGasUsed(),
+        teardownGas: context.teardownGasUsed,
+        publicGas: context.getActualPublicGasUsed(),
+        billedGas: context.getTotalGasUsed(),
+      },
+      /*revertCode=*/ revertCode,
+      /*publicTxEffect=*/ publicTxEffect,
+      /*callStackMetadata=*/ appLogicReturnValues,
+      /*logs=*/ context.state.getActiveStateManager().getLogs(),
+      /*hints=*/ hints,
+      /*publicInputs=*/ publicInputs,
+    );
   }
 
   protected computeTxHash(tx: Tx) {
@@ -340,7 +316,7 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
     );
 
     if (result.reverted) {
-      const culprit = `${contractAddress}:${callRequest.functionSelector}`;
+      const culprit = `${contractAddress}:${fnName}`;
       context.revert(phase, result.revertReason, culprit);
     }
 
@@ -383,8 +359,7 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
       request.isStaticCall,
       calldata,
       allocatedGas,
-      this.config.clientInitiatedSimulation,
-      this.config.maxDebugLogMemoryReads,
+      this.config,
     );
     const avmCallResult = await simulator.execute();
     return avmCallResult.finalize();
@@ -393,7 +368,7 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
   /**
    * Insert the non-revertible accumulated data from private into the public state.
    */
-  protected async insertNonRevertiblesFromPrivate(context: PublicTxContext, tx: Tx) {
+  protected async insertNonRevertiblesFromPrivate(context: PublicTxContext) {
     const stateManager = context.state.getActiveStateManager();
 
     for (const siloedNullifier of context.nonRevertibleAccumulatedDataFromPrivate.nullifiers.filter(
@@ -412,11 +387,12 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
       }
     }
 
-    // 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?
-    // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
-    // However things should work as they are now because the hinted db would still pick up the new contracts.
-    await this.contractsDB.addNewNonRevertibleContracts(tx);
+    // add new contracts to the contracts db so that their code may be found and called
+    // FIXME(fcarreiro): this should conceptually use the hinting contracts db.
+    // However, things work as expected because later calls to getters on the hintingContractsDB
+    // will pick up the new contracts and will generate the necessary hints.
+    // So, a consumer of the hints will always see the new contracts.
+    await this.contractsDB.addContracts(context.nonRevertibleContractDeploymentData);
   }
 
   /**
@@ -428,7 +404,7 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
    * - NoteHashLimitReachedError
    * - L2ToL1MessageLimitReachedError
    */
-  protected async insertRevertiblesFromPrivate(context: PublicTxContext, tx: Tx) {
+  protected async insertRevertiblesFromPrivate(context: PublicTxContext) {
     const stateManager = context.state.getActiveStateManager();
 
     try {
@@ -497,16 +473,21 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
     }
 
     // add new contracts to the contracts db so that their functions may be found and called
-    // FIXME(fcarreiro): this should conceptually use the hinted contracts db.
-    // However things should work as they are now because the hinted db would still pick up the new contracts.
-    await this.contractsDB.addNewRevertibleContracts(tx);
+    // FIXME(fcarreiro): this should conceptually use the hinting contracts db.
+    // However, things work as expected because later calls to getters on the hintingContractsDB
+    // will pick up the new contracts and will generate the necessary hints.
+    // So, a consumer of the hints will always see the new contracts.
+    await this.contractsDB.addContracts(context.revertibleContractDeploymentData);
   }
 
   private async payFee(context: PublicTxContext) {
     const txFee = context.getTransactionFee(TxExecutionPhase.TEARDOWN);
 
     if (context.feePayer.isZero()) {
-      this.log.debug(`No one is paying the fee of ${txFee.toBigInt()}`);
+      // Real transactions are enforced by private kernel to have nonzero fee payer.
+      // Real transactions cannot skip fee enforcement (skipping fee enforcement makes them unprovable).
+      assert(this.config.skipFeeEnforcement, 'Fee payer cannot be 0 unless skipping fee enforcement for simulation');
+      this.log.debug(`Fee payer is 0. Skipping fee enforcement. No one is paying the fee of ${txFee.toBigInt()}`);
       return;
     }
 
@@ -526,23 +507,12 @@ export class PublicTxSimulator implements PublicTxSimulatorInterface {
         this.config.skipFeeEnforcement,
         `Not enough balance for fee payer to pay for transaction (got ${currentBalance.toBigInt()} needs ${txFee.toBigInt()})`,
       );
+      this.log.debug(`Fee payer balance insufficient, but we're skipping fee enforcement`);
+      // We still proceed and perform the storage write to minimize deviation from normal execution.
       currentBalance = txFee;
     }
 
     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(hints, publicInputs),
-    };
-  }
 }

package/src/public/public_tx_simulator/public_tx_simulator_interface.ts

@@ -1,11 +1,33 @@
+import type { PublicTxResult } from '@aztec/stdlib/avm';
 import type { Tx } from '@aztec/stdlib/tx';
 
-import type { PublicTxResult } from './public_tx_simulator.js';
-
 export interface PublicTxSimulatorInterface {
   simulate(tx: Tx): Promise<PublicTxResult>;
+  /**
+   * Cancel the current simulation if one is in progress.
+   * This signals the underlying simulator (e.g., C++) to stop at the next safe point.
+   * Safe to call even if no simulation is in progress.
+   * Optional - not all implementations support cancellation.
+   *
+   * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
+   *                        This is important because signaling cancellation doesn't immediately stop C++ -
+   *                        it only sets a flag that C++ checks at certain points. If C++ is in the middle
+   *                        of a slow operation (e.g., pad_trees), it won't stop until that completes.
+   * @returns Promise that resolves when cancellation is signaled (and optionally when simulation stops)
+   */
+  cancel?(waitTimeoutMs?: number): Promise<void>;
 }
 
 export interface MeasuredPublicTxSimulatorInterface {
   simulate(tx: Tx, txLabel: string): Promise<PublicTxResult>;
+  /**
+   * Cancel the current simulation if one is in progress.
+   * This signals the underlying simulator (e.g., C++) to stop at the next safe point.
+   * Safe to call even if no simulation is in progress.
+   * Optional - not all implementations support cancellation.
+   *
+   * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
+   * @returns Promise that resolves when cancellation is signaled (and optionally when simulation stops)
+   */
+  cancel?(waitTimeoutMs?: number): Promise<void>;
 }

package/src/public/public_tx_simulator/telemetry_public_tx_simulator.ts

@@ -1,4 +1,5 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import type { Gas } from '@aztec/stdlib/gas';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
 import { type GlobalVariables, PublicCallRequestWithCalldata, TxExecutionPhase } from '@aztec/stdlib/tx';
@@ -10,7 +11,6 @@ import type { PublicContractsDB } from '../public_db_sources.js';
 import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import { MeasuredPublicTxSimulator } from './measured_public_tx_simulator.js';
 import { PublicTxContext } from './public_tx_context.js';
-import type { PublicTxSimulatorConfig } from './public_tx_simulator.js';
 
 /**
  * A public tx simulator that tracks runtime/production metrics with telemetry.
@@ -24,7 +24,7 @@ export class TelemetryPublicTxSimulator extends MeasuredPublicTxSimulator {
     contractsDB: PublicContractsDB,
     globalVariables: GlobalVariables,
     telemetryClient: TelemetryClient = getTelemetryClient(),
-    config?: Partial<PublicTxSimulatorConfig>,
+    config?: Partial<PublicSimulatorConfig>,
   ) {
     const metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
     super(merkleTree, contractsDB, globalVariables, metrics, config);

package/src/public/side_effect_trace.ts

@@ -7,8 +7,8 @@ import {
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
 } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { type LogLevel, createLogger } from '@aztec/foundation/log';
 import { PublicDataUpdateRequest } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';

package/src/public/side_effect_trace_interface.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { LogLevel } from '@aztec/foundation/log';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { DebugLog } from '@aztec/stdlib/logs';

package/src/public/state_manager/nullifiers.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { PublicTreesDB } from '../public_db_sources.js';
 import { NullifierCollisionError } from '../side_effect_errors.js';

package/src/public/state_manager/public_storage.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
 import type { PublicStateDBInterface } from '../db_interfaces.js';

package/src/public/state_manager/state_manager.ts

@@ -1,16 +1,10 @@
-import {
-  CANONICAL_AUTH_REGISTRY_ADDRESS,
-  CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,
-  CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
-  FEE_JUICE_ADDRESS,
-  MULTI_CALL_ENTRYPOINT_ADDRESS,
-  ROUTER_ADDRESS,
-} from '@aztec/constants';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { type LogLevel, createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublicWithCommitment, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { SerializableContractInstance } from '@aztec/stdlib/contract';
@@ -26,7 +20,7 @@ import { strict as assert } from 'assert';
 
 import type { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
 import type { PublicContractsDBInterface } from '../db_interfaces.js';
-import { getPublicFunctionDebugName } from '../debug_fn_name.js';
+import { getPublicFunctionDebugName, getPublicFunctionSelectorAndName } from '../debug_fn_name.js';
 import type { PublicTreesDB } from '../public_db_sources.js';
 import {
   L1ToL2MessageIndexOutOfRangeError,
@@ -59,7 +53,7 @@ export class PublicPersistableStateManager {
     private readonly trace: PublicSideEffectTraceInterface,
     private readonly firstNullifier: Fr, // Needed for note hashes.
     private readonly timestamp: UInt64, // Needed for contract updates.
-    private readonly doMerkleOperations: boolean = false,
+    private readonly doMerkleOperations: boolean = true,
     private readonly publicStorage: PublicStorage = new PublicStorage(treesDB),
     private readonly nullifiers: NullifierManager = new NullifierManager(treesDB),
   ) {}
@@ -71,18 +65,10 @@ export class PublicPersistableStateManager {
     treesDB: PublicTreesDB,
     contractsDB: PublicContractsDBInterface,
     trace: PublicSideEffectTraceInterface,
-    doMerkleOperations: boolean = false,
     firstNullifier: Fr,
     timestamp: UInt64,
   ): PublicPersistableStateManager {
-    return new PublicPersistableStateManager(
-      treesDB,
-      contractsDB,
-      trace,
-      firstNullifier,
-      timestamp,
-      doMerkleOperations,
-    );
+    return new PublicPersistableStateManager(treesDB, contractsDB, trace, firstNullifier, timestamp);
   }
 
   /**
@@ -171,7 +157,6 @@ export class PublicPersistableStateManager {
     if (this.doMerkleOperations) {
       return await this.treesDB.storageRead(contractAddress, slot);
     } else {
-      // TODO(fcarreiro): I don't get this. PublicStorage CAN end up reading the tree. Why is it in the "dont do merkle operations" branch?
       const read = await this.publicStorage.read(contractAddress, slot);
       this.log.trace(
         `Storage read results (address=${contractAddress}, slot=${slot}): value=${read.value}, cached=${read.cached}`,
@@ -437,6 +422,8 @@ export class PublicPersistableStateManager {
         await this.readStorage(ProtocolContractAddress.ContractInstanceRegistry, storageSlot);
 
       const hash = await readDeployerStorage(delayedPublicMutableHashSlot);
+      // NOTE: The below reads are either not performed (if hash.isZero()) or only performed in unconstrained in c++ simulation.
+      // See UpdateCheck::check_current_class_id documentation - this means if we generate hints from the merkle db, they are unused:
       const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(
         delayedPublicMutableSlot,
         readDeployerStorage,
@@ -539,6 +526,12 @@ export class PublicPersistableStateManager {
     return await getPublicFunctionDebugName(this.contractsDB, avmEnvironment.address, avmEnvironment.calldata);
   }
 
+  public async getPublicFunctionSelectorAndName(
+    avmEnvironment: AvmExecutionEnvironment,
+  ): Promise<{ functionSelector?: FunctionSelector; functionName?: string }> {
+    return await getPublicFunctionSelectorAndName(this.contractsDB, avmEnvironment.address, avmEnvironment.calldata);
+  }
+
   public async padTree(treeId: MerkleTreeId, leavesToInsert: number): Promise<void> {
     await this.treesDB.padTree(treeId, leavesToInsert);
   }
@@ -549,12 +542,5 @@ export class PublicPersistableStateManager {
 }
 
 function contractAddressIsCanonical(contractAddress: AztecAddress): boolean {
-  return (
-    contractAddress.equals(AztecAddress.fromNumber(CANONICAL_AUTH_REGISTRY_ADDRESS)) ||
-    contractAddress.equals(AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS)) ||
-    contractAddress.equals(AztecAddress.fromNumber(CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS)) ||
-    contractAddress.equals(AztecAddress.fromNumber(MULTI_CALL_ENTRYPOINT_ADDRESS)) ||
-    contractAddress.equals(AztecAddress.fromNumber(FEE_JUICE_ADDRESS)) ||
-    contractAddress.equals(AztecAddress.fromNumber(ROUTER_ADDRESS))
-  );
+  return contractAddress.toBigInt() >= 1 && contractAddress.toBigInt() <= MAX_PROTOCOL_CONTRACTS;
 }