@aztec/simulator 0.45.1 → 0.46.2

package/src/public/abstract_phase_manager.ts

@@ -35,7 +35,6 @@ import {
   MAX_PUBLIC_DATA_READS_PER_CALL,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
   MAX_UNENCRYPTED_LOGS_PER_CALL,
-  MembershipWitness,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NoteHash,
   Nullifier,
@@ -48,14 +47,19 @@ import {
   PublicKernelData,
   ReadRequest,
   RevertCode,
-  VK_TREE_HEIGHT,
-  VerificationKeyData,
   makeEmptyProof,
   makeEmptyRecursiveProof,
 } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
+import {
+  type ProtocolArtifact,
+  ProtocolCircuitVkIndexes,
+  ProtocolCircuitVks,
+  getVKIndex,
+  getVKSiblingPath,
+} from '@aztec/noir-protocol-circuits-types';
 import {
   type PublicExecutionRequest,
   type PublicExecutionResult,
@@ -106,6 +110,8 @@ export type TxPublicCallsResult = {
   publicProvingInformation: PublicProvingInformation[];
   /** The public kernel output at the end of the Tx */
   kernelOutput: PublicKernelCircuitPublicInputs;
+  /** The last circuit ran by this phase */
+  lastKernelArtifact: ProtocolArtifact;
   /** Unencrypted logs generated during the execution of this Tx */
   newUnencryptedLogs: UnencryptedFunctionL2Logs[];
   /** Revert reason, if any */
@@ -121,6 +127,8 @@ export type PhaseResult = {
   publicProvingRequests: PublicProvingRequest[];
   /** The output of the public kernel circuit simulation for this phase */
   publicKernelOutput: PublicKernelCircuitPublicInputs;
+  /** The last circuit ran by this phase */
+  lastKernelArtifact: ProtocolArtifact;
   /** The final output of the public kernel circuit for this phase */
   finalKernelOutput?: KernelCircuitPublicInputs;
   /** Revert reason, if any */
@@ -150,7 +158,11 @@ export abstract class AbstractPhaseManager {
    * @param tx - the tx to be processed
    * @param publicKernelPublicInputs - the output of the public kernel circuit for the previous phase
    */
-  abstract handle(tx: Tx, publicKernelPublicInputs: PublicKernelCircuitPublicInputs): Promise<PhaseResult>;
+  abstract handle(
+    tx: Tx,
+    publicKernelPublicInputs: PublicKernelCircuitPublicInputs,
+    previousKernelArtifact: ProtocolArtifact,
+  ): Promise<PhaseResult>;
 
   public static extractEnqueuedPublicCallsByPhase(tx: Tx): Record<PublicKernelType, PublicCallRequest[]> {
     const data = tx.data.forPublic;
@@ -230,6 +242,7 @@ export abstract class AbstractPhaseManager {
   protected async processEnqueuedPublicCalls(
     tx: Tx,
     previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
+    previousKernelArtifact: ProtocolArtifact,
   ): Promise<TxPublicCallsResult> {
     const enqueuedCalls = this.extractEnqueuedPublicCalls(tx);
 
@@ -237,6 +250,7 @@ export abstract class AbstractPhaseManager {
       return {
         publicProvingInformation: [],
         kernelOutput: previousPublicKernelOutput,
+        lastKernelArtifact: previousKernelArtifact,
         newUnencryptedLogs: [],
         returnValues: [],
         gasUsed: Gas.empty(),
@@ -253,6 +267,7 @@ export abstract class AbstractPhaseManager {
     const transactionFee = this.getTransactionFee(tx, previousPublicKernelOutput);
     let gasUsed = Gas.empty();
     let kernelPublicOutput: PublicKernelCircuitPublicInputs = previousPublicKernelOutput;
+
     const enqueuedCallResults = [];
 
     for (const enqueuedCall of enqueuedCalls) {
@@ -313,8 +328,13 @@ export abstract class AbstractPhaseManager {
           })`,
         );
         const callData = await this.getPublicCallData(result, isExecutionRequest);
-        const [privateInputs, publicInputs] = await this.runKernelCircuit(kernelPublicOutput, callData);
+        const [privateInputs, publicInputs, artifact] = await this.runKernelCircuit(
+          kernelPublicOutput,
+          previousKernelArtifact,
+          callData,
+        );
         kernelPublicOutput = publicInputs;
+        previousKernelArtifact = artifact;
 
         // Capture the inputs for later proving in the AVM and kernel.
         const publicProvingInformation: PublicProvingInformation = {
@@ -349,6 +369,7 @@ export abstract class AbstractPhaseManager {
           return {
             publicProvingInformation: [],
             kernelOutput: kernelPublicOutput,
+            lastKernelArtifact: previousKernelArtifact,
             newUnencryptedLogs: [],
             revertReason: result.revertReason,
             returnValues: [],
@@ -367,6 +388,7 @@ export abstract class AbstractPhaseManager {
     return {
       publicProvingInformation: provingInformationList,
       kernelOutput: kernelPublicOutput,
+      lastKernelArtifact: previousKernelArtifact,
       newUnencryptedLogs: newUnencryptedFunctionLogs,
       returnValues: enqueuedCallResults,
       gasUsed,
@@ -391,31 +413,46 @@ export abstract class AbstractPhaseManager {
 
   private async runKernelCircuit(
     previousOutput: PublicKernelCircuitPublicInputs,
+    previousCircuit: ProtocolArtifact,
     callData: PublicCallData,
-  ): Promise<[PublicKernelCircuitPrivateInputs, PublicKernelCircuitPublicInputs]> {
-    const previousKernel = this.getPreviousKernelData(previousOutput);
+  ): Promise<[PublicKernelCircuitPrivateInputs, PublicKernelCircuitPublicInputs, ProtocolArtifact]> {
+    const previousKernel = this.getPreviousKernelData(previousOutput, previousCircuit);
 
     // We take a deep copy (clone) of these inputs to be passed to the prover
     const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, callData);
     switch (this.phase) {
       case PublicKernelType.SETUP:
-        return [inputs.clone(), await this.publicKernel.publicKernelCircuitSetup(inputs)];
+        return [inputs.clone(), await this.publicKernel.publicKernelCircuitSetup(inputs), 'PublicKernelSetupArtifact'];
       case PublicKernelType.APP_LOGIC:
-        return [inputs.clone(), await this.publicKernel.publicKernelCircuitAppLogic(inputs)];
+        return [
+          inputs.clone(),
+          await this.publicKernel.publicKernelCircuitAppLogic(inputs),
+          'PublicKernelAppLogicArtifact',
+        ];
       case PublicKernelType.TEARDOWN:
-        return [inputs.clone(), await this.publicKernel.publicKernelCircuitTeardown(inputs)];
+        return [
+          inputs.clone(),
+          await this.publicKernel.publicKernelCircuitTeardown(inputs),
+          'PublicKernelTeardownArtifact',
+        ];
       default:
         throw new Error(`No public kernel circuit for inputs`);
     }
   }
 
-  protected getPreviousKernelData(previousOutput: PublicKernelCircuitPublicInputs): PublicKernelData {
-    // The proof and verification key are not used in simulation
-    const vk = VerificationKeyData.makeFake();
+  protected getPreviousKernelData(
+    previousOutput: PublicKernelCircuitPublicInputs,
+    previousCircuit: ProtocolArtifact,
+  ): PublicKernelData {
+    // The proof is not used in simulation
     const proof = makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH);
-    const vkIndex = 0;
-    const vkSiblingPath = MembershipWitness.random(VK_TREE_HEIGHT).siblingPath;
-    return new PublicKernelData(previousOutput, proof, vk, vkIndex, vkSiblingPath);
+
+    const vk = ProtocolCircuitVks[previousCircuit];
+    const vkIndex = ProtocolCircuitVkIndexes[previousCircuit];
+
+    const leafIndex = getVKIndex(vk);
+
+    return new PublicKernelData(previousOutput, proof, vk, vkIndex, getVKSiblingPath(leafIndex));
   }
 
   protected async getPublicCallStackItem(result: PublicExecutionResult, isExecutionRequest = false) {
@@ -424,7 +461,7 @@ export abstract class AbstractPhaseManager {
 
     const callStackPreimages = await this.getPublicCallStackPreimages(result);
     const publicCallStackHashes = padArrayEnd(
-      callStackPreimages.map(c => c.hash()),
+      callStackPreimages.map(c => c.getCompressed().hash()),
       Fr.ZERO,
       MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
     );

package/src/public/app_logic_phase_manager.ts

@@ -1,5 +1,6 @@
 import { PublicKernelType, type PublicProvingRequest, type Tx } from '@aztec/circuit-types';
 import { type GlobalVariables, type Header, type PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
+import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
 import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
@@ -24,7 +25,11 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
     super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
   }
 
-  override async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs) {
+  override async handle(
+    tx: Tx,
+    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
+    previousCircuit: ProtocolArtifact,
+  ) {
     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
@@ -33,14 +38,21 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
     // 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, 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;
-        },
-      );
+    const {
+      publicProvingInformation,
+      kernelOutput,
+      lastKernelArtifact,
+      newUnencryptedLogs,
+      revertReason,
+      returnValues,
+      gasUsed,
+    } = await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousCircuit).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?
@@ -57,6 +69,13 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
     const publicProvingRequests: PublicProvingRequest[] = publicProvingInformation.map(info => {
       return makeAvmProvingRequest(info, PublicKernelType.APP_LOGIC);
     });
-    return { publicProvingRequests, publicKernelOutput: kernelOutput, revertReason, returnValues, gasUsed };
+    return {
+      publicProvingRequests,
+      publicKernelOutput: kernelOutput,
+      lastKernelArtifact,
+      revertReason,
+      returnValues,
+      gasUsed,
+    };
   }
 }

package/src/public/executor.ts

@@ -99,9 +99,6 @@ export class PublicExecutor {
       bytecode,
       avmResult,
       fnName,
-      /*requestSideEffectCounter=*/ executionRequest.callContext.sideEffectCounter,
-      // NOTE: startSideEffectCounter is not the same as the executionRequest's sideEffectCounter
-      // (which counts the request itself)
     );
 
     return publicExecutionResult;

package/src/public/public_kernel.ts

@@ -8,10 +8,7 @@ import {
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
 import {
-  SimulatedPublicKernelAppLogicArtifact,
-  SimulatedPublicKernelSetupArtifact,
-  SimulatedPublicKernelTailArtifact,
-  SimulatedPublicKernelTeardownArtifact,
+  SimulatedServerCircuitArtifacts,
   convertSimulatedPublicInnerInputsToWitnessMap,
   convertSimulatedPublicInnerOutputFromWitnessMap,
   convertSimulatedPublicSetupInputsToWitnessMap,
@@ -50,7 +47,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     }
     const inputWitness = convertSimulatedPublicSetupInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedPublicKernelSetupArtifact),
+      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedServerCircuitArtifacts.PublicKernelSetupArtifact),
     );
     const result = convertSimulatedPublicSetupOutputFromWitnessMap(witness);
     this.log.debug(`Simulated public kernel setup circuit`, {
@@ -76,7 +73,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     }
     const inputWitness = convertSimulatedPublicInnerInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedPublicKernelAppLogicArtifact),
+      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedServerCircuitArtifacts.PublicKernelAppLogicArtifact),
     );
     const result = convertSimulatedPublicInnerOutputFromWitnessMap(witness);
     this.log.debug(`Simulated public kernel app logic circuit`, {
@@ -102,7 +99,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     }
     const inputWitness = convertSimulatedPublicTeardownInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedPublicKernelTeardownArtifact),
+      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedServerCircuitArtifacts.PublicKernelTeardownArtifact),
     );
     const result = convertSimulatedPublicTeardownOutputFromWitnessMap(witness);
     this.log.debug(`Simulated public kernel teardown circuit`, {
@@ -125,7 +122,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
   ): Promise<KernelCircuitPublicInputs> {
     const inputWitness = convertSimulatedPublicTailInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedPublicKernelTailArtifact),
+      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedServerCircuitArtifacts.PublicKernelTailArtifact),
     );
     const result = convertSimulatedPublicTailOutputFromWitnessMap(witness);
     this.log.debug(`Simulated public kernel tail circuit`, {

package/src/public/public_processor.ts

@@ -23,6 +23,7 @@ import {
 } from '@aztec/circuits.js';
 import { times } from '@aztec/foundation/collection';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
 import {
   PublicExecutor,
   type PublicStateDB,
@@ -232,17 +233,19 @@ export class PublicProcessor {
     );
     this.log.debug(`Beginning processing in phase ${phase?.phase} for tx ${tx.getTxHash()}`);
     let publicKernelPublicInput = tx.data.toPublicKernelCircuitPublicInputs();
+    let lastKernelArtifact: ProtocolArtifact = 'PrivateKernelTailToPublicArtifact'; // All txs with public calls must carry tail to public proofs
     let finalKernelOutput: KernelCircuitPublicInputs | undefined;
     let revertReason: SimulationError | undefined;
     const gasUsed: ProcessedTx['gasUsed'] = {};
     while (phase) {
-      const output = await phase.handle(tx, publicKernelPublicInput);
+      const output = await phase.handle(tx, publicKernelPublicInput, lastKernelArtifact);
       gasUsed[phase.phase] = output.gasUsed;
       if (phase.phase === PublicKernelType.APP_LOGIC) {
         returnValues = output.returnValues;
       }
       publicProvingRequests.push(...output.publicProvingRequests);
       publicKernelPublicInput = output.publicKernelOutput;
+      lastKernelArtifact = output.lastKernelArtifact;
       finalKernelOutput = output.finalKernelOutput;
       revertReason ??= output.revertReason;
       phase = PhaseManagerFactory.phaseFromOutput(

package/src/public/setup_phase_manager.ts

@@ -1,5 +1,6 @@
 import { PublicKernelType, type PublicProvingRequest, type Tx } from '@aztec/circuit-types';
 import { type GlobalVariables, type Header, type PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
+import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
 import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
@@ -24,13 +25,17 @@ export class SetupPhaseManager extends AbstractPhaseManager {
     super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
   }
 
-  override async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs) {
+  override async handle(
+    tx: Tx,
+    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
+    previousCircuit: ProtocolArtifact,
+  ) {
     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 { publicProvingInformation, kernelOutput, newUnencryptedLogs, revertReason, gasUsed } =
-      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput).catch(
+    const { publicProvingInformation, kernelOutput, lastKernelArtifact, newUnencryptedLogs, revertReason, gasUsed } =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousCircuit).catch(
         // the abstract phase manager throws if simulation gives error in a non-revertible phase
         async err => {
           await this.publicStateDB.rollbackToCommit();
@@ -44,6 +49,13 @@ export class SetupPhaseManager extends AbstractPhaseManager {
     const publicProvingRequests: PublicProvingRequest[] = publicProvingInformation.map(info => {
       return makeAvmProvingRequest(info, PublicKernelType.SETUP);
     });
-    return { publicProvingRequests, publicKernelOutput: kernelOutput, revertReason, returnValues: [], gasUsed };
+    return {
+      publicProvingRequests,
+      publicKernelOutput: kernelOutput,
+      lastKernelArtifact,
+      revertReason,
+      returnValues: [],
+      gasUsed,
+    };
   }
 }

package/src/public/side_effect_trace.ts

@@ -273,11 +273,9 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     avmCallResults: AvmContractCallResult,
     /** Function name for logging */
     functionName: string = 'unknown',
-    /** The side effect counter of the execution request itself */
-    requestSideEffectCounter: number = this.startSideEffectCounter,
   ): PublicExecutionResult {
     return {
-      executionRequest: createPublicExecutionRequest(requestSideEffectCounter, avmEnvironment),
+      executionRequest: createPublicExecutionRequest(avmEnvironment),
 
       startSideEffectCounter: new Fr(this.startSideEffectCounter),
       endSideEffectCounter: new Fr(this.sideEffectCounter),
@@ -319,17 +317,13 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
 /**
  * Helper function to create a public execution request from an AVM execution environment
  */
-function createPublicExecutionRequest(
-  requestSideEffectCounter: number,
-  avmEnvironment: AvmExecutionEnvironment,
-): PublicExecutionRequest {
+function createPublicExecutionRequest(avmEnvironment: AvmExecutionEnvironment): PublicExecutionRequest {
   const callContext = CallContext.from({
     msgSender: avmEnvironment.sender,
     storageContractAddress: avmEnvironment.storageAddress,
     functionSelector: avmEnvironment.functionSelector,
     isDelegateCall: avmEnvironment.isDelegateCall,
     isStaticCall: avmEnvironment.isStaticCall,
-    sideEffectCounter: requestSideEffectCounter,
   });
   return {
     contractAddress: avmEnvironment.address,

package/src/public/tail_phase_manager.ts

@@ -10,6 +10,7 @@ import {
   PublicKernelTailCircuitPrivateInputs,
   mergeAccumulatedData,
 } from '@aztec/circuits.js';
+import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
 import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
@@ -31,9 +32,13 @@ export class TailPhaseManager extends AbstractPhaseManager {
     super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
   }
 
-  override async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs) {
+  override async handle(
+    tx: Tx,
+    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
+    previousKernelArtifact: ProtocolArtifact,
+  ) {
     this.log.verbose(`Processing tx ${tx.getTxHash()}`);
-    const [inputs, finalKernelOutput] = await this.simulate(previousPublicKernelOutput).catch(
+    const [inputs, finalKernelOutput] = await this.simulate(previousPublicKernelOutput, previousKernelArtifact).catch(
       // the abstract phase manager throws if simulation gives error in non-revertible phase
       async err => {
         await this.publicStateDB.rollbackToCommit();
@@ -50,6 +55,7 @@ export class TailPhaseManager extends AbstractPhaseManager {
     return {
       publicProvingRequests: [kernelRequest],
       publicKernelOutput: previousPublicKernelOutput,
+      lastKernelArtifact: 'PublicKernelTailArtifact' as ProtocolArtifact,
       finalKernelOutput,
       returnValues: [],
     };
@@ -57,14 +63,18 @@ export class TailPhaseManager extends AbstractPhaseManager {
 
   private async simulate(
     previousOutput: PublicKernelCircuitPublicInputs,
+    previousKernelArtifact: ProtocolArtifact,
   ): Promise<[PublicKernelTailCircuitPrivateInputs, KernelCircuitPublicInputs]> {
-    const inputs = await this.buildPrivateInputs(previousOutput);
+    const inputs = await this.buildPrivateInputs(previousOutput, previousKernelArtifact);
     // 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) {
-    const previousKernel = this.getPreviousKernelData(previousOutput);
+  private async buildPrivateInputs(
+    previousOutput: PublicKernelCircuitPublicInputs,
+    previousKernelArtifact: ProtocolArtifact,
+  ) {
+    const previousKernel = this.getPreviousKernelData(previousOutput, previousKernelArtifact);
 
     const { validationRequests, endNonRevertibleData: nonRevertibleData, end: revertibleData } = previousOutput;
 

package/src/public/teardown_phase_manager.ts

@@ -6,6 +6,7 @@ import {
   type Header,
   type PublicKernelCircuitPublicInputs,
 } from '@aztec/circuits.js';
+import { type ProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
 import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 
@@ -32,10 +33,14 @@ export class TeardownPhaseManager extends AbstractPhaseManager {
     super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
   }
 
-  override async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs) {
+  override async handle(
+    tx: Tx,
+    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
+    previousKernelArtifact: ProtocolArtifact,
+  ) {
     this.log.verbose(`Processing tx ${tx.getTxHash()}`);
-    const { publicProvingInformation, kernelOutput, newUnencryptedLogs, revertReason, gasUsed } =
-      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput).catch(
+    const { publicProvingInformation, kernelOutput, lastKernelArtifact, newUnencryptedLogs, revertReason, gasUsed } =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousKernelArtifact).catch(
         // the abstract phase manager throws if simulation gives error in a non-revertible phase
         async err => {
           await this.publicStateDB.rollbackToCommit();
@@ -55,7 +60,14 @@ export class TeardownPhaseManager extends AbstractPhaseManager {
     const publicProvingRequests: PublicProvingRequest[] = publicProvingInformation.map(info => {
       return makeAvmProvingRequest(info, PublicKernelType.TEARDOWN);
     });
-    return { publicProvingRequests, publicKernelOutput: kernelOutput, revertReason, returnValues: [], gasUsed };
+    return {
+      publicProvingRequests,
+      publicKernelOutput: kernelOutput,
+      lastKernelArtifact,
+      revertReason,
+      returnValues: [],
+      gasUsed,
+    };
   }
 
   protected override getTransactionFee(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs): Fr {

package/src/rollup/rollup.ts

@@ -12,11 +12,7 @@ import {
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
 import {
-  BaseParityArtifact,
-  MergeRollupArtifact,
-  RootParityArtifact,
-  RootRollupArtifact,
-  SimulatedBaseRollupArtifact,
+  SimulatedServerCircuitArtifacts,
   convertBaseParityInputsToWitnessMap,
   convertBaseParityOutputsFromWitnessMap,
   convertMergeRollupInputsToWitnessMap,
@@ -87,7 +83,10 @@ export class RealRollupCircuitSimulator implements RollupSimulator {
   public async baseParityCircuit(inputs: BaseParityInputs): Promise<ParityPublicInputs> {
     const witnessMap = convertBaseParityInputsToWitnessMap(inputs);
 
-    const witness = await this.simulationProvider.simulateCircuit(witnessMap, BaseParityArtifact);
+    const witness = await this.simulationProvider.simulateCircuit(
+      witnessMap,
+      SimulatedServerCircuitArtifacts.BaseParityArtifact,
+    );
 
     const result = convertBaseParityOutputsFromWitnessMap(witness);
 
@@ -102,7 +101,10 @@ export class RealRollupCircuitSimulator implements RollupSimulator {
   public async rootParityCircuit(inputs: RootParityInputs): Promise<ParityPublicInputs> {
     const witnessMap = convertRootParityInputsToWitnessMap(inputs);
 
-    const witness = await this.simulationProvider.simulateCircuit(witnessMap, RootParityArtifact);
+    const witness = await this.simulationProvider.simulateCircuit(
+      witnessMap,
+      SimulatedServerCircuitArtifacts.RootParityArtifact,
+    );
 
     const result = convertRootParityOutputsFromWitnessMap(witness);
 
@@ -117,7 +119,10 @@ export class RealRollupCircuitSimulator implements RollupSimulator {
   public async baseRollupCircuit(input: BaseRollupInputs): Promise<BaseOrMergeRollupPublicInputs> {
     const witnessMap = convertSimulatedBaseRollupInputsToWitnessMap(input);
 
-    const witness = await this.simulationProvider.simulateCircuit(witnessMap, SimulatedBaseRollupArtifact);
+    const witness = await this.simulationProvider.simulateCircuit(
+      witnessMap,
+      SimulatedServerCircuitArtifacts.BaseRollupArtifact,
+    );
 
     const result = convertSimulatedBaseRollupOutputsFromWitnessMap(witness);
 
@@ -131,7 +136,10 @@ export class RealRollupCircuitSimulator implements RollupSimulator {
   public async mergeRollupCircuit(input: MergeRollupInputs): Promise<BaseOrMergeRollupPublicInputs> {
     const witnessMap = convertMergeRollupInputsToWitnessMap(input);
 
-    const witness = await this.wasmSimulator.simulateCircuit(witnessMap, MergeRollupArtifact);
+    const witness = await this.wasmSimulator.simulateCircuit(
+      witnessMap,
+      SimulatedServerCircuitArtifacts.MergeRollupArtifact,
+    );
 
     const result = convertMergeRollupOutputsFromWitnessMap(witness);
 
@@ -146,7 +154,9 @@ export class RealRollupCircuitSimulator implements RollupSimulator {
   public async rootRollupCircuit(input: RootRollupInputs): Promise<RootRollupPublicInputs> {
     const witnessMap = convertRootRollupInputsToWitnessMap(input);
 
-    const [duration, witness] = await elapsed(() => this.wasmSimulator.simulateCircuit(witnessMap, RootRollupArtifact));
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(witnessMap, SimulatedServerCircuitArtifacts.RootRollupArtifact),
+    );
 
     const result = convertRootRollupOutputsFromWitnessMap(witness);