@aztec/sequencer-client 0.26.5 → 0.26.6

package/src/sequencer/app_logic_phase_manager.ts

@@ -27,42 +27,32 @@ export class AppLogicPhaseManager extends AbstractPhaseManager {
     super(db, publicExecutor, publicKernel, publicProver, globalVariables, historicalHeader, phase);
   }
 
-  async handle(
+  override 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;
-  }> {
+  ) {
     // 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
     // have to capture contracts emitted in that phase as well.
     // TODO(@spalladino): Should we allow emitting contracts in the fee preparation phase?
     this.log(`Processing tx ${tx.getTxHash()}`);
     await this.publicContractsDB.addNewContracts(tx);
-    this.log(`Executing enqueued public calls for tx ${tx.getTxHash()}`);
-    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs] = await this.processEnqueuedPublicCalls(
-      tx,
-      previousPublicKernelOutput,
-      previousPublicKernelProof,
-    );
-    tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
+    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof);
 
-    // commit the state updates from this transaction
-    await this.publicStateDB.commit();
+    if (revertReason) {
+      await this.rollback(tx, revertReason);
+    } else {
+      tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
+      await this.publicStateDB.commit();
+    }
 
-    return { publicKernelOutput, publicKernelProof };
+    return { publicKernelOutput, publicKernelProof, revertReason };
   }
 
   async rollback(tx: Tx, err: unknown): Promise<FailedTx> {
-    this.log.warn(`Error processing tx ${tx.getTxHash()}: ${err}`);
+    this.log.warn(`Rolling back changes from ${tx.getTxHash()}`);
     // remove contracts on failure
     await this.publicContractsDB.removeNewContracts(tx);
     // rollback any state updates from this failed transaction

package/src/sequencer/hints_builder.ts

@@ -0,0 +1,56 @@
+import { MerkleTreeId } from '@aztec/circuit-types';
+import {
+  Fr,
+  MAX_NEW_NULLIFIERS_PER_TX,
+  MAX_NON_REVERTIBLE_NULLIFIERS_PER_TX,
+  MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+  MAX_REVERTIBLE_NULLIFIERS_PER_TX,
+  MembershipWitness,
+  NULLIFIER_TREE_HEIGHT,
+  NullifierLeafPreimage,
+  ReadRequestContext,
+  SideEffectLinkedToNoteHash,
+  buildNullifierReadRequestResetHints,
+  concatAccumulatedData,
+  mergeAccumulatedData,
+} from '@aztec/circuits.js';
+import { Tuple } from '@aztec/foundation/serialize';
+import { MerkleTreeOperations } from '@aztec/world-state';
+
+export class HintsBuilder {
+  constructor(private db: MerkleTreeOperations) {}
+
+  getNullifierReadRequestResetHints(
+    nullifierReadRequestsNonRevertible: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+    nullifierReadRequestsRevertible: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NON_REVERTIBLE_NULLIFIERS_PER_TX>,
+    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_REVERTIBLE_NULLIFIERS_PER_TX>,
+  ) {
+    return buildNullifierReadRequestResetHints(
+      this,
+      mergeAccumulatedData(
+        MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+        nullifierReadRequestsNonRevertible,
+        nullifierReadRequestsRevertible,
+      ),
+      concatAccumulatedData(MAX_NEW_NULLIFIERS_PER_TX, nullifiersNonRevertible, nullifiersRevertible),
+    );
+  }
+
+  async getNullifierMembershipWitness(nullifier: Fr) {
+    const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+    if (index === undefined) {
+      return;
+    }
+
+    const siblingPath = await this.db.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, index);
+    const membershipWitness = new MembershipWitness(
+      NULLIFIER_TREE_HEIGHT,
+      index,
+      siblingPath.toTuple<typeof NULLIFIER_TREE_HEIGHT>(),
+    );
+    const leafPreimage = (await this.db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index))! as NullifierLeafPreimage;
+
+    return { membershipWitness, leafPreimage };
+  }
+}

package/src/sequencer/index.ts

@@ -1,2 +1,2 @@
-export * from './sequencer.js';
 export * from './config.js';
+export * from './sequencer.js';

package/src/sequencer/phase_manager_factory.ts

@@ -9,6 +9,7 @@ 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 { TailPhaseManager } from './tail_phase_manager.js';
 import { TeardownPhaseManager } from './teardown_phase_manager.js';
 
 export class PhaseDidNotChangeError extends Error {
@@ -115,6 +116,17 @@ export class PhaseManagerFactory {
         publicContractsDB,
         publicStateDB,
       );
+    } else if (currentPhaseManager.phase !== PublicKernelPhase.TAIL) {
+      return new TailPhaseManager(
+        db,
+        publicExecutor,
+        publicKernel,
+        publicProver,
+        globalVariables,
+        historicalHeader,
+        publicContractsDB,
+        publicStateDB,
+      );
     } else {
       return undefined;
     }

package/src/sequencer/processed_tx.ts

@@ -1,13 +1,29 @@
-import { ExtendedContractData, Tx, TxHash, TxL2Logs } from '@aztec/circuit-types';
+import {
+  ContractData,
+  ExtendedContractData,
+  PublicDataWrite,
+  SimulationError,
+  Tx,
+  TxEffect,
+  TxHash,
+  TxL2Logs,
+} from '@aztec/circuit-types';
 import {
   Fr,
   Header,
+  MAX_NEW_CONTRACTS_PER_TX,
+  MAX_NEW_NOTE_HASHES_PER_TX,
+  MAX_NEW_NULLIFIERS_PER_TX,
+  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   Proof,
   PublicAccumulatedNonRevertibleData,
   PublicAccumulatedRevertibleData,
   PublicKernelCircuitPublicInputs,
+  SideEffect,
+  SideEffectLinkedToNoteHash,
   makeEmptyProof,
 } from '@aztec/circuits.js';
+import { Tuple, fromFieldsTuple } from '@aztec/foundation/serialize';
 
 /**
  * Represents a tx that has been processed by the sequencer public processor,
@@ -26,8 +42,39 @@ export type ProcessedTx = Pick<Tx, 'proof' | 'encryptedLogs' | 'unencryptedLogs'
    * Flag indicating the tx is 'empty' meaning it's a padding tx to take us to a power of 2.
    */
   isEmpty: boolean;
+
+  /**
+   * Reason the tx was reverted.
+   */
+  revertReason: SimulationError | undefined;
 };
 
+export type RevertedTx = ProcessedTx & {
+  data: PublicKernelCircuitPublicInputs & {
+    reverted: true;
+  };
+
+  revertReason: SimulationError;
+};
+
+export function isRevertedTx(tx: ProcessedTx): tx is RevertedTx {
+  return tx.data.reverted;
+}
+
+export function partitionReverts(txs: ProcessedTx[]): { reverted: RevertedTx[]; nonReverted: ProcessedTx[] } {
+  return txs.reduce(
+    ({ reverted, nonReverted }, tx) => {
+      if (isRevertedTx(tx)) {
+        reverted.push(tx);
+      } else {
+        nonReverted.push(tx);
+      }
+      return { reverted, nonReverted };
+    },
+    { reverted: [], nonReverted: [] } as ReturnType<typeof partitionReverts>,
+  );
+}
+
 /**
  * Represents a tx that failed to be processed by the sequencer public processor.
  */
@@ -42,31 +89,73 @@ export type FailedTx = {
   error: Error;
 };
 
+/**
+ *
+ * @param tx - the TX being procesed
+ * @param publicKernelPublicInput - the output of the public kernel circuit, unless we just came from private
+ * @param publicKernelProof - the proof of the public kernel circuit, unless we just came from private
+ * @returns PublicKernelCircuitPublicInputs, either passed through from the input or converted from the output of the TX,
+ * and Proof, either passed through from the input or the proof of the TX
+ */
+export function getPreviousOutputAndProof(
+  tx: Tx,
+  publicKernelPublicInput?: PublicKernelCircuitPublicInputs,
+  publicKernelProof?: Proof,
+): {
+  /**
+   * the output of the public kernel circuit for this phase
+   */
+  publicKernelPublicInput: PublicKernelCircuitPublicInputs;
+  /**
+   * the proof of the public kernel circuit for this phase
+   */
+  previousProof: Proof;
+} {
+  if (publicKernelPublicInput && publicKernelProof) {
+    return {
+      publicKernelPublicInput,
+      previousProof: publicKernelProof,
+    };
+  } else {
+    const publicKernelPublicInput = new PublicKernelCircuitPublicInputs(
+      tx.data.aggregationObject,
+      PublicAccumulatedNonRevertibleData.fromPrivateAccumulatedNonRevertibleData(tx.data.endNonRevertibleData),
+      PublicAccumulatedRevertibleData.fromPrivateAccumulatedRevertibleData(tx.data.end),
+      tx.data.constants,
+      tx.data.needsSetup,
+      tx.data.needsAppLogic,
+      tx.data.needsTeardown,
+      false, // reverted
+    );
+    return {
+      publicKernelPublicInput,
+      previousProof: publicKernelProof || tx.proof,
+    };
+  }
+}
+
 /**
  * Makes a processed tx out of source tx.
  * @param tx - Source tx.
  * @param kernelOutput - Output of the kernel circuit simulation for this tx.
  * @param proof - Proof of the kernel circuit for this tx.
  */
-export function makeProcessedTx(tx: Tx, kernelOutput?: PublicKernelCircuitPublicInputs, proof?: Proof): ProcessedTx {
+export function makeProcessedTx(
+  tx: Tx,
+  kernelOutput?: PublicKernelCircuitPublicInputs,
+  proof?: Proof,
+  revertReason?: SimulationError,
+): ProcessedTx {
+  const { publicKernelPublicInput, previousProof } = getPreviousOutputAndProof(tx, kernelOutput, proof);
   return {
     hash: tx.getTxHash(),
-    data:
-      kernelOutput ??
-      new PublicKernelCircuitPublicInputs(
-        tx.data.aggregationObject,
-        PublicAccumulatedNonRevertibleData.fromPrivateAccumulatedNonRevertibleData(tx.data.endNonRevertibleData),
-        PublicAccumulatedRevertibleData.fromPrivateAccumulatedRevertibleData(tx.data.end),
-        tx.data.constants,
-        tx.data.needsSetup,
-        tx.data.needsAppLogic,
-        tx.data.needsTeardown,
-      ),
-    proof: proof ?? tx.proof,
-    encryptedLogs: tx.encryptedLogs,
-    unencryptedLogs: tx.unencryptedLogs,
-    newContracts: tx.newContracts,
+    data: publicKernelPublicInput,
+    proof: previousProof,
+    encryptedLogs: revertReason ? new TxL2Logs([]) : tx.encryptedLogs,
+    unencryptedLogs: revertReason ? new TxL2Logs([]) : tx.unencryptedLogs,
+    newContracts: revertReason ? [ExtendedContractData.empty()] : tx.newContracts,
     isEmpty: false,
+    revertReason,
   };
 }
 
@@ -90,5 +179,46 @@ export function makeEmptyProcessedTx(header: Header, chainId: Fr, version: Fr):
     proof: emptyProof,
     newContracts: [ExtendedContractData.empty()],
     isEmpty: true,
+    revertReason: undefined,
   };
 }
+
+export function toTxEffect(tx: ProcessedTx): TxEffect {
+  return new TxEffect(
+    tx.data.combinedData.newNoteHashes.map((c: SideEffect) => c.value) as Tuple<Fr, typeof MAX_NEW_NOTE_HASHES_PER_TX>,
+    tx.data.combinedData.newNullifiers.map((n: SideEffectLinkedToNoteHash) => n.value) as Tuple<
+      Fr,
+      typeof MAX_NEW_NULLIFIERS_PER_TX
+    >,
+    tx.data.combinedData.newL2ToL1Msgs,
+    tx.data.combinedData.publicDataUpdateRequests.map(t => new PublicDataWrite(t.leafSlot, t.newValue)) as Tuple<
+      PublicDataWrite,
+      typeof MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
+    >,
+    tx.data.combinedData.newContracts.map(cd => cd.hash()) as Tuple<Fr, typeof MAX_NEW_CONTRACTS_PER_TX>,
+    tx.data.combinedData.newContracts.map(
+      cd => new ContractData(cd.contractAddress, cd.portalContractAddress),
+    ) as Tuple<ContractData, typeof MAX_NEW_CONTRACTS_PER_TX>,
+    tx.encryptedLogs || new TxL2Logs([]),
+    tx.unencryptedLogs || new TxL2Logs([]),
+  );
+}
+
+function validateProcessedTxLogs(tx: ProcessedTx): void {
+  const unencryptedLogs = tx.unencryptedLogs || new TxL2Logs([]);
+  const kernelUnencryptedLogsHash = fromFieldsTuple(tx.data.combinedData.unencryptedLogsHash);
+  if (!unencryptedLogs.hash().equals(kernelUnencryptedLogsHash)) {
+    throw new Error(
+      `Unencrypted logs hash mismatch. Expected ${unencryptedLogs
+        .hash()
+        .toString('hex')}, got ${kernelUnencryptedLogsHash.toString('hex')}.
+             Processed: ${JSON.stringify(unencryptedLogs.toJSON())}
+             Kernel Length: ${tx.data.combinedData.unencryptedLogPreimagesLength}`,
+    );
+  }
+}
+
+export function validateProcessedTx(tx: ProcessedTx): void {
+  validateProcessedTxLogs(tx);
+  // TODO: validate other fields
+}

package/src/sequencer/public_processor.ts

@@ -1,4 +1,4 @@
-import { ContractDataSource, L1ToL2MessageSource, Tx } from '@aztec/circuit-types';
+import { ContractDataSource, L1ToL2MessageSource, SimulationError, Tx } from '@aztec/circuit-types';
 import { TxSequencerProcessingStats } from '@aztec/circuit-types/stats';
 import { GlobalVariables, Header } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -14,7 +14,14 @@ import { RealPublicKernelCircuitSimulator } from '../simulator/public_kernel.js'
 import { SimulationProvider } from '../simulator/simulation_provider.js';
 import { AbstractPhaseManager } from './abstract_phase_manager.js';
 import { PhaseManagerFactory } from './phase_manager_factory.js';
-import { FailedTx, ProcessedTx, makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
+import {
+  FailedTx,
+  ProcessedTx,
+  getPreviousOutputAndProof,
+  makeEmptyProcessedTx,
+  makeProcessedTx,
+  validateProcessedTx,
+} from './processed_tx.js';
 
 /**
  * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
@@ -99,17 +106,15 @@ export class PublicProcessor {
         this.publicStateDB,
       );
       this.log(`Beginning processing in phase ${phase?.phase} for tx ${tx.getTxHash()}`);
-      let { publicKernelPublicInput, publicKernelProof } = AbstractPhaseManager.getKernelOutputAndProof(
-        tx,
-        undefined,
-        undefined,
-      );
+      let { publicKernelPublicInput, previousProof: proof } = getPreviousOutputAndProof(tx, undefined, undefined);
+      let revertReason: SimulationError | undefined;
       const timer = new Timer();
       try {
         while (phase) {
-          const output = await phase.handle(tx, publicKernelPublicInput, publicKernelProof);
+          const output = await phase.handle(tx, publicKernelPublicInput, proof);
           publicKernelPublicInput = output.publicKernelOutput;
-          publicKernelProof = output.publicKernelProof;
+          proof = output.publicKernelProof;
+          revertReason ??= output.revertReason;
           phase = PhaseManagerFactory.phaseFromOutput(
             publicKernelPublicInput,
             phase,
@@ -124,7 +129,9 @@ export class PublicProcessor {
           );
         }
 
-        const processedTransaction = makeProcessedTx(tx, publicKernelPublicInput, publicKernelProof);
+        const processedTransaction = makeProcessedTx(tx, publicKernelPublicInput, proof, revertReason);
+        validateProcessedTx(processedTransaction);
+
         result.push(processedTransaction);
 
         this.log(`Processed public part of ${tx.data.endNonRevertibleData.newNullifiers[0].value}`, {
@@ -135,9 +142,14 @@ export class PublicProcessor {
             0,
           ...tx.getStats(),
         } satisfies TxSequencerProcessingStats);
-      } catch (err) {
-        const failedTx = await phase!.rollback(tx, err);
-        failed.push(failedTx);
+      } catch (err: any) {
+        const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+        this.log.warn(`Failed to process tx ${tx.getTxHash()}: ${errorMessage}`);
+
+        failed.push({
+          tx,
+          error: err instanceof Error ? err : new Error(errorMessage),
+        });
       }
     }
 

package/src/sequencer/sequencer.ts

@@ -180,7 +180,6 @@ export class Sequencer {
       this.log.info(`Building block ${newBlockNumber} with ${validTxs.length} transactions`);
       this.state = SequencerState.CREATING_BLOCK;
 
-      // Process txs and drop the ones that fail processing
       // We create a fresh processor each time to reset any cached state (eg storage writes)
       const processor = await this.publicProcessorFactory.create(historicalHeader, newGlobalVariables);
       const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() => processor.process(validTxs));

package/src/sequencer/setup_phase_manager.ts

@@ -27,34 +27,20 @@ export class SetupPhaseManager extends AbstractPhaseManager {
     super(db, publicExecutor, publicKernel, publicProver, globalVariables, historicalHeader, phase);
   }
 
-  // this is a no-op for now
-  async handle(
+  override 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,
-    );
+    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof);
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
 
     // commit the state updates from this transaction
     await this.publicStateDB.commit();
 
-    return { publicKernelOutput, publicKernelProof };
+    return { publicKernelOutput, publicKernelProof, revertReason };
   }
 
   async rollback(tx: Tx, err: unknown): Promise<FailedTx> {

package/src/sequencer/tail_phase_manager.ts

@@ -0,0 +1,49 @@
+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';
+
+export class TailPhaseManager 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 readonly phase: PublicKernelPhase = PublicKernelPhase.TAIL,
+  ) {
+    super(db, publicExecutor, publicKernel, publicProver, globalVariables, historicalHeader, phase);
+  }
+
+  async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs, previousPublicKernelProof: Proof) {
+    this.log(`Processing tx ${tx.getTxHash()}`);
+    this.log(`Executing tail circuit for tx ${tx.getTxHash()}`);
+    const [publicKernelOutput, publicKernelProof] = await this.runKernelCircuit(
+      previousPublicKernelOutput,
+      previousPublicKernelProof,
+    );
+
+    // commit the state updates from this transaction
+    await this.publicStateDB.commit();
+
+    return { publicKernelOutput, publicKernelProof, revertReason: undefined };
+  }
+
+  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/sequencer/teardown_phase_manager.ts

@@ -27,33 +27,20 @@ export class TeardownPhaseManager extends AbstractPhaseManager {
     super(db, publicExecutor, publicKernel, publicProver, globalVariables, historicalHeader, phase);
   }
 
-  async handle(
+  override 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,
-    );
+    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
+      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof);
     tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
 
     // commit the state updates from this transaction
     await this.publicStateDB.commit();
 
-    return { publicKernelOutput, publicKernelProof };
+    return { publicKernelOutput, publicKernelProof, revertReason };
   }
 
   async rollback(tx: Tx, err: unknown): Promise<FailedTx> {

package/src/simulator/index.ts

@@ -4,6 +4,7 @@ import {
   MergeRollupInputs,
   PublicKernelCircuitPrivateInputs,
   PublicKernelCircuitPublicInputs,
+  PublicKernelTailCircuitPrivateInputs,
   RootRollupInputs,
   RootRollupPublicInputs,
 } from '@aztec/circuits.js';
@@ -54,5 +55,11 @@ export interface PublicKernelCircuitSimulator {
    * @returns The public inputs as outputs of the simulation.
    */
   publicKernelCircuitTeardown(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
+  /**
+   * Simulates the public kernel tail circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  publicKernelCircuitTail(inputs: PublicKernelTailCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
 }
 export * from './acvm_wasm.js';

package/src/simulator/public_kernel.ts

@@ -1,17 +1,24 @@
 import { CircuitSimulationStats } from '@aztec/circuit-types/stats';
-import { PublicKernelCircuitPrivateInputs, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
+import {
+  PublicKernelCircuitPrivateInputs,
+  PublicKernelCircuitPublicInputs,
+  PublicKernelTailCircuitPrivateInputs,
+} from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
 import {
   PublicKernelAppLogicArtifact,
   PublicKernelSetupArtifact,
+  PublicKernelTailArtifact,
   PublicKernelTeardownArtifact,
   convertPublicInnerRollupInputsToWitnessMap,
   convertPublicInnerRollupOutputFromWitnessMap,
   convertPublicSetupRollupInputsToWitnessMap,
   convertPublicSetupRollupOutputFromWitnessMap,
-  convertPublicTailRollupInputsToWitnessMap,
-  convertPublicTailRollupOutputFromWitnessMap,
+  convertPublicTailInputsToWitnessMap,
+  convertPublicTailOutputFromWitnessMap,
+  convertPublicTeardownRollupInputsToWitnessMap,
+  convertPublicTeardownRollupOutputFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
 
 import { PublicKernelCircuitSimulator, WASMSimulator } from './index.js';
@@ -91,11 +98,11 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     if (!input.previousKernel.publicInputs.needsTeardown) {
       throw new Error(`Expected previous kernel inputs to need teardown`);
     }
-    const inputWitness = convertPublicTailRollupInputsToWitnessMap(input);
+    const inputWitness = convertPublicTeardownRollupInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
       this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTeardownArtifact),
     );
-    const result = convertPublicTailRollupOutputFromWitnessMap(witness);
+    const result = convertPublicTeardownRollupOutputFromWitnessMap(witness);
     this.log(`Simulated public kernel teardown circuit`, {
       eventName: 'circuit-simulation',
       circuitName: 'public-kernel-teardown',
@@ -105,4 +112,27 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
     } satisfies CircuitSimulationStats);
     return result;
   }
+
+  /**
+   * Simulates the public kernel tail circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async publicKernelCircuitTail(
+    input: PublicKernelTailCircuitPrivateInputs,
+  ): Promise<PublicKernelCircuitPublicInputs> {
+    const inputWitness = convertPublicTailInputsToWitnessMap(input);
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTailArtifact),
+    );
+    const result = convertPublicTailOutputFromWitnessMap(witness);
+    this.log(`Simulated public kernel tail circuit`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'public-kernel-tail',
+      duration,
+      inputSize: input.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+    return result;
+  }
 }