@aztec/sequencer-client 0.22.0 → 0.24.0

package/src/simulator/index.ts

@@ -0,0 +1,53 @@
+import {
+  BaseOrMergeRollupPublicInputs,
+  BaseRollupInputs,
+  MergeRollupInputs,
+  PublicKernelCircuitPrivateInputs,
+  PublicKernelCircuitPublicInputs,
+  RootRollupInputs,
+  RootRollupPublicInputs,
+} from '@aztec/circuits.js';
+
+/**
+ * Circuit simulator for the rollup circuits.
+ */
+export interface RollupSimulator {
+  /**
+   * Simulates the base rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  baseRollupCircuit(input: BaseRollupInputs): Promise<BaseOrMergeRollupPublicInputs>;
+  /**
+   * Simulates the merge rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  mergeRollupCircuit(input: MergeRollupInputs): Promise<BaseOrMergeRollupPublicInputs>;
+  /**
+   * Simulates the root rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  rootRollupCircuit(input: RootRollupInputs): Promise<RootRollupPublicInputs>;
+}
+
+/**
+ * Circuit simulator for the public kernel circuits.
+ */
+export interface PublicKernelCircuitSimulator {
+  /**
+   * Simulates the public kernel circuit (with a previous private kernel circuit run) from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  publicKernelCircuitPrivateInput(inputs: PublicKernelCircuitPrivateInputs): Promise<PublicKernelCircuitPublicInputs>;
+  /**
+   * Simulates the public kernel circuit (with no previous public kernel circuit run) from its inputs.
+   * @param inputs - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  publicKernelCircuitNonFirstIteration(
+    inputs: PublicKernelCircuitPrivateInputs,
+  ): Promise<PublicKernelCircuitPublicInputs>;
+}

package/src/simulator/public_executor.ts

@@ -0,0 +1,169 @@
+import { ContractDataSource, ExtendedContractData, L1ToL2MessageSource, MerkleTreeId, Tx } from '@aztec/circuit-types';
+import {
+  AztecAddress,
+  EthAddress,
+  Fr,
+  FunctionSelector,
+  L1_TO_L2_MSG_TREE_HEIGHT,
+  PublicDataTreeLeafPreimage,
+} from '@aztec/circuits.js';
+import { computePublicDataTreeLeafSlot } from '@aztec/circuits.js/abis';
+import { CommitmentsDB, MessageLoadOracleInputs, PublicContractsDB, PublicStateDB } from '@aztec/simulator';
+import { 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 {
+  cache = new Map<string, ExtendedContractData>();
+
+  constructor(private db: ContractDataSource) {}
+
+  /**
+   * Add new contracts from a transaction
+   * @param tx - The transaction to add contracts from.
+   */
+  public addNewContracts(tx: Tx): Promise<void> {
+    for (const contract of tx.newContracts) {
+      const contractAddress = contract.contractData.contractAddress;
+
+      if (contractAddress.isZero()) {
+        continue;
+      }
+
+      this.cache.set(contractAddress.toString(), contract);
+    }
+
+    return Promise.resolve();
+  }
+
+  /**
+   * Removes new contracts added from transactions
+   * @param tx - The tx's contracts to be removed
+   */
+  public removeNewContracts(tx: Tx): Promise<void> {
+    for (const contract of tx.newContracts) {
+      const contractAddress = contract.contractData.contractAddress;
+
+      if (contractAddress.isZero()) {
+        continue;
+      }
+
+      this.cache.delete(contractAddress.toString());
+    }
+    return Promise.resolve();
+  }
+
+  async getBytecode(address: AztecAddress, selector: FunctionSelector): Promise<Buffer | undefined> {
+    const contract = await this.#getContract(address);
+    return contract?.getPublicFunction(selector)?.bytecode;
+  }
+  async getIsInternal(address: AztecAddress, selector: FunctionSelector): Promise<boolean | undefined> {
+    const contract = await this.#getContract(address);
+    return contract?.getPublicFunction(selector)?.isInternal;
+  }
+  async getPortalContractAddress(address: AztecAddress): Promise<EthAddress | undefined> {
+    const contract = await this.#getContract(address);
+    return contract?.contractData.portalContractAddress;
+  }
+
+  async #getContract(address: AztecAddress): Promise<ExtendedContractData | undefined> {
+    return this.cache.get(address.toString()) ?? (await this.db.getExtendedContractData(address));
+  }
+}
+
+/**
+ * Implements the PublicStateDB using a world-state database.
+ */
+export class WorldStatePublicDB implements PublicStateDB {
+  private commitedWriteCache: Map<bigint, Fr> = new Map();
+  private uncommitedWriteCache: 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 uncommited = this.uncommitedWriteCache.get(leafSlot);
+    if (uncommited !== undefined) {
+      return uncommited;
+    }
+    const commited = this.commitedWriteCache.get(leafSlot);
+    if (commited !== undefined) {
+      return commited;
+    }
+
+    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.uncommitedWriteCache.set(index, newValue);
+    return Promise.resolve();
+  }
+
+  /**
+   * Commit the pending changes to the DB.
+   * @returns Nothing.
+   */
+  commit(): Promise<void> {
+    for (const [k, v] of this.uncommitedWriteCache) {
+      this.commitedWriteCache.set(k, v);
+    }
+    return this.rollback();
+  }
+
+  /**
+   * Rollback the pending changes.
+   * @returns Nothing.
+   */
+  rollback(): Promise<void> {
+    this.uncommitedWriteCache = new Map<bigint, Fr>();
+    return Promise.resolve();
+  }
+}
+
+/**
+ * Implements WorldState db using a world state database.
+ */
+export class WorldStateDB implements CommitmentsDB {
+  constructor(private db: MerkleTreeOperations, private l1ToL2MessageSource: L1ToL2MessageSource) {}
+
+  public async getL1ToL2Message(messageKey: Fr): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
+    // todo: #697 - make this one lookup.
+    const message = await this.l1ToL2MessageSource.getConfirmedL1ToL2Message(messageKey);
+    const index = (await this.db.findLeafIndex(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, messageKey.toBuffer()))!;
+    const siblingPath = await this.db.getSiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>(
+      MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
+      index,
+    );
+
+    return new MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>(message, index, siblingPath);
+  }
+
+  public async getCommitmentIndex(commitment: Fr): Promise<bigint | undefined> {
+    return await this.db.findLeafIndex(MerkleTreeId.NOTE_HASH_TREE, commitment.toBuffer());
+  }
+}

package/src/simulator/public_kernel.ts

@@ -0,0 +1,58 @@
+import { CircuitSimulationStats } from '@aztec/circuit-types/stats';
+import { PublicKernelCircuitPrivateInputs, PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { elapsed } from '@aztec/foundation/timer';
+import { executePublicKernelAppLogic, executePublicKernelSetup } from '@aztec/noir-protocol-circuits-types';
+
+import { PublicKernelCircuitSimulator } from './index.js';
+
+/**
+ * Implements the PublicKernelCircuitSimulator.
+ */
+export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimulator {
+  private log = createDebugLogger('aztec:public-kernel-simulator');
+
+  /**
+   * Simulates the public kernel circuit (with a previous private kernel circuit run) from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async publicKernelCircuitPrivateInput(
+    input: PublicKernelCircuitPrivateInputs,
+  ): Promise<PublicKernelCircuitPublicInputs> {
+    if (!input.previousKernel.publicInputs.isPrivate) {
+      throw new Error(`Expected private kernel previous inputs`);
+    }
+    const [duration, result] = await elapsed(() => executePublicKernelSetup(input));
+    this.log(`Simulated public kernel circuit with private input`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'public-kernel-private-input',
+      duration,
+      inputSize: input.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+    return result;
+  }
+
+  /**
+   * Simulates the public kernel circuit (with no previous public kernel circuit run) from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async publicKernelCircuitNonFirstIteration(
+    input: PublicKernelCircuitPrivateInputs,
+  ): Promise<PublicKernelCircuitPublicInputs> {
+    if (input.previousKernel.publicInputs.isPrivate) {
+      throw new Error(`Expected public kernel previous inputs`);
+    }
+    const [duration, result] = await elapsed(() => executePublicKernelAppLogic(input));
+    this.log(`Simulated public kernel circuit non-first iteration`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'public-kernel-non-first-iteration',
+      duration,
+      inputSize: input.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+    return result;
+  }
+}

package/src/simulator/rollup.ts

@@ -0,0 +1,76 @@
+import { CircuitSimulationStats } from '@aztec/circuit-types/stats';
+import {
+  BaseOrMergeRollupPublicInputs,
+  BaseRollupInputs,
+  MergeRollupInputs,
+  RootRollupInputs,
+  RootRollupPublicInputs,
+} from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { elapsed } from '@aztec/foundation/timer';
+import { executeBaseRollup, executeMergeRollup, executeRootRollup } from '@aztec/noir-protocol-circuits-types';
+
+import { RollupSimulator } from './index.js';
+
+/**
+ * Implements the rollup circuit simulator.
+ */
+export class RealRollupCircuitSimulator implements RollupSimulator {
+  private log = createDebugLogger('aztec:rollup-simulator');
+
+  /**
+   * 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 [duration, result] = await elapsed(() => executeBaseRollup(input));
+
+    this.log(`Simulated base rollup circuit`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'base-rollup',
+      duration,
+      inputSize: input.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+
+    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 [duration, result] = await elapsed(() => executeMergeRollup(input));
+
+    this.log(`Simulated merge rollup circuit`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'merge-rollup',
+      duration,
+      inputSize: input.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+
+    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 [duration, result] = await elapsed(() => executeRootRollup(input));
+
+    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;
+  }
+}

package/src/utils.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns a promise that resolves after ms milliseconds, returning "returnValue".
+ * @param ms - How many milliseconds to sleep.
+ * @param returnValue - The return value of the promise.
+ */
+export function sleep<T>(ms: number, returnValue: T): Promise<T> {
+  return new Promise(resolve => setTimeout(() => resolve(returnValue), ms));
+}
+
+/**
+ * Returns the lowest power of two that is greater of equal to the input.
+ * @param num - The input.
+ */
+export function ceilPowerOfTwo(num: number): number {
+  return 2 ** Math.ceil(Math.log2(num));
+}