@aztec/simulator 0.40.1 → 0.42.0

package/src/public/abstract_phase_manager.ts

@@ -1,64 +1,66 @@
 import {
+  AVM_REQUEST,
+  type AvmProvingRequest,
   MerkleTreeId,
-  type ProcessReturnValues,
-  type PublicKernelRequest,
+  type NestedProcessReturnValues,
+  type PublicKernelNonTailRequest,
   PublicKernelType,
+  type PublicProvingRequest,
   type SimulationError,
   type Tx,
   type UnencryptedFunctionL2Logs,
 } from '@aztec/circuit-types';
 import {
+  type AvmExecutionHints,
   AztecAddress,
   CallRequest,
   ContractStorageRead,
   ContractStorageUpdateRequest,
   Fr,
+  FunctionData,
   Gas,
   type GlobalVariables,
   type Header,
   type KernelCircuitPublicInputs,
   L2ToL1Message,
+  LogHash,
+  MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
   MAX_NEW_L2_TO_L1_MSGS_PER_CALL,
   MAX_NEW_NOTE_HASHES_PER_CALL,
   MAX_NEW_NULLIFIERS_PER_CALL,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
   MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
   MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
   MAX_PUBLIC_DATA_READS_PER_CALL,
-  MAX_PUBLIC_DATA_READS_PER_TX,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
-  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MAX_UNENCRYPTED_LOGS_PER_CALL,
   MembershipWitness,
+  NESTED_RECURSIVE_PROOF_LENGTH,
   NoteHash,
   Nullifier,
-  type Proof,
   PublicCallData,
   type PublicCallRequest,
   PublicCallStackItem,
   PublicCircuitPublicInputs,
-  PublicDataRead,
-  PublicDataUpdateRequest,
   PublicKernelCircuitPrivateInputs,
   type PublicKernelCircuitPublicInputs,
   PublicKernelData,
   ReadRequest,
   RevertCode,
-  SideEffect,
   VK_TREE_HEIGHT,
-  VerificationKey,
+  VerificationKeyData,
   makeEmptyProof,
+  makeEmptyRecursiveProof,
 } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
-import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
+import { padArrayEnd } from '@aztec/foundation/collection';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
-import { type Tuple } from '@aztec/foundation/serialize';
 import {
   type PublicExecution,
   type PublicExecutionResult,
   type PublicExecutor,
-  collectPublicDataReads,
-  collectPublicDataUpdateRequests,
+  accumulateReturnValues,
   isPublicExecutionResult,
 } from '@aztec/simulator';
 import { type MerkleTreeOperations } from '@aztec/world-state';
@@ -77,7 +79,7 @@ export enum PublicKernelPhase {
 export const PhaseIsRevertible: Record<PublicKernelPhase, boolean> = {
   [PublicKernelPhase.SETUP]: false,
   [PublicKernelPhase.APP_LOGIC]: true,
-  [PublicKernelPhase.TEARDOWN]: false,
+  [PublicKernelPhase.TEARDOWN]: true,
   [PublicKernelPhase.TAIL]: false,
 };
 
@@ -95,6 +97,59 @@ export function publicKernelPhaseToKernelType(phase: PublicKernelPhase): PublicK
   }
 }
 
+export type PublicProvingInformation = {
+  calldata: Fr[];
+  bytecode: Buffer;
+  inputs: PublicKernelCircuitPrivateInputs;
+  avmHints: AvmExecutionHints;
+};
+
+export function makeAvmProvingRequest(
+  info: PublicProvingInformation,
+  kernelType: PublicKernelNonTailRequest['type'],
+): AvmProvingRequest {
+  return {
+    type: AVM_REQUEST,
+    bytecode: info.bytecode,
+    calldata: info.calldata,
+    avmHints: info.avmHints,
+    kernelRequest: {
+      type: kernelType,
+      inputs: info.inputs,
+    },
+  };
+}
+
+export type TxPublicCallsResult = {
+  /** Inputs to be used for proving */
+  publicProvingInformation: PublicProvingInformation[];
+  /** The public kernel output at the end of the Tx */
+  kernelOutput: PublicKernelCircuitPublicInputs;
+  /** Unencrypted logs generated during the execution of this Tx */
+  newUnencryptedLogs: UnencryptedFunctionL2Logs[];
+  /** Revert reason, if any */
+  revertReason?: SimulationError;
+  /** Return values of simulating complete callstack */
+  returnValues: NestedProcessReturnValues[];
+  /** Gas used during the execution this Tx */
+  gasUsed?: Gas;
+};
+
+export type PhaseResult = {
+  /** The collection of public proving requests */
+  publicProvingRequests: PublicProvingRequest[];
+  /** The output of the public kernel circuit simulation for this phase */
+  publicKernelOutput: PublicKernelCircuitPublicInputs;
+  /** The final output of the public kernel circuit for this phase */
+  finalKernelOutput?: KernelCircuitPublicInputs;
+  /** Revert reason, if any */
+  revertReason?: SimulationError;
+  /** Return values of simulating complete callstack */
+  returnValues: NestedProcessReturnValues[];
+  /** Gas used during the execution this phase */
+  gasUsed?: Gas;
+};
+
 export abstract class AbstractPhaseManager {
   protected hintsBuilder: HintsBuilder;
   protected log: DebugLogger;
@@ -109,41 +164,12 @@ export abstract class AbstractPhaseManager {
     this.hintsBuilder = new HintsBuilder(db);
     this.log = createDebugLogger(`aztec:sequencer:${phase}`);
   }
+
   /**
-   *
    * @param tx - the tx to be processed
    * @param publicKernelPublicInputs - the output of the public kernel circuit for the previous phase
-   * @param previousPublicKernelProof - the proof of the public kernel circuit for the previous phase
    */
-  abstract handle(
-    tx: Tx,
-    publicKernelPublicInputs: PublicKernelCircuitPublicInputs,
-    previousPublicKernelProof: Proof,
-  ): Promise<{
-    /**
-     * The collection of public kernel requests
-     */
-    kernelRequests: PublicKernelRequest[];
-    /**
-     * the output of the public kernel circuit for this phase
-     */
-    publicKernelOutput: PublicKernelCircuitPublicInputs;
-    /**
-     * the final output of the public kernel circuit for this phase
-     */
-    finalKernelOutput?: KernelCircuitPublicInputs;
-    /**
-     * the proof of the public kernel circuit for this phase
-     */
-    publicKernelProof: Proof;
-    /**
-     * revert reason, if any
-     */
-    revertReason: SimulationError | undefined;
-    returnValues: ProcessReturnValues;
-    /** Gas used during the execution this particular phase. */
-    gasUsed: Gas | undefined;
-  }>;
+  abstract handle(tx: Tx, publicKernelPublicInputs: PublicKernelCircuitPublicInputs): Promise<PhaseResult>;
 
   public static extractEnqueuedPublicCallsByPhase(tx: Tx): Record<PublicKernelPhase, PublicCallRequest[]> {
     const data = tx.data.forPublic;
@@ -215,43 +241,33 @@ export abstract class AbstractPhaseManager {
     return calls;
   }
 
-  // REFACTOR: Do not return an array and instead return a struct with similar shape to that returned by `handle`
   protected async processEnqueuedPublicCalls(
     tx: Tx,
     previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
-    previousPublicKernelProof: Proof,
-  ): Promise<
-    [
-      PublicKernelCircuitPrivateInputs[],
-      PublicKernelCircuitPublicInputs,
-      Proof,
-      UnencryptedFunctionL2Logs[],
-      SimulationError | undefined,
-      ProcessReturnValues,
-      Gas,
-    ]
-  > {
-    let kernelOutput = previousPublicKernelOutput;
-    const kernelProof = previousPublicKernelProof;
-    const publicKernelInputs: PublicKernelCircuitPrivateInputs[] = [];
-
+  ): Promise<TxPublicCallsResult> {
     const enqueuedCalls = this.extractEnqueuedPublicCalls(tx);
 
     if (!enqueuedCalls || !enqueuedCalls.length) {
-      return [[], kernelOutput, kernelProof, [], undefined, undefined, Gas.empty()];
+      return {
+        publicProvingInformation: [],
+        kernelOutput: previousPublicKernelOutput,
+        newUnencryptedLogs: [],
+        returnValues: [],
+        gasUsed: Gas.empty(),
+      };
     }
 
-    const newUnencryptedFunctionLogs: UnencryptedFunctionL2Logs[] = [];
-
-    // Transaction fee is zero for all phases except teardown
-    const transactionFee = this.getTransactionFee(tx, previousPublicKernelOutput);
-
     // TODO(#1684): Should multiple separately enqueued public calls be treated as
     // separate public callstacks to be proven by separate public kernel sequences
     // and submitted separately to the base rollup?
 
-    let returns: ProcessReturnValues = undefined;
+    const provingInformationList: PublicProvingInformation[] = [];
+    const newUnencryptedFunctionLogs: UnencryptedFunctionL2Logs[] = [];
+    // Transaction fee is zero for all phases except teardown
+    const transactionFee = this.getTransactionFee(tx, previousPublicKernelOutput);
     let gasUsed = Gas.empty();
+    let kernelPublicOutput: PublicKernelCircuitPublicInputs = previousPublicKernelOutput;
+    const enqueuedCallResults = [];
 
     for (const enqueuedCall of enqueuedCalls) {
       const executionStack: (PublicExecution | PublicExecutionResult)[] = [enqueuedCall];
@@ -262,10 +278,9 @@ export abstract class AbstractPhaseManager {
       while (executionStack.length) {
         const current = executionStack.pop()!;
         const isExecutionRequest = !isPublicExecutionResult(current);
-        // TODO(6052): Extract correct new counter from nested calls
-        const sideEffectCounter = lastSideEffectCounter(tx) + 1;
-        const availableGas = this.getAvailableGas(tx, kernelOutput);
-        const pendingNullifiers = this.getSiloedPendingNullifiers(kernelOutput);
+        const sideEffectCounter = lastSideEffectCounter(kernelPublicOutput) + 1;
+        const availableGas = this.getAvailableGas(tx, kernelPublicOutput);
+        const pendingNullifiers = this.getSiloedPendingNullifiers(kernelPublicOutput);
 
         const result = isExecutionRequest
           ? await this.publicExecutor.simulate(
@@ -279,18 +294,18 @@ export abstract class AbstractPhaseManager {
             )
           : current;
 
+        // Accumulate gas used in this execution
+        gasUsed = gasUsed.add(Gas.from(result.startGasLeft).sub(Gas.from(result.endGasLeft)));
+
         // Sanity check for a current upstream assumption.
         // Consumers of the result seem to expect "reverted <=> revertReason !== undefined".
-        const functionSelector = result.execution.functionData.selector.toString();
+        const functionSelector = result.execution.functionSelector.toString();
         if (result.reverted && !result.revertReason) {
           throw new Error(
             `Simulation of ${result.execution.contractAddress.toString()}:${functionSelector} reverted with no reason.`,
           );
         }
 
-        // Accumulate gas used in this execution
-        gasUsed = gasUsed.add(Gas.from(result.startGasLeft).sub(Gas.from(result.endGasLeft)));
-
         if (result.reverted && !PhaseIsRevertible[this.phase]) {
           this.log.debug(
             `Simulation error on ${result.execution.contractAddress.toString()}:${functionSelector} with reason: ${
@@ -303,23 +318,29 @@ export abstract class AbstractPhaseManager {
         if (isExecutionRequest) {
           newUnencryptedFunctionLogs.push(result.allUnencryptedLogs);
         }
+        executionStack.push(...result.nestedExecutions);
 
+        // Simulate the public kernel circuit.
         this.log.debug(
           `Running public kernel circuit for ${result.execution.contractAddress.toString()}:${functionSelector}`,
         );
-        executionStack.push(...result.nestedExecutions);
         const callData = await this.getPublicCallData(result, isExecutionRequest);
-
-        const circuitResult = await this.runKernelCircuit(kernelOutput, kernelProof, callData);
-        kernelOutput = circuitResult[1];
-
-        // Capture the inputs to the kernel circuit for later proving
-        publicKernelInputs.push(circuitResult[0]);
-
-        // sanity check. Note we can't expect them to just be equal, because e.g.
+        const [privateInputs, publicInputs] = await this.runKernelCircuit(kernelPublicOutput, callData);
+        kernelPublicOutput = publicInputs;
+
+        // Capture the inputs for later proving in the AVM and kernel.
+        const publicProvingInformation: PublicProvingInformation = {
+          calldata: result.calldata,
+          bytecode: result.bytecode!,
+          inputs: privateInputs,
+          avmHints: result.avmHints,
+        };
+        provingInformationList.push(publicProvingInformation);
+
+        // Sanity check: Note we can't expect them to just be equal, because e.g.
         // if the simulator reverts in app logic, it "resets" and result.reverted will be false when we run teardown,
         // but the kernel carries the reverted flag forward. But if the simulator reverts, so should the kernel.
-        if (result.reverted && kernelOutput.revertCode.isOK()) {
+        if (result.reverted && kernelPublicOutput.revertCode.isOK()) {
           throw new Error(
             `Public kernel circuit did not revert on ${result.execution.contractAddress.toString()}:${functionSelector}, but simulator did.`,
           );
@@ -334,26 +355,34 @@ export abstract class AbstractPhaseManager {
             }`,
           );
           // TODO(@spalladino): Check gasUsed is correct. The AVM should take care of setting gasLeft to zero upon a revert.
-          return [[], kernelOutput, kernelProof, [], result.revertReason, undefined, gasUsed];
+          return {
+            publicProvingInformation: [],
+            kernelOutput: kernelPublicOutput,
+            newUnencryptedLogs: [],
+            revertReason: result.revertReason,
+            returnValues: [],
+            gasUsed,
+          };
         }
 
         if (!enqueuedExecutionResult) {
           enqueuedExecutionResult = result;
-          returns = result.returnValues;
         }
+
+        enqueuedCallResults.push(accumulateReturnValues(enqueuedExecutionResult));
       }
-      // HACK(#1622): Manually patches the ordering of public state actions
-      // TODO(#757): Enforce proper ordering of public state actions
-      patchPublicStorageActionOrdering(kernelOutput, enqueuedExecutionResult!, this.phase);
     }
 
-    // TODO(#3675): This should be done in a public kernel circuit
-    removeRedundantPublicDataWrites(kernelOutput, this.phase);
-
-    return [publicKernelInputs, kernelOutput, kernelProof, newUnencryptedFunctionLogs, undefined, returns, gasUsed];
+    return {
+      publicProvingInformation: provingInformationList,
+      kernelOutput: kernelPublicOutput,
+      newUnencryptedLogs: newUnencryptedFunctionLogs,
+      returnValues: enqueuedCallResults,
+      gasUsed,
+    };
   }
 
-  /** Returns all pending private and public nullifiers.  */
+  /** Returns all pending private and public nullifiers. */
   private getSiloedPendingNullifiers(ko: PublicKernelCircuitPublicInputs) {
     return [...ko.end.newNullifiers, ...ko.endNonRevertibleData.newNullifiers].filter(n => !n.isEmpty());
   }
@@ -369,20 +398,11 @@ export abstract class AbstractPhaseManager {
     return Fr.ZERO;
   }
 
-  protected async runKernelCircuit(
-    previousOutput: PublicKernelCircuitPublicInputs,
-    previousProof: Proof,
-    callData: PublicCallData,
-  ): Promise<[PublicKernelCircuitPrivateInputs, PublicKernelCircuitPublicInputs]> {
-    return await this.getKernelCircuitOutput(previousOutput, previousProof, callData);
-  }
-
-  protected async getKernelCircuitOutput(
+  private async runKernelCircuit(
     previousOutput: PublicKernelCircuitPublicInputs,
-    previousProof: Proof,
     callData: PublicCallData,
   ): Promise<[PublicKernelCircuitPrivateInputs, PublicKernelCircuitPublicInputs]> {
-    const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
+    const previousKernel = this.getPreviousKernelData(previousOutput);
 
     // We take a deep copy (clone) of these inputs to be passed to the prover
     const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, callData);
@@ -398,15 +418,13 @@ export abstract class AbstractPhaseManager {
     }
   }
 
-  protected getPreviousKernelData(
-    previousOutput: PublicKernelCircuitPublicInputs,
-    previousProof: Proof,
-  ): PublicKernelData {
-    // TODO(@PhilWindle) Fix once we move this to prover-client
-    const vk = VerificationKey.makeFake();
+  protected getPreviousKernelData(previousOutput: PublicKernelCircuitPublicInputs): PublicKernelData {
+    // The proof and verification key are not used in simulation
+    const vk = VerificationKeyData.makeFake();
+    const proof = makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH);
     const vkIndex = 0;
     const vkSiblingPath = MembershipWitness.random(VK_TREE_HEIGHT).siblingPath;
-    return new PublicKernelData(previousOutput, previousProof, vk, vkIndex, vkSiblingPath);
+    return new PublicKernelData(previousOutput, proof, vk, vkIndex, vkSiblingPath);
   }
 
   protected async getPublicCallStackItem(result: PublicExecutionResult, isExecutionRequest = false) {
@@ -430,6 +448,11 @@ export abstract class AbstractPhaseManager {
       startSideEffectCounter: result.startSideEffectCounter,
       endSideEffectCounter: result.endSideEffectCounter,
       returnsHash: computeVarArgsHash(result.returnValues),
+      noteHashReadRequests: padArrayEnd(
+        result.noteHashReadRequests,
+        ReadRequest.empty(),
+        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+      ),
       nullifierReadRequests: padArrayEnd(
         result.nullifierReadRequests,
         ReadRequest.empty(),
@@ -440,6 +463,11 @@ export abstract class AbstractPhaseManager {
         ReadRequest.empty(),
         MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
       ),
+      l1ToL2MsgReadRequests: padArrayEnd(
+        result.l1ToL2MsgReadRequests,
+        ReadRequest.empty(),
+        MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
+      ),
       contractStorageReads: padArrayEnd(
         result.contractStorageReads,
         ContractStorageRead.empty(),
@@ -451,24 +479,19 @@ export abstract class AbstractPhaseManager {
         MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
       ),
       publicCallStackHashes,
-      unencryptedLogsHashes: padArrayEnd(
-        result.unencryptedLogsHashes,
-        SideEffect.empty(),
-        MAX_UNENCRYPTED_LOGS_PER_CALL,
-      ),
-      unencryptedLogPreimagesLength: result.unencryptedLogPreimagesLength,
+      unencryptedLogsHashes: padArrayEnd(result.unencryptedLogsHashes, LogHash.empty(), MAX_UNENCRYPTED_LOGS_PER_CALL),
       historicalHeader: this.historicalHeader,
       globalVariables: this.globalVariables,
       startGasLeft: Gas.from(result.startGasLeft),
       endGasLeft: Gas.from(result.endGasLeft),
       transactionFee: result.transactionFee,
       // TODO(@just-mitch): need better mapping from simulator to revert code.
-      revertCode: result.reverted ? RevertCode.REVERTED : RevertCode.OK,
+      revertCode: result.reverted ? RevertCode.APP_LOGIC_REVERTED : RevertCode.OK,
     });
 
     return new PublicCallStackItem(
       result.execution.contractAddress,
-      result.execution.functionData,
+      new FunctionData(result.execution.functionSelector, false),
       publicCircuitPublicInputs,
       isExecutionRequest,
     );
@@ -510,87 +533,3 @@ export abstract class AbstractPhaseManager {
     return new PublicCallData(callStackItem, publicCallStack, makeEmptyProof(), bytecodeHash);
   }
 }
-
-function removeRedundantPublicDataWrites(publicInputs: PublicKernelCircuitPublicInputs, phase: PublicKernelPhase) {
-  const lastWritesMap = new Map<string, boolean>();
-  const patch = <N extends number>(requests: Tuple<PublicDataUpdateRequest, N>) =>
-    requests.filter(write => {
-      const leafSlot = write.leafSlot.toString();
-      const exists = lastWritesMap.get(leafSlot);
-      lastWritesMap.set(leafSlot, true);
-      return !exists;
-    });
-
-  const [prev, curr] = PhaseIsRevertible[phase]
-    ? [publicInputs.endNonRevertibleData, publicInputs.end]
-    : [publicInputs.end, publicInputs.endNonRevertibleData];
-
-  curr.publicDataUpdateRequests = padArrayEnd(
-    patch(curr.publicDataUpdateRequests.reverse()).reverse(),
-    PublicDataUpdateRequest.empty(),
-    MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  );
-
-  prev.publicDataUpdateRequests = padArrayEnd(
-    patch(prev.publicDataUpdateRequests.reverse()),
-    PublicDataUpdateRequest.empty(),
-    MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  );
-}
-
-// HACK(#1622): this is a hack to fix ordering of public state in the call stack. Since the private kernel
-// cannot keep track of side effects that happen after or before a nested call, we override the public
-// state actions it emits with whatever we got from the simulator. As a sanity check, we at least verify
-// that the elements are the same, so we are only tweaking their ordering.
-// See yarn-project/end-to-end/src/e2e_ordering.test.ts
-// See https://github.com/AztecProtocol/aztec-packages/issues/1616
-// TODO(#757): Enforce proper ordering of public state actions
-/**
- * Patch the ordering of storage actions output from the public kernel.
- * @param publicInputs - to be patched here: public inputs to the kernel iteration up to this point
- * @param execResult - result of the top/first execution for this enqueued public call
- */
-function patchPublicStorageActionOrdering(
-  publicInputs: PublicKernelCircuitPublicInputs,
-  execResult: PublicExecutionResult,
-  phase: PublicKernelPhase,
-) {
-  const { publicDataUpdateRequests } = PhaseIsRevertible[phase] ? publicInputs.end : publicInputs.endNonRevertibleData;
-  const { publicDataReads } = publicInputs.validationRequests;
-
-  // Convert ContractStorage* objects to PublicData* objects and sort them in execution order.
-  // Note, this only pulls simulated reads/writes from the current phase,
-  // so the returned result will be a subset of the public kernel output.
-
-  const simPublicDataReads = collectPublicDataReads(execResult);
-
-  const simPublicDataUpdateRequests = collectPublicDataUpdateRequests(execResult);
-
-  // We only want to reorder the items from the public inputs of the
-  // most recently processed top/enqueued call.
-
-  const effectSet = PhaseIsRevertible[phase] ? 'end' : 'endNonRevertibleData';
-
-  const numReadsInKernel = arrayNonEmptyLength(publicDataReads, f => f.isEmpty());
-  const numReadsBeforeThisEnqueuedCall = numReadsInKernel - simPublicDataReads.length;
-  publicInputs.validationRequests.publicDataReads = padArrayEnd(
-    [
-      // do not mess with items from previous top/enqueued calls in kernel output
-      ...publicInputs.validationRequests.publicDataReads.slice(0, numReadsBeforeThisEnqueuedCall),
-      ...simPublicDataReads,
-    ],
-    PublicDataRead.empty(),
-    MAX_PUBLIC_DATA_READS_PER_TX,
-  );
-
-  const numUpdatesInKernel = arrayNonEmptyLength(publicDataUpdateRequests, f => f.isEmpty());
-  const numUpdatesBeforeThisEnqueuedCall = numUpdatesInKernel - simPublicDataUpdateRequests.length;
-  publicInputs[effectSet].publicDataUpdateRequests = padArrayEnd(
-    [
-      ...publicInputs[effectSet].publicDataUpdateRequests.slice(0, numUpdatesBeforeThisEnqueuedCall),
-      ...simPublicDataUpdateRequests,
-    ],
-    PublicDataUpdateRequest.empty(),
-    MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  );
-}

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, PublicKernelPhase, makeAvmProvingRequest } from './abstract_phase_manager.js';
+import { type ContractsDataSourcePublicDB } from './public_db_sources.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 
 /**
@@ -29,49 +24,38 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
     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.