@aztec/simulator 6.0.0-nightly.20260604 → 6.0.0-nightly.20260721

package/src/public/side_effect_trace.ts

@@ -1,293 +0,0 @@
-import {
-  FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH,
-  MAX_L2_TO_L1_MSGS_PER_TX,
-  MAX_NOTE_HASHES_PER_TX,
-  MAX_NULLIFIERS_PER_TX,
-  MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
-  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 { type LogLevel, type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
-import { PublicDataUpdateRequest } from '@aztec/stdlib/avm';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
-import { NoteHash, Nullifier } from '@aztec/stdlib/kernel';
-import { DebugLog, PublicLog } from '@aztec/stdlib/logs';
-import { L2ToL1Message, ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
-
-import { strict as assert } from 'assert';
-
-import {
-  L2ToL1MessageLimitReachedError,
-  MaxCallsToUniqueContractClassIdsError,
-  NoteHashLimitReachedError,
-  NullifierLimitReachedError,
-  SideEffectLimitReachedError,
-} from './side_effect_errors.js';
-import type { PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
-import { UniqueClassIds } from './unique_class_ids.js';
-
-/**
- * A struct containing just the side effects as regular arrays
- * as opposed to "Tuple" arrays used by circuit public inputs.
- * This struct is helpful for testing and checking array lengths.
- **/
-export type SideEffects = {
-  publicDataWrites: PublicDataUpdateRequest[];
-  noteHashes: NoteHash[];
-  nullifiers: Nullifier[];
-  l2ToL1Msgs: ScopedL2ToL1Message[];
-  publicLogs: PublicLog[];
-};
-
-export class SideEffectArrayLengths {
-  constructor(
-    public readonly publicDataWrites: number,
-    public readonly protocolPublicDataWrites: number,
-    public readonly noteHashes: number,
-    public readonly nullifiers: number,
-    public readonly l2ToL1Msgs: number,
-    public readonly publicLogFields: number,
-  ) {}
-
-  static empty() {
-    return new this(0, 0, 0, 0, 0, 0);
-  }
-}
-
-/**
- * Trace side effects for an enqueued public call's execution.
- */
-export class SideEffectTrace implements PublicSideEffectTraceInterface {
-  public log: Logger;
-
-  /** The side effect counter increments with every call to the trace. */
-  private sideEffectCounter: number;
-
-  private publicDataWrites: PublicDataUpdateRequest[] = [];
-  private protocolPublicDataWritesLength: number = 0;
-  private userPublicDataWritesLength: number = 0;
-  private noteHashes: NoteHash[] = [];
-  private nullifiers: Nullifier[] = [];
-  private l2ToL1Messages: ScopedL2ToL1Message[] = [];
-  private publicLogs: PublicLog[] = [];
-  /** Make sure a forked trace is never merged twice. */
-  private alreadyMergedIntoParent = false;
-
-  constructor(
-    /** The counter of this trace's first side effect. */
-    public readonly startSideEffectCounter: number = 0,
-    bindings?: LoggerBindings,
-    /** Track parent's (or previous kernel's) lengths so the AVM can properly enforce TX-wide limits,
-     *  otherwise the public kernel can fail to prove because TX limits are breached.
-     */
-    private readonly previousSideEffectArrayLengths: SideEffectArrayLengths = SideEffectArrayLengths.empty(),
-    /** We need to track the set of class IDs used, to enforce limits. */
-    private uniqueClassIds: UniqueClassIds = new UniqueClassIds(),
-    private writtenPublicDataSlots: Set<string> = new Set(),
-    private debugLogs: DebugLog[] = [],
-    private debugLogMemoryReads: number = 0,
-  ) {
-    this.sideEffectCounter = startSideEffectCounter;
-    this.log = createLogger('simulator:side_effect_trace', bindings);
-  }
-
-  public fork() {
-    return new SideEffectTrace(
-      this.sideEffectCounter,
-      this.log.getBindings(),
-      new SideEffectArrayLengths(
-        this.previousSideEffectArrayLengths.publicDataWrites + this.userPublicDataWritesLength,
-        this.previousSideEffectArrayLengths.protocolPublicDataWrites + this.protocolPublicDataWritesLength,
-        this.previousSideEffectArrayLengths.noteHashes + this.noteHashes.length,
-        this.previousSideEffectArrayLengths.nullifiers + this.nullifiers.length,
-        this.previousSideEffectArrayLengths.l2ToL1Msgs + this.l2ToL1Messages.length,
-        this.previousSideEffectArrayLengths.publicLogFields +
-          this.publicLogs.reduce((acc, log) => acc + log.sizeInFields(), 0),
-      ),
-      this.uniqueClassIds.fork(),
-      new Set(this.writtenPublicDataSlots),
-      this.debugLogs.slice(),
-      this.debugLogMemoryReads,
-    );
-  }
-
-  public merge(forkedTrace: this, reverted: boolean = false) {
-    // sanity check to avoid merging the same forked trace twice
-    assert(
-      !forkedTrace.alreadyMergedIntoParent,
-      'Bug! Cannot merge a forked trace that has already been merged into its parent!',
-    );
-    forkedTrace.alreadyMergedIntoParent = true;
-
-    this.sideEffectCounter = forkedTrace.sideEffectCounter;
-    this.uniqueClassIds.acceptAndMerge(forkedTrace.uniqueClassIds);
-    this.debugLogs = forkedTrace.debugLogs;
-    this.debugLogMemoryReads = forkedTrace.debugLogMemoryReads;
-
-    if (!reverted) {
-      this.publicDataWrites.push(...forkedTrace.publicDataWrites);
-      this.noteHashes.push(...forkedTrace.noteHashes);
-      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);
-      }
-    }
-  }
-
-  public getCounter() {
-    return this.sideEffectCounter;
-  }
-
-  private incrementSideEffectCounter() {
-    this.sideEffectCounter++;
-  }
-
-  public getNoteHashCount() {
-    return this.previousSideEffectArrayLengths.noteHashes + this.noteHashes.length;
-  }
-
-  public async tracePublicStorageWrite(
-    contractAddress: AztecAddress,
-    slot: Fr,
-    value: Fr,
-    protocolWrite: boolean,
-  ): Promise<void> {
-    // 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++;
-      }
-    }
-
-    const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
-    this.publicDataWrites.push(new PublicDataUpdateRequest(leafSlot, value, this.sideEffectCounter));
-
-    this.log.trace(
-      `Traced public data write (address=${contractAddress}, slot=${slot}): value=${value} (counter=${this.sideEffectCounter}, isProtocol:${protocolWrite})`,
-    );
-    this.incrementSideEffectCounter();
-    this.writtenPublicDataSlots.add(this.computePublicDataSlotKey(contractAddress, slot));
-  }
-
-  private computePublicDataSlotKey(contractAddress: AztecAddress, slot: Fr): string {
-    return `${contractAddress.toString()}:${slot.toString()}`;
-  }
-
-  public isStorageCold(contractAddress: AztecAddress, slot: Fr): boolean {
-    return !this.writtenPublicDataSlots.has(this.computePublicDataSlotKey(contractAddress, slot));
-  }
-
-  public traceNewNoteHash(noteHash: Fr) {
-    if (this.noteHashes.length + this.previousSideEffectArrayLengths.noteHashes >= MAX_NOTE_HASHES_PER_TX) {
-      throw new NoteHashLimitReachedError();
-    }
-
-    this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter));
-    this.log.trace(`Tracing new note hash (counter=${this.sideEffectCounter})`);
-    this.incrementSideEffectCounter();
-  }
-
-  public traceNewNullifier(siloedNullifier: Fr) {
-    if (this.nullifiers.length + this.previousSideEffectArrayLengths.nullifiers >= MAX_NULLIFIERS_PER_TX) {
-      throw new NullifierLimitReachedError();
-    }
-
-    this.nullifiers.push(new Nullifier(siloedNullifier, /*noteHash=*/ Fr.ZERO, this.sideEffectCounter));
-
-    this.log.trace(`Tracing new nullifier (counter=${this.sideEffectCounter})`);
-    this.incrementSideEffectCounter();
-  }
-
-  public traceNewL2ToL1Message(contractAddress: AztecAddress, recipient: Fr, content: Fr) {
-    if (this.l2ToL1Messages.length + this.previousSideEffectArrayLengths.l2ToL1Msgs >= MAX_L2_TO_L1_MSGS_PER_TX) {
-      throw new L2ToL1MessageLimitReachedError();
-    }
-
-    const recipientAddress = EthAddress.fromField(recipient);
-    this.l2ToL1Messages.push(new L2ToL1Message(recipientAddress, content).scope(contractAddress));
-    this.log.trace(`Tracing new l2 to l1 message (counter=${this.sideEffectCounter})`);
-    this.incrementSideEffectCounter();
-  }
-
-  public tracePublicLog(contractAddress: AztecAddress, log: Fr[]) {
-    const previouslyEmittedPublicLogFieldsCount =
-      this.previousSideEffectArrayLengths.publicLogFields +
-      this.publicLogs.reduce((acc, log) => acc + log.sizeInFields(), 0);
-
-    const publicLog = new PublicLog(contractAddress, log);
-
-    if (previouslyEmittedPublicLogFieldsCount + publicLog.sizeInFields() > FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH) {
-      throw new SideEffectLimitReachedError('public log fields', FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH);
-    }
-
-    this.publicLogs.push(publicLog);
-    this.log.trace(`Tracing new public log (counter=${this.sideEffectCounter})`);
-    this.incrementSideEffectCounter();
-  }
-
-  public traceDebugLog(contractAddress: AztecAddress, level: LogLevel, message: string, fields: Fr[]) {
-    this.debugLogs.push(new DebugLog(contractAddress, level, message, fields));
-  }
-
-  public getDebugLogs() {
-    return this.debugLogs;
-  }
-
-  public getDebugLogMemoryReads() {
-    return this.debugLogMemoryReads;
-  }
-
-  public traceDebugLogMemoryReads(memoryReads: number) {
-    this.debugLogMemoryReads += memoryReads;
-  }
-
-  public traceGetContractClass(contractClassId: Fr, exists: boolean) {
-    // We limit the number of unique contract class IDs due to hashing and the trace length limit.
-    if (exists && !this.uniqueClassIds.has(contractClassId.toString())) {
-      if (this.uniqueClassIds.size() >= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS) {
-        this.log.debug(`Bytecode retrieval failure for contract class ID ${contractClassId} (limit reached)`);
-        throw new MaxCallsToUniqueContractClassIdsError();
-      }
-      this.log.trace(`Adding contract class ID ${contractClassId} (counter=${this.sideEffectCounter})`);
-      this.uniqueClassIds.add(contractClassId.toString());
-      this.incrementSideEffectCounter();
-    }
-  }
-
-  public getSideEffects(): SideEffects {
-    return {
-      publicDataWrites: this.publicDataWrites,
-      noteHashes: this.noteHashes,
-      nullifiers: this.nullifiers,
-      l2ToL1Msgs: this.l2ToL1Messages,
-      publicLogs: this.publicLogs,
-    };
-  }
-}

package/src/public/side_effect_trace_interface.ts

@@ -1,28 +0,0 @@
-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';
-
-export interface PublicSideEffectTraceInterface {
-  fork(): PublicSideEffectTraceInterface;
-  merge(nestedTrace: PublicSideEffectTraceInterface, reverted?: boolean): void;
-  getCounter(): number;
-  // all "trace*" functions can throw SideEffectLimitReachedError
-  tracePublicStorageWrite(
-    contractAddress: AztecAddress,
-    slot: Fr, // This is the storage slot not the computed leaf slot
-    value: Fr,
-    protocolWrite: boolean,
-  ): Promise<void>;
-  isStorageCold(contractAddress: AztecAddress, slot: Fr): boolean;
-  traceNewNoteHash(uniqueNoteHash: Fr): void;
-  getNoteHashCount(): number;
-  traceNewNullifier(siloedNullifier: Fr): void;
-  traceNewL2ToL1Message(contractAddress: AztecAddress, recipient: Fr, content: Fr): void;
-  tracePublicLog(contractAddress: AztecAddress, log: Fr[]): void;
-  traceDebugLog(contractAddress: AztecAddress, level: LogLevel, message: string, fields: Fr[]): void;
-  getDebugLogs(): DebugLog[];
-  getDebugLogMemoryReads(): number;
-  traceDebugLogMemoryReads(memoryReads: number): void;
-  traceGetContractClass(contractClassId: Fr, exists: boolean): void;
-}

package/src/public/state_manager/index.ts

@@ -1 +0,0 @@
-export * from './state_manager.js';

package/src/public/state_manager/nullifiers.ts

@@ -1,103 +0,0 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
-
-import type { PublicTreesDB } from '../public_db_sources.js';
-import { NullifierCollisionError } from '../side_effect_errors.js';
-
-/**
- * A class to manage new nullifier staging and existence checks during a contract call's AVM simulation.
- * Maintains a siloed nullifier cache, and ensures that existence checks fall back to the correct source.
- * When a contract call completes, its cached nullifier set can be merged into its parent's.
- */
-export class NullifierManager {
-  constructor(
-    /** Reference to node storage. Checked on parent cache-miss. */
-    private readonly hostNullifiers: PublicTreesDB,
-    /** Cache of siloed nullifiers. */
-    private cache: Set<bigint> = new Set(),
-    /** Parent nullifier manager to fall back on */
-    private readonly parent?: NullifierManager,
-  ) {}
-
-  /**
-   * Create a new nullifiers manager forked from this one
-   */
-  public fork() {
-    return new NullifierManager(this.hostNullifiers, new Set(), this);
-  }
-
-  /**
-   * Get a nullifier's existence in this' cache or parent's (recursively).
-   * DOES NOT CHECK HOST STORAGE!
-   * @param siloedNullifier - the nullifier to check for
-   * @returns exists: whether the nullifier exists in cache here or in parent's
-   */
-  private checkExistsHereOrParent(siloedNullifier: Fr): boolean {
-    // First check this cache
-    let existsAsPending = this.cache.has(siloedNullifier.toBigInt());
-    // 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(siloedNullifier);
-    }
-    return existsAsPending;
-  }
-
-  /**
-   * Get a nullifier's existence status.
-   * 1. Check cache.
-   * 2. Check parent cache.
-   * 3. Fall back to the host state.
-   * 4. Not found! Nullifier does not exist.
-   *
-   * @param siloedNullifier - the nullifier to check for
-   * @returns exists: whether the nullifier exists at all,
-   *          cacheHit: whether the nullifier was found in a cache,
-   */
-  public async checkExists(siloedNullifier: Fr): Promise<{ exists: boolean; cacheHit: boolean }> {
-    // Check this cache and parent's (recursively)
-    const cacheHit = this.checkExistsHereOrParent(siloedNullifier);
-    let existsInTree = false;
-    if (!cacheHit) {
-      // Finally try the host's Aztec state (a trip to the database)
-      //const leafOrLowLeafIndex = await this.hostNullifiers.db.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, siloedNullifier.toBigInt());
-      //assert(
-      //  leafOrLowLeafIndex !== undefined,
-      //  `${MerkleTreeId[MerkleTreeId.NULLIFIER_TREE]} low leaf index should always be found (even if target leaf does not exist)`,
-      //);
-      //existsInTree = leafOrLowLeafIndex.alreadyPresent;
-      const exists = await this.hostNullifiers.checkNullifierExists(siloedNullifier);
-      existsInTree = exists;
-    }
-    const exists = cacheHit || existsInTree;
-    return Promise.resolve({ exists, cacheHit });
-  }
-
-  /**
-   * Stage a new nullifier (append it to the cache).
-   *
-   * @param siloedNullifier - the nullifier to stage
-   */
-  public async append(siloedNullifier: Fr) {
-    const { exists } = await this.checkExists(siloedNullifier);
-    if (exists) {
-      throw new NullifierCollisionError(`Siloed nullifier ${siloedNullifier} already exists in parent cache or host.`);
-    }
-    this.cache.add(siloedNullifier.toBigInt());
-  }
-
-  /**
-   * Merges another nullifier cache into this one.
-   *
-   * @param incomingNullifiers - the incoming cached nullifiers to merge into this instance's
-   */
-  public acceptAndMerge(incomingNullifiers: NullifierManager) {
-    for (const incomingNullifier of incomingNullifiers.cache) {
-      if (this.cache.has(incomingNullifier)) {
-        throw new NullifierCollisionError(
-          `Failed to merge in fork's cached nullifiers. Siloed nullifier ${incomingNullifier} already exists in parent cache.`,
-        );
-      }
-    }
-    this.cache = new Set([...this.cache, ...incomingNullifiers.cache]);
-  }
-}

package/src/public/state_manager/public_storage.ts

@@ -1,174 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-
-import type { PublicStateDBInterface } from '../db_interfaces.js';
-
-type PublicStorageReadResult = {
-  value: Fr;
-  cached: boolean;
-};
-
-/**
- * A class to manage public storage reads and writes during a contract call's AVM simulation.
- * Maintains a storage write cache, and ensures that reads fall back to the correct source.
- * When a contract call completes, its storage cache can be merged into its parent's.
- */
-export class PublicStorage {
-  /** Cached storage writes. */
-  private readonly cache: PublicStorageCache;
-
-  constructor(
-    /** Reference to node storage. Checked on parent cache-miss. */
-    private readonly hostPublicStorage: PublicStateDBInterface,
-    /** Parent's storage. Checked on this' cache-miss. */
-    private readonly parent?: PublicStorage,
-  ) {
-    this.cache = new PublicStorageCache();
-  }
-
-  /**
-   * Create a new public storage manager forked from this one
-   */
-  public fork() {
-    return new PublicStorage(this.hostPublicStorage, this);
-  }
-
-  /**
-   * Read a storage value from this' cache or parent's (recursively).
-   * DOES NOT CHECK HOST STORAGE!
-   *
-   * @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(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
-    if (!value && this.parent) {
-      // Note: this will recurse to grandparent/etc until a cache-hit is encountered.
-      value = this.parent.readHereOrParent(contractAddress, slot);
-    }
-    return value;
-  }
-
-  /**
-   * Read a value from storage.
-   * 1. Check cache.
-   * 2. Check parent cache.
-   * 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 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(contractAddress: AztecAddress, slot: Fr): Promise<PublicStorageReadResult> {
-    let cached = false;
-    // Check this cache and parent's (recursively)
-    let value = this.readHereOrParent(contractAddress, slot);
-    // Finally try the host's Aztec state (a trip to the database)
-    if (!value) {
-      // This functions returns Fr.ZERO if it has never been written to before
-      // we explicity coalesce to Fr.ZERO in case we have some implementations that cause this to return undefined
-      value = (await this.hostPublicStorage.storageRead(contractAddress, slot)) ?? Fr.ZERO;
-      // 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
-    } else {
-      cached = true;
-    }
-    // if value is Fr.ZERO here, it that means this slot has never been written to!
-    return Promise.resolve({ value, cached });
-  }
-
-  /**
-   * Stage a storage write.
-   *
-   * @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(contractAddress: AztecAddress, slot: Fr, value: Fr) {
-    this.cache.write(contractAddress, slot, value);
-  }
-
-  /**
-   * Merges another PublicStorage's cache (pending writes) into this one.
-   *
-   * @param incomingPublicStorage - the incoming public storage to merge into this instance's
-   */
-  public acceptAndMerge(incomingPublicStorage: PublicStorage) {
-    this.cache.acceptAndMerge(incomingPublicStorage.cache);
-  }
-}
-
-/**
- * A class to cache writes to public storage during a contract call's AVM simulation.
- * "Writes" update a map, "reads" check that map or return undefined.
- * An instance of this class can merge another instance's staged writes into its own.
- */
-class PublicStorageCache {
-  /**
-   * Map for staging storage writes.
-   * One inner-map per contract storage address,
-   * mapping storage slot to latest staged write value.
-   */
-  private cachePerContract: Map<bigint, Map<bigint, Fr>> = new Map();
-
-  /**
-   * Read a staged value from storage, if it has been previously written to.
-   *
-   * @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(contractAddress: AztecAddress, slot: Fr): Fr | undefined {
-    return this.cachePerContract.get(contractAddress.toBigInt())?.get(slot.toBigInt());
-  }
-
-  /**
-   * Stage a storage write.
-   *
-   * @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(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
-      cacheAtContract = new Map();
-      this.cachePerContract.set(contractAddress.toBigInt(), cacheAtContract);
-    }
-    cacheAtContract.set(slot.toBigInt(), value);
-  }
-
-  /**
-   * Merges another cache's staged writes into this instance's cache.
-   *
-   * Staged modifications in "incoming" take precedence over those
-   * present in "this" as they are assumed to occur after this' writes.
-   *
-   * In practice, "this" is a parent call's storage cache, and "incoming" is a nested call's.
-   *
-   * @param incomingStorageCache - the incoming storage write cache to merge into this instance's
-   */
-  public acceptAndMerge(incomingStorageCache: PublicStorageCache) {
-    // Iterate over all incoming contracts with staged writes.
-    for (const [incomingAddress, incomingCacheAtContract] of incomingStorageCache.cachePerContract) {
-      const thisCacheAtContract = this.cachePerContract.get(incomingAddress);
-      if (!thisCacheAtContract) {
-        // The contract has no storage writes staged here
-        // so just accept the incoming cache as-is for this contract.
-        this.cachePerContract.set(incomingAddress, incomingCacheAtContract);
-      } else {
-        // "Incoming" and "this" both have staged writes for this contract.
-        // Merge in incoming staged writes, giving them precedence over this'.
-        for (const [slot, value] of incomingCacheAtContract) {
-          thisCacheAtContract.set(slot, value);
-        }
-      }
-    }
-  }
-}