@aztec/simulator 0.55.1 → 0.56.0

package/src/public/public_db_sources.ts

@@ -38,7 +38,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
 
   private log = createDebugLogger('aztec:sequencer:contracts-data-source');
 
-  constructor(private db: ContractDataSource) {}
+  constructor(private dataSource: ContractDataSource) {}
 
   /**
    * Add new contracts from a transaction
@@ -78,11 +78,11 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
   }
 
   public async getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    return this.instanceCache.get(address.toString()) ?? (await this.db.getContract(address));
+    return this.instanceCache.get(address.toString()) ?? (await this.dataSource.getContract(address));
   }
 
   public async getContractClass(contractClassId: Fr): Promise<ContractClassPublic | undefined> {
-    return this.classCache.get(contractClassId.toString()) ?? (await this.db.getContractClass(contractClassId));
+    return this.classCache.get(contractClassId.toString()) ?? (await this.dataSource.getContractClass(contractClassId));
   }
 
   async getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
@@ -98,7 +98,7 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
   }
 
   public async getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
-    const artifact = await this.db.getContractArtifact(address);
+    const artifact = await this.dataSource.getContractArtifact(address);
     if (!artifact) {
       return Promise.resolve(undefined);
     }
@@ -115,14 +115,18 @@ export class ContractsDataSourcePublicDB implements PublicContractsDB {
 }
 
 /**
- * Implements the PublicStateDB using a world-state database.
+ * A public state DB that reads and writes to the world state.
  */
-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();
+export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicStateDB, CommitmentsDB {
+  private logger = createDebugLogger('aztec:sequencer:world-state-db');
 
-  constructor(private db: MerkleTreeOperations) {}
+  private publicCommittedWriteCache: Map<bigint, Fr> = new Map();
+  private publicCheckpointedWriteCache: Map<bigint, Fr> = new Map();
+  private publicUncommittedWriteCache: Map<bigint, Fr> = new Map();
+
+  constructor(private db: MerkleTreeOperations, dataSource: ContractDataSource) {
+    super(dataSource);
+  }
 
   /**
    * Reads a value from public storage, returning zero if none.
@@ -132,15 +136,15 @@ export class WorldStatePublicDB implements PublicStateDB {
    */
   public async storageRead(contract: AztecAddress, slot: Fr): Promise<Fr> {
     const leafSlot = computePublicDataTreeLeafSlot(contract, slot).value;
-    const uncommitted = this.uncommittedWriteCache.get(leafSlot);
+    const uncommitted = this.publicUncommittedWriteCache.get(leafSlot);
     if (uncommitted !== undefined) {
       return uncommitted;
     }
-    const checkpointed = this.checkpointedWriteCache.get(leafSlot);
+    const checkpointed = this.publicCheckpointedWriteCache.get(leafSlot);
     if (checkpointed !== undefined) {
       return checkpointed;
     }
-    const committed = this.committedWriteCache.get(leafSlot);
+    const committed = this.publicCommittedWriteCache.get(leafSlot);
     if (committed !== undefined) {
       return committed;
     }
@@ -167,57 +171,10 @@ export class WorldStatePublicDB implements PublicStateDB {
    */
   public storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<bigint> {
     const index = computePublicDataTreeLeafSlot(contract, slot).value;
-    this.uncommittedWriteCache.set(index, newValue);
+    this.publicUncommittedWriteCache.set(index, newValue);
     return Promise.resolve(index);
   }
 
-  /**
-   * 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 {
-  private log = createDebugLogger('aztec:sequencer:world-state-db');
-
-  constructor(private db: MerkleTreeOperations) {}
-
   public async getNullifierMembershipWitnessAtLatestBlock(
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
@@ -239,7 +196,7 @@ export class WorldStateDB implements CommitmentsDB {
       return undefined;
     }
 
-    this.log.debug(`[DB] Fetched nullifier membership`, {
+    this.logger.debug(`[DB] Fetched nullifier membership`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
       operation: 'get-nullifier-membership-witness-at-latest-block',
@@ -277,7 +234,7 @@ export class WorldStateDB implements CommitmentsDB {
       messageIndex,
     );
 
-    this.log.debug(`[DB] Fetched L1 to L2 message membership`, {
+    this.logger.debug(`[DB] Fetched L1 to L2 message membership`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
       operation: 'get-l1-to-l2-message-membership-witness',
@@ -289,7 +246,7 @@ export class WorldStateDB implements CommitmentsDB {
   public async getL1ToL2LeafValue(leafIndex: bigint): Promise<Fr | undefined> {
     const timer = new Timer();
     const leafValue = await this.db.getLeafValue(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
-    this.log.debug(`[DB] Fetched L1 to L2 message leaf value`, {
+    this.logger.debug(`[DB] Fetched L1 to L2 message leaf value`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
       operation: 'get-l1-to-l2-message-leaf-value',
@@ -300,7 +257,7 @@ export class WorldStateDB implements CommitmentsDB {
   public async getCommitmentIndex(commitment: Fr): Promise<bigint | undefined> {
     const timer = new Timer();
     const index = await this.db.findLeafIndex(MerkleTreeId.NOTE_HASH_TREE, commitment);
-    this.log.debug(`[DB] Fetched commitment index`, {
+    this.logger.debug(`[DB] Fetched commitment index`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
       operation: 'get-commitment-index',
@@ -311,7 +268,7 @@ export class WorldStateDB implements CommitmentsDB {
   public async getCommitmentValue(leafIndex: bigint): Promise<Fr | undefined> {
     const timer = new Timer();
     const leafValue = await this.db.getLeafValue(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
-    this.log.debug(`[DB] Fetched commitment leaf value`, {
+    this.logger.debug(`[DB] Fetched commitment leaf value`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
       operation: 'get-commitment-leaf-value',
@@ -322,11 +279,49 @@ export class WorldStateDB implements CommitmentsDB {
   public async getNullifierIndex(nullifier: Fr): Promise<bigint | undefined> {
     const timer = new Timer();
     const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
-    this.log.debug(`[DB] Fetched nullifier index`, {
+    this.logger.debug(`[DB] Fetched nullifier index`, {
       eventName: 'public-db-access',
       duration: timer.ms(),
       operation: 'get-nullifier-index',
     } satisfies PublicDBAccessStats);
     return index;
   }
+
+  /**
+   * Commit the pending public changes to the DB.
+   * @returns Nothing.
+   */
+  commit(): Promise<void> {
+    for (const [k, v] of this.publicCheckpointedWriteCache) {
+      this.publicCommittedWriteCache.set(k, v);
+    }
+    // uncommitted writes take precedence over checkpointed writes
+    // since they are the most recent
+    for (const [k, v] of this.publicUncommittedWriteCache) {
+      this.publicCommittedWriteCache.set(k, v);
+    }
+    return this.rollbackToCommit();
+  }
+
+  /**
+   * Rollback the pending public changes.
+   * @returns Nothing.
+   */
+  async rollbackToCommit(): Promise<void> {
+    await this.rollbackToCheckpoint();
+    this.publicCheckpointedWriteCache = new Map<bigint, Fr>();
+    return Promise.resolve();
+  }
+
+  checkpoint(): Promise<void> {
+    for (const [k, v] of this.publicUncommittedWriteCache) {
+      this.publicCheckpointedWriteCache.set(k, v);
+    }
+    return this.rollbackToCheckpoint();
+  }
+
+  rollbackToCheckpoint(): Promise<void> {
+    this.publicUncommittedWriteCache = new Map<bigint, Fr>();
+    return Promise.resolve();
+  }
 }

package/src/public/public_kernel.ts

@@ -3,7 +3,9 @@ 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';
@@ -11,12 +13,10 @@ import {
   SimulatedServerCircuitArtifacts,
   convertSimulatedPublicInnerInputsToWitnessMap,
   convertSimulatedPublicInnerOutputFromWitnessMap,
-  convertSimulatedPublicSetupInputsToWitnessMap,
-  convertSimulatedPublicSetupOutputFromWitnessMap,
+  convertSimulatedPublicMergeInputsToWitnessMap,
+  convertSimulatedPublicMergeOutputFromWitnessMap,
   convertSimulatedPublicTailInputsToWitnessMap,
   convertSimulatedPublicTailOutputFromWitnessMap,
-  convertSimulatedPublicTeardownInputsToWitnessMap,
-  convertSimulatedPublicTeardownOutputFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
 
 import { WASMSimulator } from '../providers/acvm_wasm.js';
@@ -39,46 +39,15 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
    * @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 = convertSimulatedPublicSetupInputsToWitnessMap(input);
-    const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedServerCircuitArtifacts.PublicKernelSetupArtifact),
-    );
-    const result = convertSimulatedPublicSetupOutputFromWitnessMap(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`);
-    }
+  public async publicKernelCircuitInner(input: PublicKernelInnerCircuitPrivateInputs): Promise<VMCircuitPublicInputs> {
     const inputWitness = convertSimulatedPublicInnerInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedServerCircuitArtifacts.PublicKernelAppLogicArtifact),
+      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedServerCircuitArtifacts.PublicKernelInnerArtifact),
     );
     const result = convertSimulatedPublicInnerOutputFromWitnessMap(witness);
-    this.log.debug(`Simulated public kernel app logic circuit`, {
+    this.log.debug(`Simulated public kernel inner circuit`, {
       eventName: 'circuit-simulation',
-      circuitName: 'public-kernel-app-logic',
+      circuitName: 'public-kernel-inner',
       duration,
       inputSize: input.toBuffer().length,
       outputSize: result.toBuffer().length,
@@ -87,24 +56,21 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
   }
 
   /**
-   * Simulates the public kernel teardown circuit from its inputs.
+   * 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 publicKernelCircuitTeardown(
+  public async publicKernelCircuitMerge(
     input: PublicKernelCircuitPrivateInputs,
   ): Promise<PublicKernelCircuitPublicInputs> {
-    if (!input.previousKernel.publicInputs.needsTeardown) {
-      throw new Error(`Expected previous kernel inputs to need teardown`);
-    }
-    const inputWitness = convertSimulatedPublicTeardownInputsToWitnessMap(input);
+    const inputWitness = convertSimulatedPublicMergeInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedServerCircuitArtifacts.PublicKernelTeardownArtifact),
+      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedServerCircuitArtifacts.PublicKernelMergeArtifact),
     );
-    const result = convertSimulatedPublicTeardownOutputFromWitnessMap(witness);
-    this.log.debug(`Simulated public kernel teardown circuit`, {
+    const result = convertSimulatedPublicMergeOutputFromWitnessMap(witness);
+    this.log.debug(`Simulated public kernel merge circuit`, {
       eventName: 'circuit-simulation',
-      circuitName: 'public-kernel-teardown',
+      circuitName: 'public-kernel-merge',
       duration,
       inputSize: input.toBuffer().length,
       outputSize: result.toBuffer().length,

package/src/public/public_kernel_circuit_simulator.ts

@@ -2,7 +2,9 @@ import {
   type KernelCircuitPublicInputs,
   type PublicKernelCircuitPrivateInputs,
   type PublicKernelCircuitPublicInputs,
+  type PublicKernelInnerCircuitPrivateInputs,
   type PublicKernelTailCircuitPrivateInputs,
+  type VMCircuitPublicInputs,
 } from '@aztec/circuits.js';
 
 /**
@@ -10,23 +12,17 @@ import {
  */
 export interface PublicKernelCircuitSimulator {
   /**
-   * Simulates the public kernel setup circuit from its inputs.
+   * Simulates the public kernel inner circuit from its inputs.
    * @param inputs - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
-  publicKernelCircuitSetup(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
+  publicKernelCircuitInner(inputs: PublicKernelInnerCircuitPrivateInputs): Promise<VMCircuitPublicInputs>;
   /**
-   * Simulates the public kernel app logic circuit from its inputs.
+   * Simulates the public kernel merge 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>;
+  publicKernelCircuitMerge(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
   /**
    * Simulates the public kernel tail circuit from its inputs.
    * @param inputs - Inputs to the circuit.

package/src/public/public_kernel_tail_simulator.ts

@@ -0,0 +1,106 @@
+import { ProvingRequestType, type PublicKernelTailRequest } from '@aztec/circuit-types';
+import {
+  type KernelCircuitPublicInputs,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  NESTED_RECURSIVE_PROOF_LENGTH,
+  type PublicKernelCircuitPublicInputs,
+  PublicKernelData,
+  PublicKernelTailCircuitPrivateInputs,
+  makeEmptyRecursiveProof,
+  mergeAccumulatedData,
+} from '@aztec/circuits.js';
+import { ProtocolCircuitVks, getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types';
+import { type MerkleTreeOperations } from '@aztec/world-state';
+
+import { HintsBuilder } from './hints_builder.js';
+import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
+
+export class PublicKernelTailSimulator {
+  constructor(
+    private db: MerkleTreeOperations,
+    private publicKernelSimulator: PublicKernelCircuitSimulator,
+    private hintsBuilder: HintsBuilder,
+  ) {}
+
+  static create(db: MerkleTreeOperations, publicKernelSimulator: PublicKernelCircuitSimulator) {
+    const hintsBuilder = new HintsBuilder(db);
+    return new PublicKernelTailSimulator(db, publicKernelSimulator, hintsBuilder);
+  }
+
+  async simulate(
+    previousOutput: PublicKernelCircuitPublicInputs,
+  ): Promise<{ output: KernelCircuitPublicInputs; provingRequest: PublicKernelTailRequest }> {
+    const inputs = await this.buildPrivateInputs(previousOutput);
+
+    const output = await this.publicKernelSimulator.publicKernelCircuitTail(inputs);
+
+    const provingRequest: PublicKernelTailRequest = {
+      type: ProvingRequestType.PUBLIC_KERNEL_TAIL,
+      inputs,
+    };
+
+    return { output, provingRequest };
+  }
+
+  private async buildPrivateInputs(previousOutput: PublicKernelCircuitPublicInputs) {
+    const previousKernel = this.getPreviousKernelData(previousOutput);
+
+    const { validationRequests, endNonRevertibleData: nonRevertibleData, end: revertibleData } = previousOutput;
+
+    const noteHashReadRequestHints = await this.hintsBuilder.getNoteHashReadRequestsHints(
+      validationRequests.noteHashReadRequests,
+    );
+
+    const pendingNullifiers = mergeAccumulatedData(
+      nonRevertibleData.nullifiers,
+      revertibleData.nullifiers,
+      MAX_NULLIFIERS_PER_TX,
+    );
+
+    const nullifierReadRequestHints = await this.hintsBuilder.getNullifierReadRequestHints(
+      validationRequests.nullifierReadRequests,
+      pendingNullifiers,
+    );
+
+    const nullifierNonExistentReadRequestHints = await this.hintsBuilder.getNullifierNonExistentReadRequestHints(
+      validationRequests.nullifierNonExistentReadRequests,
+      pendingNullifiers,
+    );
+
+    const l1ToL2MsgReadRequestHints = await this.hintsBuilder.getL1ToL2MsgReadRequestsHints(
+      validationRequests.l1ToL2MsgReadRequests,
+    );
+
+    const pendingPublicDataWrites = mergeAccumulatedData(
+      nonRevertibleData.publicDataUpdateRequests,
+      revertibleData.publicDataUpdateRequests,
+      MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+    );
+
+    const publicDataHints = await this.hintsBuilder.getPublicDataHints(
+      validationRequests.publicDataReads,
+      pendingPublicDataWrites,
+    );
+
+    const currentState = await this.db.getStateReference();
+
+    return new PublicKernelTailCircuitPrivateInputs(
+      previousKernel,
+      noteHashReadRequestHints,
+      nullifierReadRequestHints,
+      nullifierNonExistentReadRequestHints,
+      l1ToL2MsgReadRequestHints,
+      publicDataHints,
+      currentState.partial,
+    );
+  }
+
+  private getPreviousKernelData(previousOutput: PublicKernelCircuitPublicInputs): PublicKernelData {
+    const proof = makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH);
+    const vk = ProtocolCircuitVks.PublicKernelMergeArtifact;
+    const vkIndex = getVKIndex(vk);
+    const siblingPath = getVKSiblingPath(vkIndex);
+    return new PublicKernelData(previousOutput, proof, vk, vkIndex, siblingPath);
+  }
+}