@aztec/sequencer-client 0.30.0 → 0.31.0

package/src/block_builder/types.ts

@@ -1,8 +0,0 @@
-/**
- * Type representing the names of the trees for the base rollup.
- */
-type BaseTreeNames = 'NoteHashTree' | 'ContractTree' | 'NullifierTree' | 'PublicDataTree';
-/**
- * Type representing the names of the trees.
- */
-export type TreeNames = BaseTreeNames | 'L1ToL2MessageTree' | 'Archive';

package/src/mocks/verification_keys.ts

@@ -1,36 +0,0 @@
-import { VerificationKey } from '@aztec/circuits.js';
-
-/**
- * Well-known verification keys.
- */
-export interface VerificationKeys {
-  /**
-   * Verification key for the default public kernel circuit.
-   */
-  publicKernelCircuit: VerificationKey;
-  /**
-   * Verification key for the default private kernel circuit.
-   */
-  privateKernelCircuit: VerificationKey;
-  /**
-   * Verification key for the default base rollup circuit.
-   */
-  baseRollupCircuit: VerificationKey;
-  /**
-   * Verification key for the default merge rollup circuit.
-   */
-  mergeRollupCircuit: VerificationKey;
-}
-
-/**
- * Returns mock verification keys for each well known circuit.
- * @returns A VerificationKeys object with fake values.
- */
-export function getVerificationKeys(): VerificationKeys {
-  return {
-    privateKernelCircuit: VerificationKey.makeFake(),
-    baseRollupCircuit: VerificationKey.makeFake(),
-    mergeRollupCircuit: VerificationKey.makeFake(),
-    publicKernelCircuit: VerificationKey.makeFake(),
-  };
-}

package/src/prover/empty.ts

@@ -1,97 +0,0 @@
-/* eslint-disable require-await */
-import {
-  AggregationObject,
-  BaseOrMergeRollupPublicInputs,
-  BaseParityInputs,
-  BaseRollupInputs,
-  MergeRollupInputs,
-  ParityPublicInputs,
-  Proof,
-  PublicCircuitPublicInputs,
-  PublicKernelCircuitPublicInputs,
-  RootParityInputs,
-  RootRollupInputs,
-  RootRollupPublicInputs,
-} from '@aztec/circuits.js';
-
-import { PublicProver, RollupProver } from './index.js';
-
-const EMPTY_PROOF_SIZE = 42;
-
-// TODO: Silently modifying one of the inputs to inject the aggregation object is horrible.
-// We should rethink these interfaces.
-
-/**
- * Prover implementation that returns empty proofs and overrides aggregation objects.
- */
-export class EmptyRollupProver implements RollupProver {
-  /**
-   * Creates an empty proof for the given input.
-   * @param inputs - Inputs to the circuit.
-   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
-   */
-  async getBaseParityProof(inputs: BaseParityInputs, publicInputs: ParityPublicInputs): Promise<Proof> {
-    publicInputs.aggregationObject = AggregationObject.makeFake();
-    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
-  }
-
-  /**
-   * Creates an empty proof for the given input.
-   * @param inputs - Inputs to the circuit.
-   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
-   */
-  async getRootParityProof(inputs: RootParityInputs, publicInputs: ParityPublicInputs): Promise<Proof> {
-    publicInputs.aggregationObject = AggregationObject.makeFake();
-    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
-  }
-
-  /**
-   * Creates an empty proof for the given input.
-   * @param _input - Input to the circuit.
-   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
-   */
-  async getBaseRollupProof(_input: BaseRollupInputs, publicInputs: BaseOrMergeRollupPublicInputs): Promise<Proof> {
-    publicInputs.aggregationObject = AggregationObject.makeFake();
-    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
-  }
-
-  /**
-   * Creates an empty proof for the given input.
-   * @param _input - Input to the circuit.
-   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
-   */
-  async getMergeRollupProof(_input: MergeRollupInputs, publicInputs: BaseOrMergeRollupPublicInputs): Promise<Proof> {
-    publicInputs.aggregationObject = AggregationObject.makeFake();
-    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
-  }
-  /**
-   * Creates an empty proof for the given input.
-   * @param _input - Input to the circuit.
-   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
-   */
-  async getRootRollupProof(_input: RootRollupInputs, publicInputs: RootRollupPublicInputs): Promise<Proof> {
-    publicInputs.aggregationObject = AggregationObject.makeFake();
-    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
-  }
-}
-
-/**
- * Prover implementation that returns empty proofs.
- */
-export class EmptyPublicProver implements PublicProver {
-  /**
-   * Creates an empty proof for the given input.
-   * @param _publicInputs - Public inputs obtained via simulation.
-   */
-  async getPublicCircuitProof(_publicInputs: PublicCircuitPublicInputs): Promise<Proof> {
-    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
-  }
-
-  /**
-   * Creates an empty proof for the given input.
-   * @param _publicInputs - Public inputs obtained via simulation.
-   */
-  async getPublicKernelCircuitProof(_publicInputs: PublicKernelCircuitPublicInputs): Promise<Proof> {
-    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0));
-  }
-}

package/src/prover/index.ts

@@ -1,70 +0,0 @@
-import {
-  BaseOrMergeRollupPublicInputs,
-  BaseParityInputs,
-  BaseRollupInputs,
-  MergeRollupInputs,
-  ParityPublicInputs,
-  Proof,
-  PublicCircuitPublicInputs,
-  PublicKernelCircuitPublicInputs,
-  RootParityInputs,
-  RootRollupInputs,
-  RootRollupPublicInputs,
-} from '@aztec/circuits.js';
-
-/**
- * Generates proofs for parity and rollup circuits.
- */
-export interface RollupProver {
-  /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
-   */
-  getBaseParityProof(inputs: BaseParityInputs, publicInputs: ParityPublicInputs): Promise<Proof>;
-
-  /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
-   */
-  getRootParityProof(inputs: RootParityInputs, publicInputs: ParityPublicInputs): Promise<Proof>;
-
-  /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
-   */
-  getBaseRollupProof(input: BaseRollupInputs, publicInputs: BaseOrMergeRollupPublicInputs): Promise<Proof>;
-
-  /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
-   */
-  getMergeRollupProof(input: MergeRollupInputs, publicInputs: BaseOrMergeRollupPublicInputs): Promise<Proof>;
-
-  /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   * @param publicInputs - Public inputs of the circuit obtained via simulation, modified by this call.
-   */
-  getRootRollupProof(input: RootRollupInputs, publicInputs: RootRollupPublicInputs): Promise<Proof>;
-}
-
-/**
- * Generates proofs for the public and public kernel circuits.
- */
-export interface PublicProver {
-  /**
-   * Creates a proof for the given input.
-   * @param publicInputs - Public inputs obtained via simulation.
-   */
-  getPublicCircuitProof(publicInputs: PublicCircuitPublicInputs): Promise<Proof>;
-
-  /**
-   * Creates a proof for the given input.
-   * @param publicInputs - Public inputs obtained via simulation.
-   */
-  getPublicKernelCircuitProof(publicInputs: PublicKernelCircuitPublicInputs): Promise<Proof>;
-}

package/src/sequencer/processed_tx.ts

@@ -1,210 +0,0 @@
-import { PublicDataWrite, SimulationError, Tx, TxEffect, TxHash, TxL2Logs } from '@aztec/circuit-types';
-import {
-  Fr,
-  Header,
-  MAX_NEW_NOTE_HASHES_PER_TX,
-  MAX_NEW_NULLIFIERS_PER_TX,
-  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  Proof,
-  PublicAccumulatedNonRevertibleData,
-  PublicAccumulatedRevertibleData,
-  PublicKernelCircuitPublicInputs,
-  SideEffect,
-  SideEffectLinkedToNoteHash,
-  ValidationRequests,
-  makeEmptyProof,
-} from '@aztec/circuits.js';
-import { Tuple, fromFieldsTuple } from '@aztec/foundation/serialize';
-
-/**
- * Represents a tx that has been processed by the sequencer public processor,
- * so its kernel circuit public inputs are filled in.
- */
-export type ProcessedTx = Pick<Tx, 'proof' | 'encryptedLogs' | 'unencryptedLogs'> & {
-  /**
-   * Output of the public kernel circuit for this tx.
-   */
-  data: PublicKernelCircuitPublicInputs;
-  /**
-   * Hash of the transaction.
-   */
-  hash: TxHash;
-  /**
-   * 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.
- */
-export type FailedTx = {
-  /**
-   * The failing transaction.
-   */
-  tx: Tx;
-  /**
-   * The error that caused the tx to fail.
-   */
-  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,
-      ValidationRequests.empty(),
-      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,
-  revertReason?: SimulationError,
-): ProcessedTx {
-  const { publicKernelPublicInput, previousProof } = getPreviousOutputAndProof(tx, kernelOutput, proof);
-  return {
-    hash: tx.getTxHash(),
-    data: publicKernelPublicInput,
-    proof: previousProof,
-    encryptedLogs: revertReason ? new TxL2Logs([]) : tx.encryptedLogs,
-    unencryptedLogs: revertReason ? new TxL2Logs([]) : tx.unencryptedLogs,
-    isEmpty: false,
-    revertReason,
-  };
-}
-
-/**
- * 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): ProcessedTx {
-  const emptyKernelOutput = PublicKernelCircuitPublicInputs.empty();
-  emptyKernelOutput.constants.historicalHeader = header;
-  emptyKernelOutput.constants.txContext.chainId = chainId;
-  emptyKernelOutput.constants.txContext.version = version;
-  const emptyProof = makeEmptyProof();
-
-  const hash = new TxHash(Fr.ZERO.toBuffer());
-  return {
-    hash,
-    encryptedLogs: new TxL2Logs([]),
-    unencryptedLogs: new TxL2Logs([]),
-    data: emptyKernelOutput,
-    proof: emptyProof,
-    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.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/simulator/acvm_native.ts

@@ -1,112 +0,0 @@
-import { randomBytes } from '@aztec/foundation/crypto';
-import { NoirCompiledCircuit } from '@aztec/types/noir';
-
-import { WitnessMap } from '@noir-lang/types';
-import * as proc from 'child_process';
-import fs from 'fs/promises';
-
-import { SimulationProvider } from './simulation_provider.js';
-
-/**
- * Parses a TOML format witness map string into a Map structure
- * @param outputString - The witness map in TOML format
- * @returns The parsed witness map
- */
-function parseIntoWitnessMap(outputString: string) {
-  const lines = outputString.split('\n');
-  return new Map<number, string>(
-    lines
-      .filter((line: string) => line.length)
-      .map((line: string) => {
-        const pair = line.replaceAll(' ', '').split('=');
-        return [Number(pair[0]), pair[1].replaceAll('"', '')];
-      }),
-  );
-}
-
-/**
- *
- * @param inputWitness - The circuit's input witness
- * @param bytecode - The circuit buytecode
- * @param workingDirectory - A directory to use for temporary files by the ACVM
- * @param pathToAcvm - The path to the ACVm binary
- * @returns The completed partial witness outputted from the circuit
- */
-export async function executeNativeCircuit(
-  inputWitness: WitnessMap,
-  bytecode: Buffer,
-  workingDirectory: string,
-  pathToAcvm: string,
-) {
-  const bytecodeFilename = 'bytecode';
-  const witnessFilename = 'input_witness.toml';
-
-  // convert the witness map to TOML format
-  let witnessMap = '';
-  inputWitness.forEach((value: string, key: number) => {
-    witnessMap = witnessMap.concat(`${key} = '${value}'\n`);
-  });
-
-  // In case the directory is still around from some time previously, remove it
-  await fs.rm(workingDirectory, { recursive: true, force: true });
-  // Create the new working directory
-  await fs.mkdir(workingDirectory, { recursive: true });
-  // Write the bytecode and input witness to the working directory
-  await fs.writeFile(`${workingDirectory}/${bytecodeFilename}`, bytecode);
-  await fs.writeFile(`${workingDirectory}/${witnessFilename}`, witnessMap);
-
-  // Execute the ACVM using the given args
-  const args = [
-    `execute`,
-    `--working-directory`,
-    `${workingDirectory}`,
-    `--bytecode`,
-    `${bytecodeFilename}`,
-    `--input-witness`,
-    `${witnessFilename}`,
-    `--print`,
-  ];
-  const processPromise = new Promise<string>((resolve, reject) => {
-    let outputWitness = Buffer.alloc(0);
-    let errorBuffer = Buffer.alloc(0);
-    const acvm = proc.spawn(pathToAcvm, args);
-    acvm.stdout.on('data', data => {
-      outputWitness = Buffer.concat([outputWitness, data]);
-    });
-    acvm.stderr.on('data', data => {
-      errorBuffer = Buffer.concat([errorBuffer, data]);
-    });
-    acvm.on('close', code => {
-      if (code === 0) {
-        resolve(outputWitness.toString('utf-8'));
-      } else {
-        reject(errorBuffer.toString('utf-8'));
-      }
-    });
-  });
-
-  try {
-    const output = await processPromise;
-    return parseIntoWitnessMap(output);
-  } finally {
-    // Clean up the working directory before we leave
-    await fs.rm(workingDirectory, { recursive: true, force: true });
-  }
-}
-
-export class NativeACVMSimulator implements SimulationProvider {
-  constructor(private workingDirectory: string, private pathToAcvm: string) {}
-  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
-    // Execute the circuit on those initial witness values
-
-    // Decode the bytecode from base64 since the acvm does not know about base64 encoding
-    const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
-
-    // Provide a unique working directory so we don't get clashes with parallel executions
-    const directory = `${this.workingDirectory}/${randomBytes(32).toString('hex')}`;
-    // Execute the circuit
-    const _witnessMap = await executeNativeCircuit(input, decodedBytecode, directory, this.pathToAcvm);
-
-    return _witnessMap;
-  }
-}

package/src/simulator/acvm_wasm.ts

@@ -1,31 +0,0 @@
-import { NoirCompiledCircuit } from '@aztec/types/noir';
-
-import { WasmBlackBoxFunctionSolver, createBlackBoxSolver, executeCircuitWithBlackBoxSolver } from '@noir-lang/acvm_js';
-import { WitnessMap } from '@noir-lang/types';
-
-import { SimulationProvider } from './simulation_provider.js';
-
-let solver: Promise<WasmBlackBoxFunctionSolver>;
-
-const getSolver = (): Promise<WasmBlackBoxFunctionSolver> => {
-  if (!solver) {
-    solver = createBlackBoxSolver();
-  }
-  return solver;
-};
-
-export class WASMSimulator implements SimulationProvider {
-  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
-    // Execute the circuit on those initial witness values
-    //
-    // Decode the bytecode from base64 since the acvm does not know about base64 encoding
-    const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
-    //
-    // Execute the circuit
-    const _witnessMap = await executeCircuitWithBlackBoxSolver(await getSolver(), decodedBytecode, input, () => {
-      throw Error('unexpected oracle during execution');
-    });
-
-    return _witnessMap;
-  }
-}

package/src/simulator/rollup.ts

@@ -1,127 +0,0 @@
-import { CircuitSimulationStats } from '@aztec/circuit-types/stats';
-import {
-  BaseOrMergeRollupPublicInputs,
-  BaseParityInputs,
-  BaseRollupInputs,
-  MergeRollupInputs,
-  ParityPublicInputs,
-  RootParityInputs,
-  RootRollupInputs,
-  RootRollupPublicInputs,
-} from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
-import { elapsed } from '@aztec/foundation/timer';
-import {
-  BaseParityArtifact,
-  BaseRollupArtifact,
-  MergeRollupArtifact,
-  RootParityArtifact,
-  RootRollupArtifact,
-  convertBaseParityInputsToWitnessMap,
-  convertBaseParityOutputsFromWitnessMap,
-  convertBaseRollupInputsToWitnessMap,
-  convertBaseRollupOutputsFromWitnessMap,
-  convertMergeRollupInputsToWitnessMap,
-  convertMergeRollupOutputsFromWitnessMap,
-  convertRootParityInputsToWitnessMap,
-  convertRootParityOutputsFromWitnessMap,
-  convertRootRollupInputsToWitnessMap,
-  convertRootRollupOutputsFromWitnessMap,
-} from '@aztec/noir-protocol-circuits-types';
-
-import { RollupSimulator, WASMSimulator } from './index.js';
-import { SimulationProvider } from './simulation_provider.js';
-
-/**
- * Implements the rollup circuit simulator.
- */
-export class RealRollupCircuitSimulator implements RollupSimulator {
-  private log = createDebugLogger('aztec:rollup-simulator');
-
-  // Some circuits are so small it is faster to use WASM
-  private wasmSimulator: WASMSimulator = new WASMSimulator();
-
-  constructor(private simulationProvider: SimulationProvider) {}
-
-  /**
-   * Simulates the base parity circuit from its inputs.
-   * @param inputs - Inputs to the circuit.
-   * @returns The public inputs of the parity circuit.
-   */
-  public async baseParityCircuit(inputs: BaseParityInputs): Promise<ParityPublicInputs> {
-    const witnessMap = convertBaseParityInputsToWitnessMap(inputs);
-
-    const witness = await this.simulationProvider.simulateCircuit(witnessMap, BaseParityArtifact);
-
-    const result = convertBaseParityOutputsFromWitnessMap(witness);
-
-    return Promise.resolve(result);
-  }
-
-  /**
-   * Simulates the root parity circuit from its inputs.
-   * @param inputs - Inputs to the circuit.
-   * @returns The public inputs of the parity circuit.
-   */
-  public async rootParityCircuit(inputs: RootParityInputs): Promise<ParityPublicInputs> {
-    const witnessMap = convertRootParityInputsToWitnessMap(inputs);
-
-    const witness = await this.simulationProvider.simulateCircuit(witnessMap, RootParityArtifact);
-
-    const result = convertRootParityOutputsFromWitnessMap(witness);
-
-    return Promise.resolve(result);
-  }
-
-  /**
-   * Simulates the base rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */
-  public async baseRollupCircuit(input: BaseRollupInputs): Promise<BaseOrMergeRollupPublicInputs> {
-    const witnessMap = convertBaseRollupInputsToWitnessMap(input);
-
-    const witness = await this.simulationProvider.simulateCircuit(witnessMap, BaseRollupArtifact);
-
-    const result = convertBaseRollupOutputsFromWitnessMap(witness);
-
-    return Promise.resolve(result);
-  }
-  /**
-   * Simulates the merge rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */
-  public async mergeRollupCircuit(input: MergeRollupInputs): Promise<BaseOrMergeRollupPublicInputs> {
-    const witnessMap = convertMergeRollupInputsToWitnessMap(input);
-
-    const witness = await this.wasmSimulator.simulateCircuit(witnessMap, MergeRollupArtifact);
-
-    const result = convertMergeRollupOutputsFromWitnessMap(witness);
-
-    return result;
-  }
-
-  /**
-   * Simulates the root rollup circuit from its inputs.
-   * @param input - Inputs to the circuit.
-   * @returns The public inputs as outputs of the simulation.
-   */
-  public async rootRollupCircuit(input: RootRollupInputs): Promise<RootRollupPublicInputs> {
-    const witnessMap = convertRootRollupInputsToWitnessMap(input);
-
-    const [duration, witness] = await elapsed(() => this.wasmSimulator.simulateCircuit(witnessMap, RootRollupArtifact));
-
-    const result = convertRootRollupOutputsFromWitnessMap(witness);
-
-    this.log(`Simulated root rollup circuit`, {
-      eventName: 'circuit-simulation',
-      circuitName: 'root-rollup',
-      duration,
-      inputSize: input.toBuffer().length,
-      outputSize: result.toBuffer().length,
-    } satisfies CircuitSimulationStats);
-
-    return result;
-  }
-}