@aztec/simulator 0.43.0 → 0.45.0

package/src/public/side_effect_trace.ts

@@ -0,0 +1,341 @@
+import { UnencryptedFunctionL2Logs, UnencryptedL2Log } from '@aztec/circuit-types';
+import {
+  AvmContractInstanceHint,
+  AvmExecutionHints,
+  AvmExternalCallHint,
+  AvmKeyValueHint,
+  AztecAddress,
+  CallContext,
+  ContractStorageRead,
+  ContractStorageUpdateRequest,
+  EthAddress,
+  Gas,
+  L2ToL1Message,
+  LogHash,
+  NoteHash,
+  Nullifier,
+  ReadRequest,
+} from '@aztec/circuits.js';
+import { EventSelector } from '@aztec/foundation/abi';
+import { Fr } from '@aztec/foundation/fields';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { type AvmContractCallResult } from '../avm/avm_contract_call_result.js';
+import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
+import { createSimulationError } from '../common/errors.js';
+import { type PublicExecutionRequest, type PublicExecutionResult } from './execution.js';
+import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
+
+export type TracedContractInstance = { exists: boolean } & ContractInstanceWithAddress;
+
+export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
+  public logger = createDebugLogger('aztec:public_side_effect_trace');
+
+  /** The side effect counter increments with every call to the trace. */
+  private sideEffectCounter: number; // kept as number until finalized for efficiency
+
+  private contractStorageReads: ContractStorageRead[] = [];
+  private contractStorageUpdateRequests: ContractStorageUpdateRequest[] = [];
+
+  private noteHashReadRequests: ReadRequest[] = [];
+  private newNoteHashes: NoteHash[] = [];
+
+  private nullifierReadRequests: ReadRequest[] = [];
+  private nullifierNonExistentReadRequests: ReadRequest[] = [];
+  private newNullifiers: Nullifier[] = [];
+
+  private l1ToL2MsgReadRequests: ReadRequest[] = [];
+  private newL2ToL1Messages: L2ToL1Message[] = [];
+
+  private unencryptedLogs: UnencryptedL2Log[] = [];
+  private allUnencryptedLogs: UnencryptedL2Log[] = [];
+  private unencryptedLogsHashes: LogHash[] = [];
+
+  private gotContractInstances: ContractInstanceWithAddress[] = [];
+
+  private nestedExecutions: PublicExecutionResult[] = [];
+
+  private avmCircuitHints: AvmExecutionHints;
+
+  constructor(
+    /** The counter of this trace's first side effect. */
+    public readonly startSideEffectCounter: number = 0,
+  ) {
+    this.sideEffectCounter = startSideEffectCounter;
+    this.avmCircuitHints = AvmExecutionHints.empty();
+  }
+
+  public fork() {
+    return new PublicSideEffectTrace(this.sideEffectCounter);
+  }
+
+  public getCounter() {
+    return this.sideEffectCounter;
+  }
+
+  private incrementSideEffectCounter() {
+    this.sideEffectCounter++;
+  }
+
+  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, _exists: boolean, _cached: 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)
+    // NOTE: exists and cached are unused for now but may be used for optimizations or kernel hints later
+    this.contractStorageReads.push(
+      new ContractStorageRead(slot, value, this.sideEffectCounter, AztecAddress.fromField(storageAddress)),
+    );
+    this.avmCircuitHints.storageValues.items.push(
+      new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ value),
+    );
+    this.logger.debug(`SLOAD cnt: ${this.sideEffectCounter} val: ${value} slot: ${slot}`);
+    this.incrementSideEffectCounter();
+  }
+
+  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)
+    this.contractStorageUpdateRequests.push(
+      new ContractStorageUpdateRequest(slot, value, this.sideEffectCounter, storageAddress),
+    );
+    this.logger.debug(`SSTORE cnt: ${this.sideEffectCounter} val: ${value} slot: ${slot}`);
+    this.incrementSideEffectCounter();
+  }
+
+  public traceNoteHashCheck(_storageAddress: Fr, noteHash: Fr, _leafIndex: Fr, exists: boolean) {
+    // TODO(4805): check if some threshold is reached for max note hash checks
+    // NOTE: storageAddress is unused but will be important when an AVM circuit processes an entire enqueued call
+    // TODO(dbanks12): leafIndex is unused for now but later must be used by kernel to constrain that the kernel
+    // is in fact checking the leaf indicated by the user
+    this.noteHashReadRequests.push(new ReadRequest(noteHash, this.sideEffectCounter));
+    this.avmCircuitHints.noteHashExists.items.push(
+      new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ new Fr(exists ? 1 : 0)),
+    );
+    this.logger.debug(`NOTE_HASH_CHECK cnt: ${this.sideEffectCounter}`);
+    this.incrementSideEffectCounter();
+  }
+
+  public traceNewNoteHash(_storageAddress: Fr, noteHash: Fr) {
+    // TODO(4805): check if some threshold is reached for max new note hash
+    // NOTE: storageAddress is unused but will be important when an AVM circuit processes an entire enqueued call
+    // TODO(dbanks12): non-existent note hashes should emit a read request of the note hash that actually
+    // IS there, and the AVM circuit should accept THAT noteHash as a hint. The circuit will then compare
+    // the noteHash against the one provided by the user code to determine what to return to the user (exists or not),
+    // and will then propagate the actually-present noteHash to its public inputs.
+    this.newNoteHashes.push(new NoteHash(noteHash, this.sideEffectCounter));
+    this.logger.debug(`NEW_NOTE_HASH cnt: ${this.sideEffectCounter}`);
+    this.incrementSideEffectCounter();
+  }
+
+  public traceNullifierCheck(_storageAddress: Fr, nullifier: Fr, _leafIndex: Fr, exists: boolean, _isPending: boolean) {
+    // TODO(4805): check if some threshold is reached for max new nullifier
+    // NOTE: storageAddress is unused but will be important when an AVM circuit processes an entire enqueued call
+    // NOTE: isPending and leafIndex are unused for now but may be used for optimizations or kernel hints later
+    const readRequest = new ReadRequest(nullifier, this.sideEffectCounter);
+    if (exists) {
+      this.nullifierReadRequests.push(readRequest);
+    } else {
+      this.nullifierNonExistentReadRequests.push(readRequest);
+    }
+    this.avmCircuitHints.nullifierExists.items.push(
+      new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ new Fr(exists ? 1 : 0)),
+    );
+    this.logger.debug(`NULLIFIER_EXISTS cnt: ${this.sideEffectCounter}`);
+    this.incrementSideEffectCounter();
+  }
+
+  public traceNewNullifier(_storageAddress: Fr, nullifier: Fr) {
+    // TODO(4805): check if some threshold is reached for max new nullifier
+    // NOTE: storageAddress is unused but will be important when an AVM circuit processes an entire enqueued call
+    this.newNullifiers.push(new Nullifier(nullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
+    this.logger.debug(`NEW_NULLIFIER cnt: ${this.sideEffectCounter}`);
+    this.incrementSideEffectCounter();
+  }
+
+  public traceL1ToL2MessageCheck(_contractAddress: Fr, msgHash: Fr, _msgLeafIndex: Fr, exists: boolean) {
+    // TODO(4805): check if some threshold is reached for max message reads
+    // NOTE: contractAddress is unused but will be important when an AVM circuit processes an entire enqueued call
+    // TODO(dbanks12): leafIndex is unused for now but later must be used by kernel to constrain that the kernel
+    // is in fact checking the leaf indicated by the user
+    this.l1ToL2MsgReadRequests.push(new ReadRequest(msgHash, this.sideEffectCounter));
+    this.avmCircuitHints.l1ToL2MessageExists.items.push(
+      new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ new Fr(exists ? 1 : 0)),
+    );
+    this.logger.debug(`L1_TO_L2_MSG_CHECK cnt: ${this.sideEffectCounter}`);
+    this.incrementSideEffectCounter();
+  }
+
+  public traceNewL2ToL1Message(recipient: Fr, content: Fr) {
+    // TODO(4805): check if some threshold is reached for max messages
+    const recipientAddress = EthAddress.fromField(recipient);
+    this.newL2ToL1Messages.push(new L2ToL1Message(recipientAddress, content, this.sideEffectCounter));
+    this.logger.debug(`NEW_L2_TO_L1_MSG cnt: ${this.sideEffectCounter}`);
+    this.incrementSideEffectCounter();
+  }
+
+  public traceUnencryptedLog(contractAddress: Fr, log: Fr[]) {
+    // TODO(4805): check if some threshold is reached for max logs
+    const ulog = new UnencryptedL2Log(
+      AztecAddress.fromField(contractAddress),
+      // TODO(#7198): Remove event selector from UnencryptedL2Log
+      EventSelector.fromField(new Fr(0)),
+      Buffer.concat(log.map(f => f.toBuffer())),
+    );
+    const basicLogHash = Fr.fromBuffer(ulog.hash());
+    this.unencryptedLogs.push(ulog);
+    this.allUnencryptedLogs.push(ulog);
+    // TODO(6578): explain magic number 4 here
+    this.unencryptedLogsHashes.push(new LogHash(basicLogHash, this.sideEffectCounter, new Fr(ulog.length + 4)));
+    this.logger.debug(`NEW_UNENCRYPTED_LOG cnt: ${this.sideEffectCounter}`);
+    this.incrementSideEffectCounter();
+  }
+
+  public traceGetContractInstance(instance: TracedContractInstance) {
+    // TODO(4805): check if some threshold is reached for max contract instance retrievals
+    this.gotContractInstances.push(instance);
+    this.avmCircuitHints.contractInstances.items.push(
+      new AvmContractInstanceHint(
+        instance.address,
+        new Fr(instance.exists ? 1 : 0),
+        instance.salt,
+        instance.deployer,
+        instance.contractClassId,
+        instance.initializationHash,
+        instance.publicKeysHash,
+      ),
+    );
+    this.logger.debug(`CONTRACT_INSTANCE cnt: ${this.sideEffectCounter}`);
+    this.incrementSideEffectCounter();
+  }
+
+  /**
+   * Trace a nested call.
+   * Accept some results from a finished nested call's trace into this one.
+   */
+  public traceNestedCall(
+    /** The trace of the nested call. */
+    nestedCallTrace: PublicSideEffectTrace,
+    /** The execution environment of the nested call. */
+    nestedEnvironment: AvmExecutionEnvironment,
+    /** How much gas was available for this public execution. */
+    startGasLeft: Gas,
+    /** How much gas was left after this public execution. */
+    endGasLeft: Gas,
+    /** Bytecode used for this execution. */
+    bytecode: Buffer,
+    /** The call's results */
+    avmCallResults: AvmContractCallResult,
+    /** Function name for logging */
+    functionName: string = 'unknown',
+  ) {
+    const result = nestedCallTrace.toPublicExecutionResult(
+      nestedEnvironment,
+      startGasLeft,
+      endGasLeft,
+      bytecode,
+      avmCallResults,
+      functionName,
+    );
+    this.sideEffectCounter = result.endSideEffectCounter.toNumber();
+    // when a nested call returns, caller accepts its updated counter
+    this.allUnencryptedLogs.push(...result.allUnencryptedLogs.logs);
+    // NOTE: eventually if the AVM circuit processes an entire enqueued call,
+    // this function will accept all of the nested's side effects into this instance
+    this.nestedExecutions.push(result);
+
+    const gasUsed = new Gas(
+      result.startGasLeft.daGas - result.endGasLeft.daGas,
+      result.startGasLeft.l2Gas - result.endGasLeft.l2Gas,
+    );
+    this.avmCircuitHints.externalCalls.items.push(
+      new AvmExternalCallHint(
+        /*success=*/ new Fr(result.reverted ? 0 : 1),
+        result.returnValues,
+        gasUsed,
+        result.endSideEffectCounter,
+      ),
+    );
+  }
+
+  /**
+   * Convert this trace to a PublicExecutionResult for use externally to the simulator.
+   */
+  public toPublicExecutionResult(
+    /** The execution environment of the nested call. */
+    avmEnvironment: AvmExecutionEnvironment,
+    /** How much gas was available for this public execution. */
+    startGasLeft: Gas,
+    /** How much gas was left after this public execution. */
+    endGasLeft: Gas,
+    /** Bytecode used for this execution. */
+    bytecode: Buffer,
+    /** The call's results */
+    avmCallResults: AvmContractCallResult,
+    /** Function name for logging */
+    functionName: string = 'unknown',
+    /** The side effect counter of the execution request itself */
+    requestSideEffectCounter: number = this.startSideEffectCounter,
+  ): PublicExecutionResult {
+    return {
+      executionRequest: createPublicExecutionRequest(requestSideEffectCounter, avmEnvironment),
+
+      startSideEffectCounter: new Fr(this.startSideEffectCounter),
+      endSideEffectCounter: new Fr(this.sideEffectCounter),
+      startGasLeft,
+      endGasLeft,
+      transactionFee: avmEnvironment.transactionFee,
+
+      bytecode,
+      calldata: avmEnvironment.calldata,
+      returnValues: avmCallResults.output,
+      reverted: avmCallResults.reverted,
+      revertReason: avmCallResults.revertReason ? createSimulationError(avmCallResults.revertReason) : undefined,
+
+      contractStorageReads: this.contractStorageReads,
+      contractStorageUpdateRequests: this.contractStorageUpdateRequests,
+      noteHashReadRequests: this.noteHashReadRequests,
+      newNoteHashes: this.newNoteHashes,
+      nullifierReadRequests: this.nullifierReadRequests,
+      nullifierNonExistentReadRequests: this.nullifierNonExistentReadRequests,
+      newNullifiers: this.newNullifiers,
+      l1ToL2MsgReadRequests: this.l1ToL2MsgReadRequests,
+      newL2ToL1Messages: this.newL2ToL1Messages,
+      // correct the type on these now that they are finalized (lists won't grow)
+      unencryptedLogs: new UnencryptedFunctionL2Logs(this.unencryptedLogs),
+      allUnencryptedLogs: new UnencryptedFunctionL2Logs(this.allUnencryptedLogs),
+      unencryptedLogsHashes: this.unencryptedLogsHashes,
+      // TODO(dbanks12): process contract instance read requests in public kernel
+      //gotContractInstances: this.gotContractInstances,
+
+      nestedExecutions: this.nestedExecutions,
+
+      avmCircuitHints: this.avmCircuitHints,
+
+      functionName,
+    };
+  }
+}
+
+/**
+ * Helper function to create a public execution request from an AVM execution environment
+ */
+function createPublicExecutionRequest(
+  requestSideEffectCounter: number,
+  avmEnvironment: AvmExecutionEnvironment,
+): PublicExecutionRequest {
+  const callContext = CallContext.from({
+    msgSender: avmEnvironment.sender,
+    storageContractAddress: avmEnvironment.storageAddress,
+    functionSelector: avmEnvironment.functionSelector,
+    isDelegateCall: avmEnvironment.isDelegateCall,
+    isStaticCall: avmEnvironment.isStaticCall,
+    sideEffectCounter: requestSideEffectCounter,
+  });
+  return {
+    contractAddress: avmEnvironment.address,
+    functionSelector: avmEnvironment.functionSelector,
+    callContext,
+    // execution request does not contain AvmContextInputs prefix
+    args: avmEnvironment.getCalldataWithoutPrefix(),
+  };
+}

package/src/public/side_effect_trace_interface.ts

@@ -0,0 +1,41 @@
+import { type Gas } from '@aztec/circuits.js';
+import { type Fr } from '@aztec/foundation/fields';
+
+import { type AvmContractCallResult } from '../avm/avm_contract_call_result.js';
+import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
+import { type TracedContractInstance } from './side_effect_trace.js';
+
+export interface PublicSideEffectTraceInterface {
+  fork(): PublicSideEffectTraceInterface;
+  getCounter(): number;
+  tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, exists: boolean, cached: boolean): void;
+  tracePublicStorageWrite(storageAddress: Fr, slot: Fr, value: Fr): void;
+  traceNoteHashCheck(storageAddress: Fr, noteHash: Fr, leafIndex: Fr, exists: boolean): void;
+  traceNewNoteHash(storageAddress: Fr, noteHash: Fr): void;
+  traceNullifierCheck(storageAddress: Fr, nullifier: Fr, leafIndex: Fr, exists: boolean, isPending: boolean): void;
+  traceNewNullifier(storageAddress: Fr, nullifier: Fr): void;
+  traceL1ToL2MessageCheck(contractAddress: Fr, msgHash: Fr, msgLeafIndex: Fr, exists: boolean): void;
+  // TODO(dbanks12): should new message accept contract address as arg?
+  traceNewL2ToL1Message(recipient: Fr, content: Fr): void;
+  traceUnencryptedLog(contractAddress: Fr, log: Fr[]): void;
+  // TODO(dbanks12): odd that getContractInstance is a one-off in that it accepts an entire object instead of components
+  traceGetContractInstance(instance: TracedContractInstance): void;
+  traceNestedCall(
+    /** The trace of the nested call. */
+    nestedCallTrace: PublicSideEffectTraceInterface,
+    /** The execution environment of the nested call. */
+    nestedEnvironment: AvmExecutionEnvironment,
+    /** How much gas was available for this public execution. */
+    // TODO(dbanks12): consider moving to AvmExecutionEnvironment
+    startGasLeft: Gas,
+    /** How much gas was left after this public execution. */
+    // TODO(dbanks12): consider moving to AvmContractCallResults
+    endGasLeft: Gas,
+    /** Bytecode used for this execution. */
+    bytecode: Buffer,
+    /** The call's results */
+    avmCallResults: AvmContractCallResult,
+    /** Function name */
+    functionName: string,
+  ): void;
+}

package/src/public/teardown_phase_manager.ts

@@ -44,6 +44,7 @@ export class TeardownPhaseManager extends AbstractPhaseManager {
       );
     if (revertReason) {
       await this.publicStateDB.rollbackToCheckpoint();
+      tx.filterRevertedLogs(kernelOutput);
     } else {
       // TODO(#6464): Should we allow emitting contracts in the public teardown phase?
       // if so, we should insert them here

package/src/rollup/rollup.ts

@@ -28,7 +28,9 @@ import {
   convertSimulatedBaseRollupInputsToWitnessMap,
   convertSimulatedBaseRollupOutputsFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
-import { type SimulationProvider, WASMSimulator } from '@aztec/simulator';
+
+import { WASMSimulator } from '../providers/acvm_wasm.js';
+import { type SimulationProvider } from '../providers/simulation_provider.js';
 
 /**
  * Circuit simulator for the rollup circuits.

package/dest/avm/avm_message_call_result.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"avm_message_call_result.d.ts","sourceRoot":"","sources":["../../src/avm/avm_message_call_result.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;GAEG;AACH,qBAAa,sBAAsB;IACd,QAAQ,EAAE,OAAO;IAAS,MAAM,EAAE,EAAE,EAAE;IAAS,YAAY,CAAC;gBAA5D,QAAQ,EAAE,OAAO,EAAS,MAAM,EAAE,EAAE,EAAE,EAAS,YAAY,CAAC,6BAAiB;IAEhG,QAAQ,IAAI,MAAM;CAOnB"}

package/dest/avm/avm_message_call_result.js

@@ -1,18 +0,0 @@
-/**
- * Results of an contract call's execution in the AVM.
- */
-export class AvmContractCallResults {
-    constructor(reverted, output, revertReason) {
-        this.reverted = reverted;
-        this.output = output;
-        this.revertReason = revertReason;
-    }
-    toString() {
-        let resultsStr = `reverted: ${this.reverted}, output: ${this.output}`;
-        if (this.revertReason) {
-            resultsStr += `, revertReason: ${this.revertReason}`;
-        }
-        return resultsStr;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZtX21lc3NhZ2VfY2FsbF9yZXN1bHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXZtL2F2bV9tZXNzYWdlX2NhbGxfcmVzdWx0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBOztHQUVHO0FBQ0gsTUFBTSxPQUFPLHNCQUFzQjtJQUNqQyxZQUFtQixRQUFpQixFQUFTLE1BQVksRUFBUyxZQUE4QjtRQUE3RSxhQUFRLEdBQVIsUUFBUSxDQUFTO1FBQVMsV0FBTSxHQUFOLE1BQU0sQ0FBTTtRQUFTLGlCQUFZLEdBQVosWUFBWSxDQUFrQjtJQUFHLENBQUM7SUFFcEcsUUFBUTtRQUNOLElBQUksVUFBVSxHQUFHLGFBQWEsSUFBSSxDQUFDLFFBQVEsYUFBYSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDdEUsSUFBSSxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7WUFDdEIsVUFBVSxJQUFJLG1CQUFtQixJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7UUFDdkQsQ0FBQztRQUNELE9BQU8sVUFBVSxDQUFDO0lBQ3BCLENBQUM7Q0FDRiJ9

package/dest/avm/journal/trace.d.ts

@@ -1,33 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { type TracedContractInstance, type TracedL1toL2MessageCheck, type TracedNoteHash, type TracedNoteHashCheck, type TracedNullifier, type TracedNullifierCheck, type TracedPublicStorageRead, type TracedPublicStorageWrite, type TracedUnencryptedL2Log } from './trace_types.js';
-export declare class WorldStateAccessTrace {
-    accessCounter: number;
-    publicStorageReads: TracedPublicStorageRead[];
-    publicStorageWrites: TracedPublicStorageWrite[];
-    noteHashChecks: TracedNoteHashCheck[];
-    newNoteHashes: TracedNoteHash[];
-    nullifierChecks: TracedNullifierCheck[];
-    newNullifiers: TracedNullifier[];
-    l1ToL2MessageChecks: TracedL1toL2MessageCheck[];
-    newLogsHashes: TracedUnencryptedL2Log[];
-    gotContractInstances: TracedContractInstance[];
-    constructor(parentTrace?: WorldStateAccessTrace);
-    getAccessCounter(): number;
-    tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, exists: boolean, cached: boolean): void;
-    tracePublicStorageWrite(storageAddress: Fr, slot: Fr, value: Fr): void;
-    traceNoteHashCheck(storageAddress: Fr, noteHash: Fr, exists: boolean, leafIndex: Fr): void;
-    traceNewNoteHash(storageAddress: Fr, noteHash: Fr): void;
-    traceNullifierCheck(storageAddress: Fr, nullifier: Fr, exists: boolean, isPending: boolean, leafIndex: Fr): void;
-    traceNewNullifier(storageAddress: Fr, nullifier: Fr): void;
-    traceL1ToL2MessageCheck(msgHash: Fr, msgLeafIndex: Fr, exists: boolean): void;
-    traceNewLog(logHash: Fr): void;
-    traceGetContractInstance(instance: TracedContractInstance): void;
-    private incrementAccessCounter;
-    /**
-     * Merges another trace into this one
-     *
-     * @param incomingTrace - the incoming trace to merge into this instance
-     */
-    acceptAndMerge(incomingTrace: WorldStateAccessTrace): void;
-}
-//# sourceMappingURL=trace.d.ts.map

package/dest/avm/journal/trace.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../../src/avm/journal/trace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EACL,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC5B,MAAM,kBAAkB,CAAC;AAE1B,qBAAa,qBAAqB;IACzB,aAAa,EAAE,MAAM,CAAC;IAEtB,kBAAkB,EAAE,uBAAuB,EAAE,CAAM;IACnD,mBAAmB,EAAE,wBAAwB,EAAE,CAAM;IAErD,cAAc,EAAE,mBAAmB,EAAE,CAAM;IAC3C,aAAa,EAAE,cAAc,EAAE,CAAM;IACrC,eAAe,EAAE,oBAAoB,EAAE,CAAM;IAC7C,aAAa,EAAE,eAAe,EAAE,CAAM;IACtC,mBAAmB,EAAE,wBAAwB,EAAE,CAAM;IACrD,aAAa,EAAE,sBAAsB,EAAE,CAAM;IAC7C,oBAAoB,EAAE,sBAAsB,EAAE,CAAM;gBAK/C,WAAW,CAAC,EAAE,qBAAqB;IAKxC,gBAAgB;IAIhB,sBAAsB,CAAC,cAAc,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO;IAiBhG,uBAAuB,CAAC,cAAc,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE;IAe/D,kBAAkB,CAAC,cAAc,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE;IAcnF,gBAAgB,CAAC,cAAc,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE;IAajD,mBAAmB,CAAC,cAAc,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE;IAgBzG,iBAAiB,CAAC,cAAc,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE;IAanD,uBAAuB,CAAC,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO;IActE,WAAW,CAAC,OAAO,EAAE,EAAE;IASvB,wBAAwB,CAAC,QAAQ,EAAE,sBAAsB;IAKhE,OAAO,CAAC,sBAAsB;IAI9B;;;;OAIG;IACI,cAAc,CAAC,aAAa,EAAE,qBAAqB;CAe3D"}

package/dest/avm/journal/trace.js

@@ -1,152 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-export class WorldStateAccessTrace {
-    //public contractCalls: TracedContractCall[] = [];
-    //public archiveChecks: TracedArchiveLeafCheck[] = [];
-    constructor(parentTrace) {
-        this.publicStorageReads = [];
-        this.publicStorageWrites = [];
-        this.noteHashChecks = [];
-        this.newNoteHashes = [];
-        this.nullifierChecks = [];
-        this.newNullifiers = [];
-        this.l1ToL2MessageChecks = [];
-        this.newLogsHashes = [];
-        this.gotContractInstances = [];
-        this.accessCounter = parentTrace ? parentTrace.accessCounter : 0;
-        // TODO(4805): consider tracking the parent's trace vector lengths so we can enforce limits
-    }
-    getAccessCounter() {
-        return this.accessCounter;
-    }
-    tracePublicStorageRead(storageAddress, slot, value, exists, cached) {
-        // 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 = {
-            //  callPointer: Fr.ZERO,
-            storageAddress,
-            slot,
-            value,
-            exists,
-            cached,
-            counter: new Fr(this.accessCounter),
-            //  endLifetime: Fr.ZERO,
-        };
-        this.publicStorageReads.push(traced);
-        this.incrementAccessCounter();
-    }
-    tracePublicStorageWrite(storageAddress, slot, value) {
-        // 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 = {
-            //  callPointer: Fr.ZERO,
-            storageAddress,
-            slot,
-            value,
-            counter: new Fr(this.accessCounter),
-            //  endLifetime: Fr.ZERO,
-        };
-        this.publicStorageWrites.push(traced);
-        this.incrementAccessCounter();
-    }
-    traceNoteHashCheck(storageAddress, noteHash, exists, leafIndex) {
-        const traced = {
-            // callPointer: Fr.ZERO,
-            storageAddress,
-            noteHash,
-            exists,
-            counter: new Fr(this.accessCounter),
-            // endLifetime: Fr.ZERO,
-            leafIndex,
-        };
-        this.noteHashChecks.push(traced);
-        this.incrementAccessCounter();
-    }
-    traceNewNoteHash(storageAddress, noteHash) {
-        // TODO(4805): check if some threshold is reached for max new note hash
-        const traced = {
-            //  callPointer: Fr.ZERO,
-            storageAddress,
-            noteHash,
-            counter: new Fr(this.accessCounter),
-            //  endLifetime: Fr.ZERO,
-        };
-        this.newNoteHashes.push(traced);
-        this.incrementAccessCounter();
-    }
-    traceNullifierCheck(storageAddress, nullifier, exists, isPending, leafIndex) {
-        // TODO(4805): check if some threshold is reached for max new nullifier
-        const traced = {
-            // callPointer: Fr.ZERO,
-            storageAddress,
-            nullifier,
-            exists,
-            counter: new Fr(this.accessCounter),
-            // endLifetime: Fr.ZERO,
-            isPending,
-            leafIndex,
-        };
-        this.nullifierChecks.push(traced);
-        this.incrementAccessCounter();
-    }
-    traceNewNullifier(storageAddress, nullifier) {
-        // TODO(4805): check if some threshold is reached for max new nullifier
-        const tracedNullifier = {
-            // callPointer: Fr.ZERO,
-            storageAddress,
-            nullifier,
-            counter: new Fr(this.accessCounter),
-            // endLifetime: Fr.ZERO,
-        };
-        this.newNullifiers.push(tracedNullifier);
-        this.incrementAccessCounter();
-    }
-    traceL1ToL2MessageCheck(msgHash, msgLeafIndex, exists) {
-        // TODO(4805): check if some threshold is reached for max message reads
-        const traced = {
-            //callPointer: Fr.ZERO, // FIXME
-            leafIndex: msgLeafIndex,
-            msgHash: msgHash,
-            exists: exists,
-            counter: new Fr(this.accessCounter),
-            //endLifetime: Fr.ZERO, // FIXME
-        };
-        this.l1ToL2MessageChecks.push(traced);
-        this.incrementAccessCounter();
-    }
-    traceNewLog(logHash) {
-        const traced = {
-            logHash,
-            counter: new Fr(this.accessCounter),
-        };
-        this.newLogsHashes.push(traced);
-        this.incrementAccessCounter();
-    }
-    traceGetContractInstance(instance) {
-        this.gotContractInstances.push(instance);
-        this.incrementAccessCounter();
-    }
-    incrementAccessCounter() {
-        this.accessCounter++;
-    }
-    /**
-     * Merges another trace into this one
-     *
-     * @param incomingTrace - the incoming trace to merge into this instance
-     */
-    acceptAndMerge(incomingTrace) {
-        // Merge storage read and write journals
-        this.publicStorageReads.push(...incomingTrace.publicStorageReads);
-        this.publicStorageWrites.push(...incomingTrace.publicStorageWrites);
-        // Merge new note hashes and nullifiers
-        this.noteHashChecks.push(...incomingTrace.noteHashChecks);
-        this.newNoteHashes.push(...incomingTrace.newNoteHashes);
-        this.nullifierChecks.push(...incomingTrace.nullifierChecks);
-        this.newNullifiers.push(...incomingTrace.newNullifiers);
-        this.l1ToL2MessageChecks.push(...incomingTrace.l1ToL2MessageChecks);
-        this.newLogsHashes.push(...incomingTrace.newLogsHashes);
-        this.gotContractInstances.push(...incomingTrace.gotContractInstances);
-        // it is assumed that the incoming trace was initialized with this as parent, so accept counter
-        this.accessCounter = incomingTrace.accessCounter;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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