@aztec/simulator 0.45.0 → 0.46.1

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/execution.ts

@@ -48,11 +48,11 @@ export interface PublicExecutionResult {
   /** The contract storage update requests performed by the function. */
   contractStorageUpdateRequests: ContractStorageUpdateRequest[];
   /** The new note hashes to be inserted into the note hashes tree. */
-  newNoteHashes: NoteHash[];
+  noteHashes: NoteHash[];
   /** The new l2 to l1 messages generated in this call. */
-  newL2ToL1Messages: L2ToL1Message[];
+  l2ToL1Messages: L2ToL1Message[];
   /** The new nullifiers to be inserted into the nullifier tree. */
-  newNullifiers: Nullifier[];
+  nullifiers: Nullifier[];
   /** The note hash read requests emitted in this call. */
   noteHashReadRequests: ReadRequest[];
   /** The nullifier read requests emitted in this call. */
@@ -115,17 +115,17 @@ export function isPublicExecutionResult(
  */
 
 export function checkValidStaticCall(
-  newNoteHashes: NoteHash[],
-  newNullifiers: Nullifier[],
+  noteHashes: NoteHash[],
+  nullifiers: Nullifier[],
   contractStorageUpdateRequests: ContractStorageUpdateRequest[],
-  newL2ToL1Messages: L2ToL1Message[],
+  l2ToL1Messages: L2ToL1Message[],
   unencryptedLogs: UnencryptedFunctionL2Logs,
 ) {
   if (
     contractStorageUpdateRequests.length > 0 ||
-    newNoteHashes.length > 0 ||
-    newNullifiers.length > 0 ||
-    newL2ToL1Messages.length > 0 ||
+    noteHashes.length > 0 ||
+    nullifiers.length > 0 ||
+    l2ToL1Messages.length > 0 ||
     unencryptedLogs.logs.length > 0
   ) {
     throw new Error('Static call cannot update the state, emit L2->L1 messages or generate logs');

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/hints_builder.ts

@@ -1,7 +1,7 @@
 import { MerkleTreeId } from '@aztec/circuit-types';
 import {
   type Fr,
-  type MAX_NEW_NULLIFIERS_PER_TX,
+  type MAX_NULLIFIERS_PER_TX,
   type MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
   MAX_NULLIFIER_READ_REQUESTS_PER_TX,
   type MAX_PUBLIC_DATA_HINTS,
@@ -30,7 +30,7 @@ export class HintsBuilder {
 
   async getNullifierReadRequestHints(
     nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
-    pendingNullifiers: Tuple<Nullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+    pendingNullifiers: Tuple<Nullifier, typeof MAX_NULLIFIERS_PER_TX>,
   ) {
     return (
       await buildSiloedNullifierReadRequestHints(
@@ -45,7 +45,7 @@ export class HintsBuilder {
 
   getNullifierNonExistentReadRequestHints(
     nullifierNonExistentReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX>,
-    pendingNullifiers: Tuple<Nullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+    pendingNullifiers: Tuple<Nullifier, typeof MAX_NULLIFIERS_PER_TX>,
   ) {
     return buildNullifierNonExistentReadRequestHints(this, nullifierNonExistentReadRequests, pendingNullifiers);
   }

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

@@ -16,7 +16,6 @@ import {
   Nullifier,
   ReadRequest,
 } from '@aztec/circuits.js';
-import { EventSelector } from '@aztec/foundation/abi';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
@@ -39,11 +38,11 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
   private contractStorageUpdateRequests: ContractStorageUpdateRequest[] = [];
 
   private noteHashReadRequests: ReadRequest[] = [];
-  private newNoteHashes: NoteHash[] = [];
+  private noteHashes: NoteHash[] = [];
 
   private nullifierReadRequests: ReadRequest[] = [];
   private nullifierNonExistentReadRequests: ReadRequest[] = [];
-  private newNullifiers: Nullifier[] = [];
+  private nullifiers: Nullifier[] = [];
 
   private l1ToL2MsgReadRequests: ReadRequest[] = [];
   private newL2ToL1Messages: L2ToL1Message[] = [];
@@ -122,7 +121,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     // IS there, and the AVM circuit should accept THAT noteHash as a hint. The circuit will then compare
     // the noteHash against the one provided by the user code to determine what to return to the user (exists or not),
     // and will then propagate the actually-present noteHash to its public inputs.
-    this.newNoteHashes.push(new NoteHash(noteHash, this.sideEffectCounter));
+    this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter));
     this.logger.debug(`NEW_NOTE_HASH cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
@@ -147,7 +146,7 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
   public traceNewNullifier(_storageAddress: Fr, nullifier: Fr) {
     // TODO(4805): check if some threshold is reached for max new nullifier
     // NOTE: storageAddress is unused but will be important when an AVM circuit processes an entire enqueued call
-    this.newNullifiers.push(new Nullifier(nullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
+    this.nullifiers.push(new Nullifier(nullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
     this.logger.debug(`NEW_NULLIFIER cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
@@ -177,14 +176,15 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
     // TODO(4805): check if some threshold is reached for max logs
     const ulog = new UnencryptedL2Log(
       AztecAddress.fromField(contractAddress),
-      // TODO(#7198): Remove event selector from UnencryptedL2Log
-      EventSelector.fromField(new Fr(0)),
       Buffer.concat(log.map(f => f.toBuffer())),
     );
     const basicLogHash = Fr.fromBuffer(ulog.hash());
     this.unencryptedLogs.push(ulog);
     this.allUnencryptedLogs.push(ulog);
-    // TODO(6578): explain magic number 4 here
+    // We want the length of the buffer output from function_l2_logs -> toBuffer to equal the stored log length in the kernels.
+    // The kernels store the length of the processed log as 4 bytes; thus for this length value to match the log length stored in the kernels,
+    // we need to add four to the length here.
+    // https://github.com/AztecProtocol/aztec-packages/issues/6578#issuecomment-2125003435
     this.unencryptedLogsHashes.push(new LogHash(basicLogHash, this.sideEffectCounter, new Fr(ulog.length + 4)));
     this.logger.debug(`NEW_UNENCRYPTED_LOG cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
@@ -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),
@@ -294,12 +292,12 @@ export class PublicSideEffectTrace implements PublicSideEffectTraceInterface {
       contractStorageReads: this.contractStorageReads,
       contractStorageUpdateRequests: this.contractStorageUpdateRequests,
       noteHashReadRequests: this.noteHashReadRequests,
-      newNoteHashes: this.newNoteHashes,
+      noteHashes: this.noteHashes,
       nullifierReadRequests: this.nullifierReadRequests,
       nullifierNonExistentReadRequests: this.nullifierNonExistentReadRequests,
-      newNullifiers: this.newNullifiers,
+      nullifiers: this.nullifiers,
       l1ToL2MsgReadRequests: this.l1ToL2MsgReadRequests,
-      newL2ToL1Messages: this.newL2ToL1Messages,
+      l2ToL1Messages: this.newL2ToL1Messages,
       // correct the type on these now that they are finalized (lists won't grow)
       unencryptedLogs: new UnencryptedFunctionL2Logs(this.unencryptedLogs),
       allUnencryptedLogs: new UnencryptedFunctionL2Logs(this.allUnencryptedLogs),
@@ -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

@@ -4,12 +4,13 @@ import {
   type GlobalVariables,
   type Header,
   type KernelCircuitPublicInputs,
-  MAX_NEW_NULLIFIERS_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   type PublicKernelCircuitPublicInputs,
   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,21 +63,25 @@ 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;
 
     const pendingNullifiers = mergeAccumulatedData(
-      nonRevertibleData.newNullifiers,
-      revertibleData.newNullifiers,
-      MAX_NEW_NULLIFIERS_PER_TX,
+      nonRevertibleData.nullifiers,
+      revertibleData.nullifiers,
+      MAX_NULLIFIERS_PER_TX,
     );
 
     const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(

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);