@aztec/simulator 0.32.1 → 0.34.0

package/src/avm/avm_memory_types.ts

@@ -1,10 +1,12 @@
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { Fr } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
+import { type FunctionsOf } from '@aztec/foundation/types';
 
 import { strict as assert } from 'assert';
 
-import { TagCheckError } from './errors.js';
+import { InstructionExecutionError, TagCheckError } from './errors.js';
+import { Addressing, AddressingMode } from './opcodes/addressing_mode.js';
 
 /** MemoryValue gathers the common operations for all memory types. */
 export abstract class MemoryValue {
@@ -30,6 +32,11 @@ export abstract class MemoryValue {
     return new Fr(this.toBigInt());
   }
 
+  // To number. Throws if exceeds max safe int.
+  public toNumber(): number {
+    return this.toFr().toNumber();
+  }
+
   public toString(): string {
     return `${this.constructor.name}(0x${this.toBigInt().toString(16)})`;
   }
@@ -198,10 +205,16 @@ export enum TypeTag {
   INVALID,
 }
 
+// Lazy interface definition for tagged memory
+export type TaggedMemoryInterface = FunctionsOf<TaggedMemory>;
+
 // TODO: Consider automatic conversion when getting undefined values.
-export class TaggedMemory {
+export class TaggedMemory implements TaggedMemoryInterface {
   static readonly log: DebugLogger = createDebugLogger('aztec:avm_simulator:memory');
 
+  // Whether to track and validate memory accesses for each instruction.
+  static readonly TRACK_MEMORY_ACCESSES = process.env.NODE_ENV === 'test';
+
   // FIXME: memory should be 2^32, but TS doesn't allow for arrays that big.
   static readonly MAX_MEMORY_SIZE = Number((1n << 32n) - 2n);
   private _mem: MemoryValue[];
@@ -211,6 +224,11 @@ export class TaggedMemory {
     this._mem = [];
   }
 
+  /** Returns a MeteredTaggedMemory instance to track the number of reads and writes if TRACK_MEMORY_ACCESSES is set. */
+  public track(type: string = 'instruction') {
+    return TaggedMemory.TRACK_MEMORY_ACCESSES ? new MeteredTaggedMemory(this, type) : this;
+  }
+
   public get(offset: number): MemoryValue {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     const value = this.getAs<MemoryValue>(offset);
@@ -220,7 +238,10 @@ export class TaggedMemory {
   public getAs<T>(offset: number): T {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     const word = this._mem[offset];
-    TaggedMemory.log(`get(${offset}) = ${word}`);
+    TaggedMemory.log.debug(`get(${offset}) = ${word}`);
+    if (word === undefined) {
+      TaggedMemory.log.warn(`Memory at offset ${offset} is undefined! This might be OK if it's stack dumping.`);
+    }
     return word as T;
   }
 
@@ -228,7 +249,8 @@ export class TaggedMemory {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
     const value = this._mem.slice(offset, offset + size);
-    TaggedMemory.log(`getSlice(${offset}, ${size}) = ${value}`);
+    TaggedMemory.log.debug(`getSlice(${offset}, ${size}) = ${value}`);
+    assert(!value.some(e => e === undefined), 'Memory slice contains undefined values.');
     assert(value.length === size, `Expected slice of size ${size}, got ${value.length}.`);
     return value;
   }
@@ -248,7 +270,7 @@ export class TaggedMemory {
   public set(offset: number, v: MemoryValue) {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     this._mem[offset] = v;
-    TaggedMemory.log(`set(${offset}, ${v})`);
+    TaggedMemory.log.debug(`set(${offset}, ${v})`);
   }
 
   public setSlice(offset: number, vs: MemoryValue[]) {
@@ -259,7 +281,7 @@ export class TaggedMemory {
       this._mem.length = offset + vs.length;
     }
     this._mem.splice(offset, vs.length, ...vs);
-    TaggedMemory.log(`setSlice(${offset}, ${vs})`);
+    TaggedMemory.log.debug(`setSlice(${offset}, ${vs})`);
   }
 
   public getTag(offset: number): TypeTag {
@@ -367,4 +389,110 @@ export class TaggedMemory {
         throw new Error(`${TypeTag[tag]} is not a valid integral type.`);
     }
   }
+
+  /** No-op. Implemented here for compatibility with the MeteredTaggedMemory. */
+  public assert(_operations: Partial<MemoryOperations & { indirect: number }>) {}
+}
+
+/** Tagged memory wrapper with metering for each memory read and write operation. */
+export class MeteredTaggedMemory implements TaggedMemoryInterface {
+  private reads: number = 0;
+  private writes: number = 0;
+
+  constructor(private wrapped: TaggedMemory, private type: string = 'instruction') {}
+
+  /** Returns the number of reads and writes tracked so far and resets them to zero. */
+  public reset(): MemoryOperations {
+    const stats = { reads: this.reads, writes: this.writes };
+    this.reads = 0;
+    this.writes = 0;
+    return stats;
+  }
+
+  /**
+   * Asserts that the exact number of memory operations have been performed.
+   * Indirect represents the flags for indirect accesses: each bit set to one counts as an extra read.
+   */
+  public assert(operations: Partial<MemoryOperations & { indirect: number }>) {
+    const { reads: expectedReads, writes: expectedWrites, indirect } = { reads: 0, writes: 0, ...operations };
+
+    const totalExpectedReads = expectedReads + Addressing.fromWire(indirect ?? 0).count(AddressingMode.INDIRECT);
+    const { reads: actualReads, writes: actualWrites } = this.reset();
+    if (actualReads !== totalExpectedReads) {
+      throw new InstructionExecutionError(
+        `Incorrect number of memory reads for ${this.type}: expected ${totalExpectedReads} but executed ${actualReads}`,
+      );
+    }
+    if (actualWrites !== expectedWrites) {
+      throw new InstructionExecutionError(
+        `Incorrect number of memory writes for ${this.type}: expected ${expectedWrites} but executed ${actualWrites}`,
+      );
+    }
+  }
+
+  public track(type: string = 'instruction'): MeteredTaggedMemory {
+    return new MeteredTaggedMemory(this.wrapped, type);
+  }
+
+  public get(offset: number): MemoryValue {
+    this.reads++;
+    return this.wrapped.get(offset);
+  }
+
+  public getSliceAs<T>(offset: number, size: number): T[] {
+    this.reads += size;
+    return this.wrapped.getSliceAs<T>(offset, size);
+  }
+
+  public getAs<T>(offset: number): T {
+    this.reads++;
+    return this.wrapped.getAs(offset);
+  }
+
+  public getSlice(offset: number, size: number): MemoryValue[] {
+    this.reads += size;
+    return this.wrapped.getSlice(offset, size);
+  }
+
+  public set(offset: number, v: MemoryValue): void {
+    this.writes++;
+    this.wrapped.set(offset, v);
+  }
+
+  public setSlice(offset: number, vs: MemoryValue[]): void {
+    this.writes += vs.length;
+    this.wrapped.setSlice(offset, vs);
+  }
+
+  public getSliceTags(offset: number, size: number): TypeTag[] {
+    return this.wrapped.getSliceTags(offset, size);
+  }
+
+  public getTag(offset: number): TypeTag {
+    return this.wrapped.getTag(offset);
+  }
+
+  public checkTag(tag: TypeTag, offset: number): void {
+    this.wrapped.checkTag(tag, offset);
+  }
+
+  public checkIsValidMemoryOffsetTag(offset: number): void {
+    this.wrapped.checkIsValidMemoryOffsetTag(offset);
+  }
+
+  public checkTags(tag: TypeTag, ...offsets: number[]): void {
+    this.wrapped.checkTags(tag, ...offsets);
+  }
+
+  public checkTagsRange(tag: TypeTag, startOffset: number, size: number): void {
+    this.wrapped.checkTagsRange(tag, startOffset, size);
+  }
 }
+
+/** Tracks number of memory reads and writes. */
+export type MemoryOperations = {
+  /** How many total reads are performed. Slice reads are count as one per element. */
+  reads: number;
+  /** How many total writes are performed. Slice writes are count as one per element. */
+  writes: number;
+};

package/src/avm/avm_simulator.ts

@@ -50,43 +50,45 @@ export class AvmSimulator {
    */
   public async executeInstructions(instructions: Instruction[]): Promise<AvmContractCallResults> {
     assert(instructions.length > 0);
+    const { machineState } = this.context;
     try {
       // Execute instruction pointed to by the current program counter
       // continuing until the machine state signifies a halt
-      while (!this.context.machineState.halted) {
-        const instruction = instructions[this.context.machineState.pc];
+      while (!machineState.halted) {
+        const instruction = instructions[machineState.pc];
         assert(
           !!instruction,
           'AVM attempted to execute non-existent instruction. This should never happen (invalid bytecode or AVM simulator bug)!',
         );
 
-        this.log.debug(`@${this.context.machineState.pc} ${instruction.toString()}`);
+        const gasLeft = `l1=${machineState.l1GasLeft} l2=${machineState.l2GasLeft} da=${machineState.daGasLeft}`;
+        this.log.debug(`@${machineState.pc} (${gasLeft}) ${instruction.toString()}`);
         // Execute the instruction.
         // Normal returns and reverts will return normally here.
         // "Exceptional halts" will throw.
-        await instruction.run(this.context);
+        await instruction.execute(this.context);
 
-        if (this.context.machineState.pc >= instructions.length) {
-          this.log('Passed end of program!');
-          throw new InvalidProgramCounterError(this.context.machineState.pc, /*max=*/ instructions.length);
+        if (machineState.pc >= instructions.length) {
+          this.log.warn('Passed end of program');
+          throw new InvalidProgramCounterError(machineState.pc, /*max=*/ instructions.length);
         }
       }
 
       // Return results for processing by calling context
-      const results = this.context.machineState.getResults();
-      this.log(`Context execution results: ${results.toString()}`);
+      const results = machineState.getResults();
+      this.log.debug(`Context execution results: ${results.toString()}`);
       return results;
     } catch (e) {
-      this.log('Exceptional halt');
+      this.log.verbose('Exceptional halt');
       if (!(e instanceof AvmExecutionError)) {
-        this.log(`Unknown error thrown by avm: ${e}`);
+        this.log.verbose(`Unknown error thrown by avm: ${e}`);
         throw e;
       }
 
       // Return results for processing by calling context
       // Note: "exceptional halts" cannot return data
       const results = new AvmContractCallResults(/*reverted=*/ true, /*output=*/ [], /*revertReason=*/ e);
-      this.log(`Context execution results: ${results.toString()}`);
+      this.log.debug(`Context execution results: ${results.toString()}`);
       return results;
     }
   }

package/src/avm/fixtures/index.ts

@@ -1,5 +1,5 @@
 import { SiblingPath } from '@aztec/circuit-types';
-import { GlobalVariables, L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
+import { GlobalVariables, Header, L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
 import { FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -67,6 +67,7 @@ export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnviron
     overrides?.feePerL2Gas ?? Fr.zero(),
     overrides?.feePerDaGas ?? Fr.zero(),
     overrides?.contractCallDepth ?? Fr.zero(),
+    overrides?.header ?? Header.empty(),
     overrides?.globals ?? GlobalVariables.empty(),
     overrides?.isStaticCall ?? false,
     overrides?.isDelegateCall ?? false,

package/src/avm/journal/journal.ts

@@ -7,16 +7,27 @@ import { type HostStorage } from './host_storage.js';
 import { Nullifiers } from './nullifiers.js';
 import { PublicStorage } from './public_storage.js';
 import { WorldStateAccessTrace } from './trace.js';
-import { type TracedL1toL2MessageCheck, type TracedNoteHashCheck, type TracedNullifierCheck } from './trace_types.js';
+import {
+  type TracedL1toL2MessageCheck,
+  type TracedNoteHash,
+  type TracedNoteHashCheck,
+  type TracedNullifier,
+  type TracedNullifierCheck,
+  type TracedPublicStorageRead,
+  type TracedPublicStorageWrite,
+} from './trace_types.js';
 
 /**
  * Data held within the journal
  */
 export type JournalData = {
+  storageWrites: TracedPublicStorageWrite[];
+  storageReads: TracedPublicStorageRead[];
+
   noteHashChecks: TracedNoteHashCheck[];
-  newNoteHashes: Fr[];
+  newNoteHashes: TracedNoteHash[];
   nullifierChecks: TracedNullifierCheck[];
-  newNullifiers: Fr[];
+  newNullifiers: TracedNullifier[];
   l1ToL2MessageChecks: TracedL1toL2MessageCheck[];
 
   newL1Messages: L2ToL1Message[];
@@ -24,11 +35,6 @@ export type JournalData = {
 
   /** contract address -\> key -\> value */
   currentStorageValue: Map<bigint, Map<bigint, Fr>>;
-
-  /** contract address -\> key -\> value[] (stored in order of access) */
-  storageWrites: Map<bigint, Map<bigint, Fr[]>>;
-  /** contract address -\> key -\> value[] (stored in order of access) */
-  storageReads: Map<bigint, Map<bigint, Fr[]>>;
 };
 
 /**
@@ -44,18 +50,19 @@ export class AvmPersistableStateManager {
   /** Reference to node storage */
   public readonly hostStorage: HostStorage;
 
+  // TODO: make members private once this is not used in transitional_adaptors.ts.
   /** World State */
   /** Public storage, including cached writes */
-  private publicStorage: PublicStorage;
+  public publicStorage: PublicStorage;
   /** Nullifier set, including cached/recently-emitted nullifiers */
-  private nullifiers: Nullifiers;
+  public nullifiers: Nullifiers;
 
   /** World State Access Trace */
-  private trace: WorldStateAccessTrace;
+  public trace: WorldStateAccessTrace;
 
   /** Accrued Substate **/
-  private newL1Messages: L2ToL1Message[] = [];
-  private newLogs: UnencryptedL2Log[] = [];
+  public newL1Messages: L2ToL1Message[] = [];
+  public newLogs: UnencryptedL2Log[] = [];
 
   constructor(hostStorage: HostStorage, parent?: AvmPersistableStateManager) {
     this.hostStorage = hostStorage;
@@ -93,9 +100,9 @@ export class AvmPersistableStateManager {
    * @returns the latest value written to slot, or 0 if never written to before
    */
   public async readStorage(storageAddress: Fr, slot: Fr): Promise<Fr> {
-    const [_exists, value] = await this.publicStorage.read(storageAddress, slot);
+    const [exists, value] = await this.publicStorage.read(storageAddress, slot);
     // We want to keep track of all performed reads (even reverted ones)
-    this.trace.tracePublicStorageRead(storageAddress, slot, value);
+    this.trace.tracePublicStorageRead(storageAddress, slot, value, exists);
     return Promise.resolve(value);
   }
 
@@ -119,8 +126,8 @@ export class AvmPersistableStateManager {
    * Write a note hash, trace the write.
    * @param noteHash - the unsiloed note hash to write
    */
-  public writeNoteHash(noteHash: Fr) {
-    this.trace.traceNewNoteHash(/*storageAddress*/ Fr.ZERO, noteHash);
+  public writeNoteHash(storageAddress: Fr, noteHash: Fr) {
+    this.trace.traceNewNoteHash(storageAddress, noteHash);
   }
 
   /**

package/src/avm/journal/trace.ts

@@ -1,23 +1,28 @@
 import { Fr } from '@aztec/foundation/fields';
 
-import { type TracedL1toL2MessageCheck, type TracedNoteHashCheck, type TracedNullifierCheck } from './trace_types.js';
+import {
+  type TracedL1toL2MessageCheck,
+  type TracedNoteHash,
+  type TracedNoteHashCheck,
+  type TracedNullifier,
+  type TracedNullifierCheck,
+  type TracedPublicStorageRead,
+  type TracedPublicStorageWrite,
+} from './trace_types.js';
 
 export class WorldStateAccessTrace {
   public accessCounter: number;
-  //public contractCalls: Array<TracedContractCall> = [];
 
-  //public publicStorageReads: Array<TracedPublicStorageRead> = [];
-  public publicStorageReads: Map<bigint, Map<bigint, Fr[]>> = new Map();
-  //public publicStorageWrites: Array<TracedPublicStorageWrite> = [];
-  public publicStorageWrites: Map<bigint, Map<bigint, Fr[]>> = new Map();
+  public publicStorageReads: TracedPublicStorageRead[] = [];
+  public publicStorageWrites: TracedPublicStorageWrite[] = [];
 
   public noteHashChecks: TracedNoteHashCheck[] = [];
-  //public newNoteHashes: TracedNoteHash[] = [];
-  public newNoteHashes: Fr[] = [];
+  public newNoteHashes: TracedNoteHash[] = [];
   public nullifierChecks: TracedNullifierCheck[] = [];
-  //public newNullifiers: TracedNullifier[] = [];
-  public newNullifiers: Fr[] = [];
+  public newNullifiers: TracedNullifier[] = [];
   public l1ToL2MessageChecks: TracedL1toL2MessageCheck[] = [];
+
+  //public contractCalls: TracedContractCall[] = [];
   //public archiveChecks: TracedArchiveLeafCheck[] = [];
 
   constructor(parentTrace?: WorldStateAccessTrace) {
@@ -28,76 +33,73 @@ export class WorldStateAccessTrace {
     return this.accessCounter;
   }
 
-  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr /*, _exists: boolean*/) {
+  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, exists: boolean) {
     // TODO(4805): check if some threshold is reached for max storage reads
     // (need access to parent length, or trace needs to be initialized with parent's contents)
-    //const traced: TracedPublicStorageRead = {
-    //  callPointer: Fr.ZERO,
-    //  storageAddress,
-    //  slot,
-    //  value,
-    //  exists,
-    //  counter: new Fr(this.accessCounter),
-    //  endLifetime: Fr.ZERO,
-    //};
-    //this.publicStorageReads.push(traced);
-    this.journalRead(storageAddress, slot, value);
+    const traced: TracedPublicStorageRead = {
+      //  callPointer: Fr.ZERO,
+      storageAddress,
+      slot,
+      value,
+      exists,
+      counter: new Fr(this.accessCounter),
+      //  endLifetime: Fr.ZERO,
+    };
+    this.publicStorageReads.push(traced);
     this.incrementAccessCounter();
   }
 
   public tracePublicStorageWrite(storageAddress: Fr, slot: Fr, value: Fr) {
     // TODO(4805): check if some threshold is reached for max storage writes
     // (need access to parent length, or trace needs to be initialized with parent's contents)
-    //const traced: TracedPublicStorageWrite = {
-    //  callPointer: Fr.ZERO,
-    //  storageAddress,
-    //  slot,
-    //  value,
-    //  counter: new Fr(this.accessCounter),
-    //  endLifetime: Fr.ZERO,
-    //};
-    //this.publicStorageWrites.push(traced);
-    this.journalWrite(storageAddress, slot, value);
+    const traced: TracedPublicStorageWrite = {
+      //  callPointer: Fr.ZERO,
+      storageAddress,
+      slot,
+      value,
+      counter: new Fr(this.accessCounter),
+      //  endLifetime: Fr.ZERO,
+    };
+    this.publicStorageWrites.push(traced);
     this.incrementAccessCounter();
   }
 
   public traceNoteHashCheck(storageAddress: Fr, noteHash: Fr, exists: boolean, leafIndex: Fr) {
     const traced: TracedNoteHashCheck = {
-      callPointer: Fr.ZERO, // FIXME
+      // callPointer: Fr.ZERO,
       storageAddress,
       noteHash,
       exists,
       counter: new Fr(this.accessCounter),
-      endLifetime: Fr.ZERO,
+      // endLifetime: Fr.ZERO,
       leafIndex,
     };
     this.noteHashChecks.push(traced);
     this.incrementAccessCounter();
   }
 
-  public traceNewNoteHash(_storageAddress: Fr, noteHash: Fr) {
+  public traceNewNoteHash(storageAddress: Fr, noteHash: Fr) {
     // TODO(4805): check if some threshold is reached for max new note hash
-    //const traced: TracedNoteHash = {
-    //  callPointer: Fr.ZERO,
-    //  storageAddress,
-    //  noteHash,
-    //  counter: new Fr(this.accessCounter),
-    //  endLifetime: Fr.ZERO,
-    //};
-    //this.newNoteHashes.push(traced);
-    this.newNoteHashes.push(noteHash);
+    const traced: TracedNoteHash = {
+      //  callPointer: Fr.ZERO,
+      storageAddress,
+      noteHash,
+      counter: new Fr(this.accessCounter),
+      //  endLifetime: Fr.ZERO,
+    };
+    this.newNoteHashes.push(traced);
     this.incrementAccessCounter();
   }
 
   public traceNullifierCheck(storageAddress: Fr, nullifier: Fr, exists: boolean, isPending: boolean, leafIndex: Fr) {
     // TODO(4805): check if some threshold is reached for max new nullifier
     const traced: TracedNullifierCheck = {
-      callPointer: Fr.ZERO, // FIXME
+      // callPointer: Fr.ZERO,
       storageAddress,
       nullifier,
       exists,
       counter: new Fr(this.accessCounter),
-      endLifetime: Fr.ZERO,
+      // endLifetime: Fr.ZERO,
       isPending,
       leafIndex,
     };
@@ -105,17 +107,16 @@ export class WorldStateAccessTrace {
     this.incrementAccessCounter();
   }
 
-  public traceNewNullifier(_storageAddress: Fr, nullifier: Fr) {
+  public traceNewNullifier(storageAddress: Fr, nullifier: Fr) {
     // TODO(4805): check if some threshold is reached for max new nullifier
-    //const traced: TracedNullifier = {
-    //  callPointer: Fr.ZERO,
-    //  storageAddress,
-    //  nullifier,
-    //  counter: new Fr(this.accessCounter),
-    //  endLifetime: Fr.ZERO,
-    //};
-    //this.newNullifiers.push(traced);
-    this.newNullifiers.push(nullifier);
+    const tracedNullifier: TracedNullifier = {
+      // callPointer: Fr.ZERO,
+      storageAddress,
+      nullifier,
+      counter: new Fr(this.accessCounter),
+      // endLifetime: Fr.ZERO,
+    };
+    this.newNullifiers.push(tracedNullifier);
     this.incrementAccessCounter();
   }
 
@@ -146,8 +147,8 @@ export class WorldStateAccessTrace {
    */
   public acceptAndMerge(incomingTrace: WorldStateAccessTrace) {
     // Merge storage read and write journals
-    mergeContractJournalMaps(this.publicStorageReads, incomingTrace.publicStorageReads);
-    mergeContractJournalMaps(this.publicStorageWrites, incomingTrace.publicStorageWrites);
+    this.publicStorageReads = this.publicStorageReads.concat(incomingTrace.publicStorageReads);
+    this.publicStorageWrites = this.publicStorageWrites.concat(incomingTrace.publicStorageWrites);
     // Merge new note hashes and nullifiers
     this.noteHashChecks = this.noteHashChecks.concat(incomingTrace.noteHashChecks);
     this.newNoteHashes = this.newNoteHashes.concat(incomingTrace.newNoteHashes);
@@ -157,67 +158,4 @@ export class WorldStateAccessTrace {
     // it is assumed that the incoming trace was initialized with this as parent, so accept counter
     this.accessCounter = incomingTrace.accessCounter;
   }
-
-  /**
-   * We want to keep track of all performed reads in the journal
-   * This information is hinted to the avm circuit
-
-   * @param contractAddress -
-   * @param key -
-   * @param value -
-   */
-  journalUpdate(map: Map<bigint, Map<bigint, Fr[]>>, contractAddress: Fr, key: Fr, value: Fr): void {
-    let contractMap = map.get(contractAddress.toBigInt());
-    if (!contractMap) {
-      contractMap = new Map<bigint, Array<Fr>>();
-      map.set(contractAddress.toBigInt(), contractMap);
-    }
-
-    let accessArray = contractMap.get(key.toBigInt());
-    if (!accessArray) {
-      accessArray = new Array<Fr>();
-      contractMap.set(key.toBigInt(), accessArray);
-    }
-    accessArray.push(value);
-  }
-
-  // Create an instance of journalUpdate that appends to the read array
-  private journalRead = this.journalUpdate.bind(this, this.publicStorageReads);
-  // Create an instance of journalUpdate that appends to the writes array
-  private journalWrite = this.journalUpdate.bind(this, this.publicStorageWrites);
-}
-
-/**
- * Merges two contract journalling maps together
- * For read maps, we just append the childMap arrays into the host map arrays, as the order is important
- *
- * @param hostMap - The map to be merged into
- * @param childMap - The map to be merged from
- */
-function mergeContractJournalMaps(hostMap: Map<bigint, Map<bigint, Fr[]>>, childMap: Map<bigint, Map<bigint, Fr[]>>) {
-  for (const [key, value] of childMap) {
-    const map1Value = hostMap.get(key);
-    if (!map1Value) {
-      hostMap.set(key, value);
-    } else {
-      mergeStorageJournalMaps(map1Value, value);
-    }
-  }
-}
-
-/**
- * Merge two storage journalling maps together (for a particular contract).
- *
- * @param hostMap - The map to be merge into
- * @param childMap - The map to be merged from
- */
-function mergeStorageJournalMaps(hostMap: Map<bigint, Fr[]>, childMap: Map<bigint, Fr[]>) {
-  for (const [key, value] of childMap) {
-    const readArr = hostMap.get(key);
-    if (!readArr) {
-      hostMap.set(key, value);
-    } else {
-      hostMap.set(key, readArr?.concat(...value));
-    }
-  }
 }