@aztec/simulator 0.36.0 → 0.38.0

package/src/public/executor.ts

@@ -4,6 +4,7 @@ import {
   Gas,
   type GlobalVariables,
   type Header,
+  type Nullifier,
   PublicCircuitPublicInputs,
   type TxContext,
 } from '@aztec/circuits.js';
@@ -26,7 +27,7 @@ import { PackedValuesCache } from '../common/packed_values_cache.js';
 import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from './db.js';
 import { type PublicExecution, type PublicExecutionResult, checkValidStaticCall } from './execution.js';
 import { PublicExecutionContext } from './public_execution_context.js';
-import { convertAvmResults, createAvmExecutionEnvironment, isAvmBytecode } from './transitional_adaptors.js';
+import { convertAvmResultsToPxResult, createAvmExecutionEnvironment, isAvmBytecode } from './transitional_adaptors.js';
 
 /**
  * Execute a public function and return the execution result.
@@ -46,15 +47,23 @@ export async function executePublicFunction(
   }
 
   if (isAvmBytecode(bytecode)) {
-    return await executePublicFunctionAvm(context);
+    return await executeTopLevelPublicFunctionAvm(context, bytecode);
   } else {
     return await executePublicFunctionAcvm(context, bytecode, nested);
   }
 }
 
-async function executePublicFunctionAvm(executionContext: PublicExecutionContext): Promise<PublicExecutionResult> {
+/**
+ * Execute a top-level public function call (the first call in an enqueued-call/execution-request) in the AVM.
+ * Translate the results back to the PublicExecutionResult format.
+ */
+async function executeTopLevelPublicFunctionAvm(
+  executionContext: PublicExecutionContext,
+  bytecode: Buffer,
+): Promise<PublicExecutionResult> {
   const address = executionContext.execution.contractAddress;
   const selector = executionContext.execution.functionData.selector;
+  const startGas = executionContext.availableGas;
   const log = createDebugLogger('aztec:simulator:public_execution');
   log.verbose(`[AVM] Executing public external function ${address.toString()}:${selector}.`);
 
@@ -65,7 +74,15 @@ async function executePublicFunctionAvm(executionContext: PublicExecutionContext
     executionContext.contractsDb,
     executionContext.commitmentsDb,
   );
+
+  // TODO(6207): add sideEffectCounter to persistableState construction
+  // or modify the PersistableStateManager to manage rollbacks across enqueued-calls and transactions.
   const worldStateJournal = new AvmPersistableStateManager(hostStorage);
+  const startSideEffectCounter = executionContext.execution.callContext.sideEffectCounter;
+  for (const nullifier of executionContext.pendingNullifiers) {
+    worldStateJournal.nullifiers.cache.appendSiloed(nullifier.value);
+  }
+  worldStateJournal.trace.accessCounter = startSideEffectCounter;
 
   const executionEnv = createAvmExecutionEnvironment(
     executionContext.execution,
@@ -75,18 +92,30 @@ async function executePublicFunctionAvm(executionContext: PublicExecutionContext
     executionContext.transactionFee,
   );
 
-  const machineState = new AvmMachineState(executionContext.availableGas);
-  const context = new AvmContext(worldStateJournal, executionEnv, machineState);
-  const simulator = new AvmSimulator(context);
+  const machineState = new AvmMachineState(startGas);
+  const avmContext = new AvmContext(worldStateJournal, executionEnv, machineState);
+  const simulator = new AvmSimulator(avmContext);
 
-  const result = await simulator.execute();
-  const newWorldState = context.persistableState.flush();
+  const avmResult = await simulator.executeBytecode(bytecode);
+
+  // Commit the journals 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.
+  await avmContext.persistableState.publicStorage.commitToDB();
 
   log.verbose(
-    `[AVM] ${address.toString()}:${selector} returned, reverted: ${result.reverted}, reason: ${result.revertReason}.`,
+    `[AVM] ${address.toString()}:${selector} returned, reverted: ${avmResult.reverted}, reason: ${
+      avmResult.revertReason
+    }.`,
   );
 
-  return await convertAvmResults(executionContext, newWorldState, result, machineState);
+  return convertAvmResultsToPxResult(
+    avmResult,
+    startSideEffectCounter,
+    executionContext.execution,
+    startGas,
+    avmContext,
+  );
 }
 
 async function executePublicFunctionAcvm(
@@ -159,6 +188,8 @@ async function executePublicFunctionAcvm(
       nestedExecutions: [],
       unencryptedLogsHashes: [],
       unencryptedLogs: UnencryptedFunctionL2Logs.empty(),
+      unencryptedLogPreimagesLength: new Fr(4n), // empty logs have len 4
+      allUnencryptedLogs: UnencryptedFunctionL2Logs.empty(),
       reverted,
       revertReason,
       startGasLeft: context.availableGas,
@@ -182,6 +213,7 @@ async function executePublicFunctionAcvm(
     startSideEffectCounter,
     endSideEffectCounter,
     unencryptedLogsHashes: unencryptedLogsHashesPadded,
+    unencryptedLogPreimagesLength,
   } = PublicCircuitPublicInputs.fromFields(returnWitness);
   const returnValues = await context.unpackReturns(returnsHash);
 
@@ -207,6 +239,7 @@ async function executePublicFunctionAcvm(
 
   const nestedExecutions = context.getNestedExecutions();
   const unencryptedLogs = context.getUnencryptedLogs();
+  const allUnencryptedLogs = context.getAllUnencryptedLogs();
 
   // TODO(palla/gas): We should be loading these values from the returned PublicCircuitPublicInputs
   const startGasLeft = context.availableGas;
@@ -227,6 +260,8 @@ async function executePublicFunctionAcvm(
     nestedExecutions,
     unencryptedLogsHashes,
     unencryptedLogs,
+    unencryptedLogPreimagesLength,
+    allUnencryptedLogs,
     reverted: false,
     revertReason: undefined,
     startGasLeft,
@@ -258,6 +293,7 @@ export class PublicExecutor {
     globalVariables: GlobalVariables,
     availableGas: Gas,
     txContext: TxContext,
+    pendingNullifiers: Nullifier[],
     transactionFee: Fr = Fr.ZERO,
     sideEffectCounter: number = 0,
   ): Promise<PublicExecutionResult> {
@@ -277,6 +313,7 @@ export class PublicExecutor {
       availableGas,
       transactionFee,
       txContext.gasSettings,
+      pendingNullifiers,
     );
 
     const executionResult = await executePublicFunction(context, /*nested=*/ false);

package/src/public/public_execution_context.ts

@@ -7,6 +7,7 @@ import {
   type GasSettings,
   type GlobalVariables,
   type Header,
+  type Nullifier,
   PublicContextInputs,
 } from '@aztec/circuits.js';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
@@ -37,13 +38,18 @@ export class PublicExecutionContext extends TypedOracle {
     public readonly header: Header,
     public readonly globalVariables: GlobalVariables,
     private readonly packedValuesCache: PackedValuesCache,
-    private readonly sideEffectCounter: SideEffectCounter,
+    // TRANSITIONAL: once AVM-ACVM interoperability is removed (fully functional AVM), sideEffectCounter can be made private
+    public readonly sideEffectCounter: SideEffectCounter,
     public readonly stateDb: PublicStateDB,
     public readonly contractsDb: PublicContractsDB,
     public readonly commitmentsDb: CommitmentsDB,
     public readonly availableGas: Gas,
     public readonly transactionFee: Fr,
     public readonly gasSettings: GasSettings,
+    public readonly pendingNullifiers: Nullifier[],
+    // Unencrypted logs emitted during this call AND any nested calls
+    // Useful for maintaining correct ordering in ts
+    private allUnencryptedLogs: UnencryptedL2Log[] = [],
     private log = createDebugLogger('aztec:simulator:public_execution_context'),
   ) {
     super();
@@ -87,6 +93,13 @@ export class PublicExecutionContext extends TypedOracle {
     return new UnencryptedFunctionL2Logs(this.unencryptedLogs);
   }
 
+  /**
+   * Return the encrypted logs emitted during this execution, including nested calls.
+   */
+  public getAllUnencryptedLogs() {
+    return new UnencryptedFunctionL2Logs(this.allUnencryptedLogs);
+  }
+
   /**
    * Return the data read and updated during this execution.
    */
@@ -135,11 +148,10 @@ export class PublicExecutionContext extends TypedOracle {
    * Emit an unencrypted log.
    * @param log - The unencrypted log to be emitted.
    */
-  public override emitUnencryptedLog(log: UnencryptedL2Log) {
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/885)
+  public override emitUnencryptedLog(log: UnencryptedL2Log, _counter: number) {
     this.unencryptedLogs.push(log);
+    this.allUnencryptedLogs.push(log);
     this.log.verbose(`Emitted unencrypted log: "${log.toHumanReadable()}"`);
-    return Fr.fromBuffer(log.hash());
   }
 
   /**
@@ -229,6 +241,8 @@ export class PublicExecutionContext extends TypedOracle {
       this.availableGas,
       this.transactionFee,
       this.gasSettings,
+      /*pendingNullifiers=*/ [],
+      this.allUnencryptedLogs,
       this.log,
     );
 

package/src/public/tail_phase_manager.ts

@@ -1,10 +1,4 @@
-import {
-  type PublicKernelRequest,
-  PublicKernelType,
-  type Tx,
-  UnencryptedFunctionL2Logs,
-  type UnencryptedL2Log,
-} from '@aztec/circuit-types';
+import { type PublicKernelRequest, PublicKernelType, type Tx } from '@aztec/circuit-types';
 import {
   Fr,
   type GlobalVariables,
@@ -57,8 +51,6 @@ export class TailPhaseManager extends AbstractPhaseManager {
         throw err;
       },
     );
-    // Temporary hack. Should sort them in the tail circuit.
-    this.patchLogsOrdering(tx, previousPublicKernelOutput);
     // commit the state updates from this transaction
     await this.publicStateDB.commit();
 
@@ -163,33 +155,9 @@ export class TailPhaseManager extends AbstractPhaseManager {
   }
 
   private sortLogsHashes<N extends number>(unencryptedLogsHashes: Tuple<SideEffect, N>): Tuple<SideEffect, N> {
+    // TODO(6052): logs here may have duplicate counters from nested calls
     return sortByCounter(
       unencryptedLogsHashes.map(n => ({ ...n, counter: n.counter.toNumber(), isEmpty: () => n.isEmpty() })),
     ).map(h => new SideEffect(h.value, new Fr(h.counter))) as Tuple<SideEffect, N>;
   }
-
-  // As above, this is a hack for unencrypted logs ordering, now they are sorted. Since the public kernel
-  // cannot keep track of side effects that happen after or before a nested call, we override the gathered logs.
-  // As a sanity check, we at least verify that the elements are the same, so we are only tweaking their ordering.
-  // See same fn in pxe_service.ts
-  // Added as part of resolving #5017
-  private patchLogsOrdering(tx: Tx, publicInputs: PublicKernelCircuitPublicInputs) {
-    const unencLogs = tx.unencryptedLogs.unrollLogs();
-    const sortedUnencLogs = publicInputs.end.unencryptedLogsHashes;
-
-    const finalUnencLogs: UnencryptedL2Log[] = [];
-    sortedUnencLogs.forEach((sideEffect: SideEffect) => {
-      if (!sideEffect.isEmpty()) {
-        const isLog = (log: UnencryptedL2Log) => Fr.fromBuffer(log.hash()).equals(sideEffect.value);
-        const thisLogIndex = unencLogs.findIndex(isLog);
-        finalUnencLogs.push(unencLogs[thisLogIndex]);
-      }
-    });
-    const unencryptedLogs = new UnencryptedFunctionL2Logs(finalUnencLogs);
-
-    tx.unencryptedLogs.functionLogs[0] = unencryptedLogs;
-    for (let i = 1; i < tx.unencryptedLogs.functionLogs.length; i++) {
-      tx.unencryptedLogs.functionLogs[i] = UnencryptedFunctionL2Logs.empty();
-    }
-  }
 }

package/src/public/transitional_adaptors.ts

@@ -1,32 +1,21 @@
 // All code in this file needs to die once the public executor is phased out in favor of the AVM.
-import { UnencryptedFunctionL2Logs, UnencryptedL2Log } from '@aztec/circuit-types';
+import { UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
 import {
   CallContext,
-  ContractStorageRead,
-  ContractStorageUpdateRequest,
   FunctionData,
-  Gas,
+  type Gas,
   type GasSettings,
   type GlobalVariables,
   type Header,
-  L2ToL1Message,
-  NoteHash,
-  Nullifier,
-  ReadRequest,
-  SideEffect,
 } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 
 import { type AvmContext } from '../avm/avm_context.js';
 import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
-import { type AvmMachineState } from '../avm/avm_machine_state.js';
-import { AvmContractCallResults } from '../avm/avm_message_call_result.js';
-import { type JournalData } from '../avm/journal/journal.js';
+import { type AvmContractCallResults } from '../avm/avm_message_call_result.js';
 import { Mov } from '../avm/opcodes/memory.js';
 import { createSimulationError } from '../common/errors.js';
-import { PackedValuesCache, SideEffectCounter } from '../index.js';
 import { type PublicExecution, type PublicExecutionResult } from './execution.js';
-import { PublicExecutionContext } from './public_execution_context.js';
 
 /**
  * Convert a PublicExecution(Environment) object to an AvmExecutionEnvironment
@@ -60,184 +49,56 @@ export function createAvmExecutionEnvironment(
   );
 }
 
-export function createPublicExecutionContext(avmContext: AvmContext, calldata: Fr[]): PublicExecutionContext {
-  const sideEffectCounter = avmContext.persistableState.trace.accessCounter;
+export function createPublicExecution(
+  startSideEffectCounter: number,
+  avmEnvironment: AvmExecutionEnvironment,
+  calldata: Fr[],
+): PublicExecution {
   const callContext = CallContext.from({
-    msgSender: avmContext.environment.sender,
-    storageContractAddress: avmContext.environment.storageAddress,
-    functionSelector: avmContext.environment.temporaryFunctionSelector,
-    isDelegateCall: avmContext.environment.isDelegateCall,
-    isStaticCall: avmContext.environment.isStaticCall,
-    sideEffectCounter: sideEffectCounter,
+    msgSender: avmEnvironment.sender,
+    storageContractAddress: avmEnvironment.storageAddress,
+    functionSelector: avmEnvironment.temporaryFunctionSelector,
+    isDelegateCall: avmEnvironment.isDelegateCall,
+    isStaticCall: avmEnvironment.isStaticCall,
+    sideEffectCounter: startSideEffectCounter,
   });
-  const functionData = new FunctionData(avmContext.environment.temporaryFunctionSelector, /*isPrivate=*/ false);
+  const functionData = new FunctionData(avmEnvironment.temporaryFunctionSelector, /*isPrivate=*/ false);
   const execution: PublicExecution = {
-    contractAddress: avmContext.environment.address,
+    contractAddress: avmEnvironment.address,
     callContext,
     args: calldata,
     functionData,
   };
-  const packedArgs = PackedValuesCache.create([]);
-
-  const context = new PublicExecutionContext(
-    execution,
-    avmContext.environment.header,
-    avmContext.environment.globals,
-    packedArgs,
-    new SideEffectCounter(sideEffectCounter),
-    avmContext.persistableState.hostStorage.publicStateDb,
-    avmContext.persistableState.hostStorage.contractsDb,
-    avmContext.persistableState.hostStorage.commitmentsDb,
-    Gas.from(avmContext.machineState.gasLeft),
-    avmContext.environment.transactionFee,
-    avmContext.environment.gasSettings,
-  );
-
-  return context;
+  return execution;
 }
 
-/**
- * Convert the result of an AVM contract call to a PublicExecutionResult for the public kernel
- *
- * @param execution
- * @param newWorldState
- * @param result
- * @returns
- */
-export async function convertAvmResults(
-  executionContext: PublicExecutionContext,
-  newWorldState: JournalData,
-  result: AvmContractCallResults,
-  endMachineState: AvmMachineState,
-): Promise<PublicExecutionResult> {
-  const execution = executionContext.execution;
-
-  const contractStorageReads: ContractStorageRead[] = newWorldState.storageReads.map(
-    read => new ContractStorageRead(read.slot, read.value, read.counter.toNumber(), read.storageAddress),
-  );
-  const contractStorageUpdateRequests: ContractStorageUpdateRequest[] = newWorldState.storageWrites.map(
-    write => new ContractStorageUpdateRequest(write.slot, write.value, write.counter.toNumber(), write.storageAddress),
-  );
-  // We need to write the storage updates to the DB, because that's what the ACVM expects.
-  // Assumes the updates are in the right order.
-  for (const write of newWorldState.storageWrites) {
-    await executionContext.stateDb.storageWrite(write.storageAddress, write.slot, write.value);
-  }
-
-  const newNoteHashes = newWorldState.newNoteHashes.map(
-    noteHash => new NoteHash(noteHash.noteHash, noteHash.counter.toNumber()),
-  );
-  const nullifierReadRequests: ReadRequest[] = newWorldState.nullifierChecks
-    .filter(nullifierCheck => nullifierCheck.exists)
-    .map(nullifierCheck => new ReadRequest(nullifierCheck.nullifier, nullifierCheck.counter.toNumber()));
-  const nullifierNonExistentReadRequests: ReadRequest[] = newWorldState.nullifierChecks
-    .filter(nullifierCheck => !nullifierCheck.exists)
-    .map(nullifierCheck => new ReadRequest(nullifierCheck.nullifier, nullifierCheck.counter.toNumber()));
-  const newNullifiers: Nullifier[] = newWorldState.newNullifiers.map(
-    tracedNullifier =>
-      new Nullifier(
-        /*value=*/ tracedNullifier.nullifier,
-        tracedNullifier.counter.toNumber(),
-        /*noteHash=*/ Fr.ZERO, // NEEDED?
-      ),
-  );
-  const unencryptedLogs: UnencryptedFunctionL2Logs = new UnencryptedFunctionL2Logs(
-    newWorldState.newLogs.map(log => new UnencryptedL2Log(log.contractAddress, log.selector, log.data)),
-  );
-  const unencryptedLogsHashes = newWorldState.newLogsHashes.map(
-    logHash => new SideEffect(logHash.logHash, logHash.counter),
-  );
-  const newL2ToL1Messages = newWorldState.newL1Messages.map(m => new L2ToL1Message(m.recipient, m.content));
-
-  const returnValues = result.output;
-
-  // TODO: Support nested executions.
-  const nestedExecutions: PublicExecutionResult[] = [];
-  // TODO keep track of side effect counters
-  const startSideEffectCounter = Fr.ZERO;
-  const endSideEffectCounter = Fr.ZERO;
-
+export function convertAvmResultsToPxResult(
+  avmResult: AvmContractCallResults,
+  startSideEffectCounter: number,
+  fromPx: PublicExecution,
+  startGas: Gas,
+  endAvmContext: AvmContext,
+): PublicExecutionResult {
+  const endPersistableState = endAvmContext.persistableState;
+  const endMachineState = endAvmContext.machineState;
   return {
-    execution,
-    nullifierReadRequests,
-    nullifierNonExistentReadRequests,
-    newNoteHashes,
-    newL2ToL1Messages,
-    startSideEffectCounter,
-    endSideEffectCounter,
-    newNullifiers,
-    contractStorageReads,
-    contractStorageUpdateRequests,
-    returnValues,
-    nestedExecutions,
-    unencryptedLogsHashes,
-    unencryptedLogs,
-    reverted: result.reverted,
-    revertReason: result.revertReason ? createSimulationError(result.revertReason) : undefined,
-    startGasLeft: executionContext.availableGas,
+    ...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: executionContext.transactionFee,
+    transactionFee: endAvmContext.environment.transactionFee,
   };
 }
 
-export function convertPublicExecutionResult(res: PublicExecutionResult): AvmContractCallResults {
-  return new AvmContractCallResults(res.reverted, res.returnValues, res.revertReason);
-}
-
-export function updateAvmContextFromPublicExecutionResult(ctx: AvmContext, result: PublicExecutionResult): void {
-  // We have to push these manually and not use the trace* functions
-  // so that we respect the side effect counters.
-  for (const readRequest of result.contractStorageReads) {
-    ctx.persistableState.trace.publicStorageReads.push({
-      storageAddress: ctx.environment.storageAddress,
-      exists: true, // FIXME
-      slot: readRequest.storageSlot,
-      value: readRequest.currentValue,
-      counter: new Fr(readRequest.sideEffectCounter ?? Fr.ZERO),
-    });
-  }
-
-  for (const updateRequest of result.contractStorageUpdateRequests) {
-    ctx.persistableState.trace.publicStorageWrites.push({
-      storageAddress: ctx.environment.storageAddress,
-      slot: updateRequest.storageSlot,
-      value: updateRequest.newValue,
-      counter: new Fr(updateRequest.sideEffectCounter ?? Fr.ZERO),
-    });
-
-    // We need to manually populate the cache.
-    ctx.persistableState.publicStorage.write(
-      ctx.environment.storageAddress,
-      updateRequest.storageSlot,
-      updateRequest.newValue,
-    );
-  }
-
-  for (const nullifier of result.newNullifiers) {
-    ctx.persistableState.trace.newNullifiers.push({
-      storageAddress: ctx.environment.storageAddress,
-      nullifier: nullifier.value,
-      counter: new Fr(nullifier.counter),
-    });
-  }
-
-  for (const noteHash of result.newNoteHashes) {
-    ctx.persistableState.trace.newNoteHashes.push({
-      storageAddress: ctx.environment.storageAddress,
-      noteHash: noteHash.value,
-      counter: new Fr(noteHash.counter),
-    });
-  }
-
-  for (const message of result.newL2ToL1Messages) {
-    ctx.persistableState.newL1Messages.push(message);
-  }
-
-  for (const log of result.unencryptedLogs.logs) {
-    ctx.persistableState.newLogs.push(new UnencryptedL2Log(log.contractAddress, log.selector, log.data));
-  }
-}
-
 const AVM_MAGIC_SUFFIX = Buffer.from([
   Mov.opcode, // opcode
   0x00, // indirect