@aztec/simulator 0.62.0 → 0.63.1

package/src/avm/journal/journal.ts

@@ -1,11 +1,18 @@
+import { type IndexedTreeId, MerkleTreeId, type MerkleTreeWriteOperations } from '@aztec/circuit-types';
 import {
-  AztecAddress,
+  type AztecAddress,
   type Gas,
+  type NullifierLeafPreimage,
+  type PublicCallRequest,
+  PublicDataTreeLeaf,
+  PublicDataTreeLeafPreimage,
   SerializableContractInstance,
   computePublicBytecodeCommitment,
 } from '@aztec/circuits.js';
+import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/circuits.js/hash';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { type IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
 
 import assert from 'assert';
 
@@ -29,17 +36,31 @@ import { PublicStorage } from './public_storage.js';
 export class AvmPersistableStateManager {
   private readonly log = createDebugLogger('aztec:avm_simulator:state_manager');
 
+  /** Interface to perform merkle tree operations */
+  public merkleTrees: MerkleTreeWriteOperations;
+
+  /** Make sure a forked state is never merged twice. */
+  private alreadyMergedIntoParent = false;
+
   constructor(
     /** Reference to node storage */
     private readonly worldStateDB: WorldStateDB,
     /** Side effect trace */
-    private readonly trace: PublicSideEffectTraceInterface,
-    /** Public storage, including cached writes */
     // TODO(5818): make private once no longer accessed in executor
-    public readonly publicStorage: PublicStorage,
+    public readonly trace: PublicSideEffectTraceInterface,
+    /** Public storage, including cached writes */
+    private readonly publicStorage: PublicStorage = new PublicStorage(worldStateDB),
     /** Nullifier set, including cached/recently-emitted nullifiers */
-    private readonly nullifiers: NullifierManager,
-  ) {}
+    private readonly nullifiers: NullifierManager = new NullifierManager(worldStateDB),
+    private readonly doMerkleOperations: boolean = false,
+    merkleTrees?: MerkleTreeWriteOperations,
+  ) {
+    if (merkleTrees) {
+      this.merkleTrees = merkleTrees;
+    } else {
+      this.merkleTrees = worldStateDB.getMerkleInterface();
+    }
+  }
 
   /**
    * Create a new state manager with some preloaded pending siloed nullifiers
@@ -67,9 +88,40 @@ export class AvmPersistableStateManager {
       this.trace.fork(),
       this.publicStorage.fork(),
       this.nullifiers.fork(),
+      this.doMerkleOperations,
     );
   }
 
+  /**
+   * Accept forked world state modifications & traced side effects / hints
+   */
+  public merge(forkedState: AvmPersistableStateManager) {
+    this._merge(forkedState, /*reverted=*/ false);
+  }
+
+  /**
+   * Reject forked world state modifications & traced side effects, keep traced hints
+   */
+  public reject(forkedState: AvmPersistableStateManager) {
+    this._merge(forkedState, /*reverted=*/ true);
+  }
+
+  /**
+   * Commit cached storage writes to the DB.
+   * Keeps public storage up to date from tx to tx within a block.
+   */
+  public async commitStorageWritesToDB() {
+    await this.publicStorage.commitToDB();
+  }
+
+  private _merge(forkedState: AvmPersistableStateManager, reverted: boolean) {
+    // sanity check to avoid merging the same forked trace twice
+    assert(!this.alreadyMergedIntoParent, 'Cannot merge forked state that has already been merged into its parent!');
+    this.publicStorage.acceptAndMerge(forkedState.publicStorage);
+    this.nullifiers.acceptAndMerge(forkedState.nullifiers);
+    this.trace.merge(forkedState.trace, reverted);
+  }
+
   /**
    * Write to public storage, journal/trace the write.
    *
@@ -77,11 +129,46 @@ export class AvmPersistableStateManager {
    * @param slot - the slot in the contract's storage being written to
    * @param value - the value being written to the slot
    */
-  public writeStorage(contractAddress: Fr, slot: Fr, value: Fr) {
+  public async writeStorage(contractAddress: AztecAddress, slot: Fr, value: Fr): Promise<void> {
     this.log.debug(`Storage write (address=${contractAddress}, slot=${slot}): value=${value}`);
     // Cache storage writes for later reference/reads
     this.publicStorage.write(contractAddress, slot, value);
-    this.trace.tracePublicStorageWrite(contractAddress, slot, value);
+    const leafSlot = computePublicDataTreeLeafSlot(contractAddress, slot);
+    if (this.doMerkleOperations) {
+      const result = await this.merkleTrees.batchInsert(
+        MerkleTreeId.PUBLIC_DATA_TREE,
+        [new PublicDataTreeLeaf(leafSlot, value).toBuffer()],
+        0,
+      );
+      assert(result !== undefined, 'Public data tree insertion error. You might want to disable skipMerkleOperations.');
+      this.log.debug(`Inserted public data tree leaf at leafSlot ${leafSlot}, value: ${value}`);
+
+      const lowLeafInfo = result.lowLeavesWitnessData![0];
+      const lowLeafPreimage = lowLeafInfo.leafPreimage as PublicDataTreeLeafPreimage;
+      const lowLeafIndex = lowLeafInfo.index;
+      const lowLeafPath = lowLeafInfo.siblingPath.toFields();
+
+      const insertionPath = result.newSubtreeSiblingPath.toFields();
+      const newLeafPreimage = new PublicDataTreeLeafPreimage(
+        leafSlot,
+        value,
+        lowLeafPreimage.nextSlot,
+        lowLeafPreimage.nextIndex,
+      );
+      // FIXME: Why do we need to hint both preimages for public data writes, but not for nullifier insertions?
+      this.trace.tracePublicStorageWrite(
+        contractAddress,
+        slot,
+        value,
+        lowLeafPreimage,
+        new Fr(lowLeafIndex),
+        lowLeafPath,
+        newLeafPreimage,
+        insertionPath,
+      );
+    } else {
+      this.trace.tracePublicStorageWrite(contractAddress, slot, value);
+    }
   }
 
   /**
@@ -91,12 +178,46 @@ export class AvmPersistableStateManager {
    * @param slot - the slot in the contract's storage being read from
    * @returns the latest value written to slot, or 0 if never written to before
    */
-  public async readStorage(contractAddress: Fr, slot: Fr): Promise<Fr> {
+  public async readStorage(contractAddress: AztecAddress, slot: Fr): Promise<Fr> {
     const { value, exists, cached } = await this.publicStorage.read(contractAddress, slot);
     this.log.debug(
       `Storage read  (address=${contractAddress}, slot=${slot}): value=${value}, exists=${exists}, cached=${cached}`,
     );
-    this.trace.tracePublicStorageRead(contractAddress, slot, value, exists, cached);
+
+    const leafSlot = computePublicDataTreeLeafSlot(contractAddress, slot);
+
+    if (this.doMerkleOperations) {
+      // Get leaf if present, low leaf if absent
+      // If leaf is present, hint/trace it. Otherwise, hint/trace the low leaf.
+      const [leafIndex, leafPreimage, leafPath, _alreadyPresent] = await getLeafOrLowLeaf<PublicDataTreeLeafPreimage>(
+        MerkleTreeId.PUBLIC_DATA_TREE,
+        leafSlot.toBigInt(),
+        this.merkleTrees,
+      );
+      // FIXME: cannot have this assertion until "caching" is done via ephemeral merkle writes
+      //assert(alreadyPresent == exists, 'WorldStateDB contains public data leaf, but merkle tree does not.... This is a bug!');
+      this.log.debug(
+        `leafPreimage.nextSlot: ${leafPreimage.nextSlot}, leafPreimage.nextIndex: ${Number(leafPreimage.nextIndex)}`,
+      );
+      this.log.debug(`leafPreimage.slot: ${leafPreimage.slot}, leafPreimage.value: ${leafPreimage.value}`);
+
+      if (!exists) {
+        // Sanity check that the leaf slot is skipped by low leaf when it doesn't exist
+        assert(
+          leafSlot.toBigInt() > leafPreimage.slot.toBigInt() && leafSlot.toBigInt() < leafPreimage.nextSlot.toBigInt(),
+          'Public data tree low leaf should skip the target leaf slot when the target leaf does not exist.',
+        );
+      }
+      this.log.debug(
+        `Tracing storage leaf preimage slot=${slot}, leafSlot=${leafSlot}, value=${value}, nextKey=${leafPreimage.nextSlot}, nextIndex=${leafPreimage.nextIndex}`,
+      );
+      // On non-existence, AVM circuit will need to recognize that leafPreimage.slot != leafSlot,
+      // prove that this is a low leaf that skips leafSlot, and then prove memebership of the leaf.
+      this.trace.tracePublicStorageRead(contractAddress, slot, value, leafPreimage, new Fr(leafIndex), leafPath);
+    } else {
+      this.trace.tracePublicStorageRead(contractAddress, slot, value);
+    }
+
     return Promise.resolve(value);
   }
 
@@ -107,7 +228,7 @@ export class AvmPersistableStateManager {
    * @param slot - the slot in the contract's storage being read from
    * @returns the latest value written to slot, or 0 if never written to before
    */
-  public async peekStorage(contractAddress: Fr, slot: Fr): Promise<Fr> {
+  public async peekStorage(contractAddress: AztecAddress, slot: Fr): Promise<Fr> {
     const { value, exists, cached } = await this.publicStorage.read(contractAddress, slot);
     this.log.debug(
       `Storage peek  (address=${contractAddress}, slot=${slot}): value=${value}, exists=${exists}, cached=${cached}`,
@@ -124,15 +245,20 @@ export class AvmPersistableStateManager {
    * @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: Fr, noteHash: Fr, leafIndex: Fr): Promise<boolean> {
+  public async checkNoteHashExists(contractAddress: AztecAddress, noteHash: Fr, leafIndex: Fr): Promise<boolean> {
     const gotLeafValue = (await this.worldStateDB.getCommitmentValue(leafIndex.toBigInt())) ?? Fr.ZERO;
     const exists = gotLeafValue.equals(noteHash);
     this.log.debug(
       `noteHashes(${contractAddress})@${noteHash} ?? leafIndex: ${leafIndex} | gotLeafValue: ${gotLeafValue}, exists: ${exists}.`,
     );
-    // TODO(8287): We still return exists here, but we need to transmit both the requested noteHash and the gotLeafValue
-    // such that the VM can constrain the equality and decide on exists based on that.
-    this.trace.traceNoteHashCheck(contractAddress, gotLeafValue, leafIndex, exists);
+    if (this.doMerkleOperations) {
+      // TODO(8287): We still return exists here, but we need to transmit both the requested noteHash and the gotLeafValue
+      // such that the VM can constrain the equality and decide on exists based on that.
+      const path = await this.merkleTrees.getSiblingPath(MerkleTreeId.NOTE_HASH_TREE, leafIndex.toBigInt());
+      this.trace.traceNoteHashCheck(contractAddress, gotLeafValue, leafIndex, exists, path.toFields());
+    } else {
+      this.trace.traceNoteHashCheck(contractAddress, gotLeafValue, leafIndex, exists);
+    }
     return Promise.resolve(exists);
   }
 
@@ -140,9 +266,22 @@ export class AvmPersistableStateManager {
    * Write a note hash, trace the write.
    * @param noteHash - the unsiloed note hash to write
    */
-  public writeNoteHash(contractAddress: Fr, noteHash: Fr) {
+  public async writeNoteHash(contractAddress: AztecAddress, noteHash: Fr): Promise<void> {
     this.log.debug(`noteHashes(${contractAddress}) += @${noteHash}.`);
-    this.trace.traceNewNoteHash(contractAddress, noteHash);
+
+    if (this.doMerkleOperations) {
+      // TODO: We should track this globally here in the state manager
+      const info = await this.merkleTrees.getTreeInfo(MerkleTreeId.NOTE_HASH_TREE);
+      const leafIndex = new Fr(info.size + 1n);
+
+      const path = await this.merkleTrees.getSiblingPath(MerkleTreeId.NOTE_HASH_TREE, leafIndex.toBigInt());
+      const siloedNoteHash = siloNoteHash(contractAddress, noteHash);
+
+      await this.merkleTrees.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, [siloedNoteHash]);
+      this.trace.traceNewNoteHash(contractAddress, noteHash, leafIndex, path.toFields());
+    } else {
+      this.trace.traceNewNoteHash(contractAddress, noteHash);
+    }
   }
 
   /**
@@ -151,12 +290,52 @@ export class AvmPersistableStateManager {
    * @param nullifier - the unsiloed nullifier to check
    * @returns exists - whether the nullifier exists in the nullifier set
    */
-  public async checkNullifierExists(contractAddress: Fr, nullifier: Fr): Promise<boolean> {
-    const [exists, isPending, leafIndex] = await this.nullifiers.checkExists(contractAddress, nullifier);
-    this.log.debug(
-      `nullifiers(${contractAddress})@${nullifier} ?? leafIndex: ${leafIndex}, exists: ${exists}, pending: ${isPending}.`,
-    );
-    this.trace.traceNullifierCheck(contractAddress, nullifier, leafIndex, exists, isPending);
+  public async checkNullifierExists(contractAddress: AztecAddress, nullifier: Fr): Promise<boolean> {
+    const [exists, isPending, _] = await this.nullifiers.checkExists(contractAddress, nullifier);
+
+    const siloedNullifier = siloNullifier(contractAddress, nullifier);
+
+    if (this.doMerkleOperations) {
+      // Get leaf if present, low leaf if absent
+      // If leaf is present, hint/trace it. Otherwise, hint/trace the low leaf.
+      const [leafIndex, leafPreimage, leafPath, alreadyPresent] = await getLeafOrLowLeaf<NullifierLeafPreimage>(
+        MerkleTreeId.NULLIFIER_TREE,
+        siloedNullifier.toBigInt(),
+        this.merkleTrees,
+      );
+      assert(
+        alreadyPresent == exists,
+        'WorldStateDB contains nullifier leaf, but merkle tree does not.... This is a bug!',
+      );
+
+      this.log.debug(
+        `nullifiers(${contractAddress})@${nullifier} ?? leafIndex: ${leafIndex}, exists: ${exists}, pending: ${isPending}.`,
+      );
+
+      if (!exists) {
+        // Sanity check that the leaf value is skipped by low leaf when it doesn't exist
+        assert(
+          siloedNullifier.toBigInt() > leafPreimage.nullifier.toBigInt() &&
+            siloedNullifier.toBigInt() < leafPreimage.nextNullifier.toBigInt(),
+          'Nullifier tree low leaf should skip the target leaf nullifier when the target leaf does not exist.',
+        );
+      }
+
+      this.trace.traceNullifierCheck(
+        contractAddress,
+        nullifier, // FIXME: Should this be siloed?
+        exists,
+        leafPreimage,
+        new Fr(leafIndex),
+        leafPath,
+      );
+    } else {
+      this.trace.traceNullifierCheck(
+        contractAddress,
+        nullifier, // FIXME: Should this be siloed?
+        exists,
+      );
+    }
     return Promise.resolve(exists);
   }
 
@@ -165,12 +344,44 @@ export class AvmPersistableStateManager {
    * @param contractAddress - address of the contract that the nullifier is associated with
    * @param nullifier - the unsiloed nullifier to write
    */
-  public async writeNullifier(contractAddress: Fr, nullifier: Fr) {
+  public async writeNullifier(contractAddress: AztecAddress, nullifier: Fr) {
     this.log.debug(`nullifiers(${contractAddress}) += ${nullifier}.`);
     // Cache pending nullifiers for later access
     await this.nullifiers.append(contractAddress, nullifier);
-    // Trace all nullifier creations (even reverted ones)
-    this.trace.traceNewNullifier(contractAddress, nullifier);
+
+    const siloedNullifier = siloNullifier(contractAddress, nullifier);
+
+    if (this.doMerkleOperations) {
+      // Trace all nullifier creations, even duplicate insertions that fail
+      const alreadyPresent = await this.merkleTrees.getPreviousValueIndex(
+        MerkleTreeId.NULLIFIER_TREE,
+        siloedNullifier.toBigInt(),
+      );
+      if (alreadyPresent) {
+        this.log.verbose(`Nullifier already present in tree: ${nullifier} at index ${alreadyPresent.index}.`);
+      }
+      const insertionResult = await this.merkleTrees.batchInsert(
+        MerkleTreeId.NULLIFIER_TREE,
+        [siloedNullifier.toBuffer()],
+        0,
+      );
+      const lowLeafInfo = insertionResult.lowLeavesWitnessData![0];
+      const lowLeafPreimage = lowLeafInfo.leafPreimage as NullifierLeafPreimage;
+      const lowLeafIndex = lowLeafInfo.index;
+      const lowLeafPath = lowLeafInfo.siblingPath.toFields();
+      const insertionPath = insertionResult.newSubtreeSiblingPath.toFields();
+
+      this.trace.traceNewNullifier(
+        contractAddress,
+        nullifier,
+        lowLeafPreimage,
+        new Fr(lowLeafIndex),
+        lowLeafPath,
+        insertionPath,
+      );
+    } else {
+      this.trace.traceNewNullifier(contractAddress, nullifier);
+    }
   }
 
   /**
@@ -179,15 +390,25 @@ export class AvmPersistableStateManager {
    * @param msgLeafIndex - the message leaf index to use in the check
    * @returns exists - whether the message exists in the L1 to L2 Messages tree
    */
-  public async checkL1ToL2MessageExists(contractAddress: Fr, msgHash: Fr, msgLeafIndex: Fr): Promise<boolean> {
+  public async checkL1ToL2MessageExists(
+    contractAddress: AztecAddress,
+    msgHash: Fr,
+    msgLeafIndex: Fr,
+  ): Promise<boolean> {
     const valueAtIndex = (await this.worldStateDB.getL1ToL2LeafValue(msgLeafIndex.toBigInt())) ?? Fr.ZERO;
     const exists = valueAtIndex.equals(msgHash);
     this.log.debug(
       `l1ToL2Messages(@${msgLeafIndex}) ?? exists: ${exists}, expected: ${msgHash}, found: ${valueAtIndex}.`,
     );
-    // TODO(8287): We still return exists here, but we need to transmit both the requested msgHash and the value
-    // such that the VM can constrain the equality and decide on exists based on that.
-    this.trace.traceL1ToL2MessageCheck(contractAddress, valueAtIndex, msgLeafIndex, exists);
+
+    if (this.doMerkleOperations) {
+      // TODO(8287): We still return exists here, but we need to transmit both the requested msgHash and the value
+      // such that the VM can constrain the equality and decide on exists based on that.
+      const path = await this.merkleTrees.getSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, msgLeafIndex.toBigInt());
+      this.trace.traceL1ToL2MessageCheck(contractAddress, valueAtIndex, msgLeafIndex, exists, path.toFields());
+    } else {
+      this.trace.traceL1ToL2MessageCheck(contractAddress, valueAtIndex, msgLeafIndex, exists);
+    }
     return Promise.resolve(exists);
   }
 
@@ -197,7 +418,7 @@ export class AvmPersistableStateManager {
    * @param recipient - L1 contract address to send the message to.
    * @param content - Message content.
    */
-  public writeL2ToL1Message(contractAddress: Fr, recipient: Fr, content: Fr) {
+  public writeL2ToL1Message(contractAddress: AztecAddress, recipient: Fr, content: Fr) {
     this.log.debug(`L2ToL1Messages(${contractAddress}) += (recipient: ${recipient}, content: ${content}).`);
     this.trace.traceNewL2ToL1Message(contractAddress, recipient, content);
   }
@@ -208,7 +429,7 @@ export class AvmPersistableStateManager {
    * @param event - log event selector
    * @param log - log contents
    */
-  public writeUnencryptedLog(contractAddress: Fr, log: Fr[]) {
+  public writeUnencryptedLog(contractAddress: AztecAddress, log: Fr[]) {
     this.log.debug(`UnencryptedL2Log(${contractAddress}) += event with ${log.length} fields.`);
     this.trace.traceUnencryptedLog(contractAddress, log);
   }
@@ -218,11 +439,12 @@ export class AvmPersistableStateManager {
    * @param contractAddress - address of the contract instance to retrieve.
    * @returns the contract instance or undefined if it does not exist.
    */
-  public async getContractInstance(contractAddress: Fr): Promise<SerializableContractInstance | undefined> {
+  public async getContractInstance(contractAddress: AztecAddress): Promise<SerializableContractInstance | undefined> {
     this.log.debug(`Getting contract instance for address ${contractAddress}`);
-    const instanceWithAddress = await this.worldStateDB.getContractInstance(AztecAddress.fromField(contractAddress));
+    const instanceWithAddress = await this.worldStateDB.getContractInstance(contractAddress);
     const exists = instanceWithAddress !== undefined;
 
+    // TODO: nullifier check!
     if (exists) {
       const instance = new SerializableContractInstance(instanceWithAddress);
       this.log.debug(
@@ -238,14 +460,6 @@ export class AvmPersistableStateManager {
     }
   }
 
-  /**
-   * Accept nested world state modifications
-   */
-  public acceptNestedCallState(nestedState: AvmPersistableStateManager) {
-    this.publicStorage.acceptAndMerge(nestedState.publicStorage);
-    this.nullifiers.acceptAndMerge(nestedState.nullifiers);
-  }
-
   /**
    * Get a contract's bytecode from the contracts DB, also trace the contract class and instance
    */
@@ -286,20 +500,14 @@ export class AvmPersistableStateManager {
     }
   }
 
-  /**
-   * Accept the nested call's state and trace the nested call
-   */
-  public async processNestedCall(
-    nestedState: AvmPersistableStateManager,
+  public async traceNestedCall(
+    forkedState: AvmPersistableStateManager,
     nestedEnvironment: AvmExecutionEnvironment,
     startGasLeft: Gas,
     endGasLeft: Gas,
     bytecode: Buffer,
     avmCallResults: AvmContractCallResult,
   ) {
-    if (!avmCallResults.reverted) {
-      this.acceptNestedCallState(nestedState);
-    }
     const functionName = await getPublicFunctionDebugName(
       this.worldStateDB,
       nestedEnvironment.address,
@@ -307,10 +515,10 @@ export class AvmPersistableStateManager {
       nestedEnvironment.calldata,
     );
 
-    this.log.verbose(`[AVM] Calling nested function ${functionName}`);
+    this.log.verbose(`[AVM] Tracing nested external contract call ${functionName}`);
 
     this.trace.traceNestedCall(
-      nestedState.trace,
+      forkedState.trace,
       nestedEnvironment,
       startGasLeft,
       endGasLeft,
@@ -319,4 +527,35 @@ export class AvmPersistableStateManager {
       functionName,
     );
   }
+
+  public traceEnqueuedCall(publicCallRequest: PublicCallRequest, calldata: Fr[], reverted: boolean) {
+    this.trace.traceEnqueuedCall(publicCallRequest, calldata, reverted);
+  }
+}
+
+/**
+ * Get leaf if present, low leaf if absent
+ */
+export async function getLeafOrLowLeaf<TreePreimageType extends IndexedTreeLeafPreimage>(
+  treeId: IndexedTreeId,
+  key: bigint,
+  merkleTrees: MerkleTreeWriteOperations,
+) {
+  // "key" is siloed slot (leafSlot) or siloed nullifier
+  const previousValueIndex = await merkleTrees.getPreviousValueIndex(treeId, key);
+  assert(
+    previousValueIndex !== undefined,
+    `${MerkleTreeId[treeId]} low leaf index should always be found (even if target leaf does not exist)`,
+  );
+  const { index: leafIndex, alreadyPresent } = previousValueIndex;
+
+  const leafPreimage = await merkleTrees.getLeafPreimage(treeId, leafIndex);
+  assert(
+    leafPreimage !== undefined,
+    `${MerkleTreeId[treeId]}  low leaf preimage should never be undefined (even if target leaf does not exist)`,
+  );
+
+  const leafPath = await merkleTrees.getSiblingPath(treeId, leafIndex);
+
+  return [leafIndex, leafPreimage as TreePreimageType, leafPath.toFields(), alreadyPresent] as const;
 }

package/src/avm/journal/nullifiers.ts

@@ -1,4 +1,4 @@
-import { AztecAddress } from '@aztec/circuits.js';
+import { type AztecAddress } from '@aztec/circuits.js';
 import { siloNullifier } from '@aztec/circuits.js/hash';
 import { Fr } from '@aztec/foundation/fields';
 
@@ -41,7 +41,7 @@ export class NullifierManager {
    * @param nullifier - the nullifier to check for
    * @returns exists: whether the nullifier exists in cache here or in parent's
    */
-  private checkExistsHereOrParent(contractAddress: Fr, nullifier: Fr): boolean {
+  private checkExistsHereOrParent(contractAddress: AztecAddress, nullifier: Fr): boolean {
     // First check this cache
     let existsAsPending = this.cache.exists(contractAddress, nullifier);
     // Then try parent's nullifier cache
@@ -66,7 +66,7 @@ export class NullifierManager {
    *          leafIndex: the nullifier's leaf index if it exists and is not pending (comes from host state).
    */
   public async checkExists(
-    contractAddress: Fr,
+    contractAddress: AztecAddress,
     nullifier: Fr,
   ): Promise<[/*exists=*/ boolean, /*isPending=*/ boolean, /*leafIndex=*/ Fr]> {
     // Check this cache and parent's (recursively)
@@ -89,7 +89,7 @@ export class NullifierManager {
    * @param contractAddress - the address of the contract that the nullifier is associated with
    * @param nullifier - the nullifier to stage
    */
-  public async append(contractAddress: Fr, nullifier: Fr) {
+  public async append(contractAddress: AztecAddress, nullifier: Fr) {
     const [exists, ,] = await this.checkExists(contractAddress, nullifier);
     if (exists) {
       throw new NullifierCollisionError(
@@ -139,10 +139,10 @@ export class NullifierCache {
    * @param nullifier - the nullifier to check existence of
    * @returns whether the nullifier is found in the cache
    */
-  public exists(contractAddress: Fr, nullifier: Fr): boolean {
+  public exists(contractAddress: AztecAddress, nullifier: Fr): boolean {
     const exists =
       this.cachePerContract.get(contractAddress.toBigInt())?.has(nullifier.toBigInt()) ||
-      this.siloedNullifiers.has(siloNullifier(AztecAddress.fromField(contractAddress), nullifier).toBigInt());
+      this.siloedNullifiers.has(siloNullifier(contractAddress, nullifier).toBigInt());
     return !!exists;
   }
 
@@ -152,7 +152,7 @@ export class NullifierCache {
    * @param contractAddress - the address of the contract that the nullifier is associated with
    * @param nullifier - the nullifier to stage
    */
-  public append(contractAddress: Fr, nullifier: Fr) {
+  public append(contractAddress: AztecAddress, nullifier: Fr) {
     if (this.exists(contractAddress, nullifier)) {
       throw new NullifierCollisionError(
         `Nullifier ${nullifier} at contract ${contractAddress} already exists in cache.`,

package/src/avm/journal/public_storage.ts

@@ -49,7 +49,7 @@ export class PublicStorage {
    * @param slot - the slot in the contract's storage being read from
    * @returns value: the latest value written according to this cache or the parent's. undefined on cache miss.
    */
-  public readHereOrParent(contractAddress: Fr, slot: Fr): Fr | undefined {
+  public readHereOrParent(contractAddress: AztecAddress, slot: Fr): Fr | undefined {
     // First try check this storage cache
     let value = this.cache.read(contractAddress, slot);
     // Then try parent's storage cache
@@ -71,7 +71,7 @@ export class PublicStorage {
    * @param slot - the slot in the contract's storage being read from
    * @returns exists: whether the slot has EVER been written to before, value: the latest value written to slot, or 0 if never written to before
    */
-  public async read(contractAddress: Fr, slot: Fr): Promise<PublicStorageReadResult> {
+  public async read(contractAddress: AztecAddress, slot: Fr): Promise<PublicStorageReadResult> {
     let cached = false;
     // Check this cache and parent's (recursively)
     let value = this.readHereOrParent(contractAddress, slot);
@@ -97,7 +97,7 @@ export class PublicStorage {
    * @param slot - the slot in the contract's storage being written to
    * @param value - the value being written to the slot
    */
-  public write(contractAddress: Fr, slot: Fr, value: Fr) {
+  public write(contractAddress: AztecAddress, slot: Fr, value: Fr) {
     this.cache.write(contractAddress, slot, value);
   }
 
@@ -143,7 +143,7 @@ class PublicStorageCache {
    * @param slot - the slot in the contract's storage being read from
    * @returns the latest value written to slot, or undefined if no value has been written
    */
-  public read(contractAddress: Fr, slot: Fr): Fr | undefined {
+  public read(contractAddress: AztecAddress, slot: Fr): Fr | undefined {
     return this.cachePerContract.get(contractAddress.toBigInt())?.get(slot.toBigInt());
   }
 
@@ -154,7 +154,7 @@ class PublicStorageCache {
    * @param slot - the slot in the contract's storage being written to
    * @param value - the value being written to the slot
    */
-  public write(contractAddress: Fr, slot: Fr, value: Fr) {
+  public write(contractAddress: AztecAddress, slot: Fr, value: Fr) {
     let cacheAtContract = this.cachePerContract.get(contractAddress.toBigInt());
     if (!cacheAtContract) {
       // If this contract's storage has no staged modifications, create a new inner map to store them

package/src/avm/opcodes/accrued_substate.ts

@@ -43,7 +43,6 @@ export class NoteHashExists extends Instruction {
     memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
 
     memory.assert({ reads: 2, writes: 1, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -71,10 +70,9 @@ export class EmitNoteHash extends Instruction {
     }
 
     const noteHash = memory.get(noteHashOffset).toFr();
-    context.persistableState.writeNoteHash(context.environment.address, noteHash);
+    await context.persistableState.writeNoteHash(context.environment.address, noteHash);
 
     memory.assert({ reads: 1, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -109,13 +107,12 @@ export class NullifierExists extends Instruction {
     memory.checkTags(TypeTag.FIELD, nullifierOffset, addressOffset);
 
     const nullifier = memory.get(nullifierOffset).toFr();
-    const address = memory.get(addressOffset).toFr();
+    const address = memory.get(addressOffset).toAztecAddress();
     const exists = await context.persistableState.checkNullifierExists(address, nullifier);
 
     memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
 
     memory.assert({ reads: 2, writes: 1, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -157,7 +154,6 @@ export class EmitNullifier extends Instruction {
     }
 
     memory.assert({ reads: 1, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -201,7 +197,6 @@ export class L1ToL2MessageExists extends Instruction {
     memory.set(existsOffset, exists ? new Uint1(1) : new Uint1(0));
 
     memory.assert({ reads: 2, writes: 1, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -236,7 +231,6 @@ export class EmitUnencryptedLog extends Instruction {
     context.persistableState.writeUnencryptedLog(contractAddress, log);
 
     memory.assert({ reads: 1 + logSize, addressing });
-    context.machineState.incrementPc();
   }
 }
 
@@ -261,12 +255,12 @@ export class SendL2ToL1Message extends Instruction {
     const operands = [this.recipientOffset, this.contentOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [recipientOffset, contentOffset] = addressing.resolve(operands, memory);
+    memory.checkTags(TypeTag.FIELD, recipientOffset, contentOffset);
 
     const recipient = memory.get(recipientOffset).toFr();
     const content = memory.get(contentOffset).toFr();
     context.persistableState.writeL2ToL1Message(context.environment.address, recipient, content);
 
     memory.assert({ reads: 2, addressing });
-    context.machineState.incrementPc();
   }
 }