@aztec/simulator 0.62.0 → 0.63.0

package/src/public/dual_side_effect_trace.ts

@@ -1,10 +1,13 @@
+import { type UnencryptedL2Log } from '@aztec/circuit-types';
 import {
-  type CombinedConstantData,
   type ContractClassIdPreimage,
   type Gas,
+  type NullifierLeafPreimage,
+  type PublicCallRequest,
+  type PublicDataTreeLeafPreimage,
   type SerializableContractInstance,
-  type VMCircuitPublicInputs,
 } from '@aztec/circuits.js';
+import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
 
 import { assert } from 'console';
@@ -12,7 +15,7 @@ import { assert } from 'console';
 import { type AvmContractCallResult } from '../avm/avm_contract_call_result.js';
 import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
 import { type PublicEnqueuedCallSideEffectTrace } from './enqueued_call_side_effect_trace.js';
-import { type PublicExecutionResult } from './execution.js';
+import { type EnqueuedPublicCallExecutionResultWithSideEffects, type PublicFunctionCallResult } from './execution.js';
 import { type PublicSideEffectTrace } from './side_effect_trace.js';
 import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 
@@ -26,59 +29,139 @@ export class DualSideEffectTrace implements PublicSideEffectTraceInterface {
     return new DualSideEffectTrace(this.innerCallTrace.fork(), this.enqueuedCallTrace.fork());
   }
 
+  public merge(nestedTrace: this, reverted: boolean = false) {
+    this.enqueuedCallTrace.merge(nestedTrace.enqueuedCallTrace, reverted);
+  }
+
   public getCounter() {
     assert(this.innerCallTrace.getCounter() == this.enqueuedCallTrace.getCounter());
     return this.innerCallTrace.getCounter();
   }
 
-  public tracePublicStorageRead(contractAddress: Fr, slot: Fr, value: Fr, exists: boolean, cached: boolean) {
-    this.innerCallTrace.tracePublicStorageRead(contractAddress, slot, value, exists, cached);
-    this.enqueuedCallTrace.tracePublicStorageRead(contractAddress, slot, value, exists, cached);
+  public tracePublicStorageRead(
+    contractAddress: AztecAddress,
+    slot: Fr,
+    value: Fr,
+    leafPreimage: PublicDataTreeLeafPreimage,
+    leafIndex: Fr,
+    path: Fr[],
+  ) {
+    this.innerCallTrace.tracePublicStorageRead(contractAddress, slot, value, leafPreimage, leafIndex, path);
+    this.enqueuedCallTrace.tracePublicStorageRead(contractAddress, slot, value, leafPreimage, leafIndex, path);
   }
 
-  public tracePublicStorageWrite(contractAddress: Fr, slot: Fr, value: Fr) {
-    this.innerCallTrace.tracePublicStorageWrite(contractAddress, slot, value);
-    this.enqueuedCallTrace.tracePublicStorageWrite(contractAddress, slot, value);
+  public tracePublicStorageWrite(
+    contractAddress: AztecAddress,
+    slot: Fr,
+    value: Fr,
+    lowLeafPreimage: PublicDataTreeLeafPreimage,
+    lowLeafIndex: Fr,
+    lowLeafPath: Fr[],
+    newLeafPreimage: PublicDataTreeLeafPreimage,
+    insertionPath: Fr[],
+  ) {
+    this.innerCallTrace.tracePublicStorageWrite(
+      contractAddress,
+      slot,
+      value,
+      lowLeafPreimage,
+      lowLeafIndex,
+      lowLeafPath,
+      newLeafPreimage,
+      insertionPath,
+    );
+    this.enqueuedCallTrace.tracePublicStorageWrite(
+      contractAddress,
+      slot,
+      value,
+      lowLeafPreimage,
+      lowLeafIndex,
+      lowLeafPath,
+      newLeafPreimage,
+      insertionPath,
+    );
   }
 
   // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
-  public traceNoteHashCheck(_contractAddress: Fr, noteHash: Fr, leafIndex: Fr, exists: boolean) {
-    this.innerCallTrace.traceNoteHashCheck(_contractAddress, noteHash, leafIndex, exists);
-    this.enqueuedCallTrace.traceNoteHashCheck(_contractAddress, noteHash, leafIndex, exists);
+  public traceNoteHashCheck(contractAddress: AztecAddress, noteHash: Fr, leafIndex: Fr, exists: boolean, path: Fr[]) {
+    this.innerCallTrace.traceNoteHashCheck(contractAddress, noteHash, leafIndex, exists, path);
+    this.enqueuedCallTrace.traceNoteHashCheck(contractAddress, noteHash, leafIndex, exists, path);
   }
 
-  public traceNewNoteHash(_contractAddress: Fr, noteHash: Fr) {
-    this.innerCallTrace.traceNewNoteHash(_contractAddress, noteHash);
-    this.enqueuedCallTrace.traceNewNoteHash(_contractAddress, noteHash);
+  public traceNewNoteHash(contractAddress: AztecAddress, noteHash: Fr, leafIndex: Fr, path: Fr[]) {
+    this.innerCallTrace.traceNewNoteHash(contractAddress, noteHash, leafIndex, path);
+    this.enqueuedCallTrace.traceNewNoteHash(contractAddress, noteHash, leafIndex, path);
   }
 
-  public traceNullifierCheck(contractAddress: Fr, nullifier: Fr, leafIndex: Fr, exists: boolean, isPending: boolean) {
-    this.innerCallTrace.traceNullifierCheck(contractAddress, nullifier, leafIndex, exists, isPending);
-    this.enqueuedCallTrace.traceNullifierCheck(contractAddress, nullifier, leafIndex, exists, isPending);
+  public traceNullifierCheck(
+    contractAddress: AztecAddress,
+    nullifier: Fr,
+    exists: boolean,
+    lowLeafPreimage: NullifierLeafPreimage,
+    lowLeafIndex: Fr,
+    lowLeafPath: Fr[],
+  ) {
+    this.innerCallTrace.traceNullifierCheck(
+      contractAddress,
+      nullifier,
+      exists,
+      lowLeafPreimage,
+      lowLeafIndex,
+      lowLeafPath,
+    );
+    this.enqueuedCallTrace.traceNullifierCheck(
+      contractAddress,
+      nullifier,
+      exists,
+      lowLeafPreimage,
+      lowLeafIndex,
+      lowLeafPath,
+    );
   }
 
-  public traceNewNullifier(contractAddress: Fr, nullifier: Fr) {
-    this.innerCallTrace.traceNewNullifier(contractAddress, nullifier);
-    this.enqueuedCallTrace.traceNewNullifier(contractAddress, nullifier);
+  public traceNewNullifier(
+    contractAddress: AztecAddress,
+    nullifier: Fr,
+    lowLeafPreimage: NullifierLeafPreimage,
+    lowLeafIndex: Fr,
+    lowLeafPath: Fr[],
+    insertionPath: Fr[],
+  ) {
+    this.innerCallTrace.traceNewNullifier(
+      contractAddress,
+      nullifier,
+      lowLeafPreimage,
+      lowLeafIndex,
+      lowLeafPath,
+      insertionPath,
+    );
+    this.enqueuedCallTrace.traceNewNullifier(
+      contractAddress,
+      nullifier,
+      lowLeafPreimage,
+      lowLeafIndex,
+      lowLeafPath,
+      insertionPath,
+    );
   }
 
-  public traceL1ToL2MessageCheck(contractAddress: Fr, msgHash: Fr, msgLeafIndex: Fr, exists: boolean) {
-    this.innerCallTrace.traceL1ToL2MessageCheck(contractAddress, msgHash, msgLeafIndex, exists);
-    this.enqueuedCallTrace.traceL1ToL2MessageCheck(contractAddress, msgHash, msgLeafIndex, exists);
+  traceL1ToL2MessageCheck(contractAddress: AztecAddress, msgHash: Fr, msgLeafIndex: Fr, exists: boolean, path: Fr[]) {
+    this.innerCallTrace.traceL1ToL2MessageCheck(contractAddress, msgHash, msgLeafIndex, exists, path);
+    this.enqueuedCallTrace.traceL1ToL2MessageCheck(contractAddress, msgHash, msgLeafIndex, exists, path);
   }
 
-  public traceNewL2ToL1Message(contractAddress: Fr, recipient: Fr, content: Fr) {
+  public traceNewL2ToL1Message(contractAddress: AztecAddress, recipient: Fr, content: Fr) {
     this.innerCallTrace.traceNewL2ToL1Message(contractAddress, recipient, content);
     this.enqueuedCallTrace.traceNewL2ToL1Message(contractAddress, recipient, content);
   }
 
-  public traceUnencryptedLog(contractAddress: Fr, log: Fr[]) {
+  public traceUnencryptedLog(contractAddress: AztecAddress, log: Fr[]) {
     this.innerCallTrace.traceUnencryptedLog(contractAddress, log);
     this.enqueuedCallTrace.traceUnencryptedLog(contractAddress, log);
   }
 
   public traceGetContractInstance(
-    contractAddress: Fr,
+    contractAddress: AztecAddress,
     exists: boolean,
     instance: SerializableContractInstance | undefined,
   ) {
@@ -87,7 +170,7 @@ export class DualSideEffectTrace implements PublicSideEffectTraceInterface {
   }
 
   public traceGetBytecode(
-    contractAddress: Fr,
+    contractAddress: AztecAddress,
     exists: boolean,
     bytecode: Buffer,
     contractInstance: SerializableContractInstance | undefined,
@@ -137,10 +220,32 @@ export class DualSideEffectTrace implements PublicSideEffectTraceInterface {
     );
   }
 
+  public traceEnqueuedCall(
+    /** The call request from private that enqueued this call. */
+    publicCallRequest: PublicCallRequest,
+    /** The call's calldata */
+    calldata: Fr[],
+    /** Did the call revert? */
+    reverted: boolean,
+  ) {
+    this.enqueuedCallTrace.traceEnqueuedCall(publicCallRequest, calldata, reverted);
+  }
+
   /**
    * Convert this trace to a PublicExecutionResult for use externally to the simulator.
    */
-  public toPublicExecutionResult(
+  public toPublicEnqueuedCallExecutionResult(
+    /** How much gas was left after this public execution. */
+    endGasLeft: Gas,
+    /** The call's results */
+    avmCallResults: AvmContractCallResult,
+  ): EnqueuedPublicCallExecutionResultWithSideEffects {
+    return this.enqueuedCallTrace.toPublicEnqueuedCallExecutionResult(endGasLeft, avmCallResults);
+  }
+  /**
+   * Convert this trace to a PublicExecutionResult for use externally to the simulator.
+   */
+  public toPublicFunctionCallResult(
     /** The execution environment of the nested call. */
     avmEnvironment: AvmExecutionEnvironment,
     /** How much gas was available for this public execution. */
@@ -153,8 +258,8 @@ export class DualSideEffectTrace implements PublicSideEffectTraceInterface {
     avmCallResults: AvmContractCallResult,
     /** Function name for logging */
     functionName: string = 'unknown',
-  ): PublicExecutionResult {
-    return this.innerCallTrace.toPublicExecutionResult(
+  ): PublicFunctionCallResult {
+    return this.innerCallTrace.toPublicFunctionCallResult(
       avmEnvironment,
       startGasLeft,
       endGasLeft,
@@ -164,24 +269,7 @@ export class DualSideEffectTrace implements PublicSideEffectTraceInterface {
     );
   }
 
-  public toVMCircuitPublicInputs(
-    /** Constants */
-    constants: CombinedConstantData,
-    /** 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,
-    /** The call's results */
-    avmCallResults: AvmContractCallResult,
-  ): VMCircuitPublicInputs {
-    return this.enqueuedCallTrace.toVMCircuitPublicInputs(
-      constants,
-      avmEnvironment,
-      startGasLeft,
-      endGasLeft,
-      avmCallResults,
-    );
+  public getUnencryptedLogs(): UnencryptedL2Log[] {
+    return this.enqueuedCallTrace.getUnencryptedLogs();
   }
 }