@aztec/sequencer-client 0.24.0 → 0.26.1

package/src/sequencer/abstract_phase_manager.ts

@@ -2,22 +2,27 @@ import { FunctionL2Logs, MerkleTreeId, Tx } from '@aztec/circuit-types';
 import {
   AztecAddress,
   CallRequest,
-  CombinedAccumulatedData,
   ContractStorageRead,
   ContractStorageUpdateRequest,
   Fr,
   GlobalVariables,
   Header,
-  MAX_NEW_COMMITMENTS_PER_CALL,
+  L2ToL1Message,
   MAX_NEW_L2_TO_L1_MSGS_PER_CALL,
+  MAX_NEW_NOTE_HASHES_PER_CALL,
   MAX_NEW_NULLIFIERS_PER_CALL,
+  MAX_NON_REVERTIBLE_PUBLIC_DATA_READS_PER_TX,
+  MAX_NON_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   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_REVERTIBLE_PUBLIC_DATA_READS_PER_TX,
+  MAX_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MembershipWitness,
+  PrivateKernelTailCircuitPublicInputs,
   Proof,
+  PublicAccumulatedNonRevertibleData,
+  PublicAccumulatedRevertibleData,
   PublicCallData,
   PublicCallRequest,
   PublicCallStackItem,
@@ -32,10 +37,10 @@ import {
   SideEffectLinkedToNoteHash,
   VK_TREE_HEIGHT,
 } from '@aztec/circuits.js';
-import { computeVarArgsHash } from '@aztec/circuits.js/abis';
+import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
-import { createDebugLogger } from '@aztec/foundation/log';
-import { to2Fields } from '@aztec/foundation/serialize';
+import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
+import { Tuple, to2Fields } from '@aztec/foundation/serialize';
 import {
   PublicExecution,
   PublicExecutionResult,
@@ -53,15 +58,20 @@ import { PublicProver } from '../prover/index.js';
 import { PublicKernelCircuitSimulator } from '../simulator/index.js';
 import { FailedTx } from './processed_tx.js';
 
-/**
- * A phase manager is responsible for performing/rolling back a phase of a transaction.
- *
- * The phases are as follows:
- * 1. Fee Preparation
- * 2. Application Logic
- * 3. Fee Distribution
- */
+export enum PublicKernelPhase {
+  SETUP = 'setup',
+  APP_LOGIC = 'app-logic',
+  TEARDOWN = 'teardown',
+}
+
+export const PhaseIsRevertible: Record<PublicKernelPhase, boolean> = {
+  [PublicKernelPhase.SETUP]: false,
+  [PublicKernelPhase.APP_LOGIC]: true,
+  [PublicKernelPhase.TEARDOWN]: false,
+};
+
 export abstract class AbstractPhaseManager {
+  protected log: DebugLogger;
   constructor(
     protected db: MerkleTreeOperations,
     protected publicExecutor: PublicExecutor,
@@ -69,8 +79,10 @@ export abstract class AbstractPhaseManager {
     protected publicProver: PublicProver,
     protected globalVariables: GlobalVariables,
     protected historicalHeader: Header,
-    protected log = createDebugLogger('aztec:sequencer:phase-manager'),
-  ) {}
+    public phase: PublicKernelPhase,
+  ) {
+    this.log = createDebugLogger(`aztec:sequencer:${phase}`);
+  }
   /**
    *
    * @param tx - the tx to be processed
@@ -79,25 +91,74 @@ export abstract class AbstractPhaseManager {
    */
   abstract handle(
     tx: Tx,
-    publicKernelPublicInputs?: PublicKernelCircuitPublicInputs,
-    previousPublicKernelProof?: Proof,
+    publicKernelPublicInputs: PublicKernelCircuitPublicInputs,
+    previousPublicKernelProof: Proof,
   ): Promise<{
     /**
      * the output of the public kernel circuit for this phase
      */
-    publicKernelOutput?: PublicKernelCircuitPublicInputs;
+    publicKernelOutput: PublicKernelCircuitPublicInputs;
     /**
      * the proof of the public kernel circuit for this phase
      */
-    publicKernelProof?: Proof;
+    publicKernelProof: Proof;
   }>;
-  abstract nextPhase(): AbstractPhaseManager | undefined;
   abstract rollback(tx: Tx, err: unknown): Promise<FailedTx>;
 
-  // Extract the public calls from the tx for this phase
-  abstract extractEnqueuedPublicCalls(tx: Tx): PublicCallRequest[];
+  public static extractEnqueuedPublicCallsByPhase(
+    publicInputs: PrivateKernelTailCircuitPublicInputs,
+    enqueuedPublicFunctionCalls: PublicCallRequest[],
+  ): Record<PublicKernelPhase, PublicCallRequest[]> {
+    const publicCallsStack = enqueuedPublicFunctionCalls.slice().reverse();
+    const nonRevertibleCallStack = publicInputs.endNonRevertibleData.publicCallStack.filter(i => !i.isEmpty());
+    const revertibleCallStack = publicInputs.end.publicCallStack.filter(i => !i.isEmpty());
+
+    const callRequestsStack = publicCallsStack
+      .map(call => call.toCallRequest())
+      .filter(
+        // filter out enqueued calls that are not in the public call stack
+        // TODO mitch left a question about whether this is only needed when unit testing
+        // with mock data
+        call => revertibleCallStack.find(p => p.equals(call)) || nonRevertibleCallStack.find(p => p.equals(call)),
+      );
 
-  protected getKernelOutputAndProof(
+    if (callRequestsStack.length === 0) {
+      return {
+        [PublicKernelPhase.SETUP]: [],
+        [PublicKernelPhase.APP_LOGIC]: [],
+        [PublicKernelPhase.TEARDOWN]: [],
+      };
+    }
+
+    // find the first call that is revertible
+    const firstRevertibleCallIndex = callRequestsStack.findIndex(
+      c => revertibleCallStack.findIndex(p => p.equals(c)) !== -1,
+    );
+
+    if (firstRevertibleCallIndex === 0) {
+      return {
+        [PublicKernelPhase.SETUP]: [],
+        [PublicKernelPhase.APP_LOGIC]: publicCallsStack,
+        [PublicKernelPhase.TEARDOWN]: [],
+      };
+    } else {
+      return {
+        [PublicKernelPhase.SETUP]: publicCallsStack.slice(0, firstRevertibleCallIndex - 1),
+        [PublicKernelPhase.APP_LOGIC]: publicCallsStack.slice(firstRevertibleCallIndex),
+        [PublicKernelPhase.TEARDOWN]: [publicCallsStack[firstRevertibleCallIndex - 1]],
+      };
+    }
+  }
+
+  protected extractEnqueuedPublicCalls(tx: Tx): PublicCallRequest[] {
+    const calls = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx.data, tx.enqueuedPublicFunctionCalls)[
+      this.phase
+    ];
+
+    return calls;
+  }
+
+  public static getKernelOutputAndProof(
     tx: Tx,
     publicKernelPublicInput?: PublicKernelCircuitPublicInputs,
     previousPublicKernelProof?: Proof,
@@ -119,10 +180,12 @@ export abstract class AbstractPhaseManager {
     } else {
       const publicKernelPublicInput = new PublicKernelCircuitPublicInputs(
         tx.data.aggregationObject,
-        tx.data.endNonRevertibleData,
-        CombinedAccumulatedData.fromFinalAccumulatedData(tx.data.end),
+        PublicAccumulatedNonRevertibleData.fromPrivateAccumulatedNonRevertibleData(tx.data.endNonRevertibleData),
+        PublicAccumulatedRevertibleData.fromPrivateAccumulatedRevertibleData(tx.data.end),
         tx.data.constants,
-        tx.data.isPrivate,
+        tx.data.needsSetup,
+        tx.data.needsAppLogic,
+        tx.data.needsTeardown,
       );
       const publicKernelProof = previousPublicKernelProof || tx.proof;
       return {
@@ -133,16 +196,19 @@ export abstract class AbstractPhaseManager {
   }
 
   protected async processEnqueuedPublicCalls(
-    enqueuedCalls: PublicCallRequest[],
+    tx: Tx,
     previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
     previousPublicKernelProof: Proof,
   ): Promise<[PublicKernelCircuitPublicInputs, Proof, FunctionL2Logs[]]> {
-    if (!enqueuedCalls || !enqueuedCalls.length) {
-      throw new Error(`Missing preimages for enqueued public calls`);
-    }
     let kernelOutput = previousPublicKernelOutput;
     let kernelProof = previousPublicKernelProof;
 
+    const enqueuedCalls = this.extractEnqueuedPublicCalls(tx);
+
+    if (!enqueuedCalls || !enqueuedCalls.length) {
+      return [kernelOutput, kernelProof, []];
+    }
+
     const newUnencryptedFunctionLogs: FunctionL2Logs[] = [];
 
     // TODO(#1684): Should multiple separately enqueued public calls be treated as
@@ -169,8 +235,8 @@ export abstract class AbstractPhaseManager {
 
         newUnencryptedFunctionLogs.push(result.unencryptedLogs);
         const functionSelector = result.execution.functionData.selector.toString();
-        this.log(
-          `Running public kernel circuit for ${functionSelector}@${result.execution.contractAddress.toString()}`,
+        this.log.debug(
+          `Running public kernel circuit for ${result.execution.contractAddress.toString()}:${functionSelector}`,
         );
         executionStack.push(...result.nestedExecutions);
         const callData = await this.getPublicCallData(result, isExecutionRequest);
@@ -183,11 +249,11 @@ export abstract class AbstractPhaseManager {
       }
       // HACK(#1622): Manually patches the ordering of public state actions
       // TODO(#757): Enforce proper ordering of public state actions
-      this.patchPublicStorageActionOrdering(kernelOutput, enqueuedExecutionResult!);
+      patchPublicStorageActionOrdering(kernelOutput, enqueuedExecutionResult!, this.phase);
     }
 
     // TODO(#3675): This should be done in a public kernel circuit
-    this.removeRedundantPublicDataWrites(kernelOutput);
+    removeRedundantPublicDataWrites(kernelOutput);
 
     return [kernelOutput, kernelProof, newUnencryptedFunctionLogs];
   }
@@ -207,18 +273,17 @@ export abstract class AbstractPhaseManager {
     previousOutput: PublicKernelCircuitPublicInputs,
     previousProof: Proof,
   ): Promise<PublicKernelCircuitPublicInputs> {
-    if (previousOutput?.isPrivate && previousProof) {
-      // Run the public kernel circuit with previous private kernel
-      const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
-      const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, callData);
-      return this.publicKernel.publicKernelCircuitPrivateInput(inputs);
-    } else if (previousOutput && previousProof) {
-      // Run the public kernel circuit with previous public kernel
-      const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
-      const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, callData);
-      return this.publicKernel.publicKernelCircuitNonFirstIteration(inputs);
-    } else {
-      throw new Error(`No public kernel circuit for inputs`);
+    const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
+    const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, callData);
+    switch (this.phase) {
+      case PublicKernelPhase.SETUP:
+        return this.publicKernel.publicKernelCircuitSetup(inputs);
+      case PublicKernelPhase.APP_LOGIC:
+        return this.publicKernel.publicKernelCircuitAppLogic(inputs);
+      case PublicKernelPhase.TEARDOWN:
+        return this.publicKernel.publicKernelCircuitTeardown(inputs);
+      default:
+        throw new Error(`No public kernel circuit for inputs`);
     }
   }
 
@@ -251,9 +316,9 @@ export abstract class AbstractPhaseManager {
       callContext: result.execution.callContext,
       proverAddress: AztecAddress.ZERO,
       argsHash: computeVarArgsHash(result.execution.args),
-      newCommitments: padArrayEnd(result.newCommitments, SideEffect.empty(), MAX_NEW_COMMITMENTS_PER_CALL),
+      newNoteHashes: padArrayEnd(result.newNoteHashes, SideEffect.empty(), MAX_NEW_NOTE_HASHES_PER_CALL),
       newNullifiers: padArrayEnd(result.newNullifiers, SideEffectLinkedToNoteHash.empty(), MAX_NEW_NULLIFIERS_PER_CALL),
-      newL2ToL1Msgs: padArrayEnd(result.newL2ToL1Messages, Fr.ZERO, MAX_NEW_L2_TO_L1_MSGS_PER_CALL),
+      newL2ToL1Msgs: padArrayEnd(result.newL2ToL1Messages, L2ToL1Message.empty(), MAX_NEW_L2_TO_L1_MSGS_PER_CALL),
       returnValues: padArrayEnd(result.returnValues, Fr.ZERO, RETURN_VALUES_LENGTH),
       contractStorageReads: padArrayEnd(
         result.contractStorageReads,
@@ -310,118 +375,115 @@ export abstract class AbstractPhaseManager {
   protected async getPublicCallData(result: PublicExecutionResult, isExecutionRequest = false) {
     const bytecodeHash = await this.getBytecodeHash(result);
     const callStackItem = await this.getPublicCallStackItem(result, isExecutionRequest);
-    const publicCallRequests = (await this.getPublicCallStackPreimages(result)).map(c => c.toCallRequest());
+    const publicCallRequests = (await this.getPublicCallStackPreimages(result)).map(c =>
+      c.toCallRequest(callStackItem.publicInputs.callContext),
+    );
     const publicCallStack = padArrayEnd(publicCallRequests, CallRequest.empty(), MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL);
     const portalContractAddress = result.execution.callContext.portalContractAddress.toField();
     const proof = await this.publicProver.getPublicCircuitProof(callStackItem.publicInputs);
     return new PublicCallData(callStackItem, publicCallStack, proof, portalContractAddress, bytecodeHash);
   }
+}
 
-  // 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
-   */
-  private patchPublicStorageActionOrdering(
-    publicInputs: PublicKernelCircuitPublicInputs,
-    execResult: PublicExecutionResult,
-  ) {
-    // Convert ContractStorage* objects to PublicData* objects and sort them in execution order
-    const simPublicDataReads = collectPublicDataReads(execResult);
-    const simPublicDataUpdateRequests = collectPublicDataUpdateRequests(execResult);
-
-    const { publicDataReads, publicDataUpdateRequests } = publicInputs.end; // from kernel
-
-    // Validate all items in enqueued public calls are in the kernel emitted stack
-    const readsAreEqual = simPublicDataReads.reduce(
-      (accum, read) =>
-        accum && !!publicDataReads.find(item => item.leafSlot.equals(read.leafSlot) && item.value.equals(read.value)),
-      true,
-    );
-    const updatesAreEqual = simPublicDataUpdateRequests.reduce(
-      (accum, update) =>
-        accum &&
-        !!publicDataUpdateRequests.find(
-          item => item.leafSlot.equals(update.leafSlot) && item.newValue.equals(update.newValue),
-        ),
-      true,
-    );
+function removeRedundantPublicDataWrites(publicInputs: PublicKernelCircuitPublicInputs) {
+  const patch = <N extends number>(requests: Tuple<PublicDataUpdateRequest, N>) => {
+    const lastWritesMap = new Map<string, PublicDataUpdateRequest>();
+    for (const write of requests) {
+      const key = write.leafSlot.toString();
+      lastWritesMap.set(key, write);
+    }
+    return requests.filter(write => lastWritesMap.get(write.leafSlot.toString())?.equals(write));
+  };
+
+  publicInputs.end.publicDataUpdateRequests = padArrayEnd(
+    patch(publicInputs.end.publicDataUpdateRequests),
+    PublicDataUpdateRequest.empty(),
+    MAX_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  );
+
+  publicInputs.endNonRevertibleData.publicDataUpdateRequests = padArrayEnd(
+    patch(publicInputs.endNonRevertibleData.publicDataUpdateRequests),
+    PublicDataUpdateRequest.empty(),
+    MAX_NON_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  );
+}
 
-    if (!readsAreEqual) {
+// 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 { publicDataReads, publicDataUpdateRequests } = PhaseIsRevertible[phase]
+    ? publicInputs.end
+    : publicInputs.endNonRevertibleData;
+
+  // 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);
+  // verify that each read is in the kernel output
+  for (const read of simPublicDataReads) {
+    if (!publicDataReads.find(item => item.equals(read))) {
       throw new Error(
         `Public data reads from simulator do not match those from public kernel.\nFrom simulator: ${simPublicDataReads
           .map(p => p.toFriendlyJSON())
           .join(', ')}\nFrom public kernel: ${publicDataReads.map(i => i.toFriendlyJSON()).join(', ')}`,
       );
     }
-    if (!updatesAreEqual) {
+  }
+
+  const simPublicDataUpdateRequests = collectPublicDataUpdateRequests(execResult);
+  for (const update of simPublicDataUpdateRequests) {
+    if (!publicDataUpdateRequests.find(item => item.equals(update))) {
       throw new Error(
         `Public data update requests from simulator do not match those from public kernel.\nFrom simulator: ${simPublicDataUpdateRequests
           .map(p => p.toFriendlyJSON())
-          .join(', ')}\nFrom public kernel: ${publicDataUpdateRequests.map(i => i.toFriendlyJSON()).join(', ')}`,
+          .join(', ')}\nFrom public kernel revertible: ${publicDataUpdateRequests
+          .map(i => i.toFriendlyJSON())
+          .join(', ')}`,
       );
     }
-
-    // Assume that kernel public inputs has the right number of items.
-    // We only want to reorder the items from the public inputs of the
-    // most recently processed top/enqueued call.
-    const numTotalReadsInKernel = arrayNonEmptyLength(
-      publicInputs.end.publicDataReads,
-      f => f.leafSlot.equals(Fr.ZERO) && f.value.equals(Fr.ZERO),
-    );
-    const numTotalUpdatesInKernel = arrayNonEmptyLength(
-      publicInputs.end.publicDataUpdateRequests,
-      f => f.leafSlot.equals(Fr.ZERO) && f.newValue.equals(Fr.ZERO),
-    );
-    const numReadsBeforeThisEnqueuedCall = numTotalReadsInKernel - simPublicDataReads.length;
-    const numUpdatesBeforeThisEnqueuedCall = numTotalUpdatesInKernel - simPublicDataUpdateRequests.length;
-
-    // Override kernel output
-    publicInputs.end.publicDataReads = padArrayEnd(
-      [
-        // do not mess with items from previous top/enqueued calls in kernel output
-        ...publicDataReads.slice(0, numReadsBeforeThisEnqueuedCall),
-        ...simPublicDataReads,
-      ],
-      PublicDataRead.empty(),
-      MAX_PUBLIC_DATA_READS_PER_TX,
-    );
-
-    // Override kernel output
-    publicInputs.end.publicDataUpdateRequests = padArrayEnd(
-      [
-        // do not mess with items from previous top/enqueued calls in kernel output
-        ...publicDataUpdateRequests.slice(0, numUpdatesBeforeThisEnqueuedCall),
-        ...simPublicDataUpdateRequests,
-      ],
-      PublicDataUpdateRequest.empty(),
-      MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-    );
-  }
-
-  private removeRedundantPublicDataWrites(publicInputs: PublicKernelCircuitPublicInputs) {
-    const lastWritesMap = new Map();
-    for (const write of publicInputs.end.publicDataUpdateRequests) {
-      const key = write.leafSlot.toString();
-      lastWritesMap.set(key, write);
-    }
-
-    const lastWrites = publicInputs.end.publicDataUpdateRequests.filter(
-      write => lastWritesMap.get(write.leafSlot.toString()) === write,
-    );
-
-    publicInputs.end.publicDataUpdateRequests = padArrayEnd(
-      lastWrites,
-
-      PublicDataUpdateRequest.empty(),
-      MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-    );
   }
+  // 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[effectSet].publicDataReads = padArrayEnd(
+    [
+      // do not mess with items from previous top/enqueued calls in kernel output
+      ...publicInputs[effectSet].publicDataReads.slice(0, numReadsBeforeThisEnqueuedCall),
+      ...simPublicDataReads,
+    ],
+    PublicDataRead.empty(),
+    PhaseIsRevertible[phase] ? MAX_REVERTIBLE_PUBLIC_DATA_READS_PER_TX : MAX_NON_REVERTIBLE_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(),
+    PhaseIsRevertible[phase]
+      ? MAX_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+      : MAX_NON_REVERTIBLE_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  );
 }

package/src/sequencer/app_logic_phase_manager.ts

@@ -0,0 +1,75 @@
+import { Tx } from '@aztec/circuit-types';
+import { GlobalVariables, Header, Proof, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
+import { PublicExecutor, PublicStateDB } from '@aztec/simulator';
+import { MerkleTreeOperations } from '@aztec/world-state';
+
+import { PublicProver } from '../prover/index.js';
+import { PublicKernelCircuitSimulator } from '../simulator/index.js';
+import { ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
+import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
+import { FailedTx } from './processed_tx.js';
+
+/**
+ * The phase manager responsible for performing the fee preparation phase.
+ */
+export class AppLogicPhaseManager extends AbstractPhaseManager {
+  constructor(
+    protected db: MerkleTreeOperations,
+    protected publicExecutor: PublicExecutor,
+    protected publicKernel: PublicKernelCircuitSimulator,
+    protected publicProver: PublicProver,
+    protected globalVariables: GlobalVariables,
+    protected historicalHeader: Header,
+    protected publicContractsDB: ContractsDataSourcePublicDB,
+    protected publicStateDB: PublicStateDB,
+    public phase: PublicKernelPhase = PublicKernelPhase.APP_LOGIC,
+  ) {
+    super(db, publicExecutor, publicKernel, publicProver, globalVariables, historicalHeader, phase);
+  }
+
+  async handle(
+    tx: Tx,
+    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
+    previousPublicKernelProof: Proof,
+  ): Promise<{
+    /**
+     * the output of the public kernel circuit for this phase
+     */
+    publicKernelOutput: PublicKernelCircuitPublicInputs;
+    /**
+     * the proof of the public kernel circuit for this phase
+     */
+    publicKernelProof: Proof;
+  }> {
+    // 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(`Processing tx ${tx.getTxHash()}`);
+    await this.publicContractsDB.addNewContracts(tx);
+    this.log(`Executing enqueued public calls for tx ${tx.getTxHash()}`);
+    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs] = await this.processEnqueuedPublicCalls(
+      tx,
+      previousPublicKernelOutput,
+      previousPublicKernelProof,
+    );
+    tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
+
+    // commit the state updates from this transaction
+    await this.publicStateDB.commit();
+
+    return { publicKernelOutput, publicKernelProof };
+  }
+
+  async rollback(tx: Tx, err: unknown): Promise<FailedTx> {
+    this.log.warn(`Error processing tx ${tx.getTxHash()}: ${err}`);
+    // remove contracts on failure
+    await this.publicContractsDB.removeNewContracts(tx);
+    // rollback any state updates from this failed transaction
+    await this.publicStateDB.rollback();
+    return {
+      tx,
+      error: err instanceof Error ? err : new Error('Unknown error'),
+    };
+  }
+}