@aztec/simulator 0.34.0 → 0.35.0

package/src/public/public_executor.ts

@@ -0,0 +1,267 @@
+import { MerkleTreeId, NullifierMembershipWitness, type Tx } from '@aztec/circuit-types';
+import {
+  type AztecAddress,
+  ContractClassRegisteredEvent,
+  ContractInstanceDeployedEvent,
+  type EthAddress,
+  Fr,
+  type FunctionSelector,
+  type L1_TO_L2_MSG_TREE_HEIGHT,
+  type NULLIFIER_TREE_HEIGHT,
+  type NullifierLeafPreimage,
+  type PublicDataTreeLeafPreimage,
+} from '@aztec/circuits.js';
+import { computeL1ToL2MessageNullifier, computePublicDataTreeLeafSlot } from '@aztec/circuits.js/hash';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { getCanonicalClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
+import {
+  type CommitmentsDB,
+  MessageLoadOracleInputs,
+  type PublicContractsDB,
+  type PublicStateDB,
+} from '@aztec/simulator';
+import {
+  type ContractClassPublic,
+  type ContractDataSource,
+  type ContractInstanceWithAddress,
+} from '@aztec/types/contracts';
+import { type MerkleTreeOperations } from '@aztec/world-state';
+
+/**
+ * Implements the PublicContractsDB using a ContractDataSource.
+ * Progressively records contracts in transaction as they are processed in a block.
+ */
+export class ContractsDataSourcePublicDB implements PublicContractsDB {
+  private instanceCache = new Map<string, ContractInstanceWithAddress>();
+  private classCache = new Map<string, ContractClassPublic>();
+
+  private log = createDebugLogger('aztec:sequencer:contracts-data-source');
+
+  constructor(private db: ContractDataSource) {}
+
+  /**
+   * Add new contracts from a transaction
+   * @param tx - The transaction to add contracts from.
+   */
+  public addNewContracts(tx: Tx): Promise<void> {
+    // Extract contract class and instance data from logs and add to cache for this block
+    const logs = tx.unencryptedLogs.unrollLogs();
+    ContractClassRegisteredEvent.fromLogs(logs, getCanonicalClassRegistererAddress()).forEach(e => {
+      this.log.debug(`Adding class ${e.contractClassId.toString()} to public execution contract cache`);
+      this.classCache.set(e.contractClassId.toString(), e.toContractClassPublic());
+    });
+    ContractInstanceDeployedEvent.fromLogs(logs).forEach(e => {
+      this.log.debug(
+        `Adding instance ${e.address.toString()} with class ${e.contractClassId.toString()} to public execution contract cache`,
+      );
+      this.instanceCache.set(e.address.toString(), e.toContractInstance());
+    });
+
+    return Promise.resolve();
+  }
+
+  /**
+   * Removes new contracts added from transactions
+   * @param tx - The tx's contracts to be removed
+   */
+  public removeNewContracts(tx: Tx): Promise<void> {
+    // TODO(@spalladino): Can this inadvertently delete a valid contract added by another tx?
+    // Let's say we have two txs adding the same contract on the same block. If the 2nd one reverts,
+    // wouldn't that accidentally remove the contract added on the first one?
+    const logs = tx.unencryptedLogs.unrollLogs();
+    ContractClassRegisteredEvent.fromLogs(logs, getCanonicalClassRegistererAddress()).forEach(e =>
+      this.classCache.delete(e.contractClassId.toString()),
+    );
+    ContractInstanceDeployedEvent.fromLogs(logs).forEach(e => this.instanceCache.delete(e.address.toString()));
+    return Promise.resolve();
+  }
+
+  public async getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    return this.instanceCache.get(address.toString()) ?? (await this.db.getContract(address));
+  }
+
+  public async getContractClass(contractClassId: Fr): Promise<ContractClassPublic | undefined> {
+    return this.classCache.get(contractClassId.toString()) ?? (await this.db.getContractClass(contractClassId));
+  }
+
+  async getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
+    const instance = await this.getContractInstance(address);
+    if (!instance) {
+      throw new Error(`Contract ${address.toString()} not found`);
+    }
+    const contractClass = await this.getContractClass(instance.contractClassId);
+    if (!contractClass) {
+      throw new Error(`Contract class ${instance.contractClassId.toString()} for ${address.toString()} not found`);
+    }
+    return contractClass.publicFunctions.find(f => f.selector.equals(selector))?.bytecode;
+  }
+
+  async getPortalContractAddress(address: AztecAddress): Promise<EthAddress | undefined> {
+    const contract = await this.getContractInstance(address);
+    return contract?.portalContractAddress;
+  }
+}
+
+/**
+ * Implements the PublicStateDB using a world-state database.
+ */
+export class WorldStatePublicDB implements PublicStateDB {
+  private committedWriteCache: Map<bigint, Fr> = new Map();
+  private checkpointedWriteCache: Map<bigint, Fr> = new Map();
+  private uncommittedWriteCache: Map<bigint, Fr> = new Map();
+
+  constructor(private db: MerkleTreeOperations) {}
+
+  /**
+   * Reads a value from public storage, returning zero if none.
+   * @param contract - Owner of the storage.
+   * @param slot - Slot to read in the contract storage.
+   * @returns The current value in the storage slot.
+   */
+  public async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {
+    const leafSlot = computePublicDataTreeLeafSlot(contract, slot).value;
+    const uncommitted = this.uncommittedWriteCache.get(leafSlot);
+    if (uncommitted !== undefined) {
+      return uncommitted;
+    }
+    const checkpointed = this.checkpointedWriteCache.get(leafSlot);
+    if (checkpointed !== undefined) {
+      return checkpointed;
+    }
+    const committed = this.committedWriteCache.get(leafSlot);
+    if (committed !== undefined) {
+      return committed;
+    }
+
+    const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+    if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
+      return Fr.ZERO;
+    }
+
+    const preimage = (await this.db.getLeafPreimage(
+      MerkleTreeId.PUBLIC_DATA_TREE,
+      lowLeafResult.index,
+    )) as PublicDataTreeLeafPreimage;
+
+    return preimage.value;
+  }
+
+  /**
+   * Records a write to public storage.
+   * @param contract - Owner of the storage.
+   * @param slot - Slot to read in the contract storage.
+   * @param newValue - The new value to store.
+   */
+  public storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void> {
+    const index = computePublicDataTreeLeafSlot(contract, slot).value;
+    this.uncommittedWriteCache.set(index, newValue);
+    return Promise.resolve();
+  }
+
+  /**
+   * Commit the pending changes to the DB.
+   * @returns Nothing.
+   */
+  commit(): Promise<void> {
+    for (const [k, v] of this.checkpointedWriteCache) {
+      this.committedWriteCache.set(k, v);
+    }
+    // uncommitted writes take precedence over checkpointed writes
+    // since they are the most recent
+    for (const [k, v] of this.uncommittedWriteCache) {
+      this.committedWriteCache.set(k, v);
+    }
+    return this.rollbackToCommit();
+  }
+
+  /**
+   * Rollback the pending changes.
+   * @returns Nothing.
+   */
+  async rollbackToCommit(): Promise<void> {
+    await this.rollbackToCheckpoint();
+    this.checkpointedWriteCache = new Map<bigint, Fr>();
+    return Promise.resolve();
+  }
+
+  checkpoint(): Promise<void> {
+    for (const [k, v] of this.uncommittedWriteCache) {
+      this.checkpointedWriteCache.set(k, v);
+    }
+    return this.rollbackToCheckpoint();
+  }
+
+  rollbackToCheckpoint(): Promise<void> {
+    this.uncommittedWriteCache = new Map<bigint, Fr>();
+    return Promise.resolve();
+  }
+}
+
+/**
+ * Implements WorldState db using a world state database.
+ */
+export class WorldStateDB implements CommitmentsDB {
+  constructor(private db: MerkleTreeOperations) {}
+
+  public async getNullifierMembershipWitnessAtLatestBlock(
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined> {
+    const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+    if (!index) {
+      return undefined;
+    }
+
+    const leafPreimagePromise = this.db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
+    const siblingPathPromise = this.db.getSiblingPath<typeof NULLIFIER_TREE_HEIGHT>(
+      MerkleTreeId.NULLIFIER_TREE,
+      BigInt(index),
+    );
+
+    const [leafPreimage, siblingPath] = await Promise.all([leafPreimagePromise, siblingPathPromise]);
+
+    if (!leafPreimage) {
+      return undefined;
+    }
+
+    return new NullifierMembershipWitness(BigInt(index), leafPreimage as NullifierLeafPreimage, siblingPath);
+  }
+
+  public async getL1ToL2MembershipWitness(
+    contractAddress: AztecAddress,
+    messageHash: Fr,
+    secret: Fr,
+  ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
+    let nullifierIndex: bigint | undefined;
+    let messageIndex: bigint | undefined;
+    let startIndex = 0n;
+
+    // We iterate over messages until we find one whose nullifier is not in the nullifier tree --> we need to check
+    // for nullifiers because messages can have duplicates.
+    do {
+      messageIndex = (await this.db.findLeafIndexAfter(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, messageHash, startIndex))!;
+      if (messageIndex === undefined) {
+        throw new Error(`No non-nullified L1 to L2 message found for message hash ${messageHash.toString()}`);
+      }
+
+      const messageNullifier = computeL1ToL2MessageNullifier(contractAddress, messageHash, secret, messageIndex);
+      nullifierIndex = await this.getNullifierIndex(messageNullifier);
+
+      startIndex = messageIndex + 1n;
+    } while (nullifierIndex !== undefined);
+
+    const siblingPath = await this.db.getSiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>(
+      MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
+      messageIndex,
+    );
+
+    return new MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>(messageIndex, siblingPath);
+  }
+
+  public async getCommitmentIndex(commitment: Fr): Promise<bigint | undefined> {
+    return await this.db.findLeafIndex(MerkleTreeId.NOTE_HASH_TREE, commitment);
+  }
+
+  public async getNullifierIndex(nullifier: Fr): Promise<bigint | undefined> {
+    return await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+  }
+}

package/src/public/public_kernel.ts

@@ -0,0 +1,139 @@
+import { type CircuitSimulationStats } from '@aztec/circuit-types/stats';
+import {
+  type KernelCircuitPublicInputs,
+  type PublicKernelCircuitPrivateInputs,
+  type PublicKernelCircuitPublicInputs,
+  type 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,
+  convertPublicTailInputsToWitnessMap,
+  convertPublicTailOutputFromWitnessMap,
+  convertPublicTeardownRollupInputsToWitnessMap,
+  convertPublicTeardownRollupOutputFromWitnessMap,
+} from '@aztec/noir-protocol-circuits-types';
+import { type SimulationProvider, WASMSimulator } from '@aztec/simulator';
+
+import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
+
+/**
+ * Implements the PublicKernelCircuitSimulator.
+ */
+export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimulator {
+  private log = createDebugLogger('aztec:public-kernel-simulator');
+
+  // Some circuits are so small it is faster to use WASM
+  private wasmSimulator: WASMSimulator = new WASMSimulator();
+
+  constructor(private simulator: SimulationProvider) {}
+
+  /**
+   * Simulates the public kernel setup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async publicKernelCircuitSetup(
+    input: PublicKernelCircuitPrivateInputs,
+  ): Promise<PublicKernelCircuitPublicInputs> {
+    if (!input.previousKernel.publicInputs.needsSetup) {
+      throw new Error(`Expected previous kernel inputs to need setup`);
+    }
+    const inputWitness = convertPublicSetupRollupInputsToWitnessMap(input);
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelSetupArtifact),
+    );
+    const result = convertPublicSetupRollupOutputFromWitnessMap(witness);
+    this.log.debug(`Simulated public kernel setup circuit`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'public-kernel-setup',
+      duration,
+      inputSize: input.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+    return result;
+  }
+
+  /**
+   * Simulates the public kernel app logic circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async publicKernelCircuitAppLogic(
+    input: PublicKernelCircuitPrivateInputs,
+  ): Promise<PublicKernelCircuitPublicInputs> {
+    if (!input.previousKernel.publicInputs.needsAppLogic) {
+      throw new Error(`Expected previous kernel inputs to need app logic`);
+    }
+    const inputWitness = convertPublicInnerRollupInputsToWitnessMap(input);
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelAppLogicArtifact),
+    );
+    const result = convertPublicInnerRollupOutputFromWitnessMap(witness);
+    this.log.debug(`Simulated public kernel app logic circuit`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'public-kernel-app-logic',
+      duration,
+      inputSize: input.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+    return result;
+  }
+
+  /**
+   * Simulates the public kernel teardown circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async publicKernelCircuitTeardown(
+    input: PublicKernelCircuitPrivateInputs,
+  ): Promise<PublicKernelCircuitPublicInputs> {
+    if (!input.previousKernel.publicInputs.needsTeardown) {
+      throw new Error(`Expected previous kernel inputs to need teardown`);
+    }
+    const inputWitness = convertPublicTeardownRollupInputsToWitnessMap(input);
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTeardownArtifact),
+    );
+    const result = convertPublicTeardownRollupOutputFromWitnessMap(witness);
+    this.log.debug(`Simulated public kernel teardown circuit`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'public-kernel-teardown',
+      duration,
+      inputSize: input.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } 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<KernelCircuitPublicInputs> {
+    const inputWitness = convertPublicTailInputsToWitnessMap(input);
+    const [duration, witness] = await elapsed(() =>
+      this.wasmSimulator.simulateCircuit(inputWitness, PublicKernelTailArtifact),
+    );
+    const result = convertPublicTailOutputFromWitnessMap(witness);
+    this.log.debug(`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;
+  }
+}

package/src/public/public_kernel_circuit_simulator.ts

@@ -0,0 +1,36 @@
+import {
+  type KernelCircuitPublicInputs,
+  type PublicKernelCircuitPrivateInputs,
+  type PublicKernelCircuitPublicInputs,
+  type PublicKernelTailCircuitPrivateInputs,
+} from '@aztec/circuits.js';
+
+/**
+ * Circuit simulator for the public kernel circuits.
+ */
+export interface PublicKernelCircuitSimulator {
+  /**
+   * Simulates the public kernel setup circuit from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  publicKernelCircuitSetup(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
+  /**
+   * 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.
+   */
+  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>;
+  /**
+   * 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<KernelCircuitPublicInputs>;
+}

package/src/public/public_processor.ts

@@ -0,0 +1,212 @@
+import {
+  type BlockProver,
+  type FailedTx,
+  type ProcessedTx,
+  type PublicKernelRequest,
+  type SimulationError,
+  Tx,
+  type TxValidator,
+  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 AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
+import { PhaseManagerFactory } from './phase_manager_factory.js';
+import { ContractsDataSourcePublicDB, WorldStateDB, WorldStatePublicDB } from './public_executor.js';
+import { RealPublicKernelCircuitSimulator } from './public_kernel.js';
+import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.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<ProcessedTx>,
+  ): 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;
+    const publicRequests: PublicKernelRequest[] = [];
+    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;
+      }
+      publicRequests.push(...output.kernelRequests);
+      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, publicRequests, 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];
+  }
+}