@aztec/simulator 0.61.0 → 0.63.0

package/src/public/enqueued_calls_processor.ts

@@ -1,372 +0,0 @@
-import {
-  type AvmProvingRequest,
-  type MerkleTreeReadOperations,
-  type NestedProcessReturnValues,
-  type ProcessedTx,
-  type PublicExecutionRequest,
-  PublicKernelPhase,
-  type SimulationError,
-  type Tx,
-} from '@aztec/circuit-types';
-import {
-  EnqueuedCallData,
-  Fr,
-  Gas,
-  type GlobalVariables,
-  type Header,
-  type KernelCircuitPublicInputs,
-  NESTED_RECURSIVE_PROOF_LENGTH,
-  type PublicCallRequest,
-  PublicKernelCircuitPrivateInputs,
-  type PublicKernelCircuitPublicInputs,
-  PublicKernelData,
-  type VMCircuitPublicInputs,
-  VerificationKeyData,
-  makeEmptyProof,
-  makeEmptyRecursiveProof,
-} from '@aztec/circuits.js';
-import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
-import { getVKSiblingPath } from '@aztec/noir-protocol-circuits-types';
-
-import { inspect } from 'util';
-
-import { EnqueuedCallSimulator } from './enqueued_call_simulator.js';
-import { type PublicExecutor } from './executor.js';
-import { type WorldStateDB } from './public_db_sources.js';
-import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
-import { PublicKernelTailSimulator } from './public_kernel_tail_simulator.js';
-
-const PhaseIsRevertible: Record<PublicKernelPhase, boolean> = {
-  [PublicKernelPhase.SETUP]: false,
-  [PublicKernelPhase.APP_LOGIC]: true,
-  [PublicKernelPhase.TEARDOWN]: true,
-};
-
-type PublicPhaseResult = {
-  avmProvingRequest: AvmProvingRequest;
-  /** The output of the public kernel circuit simulation for this phase */
-  publicKernelOutput: PublicKernelCircuitPublicInputs;
-  /** Return values of simulating complete callstack */
-  returnValues: NestedProcessReturnValues[];
-  /** Gas used during the execution this phase */
-  gasUsed: Gas;
-  /** Time spent for the execution this phase */
-  durationMs: number;
-  /** Revert reason, if any */
-  revertReason?: SimulationError;
-};
-
-export type ProcessedPhase = {
-  phase: PublicKernelPhase;
-  durationMs: number;
-  revertReason?: SimulationError;
-};
-
-export type TxPublicCallsResult = {
-  avmProvingRequest: AvmProvingRequest;
-  /** The output of the public kernel tail circuit simulation for this tx */
-  tailKernelOutput: KernelCircuitPublicInputs;
-  /** Return values of simulating complete callstack */
-  returnValues: NestedProcessReturnValues[];
-  /** Gas used during the execution this tx */
-  gasUsed: ProcessedTx['gasUsed'];
-  /** Revert reason, if any */
-  revertReason?: SimulationError;
-  processedPhases: ProcessedPhase[];
-};
-
-export class EnqueuedCallsProcessor {
-  private log: DebugLogger;
-
-  constructor(
-    private publicKernelSimulator: PublicKernelCircuitSimulator,
-    private globalVariables: GlobalVariables,
-    private worldStateDB: WorldStateDB,
-    private enqueuedCallSimulator: EnqueuedCallSimulator,
-    private publicKernelTailSimulator: PublicKernelTailSimulator,
-  ) {
-    this.log = createDebugLogger(`aztec:sequencer`);
-  }
-
-  static create(
-    db: MerkleTreeReadOperations,
-    publicExecutor: PublicExecutor,
-    publicKernelSimulator: PublicKernelCircuitSimulator,
-    globalVariables: GlobalVariables,
-    historicalHeader: Header,
-    worldStateDB: WorldStateDB,
-  ) {
-    const enqueuedCallSimulator = new EnqueuedCallSimulator(
-      db,
-      publicExecutor,
-      publicKernelSimulator,
-      globalVariables,
-      historicalHeader,
-    );
-
-    const publicKernelTailSimulator = PublicKernelTailSimulator.create(db, publicKernelSimulator);
-
-    return new EnqueuedCallsProcessor(
-      publicKernelSimulator,
-      globalVariables,
-      worldStateDB,
-      enqueuedCallSimulator,
-      publicKernelTailSimulator,
-    );
-  }
-
-  static getExecutionRequestsByPhase(tx: Tx, phase: PublicKernelPhase): PublicExecutionRequest[] {
-    switch (phase) {
-      case PublicKernelPhase.SETUP:
-        return tx.getNonRevertiblePublicExecutionRequests();
-      case PublicKernelPhase.APP_LOGIC:
-        return tx.getRevertiblePublicExecutionRequests();
-      case PublicKernelPhase.TEARDOWN: {
-        const request = tx.getPublicTeardownExecutionRequest();
-        return request ? [request] : [];
-      }
-      default:
-        throw new Error(`Unknown phase: ${phase}`);
-    }
-  }
-
-  static getCallRequestsByPhase(tx: Tx, phase: PublicKernelPhase): PublicCallRequest[] {
-    switch (phase) {
-      case PublicKernelPhase.SETUP:
-        return tx.data.getNonRevertiblePublicCallRequests();
-      case PublicKernelPhase.APP_LOGIC:
-        return tx.data.getRevertiblePublicCallRequests();
-      case PublicKernelPhase.TEARDOWN: {
-        const request = tx.data.getTeardownPublicCallRequest();
-        return request ? [request] : [];
-      }
-      default:
-        throw new Error(`Unknown phase: ${phase}`);
-    }
-  }
-
-  async process(tx: Tx): Promise<TxPublicCallsResult> {
-    this.log.verbose(`Processing tx ${tx.getTxHash()}`);
-
-    const phases: PublicKernelPhase[] = [
-      PublicKernelPhase.SETUP,
-      PublicKernelPhase.APP_LOGIC,
-      PublicKernelPhase.TEARDOWN,
-    ];
-    const processedPhases: ProcessedPhase[] = [];
-    const gasUsed: ProcessedTx['gasUsed'] = {};
-    let avmProvingRequest: AvmProvingRequest;
-    let publicKernelOutput = tx.data.toPublicKernelCircuitPublicInputs();
-    let isFromPrivate = true;
-    let returnValues: NestedProcessReturnValues[] = [];
-    let revertReason: SimulationError | undefined;
-    for (let i = 0; i < phases.length; i++) {
-      const phase = phases[i];
-      const callRequests = EnqueuedCallsProcessor.getCallRequestsByPhase(tx, phase);
-      if (callRequests.length) {
-        const executionRequests = EnqueuedCallsProcessor.getExecutionRequestsByPhase(tx, phase);
-        const result = await this.processPhase(
-          tx,
-          callRequests,
-          executionRequests,
-          publicKernelOutput,
-          phase,
-          isFromPrivate,
-        ).catch(async err => {
-          await this.worldStateDB.rollbackToCommit();
-          throw err;
-        });
-
-        publicKernelOutput = result.publicKernelOutput;
-        isFromPrivate = false;
-
-        // Propagate only one avmProvingRequest of a function call for now, so that we know it's still provable.
-        // Eventually this will be the proof for the entire public call stack.
-        avmProvingRequest = result.avmProvingRequest;
-        if (phase === PublicKernelPhase.APP_LOGIC) {
-          returnValues = result.returnValues;
-        }
-
-        gasUsed[phase] = result.gasUsed;
-
-        processedPhases.push({
-          phase,
-          durationMs: result.durationMs,
-          revertReason: result.revertReason,
-        });
-
-        revertReason ??= result.revertReason;
-      }
-    }
-
-    const tailKernelOutput = await this.publicKernelTailSimulator.simulate(publicKernelOutput).catch(
-      // the abstract phase manager throws if simulation gives error in non-revertible phase
-      async err => {
-        await this.worldStateDB.rollbackToCommit();
-        throw err;
-      },
-    );
-
-    return {
-      avmProvingRequest: avmProvingRequest!,
-      tailKernelOutput,
-      returnValues,
-      gasUsed,
-      processedPhases,
-      revertReason,
-    };
-  }
-
-  private async processPhase(
-    tx: Tx,
-    callRequests: PublicCallRequest[],
-    executionRequests: PublicExecutionRequest[],
-    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
-    phase: PublicKernelPhase,
-    isFromPrivate: boolean,
-  ): Promise<PublicPhaseResult> {
-    this.log.debug(`Beginning processing in phase ${PublicKernelPhase[phase]} for tx ${tx.getTxHash()}`);
-
-    const phaseTimer = new Timer();
-    const returnValues: NestedProcessReturnValues[] = [];
-    let avmProvingRequest: AvmProvingRequest;
-    let publicKernelOutput = previousPublicKernelOutput;
-    let gasUsed = Gas.empty();
-    let revertReason: SimulationError | undefined;
-    for (let i = callRequests.length - 1; i >= 0 && !revertReason; i--) {
-      const callRequest = callRequests[i];
-      const executionRequest = executionRequests[i];
-
-      // 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?
-      // TODO(#6464): Should we allow emitting contracts in the private setup phase?
-      // if so, this should only add contracts that were deployed during private app logic.
-      await this.worldStateDB.addNewContracts(tx);
-
-      const availableGas = this.getAvailableGas(tx, publicKernelOutput, phase);
-      const transactionFee = this.getTransactionFee(tx, publicKernelOutput, phase);
-
-      const enqueuedCallResult = await this.enqueuedCallSimulator.simulate(
-        callRequest,
-        executionRequest,
-        tx,
-        publicKernelOutput,
-        availableGas,
-        transactionFee,
-        phase,
-      );
-
-      if (enqueuedCallResult.revertReason && !PhaseIsRevertible[phase]) {
-        this.log.debug(
-          `Simulation error on ${executionRequest.callContext.contractAddress}:${executionRequest.callContext.functionSelector} with reason: ${enqueuedCallResult.revertReason}`,
-        );
-        throw enqueuedCallResult.revertReason;
-      }
-
-      avmProvingRequest = enqueuedCallResult.avmProvingRequest;
-      returnValues.push(enqueuedCallResult.returnValues);
-      gasUsed = gasUsed.add(enqueuedCallResult.gasUsed);
-      revertReason ??= enqueuedCallResult.revertReason;
-
-      if (revertReason) {
-        // TODO(#6464): Should we allow emitting contracts in the private setup phase?
-        // if so, this is removing contracts deployed in private setup
-        await this.worldStateDB.removeNewContracts(tx);
-        await this.worldStateDB.rollbackToCheckpoint();
-        tx.filterRevertedLogs(publicKernelOutput);
-      } else {
-        // TODO(#6470): we should be adding contracts deployed in those logs to the publicContractsDB
-        tx.unencryptedLogs.addFunctionLogs([enqueuedCallResult.newUnencryptedLogs]);
-      }
-
-      const output = await this.runMergeKernelCircuit(
-        publicKernelOutput,
-        enqueuedCallResult.kernelOutput,
-        isFromPrivate,
-      );
-      publicKernelOutput = output;
-      isFromPrivate = false;
-    }
-
-    if (phase === PublicKernelPhase.SETUP) {
-      await this.worldStateDB.checkpoint();
-    }
-
-    return {
-      avmProvingRequest: avmProvingRequest!,
-      publicKernelOutput,
-      durationMs: phaseTimer.ms(),
-      gasUsed,
-      returnValues: revertReason ? [] : returnValues,
-      revertReason,
-    };
-  }
-
-  private getAvailableGas(
-    tx: Tx,
-    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
-    phase: PublicKernelPhase,
-  ) {
-    if (phase === PublicKernelPhase.TEARDOWN) {
-      return tx.data.constants.txContext.gasSettings.getTeardownLimits();
-    } else {
-      return tx.data.constants.txContext.gasSettings
-        .getLimits() // No need to subtract teardown limits since they are already included in end.gasUsed
-        .sub(previousPublicKernelOutput.end.gasUsed)
-        .sub(previousPublicKernelOutput.endNonRevertibleData.gasUsed);
-    }
-  }
-
-  private getTransactionFee(
-    tx: Tx,
-    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
-    phase: PublicKernelPhase,
-  ): Fr {
-    if (phase !== PublicKernelPhase.TEARDOWN) {
-      return Fr.ZERO;
-    } else {
-      const gasSettings = tx.data.constants.txContext.gasSettings;
-      const gasFees = this.globalVariables.gasFees;
-      // No need to add teardown limits since they are already included in end.gasUsed
-      const gasUsed = previousPublicKernelOutput.end.gasUsed.add(
-        previousPublicKernelOutput.endNonRevertibleData.gasUsed,
-      );
-      const txFee = gasSettings.inclusionFee.add(gasUsed.computeFee(gasFees));
-      this.log.debug(`Computed tx fee`, { txFee, gasUsed: inspect(gasUsed), gasFees: inspect(gasFees) });
-      return txFee;
-    }
-  }
-
-  private async runMergeKernelCircuit(
-    previousOutput: PublicKernelCircuitPublicInputs,
-    enqueuedCallData: VMCircuitPublicInputs,
-    isFromPrivate: boolean,
-  ): Promise<PublicKernelCircuitPublicInputs> {
-    const previousKernel = this.getPreviousKernelData(previousOutput, isFromPrivate);
-
-    // The proof is not used in simulation.
-    const vmProof = makeEmptyProof();
-    const callData = new EnqueuedCallData(enqueuedCallData, vmProof);
-
-    const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, callData);
-
-    return await this.publicKernelSimulator.publicKernelCircuitMerge(inputs);
-  }
-
-  private getPreviousKernelData(
-    previousOutput: PublicKernelCircuitPublicInputs,
-    _isFromPrivate: boolean,
-  ): PublicKernelData {
-    // The proof is not used in simulation.
-    const proof = makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH);
-
-    const vk = VerificationKeyData.makeFakeHonk();
-    const vkIndex = 0;
-    const siblingPath = getVKSiblingPath(vkIndex);
-
-    return new PublicKernelData(previousOutput, proof, vk, vkIndex, siblingPath);
-  }
-}

package/src/public/hints_builder.ts

@@ -1,168 +0,0 @@
-import { type IndexedTreeId, MerkleTreeId } from '@aztec/circuit-types';
-import {
-  type Fr,
-  L1_TO_L2_MSG_TREE_HEIGHT,
-  MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_TX,
-  MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
-  type MAX_NULLIFIERS_PER_TX,
-  type MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
-  MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-  type MAX_PUBLIC_DATA_READS_PER_TX,
-  type MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  MembershipWitness,
-  NOTE_HASH_TREE_HEIGHT,
-  NULLIFIER_TREE_HEIGHT,
-  type Nullifier,
-  type NullifierLeafPreimage,
-  PUBLIC_DATA_TREE_HEIGHT,
-  type PublicDataRead,
-  type PublicDataTreeLeafPreimage,
-  type PublicDataUpdateRequest,
-  type ScopedReadRequest,
-  type TreeLeafReadRequest,
-  TreeLeafReadRequestHint,
-  buildNullifierNonExistentReadRequestHints,
-  buildPublicDataHint,
-  buildPublicDataHints,
-  buildSiloedNullifierReadRequestHints,
-} from '@aztec/circuits.js';
-import { makeTuple } from '@aztec/foundation/array';
-import { type Tuple } from '@aztec/foundation/serialize';
-import { type IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
-import { type MerkleTreeReadOperations } from '@aztec/world-state';
-
-export class HintsBuilder {
-  constructor(private db: MerkleTreeReadOperations) {}
-
-  async getNoteHashReadRequestsHints(
-    readRequests: Tuple<TreeLeafReadRequest, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
-  ) {
-    return await this.getTreeLeafReadRequestsHints(
-      readRequests,
-      MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
-      NOTE_HASH_TREE_HEIGHT,
-      MerkleTreeId.NOTE_HASH_TREE,
-    );
-  }
-
-  async getNullifierReadRequestHints(
-    nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
-    pendingNullifiers: Tuple<Nullifier, typeof MAX_NULLIFIERS_PER_TX>,
-  ) {
-    return await buildSiloedNullifierReadRequestHints(
-      this,
-      nullifierReadRequests,
-      pendingNullifiers,
-      MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-      MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-    );
-  }
-
-  getNullifierNonExistentReadRequestHints(
-    nullifierNonExistentReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX>,
-    pendingNullifiers: Tuple<Nullifier, typeof MAX_NULLIFIERS_PER_TX>,
-  ) {
-    return buildNullifierNonExistentReadRequestHints(this, nullifierNonExistentReadRequests, pendingNullifiers);
-  }
-
-  async getL1ToL2MsgReadRequestsHints(
-    readRequests: Tuple<TreeLeafReadRequest, typeof MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_TX>,
-  ) {
-    return await this.getTreeLeafReadRequestsHints(
-      readRequests,
-      MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_TX,
-      L1_TO_L2_MSG_TREE_HEIGHT,
-      MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
-    );
-  }
-
-  getPublicDataHints(
-    publicDataReads: Tuple<PublicDataRead, typeof MAX_PUBLIC_DATA_READS_PER_TX>,
-    publicDataUpdateRequests: Tuple<PublicDataUpdateRequest, typeof MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX>,
-  ) {
-    return buildPublicDataHints(this, publicDataReads, publicDataUpdateRequests);
-  }
-
-  getPublicDataHint(dataAction: PublicDataRead | PublicDataUpdateRequest | bigint) {
-    const slot = typeof dataAction === 'bigint' ? dataAction : dataAction.leafSlot.toBigInt();
-    return buildPublicDataHint(this, slot);
-  }
-
-  async getNullifierMembershipWitness(nullifier: Fr) {
-    const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
-    if (index === undefined) {
-      throw new Error(`Cannot find the leaf for nullifier ${nullifier.toBigInt()}.`);
-    }
-
-    return this.getMembershipWitnessWithPreimage<typeof NULLIFIER_TREE_HEIGHT>(
-      MerkleTreeId.NULLIFIER_TREE,
-      NULLIFIER_TREE_HEIGHT,
-      index,
-    );
-  }
-
-  async getLowNullifierMembershipWitness(nullifier: Fr) {
-    const res = await this.db.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
-    if (!res) {
-      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.`);
-    }
-
-    // Should find a way to stop casting IndexedTreeLeafPreimage as NullifierLeafPreimage
-    return this.getMembershipWitnessWithPreimage<typeof NULLIFIER_TREE_HEIGHT, NullifierLeafPreimage>(
-      MerkleTreeId.NULLIFIER_TREE,
-      NULLIFIER_TREE_HEIGHT,
-      index,
-    );
-  }
-
-  async getMatchOrLowPublicDataMembershipWitness(leafSlot: bigint) {
-    const res = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
-    if (!res) {
-      throw new Error(`Cannot find the previous value index for public data ${leafSlot}.`);
-    }
-
-    // Should find a way to stop casting IndexedTreeLeafPreimage as PublicDataTreeLeafPreimage everywhere.
-    return this.getMembershipWitnessWithPreimage<typeof PUBLIC_DATA_TREE_HEIGHT, PublicDataTreeLeafPreimage>(
-      MerkleTreeId.PUBLIC_DATA_TREE,
-      PUBLIC_DATA_TREE_HEIGHT,
-      res.index,
-    );
-  }
-
-  private async getMembershipWitnessWithPreimage<
-    TREE_HEIGHT extends number,
-    LEAF_PREIMAGE extends IndexedTreeLeafPreimage = IndexedTreeLeafPreimage,
-  >(treeId: IndexedTreeId, treeHeight: TREE_HEIGHT, index: bigint) {
-    const siblingPath = await this.db.getSiblingPath<TREE_HEIGHT>(treeId, index);
-    const membershipWitness = new MembershipWitness(treeHeight, index, siblingPath.toTuple());
-
-    const leafPreimage = (await this.db.getLeafPreimage(treeId, index)) as LEAF_PREIMAGE;
-    if (!leafPreimage) {
-      throw new Error(`Cannot find the leaf preimage for tree ${treeId} at index ${index}.`);
-    }
-
-    return { membershipWitness, leafPreimage };
-  }
-
-  private async getTreeLeafReadRequestsHints<N extends number, TREE_HEIGHT extends number>(
-    readRequests: Tuple<TreeLeafReadRequest, N>,
-    size: N,
-    treeHeight: TREE_HEIGHT,
-    treeId: MerkleTreeId,
-  ): Promise<Tuple<TreeLeafReadRequestHint<TREE_HEIGHT>, N>> {
-    const hints = makeTuple(size, () => TreeLeafReadRequestHint.empty(treeHeight));
-    for (let i = 0; i < readRequests.length; i++) {
-      const request = readRequests[i];
-      if (!request.isEmpty()) {
-        const siblingPath = await this.db.getSiblingPath<typeof treeHeight>(treeId, request.leafIndex.toBigInt());
-        hints[i] = new TreeLeafReadRequestHint(treeHeight, siblingPath.toTuple());
-      }
-    }
-    return hints;
-  }
-}

package/src/public/public_kernel.ts

@@ -1,100 +0,0 @@
-import {
-  type KernelCircuitPublicInputs,
-  type PublicKernelCircuitPrivateInputs,
-  type PublicKernelCircuitPublicInputs,
-  type PublicKernelInnerCircuitPrivateInputs,
-  type PublicKernelTailCircuitPrivateInputs,
-  type VMCircuitPublicInputs,
-} from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
-import { elapsed } from '@aztec/foundation/timer';
-import {
-  SimulatedPublicKernelInnerArtifact,
-  SimulatedPublicKernelMergeArtifact,
-  SimulatedPublicKernelTailArtifact,
-  convertSimulatedPublicInnerInputsToWitnessMap,
-  convertSimulatedPublicInnerOutputFromWitnessMap,
-  convertSimulatedPublicMergeInputsToWitnessMap,
-  convertSimulatedPublicMergeOutputFromWitnessMap,
-  convertSimulatedPublicTailInputsToWitnessMap,
-  convertSimulatedPublicTailOutputFromWitnessMap,
-} from '@aztec/noir-protocol-circuits-types';
-
-import { type SimulationProvider } from '../providers/simulation_provider.js';
-import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
-
-/**
- * Implements the PublicKernelCircuitSimulator.
- */
-export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimulator {
-  private log = createDebugLogger('aztec:public-kernel-simulator');
-
-  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 publicKernelCircuitInner(input: PublicKernelInnerCircuitPrivateInputs): Promise<VMCircuitPublicInputs> {
-    const inputWitness = convertSimulatedPublicInnerInputsToWitnessMap(input);
-    const [duration, witness] = await elapsed(() =>
-      this.simulator.simulateCircuit(inputWitness, SimulatedPublicKernelInnerArtifact),
-    );
-    const result = convertSimulatedPublicInnerOutputFromWitnessMap(witness);
-    this.log.debug(`Simulated public kernel inner circuit`, {
-      eventName: 'circuit-simulation',
-      circuitName: 'public-kernel-inner',
-      duration,
-      inputSize: input.toBuffer().length,
-      outputSize: result.toBuffer().length,
-    });
-    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 publicKernelCircuitMerge(
-    input: PublicKernelCircuitPrivateInputs,
-  ): Promise<PublicKernelCircuitPublicInputs> {
-    const inputWitness = convertSimulatedPublicMergeInputsToWitnessMap(input);
-    const [duration, witness] = await elapsed(() =>
-      this.simulator.simulateCircuit(inputWitness, SimulatedPublicKernelMergeArtifact),
-    );
-    const result = convertSimulatedPublicMergeOutputFromWitnessMap(witness);
-    this.log.debug(`Simulated public kernel merge circuit`, {
-      eventName: 'circuit-simulation',
-      circuitName: 'public-kernel-merge',
-      duration,
-      inputSize: input.toBuffer().length,
-      outputSize: result.toBuffer().length,
-    });
-    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 = convertSimulatedPublicTailInputsToWitnessMap(input);
-    const [duration, witness] = await elapsed(() =>
-      this.simulator.simulateCircuit(inputWitness, SimulatedPublicKernelTailArtifact),
-    );
-    const result = convertSimulatedPublicTailOutputFromWitnessMap(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,
-    });
-    return result;
-  }
-}

package/src/public/public_kernel_circuit_simulator.ts

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