@aztec/simulator 0.43.0 → 0.44.0

package/src/public/public_processor.ts

@@ -30,6 +30,7 @@ import {
   computeFeePayerBalanceLeafSlot,
   computeFeePayerBalanceStorageSlot,
 } from '@aztec/simulator';
+import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
 import { type ContractDataSource } from '@aztec/types/contracts';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
@@ -47,6 +48,7 @@ export class PublicProcessorFactory {
     private merkleTree: MerkleTreeOperations,
     private contractDataSource: ContractDataSource,
     private simulator: SimulationProvider,
+    private telemetryClient: TelemetryClient,
   ) {}
 
   /**
@@ -74,6 +76,7 @@ export class PublicProcessorFactory {
       historicalHeader,
       publicContractsDB,
       worldStatePublicDB,
+      this.telemetryClient,
     );
   }
 }
@@ -83,6 +86,7 @@ export class PublicProcessorFactory {
  * any public function calls in them. Txs with private calls only are unaffected.
  */
 export class PublicProcessor {
+  public readonly tracer: Tracer;
   constructor(
     protected db: MerkleTreeOperations,
     protected publicExecutor: PublicExecutor,
@@ -91,9 +95,11 @@ export class PublicProcessor {
     protected historicalHeader: Header,
     protected publicContractsDB: ContractsDataSourcePublicDB,
     protected publicStateDB: PublicStateDB,
-
+    telemetryClient: TelemetryClient,
     private log = createDebugLogger('aztec:sequencer:public-processor'),
-  ) {}
+  ) {
+    this.tracer = telemetryClient.getTracer('PublicProcessor');
+  }
 
   /**
    * Run each tx through the public circuit and the public kernel circuit if needed.
@@ -208,6 +214,9 @@ export class PublicProcessor {
     return finalPublicDataUpdateRequests;
   }
 
+  @trackSpan('PublicProcessor.processTxWithPublicCalls', tx => ({
+    [Attributes.TX_HASH]: tx.getTxHash().toString(),
+  }))
   private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
     let returnValues: NestedProcessReturnValues[] = [];
     const publicProvingRequests: PublicProvingRequest[] = [];

package/src/public/side_effect_trace.ts

@@ -0,0 +1,323 @@
+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 { type ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
+import { type AvmContractCallResults } from '../avm/avm_message_call_result.js';
+import { createSimulationError } from '../common/errors.js';
+import { type PublicExecution, 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 {
+  /** 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.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.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.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.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.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.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.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.incrementSideEffectCounter();
+  }
+
+  public traceUnencryptedLog(contractAddress: Fr, event: Fr, log: Fr[]) {
+    // TODO(4805): check if some threshold is reached for max logs
+    const ulog = new UnencryptedL2Log(
+      AztecAddress.fromField(contractAddress),
+      EventSelector.fromField(event),
+      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.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.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: AvmContractCallResults,
+    /** 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),
+    );
+  }
+
+  /**
+   * 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: AvmContractCallResults,
+    /** Function name for logging */
+    functionName: string = 'unknown',
+    /** The side effect counter of the execution request itself */
+    requestSideEffectCounter: number = this.startSideEffectCounter,
+  ): PublicExecutionResult {
+    return {
+      execution: 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,
+): PublicExecution {
+  const callContext = CallContext.from({
+    msgSender: avmEnvironment.sender,
+    storageContractAddress: avmEnvironment.storageAddress,
+    functionSelector: avmEnvironment.temporaryFunctionSelector,
+    isDelegateCall: avmEnvironment.isDelegateCall,
+    isStaticCall: avmEnvironment.isStaticCall,
+    sideEffectCounter: requestSideEffectCounter,
+  });
+  const execution: PublicExecution = {
+    contractAddress: avmEnvironment.address,
+    functionSelector: avmEnvironment.temporaryFunctionSelector,
+    callContext,
+    // execution request does not contain AvmContextInputs prefix
+    args: avmEnvironment.getCalldataWithoutPrefix(),
+  };
+  return execution;
+}

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 AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
+import { type AvmContractCallResults } from '../avm/avm_message_call_result.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, event: 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: AvmContractCallResults,
+    /** 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/public/transitional_adaptors.ts

@@ -1,29 +1,13 @@
 // All code in this file needs to die once the public executor is phased out in favor of the AVM.
-import { UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
-import {
-  AvmContractInstanceHint,
-  AvmExecutionHints,
-  AvmExternalCallHint,
-  AvmKeyValueHint,
-  CallContext,
-  Gas,
-  type GasSettings,
-  type GlobalVariables,
-  type Header,
-} from '@aztec/circuits.js';
+import { type GasSettings, type GlobalVariables, type Header } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 
 import { promisify } from 'util';
 import { gunzip } from 'zlib';
 
-import { type AvmContext } from '../avm/avm_context.js';
 import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
-import { type AvmContractCallResults } from '../avm/avm_message_call_result.js';
-import { type PartialPublicExecutionResult } from '../avm/journal/journal.js';
-import { type WorldStateAccessTrace } from '../avm/journal/trace.js';
 import { Mov } from '../avm/opcodes/memory.js';
-import { createSimulationError } from '../common/errors.js';
-import { type PublicExecution, type PublicExecutionResult } from './execution.js';
+import { type PublicExecution } from './execution.js';
 
 /**
  * Convert a PublicExecution(Environment) object to an AvmExecutionEnvironment
@@ -57,88 +41,6 @@ export function createAvmExecutionEnvironment(
   );
 }
 
-export function createPublicExecution(
-  startSideEffectCounter: number,
-  avmEnvironment: AvmExecutionEnvironment,
-  calldata: Fr[],
-): PublicExecution {
-  const callContext = CallContext.from({
-    msgSender: avmEnvironment.sender,
-    storageContractAddress: avmEnvironment.storageAddress,
-    functionSelector: avmEnvironment.temporaryFunctionSelector,
-    isDelegateCall: avmEnvironment.isDelegateCall,
-    isStaticCall: avmEnvironment.isStaticCall,
-    sideEffectCounter: startSideEffectCounter,
-  });
-  const execution: PublicExecution = {
-    contractAddress: avmEnvironment.address,
-    callContext,
-    args: calldata,
-    functionSelector: avmEnvironment.temporaryFunctionSelector,
-  };
-  return execution;
-}
-
-function computeHints(trace: WorldStateAccessTrace, executionResult: PartialPublicExecutionResult): AvmExecutionHints {
-  return new AvmExecutionHints(
-    trace.publicStorageReads.map(read => new AvmKeyValueHint(read.counter, read.value)),
-    trace.noteHashChecks.map(check => new AvmKeyValueHint(check.counter, new Fr(check.exists ? 1 : 0))),
-    trace.nullifierChecks.map(check => new AvmKeyValueHint(check.counter, new Fr(check.exists ? 1 : 0))),
-    trace.l1ToL2MessageChecks.map(check => new AvmKeyValueHint(check.counter, new Fr(check.exists ? 1 : 0))),
-    executionResult.nestedExecutions.map(nested => {
-      const gasUsed = new Gas(
-        nested.startGasLeft.daGas - nested.endGasLeft.daGas,
-        nested.startGasLeft.l2Gas - nested.endGasLeft.l2Gas,
-      );
-      return new AvmExternalCallHint(/*success=*/ new Fr(nested.reverted ? 0 : 1), nested.returnValues, gasUsed);
-    }),
-    trace.gotContractInstances.map(
-      instance =>
-        new AvmContractInstanceHint(
-          instance.address,
-          new Fr(instance.exists ? 1 : 0),
-          instance.salt,
-          instance.deployer,
-          instance.contractClassId,
-          instance.initializationHash,
-          instance.publicKeysHash,
-        ),
-    ),
-  );
-}
-
-export function convertAvmResultsToPxResult(
-  avmResult: AvmContractCallResults,
-  startSideEffectCounter: number,
-  fromPx: PublicExecution,
-  startGas: Gas,
-  endAvmContext: AvmContext,
-  bytecode: Buffer | undefined,
-): PublicExecutionResult {
-  const endPersistableState = endAvmContext.persistableState;
-  const endMachineState = endAvmContext.machineState;
-
-  return {
-    ...endPersistableState.transitionalExecutionResult, // includes nestedExecutions
-    execution: fromPx,
-    returnValues: avmResult.output,
-    startSideEffectCounter: new Fr(startSideEffectCounter),
-    endSideEffectCounter: new Fr(endPersistableState.trace.accessCounter),
-    unencryptedLogs: new UnencryptedFunctionL2Logs(endPersistableState.transitionalExecutionResult.unencryptedLogs),
-    allUnencryptedLogs: new UnencryptedFunctionL2Logs(
-      endPersistableState.transitionalExecutionResult.allUnencryptedLogs,
-    ),
-    reverted: avmResult.reverted,
-    revertReason: avmResult.revertReason ? createSimulationError(avmResult.revertReason) : undefined,
-    startGasLeft: startGas,
-    endGasLeft: endMachineState.gasLeft,
-    transactionFee: endAvmContext.environment.transactionFee,
-    bytecode: bytecode,
-    calldata: endAvmContext.environment.calldata,
-    avmHints: computeHints(endPersistableState.trace, endPersistableState.transitionalExecutionResult),
-  };
-}
-
 const AVM_MAGIC_SUFFIX = Buffer.from([
   Mov.opcode, // opcode
   0x00, // indirect

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"}