@aztec/simulator 1.2.0 → 2.0.0-nightly.20250813

package/src/public/public_tx_simulator/public_tx_simulator.ts

@@ -22,14 +22,11 @@ import {
   TxExecutionPhase,
 } from '@aztec/stdlib/tx';
 
-import { strict as assert } from 'assert';
-
 import type { AvmFinalizedCallResult } from '../avm/avm_contract_call_result.js';
 import { AvmSimulator } from '../avm/index.js';
 import { getPublicFunctionDebugName } from '../debug_fn_name.js';
 import { HintingMerkleWriteOperations, HintingPublicContractsDB } from '../hinting_db_sources.js';
 import { type PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
-import { NullifierCollisionError } from '../state_manager/nullifiers.js';
 import type { PublicPersistableStateManager } from '../state_manager/state_manager.js';
 import { PublicTxContext } from './public_tx_context.js';
 
@@ -72,11 +69,11 @@ export class PublicTxSimulator {
    */
   public async simulate(tx: Tx): Promise<PublicTxResult> {
     try {
-      const txHash = await this.computeTxHash(tx);
+      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(await AvmTxHint.fromTx(tx));
+      const hints = new AvmExecutionHints(this.globalVariables, AvmTxHint.fromTx(tx));
       const hintingMerkleTree = await HintingMerkleWriteOperations.create(this.merkleTree, hints);
       const hintingTreesDB = new PublicTreesDB(hintingMerkleTree);
       const hintingContractsDB = new HintingPublicContractsDB(this.contractsDB, hints);
@@ -89,31 +86,64 @@ export class PublicTxSimulator {
         this.doMerkleOperations,
       );
 
+      // This will throw if there is a nullifier collision.
+      // In that case the transaction will be thrown out.
       await this.insertNonRevertiblesFromPrivate(context, tx);
 
       const processedPhases: ProcessedPhase[] = [];
       if (context.hasPhase(TxExecutionPhase.SETUP)) {
-        const setupResult: ProcessedPhase = await this.simulateSetupPhase(context);
+        // 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 success = await this.insertRevertiblesFromPrivate(context, tx);
-      if (success) {
-        // Only proceed with app logic if there was no revert during revertible insertion
+      // 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.
+        await this.insertRevertiblesFromPrivate(context, tx);
+        // Only proceed with app logic if there was no revert during revertible insertion.
         if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
-          const appLogicResult: ProcessedPhase = await this.simulateAppLogicPhase(context);
+          const appLogicResult = await this.simulatePhase(TxExecutionPhase.APP_LOGIC, context);
           processedPhases.push(appLogicResult);
+          if (appLogicResult.reverted) {
+            throw new Error(`App logic phase reverted! ${appLogicResult.revertReason?.message}`);
+          }
         }
-      } else {
-        this.log.debug(`Revertible insertions failed. Skipping app logic.`);
+      } catch (e) {
+        this.log.debug(String(e));
+        // 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();
       }
 
-      if (context.hasPhase(TxExecutionPhase.TEARDOWN)) {
-        const teardownResult: ProcessedPhase = await this.simulateTeardownPhase(context);
-        processedPhases.push(teardownResult);
+      try {
+        if (context.hasPhase(TxExecutionPhase.TEARDOWN)) {
+          const teardownResult = await this.simulatePhase(TxExecutionPhase.TEARDOWN, context);
+          processedPhases.push(teardownResult);
+          if (teardownResult.reverted) {
+            throw new Error(`Teardown phase reverted! ${teardownResult.revertReason?.message}`);
+          }
+        }
+
+        // We commit the forked state and we are done.
+        await context.state.mergeForkedState();
+      } catch (e) {
+        this.log.debug(String(e));
+        // We rollback to the post-setup state.
+        await context.state.discardForkedState();
       }
 
-      await context.halt();
+      context.halt();
       await this.payFee(context);
 
       const publicInputs = await context.generateAvmCircuitPublicInputs();
@@ -149,8 +179,8 @@ export class PublicTxSimulator {
     }
   }
 
-  protected async computeTxHash(tx: Tx) {
-    return await tx.getTxHash();
+  protected computeTxHash(tx: Tx) {
+    return tx.getTxHash();
   }
 
   /**
@@ -158,64 +188,6 @@ export class PublicTxSimulator {
    * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
    * @returns The phase result.
    */
-  private async simulateSetupPhase(context: PublicTxContext): Promise<ProcessedPhase> {
-    return await this.simulatePhase(TxExecutionPhase.SETUP, context);
-  }
-
-  /**
-   * Simulate the app logic phase of a transaction's public execution.
-   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
-   * @returns The phase result.
-   */
-  private async simulateAppLogicPhase(context: PublicTxContext): Promise<ProcessedPhase> {
-    assert(context.state.isForked(), 'App logic phase should operate with forked state.');
-
-    const result = await this.simulatePhase(TxExecutionPhase.APP_LOGIC, context);
-
-    if (result.reverted) {
-      // Drop the currently active forked state manager and rollback to end of setup.
-      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.
-        await context.state.mergeForkedState();
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Simulate the teardown phase of a transaction's public execution.
-   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
-   * @returns The phase result.
-   */
-  private async simulateTeardownPhase(context: PublicTxContext): Promise<ProcessedPhase> {
-    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.
-      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.
-      await context.state.discardForkedState();
-    } else {
-      // Merge state updates from teardown,
-      await context.state.mergeForkedState();
-    }
-
-    return result;
-  }
-
-  /**
-   * Simulate a phase of a transaction's public execution.
-   * @param phase - The current phase
-   * @param context - WILL BE MUTATED. The context of the currently executing public transaction portion
-   * @returns The phase result.
-   */
   protected async simulatePhase(phase: TxExecutionPhase, context: PublicTxContext): Promise<ProcessedPhase> {
     const callRequests = context.getCallRequestsForPhase(phase);
 
@@ -287,7 +259,7 @@ export class PublicTxSimulator {
 
     if (result.reverted) {
       const culprit = `${contractAddress}:${callRequest.functionSelector}`;
-      context.revert(phase, result.revertReason, culprit); // throws if in setup (non-revertible) phase
+      context.revert(phase, result.revertReason, culprit);
     }
 
     return result;
@@ -340,18 +312,11 @@ export class PublicTxSimulator {
    */
   protected async insertNonRevertiblesFromPrivate(context: PublicTxContext, tx: Tx) {
     const stateManager = context.state.getActiveStateManager();
-    try {
-      for (const siloedNullifier of context.nonRevertibleAccumulatedDataFromPrivate.nullifiers.filter(
-        n => !n.isEmpty(),
-      )) {
-        await stateManager.writeSiloedNullifier(siloedNullifier);
-      }
-    } catch (e) {
-      if (e instanceof NullifierCollisionError) {
-        throw new NullifierCollisionError(
-          `Nullifier collision encountered when inserting non-revertible nullifiers from private.\nDetails: ${e.message}\nStack:${e.stack}`,
-        );
-      }
+
+    for (const siloedNullifier of context.nonRevertibleAccumulatedDataFromPrivate.nullifiers.filter(
+      n => !n.isEmpty(),
+    )) {
+      await stateManager.writeSiloedNullifier(siloedNullifier);
     }
     for (const noteHash of context.nonRevertibleAccumulatedDataFromPrivate.noteHashes) {
       if (!noteHash.isEmpty()) {
@@ -376,28 +341,21 @@ export class PublicTxSimulator {
    * Start by forking state so we can rollback to the end of setup if app logic or teardown reverts.
    */
   protected async insertRevertiblesFromPrivate(context: PublicTxContext, tx: Tx): /*success=*/ Promise<boolean> {
-    // Fork the state manager so we can rollback to end of setup if app logic reverts.
-    await context.state.fork();
     const stateManager = context.state.getActiveStateManager();
+
     try {
       for (const siloedNullifier of context.revertibleAccumulatedDataFromPrivate.nullifiers.filter(n => !n.isEmpty())) {
         await stateManager.writeSiloedNullifier(siloedNullifier);
       }
     } catch (e) {
-      if (e instanceof NullifierCollisionError) {
-        // Instead of throwing, revert the app_logic phase
-        context.revert(
-          TxExecutionPhase.APP_LOGIC,
-          new SimulationError(
-            `Nullifier collision encountered when inserting revertible nullifiers from private\nDetails: ${e.message}\nError stack: ${e.stack}`,
-            [],
-          ),
-          /*culprit=*/ 'insertRevertiblesFromPrivate',
-        );
-        return /*success=*/ false;
-      } else {
-        throw e;
-      }
+      context.revert(
+        TxExecutionPhase.APP_LOGIC,
+        new SimulationError(
+          `Nullifier collision encountered when inserting revertible nullifiers from private.\nDetails: ${String(e)}`,
+          [],
+        ),
+      );
+      throw e;
     }
     for (const noteHash of context.revertibleAccumulatedDataFromPrivate.noteHashes) {
       if (!noteHash.isEmpty()) {

package/src/public/side_effect_trace.ts

@@ -113,8 +113,6 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
 
     this.sideEffectCounter = forkedTrace.sideEffectCounter;
     this.uniqueClassIds.acceptAndMerge(forkedTrace.uniqueClassIds);
-    // Accept even if reverted, since the user already paid for the writes
-    this.writtenPublicDataSlots = new Set(forkedTrace.writtenPublicDataSlots);
 
     if (!reverted) {
       this.publicDataWrites.push(...forkedTrace.publicDataWrites);
@@ -122,6 +120,11 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
       this.nullifiers.push(...forkedTrace.nullifiers);
       this.l2ToL1Messages.push(...forkedTrace.l2ToL1Messages);
       this.publicLogs.push(...forkedTrace.publicLogs);
+      this.userPublicDataWritesLength += forkedTrace.userPublicDataWritesLength;
+      this.protocolPublicDataWritesLength += forkedTrace.protocolPublicDataWritesLength;
+      for (const slot of forkedTrace.writtenPublicDataSlots) {
+        this.writtenPublicDataSlots.add(slot);
+      }
     }
   }
 
@@ -143,28 +146,31 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     value: Fr,
     protocolWrite: boolean,
   ): Promise<void> {
-    if (protocolWrite) {
-      if (
-        this.protocolPublicDataWritesLength + this.previousSideEffectArrayLengths.protocolPublicDataWrites >=
-        PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
-      ) {
-        throw new SideEffectLimitReachedError(
-          'protocol public data (contract storage) write',
-          PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-        );
-      }
-      this.protocolPublicDataWritesLength++;
-    } else {
-      if (
-        this.userPublicDataWritesLength + this.previousSideEffectArrayLengths.publicDataWrites >=
-        MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
-      ) {
-        throw new SideEffectLimitReachedError(
-          'public data (contract storage) write',
-          MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-        );
+    // Only increment counts if the storage slot has not been written to before.
+    if (this.isStorageCold(contractAddress, slot)) {
+      if (protocolWrite) {
+        if (
+          this.protocolPublicDataWritesLength + this.previousSideEffectArrayLengths.protocolPublicDataWrites >=
+          PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+        ) {
+          throw new SideEffectLimitReachedError(
+            'protocol public data (contract storage) write',
+            PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+          );
+        }
+        this.protocolPublicDataWritesLength++;
+      } else {
+        if (
+          this.userPublicDataWritesLength + this.previousSideEffectArrayLengths.publicDataWrites >=
+          MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+        ) {
+          throw new SideEffectLimitReachedError(
+            'public data (contract storage) write',
+            MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+          );
+        }
+        this.userPublicDataWritesLength++;
       }
-      this.userPublicDataWritesLength++;
     }
 
     const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);

package/src/public/state_manager/state_manager.ts

@@ -1,9 +1,9 @@
 import {
   CANONICAL_AUTH_REGISTRY_ADDRESS,
-  DEPLOYER_CONTRACT_ADDRESS,
+  CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,
+  CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
   FEE_JUICE_ADDRESS,
   MULTI_CALL_ENTRYPOINT_ADDRESS,
-  REGISTERER_CONTRACT_ADDRESS,
   ROUTER_ADDRESS,
 } from '@aztec/constants';
 import { poseidon2Hash } from '@aztec/foundation/crypto';
@@ -14,9 +14,9 @@ import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublicWithCommitment, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { SerializableContractInstance } from '@aztec/stdlib/contract';
+import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
 import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
 import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
-import { SharedMutableValues, SharedMutableValuesWithHash } from '@aztec/stdlib/shared-mutable';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import type { TreeSnapshots } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
@@ -182,8 +182,8 @@ export class PublicPersistableStateManager {
    * @param leafIndex - the leaf index being checked
    * @returns true if the note hash exists at the given leaf index, false otherwise
    */
-  public async checkNoteHashExists(contractAddress: AztecAddress, noteHash: Fr, leafIndex: Fr): Promise<boolean> {
-    const gotLeafValue = await this.treesDB.getNoteHash(leafIndex.toBigInt());
+  public async checkNoteHashExists(contractAddress: AztecAddress, noteHash: Fr, leafIndex: bigint): Promise<boolean> {
+    const gotLeafValue = await this.treesDB.getNoteHash(leafIndex);
     const exists = gotLeafValue !== undefined && gotLeafValue.equals(noteHash);
     this.log.trace(
       `noteHashes(${contractAddress})@${noteHash} ?? leafIndex: ${leafIndex} | gotLeafValue: ${gotLeafValue}, exists: ${exists}.`,
@@ -353,7 +353,7 @@ export class PublicPersistableStateManager {
 
     // This will decide internally whether to check the nullifier tree or not depending on doMerkleOperations.
     const nullifierExistsInTree = await this.checkNullifierExists(
-      AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
+      AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
       contractAddress.toField(),
     );
     assert(
@@ -375,23 +375,25 @@ export class PublicPersistableStateManager {
     // All failures are fatal and the simulation is not expected to be provable.
     if (this.doMerkleOperations) {
       // Conceptually, we want to do the following:
-      // * Read a SharedMutable at the contract update slot.
-      // * Obtain the expected current class id from the SharedMutable, at the current block.
+      // * Read a DelayedPublicMutable at the contract update slot.
+      // * Obtain the expected current class id from the DelayedPublicMutable, at the current block.
       // * if expectedId == 0 then currentClassId should be original contract class id
       // * if expectedId != 0 then currentClassId should be expectedId
       //
-      // However, we will also be checking the hash of the shared mutable values.
+      // However, we will also be checking the hash of the delayed public mutable values.
       // This is a bit of a leak of information, since the circuit will use it to prove
-      // one public read insted of N of the shared mutable values.
-      const { sharedMutableSlot, sharedMutableHashSlot } = await SharedMutableValuesWithHash.getContractUpdateSlots(
-        instance.address,
-      );
+      // one public read insted of N of the delayed public mutable values.
+      const { delayedPublicMutableSlot, delayedPublicMutableHashSlot } =
+        await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(instance.address);
       const readDeployerStorage = async (storageSlot: Fr) =>
-        await this.readStorage(ProtocolContractAddress.ContractInstanceDeployer, storageSlot);
+        await this.readStorage(ProtocolContractAddress.ContractInstanceRegistry, storageSlot);
 
-      const hash = await readDeployerStorage(sharedMutableHashSlot);
-      const sharedMutableValues = await SharedMutableValues.readFromTree(sharedMutableSlot, readDeployerStorage);
-      const preImage = sharedMutableValues.toFields();
+      const hash = await readDeployerStorage(delayedPublicMutableHashSlot);
+      const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(
+        delayedPublicMutableSlot,
+        readDeployerStorage,
+      );
+      const preImage = delayedPublicMutableValues.toFields();
 
       // 1) update never scheduled: hash == 0 and preimage should be empty (but poseidon2hash(preimage) will not be 0s)
       if (hash.isZero()) {
@@ -410,11 +412,11 @@ export class PublicPersistableStateManager {
       const computedHash = await poseidon2Hash(preImage);
       assert(
         hash.equals(computedHash),
-        `Shared mutable values hash mismatch for contract instance ${instance.address}. Expected: ${hash}, computed: ${computedHash}`,
+        `Delayed public mutable values hash mismatch for contract instance ${instance.address}. Expected: ${hash}, computed: ${computedHash}`,
       );
 
       // We now check that, depending on the current block, the current class id is correct.
-      const expectedClassIdRaw = sharedMutableValues.svc.getCurrentAt(this.timestamp).at(0)!;
+      const expectedClassIdRaw = delayedPublicMutableValues.svc.getCurrentAt(this.timestamp).at(0)!;
       const expectedClassId = expectedClassIdRaw.isZero() ? instance.originalContractClassId : expectedClassIdRaw;
       assert(
         instance.currentContractClassId.equals(expectedClassId),
@@ -493,8 +495,8 @@ export class PublicPersistableStateManager {
 function contractAddressIsCanonical(contractAddress: AztecAddress): boolean {
   return (
     contractAddress.equals(AztecAddress.fromNumber(CANONICAL_AUTH_REGISTRY_ADDRESS)) ||
-    contractAddress.equals(AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS)) ||
-    contractAddress.equals(AztecAddress.fromNumber(REGISTERER_CONTRACT_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))