@aztec/sequencer-client 0.34.0 → 0.35.0

package/src/sequencer/hints_builder.ts

@@ -1,119 +0,0 @@
-import { MerkleTreeId } from '@aztec/circuit-types';
-import {
-  type Fr,
-  MAX_NEW_NULLIFIERS_PER_TX,
-  type MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
-  type MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-  MAX_PUBLIC_DATA_READS_PER_TX,
-  MembershipWitness,
-  NULLIFIER_TREE_HEIGHT,
-  PUBLIC_DATA_TREE_HEIGHT,
-  type PublicDataRead,
-  PublicDataTreeLeafPreimage,
-  type ReadRequestContext,
-  type SideEffectLinkedToNoteHash,
-  buildNullifierNonExistentReadRequestHints,
-  buildNullifierReadRequestHints,
-  mergeAccumulatedData,
-} from '@aztec/circuits.js';
-import { makeTuple } from '@aztec/foundation/array';
-import { type Tuple } from '@aztec/foundation/serialize';
-import { type MerkleTreeOperations } from '@aztec/world-state';
-
-export class HintsBuilder {
-  constructor(private db: MerkleTreeOperations) {}
-
-  getNullifierReadRequestHints(
-    nullifierReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
-    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
-    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
-  ) {
-    return buildNullifierReadRequestHints(
-      this,
-      nullifierReadRequests,
-      mergeAccumulatedData(MAX_NEW_NULLIFIERS_PER_TX, nullifiersNonRevertible, nullifiersRevertible),
-    );
-  }
-
-  getNullifierNonExistentReadRequestHints(
-    nullifierNonExistentReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX>,
-    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
-    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
-  ) {
-    const pendingNullifiers = mergeAccumulatedData(
-      MAX_NEW_NULLIFIERS_PER_TX,
-      nullifiersNonRevertible,
-      nullifiersRevertible,
-    );
-    return buildNullifierNonExistentReadRequestHints(this, nullifierNonExistentReadRequests, pendingNullifiers);
-  }
-
-  async getNullifierMembershipWitness(nullifier: Fr) {
-    const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
-    if (index === undefined) {
-      return;
-    }
-
-    return this.getNullifierMembershipWitnessWithPreimage(index);
-  }
-
-  async getLowNullifierMembershipWitness(nullifier: Fr) {
-    const res = await this.db.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
-    if (res === undefined) {
-      throw new Error(`Cannot find the low leaf for nullifier ${nullifier.toBigInt()}.`);
-    }
-
-    const { index, alreadyPresent } = res;
-    if (alreadyPresent) {
-      throw new Error(`Nullifier ${nullifier.toBigInt()} already exists in the tree.`);
-    }
-
-    return this.getNullifierMembershipWitnessWithPreimage(index);
-  }
-
-  private async getNullifierMembershipWitnessWithPreimage(index: bigint) {
-    const siblingPath = await this.db.getSiblingPath<typeof NULLIFIER_TREE_HEIGHT>(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);
-    if (!leafPreimage) {
-      throw new Error(`Cannot find the leaf preimage at index ${index}.`);
-    }
-
-    return { membershipWitness, leafPreimage };
-  }
-
-  async getPublicDataReadsInfo(publicDataReads: PublicDataRead[]) {
-    const newPublicDataReadsWitnesses: Tuple<
-      MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>,
-      typeof MAX_PUBLIC_DATA_READS_PER_TX
-    > = makeTuple(MAX_PUBLIC_DATA_READS_PER_TX, () => MembershipWitness.empty(PUBLIC_DATA_TREE_HEIGHT, 0n));
-
-    const newPublicDataReadsPreimages: Tuple<PublicDataTreeLeafPreimage, typeof MAX_PUBLIC_DATA_READS_PER_TX> =
-      makeTuple(MAX_PUBLIC_DATA_READS_PER_TX, () => PublicDataTreeLeafPreimage.empty());
-
-    for (const i in publicDataReads) {
-      const leafSlot = publicDataReads[i].leafSlot.value;
-      const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
-      if (!lowLeafResult) {
-        throw new Error(`Public data tree should have one initial leaf`);
-      }
-      const preimage = await this.db.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
-      const path = await this.db.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
-      newPublicDataReadsWitnesses[i] = new MembershipWitness(
-        PUBLIC_DATA_TREE_HEIGHT,
-        BigInt(lowLeafResult.index),
-        path.toTuple<typeof PUBLIC_DATA_TREE_HEIGHT>(),
-      );
-      newPublicDataReadsPreimages[i] = preimage! as PublicDataTreeLeafPreimage;
-    }
-    return {
-      newPublicDataReadsWitnesses,
-      newPublicDataReadsPreimages,
-    };
-  }
-}

package/src/sequencer/phase_manager_factory.ts

@@ -1,126 +0,0 @@
-import { type Tx } from '@aztec/circuit-types';
-import { type GlobalVariables, type Header, type PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
-import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
-import { type MerkleTreeOperations } from '@aztec/world-state';
-
-import { type PublicKernelCircuitSimulator } from '../simulator/index.js';
-import { type ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
-import { type 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 {
-  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,
-    globalVariables: GlobalVariables,
-    historicalHeader: Header,
-    publicContractsDB: ContractsDataSourcePublicDB,
-    publicStateDB: PublicStateDB,
-  ): AbstractPhaseManager | undefined {
-    const data = tx.data.forPublic!;
-    if (data.needsSetup) {
-      return new SetupPhaseManager(
-        db,
-        publicExecutor,
-        publicKernel,
-        globalVariables,
-        historicalHeader,
-        publicContractsDB,
-        publicStateDB,
-      );
-    } else if (data.needsAppLogic) {
-      return new AppLogicPhaseManager(
-        db,
-        publicExecutor,
-        publicKernel,
-        globalVariables,
-        historicalHeader,
-        publicContractsDB,
-        publicStateDB,
-      );
-    } else if (data.needsTeardown) {
-      return new TeardownPhaseManager(
-        db,
-        publicExecutor,
-        publicKernel,
-        globalVariables,
-        historicalHeader,
-        publicContractsDB,
-        publicStateDB,
-      );
-    } else {
-      return undefined;
-    }
-  }
-
-  public static phaseFromOutput(
-    output: PublicKernelCircuitPublicInputs,
-    currentPhaseManager: AbstractPhaseManager,
-    db: MerkleTreeOperations,
-    publicExecutor: PublicExecutor,
-    publicKernel: PublicKernelCircuitSimulator,
-    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,
-        globalVariables,
-        historicalHeader,
-        publicContractsDB,
-        publicStateDB,
-      );
-    } else if (output.needsTeardown) {
-      if (currentPhaseManager.phase === PublicKernelPhase.TEARDOWN) {
-        throw new PhaseDidNotChangeError(currentPhaseManager.phase);
-      }
-      return new TeardownPhaseManager(
-        db,
-        publicExecutor,
-        publicKernel,
-        globalVariables,
-        historicalHeader,
-        publicContractsDB,
-        publicStateDB,
-      );
-    } else if (currentPhaseManager.phase !== PublicKernelPhase.TAIL) {
-      return new TailPhaseManager(
-        db,
-        publicExecutor,
-        publicKernel,
-        globalVariables,
-        historicalHeader,
-        publicContractsDB,
-        publicStateDB,
-      );
-    } else {
-      return undefined;
-    }
-  }
-}

package/src/sequencer/public_processor.ts

@@ -1,209 +0,0 @@
-import {
-  type BlockProver,
-  type FailedTx,
-  type ProcessedTx,
-  type SimulationError,
-  Tx,
-  makeEmptyProcessedTx,
-  makeProcessedTx,
-  toTxEffect,
-  validateProcessedTx,
-} from '@aztec/circuit-types';
-import { type TxSequencerProcessingStats } from '@aztec/circuit-types/stats';
-import { type GlobalVariables, type Header, type KernelCircuitPublicInputs } from '@aztec/circuits.js';
-import { type ProcessReturnValues } from '@aztec/foundation/abi';
-import { createDebugLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
-import { PublicExecutor, type PublicStateDB, type SimulationProvider } from '@aztec/simulator';
-import { type ContractDataSource } from '@aztec/types/contracts';
-import { type MerkleTreeOperations } from '@aztec/world-state';
-
-import { type PublicKernelCircuitSimulator } from '../simulator/index.js';
-import { ContractsDataSourcePublicDB, WorldStateDB, WorldStatePublicDB } from '../simulator/public_executor.js';
-import { RealPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
-import { type AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
-import { PhaseManagerFactory } from './phase_manager_factory.js';
-import { type TxValidator } from './tx_validator.js';
-
-/**
- * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
- */
-export class PublicProcessorFactory {
-  constructor(
-    private merkleTree: MerkleTreeOperations,
-    private contractDataSource: ContractDataSource,
-    private simulator: SimulationProvider,
-  ) {}
-
-  /**
-   * Creates a new instance of a PublicProcessor.
-   * @param historicalHeader - The header of a block previous to the one in which the tx is included.
-   * @param globalVariables - The global variables for the block being processed.
-   * @param newContracts - Provides access to contract bytecode for public executions.
-   * @returns A new instance of a PublicProcessor.
-   */
-  public async create(
-    historicalHeader: Header | undefined,
-    globalVariables: GlobalVariables,
-  ): Promise<PublicProcessor> {
-    historicalHeader = historicalHeader ?? (await this.merkleTree.buildInitialHeader());
-
-    const publicContractsDB = new ContractsDataSourcePublicDB(this.contractDataSource);
-    const worldStatePublicDB = new WorldStatePublicDB(this.merkleTree);
-    const worldStateDB = new WorldStateDB(this.merkleTree);
-    const publicExecutor = new PublicExecutor(worldStatePublicDB, publicContractsDB, worldStateDB, historicalHeader);
-    return new PublicProcessor(
-      this.merkleTree,
-      publicExecutor,
-      new RealPublicKernelCircuitSimulator(this.simulator),
-      globalVariables,
-      historicalHeader,
-      publicContractsDB,
-      worldStatePublicDB,
-    );
-  }
-}
-
-/**
- * Converts Txs lifted from the P2P module into ProcessedTx objects by executing
- * any public function calls in them. Txs with private calls only are unaffected.
- */
-export class PublicProcessor {
-  constructor(
-    protected db: MerkleTreeOperations,
-    protected publicExecutor: PublicExecutor,
-    protected publicKernel: PublicKernelCircuitSimulator,
-    protected globalVariables: GlobalVariables,
-    protected historicalHeader: Header,
-    protected publicContractsDB: ContractsDataSourcePublicDB,
-    protected publicStateDB: PublicStateDB,
-
-    private log = createDebugLogger('aztec:sequencer:public-processor'),
-  ) {}
-
-  /**
-   * Run each tx through the public circuit and the public kernel circuit if needed.
-   * @param txs - Txs to process.
-   * @returns The list of processed txs with their circuit simulation outputs.
-   */
-  public async process(
-    txs: Tx[],
-    maxTransactions = txs.length,
-    blockProver?: BlockProver,
-    txValidator?: TxValidator,
-  ): Promise<[ProcessedTx[], FailedTx[], ProcessReturnValues[]]> {
-    // The processor modifies the tx objects in place, so we need to clone them.
-    txs = txs.map(tx => Tx.clone(tx));
-    const result: ProcessedTx[] = [];
-    const failed: FailedTx[] = [];
-    const returns: ProcessReturnValues[] = [];
-
-    for (const tx of txs) {
-      // only process up to the limit of the block
-      if (result.length >= maxTransactions) {
-        break;
-      }
-      try {
-        const [processedTx, returnValues] = !tx.hasPublicCalls()
-          ? [makeProcessedTx(tx, tx.data.toKernelCircuitPublicInputs(), tx.proof)]
-          : await this.processTxWithPublicCalls(tx);
-        validateProcessedTx(processedTx);
-        // Re-validate the transaction
-        if (txValidator) {
-          // Only accept processed transactions that are not double-spends,
-          // public functions emitting nullifiers would pass earlier check but fail here.
-          // Note that we're checking all nullifiers generated in the private execution twice,
-          // we could store the ones already checked and skip them here as an optimization.
-          const [_, invalid] = await txValidator.validateTxs([processedTx]);
-          if (invalid.length) {
-            throw new Error(`Transaction ${invalid[0].hash} invalid after processing public functions`);
-          }
-        }
-        // if we were given a prover then send the transaction to it for proving
-        if (blockProver) {
-          await blockProver.addNewTx(processedTx);
-        }
-        result.push(processedTx);
-        returns.push(returnValues);
-      } 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),
-        });
-        returns.push([]);
-      }
-    }
-
-    return [result, failed, returns];
-  }
-
-  /**
-   * 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(): ProcessedTx {
-    const { chainId, version } = this.globalVariables;
-    return makeEmptyProcessedTx(this.historicalHeader.clone(), chainId, version);
-  }
-
-  private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, ProcessReturnValues | undefined]> {
-    let returnValues: ProcessReturnValues = undefined;
-    let phase: AbstractPhaseManager | undefined = PhaseManagerFactory.phaseFromTx(
-      tx,
-      this.db,
-      this.publicExecutor,
-      this.publicKernel,
-      this.globalVariables,
-      this.historicalHeader,
-      this.publicContractsDB,
-      this.publicStateDB,
-    );
-    this.log.debug(`Beginning processing in phase ${phase?.phase} for tx ${tx.getTxHash()}`);
-    let proof = tx.proof;
-    let publicKernelPublicInput = tx.data.toPublicKernelCircuitPublicInputs();
-    let finalKernelOutput: KernelCircuitPublicInputs | undefined;
-    let revertReason: SimulationError | undefined;
-    const timer = new Timer();
-    while (phase) {
-      const output = await phase.handle(tx, publicKernelPublicInput, proof);
-      if (phase.phase === PublicKernelPhase.APP_LOGIC) {
-        returnValues = output.returnValues;
-      }
-      publicKernelPublicInput = output.publicKernelOutput;
-      finalKernelOutput = output.finalKernelOutput;
-      proof = output.publicKernelProof;
-      revertReason ??= output.revertReason;
-      phase = PhaseManagerFactory.phaseFromOutput(
-        publicKernelPublicInput,
-        phase,
-        this.db,
-        this.publicExecutor,
-        this.publicKernel,
-        this.globalVariables,
-        this.historicalHeader,
-        this.publicContractsDB,
-        this.publicStateDB,
-      );
-    }
-
-    if (!finalKernelOutput) {
-      throw new Error('Final public kernel was not executed.');
-    }
-
-    const processedTx = makeProcessedTx(tx, finalKernelOutput, proof, revertReason);
-
-    this.log.debug(`Processed public part of ${tx.getTxHash()}`, {
-      eventName: 'tx-sequencer-processing',
-      duration: timer.ms(),
-      effectsSize: toTxEffect(processedTx).toBuffer().length,
-      publicDataUpdateRequests:
-        processedTx.data.end.publicDataUpdateRequests.filter(x => !x.leafSlot.isZero()).length ?? 0,
-      ...tx.getStats(),
-    } satisfies TxSequencerProcessingStats);
-
-    return [processedTx, returnValues];
-  }
-}

package/src/sequencer/setup_phase_manager.ts

@@ -1,50 +0,0 @@
-import { type Tx } from '@aztec/circuit-types';
-import {
-  type GlobalVariables,
-  type Header,
-  type Proof,
-  type PublicKernelCircuitPublicInputs,
-} from '@aztec/circuits.js';
-import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
-import { type MerkleTreeOperations } from '@aztec/world-state';
-
-import { type PublicKernelCircuitSimulator } from '../simulator/index.js';
-import { type ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
-import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
-
-/**
- * The phase manager responsible for performing the fee preparation phase.
- */
-export class SetupPhaseManager extends AbstractPhaseManager {
-  constructor(
-    protected db: MerkleTreeOperations,
-    protected publicExecutor: PublicExecutor,
-    protected publicKernel: PublicKernelCircuitSimulator,
-    protected globalVariables: GlobalVariables,
-    protected historicalHeader: Header,
-    protected publicContractsDB: ContractsDataSourcePublicDB,
-    protected publicStateDB: PublicStateDB,
-    public phase: PublicKernelPhase = PublicKernelPhase.SETUP,
-  ) {
-    super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
-  }
-
-  override async handle(
-    tx: Tx,
-    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
-    previousPublicKernelProof: Proof,
-  ) {
-    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
-    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
-      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
-        // the abstract phase manager throws if simulation gives error in a non-revertible phase
-        async err => {
-          await this.publicStateDB.rollbackToCommit();
-          throw err;
-        },
-      );
-    tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
-    await this.publicStateDB.checkpoint();
-    return { publicKernelOutput, publicKernelProof, revertReason, returnValues: undefined };
-  }
-}

package/src/sequencer/tail_phase_manager.ts

@@ -1,111 +0,0 @@
-import { type Tx } from '@aztec/circuit-types';
-import {
-  type Fr,
-  type GlobalVariables,
-  type Header,
-  type KernelCircuitPublicInputs,
-  MAX_NEW_NOTE_HASHES_PER_TX,
-  type Proof,
-  type PublicKernelCircuitPublicInputs,
-  PublicKernelTailCircuitPrivateInputs,
-  type SideEffect,
-  makeEmptyProof,
-  mergeAccumulatedData,
-  sortByCounter,
-} from '@aztec/circuits.js';
-import { type Tuple } from '@aztec/foundation/serialize';
-import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
-import { type MerkleTreeOperations } from '@aztec/world-state';
-
-import { type PublicKernelCircuitSimulator } from '../simulator/index.js';
-import { type ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
-import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
-
-export class TailPhaseManager extends AbstractPhaseManager {
-  constructor(
-    protected db: MerkleTreeOperations,
-    protected publicExecutor: PublicExecutor,
-    protected publicKernel: PublicKernelCircuitSimulator,
-    protected globalVariables: GlobalVariables,
-    protected historicalHeader: Header,
-    protected publicContractsDB: ContractsDataSourcePublicDB,
-    protected publicStateDB: PublicStateDB,
-    public readonly phase: PublicKernelPhase = PublicKernelPhase.TAIL,
-  ) {
-    super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
-  }
-
-  async handle(tx: Tx, previousPublicKernelOutput: PublicKernelCircuitPublicInputs, previousPublicKernelProof: Proof) {
-    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
-    const [finalKernelOutput, publicKernelProof] = await this.runTailKernelCircuit(
-      previousPublicKernelOutput,
-      previousPublicKernelProof,
-    ).catch(
-      // the abstract phase manager throws if simulation gives error in non-revertible phase
-      async err => {
-        await this.publicStateDB.rollbackToCommit();
-        throw err;
-      },
-    );
-
-    // commit the state updates from this transaction
-    await this.publicStateDB.commit();
-
-    return {
-      publicKernelOutput: previousPublicKernelOutput,
-      finalKernelOutput,
-      publicKernelProof,
-      revertReason: undefined,
-      returnValues: undefined,
-    };
-  }
-
-  private async runTailKernelCircuit(
-    previousOutput: PublicKernelCircuitPublicInputs,
-    previousProof: Proof,
-  ): Promise<[KernelCircuitPublicInputs, Proof]> {
-    const output = await this.simulate(previousOutput, previousProof);
-
-    // Temporary hack. Should sort them in the tail circuit.
-    const noteHashes = mergeAccumulatedData(
-      MAX_NEW_NOTE_HASHES_PER_TX,
-      previousOutput.endNonRevertibleData.newNoteHashes,
-      previousOutput.end.newNoteHashes,
-    );
-    output.end.newNoteHashes = this.sortNoteHashes<typeof MAX_NEW_NOTE_HASHES_PER_TX>(noteHashes);
-
-    return [output, makeEmptyProof()];
-  }
-
-  private async simulate(
-    previousOutput: PublicKernelCircuitPublicInputs,
-    previousProof: Proof,
-  ): Promise<KernelCircuitPublicInputs> {
-    const previousKernel = this.getPreviousKernelData(previousOutput, previousProof);
-
-    const { validationRequests, endNonRevertibleData, end } = previousOutput;
-    const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(
-      validationRequests.nullifierReadRequests,
-      endNonRevertibleData.newNullifiers,
-      end.newNullifiers,
-    );
-    const nullifierNonExistentReadRequestHints = await this.hintsBuilder.getNullifierNonExistentReadRequestHints(
-      validationRequests.nullifierNonExistentReadRequests,
-      endNonRevertibleData.newNullifiers,
-      end.newNullifiers,
-    );
-    const inputs = new PublicKernelTailCircuitPrivateInputs(
-      previousKernel,
-      nullifierReadRequestHints,
-      nullifierNonExistentReadRequestHints,
-    );
-    return this.publicKernel.publicKernelCircuitTail(inputs);
-  }
-
-  private sortNoteHashes<N extends number>(noteHashes: Tuple<SideEffect, N>): Tuple<Fr, N> {
-    return sortByCounter(noteHashes.map(n => ({ ...n, counter: n.counter.toNumber() }))).map(n => n.value) as Tuple<
-      Fr,
-      N
-    >;
-  }
-}

package/src/sequencer/teardown_phase_manager.ts

@@ -1,50 +0,0 @@
-import { type Tx } from '@aztec/circuit-types';
-import {
-  type GlobalVariables,
-  type Header,
-  type Proof,
-  type PublicKernelCircuitPublicInputs,
-} from '@aztec/circuits.js';
-import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
-import { type MerkleTreeOperations } from '@aztec/world-state';
-
-import { type PublicKernelCircuitSimulator } from '../simulator/index.js';
-import { type ContractsDataSourcePublicDB } from '../simulator/public_executor.js';
-import { AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.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 globalVariables: GlobalVariables,
-    protected historicalHeader: Header,
-    protected publicContractsDB: ContractsDataSourcePublicDB,
-    protected publicStateDB: PublicStateDB,
-    public phase: PublicKernelPhase = PublicKernelPhase.TEARDOWN,
-  ) {
-    super(db, publicExecutor, publicKernel, globalVariables, historicalHeader, phase);
-  }
-
-  override async handle(
-    tx: Tx,
-    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
-    previousPublicKernelProof: Proof,
-  ) {
-    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
-    const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs, revertReason] =
-      await this.processEnqueuedPublicCalls(tx, previousPublicKernelOutput, previousPublicKernelProof).catch(
-        // the abstract phase manager throws if simulation gives error in a non-revertible phase
-        async err => {
-          await this.publicStateDB.rollbackToCommit();
-          throw err;
-        },
-      );
-    tx.unencryptedLogs.addFunctionLogs(newUnencryptedFunctionLogs);
-    await this.publicStateDB.checkpoint();
-    return { publicKernelOutput, publicKernelProof, revertReason, returnValues: undefined };
-  }
-}