@aztec/simulator 0.41.0 → 0.43.0

package/src/public/app_logic_phase_manager.ts

@@ -1,15 +1,10 @@
-import { type PublicKernelRequest, PublicKernelType, type Tx } from '@aztec/circuit-types';
-import {
-  type GlobalVariables,
-  type Header,
-  type Proof,
-  type PublicKernelCircuitPublicInputs,
-} from '@aztec/circuits.js';
+import { PublicKernelType, type PublicProvingRequest, type Tx } from '@aztec/circuit-types';
+import { type GlobalVariables, type Header, type PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
 import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
-import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
-import { type ContractsDataSourcePublicDB } from './public_executor.js';
+import { AbstractPhaseManager, makeAvmProvingRequest } from './abstract_phase_manager.js';
+import { type ContractsDataSourcePublicDB } from './public_db_sources.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 
 /**
@@ -24,54 +19,43 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
     historicalHeader: Header,
     protected publicContractsDB: ContractsDataSourcePublicDB,
     protected publicStateDB: PublicStateDB,
-    phase: PublicKernelPhase = PublicKernelPhase.APP_LOGIC,
+    phase: PublicKernelType = PublicKernelType.APP_LOGIC,
   ) {
     super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
   }
 
-  override async handle(
-    tx: Tx,
-    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
-    previousPublicKernelProof: Proof,
-  ) {
+  override async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs) {
+    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
     // add new contracts to the contracts db so that their functions may be found and called
     // TODO(#4073): This is catching only private deployments, when we add public ones, we'll
     // have to capture contracts emitted in that phase as well.
     // TODO(@spalladino): Should we allow emitting contracts in the fee preparation phase?
-    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
+    // TODO(#6464): Should we allow emitting contracts in the private setup phase?
+    // if so, this should only add contracts that were deployed during private app logic.
     await this.publicContractsDB.addNewContracts(tx);
-    const [
-      kernelInputs,
-      publicKernelOutput,
-      publicKernelProof,
-      newUnencryptedFunctionLogs,
-      revertReason,
-      returnValues,
-      gasUsed,
-    ] = await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
-      // if we throw for any reason other than simulation, we need to rollback and drop the TX
-      async err => {
-        await this.publicStateDB.rollbackToCommit();
-        throw err;
-      },
-    );
+    const { publicProvingInformation, kernelOutput, newUnencryptedLogs, revertReason, returnValues, gasUsed } =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput).catch(
+        // if we throw for any reason other than simulation, we need to rollback and drop the TX
+        async err => {
+          await this.publicStateDB.rollbackToCommit();
+          throw err;
+        },
+      );
 
     if (revertReason) {
+      // TODO(#6464): Should we allow emitting contracts in the private setup phase?
+      // if so, this is removing contracts deployed in private setup
       await this.publicContractsDB.removeNewContracts(tx);
       await this.publicStateDB.rollbackToCheckpoint();
     } else {
-      tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
-      await this.publicStateDB.checkpoint();
+      tx.unencryptedLogs.addFunctionLogs(newUnencryptedLogs);
+      // TODO(#6470): we should be adding contracts deployed in those logs to the publicContractsDB
     }
 
     // Return a list of app logic proving requests
-    const kernelRequests = kernelInputs.map(input => {
-      const request: PublicKernelRequest = {
-        type: PublicKernelType.APP_LOGIC,
-        inputs: input,
-      };
-      return request;
+    const publicProvingRequests: PublicProvingRequest[] = publicProvingInformation.map(info => {
+      return makeAvmProvingRequest(info, PublicKernelType.APP_LOGIC);
     });
-    return { kernelRequests, publicKernelOutput, publicKernelProof, revertReason, returnValues, gasUsed };
+    return { publicProvingRequests, publicKernelOutput: kernelOutput, revertReason, returnValues, gasUsed };
   }
 }

package/src/public/{db.ts → db_interfaces.ts}

@@ -23,9 +23,9 @@ export interface PublicStateDB {
    * @param contract - Owner of the storage.
    * @param slot - Slot to read in the contract storage.
    * @param newValue - The new value to store.
-   * @returns Nothing.
+   * @returns The slot of the written leaf in the public data tree.
    */
-  storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void>;
+  storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<bigint>;
 
   /**
    * Mark the uncommitted changes in this TX as a checkpoint.
@@ -67,6 +67,8 @@ export interface PublicContractsDB {
    * @returns The contract instance or undefined if not found.
    */
   getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
+
+  getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
 }
 
 /** Database interface for providing access to commitment tree, l1 to l2 message tree, and nullifier tree. */

package/src/public/execution.ts

@@ -1,5 +1,6 @@
 import { type SimulationError, type UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
 import {
+  type AvmExecutionHints,
   type ContractStorageRead,
   type ContractStorageUpdateRequest,
   type Fr,
@@ -8,11 +9,8 @@ import {
   type NoteHash,
   type Nullifier,
   type PublicCallRequest,
-  PublicDataRead,
-  PublicDataUpdateRequest,
   type ReadRequest,
 } from '@aztec/circuits.js';
-import { computePublicDataTreeLeafSlot, computePublicDataTreeValue } from '@aztec/circuits.js/hash';
 
 import { type Gas } from '../avm/avm_gas.js';
 
@@ -34,10 +32,14 @@ export interface PublicExecutionResult {
   endSideEffectCounter: Fr;
   /** The new nullifiers to be inserted into the nullifier tree. */
   newNullifiers: Nullifier[];
+  /** The note hash read requests emitted in this call. */
+  noteHashReadRequests: ReadRequest[];
   /** The nullifier read requests emitted in this call. */
   nullifierReadRequests: ReadRequest[];
   /** The nullifier non existent read requests emitted in this call. */
   nullifierNonExistentReadRequests: ReadRequest[];
+  /** L1 to L2 message read requests emitted in this call. */
+  l1ToL2MsgReadRequests: ReadRequest[];
   /** The contract storage reads performed by the function. */
   contractStorageReads: ContractStorageRead[];
   /** The contract storage update requests performed by the function. */
@@ -59,26 +61,28 @@ export interface PublicExecutionResult {
    * Useful for maintaining correct ordering in ts.
    */
   allUnencryptedLogs: UnencryptedFunctionL2Logs;
-  /**
-   * Whether the execution reverted.
-   */
+  /** Whether the execution reverted. */
   reverted: boolean;
-  /**
-   * The revert reason if the execution reverted.
-   */
-  revertReason: SimulationError | undefined;
+  /** The revert reason if the execution reverted. */
+  revertReason?: SimulationError;
   /** How much gas was available for this public execution. */
   startGasLeft: Gas;
   /** How much gas was left after this public execution. */
   endGasLeft: Gas;
   /** Transaction fee set for this tx. */
   transactionFee: Fr;
+  /** Bytecode used for this execution. */
+  bytecode?: Buffer;
+  /** Calldata used for this execution. */
+  calldata: Fr[];
+  /** Hints for proving AVM execution. */
+  avmHints: AvmExecutionHints;
 }
 
 /**
  * The execution of a public function.
  */
-export type PublicExecution = Pick<PublicCallRequest, 'contractAddress' | 'functionData' | 'callContext' | 'args'>;
+export type PublicExecution = Pick<PublicCallRequest, 'contractAddress' | 'functionSelector' | 'callContext' | 'args'>;
 
 /**
  * Returns if the input is a public execution result and not just a public execution.
@@ -91,72 +95,6 @@ export function isPublicExecutionResult(
   return 'execution' in input && input.execution !== undefined;
 }
 
-/**
- * Collect all public storage reads across all nested executions
- * and convert them to PublicDataReads (to match kernel output).
- * @param execResult - The topmost execution result.
- * @returns All public data reads (in execution order).
- */
-export function collectPublicDataReads(execResult: PublicExecutionResult): PublicDataRead[] {
-  // HACK(#1622): part of temporary hack - may be able to remove this function after public state ordering is fixed
-  const thisExecPublicDataReads = execResult.contractStorageReads.map(read =>
-    contractStorageReadToPublicDataRead(read),
-  );
-  const unsorted = [
-    ...thisExecPublicDataReads,
-    ...[...execResult.nestedExecutions].flatMap(result => collectPublicDataReads(result)),
-  ];
-  return unsorted.sort((a, b) => a.sideEffectCounter! - b.sideEffectCounter!);
-}
-
-/**
- * Collect all public storage update requests across all nested executions
- * and convert them to PublicDataUpdateRequests (to match kernel output).
- * @param execResult - The topmost execution result.
- * @returns All public data reads (in execution order).
- */
-export function collectPublicDataUpdateRequests(execResult: PublicExecutionResult): PublicDataUpdateRequest[] {
-  // HACK(#1622): part of temporary hack - may be able to remove this function after public state ordering is fixed
-  const thisExecPublicDataUpdateRequests = execResult.contractStorageUpdateRequests.map(update =>
-    contractStorageUpdateRequestToPublicDataUpdateRequest(update),
-  );
-  const unsorted = [
-    ...thisExecPublicDataUpdateRequests,
-    ...[...execResult.nestedExecutions].flatMap(result => collectPublicDataUpdateRequests(result)),
-  ];
-  return unsorted.sort((a, b) => a.sideEffectCounter! - b.sideEffectCounter!);
-}
-
-/**
- * Convert a Contract Storage Read to a Public Data Read.
- * @param read - the contract storage read to convert
- * @param contractAddress - the contract address of the read
- * @returns The public data read.
- */
-function contractStorageReadToPublicDataRead(read: ContractStorageRead): PublicDataRead {
-  return new PublicDataRead(
-    computePublicDataTreeLeafSlot(read.contractAddress!, read.storageSlot),
-    computePublicDataTreeValue(read.currentValue),
-    read.sideEffectCounter!,
-  );
-}
-
-/**
- * Convert a Contract Storage Update Request to a Public Data Update Request.
- * @param update - the contract storage update request to convert
- * @param contractAddress - the contract address of the data update request.
- * @returns The public data update request.
- */
-function contractStorageUpdateRequestToPublicDataUpdateRequest(
-  update: ContractStorageUpdateRequest,
-): PublicDataUpdateRequest {
-  return new PublicDataUpdateRequest(
-    computePublicDataTreeLeafSlot(update.contractAddress!, update.storageSlot),
-    computePublicDataTreeValue(update.newValue),
-    update.sideEffectCounter!,
-  );
-}
-
 /**
  * Checks whether the child execution result is valid for a static call (no state modifications).
  * @param executionResult - The execution result of a public function