@aztec/simulator 0.62.0 → 0.63.1

package/src/public/execution.ts

@@ -1,5 +1,4 @@
 import {
-  NestedProcessReturnValues,
   type PublicExecutionRequest,
   type SimulationError,
   type UnencryptedFunctionL2Logs,
@@ -15,17 +14,73 @@ import {
   type NoteHash,
   type Nullifier,
   PublicCallStackItemCompressed,
+  type PublicDataUpdateRequest,
   PublicInnerCallRequest,
   type ReadRequest,
   RevertCode,
+  type ScopedL2ToL1Message,
+  type ScopedLogHash,
+  type ScopedNoteHash,
   type TreeLeafReadRequest,
 } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 
+export interface PublicSideEffects {
+  /** The contract storage update requests performed. */
+  publicDataWrites: PublicDataUpdateRequest[];
+  /** The new note hashes to be inserted into the note hashes tree. */
+  noteHashes: ScopedNoteHash[];
+  /** The new nullifiers to be inserted into the nullifier tree. */
+  nullifiers: Nullifier[];
+  /** The new l2 to l1 messages generated to be inserted into the messages tree. */
+  l2ToL1Messages: ScopedL2ToL1Message[];
+  /**
+   * The hashed logs with side effect counter.
+   * Note: required as we don't track the counter anywhere else.
+   */
+  unencryptedLogsHashes: ScopedLogHash[];
+  /**
+   * Unencrypted logs emitted during execution.
+   * Note: These are preimages to `unencryptedLogsHashes`.
+   */
+  unencryptedLogs: UnencryptedFunctionL2Logs;
+}
+
+export interface EnqueuedPublicCallExecutionResult {
+  /** How much gas was left after this public execution. */
+  endGasLeft: Gas;
+  /** The side effect counter after execution */
+  endSideEffectCounter: Fr;
+
+  /** The return values of the function. */
+  returnValues: Fr[];
+  /** Whether the execution reverted. */
+  reverted: boolean;
+  /** The revert reason if the execution reverted. */
+  revertReason?: SimulationError;
+}
+
+export interface EnqueuedPublicCallExecutionResultWithSideEffects {
+  /** How much gas was left after this public execution. */
+  endGasLeft: Gas;
+  /** The side effect counter after execution */
+  endSideEffectCounter: Fr;
+
+  /** The return values of the function. */
+  returnValues: Fr[];
+  /** Whether the execution reverted. */
+  reverted: boolean;
+  /** The revert reason if the execution reverted. */
+  revertReason?: SimulationError;
+
+  /** The public side effects of the function. */
+  sideEffects: PublicSideEffects;
+}
+
 /**
  * The public function execution result.
  */
-export interface PublicExecutionResult {
+export interface PublicFunctionCallResult {
   /** The execution request that triggered this result. */
   executionRequest: PublicExecutionRequest;
 
@@ -97,46 +152,7 @@ export interface PublicExecutionResult {
   functionName: string;
 }
 
-/**
- * Recursively accummulate the return values of a call result and its nested executions,
- * so they can be retrieved in order.
- * @param executionResult
- * @returns
- */
-export function accumulatePublicReturnValues(executionResult: PublicExecutionResult): NestedProcessReturnValues {
-  const acc = new NestedProcessReturnValues(executionResult.returnValues);
-  acc.nested = executionResult.nestedExecutions.map(nestedExecution => accumulatePublicReturnValues(nestedExecution));
-  return acc;
-}
-
-export function collectExecutionResults(result: PublicExecutionResult): PublicExecutionResult[] {
-  return [result, ...result.nestedExecutions.map(collectExecutionResults)].flat();
-}
-
-/**
- * Checks whether the child execution result is valid for a static call (no state modifications).
- * @param executionResult - The execution result of a public function
- */
-
-export function checkValidStaticCall(
-  noteHashes: NoteHash[],
-  nullifiers: Nullifier[],
-  contractStorageUpdateRequests: ContractStorageUpdateRequest[],
-  l2ToL1Messages: L2ToL1Message[],
-  unencryptedLogs: UnencryptedFunctionL2Logs,
-) {
-  if (
-    contractStorageUpdateRequests.length > 0 ||
-    noteHashes.length > 0 ||
-    nullifiers.length > 0 ||
-    l2ToL1Messages.length > 0 ||
-    unencryptedLogs.logs.length > 0
-  ) {
-    throw new Error('Static call cannot update the state, emit L2->L1 messages or generate logs');
-  }
-}
-
-export function resultToPublicCallRequest(result: PublicExecutionResult) {
+export function resultToPublicCallRequest(result: PublicFunctionCallResult) {
   const request = result.executionRequest;
   const item = new PublicCallStackItemCompressed(
     request.callContext.contractAddress,

package/src/public/executor.ts

@@ -1,15 +1,6 @@
 import { type PublicExecutionRequest } from '@aztec/circuit-types';
 import { type AvmSimulationStats } from '@aztec/circuit-types/stats';
-import {
-  type CombinedConstantData,
-  Fr,
-  Gas,
-  type GlobalVariables,
-  type Nullifier,
-  PublicAccumulatedDataArrayLengths,
-  PublicValidationRequestArrayLengths,
-  type TxContext,
-} from '@aztec/circuits.js';
+import { Fr, Gas, type GlobalVariables } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { type TelemetryClient } from '@aztec/telemetry-client';
@@ -22,7 +13,10 @@ import { AvmPersistableStateManager } from '../avm/journal/index.js';
 import { getPublicFunctionDebugName } from '../common/debug_fn_name.js';
 import { DualSideEffectTrace } from './dual_side_effect_trace.js';
 import { PublicEnqueuedCallSideEffectTrace } from './enqueued_call_side_effect_trace.js';
-import { type PublicExecutionResult } from './execution.js';
+import {
+  type EnqueuedPublicCallExecutionResult,
+  type EnqueuedPublicCallExecutionResultWithSideEffects,
+} from './execution.js';
 import { ExecutorMetrics } from './executor_metrics.js';
 import { type WorldStateDB } from './public_db_sources.js';
 import { PublicSideEffectTrace } from './side_effect_trace.js';
@@ -40,29 +34,20 @@ export class PublicExecutor {
   static readonly log = createDebugLogger('aztec:simulator:public_executor');
 
   /**
-   * Executes a public execution request.
+   * Simulate a public execution request.
    * @param executionRequest - The execution to run.
-   * @param constants - The constants (including global variables) to use.
+   * @param globalVariables - The global variables to use.
    * @param allocatedGas - The gas available at the start of this enqueued call.
-   * @param txContext - Transaction context.
-   * @param pendingSiloedNullifiers - The pending nullifier set from earlier parts of this TX.
    * @param transactionFee - Fee offered for this TX.
-   * @param startSideEffectCounter - The counter of the first side-effect generated by this simulation.
-   * @param previousValidationRequestArrayLengths - Side effect array lengths from previous kernel
-   * @param previousAccumulatedDataArrayLengths - Side effect array lengths from previous kernel
-   * @returns The result of execution, including the results of all nested calls.
+   * @returns The result of execution.
    */
   public async simulate(
+    stateManager: AvmPersistableStateManager,
     executionRequest: PublicExecutionRequest,
-    constants: CombinedConstantData,
+    globalVariables: GlobalVariables,
     allocatedGas: Gas,
-    _txContext: TxContext,
-    pendingSiloedNullifiers: Nullifier[],
     transactionFee: Fr = Fr.ZERO,
-    startSideEffectCounter: number = 0,
-    previousValidationRequestArrayLengths: PublicValidationRequestArrayLengths = PublicValidationRequestArrayLengths.empty(),
-    previousAccumulatedDataArrayLengths: PublicAccumulatedDataArrayLengths = PublicAccumulatedDataArrayLengths.empty(),
-  ): Promise<PublicExecutionResult> {
+  ): Promise<EnqueuedPublicCallExecutionResult> {
     const address = executionRequest.callContext.contractAddress;
     const selector = executionRequest.callContext.functionSelector;
     const fnName = await getPublicFunctionDebugName(this.worldStateDB, address, selector, executionRequest.args);
@@ -72,36 +57,17 @@ export class PublicExecutor {
     );
     const timer = new Timer();
 
-    const innerCallTrace = new PublicSideEffectTrace(startSideEffectCounter);
-    const enqueuedCallTrace = new PublicEnqueuedCallSideEffectTrace(
-      startSideEffectCounter,
-      previousValidationRequestArrayLengths,
-      previousAccumulatedDataArrayLengths,
-    );
-    const trace = new DualSideEffectTrace(innerCallTrace, enqueuedCallTrace);
-    const avmPersistableState = AvmPersistableStateManager.newWithPendingSiloedNullifiers(
-      this.worldStateDB,
-      trace,
-      pendingSiloedNullifiers.map(n => n.value),
-    );
-
-    const avmExecutionEnv = createAvmExecutionEnvironment(executionRequest, constants.globalVariables, transactionFee);
+    const avmExecutionEnv = createAvmExecutionEnvironment(executionRequest, globalVariables, transactionFee);
 
     const avmMachineState = new AvmMachineState(allocatedGas);
-    const avmContext = new AvmContext(avmPersistableState, avmExecutionEnv, avmMachineState);
+    const avmContext = new AvmContext(stateManager, avmExecutionEnv, avmMachineState);
     const simulator = new AvmSimulator(avmContext);
-    const avmResult = await simulator.execute();
+    const avmCallResult = await simulator.execute();
     const bytecode = simulator.getBytecode()!;
 
-    // Commit the public storage state to the DBs since this is a top-level execution.
-    // Observe that this will write all the state changes to the DBs, not only the latest for each slot.
-    // However, the underlying DB keep a cache and will only write the latest state to disk.
-    // TODO(dbanks12): this should be unnecessary here or should be exposed by state manager
-    await avmContext.persistableState.publicStorage.commitToDB();
-
     PublicExecutor.log.verbose(
-      `[AVM] ${fnName} returned, reverted: ${avmResult.reverted}${
-        avmResult.reverted ? ', reason: ' + avmResult.revertReason : ''
+      `[AVM] ${fnName} returned, reverted: ${avmCallResult.reverted}${
+        avmCallResult.reverted ? ', reason: ' + avmCallResult.revertReason : ''
       }.`,
       {
         eventName: 'avm-simulation',
@@ -111,37 +77,56 @@ export class PublicExecutor {
       } satisfies AvmSimulationStats,
     );
 
-    const publicExecutionResult = trace.toPublicExecutionResult(
-      avmExecutionEnv,
-      /*startGasLeft=*/ allocatedGas,
+    const publicExecutionResult = stateManager.trace.toPublicEnqueuedCallExecutionResult(
       /*endGasLeft=*/ Gas.from(avmContext.machineState.gasLeft),
-      bytecode,
-      avmResult,
-      fnName,
+      avmCallResult,
     );
 
-    if (publicExecutionResult.reverted) {
+    if (avmCallResult.reverted) {
       this.metrics.recordFunctionSimulationFailure();
     } else {
       this.metrics.recordFunctionSimulation(bytecode.length, timer.ms());
     }
 
-    const _vmCircuitPublicInputs = enqueuedCallTrace.toVMCircuitPublicInputs(
-      constants,
-      avmExecutionEnv,
-      /*startGasLeft=*/ allocatedGas,
-      /*endGasLeft=*/ Gas.from(avmContext.machineState.gasLeft),
-      avmResult,
-    );
-
     PublicExecutor.log.verbose(
-      `[AVM] ${fnName} simulation complete. Reverted=${avmResult.reverted}. Consumed ${
+      `[AVM] ${fnName} simulation complete. Reverted=${avmCallResult.reverted}. Consumed ${
         allocatedGas.l2Gas - avmContext.machineState.gasLeft.l2Gas
       } L2 gas, ending with ${avmContext.machineState.gasLeft.l2Gas} L2 gas left.`,
     );
 
     return publicExecutionResult;
   }
+
+  /**
+   * Simulate an enqueued call on its own, and include its side effects in its results.
+   * @param executionRequest - The execution to run.
+   * @param globalVariables - The global variables to use.
+   * @param allocatedGas - The gas available at the start of this enqueued call.
+   * @param transactionFee - Fee offered for this TX.
+   * @param startSideEffectCounter - The start counter to initialize the side effect trace with.
+   * @returns The result of execution including side effect vectors.
+   * FIXME: this function is only used by the TXE. Ideally we would not support this as an external interface.
+   * Avoid using this interface as it it shouldn't really exist in the first place.
+   */
+  public async simulateIsolatedEnqueuedCall(
+    executionRequest: PublicExecutionRequest,
+    globalVariables: GlobalVariables,
+    allocatedGas: Gas,
+    transactionFee: Fr = Fr.ONE,
+    startSideEffectCounter: number = 0,
+  ): Promise<EnqueuedPublicCallExecutionResultWithSideEffects> {
+    const innerCallTrace = new PublicSideEffectTrace(startSideEffectCounter);
+    const enqueuedCallTrace = new PublicEnqueuedCallSideEffectTrace(startSideEffectCounter);
+    const trace = new DualSideEffectTrace(innerCallTrace, enqueuedCallTrace);
+    const stateManager = new AvmPersistableStateManager(this.worldStateDB, trace);
+    return (await this.simulate(
+      stateManager,
+      executionRequest,
+      globalVariables,
+      allocatedGas,
+      transactionFee,
+    )) as EnqueuedPublicCallExecutionResultWithSideEffects;
+  }
 }
 
 /**
@@ -151,7 +136,7 @@ export class PublicExecutor {
  * @param globalVariables
  * @returns
  */
-function createAvmExecutionEnvironment(
+export function createAvmExecutionEnvironment(
   executionRequest: PublicExecutionRequest,
   globalVariables: GlobalVariables,
   transactionFee: Fr,

package/src/public/index.ts

@@ -1,11 +1,13 @@
 export * from './db_interfaces.js';
-export * from './enqueued_calls_processor.js';
-export { type PublicExecutionResult } from './execution.js';
+export * from './public_tx_simulator.js';
+export {
+  type EnqueuedPublicCallExecutionResult as PublicExecutionResult,
+  type PublicFunctionCallResult,
+} from './execution.js';
 export { PublicExecutor } from './executor.js';
 export * from './fee_payment.js';
-export { HintsBuilder } from './hints_builder.js';
 export * from './public_db_sources.js';
-export * from './public_kernel.js';
-export * from './public_kernel_circuit_simulator.js';
 export { PublicProcessor, PublicProcessorFactory } from './public_processor.js';
 export { PublicSideEffectTrace } from './side_effect_trace.js';
+export { PublicEnqueuedCallSideEffectTrace } from './enqueued_call_side_effect_trace.js';
+export { getExecutionRequestsByPhase } from './utils.js';

package/src/public/public_db_sources.ts

@@ -49,12 +49,14 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
    */
   public addNewContracts(tx: Tx): Promise<void> {
     // Extract contract class and instance data from logs and add to cache for this block
-    const logs = tx.unencryptedLogs.unrollLogs();
+    const logs = tx.contractClassLogs.unrollLogs();
     ContractClassRegisteredEvent.fromLogs(logs, ProtocolContractAddress.ContractClassRegisterer).forEach(e => {
       this.log.debug(`Adding class ${e.contractClassId.toString()} to public execution contract cache`);
       this.classCache.set(e.contractClassId.toString(), e.toContractClassPublic());
     });
-    ContractInstanceDeployedEvent.fromLogs(logs).forEach(e => {
+    // We store the contract instance deployed event log in enc logs, contract_instance_deployer_contract/src/main.nr
+    const encLogs = tx.encryptedLogs.unrollLogs();
+    ContractInstanceDeployedEvent.fromLogs(encLogs).forEach(e => {
       this.log.debug(
         `Adding instance ${e.address.toString()} with class ${e.contractClassId.toString()} to public execution contract cache`,
       );
@@ -72,11 +74,13 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     // TODO(@spalladino): Can this inadvertently delete a valid contract added by another tx?
     // Let's say we have two txs adding the same contract on the same block. If the 2nd one reverts,
     // wouldn't that accidentally remove the contract added on the first one?
-    const logs = tx.unencryptedLogs.unrollLogs();
+    const logs = tx.contractClassLogs.unrollLogs();
     ContractClassRegisteredEvent.fromLogs(logs, ProtocolContractAddress.ContractClassRegisterer).forEach(e =>
       this.classCache.delete(e.contractClassId.toString()),
     );
-    ContractInstanceDeployedEvent.fromLogs(logs).forEach(e => this.instanceCache.delete(e.address.toString()));
+    // We store the contract instance deployed event log in enc logs, contract_instance_deployer_contract/src/main.nr
+    const encLogs = tx.encryptedLogs.unrollLogs();
+    ContractInstanceDeployedEvent.fromLogs(encLogs).forEach(e => this.instanceCache.delete(e.address.toString()));
     return Promise.resolve();
   }
 
@@ -131,6 +135,10 @@ export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicS
     super(dataSource);
   }
 
+  public getMerkleInterface(): MerkleTreeWriteOperations {
+    return this.db;
+  }
+
   /**
    * Reads a value from public storage, returning zero if none.
    * @param contract - Owner of the storage.