@aztec/simulator 0.41.0 → 0.43.0

package/src/public/{public_executor.ts → public_db_sources.ts}

@@ -1,10 +1,11 @@
 import { MerkleTreeId, NullifierMembershipWitness, type Tx } from '@aztec/circuit-types';
+import { type PublicDBAccessStats } from '@aztec/circuit-types/stats';
 import {
   type AztecAddress,
   ContractClassRegisteredEvent,
   ContractInstanceDeployedEvent,
   Fr,
-  type FunctionSelector,
+  FunctionSelector,
   type L1_TO_L2_MSG_TREE_HEIGHT,
   type NULLIFIER_TREE_HEIGHT,
   type NullifierLeafPreimage,
@@ -12,7 +13,8 @@ import {
 } from '@aztec/circuits.js';
 import { computeL1ToL2MessageNullifier, computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { getCanonicalClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
+import { Timer } from '@aztec/foundation/timer';
+import { ClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
 import {
   type CommitmentsDB,
   MessageLoadOracleInputs,
@@ -45,7 +47,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
   public addNewContracts(tx: Tx): Promise<void> {
     // Extract contract class and instance data from logs and add to cache for this block
     const logs = tx.unencryptedLogs.unrollLogs();
-    ContractClassRegisteredEvent.fromLogs(logs, getCanonicalClassRegistererAddress()).forEach(e => {
+    ContractClassRegisteredEvent.fromLogs(logs, ClassRegistererAddress).forEach(e => {
       this.log.debug(`Adding class ${e.contractClassId.toString()} to public execution contract cache`);
       this.classCache.set(e.contractClassId.toString(), e.toContractClassPublic());
     });
@@ -68,7 +70,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     // Let's say we have two txs adding the same contract on the same block. If the 2nd one reverts,
     // wouldn't that accidentally remove the contract added on the first one?
     const logs = tx.unencryptedLogs.unrollLogs();
-    ContractClassRegisteredEvent.fromLogs(logs, getCanonicalClassRegistererAddress()).forEach(e =>
+    ContractClassRegisteredEvent.fromLogs(logs, ClassRegistererAddress).forEach(e =>
       this.classCache.delete(e.contractClassId.toString()),
     );
     ContractInstanceDeployedEvent.fromLogs(logs).forEach(e => this.instanceCache.delete(e.address.toString()));
@@ -94,6 +96,22 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
     }
     return contractClass.publicFunctions.find(f => f.selector.equals(selector))?.bytecode;
   }
+
+  public async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
+    const artifact = await this.db.getContractArtifact(address);
+    if (!artifact) {
+      return Promise.resolve(undefined);
+    }
+
+    const f = artifact.functions.find(f =>
+      FunctionSelector.fromNameAndParameters(f.name, f.parameters).equals(selector),
+    );
+    if (!f) {
+      return Promise.resolve(undefined);
+    }
+
+    return Promise.resolve(`${artifact.name}:${f.name}`);
+  }
 }
 
 /**
@@ -145,11 +163,12 @@ export class WorldStatePublicDB implements PublicStateDB {
    * @param contract - Owner of the storage.
    * @param slot - Slot to read in the contract storage.
    * @param newValue - The new value to store.
+   * @returns The slot of the written leaf in the public data tree.
    */
-  public storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void> {
+  public storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<bigint> {
     const index = computePublicDataTreeLeafSlot(contract, slot).value;
     this.uncommittedWriteCache.set(index, newValue);
-    return Promise.resolve();
+    return Promise.resolve(index);
   }
 
   /**
@@ -195,11 +214,14 @@ export class WorldStatePublicDB implements PublicStateDB {
  * Implements WorldState db using a world state database.
  */
 export class WorldStateDB implements CommitmentsDB {
+  private log = createDebugLogger('aztec:sequencer:world-state-db');
+
   constructor(private db: MerkleTreeOperations) {}
 
   public async getNullifierMembershipWitnessAtLatestBlock(
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
+    const timer = new Timer();
     const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
     if (!index) {
       return undefined;
@@ -217,6 +239,12 @@ export class WorldStateDB implements CommitmentsDB {
       return undefined;
     }
 
+    this.log.debug(`[DB] Fetched nullifier membership`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'get-nullifier-membership-witness-at-latest-block',
+    } satisfies PublicDBAccessStats);
+
     return new NullifierMembershipWitness(BigInt(index), leafPreimage as NullifierLeafPreimage, siblingPath);
   }
 
@@ -231,6 +259,7 @@ export class WorldStateDB implements CommitmentsDB {
 
     // We iterate over messages until we find one whose nullifier is not in the nullifier tree --> we need to check
     // for nullifiers because messages can have duplicates.
+    const timer = new Timer();
     do {
       messageIndex = (await this.db.findLeafIndexAfter(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, messageHash, startIndex))!;
       if (messageIndex === undefined) {
@@ -248,18 +277,45 @@ export class WorldStateDB implements CommitmentsDB {
       messageIndex,
     );
 
+    this.log.debug(`[DB] Fetched L1 to L2 message membership`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'get-l1-to-l2-message-membership-witness',
+    } satisfies PublicDBAccessStats);
+
     return new MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>(messageIndex, siblingPath);
   }
 
   public async getL1ToL2LeafValue(leafIndex: bigint): Promise<Fr | undefined> {
-    return await this.db.getLeafValue(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+    const timer = new Timer();
+    const leafValue = await this.db.getLeafValue(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+    this.log.debug(`[DB] Fetched L1 to L2 message leaf value`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'get-l1-to-l2-message-leaf-value',
+    } satisfies PublicDBAccessStats);
+    return leafValue;
   }
 
   public async getCommitmentIndex(commitment: Fr): Promise<bigint | undefined> {
-    return await this.db.findLeafIndex(MerkleTreeId.NOTE_HASH_TREE, commitment);
+    const timer = new Timer();
+    const index = await this.db.findLeafIndex(MerkleTreeId.NOTE_HASH_TREE, commitment);
+    this.log.debug(`[DB] Fetched commitment index`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'get-commitment-index',
+    } satisfies PublicDBAccessStats);
+    return index;
   }
 
   public async getNullifierIndex(nullifier: Fr): Promise<bigint | undefined> {
-    return await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+    const timer = new Timer();
+    const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+    this.log.debug(`[DB] Fetched nullifier index`, {
+      eventName: 'public-db-access',
+      duration: timer.ms(),
+      operation: 'get-nullifier-index',
+    } satisfies PublicDBAccessStats);
+    return index;
   }
 }

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

@@ -3,30 +3,39 @@ import {
   type FailedTx,
   NestedProcessReturnValues,
   type ProcessedTx,
-  type PublicKernelRequest,
+  PublicKernelType,
+  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';
 
-import {
-  type AbstractPhaseManager,
-  PublicKernelPhase,
-  publicKernelPhaseToKernelType,
-} from './abstract_phase_manager.js';
+import { type AbstractPhaseManager } 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';
 
@@ -101,7 +110,7 @@ export class PublicProcessor {
     txs = txs.map(tx => Tx.clone(tx));
     const result: ProcessedTx[] = [];
     const failed: FailedTx[] = [];
-    const returns: NestedProcessReturnValues[] = [];
+    let returns: NestedProcessReturnValues[] = [];
 
     for (const tx of txs) {
       // only process up to the limit of the block
@@ -112,7 +121,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,10 +145,10 @@ export class PublicProcessor {
           await blockProver.addNewTx(processedTx);
         }
         result.push(processedTx);
-        returns.push(returnValues?.[0] ?? new NestedProcessReturnValues([]));
+        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,
@@ -146,17 +162,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, NestedProcessReturnValues[]]> {
     let returnValues: NestedProcessReturnValues[] = [];
-    const publicRequests: PublicKernelRequest[] = [];
+    const publicProvingRequests: PublicProvingRequest[] = [];
     let phase: AbstractPhaseManager | undefined = PhaseManagerFactory.phaseFromTx(
       tx,
       this.db,
@@ -168,22 +222,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);
-      gasUsed[publicKernelPhaseToKernelType(phase.phase)] = output.gasUsed;
-      if (phase.phase === PublicKernelPhase.APP_LOGIC) {
+      const output = await phase.handle(tx, publicKernelPublicInput);
+      gasUsed[phase.phase] = output.gasUsed;
+      if (phase.phase === PublicKernelType.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 +253,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, makeAvmProvingRequest } from './abstract_phase_manager.js';
+import { type ContractsDataSourcePublicDB } from './public_db_sources.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 
 /**
@@ -24,51 +19,31 @@ export class SetupPhaseManager extends AbstractPhaseManager {
     historicalHeader: Header,
     protected publicContractsDB: ContractsDataSourcePublicDB,
     protected publicStateDB: PublicStateDB,
-    phase: PublicKernelPhase = PublicKernelPhase.SETUP,
+    phase: PublicKernelType = PublicKernelType.SETUP,
   ) {
     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: [],
-      gasUsed,
-    };
+    return { publicProvingRequests, publicKernelOutput: kernelOutput, revertReason, returnValues: [], gasUsed };
   }
 }