@aztec/simulator 0.55.0 → 0.56.0

package/src/avm/test_utils.ts

@@ -4,12 +4,11 @@ import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
 import { type jest } from '@jest/globals';
 import { mock } from 'jest-mock-extended';
 
-import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from '../public/db_interfaces.js';
+import { type WorldStateDB } from '../public/public_db_sources.js';
 import { type PublicSideEffectTraceInterface } from '../public/side_effect_trace_interface.js';
-import { type HostStorage } from './journal/host_storage.js';
 
-export function mockGetBytecode(hs: HostStorage, bytecode: Buffer) {
-  (hs as jest.Mocked<HostStorage>).contractsDb.getBytecode.mockResolvedValue(bytecode);
+export function mockGetBytecode(worldStateDB: WorldStateDB, bytecode: Buffer) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecode.mockResolvedValue(bytecode);
 }
 
 export function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace?: PublicSideEffectTraceInterface) {
@@ -18,18 +17,18 @@ export function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace
   );
 }
 
-export function mockStorageRead(hs: HostStorage, value: Fr) {
-  (hs.publicStateDb as jest.Mocked<PublicStateDB>).storageRead.mockResolvedValue(value);
+export function mockStorageRead(worldStateDB: WorldStateDB, value: Fr) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).storageRead.mockResolvedValue(value);
 }
 
-export function mockStorageReadWithMap(hs: HostStorage, mockedStorage: Map<bigint, Fr>) {
-  (hs.publicStateDb as jest.Mocked<PublicStateDB>).storageRead.mockImplementation((_address, slot) =>
+export function mockStorageReadWithMap(worldStateDB: WorldStateDB, mockedStorage: Map<bigint, Fr>) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).storageRead.mockImplementation((_address, slot) =>
     Promise.resolve(mockedStorage.get(slot.toBigInt()) ?? Fr.ZERO),
   );
 }
 
-export function mockNoteHashExists(hs: HostStorage, _leafIndex: Fr, value?: Fr) {
-  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getCommitmentValue.mockImplementation((index: bigint) => {
+export function mockNoteHashExists(worldStateDB: WorldStateDB, _leafIndex: Fr, value?: Fr) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getCommitmentValue.mockImplementation((index: bigint) => {
     if (index == _leafIndex.toBigInt()) {
       return Promise.resolve(value);
     } else {
@@ -39,12 +38,17 @@ export function mockNoteHashExists(hs: HostStorage, _leafIndex: Fr, value?: Fr)
   });
 }
 
-export function mockNullifierExists(hs: HostStorage, leafIndex: Fr, _value?: Fr) {
-  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getNullifierIndex.mockResolvedValue(leafIndex.toBigInt());
+export function mockNullifierExists(worldStateDB: WorldStateDB, leafIndex: Fr, _value?: Fr) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getNullifierIndex.mockResolvedValue(leafIndex.toBigInt());
 }
 
-export function mockL1ToL2MessageExists(hs: HostStorage, leafIndex: Fr, value: Fr, valueAtOtherIndices?: Fr) {
-  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getL1ToL2LeafValue.mockImplementation((index: bigint) => {
+export function mockL1ToL2MessageExists(
+  worldStateDB: WorldStateDB,
+  leafIndex: Fr,
+  value: Fr,
+  valueAtOtherIndices?: Fr,
+) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getL1ToL2LeafValue.mockImplementation((index: bigint) => {
     if (index == leafIndex.toBigInt()) {
       return Promise.resolve(value);
     } else {
@@ -55,6 +59,6 @@ export function mockL1ToL2MessageExists(hs: HostStorage, leafIndex: Fr, value: F
   });
 }
 
-export function mockGetContractInstance(hs: HostStorage, contractInstance: ContractInstanceWithAddress) {
-  (hs.contractsDb as jest.Mocked<PublicContractsDB>).getContractInstance.mockResolvedValue(contractInstance);
+export function mockGetContractInstance(worldStateDB: WorldStateDB, contractInstance: ContractInstanceWithAddress) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getContractInstance.mockResolvedValue(contractInstance);
 }

package/src/client/test_utils.ts

@@ -1,8 +1,35 @@
-import { Fq, Fr, GeneratorIndex, Point } from '@aztec/circuits.js';
+import { Fq, Fr, Point } from '@aztec/circuits.js';
 import { Grumpkin } from '@aztec/circuits.js/barretenberg';
-import { pedersenCommit } from '@aztec/foundation/crypto';
 
 // Copied over from `noir-projects/aztec-nr/aztec/src/generators.nr`
+const GENERATORS = [
+  new Point(
+    new Fr(0x30426e64aee30e998c13c8ceecda3a77807dbead52bc2f3bf0eae851b4b710c1n),
+    new Fr(0x113156a068f603023240c96b4da5474667db3b8711c521c748212a15bc034ea6n),
+    false,
+  ),
+  new Point(
+    new Fr(0x2825c79cc6a5cbbeef7d6a8f1b6a12b312aa338440aefeb4396148c89147c049n),
+    new Fr(0x129bfd1da54b7062d6b544e7e36b90736350f6fba01228c41c72099509f5701en),
+    false,
+  ),
+  new Point(
+    new Fr(0x0edb1e293c3ce91bfc04e3ceaa50d2c541fa9d091c72eb403efb1cfa2cb3357fn),
+    new Fr(0x1341d675fa030ece3113ad53ca34fd13b19b6e9762046734f414824c4d6ade35n),
+    false,
+  ),
+  new Point(
+    new Fr(0x0e0dad2250583f2a9f0acb04ededf1701b85b0393cae753fe7e14b88af81cb52n),
+    new Fr(0x0973b02c5caac339ee4ad5dab51329920f7bf1b6a07e1dabe5df67040b300962n),
+    false,
+  ),
+  new Point(
+    new Fr(0x2f3342e900e8c488a28931aae68970738fdc68afde2910de7b320c00c902087dn),
+    new Fr(0x1bf958dc63cb09d59230603a0269ae86d6f92494da244910351f1132df20fc08n),
+    false,
+  ),
+];
+
 const G_SLOT = new Point(
   new Fr(0x041223147b680850dc82e8a55a952d4df20256fe0593d949a9541ca00f0abf15n),
   new Fr(0x0a8c72e60d0e60f5d804549d48f3044d06140b98ed717a9b532af630c1530791n),
@@ -16,14 +43,14 @@ const G_SLOT = new Point(
  * @returns A note hash.
  */
 export function computeNoteHash(storageSlot: Fr, noteContent: Fr[]): Fr {
-  // TODO(#7771): update this to do only 1 MSM call
-  const c = pedersenCommit(
-    noteContent.map(f => f.toBuffer()),
-    GeneratorIndex.NOTE_HIDING_POINT,
-  );
-  const noteHidingPointBeforeSlotting = new Point(new Fr(c[0]), new Fr(c[1]), false);
-
   const grumpkin = new Grumpkin();
+  const noteHidingPointBeforeSlotting = noteContent
+    .slice(1)
+    .reduce(
+      (acc, item, i) => grumpkin.add(acc, grumpkin.mul(GENERATORS[i + 1], new Fq(item.toBigInt()))),
+      grumpkin.mul(GENERATORS[0], new Fq(noteContent[0].toBigInt())),
+    );
+
   const slotPoint = grumpkin.mul(G_SLOT, new Fq(storageSlot.toBigInt()));
   const noteHidingPoint = grumpkin.add(noteHidingPointBeforeSlotting, slotPoint);
   return noteHidingPoint.x;

package/src/client/unconstrained_execution.ts

@@ -1,9 +1,4 @@
-import {
-  type DecodedReturn,
-  type FunctionArtifact,
-  type FunctionSelector,
-  decodeReturnValues,
-} from '@aztec/foundation/abi';
+import { type AbiDecoded, type FunctionArtifact, type FunctionSelector, decodeFromAbi } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -24,7 +19,7 @@ export async function executeUnconstrainedFunction(
   functionSelector: FunctionSelector,
   args: Fr[],
   log = createDebugLogger('aztec:simulator:unconstrained_execution'),
-): Promise<DecodedReturn> {
+): Promise<AbiDecoded> {
   log.verbose(`Executing unconstrained function ${contractAddress}:${functionSelector}(${artifact.name})`);
 
   const acir = artifact.bytecode;
@@ -42,6 +37,6 @@ export async function executeUnconstrainedFunction(
   });
 
   const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
-  return decodeReturnValues(artifact.returnTypes, returnWitness);
+  return decodeFromAbi(artifact.returnTypes, returnWitness);
 }
 // docs:end:execute_unconstrained_function

package/src/public/enqueued_call_simulator.ts

@@ -0,0 +1,336 @@
+import {
+  AVM_REQUEST,
+  type AvmProvingRequest,
+  MerkleTreeId,
+  NestedProcessReturnValues,
+  ProvingRequestType,
+  type PublicExecutionRequest,
+  PublicKernelPhase,
+  type PublicProvingRequest,
+  type SimulationError,
+  type Tx,
+  UnencryptedFunctionL2Logs,
+} from '@aztec/circuit-types';
+import {
+  AztecAddress,
+  ContractStorageRead,
+  ContractStorageUpdateRequest,
+  Fr,
+  FunctionData,
+  Gas,
+  type GlobalVariables,
+  type Header,
+  L2ToL1Message,
+  LogHash,
+  MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
+  MAX_L2_TO_L1_MSGS_PER_CALL,
+  MAX_NOTE_HASHES_PER_CALL,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+  MAX_NULLIFIERS_PER_CALL,
+  MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
+  MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+  MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
+  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+  MAX_PUBLIC_DATA_READS_PER_CALL,
+  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
+  MAX_UNENCRYPTED_LOGS_PER_CALL,
+  NESTED_RECURSIVE_PROOF_LENGTH,
+  NoteHash,
+  Nullifier,
+  PublicAccumulatedData,
+  PublicAccumulatedDataArrayLengths,
+  PublicCallData,
+  type PublicCallRequest,
+  PublicCallStackItem,
+  PublicCircuitPublicInputs,
+  PublicInnerCallRequest,
+  type PublicKernelCircuitPublicInputs,
+  PublicKernelInnerCircuitPrivateInputs,
+  PublicKernelInnerData,
+  PublicValidationRequestArrayLengths,
+  PublicValidationRequests,
+  ReadRequest,
+  RevertCode,
+  TreeLeafReadRequest,
+  VMCircuitPublicInputs,
+  makeEmptyProof,
+  makeEmptyRecursiveProof,
+} from '@aztec/circuits.js';
+import { computeVarArgsHash } from '@aztec/circuits.js/hash';
+import { makeTuple } from '@aztec/foundation/array';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
+import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types';
+import { type MerkleTreeOperations } from '@aztec/world-state';
+
+import { accumulateReturnValues } from '../common/index.js';
+import { type PublicExecutionResult, collectExecutionResults } from './execution.js';
+import { type PublicExecutor } from './executor.js';
+import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
+
+function makeAvmProvingRequest(
+  inputs: PublicKernelInnerCircuitPrivateInputs,
+  result: PublicExecutionResult,
+): AvmProvingRequest {
+  return {
+    type: AVM_REQUEST,
+    functionName: result.functionName,
+    calldata: result.calldata,
+    bytecode: result.bytecode!,
+    avmHints: result.avmCircuitHints,
+    kernelRequest: {
+      type: ProvingRequestType.PUBLIC_KERNEL_INNER,
+      inputs,
+    },
+  };
+}
+
+export type EnqueuedCallResult = {
+  /** Inputs to be used for proving */
+  provingRequests: PublicProvingRequest[];
+  /** The public kernel output at the end of the enqueued call */
+  kernelOutput: VMCircuitPublicInputs;
+  /** Unencrypted logs generated during the execution of this enqueued call */
+  newUnencryptedLogs: UnencryptedFunctionL2Logs;
+  /** Return values of simulating complete callstack */
+  returnValues: NestedProcessReturnValues;
+  /** Gas used during the execution this enqueued call */
+  gasUsed: Gas;
+  /** Revert reason, if any */
+  revertReason?: SimulationError;
+};
+
+export class EnqueuedCallSimulator {
+  private log: DebugLogger;
+  constructor(
+    private db: MerkleTreeOperations,
+    private publicExecutor: PublicExecutor,
+    private publicKernelSimulator: PublicKernelCircuitSimulator,
+    private globalVariables: GlobalVariables,
+    private historicalHeader: Header,
+  ) {
+    this.log = createDebugLogger(`aztec:sequencer`);
+  }
+
+  async simulate(
+    callRequest: PublicCallRequest,
+    executionRequest: PublicExecutionRequest,
+    tx: Tx,
+    previousPublicKernelOutput: PublicKernelCircuitPublicInputs,
+    availableGas: Gas,
+    transactionFee: Fr,
+    phase: PublicKernelPhase,
+  ): Promise<EnqueuedCallResult> {
+    const pendingNullifiers = this.getSiloedPendingNullifiers(previousPublicKernelOutput);
+    const startSideEffectCounter = previousPublicKernelOutput.endSideEffectCounter + 1;
+    const result = await this.publicExecutor.simulate(
+      executionRequest,
+      this.globalVariables,
+      availableGas,
+      tx.data.constants.txContext,
+      pendingNullifiers,
+      transactionFee,
+      startSideEffectCounter,
+    );
+
+    const callStack = makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, PublicInnerCallRequest.empty);
+    callStack[0].item.contractAddress = callRequest.contractAddress;
+    callStack[0].item.callContext = callRequest.callContext;
+    callStack[0].item.argsHash = callRequest.argsHash;
+    const prevAccumulatedData =
+      phase === PublicKernelPhase.SETUP
+        ? previousPublicKernelOutput.endNonRevertibleData
+        : previousPublicKernelOutput.end;
+    const accumulatedData = PublicAccumulatedData.empty();
+    accumulatedData.publicCallStack[0] = callRequest;
+    const startVMCircuitOutput = new VMCircuitPublicInputs(
+      previousPublicKernelOutput.constants,
+      callRequest,
+      callStack,
+      PublicValidationRequestArrayLengths.new(previousPublicKernelOutput.validationRequests),
+      PublicValidationRequests.empty(),
+      PublicAccumulatedDataArrayLengths.new(prevAccumulatedData),
+      accumulatedData,
+      startSideEffectCounter,
+      startSideEffectCounter,
+      availableGas,
+      result.transactionFee,
+      result.reverted,
+    );
+
+    return await this.combineNestedExecutionResults(result, startVMCircuitOutput);
+  }
+
+  private async combineNestedExecutionResults(
+    topResult: PublicExecutionResult,
+    startVMCircuitOutput: VMCircuitPublicInputs,
+  ): Promise<EnqueuedCallResult> {
+    const executionResults = collectExecutionResults(topResult);
+
+    const provingRequests: AvmProvingRequest[] = [];
+    let gasUsed = Gas.empty();
+    let revertReason;
+    let kernelOutput = startVMCircuitOutput;
+
+    for (const result of executionResults) {
+      // Accumulate gas used in this enqueued call.
+      gasUsed = gasUsed.add(Gas.from(result.startGasLeft).sub(Gas.from(result.endGasLeft)));
+
+      // Sanity check for a current upstream assumption.
+      // Consumers of the result seem to expect "reverted <=> revertReason !== undefined".
+      const functionSelector = result.executionRequest.callContext.functionSelector.toString();
+      if (result.reverted && !result.revertReason) {
+        throw new Error(
+          `Simulation of ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
+            result.functionName
+          }) reverted with no reason.`,
+        );
+      }
+
+      // Simulate the public kernel circuit.
+      this.log.debug(
+        `Running public kernel inner circuit for ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
+          result.functionName
+        })`,
+      );
+
+      const callData = await this.getPublicCallData(result);
+      const { inputs, output } = await this.runKernelCircuit(kernelOutput, callData);
+      kernelOutput = output;
+
+      // Capture the inputs for later proving in the AVM and kernel.
+      provingRequests.push(makeAvmProvingRequest(inputs, result));
+
+      // Safely return the revert reason and the kernel output (which has had its revertible side effects dropped)
+      // TODO(@leila) we shouldn't drop everything when it reverts. The tail kernel needs the data to prove that it's reverted for the correct reason.
+      if (result.reverted) {
+        this.log.debug(
+          `Reverting on ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
+            result.functionName
+          }) with reason: ${result.revertReason}`,
+        );
+        // TODO(@spalladino): Check gasUsed is correct. The AVM should take care of setting gasLeft to zero upon a revert.
+
+        return {
+          provingRequests,
+          kernelOutput,
+          newUnencryptedLogs: UnencryptedFunctionL2Logs.empty(),
+          returnValues: NestedProcessReturnValues.empty(),
+          gasUsed,
+          revertReason: result.revertReason,
+        };
+      }
+    }
+
+    return {
+      provingRequests,
+      kernelOutput,
+      newUnencryptedLogs: topResult.allUnencryptedLogs,
+      returnValues: accumulateReturnValues(topResult),
+      gasUsed,
+      revertReason,
+    };
+  }
+
+  /** Returns all pending private and public nullifiers. */
+  private getSiloedPendingNullifiers(ko: PublicKernelCircuitPublicInputs) {
+    return [...ko.end.nullifiers, ...ko.endNonRevertibleData.nullifiers].filter(n => !n.isEmpty());
+  }
+
+  private async runKernelCircuit(
+    previousOutput: VMCircuitPublicInputs,
+    callData: PublicCallData,
+  ): Promise<{ inputs: PublicKernelInnerCircuitPrivateInputs; output: VMCircuitPublicInputs }> {
+    // The proof is not used in simulation
+    const proof = makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH);
+    const vk = ProtocolCircuitVks.PublicKernelInnerArtifact;
+    const previousKernel = new PublicKernelInnerData(previousOutput, proof, vk);
+    const inputs = new PublicKernelInnerCircuitPrivateInputs(previousKernel, callData);
+    return { inputs, output: await this.publicKernelSimulator.publicKernelCircuitInner(inputs) };
+  }
+
+  /**
+   * Calculates the PublicCircuitOutput for this execution result along with its proof,
+   * and assembles a PublicCallData object from it.
+   * @param result - The execution result.
+   * @returns A corresponding PublicCallData object.
+   */
+  private async getPublicCallData(result: PublicExecutionResult) {
+    const bytecodeHash = await this.getBytecodeHash(result);
+    const callStackItem = await this.getPublicCallStackItem(result);
+    return new PublicCallData(callStackItem, makeEmptyProof(), bytecodeHash);
+  }
+
+  private async getPublicCallStackItem(result: PublicExecutionResult) {
+    const publicDataTreeInfo = await this.db.getTreeInfo(MerkleTreeId.PUBLIC_DATA_TREE);
+    this.historicalHeader.state.partial.publicDataTree.root = Fr.fromBuffer(publicDataTreeInfo.root);
+
+    const publicCircuitPublicInputs = PublicCircuitPublicInputs.from({
+      callContext: result.executionRequest.callContext,
+      proverAddress: AztecAddress.ZERO,
+      argsHash: computeVarArgsHash(result.executionRequest.args),
+      noteHashes: padArrayEnd(result.noteHashes, NoteHash.empty(), MAX_NOTE_HASHES_PER_CALL),
+      nullifiers: padArrayEnd(result.nullifiers, Nullifier.empty(), MAX_NULLIFIERS_PER_CALL),
+      l2ToL1Msgs: padArrayEnd(result.l2ToL1Messages, L2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_CALL),
+      startSideEffectCounter: result.startSideEffectCounter,
+      endSideEffectCounter: result.endSideEffectCounter,
+      returnsHash: computeVarArgsHash(result.returnValues),
+      noteHashReadRequests: padArrayEnd(
+        result.noteHashReadRequests,
+        TreeLeafReadRequest.empty(),
+        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+      ),
+      nullifierReadRequests: padArrayEnd(
+        result.nullifierReadRequests,
+        ReadRequest.empty(),
+        MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+      ),
+      nullifierNonExistentReadRequests: padArrayEnd(
+        result.nullifierNonExistentReadRequests,
+        ReadRequest.empty(),
+        MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
+      ),
+      l1ToL2MsgReadRequests: padArrayEnd(
+        result.l1ToL2MsgReadRequests,
+        TreeLeafReadRequest.empty(),
+        MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
+      ),
+      contractStorageReads: padArrayEnd(
+        result.contractStorageReads,
+        ContractStorageRead.empty(),
+        MAX_PUBLIC_DATA_READS_PER_CALL,
+      ),
+      contractStorageUpdateRequests: padArrayEnd(
+        result.contractStorageUpdateRequests,
+        ContractStorageUpdateRequest.empty(),
+        MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
+      ),
+      publicCallRequests: padArrayEnd(
+        result.publicCallRequests,
+        PublicInnerCallRequest.empty(),
+        MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
+      ),
+      unencryptedLogsHashes: padArrayEnd(result.unencryptedLogsHashes, LogHash.empty(), MAX_UNENCRYPTED_LOGS_PER_CALL),
+      historicalHeader: this.historicalHeader,
+      globalVariables: this.globalVariables,
+      startGasLeft: Gas.from(result.startGasLeft),
+      endGasLeft: Gas.from(result.endGasLeft),
+      transactionFee: result.transactionFee,
+      // TODO(@just-mitch): need better mapping from simulator to revert code.
+      revertCode: result.reverted ? RevertCode.APP_LOGIC_REVERTED : RevertCode.OK,
+    });
+
+    return new PublicCallStackItem(
+      result.executionRequest.contractAddress,
+      new FunctionData(result.executionRequest.callContext.functionSelector, false),
+      publicCircuitPublicInputs,
+    );
+  }
+
+  private getBytecodeHash(_result: PublicExecutionResult) {
+    // TODO: Determine how to calculate bytecode hash. Circuits just check it isn't zero for now.
+    // See https://github.com/AztecProtocol/aztec3-packages/issues/378
+    const bytecodeHash = new Fr(1n);
+    return Promise.resolve(bytecodeHash);
+  }
+}