@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/public/avm/serialization/instruction_serialization.ts

@@ -1,5 +1,8 @@
+import { Fr } from '@aztec/foundation/fields';
+
 import { strict as assert } from 'assert';
 
+import { TaggedMemory } from '../avm_memory_types.js';
 import { BufferCursor } from './buffer_cursor.js';
 
 /**
@@ -92,10 +95,8 @@ export const MAX_OPCODE_VALUE = Math.max(
     .filter(k => !isNaN(k)),
 );
 
-// Possible types for an instruction's operand in its wire format. (Keep in sync with CPP code.
-// See vm/avm_trace/deserialization.cpp)
-// Note that cpp code introduced an additional enum value TAG to express the instruction tag. In TS,
-// this one is parsed as UINT8.
+// Possible types for an instruction's operand in its wire format.
+// The counterpart cpp file is: vm2/simulation/lib/serialization.hpp.
 export enum OperandType {
   UINT8,
   UINT16,
@@ -103,8 +104,12 @@ export enum OperandType {
   UINT64,
   UINT128,
   FF,
+  TAG,
 }
 
+// Define a type that represents the possible types of the deserialized values.
+type DeserializedValue = number | bigint;
+
 type OperandNativeType = number | bigint;
 type OperandWriter = (value: any) => void;
 
@@ -113,45 +118,70 @@ const OPERAND_SPEC = new Map<OperandType, [number, (offset: number) => OperandNa
   [OperandType.UINT8, [1, Buffer.prototype.readUint8, Buffer.prototype.writeUint8]],
   [OperandType.UINT16, [2, Buffer.prototype.readUint16BE, Buffer.prototype.writeUint16BE]],
   [OperandType.UINT32, [4, Buffer.prototype.readUint32BE, Buffer.prototype.writeUint32BE]],
-  [OperandType.UINT64, [8, Buffer.prototype.readBigInt64BE, Buffer.prototype.writeBigInt64BE]],
-  [OperandType.UINT128, [16, readBigInt128BE, writeBigInt128BE]],
-  [OperandType.FF, [32, readBigInt254BE, writeBigInt254BE]],
+  [OperandType.UINT64, [8, readUint64BE, writeUint64BE]],
+  [OperandType.UINT128, [16, readUint128BE, writeUint128BE]],
+  [OperandType.FF, [32, readUint254BE, writeUint254BE]],
+  [OperandType.TAG, [1, Buffer.prototype.readUint8, Buffer.prototype.writeUint8]],
 ]);
 
-function readBigInt254BE(this: Buffer, offset: number): bigint {
-  const totalBytes = 32;
-  let ret: bigint = 0n;
+/**
+ * Returns the size of an operand in bytes.
+ * Should not be called with unknown operand types.
+ * @param operandType
+ * @returns number size in bytes
+ * @throws AssertionError if the operand type is unknown
+ */
+export function getOperandSize(operandType: OperandType): number {
+  assert(OPERAND_SPEC.has(operandType), `Unknown operand type: ${operandType}`);
+  return OPERAND_SPEC.get(operandType)![0];
+}
+
+function readUintBE(buf: Buffer, offset: number, totalBytes: number): bigint {
+  let value: bigint = 0n;
   for (let i = 0; i < totalBytes; ++i) {
-    ret <<= 8n;
-    ret |= BigInt(this.readUint8(i + offset));
+    value <<= 8n;
+    value |= BigInt(buf.readUint8(i + offset));
   }
-  return ret;
+  return value;
 }
 
-function writeBigInt254BE(this: Buffer, value: bigint): void {
-  const totalBytes = 32;
+function writeUintBE(buf: Buffer, value: bigint, totalBytes: number): void {
   for (let offset = totalBytes - 1; offset >= 0; --offset) {
-    this.writeUint8(Number(value & 0xffn), offset);
+    buf.writeUint8(Number(value & 0xffn), offset);
     value >>= 8n;
   }
 }
 
-function readBigInt128BE(this: Buffer, offset: number): bigint {
-  const totalBytes = 16;
-  let ret: bigint = 0n;
-  for (let i = 0; i < totalBytes; ++i) {
-    ret <<= 8n;
-    ret |= BigInt(this.readUint8(i + offset));
-  }
-  return ret;
+function readUint64BE(this: Buffer, offset: number): bigint {
+  return readUintBE(this, offset, 8);
 }
 
-function writeBigInt128BE(this: Buffer, value: bigint): void {
-  const totalBytes = 16;
-  for (let offset = totalBytes - 1; offset >= 0; --offset) {
-    this.writeUint8(Number(value & 0xffn), offset);
-    value >>= 8n;
+function writeUint64BE(this: Buffer, value: bigint): void {
+  writeUintBE(this, value, 8);
+}
+
+function readUint254BE(this: Buffer, offset: number): bigint {
+  let value = readUintBE(this, offset, 32);
+
+  // In circuit, we only support values up to Fr.MODULUS and any deserialized value
+  // would naturally undergo a modulus reduction.
+  if (value >= Fr.MODULUS) {
+    value = value % Fr.MODULUS;
   }
+
+  return value;
+}
+
+function writeUint254BE(this: Buffer, value: bigint): void {
+  writeUintBE(this, value, 32);
+}
+
+function readUint128BE(this: Buffer, offset: number): bigint {
+  return readUintBE(this, offset, 16);
+}
+
+function writeUint128BE(this: Buffer, value: bigint): void {
+  writeUintBE(this, value, 16);
 }
 
 /**
@@ -160,19 +190,30 @@ function writeBigInt128BE(this: Buffer, value: bigint): void {
  * @param operands Specification of the operand types.
  * @returns An array as big as {@code operands}, with the converted TS values.
  */
-export function deserialize(cursor: BufferCursor | Buffer, operands: OperandType[]): (number | bigint)[] {
-  const argValues = [];
+export function deserialize(cursor: BufferCursor | Buffer, operands: OperandType[]): DeserializedValue[] {
+  const argValues: DeserializedValue[] = [];
   if (Buffer.isBuffer(cursor)) {
     cursor = new BufferCursor(cursor);
   }
 
-  for (const op of operands) {
-    const opType = op;
+  for (const opType of operands) {
     const [sizeBytes, reader, _writer] = OPERAND_SPEC.get(opType)!;
-    argValues.push(reader.call(cursor.buffer(), cursor.position()));
+    const value = reader.call(cursor.buffer(), cursor.position());
+    argValues.push(value);
     cursor.advance(sizeBytes);
   }
 
+  // We first want to detect other parsing errors (e.g., instruction size
+  // is longer than remaining bytes) first and therefore tag validation is done after completion
+  // of parsing above. Order of errors need to match with circuit.
+  for (let i = 0; i < operands.length; i++) {
+    if (operands[i] === OperandType.TAG) {
+      // We parsed a single byte (readUInt8()) and therefore value is of number type (not bigint)
+      // We need to cast to number because checkIsValidTag expects a number.
+      TaggedMemory.checkIsValidTag(Number(argValues[i] ?? 0));
+    }
+  }
+
   return argValues;
 }
 

package/src/public/avm/test_utils.ts

@@ -1,81 +1,64 @@
 import { Fr } from '@aztec/foundation/fields';
-import {
-  type ContractClassPublic,
-  type ContractInstanceWithAddress,
-  computePublicBytecodeCommitment,
-} from '@aztec/stdlib/contract';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 
 import type { jest } from '@jest/globals';
 import { mock } from 'jest-mock-extended';
 
-import type { WorldStateDB } from '../../public/public_db_sources.js';
+import type { PublicContractsDB, PublicTreesDB } from '../public_db_sources.js';
 import type { PublicSideEffectTraceInterface } from '../side_effect_trace_interface.js';
 
-export async function mockGetBytecode(worldStateDB: WorldStateDB, bytecode: Buffer) {
-  const commitment = await computePublicBytecodeCommitment(bytecode);
-  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecodeCommitment.mockResolvedValue(commitment);
-}
-
 export function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace?: PublicSideEffectTraceInterface) {
   (trace as jest.Mocked<PublicSideEffectTraceInterface>).fork.mockReturnValue(
     nestedTrace ?? mock<PublicSideEffectTraceInterface>(),
   );
 }
 
-export function mockStorageRead(worldStateDB: WorldStateDB, value: Fr) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).storageRead.mockResolvedValue(value);
+export function mockStorageRead(worldStateDB: PublicTreesDB, value: Fr) {
+  (worldStateDB as jest.Mocked<PublicTreesDB>).storageRead.mockResolvedValue(value);
 }
 
 export function mockNoteHashCount(mockedTrace: PublicSideEffectTraceInterface, count: number) {
   (mockedTrace as jest.Mocked<PublicSideEffectTraceInterface>).getNoteHashCount.mockReturnValue(count);
 }
 
-export function mockStorageReadWithMap(worldStateDB: WorldStateDB, mockedStorage: Map<bigint, Fr>) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).storageRead.mockImplementation((_address, slot) =>
+export function mockStorageReadWithMap(worldStateDB: PublicTreesDB, mockedStorage: Map<bigint, Fr>) {
+  (worldStateDB as jest.Mocked<PublicTreesDB>).storageRead.mockImplementation((_address, slot) =>
     Promise.resolve(mockedStorage.get(slot.toBigInt()) ?? Fr.ZERO),
   );
 }
 
-export function mockGetBytecodeCommitment(worldStateDB: WorldStateDB, commitment: Fr) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecodeCommitment.mockResolvedValue(commitment);
-}
-
-export function mockNoteHashExists(worldStateDB: WorldStateDB, _leafIndex: Fr, value?: Fr) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).getCommitmentValue.mockImplementation((index: bigint) => {
-    if (index == _leafIndex.toBigInt()) {
+export function mockGetNoteHash(worldStateDB: PublicTreesDB, _leafIndex: bigint, value?: Fr) {
+  (worldStateDB as jest.Mocked<PublicTreesDB>).getNoteHash.mockImplementation((index: bigint) => {
+    if (index == _leafIndex && value) {
       return Promise.resolve(value);
     } else {
-      // This is ok for now since the traceing functions handle it
-      return Promise.resolve(undefined);
+      return Promise.resolve(Fr.ZERO);
     }
   });
 }
 
-export function mockGetNullifierIndex(worldStateDB: WorldStateDB, leafIndex: Fr, _ignoredValue?: Fr) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).getNullifierIndex.mockResolvedValue(leafIndex.toBigInt());
+export function mockCheckNullifierExists(worldStateDB: PublicTreesDB, exists: boolean, _ignoredValue?: Fr) {
+  (worldStateDB as jest.Mocked<PublicTreesDB>).checkNullifierExists.mockResolvedValue(exists);
 }
 
-export function mockL1ToL2MessageExists(
-  worldStateDB: WorldStateDB,
-  leafIndex: Fr,
-  value: Fr,
-  valueAtOtherIndices?: Fr,
-) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).getL1ToL2LeafValue.mockImplementation((index: bigint) => {
-    if (index == leafIndex.toBigInt()) {
+export function mockGetL1ToL2LeafValue(worldStateDB: PublicTreesDB, leafIndex: bigint, value?: Fr) {
+  (worldStateDB as jest.Mocked<PublicTreesDB>).getL1ToL2LeafValue.mockImplementation((index: bigint) => {
+    if (index == leafIndex && value) {
       return Promise.resolve(value);
     } else {
-      // any indices other than mockAtLeafIndex will return a different value
-      // (or undefined if no value is specified for other indices)
-      return Promise.resolve(valueAtOtherIndices!);
+      return Promise.resolve(Fr.ZERO!);
     }
   });
 }
 
-export function mockGetContractInstance(worldStateDB: WorldStateDB, contractInstance: ContractInstanceWithAddress) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).getContractInstance.mockResolvedValue(contractInstance);
+export function mockGetContractInstance(contractsDB: PublicContractsDB, contractInstance: ContractInstanceWithAddress) {
+  (contractsDB as jest.Mocked<PublicContractsDB>).getContractInstance.mockResolvedValue(contractInstance);
+}
+
+export function mockGetContractClass(contractsDB: PublicContractsDB, contractClass: ContractClassPublic) {
+  (contractsDB as jest.Mocked<PublicContractsDB>).getContractClass.mockResolvedValue(contractClass);
 }
 
-export function mockGetContractClass(worldStateDB: WorldStateDB, contractClass: ContractClassPublic) {
-  (worldStateDB as jest.Mocked<WorldStateDB>).getContractClass.mockResolvedValue(contractClass);
+export function mockGetBytecodeCommitment(contractsDB: PublicContractsDB, commitment: Fr) {
+  (contractsDB as jest.Mocked<PublicContractsDB>).getBytecodeCommitment.mockResolvedValue(commitment);
 }

package/src/public/contracts_db_checkpoint.ts

@@ -0,0 +1,41 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+export class ContractsDbCheckpoint {
+  private instances: Map<string, ContractInstanceWithAddress> = new Map();
+  private classes: Map<string, ContractClassPublic> = new Map();
+  private bytecodeCommitments: Map<string, Fr> = new Map();
+
+  public addInstance(address: AztecAddress, instance: ContractInstanceWithAddress): void {
+    this.instances.set(address.toString(), instance);
+  }
+
+  public addClass(classId: Fr, contractClass: ContractClassPublic): void {
+    this.classes.set(classId.toString(), contractClass);
+  }
+
+  public addBytecodeCommitment(classId: Fr, commitment: Fr): void {
+    this.bytecodeCommitments.set(classId.toString(), commitment);
+  }
+
+  public getInstance(address: AztecAddress): ContractInstanceWithAddress | undefined {
+    return this.instances.get(address.toString());
+  }
+
+  public getClass(classId: Fr): ContractClassPublic | undefined {
+    return this.classes.get(classId.toString());
+  }
+
+  public getBytecodeCommitment(classId: Fr): Fr | undefined {
+    return this.bytecodeCommitments.get(classId.toString());
+  }
+
+  public deepCopy(): ContractsDbCheckpoint {
+    const copy = new ContractsDbCheckpoint();
+    this.instances.forEach((value, key) => copy.instances.set(key, value));
+    this.classes.forEach((value, key) => copy.classes.set(key, value));
+    this.bytecodeCommitments.forEach((value, key) => copy.bytecodeCommitments.set(key, value));
+    return copy;
+  }
+}

package/src/public/db_interfaces.ts

@@ -0,0 +1,76 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+/**
+ * Database interface for providing access to public state.
+ */
+export interface PublicStateDBInterface {
+  /**
+   * 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.
+   */
+  storageRead(contract: AztecAddress, slot: Fr): Promise<Fr>;
+
+  /**
+   * 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.
+   */
+  storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void>;
+}
+
+/**
+ * Database interface for providing access to public contract data.
+ */
+export interface PublicContractsDBInterface {
+  /**
+   * Returns a contract instance given its address and the given timestamp, or undefined if not exists.
+   * @param address - Address of the contract.
+   * @param timestamp - Timestamp to get the contract instance at. Contract updates might change the instance.
+   * @returns The contract instance or undefined if not found.
+   */
+  getContractInstance(address: AztecAddress, timestamp: UInt64): Promise<ContractInstanceWithAddress | undefined>;
+
+  /**
+   * Returns a publicly deployed contract class.
+   * @param contractClassId - ID of the contract class.
+   * @returns The contract class or undefined if not found
+   */
+  getContractClass(contractClassId: Fr): Promise<ContractClassPublic | undefined>;
+
+  /**
+   * Returns the commitment to the bytecode of a contract class.
+   * @param contractClassId - ID of the contract class.
+   * @returns The commitment to the bytecode or undefined if not found.
+   */
+  getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined>;
+
+  /**
+   * Returns the function name of a contract's function given its selector.
+   * @param contractAddress - Address of the contract.
+   * @param selector - Selector of the function.
+   * @returns The name of the function or undefined if not found.
+   */
+  getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+
+  /**
+   * Creates a checkpoint of the current contract state.
+   */
+  createCheckpoint(): void;
+
+  /**
+   * Commits the current checkpoint, merging its state with the parent.
+   */
+  commitCheckpoint(): void;
+
+  /**
+   * Reverts the current checkpoint, discarding its state.
+   */
+  revertCheckpoint(): void;
+}

package/src/{common → public}/debug_fn_name.ts

@@ -2,17 +2,17 @@ import type { Fr } from '@aztec/foundation/fields';
 import { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-import type { WorldStateDB } from '../public/public_db_sources.js';
+import type { PublicContractsDBInterface } from './db_interfaces.js';
 
 export async function getPublicFunctionDebugName(
-  db: WorldStateDB,
+  db: PublicContractsDBInterface,
   contractAddress: AztecAddress,
   calldata: Fr[],
 ): Promise<string> {
   // Public function is dispatched and therefore the target function is passed in the first argument.
-  const targetFunction =
-    calldata[0] !== undefined
-      ? await db.getDebugFunctionName(contractAddress, FunctionSelector.fromField(calldata[0]))
-      : `<calldata[0] undefined> (Contract Address: ${contractAddress})`;
-  return `${targetFunction}`;
+  if (!calldata[0]) {
+    return `<calldata[0] undefined> (Contract Address: ${contractAddress})`;
+  }
+  const selector = FunctionSelector.fromField(calldata[0]);
+  return (await db.getDebugFunctionName(contractAddress, selector)) ?? selector.toString();
 }

package/src/public/executor_metrics.ts

@@ -1,3 +1,5 @@
+import type { RevertCode } from '@aztec/stdlib/avm';
+import type { GasUsed } from '@aztec/stdlib/gas';
 import {
   Attributes,
   type Histogram,
@@ -8,11 +10,16 @@ import {
   ValueType,
 } from '@aztec/telemetry-client';
 
-export class ExecutorMetrics {
+import type { ExecutorMetricsInterface } from './executor_metrics_interface.js';
+
+export class ExecutorMetrics implements ExecutorMetricsInterface {
   public readonly tracer: Tracer;
   private fnCount: UpDownCounter;
   private fnDuration: Histogram;
   private manaPerSecond: Histogram;
+  private manaUsed: Histogram;
+  private totalInstructionsExecuted: Histogram;
+  private txHashing: Histogram;
   private privateEffectsInsertions: Histogram;
 
   constructor(client: TelemetryClient, name = 'PublicExecutor') {
@@ -35,20 +42,58 @@ export class ExecutorMetrics {
       valueType: ValueType.INT,
     });
 
-    this.privateEffectsInsertions = meter.createHistogram(Metrics.PUBLIC_EXECUTION_PRIVATE_EFFECTS_INSERTION, {
+    this.manaUsed = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_MANA_USED, {
+      description: 'Total mana used',
+      unit: 'mana',
+      valueType: ValueType.INT,
+    });
+
+    this.totalInstructionsExecuted = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_SIMULATION_TOTAL_INSTRUCTIONS, {
+      description: 'Total number of instructions executed',
+      unit: '#instructions',
+      valueType: ValueType.INT,
+    });
+
+    this.txHashing = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_TX_HASHING, {
+      description: 'Tx hashing time',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
+
+    this.privateEffectsInsertions = meter.createHistogram(Metrics.PUBLIC_EXECUTOR_PRIVATE_EFFECTS_INSERTION, {
       description: 'Private effects insertion time',
       unit: 'us',
       valueType: ValueType.INT,
     });
   }
 
-  recordFunctionSimulation(durationMs: number, manaUsed: number, fnName: string) {
+  startRecordingTxSimulation(_txLabel: string) {
+    // do nothing (unimplemented)
+  }
+
+  stopRecordingTxSimulation(_txLabel: string, _gasUsed?: GasUsed, _revertedCode?: RevertCode) {
+    // do nothing (unimplemented)
+  }
+
+  recordEnqueuedCallSimulation(
+    fnName: string,
+    durationMs: number,
+    manaUsed: number,
+    totalInstructionsExecuted: number,
+  ) {
     this.fnCount.add(1, {
       [Attributes.OK]: true,
       [Attributes.APP_CIRCUIT_NAME]: fnName,
-      [Attributes.MANA_USED]: manaUsed,
     });
-    this.fnDuration.record(Math.ceil(durationMs));
+    this.manaUsed.record(Math.ceil(manaUsed), {
+      [Attributes.APP_CIRCUIT_NAME]: fnName,
+    });
+    this.totalInstructionsExecuted.record(Math.ceil(totalInstructionsExecuted), {
+      [Attributes.APP_CIRCUIT_NAME]: fnName,
+    });
+    this.fnDuration.record(Math.ceil(durationMs), {
+      [Attributes.APP_CIRCUIT_NAME]: fnName,
+    });
     if (durationMs > 0 && manaUsed > 0) {
       const manaPerSecond = Math.round((manaUsed * 1000) / durationMs);
       this.manaPerSecond.record(manaPerSecond, {
@@ -57,7 +102,12 @@ export class ExecutorMetrics {
     }
   }
 
-  recordFunctionSimulationFailure() {
+  recordEnqueuedCallSimulationFailure(
+    _fnName: string,
+    _durationMs: number,
+    _manaUsed: number,
+    _totalInstructionsExecuted: number,
+  ) {
     this.fnCount.add(1, {
       [Attributes.OK]: false,
     });

package/src/public/executor_metrics_interface.ts

@@ -0,0 +1,15 @@
+import type { RevertCode } from '@aztec/stdlib/avm';
+import type { GasUsed } from '@aztec/stdlib/gas';
+
+export interface ExecutorMetricsInterface {
+  startRecordingTxSimulation(txLabel: string): void;
+  stopRecordingTxSimulation(txLabel: string, gasUsed?: GasUsed, revertedCode?: RevertCode): void;
+  recordEnqueuedCallSimulation(fnName: string, durationMs: number, manaUsed: number, totalInstructions: number): void;
+  recordEnqueuedCallSimulationFailure(
+    fnName: string,
+    durationMs: number,
+    manaUsed: number,
+    totalInstructionsExecuted: number,
+  ): void;
+  recordPrivateEffectsInsertion(durationUs: number, type: 'revertible' | 'non-revertible'): void;
+}