@aztec/simulator 0.37.0 → 0.38.0

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