@aztec/sequencer-client 0.24.0 → 0.26.1

package/src/sequencer/phase_manager_factory.ts

@@ -0,0 +1,122 @@
+import { Tx } from '@aztec/circuit-types';
+import { GlobalVariables, Header, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
+import { PublicExecutor, PublicStateDB } from '@aztec/simulator';
+import { MerkleTreeOperations } from '@aztec/world-state';
+
+import { PublicProver } from '../prover/index.js';
+import { PublicKernelCircuitSimulator } from '../simulator/index.js';
+import { ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
+import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
+import { AppLogicPhaseManager } from './app_logic_phase_manager.js';
+import { SetupPhaseManager } from './setup_phase_manager.js';
+import { TeardownPhaseManager } from './teardown_phase_manager.js';
+
+export class PhaseDidNotChangeError extends Error {
+  constructor(phase: PublicKernelPhase) {
+    super(`Tried to advance the phase from [${phase}] when the circuit still needs [${phase}]`);
+  }
+}
+
+export class CannotTransitionToSetupError extends Error {
+  constructor() {
+    super('Cannot transition to setup phase');
+  }
+}
+
+export class PhaseManagerFactory {
+  public static phaseFromTx(
+    tx: Tx,
+    db: MerkleTreeOperations,
+    publicExecutor: PublicExecutor,
+    publicKernel: PublicKernelCircuitSimulator,
+    publicProver: PublicProver,
+    globalVariables: GlobalVariables,
+    historicalHeader: Header,
+    publicContractsDB: ContractsDataSourcePublicDB,
+    publicStateDB: PublicStateDB,
+  ): AbstractPhaseManager | undefined {
+    if (tx.data.needsSetup) {
+      return new SetupPhaseManager(
+        db,
+        publicExecutor,
+        publicKernel,
+        publicProver,
+        globalVariables,
+        historicalHeader,
+        publicContractsDB,
+        publicStateDB,
+      );
+    } else if (tx.data.needsAppLogic) {
+      return new AppLogicPhaseManager(
+        db,
+        publicExecutor,
+        publicKernel,
+        publicProver,
+        globalVariables,
+        historicalHeader,
+        publicContractsDB,
+        publicStateDB,
+      );
+    } else if (tx.data.needsTeardown) {
+      return new TeardownPhaseManager(
+        db,
+        publicExecutor,
+        publicKernel,
+        publicProver,
+        globalVariables,
+        historicalHeader,
+        publicContractsDB,
+        publicStateDB,
+      );
+    } else {
+      return undefined;
+    }
+  }
+
+  public static phaseFromOutput(
+    output: PublicKernelCircuitPublicInputs,
+    currentPhaseManager: AbstractPhaseManager,
+    db: MerkleTreeOperations,
+    publicExecutor: PublicExecutor,
+    publicKernel: PublicKernelCircuitSimulator,
+    publicProver: PublicProver,
+    globalVariables: GlobalVariables,
+    historicalHeader: Header,
+    publicContractsDB: ContractsDataSourcePublicDB,
+    publicStateDB: PublicStateDB,
+  ): AbstractPhaseManager | undefined {
+    if (output.needsSetup) {
+      throw new CannotTransitionToSetupError();
+    } else if (output.needsAppLogic) {
+      if (currentPhaseManager.phase === PublicKernelPhase.APP_LOGIC) {
+        throw new PhaseDidNotChangeError(currentPhaseManager.phase);
+      }
+      return new AppLogicPhaseManager(
+        db,
+        publicExecutor,
+        publicKernel,
+        publicProver,
+        globalVariables,
+        historicalHeader,
+        publicContractsDB,
+        publicStateDB,
+      );
+    } else if (output.needsTeardown) {
+      if (currentPhaseManager.phase === PublicKernelPhase.TEARDOWN) {
+        throw new PhaseDidNotChangeError(currentPhaseManager.phase);
+      }
+      return new TeardownPhaseManager(
+        db,
+        publicExecutor,
+        publicKernel,
+        publicProver,
+        globalVariables,
+        historicalHeader,
+        publicContractsDB,
+        publicStateDB,
+      );
+    } else {
+      return undefined;
+    }
+  }
+}

package/src/sequencer/processed_tx.ts

@@ -1,9 +1,10 @@
 import { ExtendedContractData, Tx, TxHash, TxL2Logs } from '@aztec/circuit-types';
 import {
-  CombinedAccumulatedData,
   Fr,
   Header,
   Proof,
+  PublicAccumulatedNonRevertibleData,
+  PublicAccumulatedRevertibleData,
   PublicKernelCircuitPublicInputs,
   makeEmptyProof,
 } from '@aztec/circuits.js';
@@ -47,21 +48,19 @@ export type FailedTx = {
  * @param kernelOutput - Output of the kernel circuit simulation for this tx.
  * @param proof - Proof of the kernel circuit for this tx.
  */
-export async function makeProcessedTx(
-  tx: Tx,
-  kernelOutput?: PublicKernelCircuitPublicInputs,
-  proof?: Proof,
-): Promise<ProcessedTx> {
+export function makeProcessedTx(tx: Tx, kernelOutput?: PublicKernelCircuitPublicInputs, proof?: Proof): ProcessedTx {
   return {
-    hash: await tx.getTxHash(),
+    hash: tx.getTxHash(),
     data:
       kernelOutput ??
       new PublicKernelCircuitPublicInputs(
         tx.data.aggregationObject,
-        tx.data.endNonRevertibleData,
-        CombinedAccumulatedData.fromFinalAccumulatedData(tx.data.end),
+        PublicAccumulatedNonRevertibleData.fromPrivateAccumulatedNonRevertibleData(tx.data.endNonRevertibleData),
+        PublicAccumulatedRevertibleData.fromPrivateAccumulatedRevertibleData(tx.data.end),
         tx.data.constants,
-        tx.data.isPrivate,
+        tx.data.needsSetup,
+        tx.data.needsAppLogic,
+        tx.data.needsTeardown,
       ),
     proof: proof ?? tx.proof,
     encryptedLogs: tx.encryptedLogs,
@@ -75,7 +74,7 @@ export async function makeProcessedTx(
  * Makes an empty tx from an empty kernel circuit public inputs.
  * @returns A processed empty tx.
  */
-export function makeEmptyProcessedTx(header: Header, chainId: Fr, version: Fr): Promise<ProcessedTx> {
+export function makeEmptyProcessedTx(header: Header, chainId: Fr, version: Fr): ProcessedTx {
   const emptyKernelOutput = PublicKernelCircuitPublicInputs.empty();
   emptyKernelOutput.constants.historicalHeader = header;
   emptyKernelOutput.constants.txContext.chainId = chainId;
@@ -83,7 +82,7 @@ export function makeEmptyProcessedTx(header: Header, chainId: Fr, version: Fr):
   const emptyProof = makeEmptyProof();
 
   const hash = new TxHash(Fr.ZERO.toBuffer());
-  return Promise.resolve({
+  return {
     hash,
     encryptedLogs: new TxL2Logs([]),
     unencryptedLogs: new TxL2Logs([]),
@@ -91,5 +90,5 @@ export function makeEmptyProcessedTx(header: Header, chainId: Fr, version: Fr):
     proof: emptyProof,
     newContracts: [ExtendedContractData.empty()],
     isEmpty: true,
-  });
+  };
 }

package/src/sequencer/public_processor.ts

@@ -1,6 +1,6 @@
 import { ContractDataSource, L1ToL2MessageSource, Tx } from '@aztec/circuit-types';
 import { TxSequencerProcessingStats } from '@aztec/circuit-types/stats';
-import { GlobalVariables, Header, Proof, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
+import { GlobalVariables, Header } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { PublicExecutor, PublicStateDB } from '@aztec/simulator';
@@ -12,7 +12,7 @@ import { PublicKernelCircuitSimulator } from '../simulator/index.js';
 import { ContractsDataSourcePublicDB, WorldStateDB, WorldStatePublicDB } from '../simulator/public_executor.js';
 import { RealPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
 import { AbstractPhaseManager } from './abstract_phase_manager.js';
-import { FeePreparationPhaseManager } from './fee_preparation_phase_manager.js';
+import { PhaseManagerFactory } from './phase_manager_factory.js';
 import { FailedTx, ProcessedTx, makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
 
 /**
@@ -85,7 +85,8 @@ export class PublicProcessor {
     const failed: FailedTx[] = [];
 
     for (const tx of txs) {
-      let phase: AbstractPhaseManager | undefined = new FeePreparationPhaseManager(
+      let phase: AbstractPhaseManager | undefined = PhaseManagerFactory.phaseFromTx(
+        tx,
         this.db,
         this.publicExecutor,
         this.publicKernel,
@@ -95,25 +96,41 @@ export class PublicProcessor {
         this.publicContractsDB,
         this.publicStateDB,
       );
-      let publicKernelOutput: PublicKernelCircuitPublicInputs | undefined = undefined;
-      let publicKernelProof: Proof | undefined = undefined;
+      this.log(`Beginning processing in phase ${phase?.phase} for tx ${tx.getTxHash()}`);
+      let { publicKernelPublicInput, publicKernelProof } = AbstractPhaseManager.getKernelOutputAndProof(
+        tx,
+        undefined,
+        undefined,
+      );
       const timer = new Timer();
       try {
         while (phase) {
-          const output = await phase.handle(tx, publicKernelOutput, publicKernelProof);
-          publicKernelOutput = output.publicKernelOutput;
+          const output = await phase.handle(tx, publicKernelPublicInput, publicKernelProof);
+          publicKernelPublicInput = output.publicKernelOutput;
           publicKernelProof = output.publicKernelProof;
-          phase = phase.nextPhase();
+          phase = PhaseManagerFactory.phaseFromOutput(
+            publicKernelPublicInput,
+            phase,
+            this.db,
+            this.publicExecutor,
+            this.publicKernel,
+            this.publicProver,
+            this.globalVariables,
+            this.historicalHeader,
+            this.publicContractsDB,
+            this.publicStateDB,
+          );
         }
 
-        const processedTransaction = await makeProcessedTx(tx, publicKernelOutput, publicKernelProof);
+        const processedTransaction = makeProcessedTx(tx, publicKernelPublicInput, publicKernelProof);
         result.push(processedTransaction);
 
-        this.log(`Processed public part of ${tx.data.end.newNullifiers[0]}`, {
+        this.log(`Processed public part of ${tx.data.endNonRevertibleData.newNullifiers[0].value}`, {
           eventName: 'tx-sequencer-processing',
           duration: timer.ms(),
           publicDataUpdateRequests:
-            processedTransaction.data.end.publicDataUpdateRequests.filter(x => !x.leafSlot.isZero()).length ?? 0,
+            processedTransaction.data.combinedData.publicDataUpdateRequests.filter(x => !x.leafSlot.isZero()).length ??
+            0,
           ...tx.getStats(),
         } satisfies TxSequencerProcessingStats);
       } catch (err) {
@@ -129,7 +146,7 @@ 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.
    */
-  public makeEmptyProcessedTx(): Promise<ProcessedTx> {
+  public makeEmptyProcessedTx(): ProcessedTx {
     const { chainId, version } = this.globalVariables;
     return makeEmptyProcessedTx(this.historicalHeader, chainId, version);
   }

package/src/sequencer/sequencer.ts

@@ -186,8 +186,8 @@ export class Sequencer {
       const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() => processor.process(validTxs));
       if (failedTxs.length > 0) {
         const failedTxData = failedTxs.map(fail => fail.tx);
-        this.log(`Dropping failed txs ${(await Tx.getHashes(failedTxData)).join(', ')}`);
-        await this.p2pClient.deleteTxs(await Tx.getHashes(failedTxData));
+        this.log(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
+        await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
       }
 
       // Only accept processed transactions that are not double-spends,
@@ -205,7 +205,7 @@ export class Sequencer {
 
       // Get l1 to l2 messages from the contract
       this.log('Requesting L1 to L2 messages from contract');
-      const l1ToL2Messages = await this.getPendingL1ToL2Messages();
+      const l1ToL2Messages = await this.getPendingL1ToL2EntryKeys();
       this.log('Successfully retrieved L1 to L2 messages from contract');
 
       // Build the new block by running the rollup circuits
@@ -213,7 +213,7 @@ export class Sequencer {
 
       await assertBlockHeight();
 
-      const emptyTx = await processor.makeEmptyProcessedTx();
+      const emptyTx = processor.makeEmptyProcessedTx();
       const [rollupCircuitsDuration, block] = await elapsed(() =>
         this.buildBlock(processedValidTxs, l1ToL2Messages, emptyTx, newGlobalVariables),
       );
@@ -255,7 +255,7 @@ export class Sequencer {
       return;
     }
 
-    const blockCalldataHash = block.getCalldataHash();
+    const blockCalldataHash = block.body.getCalldataHash();
     this.log.info(`Publishing ${newContracts.length} contracts in block ${block.number}`);
 
     const publishedContractData = await this.publisher.processNewContractData(
@@ -296,7 +296,7 @@ export class Sequencer {
     for (const tx of txs) {
       if (tx.data.constants.txContext.chainId.value !== globalVariables.chainId.value) {
         this.log(
-          `Deleting tx for incorrect chain ${tx.data.constants.txContext.chainId.toString()}, tx hash ${await Tx.getHash(
+          `Deleting tx for incorrect chain ${tx.data.constants.txContext.chainId.toString()}, tx hash ${Tx.getHash(
             tx,
           )}`,
         );
@@ -304,17 +304,18 @@ export class Sequencer {
         continue;
       }
       if (await this.isTxDoubleSpend(tx)) {
-        this.log(`Deleting double spend tx ${await Tx.getHash(tx)}`);
+        this.log(`Deleting double spend tx ${Tx.getHash(tx)}`);
         txsToDelete.push(tx);
         continue;
       } else if (this.isTxDoubleSpendSameBlock(tx, thisBlockNullifiers)) {
         // We don't drop these txs from the p2p pool immediately since they become valid
         // again if the current block fails to be published for some reason.
-        this.log(`Skipping tx with double-spend for this same block ${await Tx.getHash(tx)}`);
+        this.log(`Skipping tx with double-spend for this same block ${Tx.getHash(tx)}`);
         continue;
       }
 
       tx.data.end.newNullifiers.forEach(n => thisBlockNullifiers.add(n.value.toBigInt()));
+      tx.data.endNonRevertibleData.newNullifiers.forEach(n => thisBlockNullifiers.add(n.value.toBigInt()));
       validTxs.push(tx);
       if (validTxs.length >= this.maxTxsPerBlock) {
         break;
@@ -323,7 +324,7 @@ export class Sequencer {
 
     // Make sure we remove these from the tx pool so we do not consider it again
     if (txsToDelete.length > 0) {
-      await this.p2pClient.deleteTxs(await Tx.getHashes([...txsToDelete]));
+      await this.p2pClient.deleteTxs(Tx.getHashes([...txsToDelete]));
     }
 
     return validTxs;
@@ -370,12 +371,12 @@ export class Sequencer {
   }
 
   /**
-   * Calls the archiver to pull upto `NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP` message keys
+   * Calls the archiver to pull upto `NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP` entry keys
    * (archiver returns the top messages sorted by fees)
-   * @returns An array of L1 to L2 messages' messageKeys
+   * @returns An array of L1 to L2 messages' entryKeys
    */
-  protected async getPendingL1ToL2Messages(): Promise<Fr[]> {
-    return await this.l1ToL2MessageSource.getPendingL1ToL2Messages();
+  protected async getPendingL1ToL2EntryKeys(): Promise<Fr[]> {
+    return await this.l1ToL2MessageSource.getPendingL1ToL2EntryKeys();
   }
 
   /**
@@ -385,7 +386,10 @@ export class Sequencer {
    */
   protected isTxDoubleSpendSameBlock(tx: Tx | ProcessedTx, thisBlockNullifiers: Set<bigint>): boolean {
     // We only consider non-empty nullifiers
-    const newNullifiers = tx.data.end.newNullifiers.filter(n => !n.isEmpty());
+    const newNullifiers = [
+      ...tx.data.endNonRevertibleData.newNullifiers.filter(n => !n.isEmpty()),
+      ...tx.data.end.newNullifiers.filter(n => !n.isEmpty()),
+    ];
 
     for (const nullifier of newNullifiers) {
       if (thisBlockNullifiers.has(nullifier.value.toBigInt())) {
@@ -403,7 +407,10 @@ export class Sequencer {
    */
   protected async isTxDoubleSpend(tx: Tx | ProcessedTx): Promise<boolean> {
     // We only consider non-empty nullifiers
-    const newNullifiers = tx.data.end.newNullifiers.filter(n => !n.isEmpty());
+    const newNullifiers = [
+      ...tx.data.endNonRevertibleData.newNullifiers.filter(n => !n.isEmpty()),
+      ...tx.data.end.newNullifiers.filter(n => !n.isEmpty()),
+    ];
 
     // Ditch this tx if it has a repeated nullifiers
     const uniqNullifiers = new Set(newNullifiers.map(n => n.value.toBigInt()));

package/src/sequencer/{fee_distribution_phase_manager.ts → setup_phase_manager.ts}

@@ -1,19 +1,18 @@
 import { Tx } from '@aztec/circuit-types';
-import { GlobalVariables, Header, Proof, PublicCallRequest, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { GlobalVariables, Header, Proof, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
 import { PublicExecutor, PublicStateDB } from '@aztec/simulator';
 import { MerkleTreeOperations } from '@aztec/world-state';
 
 import { PublicProver } from '../prover/index.js';
 import { PublicKernelCircuitSimulator } from '../simulator/index.js';
 import { ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
-import { AbstractPhaseManager } from './abstract_phase_manager.js';
+import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
 import { FailedTx } from './processed_tx.js';
 
 /**
  * The phase manager responsible for performing the fee preparation phase.
  */
-export class FeeDistributionPhaseManager extends AbstractPhaseManager {
+export class SetupPhaseManager extends AbstractPhaseManager {
   constructor(
     protected db: MerkleTreeOperations,
     protected publicExecutor: PublicExecutor,
@@ -23,45 +22,44 @@ export class FeeDistributionPhaseManager extends AbstractPhaseManager {
     protected historicalHeader: Header,
     protected publicContractsDB: ContractsDataSourcePublicDB,
     protected publicStateDB: PublicStateDB,
-
-    protected log = createDebugLogger('aztec:sequencer:fee-distribution'),
+    public phase: PublicKernelPhase = PublicKernelPhase.SETUP,
   ) {
-    super(db, publicExecutor, publicKernel, publicProver, globalVariables, historicalHeader);
-  }
-
-  // this is a no-op for now
-  extractEnqueuedPublicCalls(_tx: Tx): PublicCallRequest[] {
-    return [];
+    super(db, publicExecutor, publicKernel, publicProver, globalVariables, historicalHeader, phase);
   }
 
   // this is a no-op for now
   async handle(
     tx: Tx,
-    previousPublicKernelOutput?: PublicKernelCircuitPublicInputs,
-    previousPublicKernelProof?: Proof,
+    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
+    previousPublicKernelProof: Proof,
   ): Promise<{
     /**
      * the output of the public kernel circuit for this phase
      */
-    publicKernelOutput?: PublicKernelCircuitPublicInputs;
+    publicKernelOutput: PublicKernelCircuitPublicInputs;
     /**
      * the proof of the public kernel circuit for this phase
      */
-    publicKernelProof?: Proof;
+    publicKernelProof: Proof;
   }> {
-    this.log.debug(`Handle ${await tx.getTxHash()} with no-op`);
-    return {
-      publicKernelOutput: previousPublicKernelOutput,
-      publicKernelProof: previousPublicKernelProof,
-    };
-  }
+    this.log(`Processing tx ${tx.getTxHash()}`);
+    this.log(`Executing enqueued public calls for tx ${tx.getTxHash()}`);
+    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs] = await this.processEnqueuedPublicCalls(
+      tx,
+      previousPublicKernelOutput,
+      previousPublicKernelProof,
+    );
+    tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
+
+    // commit the state updates from this transaction
+    await this.publicStateDB.commit();
 
-  nextPhase() {
-    return undefined;
+    return { publicKernelOutput, publicKernelProof };
   }
 
   async rollback(tx: Tx, err: unknown): Promise<FailedTx> {
-    this.log.warn(`Error processing tx ${await tx.getTxHash()}: ${err}`);
+    this.log.warn(`Error processing tx ${tx.getTxHash()}: ${err}`);
+    await this.publicStateDB.rollback();
     return {
       tx,
       error: err instanceof Error ? err : new Error('Unknown error'),

package/src/sequencer/teardown_phase_manager.ts

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

package/src/simulator/index.ts

@@ -37,17 +37,21 @@ export interface RollupSimulator {
  */
 export interface PublicKernelCircuitSimulator {
   /**
-   * Simulates the public kernel circuit (with a previous private kernel circuit run) from its inputs.
+   * Simulates the public kernel setup circuit from its inputs.
    * @param inputs - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
-  publicKernelCircuitPrivateInput(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
+  publicKernelCircuitSetup(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
   /**
-   * Simulates the public kernel circuit (with no previous public kernel circuit run) from its inputs.
+   * Simulates the public kernel app logic circuit from its inputs.
    * @param inputs - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
-  publicKernelCircuitNonFirstIteration(
-    inputs: PublicKernelCircuitPrivateInputs,
-  ): Promise<PublicKernelCircuitPublicInputs>;
+  publicKernelCircuitAppLogic(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
+  /**
+   * Simulates the public kernel teardown circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  publicKernelCircuitTeardown(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
 }