@aztec/simulator 0.59.0 → 0.61.0

package/src/avm/avm_simulator.ts

@@ -6,6 +6,7 @@ import { strict as assert } from 'assert';
 import { SideEffectLimitReachedError } from '../public/side_effect_errors.js';
 import type { AvmContext } from './avm_context.js';
 import { AvmContractCallResult } from './avm_contract_call_result.js';
+import { type Gas } from './avm_gas.js';
 import { isAvmBytecode } from './bytecode_utils.js';
 import {
   AvmExecutionError,
@@ -17,9 +18,21 @@ import {
 import type { Instruction } from './opcodes/index.js';
 import { decodeFromBytecode } from './serialization/bytecode_serialization.js';
 
+type OpcodeTally = {
+  count: number;
+  gas: Gas;
+};
+type PcTally = {
+  opcode: string;
+  count: number;
+  gas: Gas;
+};
+
 export class AvmSimulator {
   private log: DebugLogger;
   private bytecode: Buffer | undefined;
+  public opcodeTallies: Map<string, OpcodeTally> = new Map();
+  public pcTallies: Map<number, PcTally> = new Map();
 
   constructor(private context: AvmContext) {
     assert(
@@ -33,10 +46,7 @@ export class AvmSimulator {
    * Fetch the bytecode and execute it in the current context.
    */
   public async execute(): Promise<AvmContractCallResult> {
-    const bytecode = await this.context.persistableState.getBytecode(
-      this.context.environment.address,
-      this.context.environment.functionSelector,
-    );
+    const bytecode = await this.context.persistableState.getBytecode(this.context.environment.address);
 
     // This assumes that we will not be able to send messages to accounts without code
     // Pending classes and instances impl details
@@ -75,6 +85,7 @@ export class AvmSimulator {
     try {
       // Execute instruction pointed to by the current program counter
       // continuing until the machine state signifies a halt
+      let instrCounter = 0;
       while (!machineState.getHalted()) {
         const instruction = instructions[machineState.pc];
         assert(
@@ -82,13 +93,26 @@ export class AvmSimulator {
           'AVM attempted to execute non-existent instruction. This should never happen (invalid bytecode or AVM simulator bug)!',
         );
 
-        const gasLeft = `l2=${machineState.l2GasLeft} da=${machineState.daGasLeft}`;
-        this.log.debug(`@${machineState.pc} ${instruction.toString()} (${gasLeft})`);
+        const instrStartGas = machineState.gasLeft; // Save gas before executing instruction (for profiling)
+        const instrPc = machineState.pc; // Save PC before executing instruction (for profiling)
+
+        this.log.debug(
+          `[PC:${machineState.pc}] [IC:${instrCounter++}] ${instruction.toString()} (gasLeft l2=${
+            machineState.l2GasLeft
+          } da=${machineState.daGasLeft})`,
+        );
         // Execute the instruction.
         // Normal returns and reverts will return normally here.
         // "Exceptional halts" will throw.
         await instruction.execute(this.context);
 
+        // gas used by this instruction - used for profiling/tallying
+        const gasUsed: Gas = {
+          l2Gas: instrStartGas.l2Gas - machineState.l2GasLeft,
+          daGas: instrStartGas.daGas - machineState.daGasLeft,
+        };
+        this.tallyInstruction(instrPc, instruction.constructor.name, gasUsed);
+
         if (machineState.pc >= instructions.length) {
           this.log.warn('Passed end of program');
           throw new InvalidProgramCounterError(machineState.pc, /*max=*/ instructions.length);
@@ -100,6 +124,8 @@ export class AvmSimulator {
       const revertReason = reverted ? revertReasonFromExplicitRevert(output, this.context) : undefined;
       const results = new AvmContractCallResult(reverted, output, revertReason);
       this.log.debug(`Context execution results: ${results.toString()}`);
+
+      this.printOpcodeTallies();
       // Return results for processing by calling context
       return results;
     } catch (err: any) {
@@ -113,8 +139,45 @@ export class AvmSimulator {
       // Note: "exceptional halts" cannot return data, hence []
       const results = new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], revertReason);
       this.log.debug(`Context execution results: ${results.toString()}`);
+
+      this.printOpcodeTallies();
       // Return results for processing by calling context
       return results;
     }
   }
+
+  private tallyInstruction(pc: number, opcode: string, gasUsed: Gas) {
+    const opcodeTally = this.opcodeTallies.get(opcode) || ({ count: 0, gas: { l2Gas: 0, daGas: 0 } } as OpcodeTally);
+    opcodeTally.count++;
+    opcodeTally.gas.l2Gas += gasUsed.l2Gas;
+    opcodeTally.gas.daGas += gasUsed.daGas;
+    this.opcodeTallies.set(opcode, opcodeTally);
+
+    const pcTally = this.pcTallies.get(pc) || ({ opcode: opcode, count: 0, gas: { l2Gas: 0, daGas: 0 } } as PcTally);
+    pcTally.count++;
+    pcTally.gas.l2Gas += gasUsed.l2Gas;
+    pcTally.gas.daGas += gasUsed.daGas;
+    this.pcTallies.set(pc, pcTally);
+  }
+
+  private printOpcodeTallies() {
+    this.log.debug(`Printing tallies per opcode sorted by gas...`);
+    // sort descending by L2 gas consumed
+    const sortedOpcodes = Array.from(this.opcodeTallies.entries()).sort((a, b) => b[1].gas.l2Gas - a[1].gas.l2Gas);
+    for (const [opcode, tally] of sortedOpcodes) {
+      // NOTE: don't care to clutter the logs with DA gas for now
+      this.log.debug(`${opcode} executed ${tally.count} times consuming a total of ${tally.gas.l2Gas} L2 gas`);
+    }
+
+    this.log.debug(`Printing tallies per PC sorted by #times each PC was executed...`);
+    const sortedPcs = Array.from(this.pcTallies.entries())
+      .sort((a, b) => b[1].count - a[1].count)
+      .filter((_, i) => i < 20);
+    for (const [pc, tally] of sortedPcs) {
+      // NOTE: don't care to clutter the logs with DA gas for now
+      this.log.debug(
+        `PC:${pc} containing opcode ${tally.opcode} executed ${tally.count} times consuming a total of ${tally.gas.l2Gas} L2 gas`,
+      );
+    }
+  }
 }

package/src/avm/fixtures/index.ts

@@ -58,14 +58,12 @@ export function initPersistableStateManager(overrides?: {
 export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnvironment>): AvmExecutionEnvironment {
   return new AvmExecutionEnvironment(
     overrides?.address ?? AztecAddress.zero(),
-    overrides?.storageAddress ?? AztecAddress.zero(),
     overrides?.sender ?? AztecAddress.zero(),
     overrides?.functionSelector ?? FunctionSelector.empty(),
     overrides?.contractCallDepth ?? Fr.zero(),
     overrides?.transactionFee ?? Fr.zero(),
     overrides?.globals ?? GlobalVariables.empty(),
     overrides?.isStaticCall ?? false,
-    overrides?.isDelegateCall ?? false,
     overrides?.calldata ?? [],
   );
 }
@@ -119,6 +117,13 @@ export function randomMemoryFields(length: number): Field[] {
   return [...Array(length)].map(_ => new Field(Fr.random()));
 }
 
+export function getAvmTestContractFunctionSelector(functionName: string): FunctionSelector {
+  const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
+  assert(!!artifact, `Function ${functionName} not found in AvmTestContractArtifact`);
+  const params = artifact.parameters;
+  return FunctionSelector.fromNameAndParameters(artifact.name, params);
+}
+
 export function getAvmTestContractBytecode(functionName: string): Buffer {
   const artifact = AvmTestContractArtifact.functions.find(f => f.name === functionName)!;
   assert(

package/src/avm/journal/journal.ts

@@ -1,10 +1,16 @@
-import { AztecAddress, type FunctionSelector, type Gas, SerializableContractInstance } from '@aztec/circuits.js';
+import {
+  AztecAddress,
+  type Gas,
+  SerializableContractInstance,
+  computePublicBytecodeCommitment,
+} from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 
+import assert from 'assert';
+
 import { getPublicFunctionDebugName } from '../../common/debug_fn_name.js';
 import { type WorldStateDB } from '../../public/public_db_sources.js';
-import { type TracedContractInstance } from '../../public/side_effect_trace.js';
 import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
 import { type AvmContractCallResult } from '../avm_contract_call_result.js';
 import { type AvmExecutionEnvironment } from '../avm_execution_environment.js';
@@ -67,44 +73,44 @@ export class AvmPersistableStateManager {
   /**
    * Write to public storage, journal/trace the write.
    *
-   * @param storageAddress - the address of the contract whose storage is being written to
+   * @param contractAddress - the address of the contract whose storage is being written to
    * @param slot - the slot in the contract's storage being written to
    * @param value - the value being written to the slot
    */
-  public writeStorage(storageAddress: Fr, slot: Fr, value: Fr) {
-    this.log.debug(`Storage write (address=${storageAddress}, slot=${slot}): value=${value}`);
+  public writeStorage(contractAddress: Fr, slot: Fr, value: Fr) {
+    this.log.debug(`Storage write (address=${contractAddress}, slot=${slot}): value=${value}`);
     // Cache storage writes for later reference/reads
-    this.publicStorage.write(storageAddress, slot, value);
-    this.trace.tracePublicStorageWrite(storageAddress, slot, value);
+    this.publicStorage.write(contractAddress, slot, value);
+    this.trace.tracePublicStorageWrite(contractAddress, slot, value);
   }
 
   /**
    * Read from public storage, trace the read.
    *
-   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param contractAddress - the address of the contract whose storage is being read from
    * @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(storageAddress: Fr, slot: Fr): Promise<Fr> {
-    const { value, exists, cached } = await this.publicStorage.read(storageAddress, slot);
+  public async readStorage(contractAddress: Fr, slot: Fr): Promise<Fr> {
+    const { value, exists, cached } = await this.publicStorage.read(contractAddress, slot);
     this.log.debug(
-      `Storage read  (address=${storageAddress}, slot=${slot}): value=${value}, exists=${exists}, cached=${cached}`,
+      `Storage read  (address=${contractAddress}, slot=${slot}): value=${value}, exists=${exists}, cached=${cached}`,
     );
-    this.trace.tracePublicStorageRead(storageAddress, slot, value, exists, cached);
+    this.trace.tracePublicStorageRead(contractAddress, slot, value, exists, cached);
     return Promise.resolve(value);
   }
 
   /**
    * Read from public storage, don't trace the read.
    *
-   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param contractAddress - the address of the contract whose storage is being read from
    * @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(storageAddress: Fr, slot: Fr): Promise<Fr> {
-    const { value, exists, cached } = await this.publicStorage.read(storageAddress, slot);
+  public async peekStorage(contractAddress: Fr, slot: Fr): Promise<Fr> {
+    const { value, exists, cached } = await this.publicStorage.read(contractAddress, slot);
     this.log.debug(
-      `Storage peek  (address=${storageAddress}, slot=${slot}): value=${value}, exists=${exists}, cached=${cached}`,
+      `Storage peek  (address=${contractAddress}, slot=${slot}): value=${value}, exists=${exists}, cached=${cached}`,
     );
     return Promise.resolve(value);
   }
@@ -113,20 +119,20 @@ export class AvmPersistableStateManager {
   /**
    * Check if a note hash exists at the given leaf index, trace the check.
    *
-   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param contractAddress - the address of the contract whose storage is being read from
    * @param noteHash - the unsiloed note hash being checked
    * @param leafIndex - the leaf index being checked
    * @returns true if the note hash exists at the given leaf index, false otherwise
    */
-  public async checkNoteHashExists(storageAddress: Fr, noteHash: Fr, leafIndex: Fr): Promise<boolean> {
+  public async checkNoteHashExists(contractAddress: Fr, 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(${storageAddress})@${noteHash} ?? leafIndex: ${leafIndex} | gotLeafValue: ${gotLeafValue}, exists: ${exists}.`,
+      `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(storageAddress, gotLeafValue, leafIndex, exists);
+    this.trace.traceNoteHashCheck(contractAddress, gotLeafValue, leafIndex, exists);
     return Promise.resolve(exists);
   }
 
@@ -134,37 +140,37 @@ export class AvmPersistableStateManager {
    * Write a note hash, trace the write.
    * @param noteHash - the unsiloed note hash to write
    */
-  public writeNoteHash(storageAddress: Fr, noteHash: Fr) {
-    this.log.debug(`noteHashes(${storageAddress}) += @${noteHash}.`);
-    this.trace.traceNewNoteHash(storageAddress, noteHash);
+  public writeNoteHash(contractAddress: Fr, noteHash: Fr) {
+    this.log.debug(`noteHashes(${contractAddress}) += @${noteHash}.`);
+    this.trace.traceNewNoteHash(contractAddress, noteHash);
   }
 
   /**
    * Check if a nullifier exists, trace the check.
-   * @param storageAddress - address of the contract that the nullifier is associated with
+   * @param contractAddress - address of the contract that the nullifier is associated with
    * @param nullifier - the unsiloed nullifier to check
    * @returns exists - whether the nullifier exists in the nullifier set
    */
-  public async checkNullifierExists(storageAddress: Fr, nullifier: Fr): Promise<boolean> {
-    const [exists, isPending, leafIndex] = await this.nullifiers.checkExists(storageAddress, nullifier);
+  public async checkNullifierExists(contractAddress: Fr, nullifier: Fr): Promise<boolean> {
+    const [exists, isPending, leafIndex] = await this.nullifiers.checkExists(contractAddress, nullifier);
     this.log.debug(
-      `nullifiers(${storageAddress})@${nullifier} ?? leafIndex: ${leafIndex}, exists: ${exists}, pending: ${isPending}.`,
+      `nullifiers(${contractAddress})@${nullifier} ?? leafIndex: ${leafIndex}, exists: ${exists}, pending: ${isPending}.`,
     );
-    this.trace.traceNullifierCheck(storageAddress, nullifier, leafIndex, exists, isPending);
+    this.trace.traceNullifierCheck(contractAddress, nullifier, leafIndex, exists, isPending);
     return Promise.resolve(exists);
   }
 
   /**
    * Write a nullifier to the nullifier set, trace the write.
-   * @param storageAddress - address of the contract that the nullifier is associated with
+   * @param contractAddress - address of the contract that the nullifier is associated with
    * @param nullifier - the unsiloed nullifier to write
    */
-  public async writeNullifier(storageAddress: Fr, nullifier: Fr) {
-    this.log.debug(`nullifiers(${storageAddress}) += ${nullifier}.`);
+  public async writeNullifier(contractAddress: Fr, nullifier: Fr) {
+    this.log.debug(`nullifiers(${contractAddress}) += ${nullifier}.`);
     // Cache pending nullifiers for later access
-    await this.nullifiers.append(storageAddress, nullifier);
+    await this.nullifiers.append(contractAddress, nullifier);
     // Trace all nullifier creations (even reverted ones)
-    this.trace.traceNewNullifier(storageAddress, nullifier);
+    this.trace.traceNewNullifier(contractAddress, nullifier);
   }
 
   /**
@@ -210,22 +216,26 @@ export class AvmPersistableStateManager {
   /**
    * Get a contract instance.
    * @param contractAddress - address of the contract instance to retrieve.
-   * @returns the contract instance with an "exists" flag
+   * @returns the contract instance or undefined if it does not exist.
    */
-  public async getContractInstance(contractAddress: Fr): Promise<TracedContractInstance> {
-    let exists = true;
-    const aztecAddress = AztecAddress.fromField(contractAddress);
-    let instance = await this.worldStateDB.getContractInstance(aztecAddress);
-    if (instance === undefined) {
-      instance = SerializableContractInstance.empty().withAddress(aztecAddress);
-      exists = false;
+  public async getContractInstance(contractAddress: Fr): Promise<SerializableContractInstance | undefined> {
+    this.log.debug(`Getting contract instance for address ${contractAddress}`);
+    const instanceWithAddress = await this.worldStateDB.getContractInstance(AztecAddress.fromField(contractAddress));
+    const exists = instanceWithAddress !== undefined;
+
+    if (exists) {
+      const instance = new SerializableContractInstance(instanceWithAddress);
+      this.log.debug(
+        `Got contract instance (address=${contractAddress}): exists=${exists}, instance=${JSON.stringify(instance)}`,
+      );
+      this.trace.traceGetContractInstance(contractAddress, exists, instance);
+
+      return Promise.resolve(instance);
+    } else {
+      this.log.debug(`Contract instance NOT FOUND (address=${contractAddress})`);
+      this.trace.traceGetContractInstance(contractAddress, exists);
+      return Promise.resolve(undefined);
     }
-    this.log.debug(
-      `Get Contract instance (address=${contractAddress}): exists=${exists}, instance=${JSON.stringify(instance)}`,
-    );
-    const tracedInstance = { ...instance, exists };
-    this.trace.traceGetContractInstance(tracedInstance);
-    return Promise.resolve(tracedInstance);
   }
 
   /**
@@ -237,10 +247,43 @@ export class AvmPersistableStateManager {
   }
 
   /**
-   * Get a contract's bytecode from the contracts DB
+   * Get a contract's bytecode from the contracts DB, also trace the contract class and instance
    */
-  public async getBytecode(contractAddress: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
-    return await this.worldStateDB.getBytecode(contractAddress, selector);
+  public async getBytecode(contractAddress: AztecAddress): Promise<Buffer | undefined> {
+    this.log.debug(`Getting bytecode for contract address ${contractAddress}`);
+    const instanceWithAddress = await this.worldStateDB.getContractInstance(contractAddress);
+    const exists = instanceWithAddress !== undefined;
+
+    if (exists) {
+      const instance = new SerializableContractInstance(instanceWithAddress);
+
+      const contractClass = await this.worldStateDB.getContractClass(instance.contractClassId);
+      assert(
+        contractClass,
+        `Contract class not found in DB, but a contract instance was found with this class ID (${instance.contractClassId}). This should not happen!`,
+      );
+
+      const contractClassPreimage = {
+        artifactHash: contractClass.artifactHash,
+        privateFunctionsRoot: contractClass.privateFunctionsRoot,
+        publicBytecodeCommitment: computePublicBytecodeCommitment(contractClass.packedBytecode),
+      };
+
+      this.trace.traceGetBytecode(
+        contractAddress,
+        exists,
+        contractClass.packedBytecode,
+        instance,
+        contractClassPreimage,
+      );
+      return contractClass.packedBytecode;
+    } else {
+      // If the contract instance is not found, we assume it has not been deployed.
+      // It doesnt matter what the values of the contract instance are in this case, as long as we tag it with exists=false.
+      // This will hint to the avm circuit to just perform the non-membership check on the address and disregard the bytecode hash
+      this.trace.traceGetBytecode(contractAddress, exists); // bytecode, instance, class undefined
+      return undefined;
+    }
   }
 
   /**

package/src/avm/journal/nullifiers.ts

@@ -37,17 +37,17 @@ export class NullifierManager {
   /**
    * Get a nullifier's existence in this' cache or parent's (recursively).
    * DOES NOT CHECK HOST STORAGE!
-   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param contractAddress - the address of the contract whose storage is being read from
    * @param nullifier - the nullifier to check for
    * @returns exists: whether the nullifier exists in cache here or in parent's
    */
-  private checkExistsHereOrParent(storageAddress: Fr, nullifier: Fr): boolean {
+  private checkExistsHereOrParent(contractAddress: Fr, nullifier: Fr): boolean {
     // First check this cache
-    let existsAsPending = this.cache.exists(storageAddress, nullifier);
+    let existsAsPending = this.cache.exists(contractAddress, nullifier);
     // Then try parent's nullifier cache
     if (!existsAsPending && this.parent) {
       // Note: this will recurse to grandparent/etc until a cache-hit is encountered.
-      existsAsPending = this.parent.checkExistsHereOrParent(storageAddress, nullifier);
+      existsAsPending = this.parent.checkExistsHereOrParent(contractAddress, nullifier);
     }
     return existsAsPending;
   }
@@ -59,24 +59,24 @@ export class NullifierManager {
    * 3. Fall back to the host state.
    * 4. Not found! Nullifier does not exist.
    *
-   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param contractAddress - the address of the contract whose storage is being read from
    * @param nullifier - the nullifier to check for
    * @returns exists: whether the nullifier exists at all,
    *          isPending: whether the nullifier was found in a cache,
    *          leafIndex: the nullifier's leaf index if it exists and is not pending (comes from host state).
    */
   public async checkExists(
-    storageAddress: Fr,
+    contractAddress: Fr,
     nullifier: Fr,
   ): Promise<[/*exists=*/ boolean, /*isPending=*/ boolean, /*leafIndex=*/ Fr]> {
     // Check this cache and parent's (recursively)
-    const existsAsPending = this.checkExistsHereOrParent(storageAddress, nullifier);
+    const existsAsPending = this.checkExistsHereOrParent(contractAddress, nullifier);
     // Finally try the host's Aztec state (a trip to the database)
     // If the value is found in the database, it will be associated with a leaf index!
     let leafIndex: bigint | undefined = undefined;
     if (!existsAsPending) {
       // silo the nullifier before checking for its existence in the host
-      leafIndex = await this.hostNullifiers.getNullifierIndex(siloNullifier(storageAddress, nullifier));
+      leafIndex = await this.hostNullifiers.getNullifierIndex(siloNullifier(contractAddress, nullifier));
     }
     const exists = existsAsPending || leafIndex !== undefined;
     leafIndex = leafIndex === undefined ? BigInt(0) : leafIndex;
@@ -86,17 +86,17 @@ export class NullifierManager {
   /**
    * Stage a new nullifier (append it to the cache).
    *
-   * @param storageAddress - the address of the contract that the nullifier is associated with
+   * @param contractAddress - the address of the contract that the nullifier is associated with
    * @param nullifier - the nullifier to stage
    */
-  public async append(storageAddress: Fr, nullifier: Fr) {
-    const [exists, ,] = await this.checkExists(storageAddress, nullifier);
+  public async append(contractAddress: Fr, nullifier: Fr) {
+    const [exists, ,] = await this.checkExists(contractAddress, nullifier);
     if (exists) {
       throw new NullifierCollisionError(
-        `Nullifier ${nullifier} at contract ${storageAddress} already exists in parent cache or host.`,
+        `Nullifier ${nullifier} at contract ${contractAddress} already exists in parent cache or host.`,
       );
     }
-    this.cache.append(storageAddress, nullifier);
+    this.cache.append(contractAddress, nullifier);
   }
 
   /**
@@ -135,35 +135,35 @@ export class NullifierCache {
   /**
    * Check whether a nullifier exists in the cache.
    *
-   * @param storageAddress - the address of the contract that the nullifier is associated with
+   * @param contractAddress - the address of the contract that the nullifier is associated with
    * @param nullifier - the nullifier to check existence of
    * @returns whether the nullifier is found in the cache
    */
-  public exists(storageAddress: Fr, nullifier: Fr): boolean {
+  public exists(contractAddress: Fr, nullifier: Fr): boolean {
     const exists =
-      this.cachePerContract.get(storageAddress.toBigInt())?.has(nullifier.toBigInt()) ||
-      this.siloedNullifiers.has(siloNullifier(AztecAddress.fromField(storageAddress), nullifier).toBigInt());
+      this.cachePerContract.get(contractAddress.toBigInt())?.has(nullifier.toBigInt()) ||
+      this.siloedNullifiers.has(siloNullifier(AztecAddress.fromField(contractAddress), nullifier).toBigInt());
     return !!exists;
   }
 
   /**
    * Stage a new nullifier (append it to the cache).
    *
-   * @param storageAddress - the address of the contract that the nullifier is associated with
+   * @param contractAddress - the address of the contract that the nullifier is associated with
    * @param nullifier - the nullifier to stage
    */
-  public append(storageAddress: Fr, nullifier: Fr) {
-    if (this.exists(storageAddress, nullifier)) {
+  public append(contractAddress: Fr, nullifier: Fr) {
+    if (this.exists(contractAddress, nullifier)) {
       throw new NullifierCollisionError(
-        `Nullifier ${nullifier} at contract ${storageAddress} already exists in cache.`,
+        `Nullifier ${nullifier} at contract ${contractAddress} already exists in cache.`,
       );
     }
 
-    let nullifiersForContract = this.cachePerContract.get(storageAddress.toBigInt());
+    let nullifiersForContract = this.cachePerContract.get(contractAddress.toBigInt());
     // If this contract's nullifier set has no cached nullifiers, create a new Set to store them
     if (!nullifiersForContract) {
       nullifiersForContract = new Set();
-      this.cachePerContract.set(storageAddress.toBigInt(), nullifiersForContract);
+      this.cachePerContract.set(contractAddress.toBigInt(), nullifiersForContract);
     }
     nullifiersForContract.add(nullifier.toBigInt());
   }

package/src/avm/journal/public_storage.ts

@@ -45,17 +45,17 @@ export class PublicStorage {
    * Read a storage value from this' cache or parent's (recursively).
    * DOES NOT CHECK HOST STORAGE!
    *
-   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param contractAddress - the address of the contract whose storage is being read from
    * @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(storageAddress: Fr, slot: Fr): Fr | undefined {
+  public readHereOrParent(contractAddress: Fr, slot: Fr): Fr | undefined {
     // First try check this storage cache
-    let value = this.cache.read(storageAddress, slot);
+    let value = this.cache.read(contractAddress, slot);
     // Then try parent's storage cache
     if (!value && this.parent) {
       // Note: this will recurse to grandparent/etc until a cache-hit is encountered.
-      value = this.parent.readHereOrParent(storageAddress, slot);
+      value = this.parent.readHereOrParent(contractAddress, slot);
     }
     return value;
   }
@@ -67,17 +67,17 @@ export class PublicStorage {
    * 3. Fall back to the host state.
    * 4. Not found! Value has never been written to before. Flag it as non-existent and return value zero.
    *
-   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param contractAddress - the address of the contract whose storage is being read from
    * @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(storageAddress: Fr, slot: Fr): Promise<PublicStorageReadResult> {
+  public async read(contractAddress: Fr, slot: Fr): Promise<PublicStorageReadResult> {
     let cached = false;
     // Check this cache and parent's (recursively)
-    let value = this.readHereOrParent(storageAddress, slot);
+    let value = this.readHereOrParent(contractAddress, slot);
     // Finally try the host's Aztec state (a trip to the database)
     if (!value) {
-      value = await this.hostPublicStorage.storageRead(storageAddress, slot);
+      value = await this.hostPublicStorage.storageRead(contractAddress, slot);
       // TODO(dbanks12): if value retrieved from host storage, we can cache it here
       // any future reads to the same slot can read from cache instead of more expensive
       // DB access
@@ -93,12 +93,12 @@ export class PublicStorage {
   /**
    * Stage a storage write.
    *
-   * @param storageAddress - the address of the contract whose storage is being written to
+   * @param contractAddress - the address of the contract whose storage is being written to
    * @param slot - the slot in the contract's storage being written to
    * @param value - the value being written to the slot
    */
-  public write(storageAddress: Fr, slot: Fr, value: Fr) {
-    this.cache.write(storageAddress, slot, value);
+  public write(contractAddress: Fr, slot: Fr, value: Fr) {
+    this.cache.write(contractAddress, slot, value);
   }
 
   /**
@@ -114,9 +114,9 @@ export class PublicStorage {
    * Commits ALL staged writes to the host's state.
    */
   public async commitToDB() {
-    for (const [storageAddress, cacheAtContract] of this.cache.cachePerContract) {
+    for (const [contractAddress, cacheAtContract] of this.cache.cachePerContract) {
       for (const [slot, value] of cacheAtContract) {
-        await this.hostPublicStorage.storageWrite(AztecAddress.fromBigInt(storageAddress), new Fr(slot), value);
+        await this.hostPublicStorage.storageWrite(AztecAddress.fromBigInt(contractAddress), new Fr(slot), value);
       }
     }
   }
@@ -139,27 +139,27 @@ class PublicStorageCache {
   /**
    * Read a staged value from storage, if it has been previously written to.
    *
-   * @param storageAddress - the address of the contract whose storage is being read from
+   * @param contractAddress - the address of the contract whose storage is being read from
    * @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(storageAddress: Fr, slot: Fr): Fr | undefined {
-    return this.cachePerContract.get(storageAddress.toBigInt())?.get(slot.toBigInt());
+  public read(contractAddress: Fr, slot: Fr): Fr | undefined {
+    return this.cachePerContract.get(contractAddress.toBigInt())?.get(slot.toBigInt());
   }
 
   /**
    * Stage a storage write.
    *
-   * @param storageAddress - the address of the contract whose storage is being written to
+   * @param contractAddress - the address of the contract whose storage is being written to
    * @param slot - the slot in the contract's storage being written to
    * @param value - the value being written to the slot
    */
-  public write(storageAddress: Fr, slot: Fr, value: Fr) {
-    let cacheAtContract = this.cachePerContract.get(storageAddress.toBigInt());
+  public write(contractAddress: Fr, 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
       cacheAtContract = new Map();
-      this.cachePerContract.set(storageAddress.toBigInt(), cacheAtContract);
+      this.cachePerContract.set(contractAddress.toBigInt(), cacheAtContract);
     }
     cacheAtContract.set(slot.toBigInt(), value);
   }