@aztec/simulator 0.40.1 → 0.42.0

package/src/public/public_kernel.ts

@@ -8,18 +8,18 @@ import {
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
 import {
-  PublicKernelAppLogicArtifact,
-  PublicKernelSetupArtifact,
-  PublicKernelTailArtifact,
-  PublicKernelTeardownArtifact,
-  convertPublicInnerRollupInputsToWitnessMap,
-  convertPublicInnerRollupOutputFromWitnessMap,
-  convertPublicSetupRollupInputsToWitnessMap,
-  convertPublicSetupRollupOutputFromWitnessMap,
-  convertPublicTailInputsToWitnessMap,
-  convertPublicTailOutputFromWitnessMap,
-  convertPublicTeardownRollupInputsToWitnessMap,
-  convertPublicTeardownRollupOutputFromWitnessMap,
+  SimulatedPublicKernelAppLogicArtifact,
+  SimulatedPublicKernelSetupArtifact,
+  SimulatedPublicKernelTailArtifact,
+  SimulatedPublicKernelTeardownArtifact,
+  convertSimulatedPublicInnerInputsToWitnessMap,
+  convertSimulatedPublicInnerOutputFromWitnessMap,
+  convertSimulatedPublicSetupInputsToWitnessMap,
+  convertSimulatedPublicSetupOutputFromWitnessMap,
+  convertSimulatedPublicTailInputsToWitnessMap,
+  convertSimulatedPublicTailOutputFromWitnessMap,
+  convertSimulatedPublicTeardownInputsToWitnessMap,
+  convertSimulatedPublicTeardownOutputFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
 import { type SimulationProvider, WASMSimulator } from '@aztec/simulator';
 
@@ -47,11 +47,11 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     if (!input.previousKernel.publicInputs.needsSetup) {
       throw new Error(`Expected previous kernel inputs to need setup`);
     }
-    const inputWitness = convertPublicSetupRollupInputsToWitnessMap(input);
+    const inputWitness = convertSimulatedPublicSetupInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelSetupArtifact),
+      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedPublicKernelSetupArtifact),
     );
-    const result = convertPublicSetupRollupOutputFromWitnessMap(witness);
+    const result = convertSimulatedPublicSetupOutputFromWitnessMap(witness);
     this.log.debug(`Simulated public kernel setup circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-setup',
@@ -73,11 +73,11 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     if (!input.previousKernel.publicInputs.needsAppLogic) {
       throw new Error(`Expected previous kernel inputs to need app logic`);
     }
-    const inputWitness = convertPublicInnerRollupInputsToWitnessMap(input);
+    const inputWitness = convertSimulatedPublicInnerInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelAppLogicArtifact),
+      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedPublicKernelAppLogicArtifact),
     );
-    const result = convertPublicInnerRollupOutputFromWitnessMap(witness);
+    const result = convertSimulatedPublicInnerOutputFromWitnessMap(witness);
     this.log.debug(`Simulated public kernel app logic circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-app-logic',
@@ -99,11 +99,11 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     if (!input.previousKernel.publicInputs.needsTeardown) {
       throw new Error(`Expected previous kernel inputs to need teardown`);
     }
-    const inputWitness = convertPublicTeardownRollupInputsToWitnessMap(input);
+    const inputWitness = convertSimulatedPublicTeardownInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTeardownArtifact),
+      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedPublicKernelTeardownArtifact),
     );
-    const result = convertPublicTeardownRollupOutputFromWitnessMap(witness);
+    const result = convertSimulatedPublicTeardownOutputFromWitnessMap(witness);
     this.log.debug(`Simulated public kernel teardown circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-teardown',
@@ -122,11 +122,11 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
   public async publicKernelCircuitTail(
     input: PublicKernelTailCircuitPrivateInputs,
   ): Promise<KernelCircuitPublicInputs> {
-    const inputWitness = convertPublicTailInputsToWitnessMap(input);
+    const inputWitness = convertSimulatedPublicTailInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTailArtifact),
+      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedPublicKernelTailArtifact),
     );
-    const result = convertPublicTailOutputFromWitnessMap(witness);
+    const result = convertSimulatedPublicTailOutputFromWitnessMap(witness);
     this.log.debug(`Simulated public kernel tail circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-tail',

package/src/public/public_processor.ts

@@ -1,22 +1,34 @@
 import {
   type BlockProver,
   type FailedTx,
-  type ProcessReturnValues,
+  NestedProcessReturnValues,
   type ProcessedTx,
-  type PublicKernelRequest,
+  type PublicProvingRequest,
   type SimulationError,
   Tx,
   type TxValidator,
-  makeEmptyProcessedTx,
   makeProcessedTx,
-  toTxEffect,
   validateProcessedTx,
 } from '@aztec/circuit-types';
-import { type TxSequencerProcessingStats } from '@aztec/circuit-types/stats';
-import { type GlobalVariables, type Header, type KernelCircuitPublicInputs } from '@aztec/circuits.js';
+import {
+  AztecAddress,
+  GAS_TOKEN_ADDRESS,
+  type GlobalVariables,
+  type Header,
+  type KernelCircuitPublicInputs,
+  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  PublicDataUpdateRequest,
+} from '@aztec/circuits.js';
+import { times } from '@aztec/foundation/collection';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
-import { PublicExecutor, type PublicStateDB, type SimulationProvider } from '@aztec/simulator';
+import {
+  PublicExecutor,
+  type PublicStateDB,
+  type SimulationProvider,
+  computeFeePayerBalanceLeafSlot,
+  computeFeePayerBalanceStorageSlot,
+} from '@aztec/simulator';
 import { type ContractDataSource } from '@aztec/types/contracts';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
@@ -26,7 +38,7 @@ import {
   publicKernelPhaseToKernelType,
 } from './abstract_phase_manager.js';
 import { PhaseManagerFactory } from './phase_manager_factory.js';
-import { ContractsDataSourcePublicDB, WorldStateDB, WorldStatePublicDB } from './public_executor.js';
+import { ContractsDataSourcePublicDB, WorldStateDB, WorldStatePublicDB } from './public_db_sources.js';
 import { RealPublicKernelCircuitSimulator } from './public_kernel.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 
@@ -96,12 +108,12 @@ export class PublicProcessor {
     maxTransactions = txs.length,
     blockProver?: BlockProver,
     txValidator?: TxValidator<ProcessedTx>,
-  ): Promise<[ProcessedTx[], FailedTx[], ProcessReturnValues[]]> {
+  ): Promise<[ProcessedTx[], FailedTx[], NestedProcessReturnValues[]]> {
     // The processor modifies the tx objects in place, so we need to clone them.
     txs = txs.map(tx => Tx.clone(tx));
     const result: ProcessedTx[] = [];
     const failed: FailedTx[] = [];
-    const returns: ProcessReturnValues[] = [];
+    let returns: NestedProcessReturnValues[] = [];
 
     for (const tx of txs) {
       // only process up to the limit of the block
@@ -112,7 +124,14 @@ export class PublicProcessor {
         const [processedTx, returnValues] = !tx.hasPublicCalls()
           ? [makeProcessedTx(tx, tx.data.toKernelCircuitPublicInputs(), tx.proof, [])]
           : await this.processTxWithPublicCalls(tx);
+
+        // Set fee payment update request into the processed tx
+        processedTx.finalPublicDataUpdateRequests = await this.createFinalDataUpdateRequests(processedTx);
+
+        // Commit the state updates from this transaction
+        await this.publicStateDB.commit();
         validateProcessedTx(processedTx);
+
         // Re-validate the transaction
         if (txValidator) {
           // Only accept processed transactions that are not double-spends,
@@ -129,16 +148,16 @@ export class PublicProcessor {
           await blockProver.addNewTx(processedTx);
         }
         result.push(processedTx);
-        returns.push(returnValues);
+        returns = returns.concat(returnValues ?? []);
       } catch (err: any) {
         const errorMessage = err instanceof Error ? err.message : 'Unknown error';
-        this.log.warn(`Failed to process tx ${tx.getTxHash()}: ${errorMessage}`);
+        this.log.warn(`Failed to process tx ${tx.getTxHash()}: ${errorMessage} ${err?.stack}`);
 
         failed.push({
           tx,
           error: err instanceof Error ? err : new Error(errorMessage),
         });
-        returns.push([]);
+        returns.push(new NestedProcessReturnValues([]));
       }
     }
 
@@ -146,17 +165,55 @@ export class PublicProcessor {
   }
 
   /**
-   * Makes an empty processed tx. Useful for padding a block to a power of two number of txs.
-   * @returns A processed tx with empty data.
+   * Creates the final set of data update requests for the transaction. This includes the
+   * set of public data update requests as returned by the public kernel, plus a data update
+   * request for updating fee balance. It also updates the local public state db.
+   * See build_or_patch_payment_update_request in base_rollup_inputs.nr for more details.
    */
-  public makeEmptyProcessedTx(): ProcessedTx {
-    const { chainId, version } = this.globalVariables;
-    return makeEmptyProcessedTx(this.historicalHeader.clone(), chainId, version);
+  private async createFinalDataUpdateRequests(tx: ProcessedTx) {
+    const finalPublicDataUpdateRequests = [
+      ...tx.data.end.publicDataUpdateRequests,
+      ...times(PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, () => PublicDataUpdateRequest.empty()),
+    ];
+
+    const feePayer = tx.data.feePayer;
+    if (feePayer.isZero()) {
+      return finalPublicDataUpdateRequests;
+    }
+
+    const gasToken = AztecAddress.fromBigInt(GAS_TOKEN_ADDRESS);
+    const balanceSlot = computeFeePayerBalanceStorageSlot(feePayer);
+    const leafSlot = computeFeePayerBalanceLeafSlot(feePayer);
+    const txFee = tx.data.getTransactionFee(this.globalVariables.gasFees);
+
+    this.log.debug(`Deducting ${txFee} balance in gas tokens for ${feePayer}`);
+
+    const existingBalanceWriteIndex = finalPublicDataUpdateRequests.findIndex(request =>
+      request.leafSlot.equals(leafSlot),
+    );
+
+    const balance =
+      existingBalanceWriteIndex > -1
+        ? finalPublicDataUpdateRequests[existingBalanceWriteIndex].newValue
+        : await this.publicStateDB.storageRead(gasToken, balanceSlot);
+
+    if (balance.lt(txFee)) {
+      throw new Error(`Not enough balance for fee payer to pay for transaction (got ${balance} needs ${txFee})`);
+    }
+
+    const updatedBalance = balance.sub(txFee);
+    await this.publicStateDB.storageWrite(gasToken, balanceSlot, updatedBalance);
+
+    finalPublicDataUpdateRequests[
+      existingBalanceWriteIndex > -1 ? existingBalanceWriteIndex : MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+    ] = new PublicDataUpdateRequest(leafSlot, updatedBalance, 0);
+
+    return finalPublicDataUpdateRequests;
   }
 
-  private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, ProcessReturnValues | undefined]> {
-    let returnValues: ProcessReturnValues = undefined;
-    const publicRequests: PublicKernelRequest[] = [];
+  private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
+    let returnValues: NestedProcessReturnValues[] = [];
+    const publicProvingRequests: PublicProvingRequest[] = [];
     let phase: AbstractPhaseManager | undefined = PhaseManagerFactory.phaseFromTx(
       tx,
       this.db,
@@ -168,22 +225,19 @@ export class PublicProcessor {
       this.publicStateDB,
     );
     this.log.debug(`Beginning processing in phase ${phase?.phase} for tx ${tx.getTxHash()}`);
-    let proof = tx.proof;
     let publicKernelPublicInput = tx.data.toPublicKernelCircuitPublicInputs();
     let finalKernelOutput: KernelCircuitPublicInputs | undefined;
     let revertReason: SimulationError | undefined;
-    const timer = new Timer();
     const gasUsed: ProcessedTx['gasUsed'] = {};
     while (phase) {
-      const output = await phase.handle(tx, publicKernelPublicInput, proof);
+      const output = await phase.handle(tx, publicKernelPublicInput);
       gasUsed[publicKernelPhaseToKernelType(phase.phase)] = output.gasUsed;
       if (phase.phase === PublicKernelPhase.APP_LOGIC) {
         returnValues = output.returnValues;
       }
-      publicRequests.push(...output.kernelRequests);
+      publicProvingRequests.push(...output.publicProvingRequests);
       publicKernelPublicInput = output.publicKernelOutput;
       finalKernelOutput = output.finalKernelOutput;
-      proof = output.publicKernelProof;
       revertReason ??= output.revertReason;
       phase = PhaseManagerFactory.phaseFromOutput(
         publicKernelPublicInput,
@@ -202,17 +256,7 @@ export class PublicProcessor {
       throw new Error('Final public kernel was not executed.');
     }
 
-    const processedTx = makeProcessedTx(tx, finalKernelOutput, proof, publicRequests, revertReason, gasUsed);
-
-    this.log.debug(`Processed public part of ${tx.getTxHash()}`, {
-      eventName: 'tx-sequencer-processing',
-      duration: timer.ms(),
-      effectsSize: toTxEffect(processedTx).toBuffer().length,
-      publicDataUpdateRequests:
-        processedTx.data.end.publicDataUpdateRequests.filter(x => !x.leafSlot.isZero()).length ?? 0,
-      ...tx.getStats(),
-    } satisfies TxSequencerProcessingStats);
-
+    const processedTx = makeProcessedTx(tx, finalKernelOutput, tx.proof, publicProvingRequests, revertReason, gasUsed);
     return [processedTx, returnValues];
   }
 }

package/src/public/setup_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,46 +24,26 @@ export class SetupPhaseManager 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()}`);
-    const [
-      kernelInputs,
-      publicKernelOutput,
-      publicKernelProof,
-      newUnencryptedFunctionLogs,
-      revertReason,
-      _returnValues,
-      gasUsed,
-    ] = await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
-      // the abstract phase manager throws if simulation gives error in a non-revertible phase
-      async err => {
-        await this.publicStateDB.rollbackToCommit();
-        throw err;
-      },
-    );
-    tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
+    // 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 { publicProvingInformation, kernelOutput, newUnencryptedLogs, revertReason, gasUsed } =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput).catch(
+        // the abstract phase manager throws if simulation gives error in a non-revertible phase
+        async err => {
+          await this.publicStateDB.rollbackToCommit();
+          throw err;
+        },
+      );
+    tx.unencryptedLogs.addFunctionLogs(newUnencryptedLogs);
     await this.publicStateDB.checkpoint();
 
     // Return a list of setup proving requests
-    const kernelRequests = kernelInputs.map(input => {
-      const request: PublicKernelRequest = {
-        type: PublicKernelType.SETUP,
-        inputs: input,
-      };
-      return request;
+    const publicProvingRequests: PublicProvingRequest[] = publicProvingInformation.map(info => {
+      return makeAvmProvingRequest(info, PublicKernelType.SETUP);
     });
-    return {
-      kernelRequests,
-      kernelInputs,
-      publicKernelOutput,
-      publicKernelProof,
-      revertReason,
-      returnValues: undefined,
-      gasUsed,
-    };
+    return { publicProvingRequests, publicKernelOutput: kernelOutput, revertReason, returnValues: [], gasUsed };
   }
 }

package/src/public/tail_phase_manager.ts

@@ -1,28 +1,20 @@
 import { type PublicKernelRequest, PublicKernelType, type Tx } from '@aztec/circuit-types';
 import {
-  Fr,
+  CombineHints,
   type GlobalVariables,
   type Header,
   type KernelCircuitPublicInputs,
-  MAX_NEW_NOTE_HASHES_PER_TX,
   MAX_NEW_NULLIFIERS_PER_TX,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  type MAX_UNENCRYPTED_LOGS_PER_TX,
-  type NoteHash,
-  type Proof,
   type PublicKernelCircuitPublicInputs,
   PublicKernelTailCircuitPrivateInputs,
-  SideEffect,
-  makeEmptyProof,
   mergeAccumulatedData,
-  sortByCounter,
 } from '@aztec/circuits.js';
-import { type Tuple } from '@aztec/foundation/serialize';
 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 { type ContractsDataSourcePublicDB } from './public_db_sources.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 
 export class TailPhaseManager extends AbstractPhaseManager {
@@ -39,80 +31,46 @@ export class TailPhaseManager 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()}`);
-    const [inputs, finalKernelOutput] = await this.runTailKernelCircuit(
-      previousPublicKernelOutput,
-      previousPublicKernelProof,
-    ).catch(
+    const [inputs, finalKernelOutput] = await this.simulate(previousPublicKernelOutput).catch(
       // the abstract phase manager throws if simulation gives error in non-revertible phase
       async err => {
         await this.publicStateDB.rollbackToCommit();
         throw err;
       },
     );
-    // commit the state updates from this transaction
-    await this.publicStateDB.commit();
 
     // Return a tail proving request
-    const request: PublicKernelRequest = {
+    const kernelRequest: PublicKernelRequest = {
       type: PublicKernelType.TAIL,
       inputs: inputs,
     };
 
     return {
-      kernelRequests: [request],
+      publicProvingRequests: [kernelRequest],
       publicKernelOutput: previousPublicKernelOutput,
       finalKernelOutput,
-      publicKernelProof: makeEmptyProof(),
-      revertReason: undefined,
-      returnValues: undefined,
-      gasUsed: undefined,
+      returnValues: [],
     };
   }
 
-  private async runTailKernelCircuit(
-    previousOutput: PublicKernelCircuitPublicInputs,
-    previousProof: Proof,
-  ): Promise<[PublicKernelTailCircuitPrivateInputs, KernelCircuitPublicInputs]> {
-    // Temporary hack. Should sort them in the tail circuit.
-    previousOutput.end.unencryptedLogsHashes = this.sortLogsHashes<typeof MAX_UNENCRYPTED_LOGS_PER_TX>(
-      previousOutput.end.unencryptedLogsHashes,
-    );
-    const [inputs, output] = await this.simulate(previousOutput, previousProof);
-
-    // Temporary hack. Should sort them in the tail circuit.
-    const noteHashes = mergeAccumulatedData(
-      previousOutput.endNonRevertibleData.newNoteHashes,
-      previousOutput.end.newNoteHashes,
-      MAX_NEW_NOTE_HASHES_PER_TX,
-    );
-    output.end.newNoteHashes = this.sortNoteHashes<typeof MAX_NEW_NOTE_HASHES_PER_TX>(noteHashes);
-
-    return [inputs, output];
-  }
-
   private async simulate(
     previousOutput: PublicKernelCircuitPublicInputs,
-    previousProof: Proof,
   ): Promise<[PublicKernelTailCircuitPrivateInputs, KernelCircuitPublicInputs]> {
-    const inputs = await this.buildPrivateInputs(previousOutput, previousProof);
+    const inputs = await this.buildPrivateInputs(previousOutput);
     // We take a deep copy (clone) of these to pass to the prover
     return [inputs.clone(), await this.publicKernel.publicKernelCircuitTail(inputs)];
   }
 
-  private async buildPrivateInputs(previousOutput: PublicKernelCircuitPublicInputs, previousProof: Proof) {
-    const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
+  private async buildPrivateInputs(previousOutput: PublicKernelCircuitPublicInputs) {
+    const previousKernel = this.getPreviousKernelData(previousOutput);
 
-    const { validationRequests, endNonRevertibleData, end } = previousOutput;
+    const { validationRequests, endNonRevertibleData: nonRevertibleData, end: revertibleData } = previousOutput;
 
     const pendingNullifiers = mergeAccumulatedData(
-      endNonRevertibleData.newNullifiers,
-      end.newNullifiers,
+      nonRevertibleData.newNullifiers,
+      revertibleData.newNullifiers,
       MAX_NEW_NULLIFIERS_PER_TX,
     );
 
@@ -127,8 +85,8 @@ export class TailPhaseManager extends AbstractPhaseManager {
     );
 
     const pendingPublicDataWrites = mergeAccumulatedData(
-      endNonRevertibleData.publicDataUpdateRequests,
-      end.publicDataUpdateRequests,
+      nonRevertibleData.publicDataUpdateRequests,
+      revertibleData.publicDataUpdateRequests,
       MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
     );
 
@@ -145,6 +103,8 @@ export class TailPhaseManager extends AbstractPhaseManager {
 
     const currentState = await this.db.getStateReference();
 
+    const hints = CombineHints.fromPublicData({ nonRevertibleData, revertibleData });
+
     return new PublicKernelTailCircuitPrivateInputs(
       previousKernel,
       nullifierReadRequestHints,
@@ -152,17 +112,7 @@ export class TailPhaseManager extends AbstractPhaseManager {
       publicDataHints,
       publicDataReadRequestHints,
       currentState.partial,
+      hints,
     );
   }
-
-  private sortNoteHashes<N extends number>(noteHashes: Tuple<NoteHash, N>): Tuple<Fr, N> {
-    return sortByCounter(noteHashes).map(n => n.value) as Tuple<Fr, N>;
-  }
-
-  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>;
-  }
 }

package/src/public/teardown_phase_manager.ts

@@ -1,10 +1,9 @@
-import { type PublicKernelRequest, PublicKernelType, type Tx } from '@aztec/circuit-types';
+import { PublicKernelType, type PublicProvingRequest, type Tx } from '@aztec/circuit-types';
 import {
   type Fr,
   type Gas,
   type GlobalVariables,
   type Header,
-  type Proof,
   type PublicKernelCircuitPublicInputs,
 } from '@aztec/circuits.js';
 import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
@@ -12,8 +11,8 @@ import { type MerkleTreeOperations } from '@aztec/world-state';
 
 import { inspect } from 'util';
 
-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';
 
 /**
@@ -33,47 +32,29 @@ export class TeardownPhaseManager 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()}`);
-    const [
-      kernelInputs,
-      publicKernelOutput,
-      publicKernelProof,
-      newUnencryptedFunctionLogs,
-      revertReason,
-      _returnValues,
-      gasUsed,
-    ] = await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
-      // the abstract phase manager throws if simulation gives error in a non-revertible phase
-      async err => {
-        await this.publicStateDB.rollbackToCommit();
-        throw err;
-      },
-    );
-    tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
-    await this.publicStateDB.checkpoint();
+    const { publicProvingInformation, kernelOutput, newUnencryptedLogs, revertReason, gasUsed } =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput).catch(
+        // the abstract phase manager throws if simulation gives error in a non-revertible phase
+        async err => {
+          await this.publicStateDB.rollbackToCommit();
+          throw err;
+        },
+      );
+    if (revertReason) {
+      await this.publicStateDB.rollbackToCheckpoint();
+    } else {
+      // TODO(#6464): Should we allow emitting contracts in the public teardown phase?
+      // if so, we should insert them here
+      tx.unencryptedLogs.addFunctionLogs(newUnencryptedLogs);
+    }
 
     // Return a list of teardown proving requests
-    const kernelRequests = kernelInputs.map(input => {
-      const request: PublicKernelRequest = {
-        type: PublicKernelType.TEARDOWN,
-        inputs: input,
-      };
-      return request;
+    const publicProvingRequests: PublicProvingRequest[] = publicProvingInformation.map(info => {
+      return makeAvmProvingRequest(info, PublicKernelType.TEARDOWN);
     });
-    return {
-      kernelRequests,
-      kernelInputs,
-      publicKernelOutput,
-      publicKernelProof,
-      revertReason,
-      returnValues: undefined,
-      gasUsed,
-    };
+    return { publicProvingRequests, publicKernelOutput: kernelOutput, revertReason, returnValues: [], gasUsed };
   }
 
   protected override getTransactionFee(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs): Fr {