@aztec/simulator 0.33.0 → 0.35.0

package/src/public/public_execution_context.ts

@@ -1,8 +1,4 @@
-import {
-  type NullifierMembershipWitness,
-  UnencryptedFunctionL2Logs,
-  type UnencryptedL2Log,
-} from '@aztec/circuit-types';
+import { UnencryptedFunctionL2Logs, type UnencryptedL2Log } from '@aztec/circuit-types';
 import {
   CallContext,
   FunctionData,
@@ -17,7 +13,7 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { type ContractInstance } from '@aztec/types/contracts';
 
 import { TypedOracle, toACVMWitness } from '../acvm/index.js';
-import { type PackedArgsCache, type SideEffectCounter } from '../common/index.js';
+import { type PackedValuesCache, type SideEffectCounter } from '../common/index.js';
 import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from './db.js';
 import { type PublicExecution, type PublicExecutionResult, checkValidStaticCall } from './execution.js';
 import { executePublicFunction } from './executor.js';
@@ -36,13 +32,13 @@ export class PublicExecutionContext extends TypedOracle {
      * Data for this execution.
      */
     public readonly execution: PublicExecution,
-    private readonly header: Header,
-    private readonly globalVariables: GlobalVariables,
-    private readonly packedArgsCache: PackedArgsCache,
+    public readonly header: Header,
+    public readonly globalVariables: GlobalVariables,
+    private readonly packedValuesCache: PackedValuesCache,
     private readonly sideEffectCounter: SideEffectCounter,
-    private readonly stateDb: PublicStateDB,
-    private readonly contractsDb: PublicContractsDB,
-    private readonly commitmentsDb: CommitmentsDB,
+    public readonly stateDb: PublicStateDB,
+    public readonly contractsDb: PublicContractsDB,
+    public readonly commitmentsDb: CommitmentsDB,
     private log = createDebugLogger('aztec:simulator:public_execution_context'),
   ) {
     super();
@@ -98,7 +94,23 @@ export class PublicExecutionContext extends TypedOracle {
    * @param args - Arguments to pack
    */
   public packArguments(args: Fr[]): Promise<Fr> {
-    return Promise.resolve(this.packedArgsCache.pack(args));
+    return Promise.resolve(this.packedValuesCache.pack(args));
+  }
+
+  /**
+   * Pack the given returns.
+   * @param returns - Returns to pack
+   */
+  public packReturns(returns: Fr[]): Promise<Fr> {
+    return Promise.resolve(this.packedValuesCache.pack(returns));
+  }
+
+  /**
+   * Unpack the given returns.
+   * @param returnsHash - Returns hash to unpack
+   */
+  public unpackReturns(returnsHash: Fr): Promise<Fr[]> {
+    return Promise.resolve(this.packedValuesCache.unpack(returnsHash));
   }
 
   /**
@@ -120,7 +132,7 @@ export class PublicExecutionContext extends TypedOracle {
   public emitUnencryptedLog(log: UnencryptedL2Log) {
     // TODO(https://github.com/AztecProtocol/aztec-packages/issues/885)
     this.unencryptedLogs.push(log);
-    this.log(`Emitted unencrypted log: "${log.toHumanReadable()}"`);
+    this.log.verbose(`Emitted unencrypted log: "${log.toHumanReadable()}"`);
   }
 
   /**
@@ -144,7 +156,7 @@ export class PublicExecutionContext extends TypedOracle {
       const storageSlot = new Fr(startStorageSlot.value + BigInt(i));
       const sideEffectCounter = this.sideEffectCounter.count();
       const value = await this.storageActions.read(storageSlot, sideEffectCounter);
-      this.log(`Oracle storage read: slot=${storageSlot.toString()} value=${value.toString()}`);
+      this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value.toString()}`);
       values.push(value);
     }
     return values;
@@ -163,7 +175,7 @@ export class PublicExecutionContext extends TypedOracle {
       const sideEffectCounter = this.sideEffectCounter.count();
       this.storageActions.write(storageSlot, newValue, sideEffectCounter);
       await this.stateDb.storageWrite(this.execution.callContext.storageContractAddress, storageSlot, newValue);
-      this.log(`Oracle storage write: slot=${storageSlot.toString()} value=${newValue.toString()}`);
+      this.log.debug(`Oracle storage write: slot=${storageSlot.toString()} value=${newValue.toString()}`);
       newValues.push(newValue);
     }
     return newValues;
@@ -186,26 +198,25 @@ export class PublicExecutionContext extends TypedOracle {
   ) {
     isStaticCall = isStaticCall || this.execution.callContext.isStaticCall;
 
-    const args = this.packedArgsCache.unpack(argsHash);
-    this.log(`Public function call: addr=${targetContractAddress} selector=${functionSelector} args=${args.join(',')}`);
+    const args = this.packedValuesCache.unpack(argsHash);
+    this.log.verbose(
+      `Public function call: addr=${targetContractAddress} selector=${functionSelector} args=${args.join(',')}`,
+    );
 
     const portalAddress = (await this.contractsDb.getPortalContractAddress(targetContractAddress)) ?? EthAddress.ZERO;
-
-    const acir = await this.contractsDb.getBytecode(targetContractAddress, functionSelector);
-    if (!acir) {
-      throw new Error(`Bytecode not found for ${targetContractAddress}:${functionSelector}`);
-    }
-
-    const functionData = new FunctionData(functionSelector, false);
-
+    const functionData = new FunctionData(functionSelector, /*isPrivate=*/ false);
+    const { transactionFee, gasSettings, gasLeft } = this.execution.callContext;
     const callContext = CallContext.from({
       msgSender: isDelegateCall ? this.execution.callContext.msgSender : this.execution.contractAddress,
       storageContractAddress: isDelegateCall ? this.execution.contractAddress : targetContractAddress,
       portalContractAddress: portalAddress,
       functionSelector,
+      gasLeft, // Propagate the same gas left as when we started since ACVM public functions don't have any metering
       isDelegateCall,
       isStaticCall,
       sideEffectCounter,
+      gasSettings,
+      transactionFee,
     });
 
     const nestedExecution: PublicExecution = {
@@ -219,7 +230,7 @@ export class PublicExecutionContext extends TypedOracle {
       nestedExecution,
       this.header,
       this.globalVariables,
-      this.packedArgsCache,
+      this.packedValuesCache,
       this.sideEffectCounter,
       this.stateDb,
       this.contractsDb,
@@ -227,7 +238,7 @@ export class PublicExecutionContext extends TypedOracle {
       this.log,
     );
 
-    const childExecutionResult = await executePublicFunction(context, acir, true /** nested */);
+    const childExecutionResult = await executePublicFunction(context, /*nested=*/ true);
 
     if (isStaticCall) {
       checkValidStaticCall(
@@ -240,19 +251,14 @@ export class PublicExecutionContext extends TypedOracle {
     }
 
     this.nestedExecutions.push(childExecutionResult);
-    this.log(`Returning from nested call: ret=${childExecutionResult.returnValues.join(', ')}`);
+    this.log.debug(`Returning from nested call: ret=${childExecutionResult.returnValues.join(', ')}`);
 
     return childExecutionResult.returnValues;
   }
 
-  public async getNullifierMembershipWitness(
-    blockNumber: number,
-    nullifier: Fr,
-  ): Promise<NullifierMembershipWitness | undefined> {
-    if (!this.header.globalVariables.blockNumber.equals(new Fr(blockNumber))) {
-      throw new Error(`Public execution oracle can only access nullifier membership witnesses for the current block`);
-    }
-    return await this.commitmentsDb.getNullifierMembershipWitnessAtLatestBlock(nullifier);
+  public async checkNullifierExists(nullifier: Fr): Promise<boolean> {
+    const witness = await this.commitmentsDb.getNullifierMembershipWitnessAtLatestBlock(nullifier);
+    return !!witness;
   }
 
   public async getContractInstance(address: AztecAddress): Promise<ContractInstance> {

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>;
+}