@aztec/simulator 0.30.1 → 0.32.0

package/src/client/client_execution_context.ts

@@ -1,11 +1,13 @@
 import {
   AuthWitness,
   AztecNode,
-  FunctionL2Logs,
+  EncryptedFunctionL2Logs,
+  EncryptedL2Log,
   L1NotePayload,
   Note,
   NoteStatus,
   TaggedNote,
+  UnencryptedFunctionL2Logs,
   UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import {
@@ -56,7 +58,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * They should act as references for the read requests output by an app circuit via public inputs.
    */
   private gotNotes: Map<bigint, bigint> = new Map();
-  private encryptedLogs: Buffer[] = [];
+  private encryptedLogs: EncryptedL2Log[] = [];
   private unencryptedLogs: UnencryptedL2Log[] = [];
   private nestedExecutions: ExecutionResult[] = [];
   private enqueuedPublicFunctionCalls: PublicCallRequest[] = [];
@@ -144,14 +146,14 @@ export class ClientExecutionContext extends ViewDataOracle {
    * Return the encrypted logs emitted during this execution.
    */
   public getEncryptedLogs() {
-    return new FunctionL2Logs(this.encryptedLogs);
+    return new EncryptedFunctionL2Logs(this.encryptedLogs);
   }
 
   /**
    * Return the encrypted logs emitted during this execution.
    */
   public getUnencryptedLogs() {
-    return new FunctionL2Logs(this.unencryptedLogs.map(log => log.toBuffer()));
+    return new UnencryptedFunctionL2Logs(this.unencryptedLogs);
   }
 
   /**
@@ -304,7 +306,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     const l1NotePayload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
     const taggedNote = new TaggedNote(l1NotePayload);
     const encryptedNote = taggedNote.toEncryptedBuffer(publicKey, this.curve);
-    this.encryptedLogs.push(encryptedNote);
+    this.encryptedLogs.push(new EncryptedL2Log(encryptedNote));
   }
 
   /**

package/src/client/execution_result.ts

@@ -1,4 +1,4 @@
-import { FunctionL2Logs, Note } from '@aztec/circuit-types';
+import { EncryptedFunctionL2Logs, Note, UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
 import { NoteHashReadRequestMembershipWitness, PrivateCallStackItem, PublicCallRequest } from '@aztec/circuits.js';
 import { DecodedReturn } from '@aztec/foundation/abi';
 import { Fr } from '@aztec/foundation/fields';
@@ -46,12 +46,12 @@ export interface ExecutionResult {
    * Encrypted logs emitted during execution of this function call.
    * Note: These are preimages to `encryptedLogsHash`.
    */
-  encryptedLogs: FunctionL2Logs;
+  encryptedLogs: EncryptedFunctionL2Logs;
   /**
    * Unencrypted logs emitted during execution of this function call.
    * Note: These are preimages to `unencryptedLogsHash`.
    */
-  unencryptedLogs: FunctionL2Logs;
+  unencryptedLogs: UnencryptedFunctionL2Logs;
 }
 
 /**
@@ -59,7 +59,7 @@ export interface ExecutionResult {
  * @param execResult - The topmost execution result.
  * @returns All encrypted logs.
  */
-export function collectEncryptedLogs(execResult: ExecutionResult): FunctionL2Logs[] {
+export function collectEncryptedLogs(execResult: ExecutionResult): EncryptedFunctionL2Logs[] {
   // without the .reverse(), the logs will be in a queue like fashion which is wrong as the kernel processes it like a stack.
   return [execResult.encryptedLogs, ...[...execResult.nestedExecutions].reverse().flatMap(collectEncryptedLogs)];
 }
@@ -69,7 +69,7 @@ export function collectEncryptedLogs(execResult: ExecutionResult): FunctionL2Log
  * @param execResult - The topmost execution result.
  * @returns All unencrypted logs.
  */
-export function collectUnencryptedLogs(execResult: ExecutionResult): FunctionL2Logs[] {
+export function collectUnencryptedLogs(execResult: ExecutionResult): UnencryptedFunctionL2Logs[] {
   // without the .reverse(), the logs will be in a queue like fashion which is wrong as the kernel processes it like a stack.
   return [execResult.unencryptedLogs, ...[...execResult.nestedExecutions].reverse().flatMap(collectUnencryptedLogs)];
 }

package/src/client/private_execution.ts

@@ -3,7 +3,6 @@ import { FunctionArtifactWithDebugMetadata, decodeReturnValues } from '@aztec/fo
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { to2Fields } from '@aztec/foundation/serialize';
 
 import { extractReturnWitness } from '../acvm/deserialize.js';
 import { Oracle, acvm, extractCallStack } from '../acvm/index.js';
@@ -24,7 +23,7 @@ export async function executePrivateFunction(
 ): Promise<ExecutionResult> {
   const functionSelector = functionData.selector;
   log(`Executing external function ${contractAddress}:${functionSelector}(${artifact.name})`);
-  const acir = Buffer.from(artifact.bytecode, 'base64');
+  const acir = artifact.bytecode;
   const initialWitness = context.getInitialWitness(artifact);
   const acvmCallback = new Oracle(context);
   const { partialWitness } = await acvm(await AcirSimulator.getSolver(), acir, initialWitness, acvmCallback).catch(
@@ -47,9 +46,9 @@ export async function executePrivateFunction(
   const encryptedLogs = context.getEncryptedLogs();
   const unencryptedLogs = context.getUnencryptedLogs();
   // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165) --> set this in Noir
-  publicInputs.encryptedLogsHash = to2Fields(encryptedLogs.hash());
+  publicInputs.encryptedLogsHash = Fr.fromBuffer(encryptedLogs.hash());
   publicInputs.encryptedLogPreimagesLength = new Fr(encryptedLogs.getSerializedLength());
-  publicInputs.unencryptedLogsHash = to2Fields(unencryptedLogs.hash());
+  publicInputs.unencryptedLogsHash = Fr.fromBuffer(unencryptedLogs.hash());
   publicInputs.unencryptedLogPreimagesLength = new Fr(unencryptedLogs.getSerializedLength());
 
   const callStackItem = new PrivateCallStackItem(contractAddress, functionData, publicInputs);

package/src/client/unconstrained_execution.ts

@@ -25,7 +25,7 @@ export async function executeUnconstrainedFunction(
   const functionSelector = functionData.selector;
   log(`Executing unconstrained function ${contractAddress}:${functionSelector}`);
 
-  const acir = Buffer.from(artifact.bytecode, 'base64');
+  const acir = artifact.bytecode;
   const initialWitness = toACVMWitness(0, args);
   const { partialWitness } = await acvm(
     await AcirSimulator.getSolver(),

package/src/client/view_data_oracle.ts

@@ -225,12 +225,15 @@ export class ViewDataOracle extends TypedOracle {
   }
 
   /**
-   * Fetches the a message from the db, given its key.
-   * @param entryKey - A buffer representing the entry key.
-   * @returns The l1 to l2 message data
+   * Fetches a message from the db, given its key.
+   * @param contractAddress - Address of a contract by which the message was emitted.
+   * @param messageHash - Hash of the message.
+   * @param secret - Secret used to compute a nullifier.
+   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
+   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
    */
-  public async getL1ToL2MembershipWitness(entryKey: Fr) {
-    return await this.db.getL1ToL2MembershipWitness(entryKey);
+  public async getL1ToL2MembershipWitness(contractAddress: AztecAddress, messageHash: Fr, secret: Fr) {
+    return await this.db.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
   }
 
   /**

package/src/index.ts

@@ -2,3 +2,4 @@ export * from './acvm/index.js';
 export * from './client/index.js';
 export * from './common/index.js';
 export * from './public/index.js';
+export * from './simulator/index.js';

package/src/public/db.ts

@@ -79,12 +79,18 @@ export interface PublicContractsDB {
 /** Database interface for providing access to commitment tree, l1 to l2 message tree, and nullifier tree. */
 export interface CommitmentsDB {
   /**
-   * Gets a confirmed L1 to L2 message for the given entry key.
-   * TODO(Maddiaa): Can be combined with aztec-node method that does the same thing.
-   * @param entryKey - The entry key.
-   * @returns - The l1 to l2 message object
+   * Fetches a message from the db, given its key.
+   * @param contractAddress - Address of a contract by which the message was emitted.
+   * @param messageHash - Hash of the message.
+   * @param secret - Secret used to compute a nullifier.
+   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
+   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
    */
-  getL1ToL2MembershipWitness(entryKey: Fr): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
+  getL1ToL2MembershipWitness(
+    contractAddress: AztecAddress,
+    messageHash: Fr,
+    secret: Fr,
+  ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
 
   /**
    * Gets the index of a commitment in the note hash tree.

package/src/public/execution.ts

@@ -1,4 +1,4 @@
-import { FunctionL2Logs, SimulationError } from '@aztec/circuit-types';
+import { SimulationError, UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
 import {
   AztecAddress,
   ContractStorageRead,
@@ -46,7 +46,7 @@ export interface PublicExecutionResult {
    * Unencrypted logs emitted during execution of this function call.
    * Note: These are preimages to `unencryptedLogsHash`.
    */
-  unencryptedLogs: FunctionL2Logs;
+  unencryptedLogs: UnencryptedFunctionL2Logs;
   /**
    * Whether the execution reverted.
    */
@@ -154,7 +154,7 @@ export function checkValidStaticCall(
   newNullifiers: SideEffectLinkedToNoteHash[],
   contractStorageUpdateRequests: ContractStorageUpdateRequest[],
   newL2ToL1Messages: L2ToL1Message[],
-  unencryptedLogs: FunctionL2Logs,
+  unencryptedLogs: UnencryptedFunctionL2Logs,
 ) {
   if (
     contractStorageUpdateRequests.length > 0 ||

package/src/public/executor.ts

@@ -1,4 +1,4 @@
-import { FunctionL2Logs } from '@aztec/circuit-types';
+import { UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
 import { Fr, GlobalVariables, Header, PublicCircuitPublicInputs } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 
@@ -92,7 +92,7 @@ export async function executePublicFunction(
       contractStorageReads: [],
       contractStorageUpdateRequests: [],
       nestedExecutions: [],
-      unencryptedLogs: FunctionL2Logs.empty(),
+      unencryptedLogs: UnencryptedFunctionL2Logs.empty(),
       reverted,
       revertReason,
     };
@@ -229,13 +229,15 @@ export class PublicExecutor {
     const hostStorage = new HostStorage(this.stateDb, this.contractsDb, this.commitmentsDb);
     const worldStateJournal = new AvmPersistableStateManager(hostStorage);
     const executionEnv = temporaryCreateAvmExecutionEnvironment(execution, globalVariables);
-    const machineState = new AvmMachineState(0, 0, 0);
+    // TODO(@spalladino) Load initial gas from the public execution request
+    const machineState = new AvmMachineState(100_000, 100_000, 100_000);
 
     const context = new AvmContext(worldStateJournal, executionEnv, machineState);
     const simulator = new AvmSimulator(context);
 
     const result = await simulator.execute();
     const newWorldState = context.persistableState.flush();
+    // TODO(@spalladino) Read gas left from machineState and return it
     return temporaryConvertAvmResults(execution, newWorldState, result);
   }
 

package/src/public/public_execution_context.ts

@@ -1,4 +1,4 @@
-import { FunctionL2Logs, NullifierMembershipWitness, UnencryptedL2Log } from '@aztec/circuit-types';
+import { NullifierMembershipWitness, UnencryptedFunctionL2Logs, UnencryptedL2Log } from '@aztec/circuit-types';
 import { CallContext, FunctionData, FunctionSelector, GlobalVariables, Header } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -72,7 +72,7 @@ export class PublicExecutionContext extends TypedOracle {
    * Return the encrypted logs emitted during this execution.
    */
   public getUnencryptedLogs() {
-    return new FunctionL2Logs(this.unencryptedLogs.map(log => log.toBuffer()));
+    return new UnencryptedFunctionL2Logs(this.unencryptedLogs);
   }
 
   /**
@@ -92,12 +92,15 @@ export class PublicExecutionContext extends TypedOracle {
   }
 
   /**
-   * Fetches the a message from the db, given its key.
-   * @param entryKey - A buffer representing the entry key.
-   * @returns The l1 to l2 message data
+   * Fetches a message from the db, given its key.
+   * @param contractAddress - Address of a contract by which the message was emitted.
+   * @param messageHash - Hash of the message.
+   * @param secret - Secret used to compute a nullifier.
+   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
+   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
    */
-  public async getL1ToL2MembershipWitness(entryKey: Fr) {
-    return await this.commitmentsDb.getL1ToL2MembershipWitness(entryKey);
+  public async getL1ToL2MembershipWitness(contractAddress: AztecAddress, messageHash: Fr, secret: Fr) {
+    return await this.commitmentsDb.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
   }
 
   /**

package/src/simulator/acvm_native.ts

@@ -0,0 +1,112 @@
+import { randomBytes } from '@aztec/foundation/crypto';
+import { NoirCompiledCircuit } from '@aztec/types/noir';
+
+import { WitnessMap } from '@noir-lang/types';
+import * as proc from 'child_process';
+import fs from 'fs/promises';
+
+import { SimulationProvider } from './simulation_provider.js';
+
+/**
+ * Parses a TOML format witness map string into a Map structure
+ * @param outputString - The witness map in TOML format
+ * @returns The parsed witness map
+ */
+function parseIntoWitnessMap(outputString: string) {
+  const lines = outputString.split('\n');
+  return new Map<number, string>(
+    lines
+      .filter((line: string) => line.length)
+      .map((line: string) => {
+        const pair = line.replaceAll(' ', '').split('=');
+        return [Number(pair[0]), pair[1].replaceAll('"', '')];
+      }),
+  );
+}
+
+/**
+ *
+ * @param inputWitness - The circuit's input witness
+ * @param bytecode - The circuit bytecode
+ * @param workingDirectory - A directory to use for temporary files by the ACVM
+ * @param pathToAcvm - The path to the ACVm binary
+ * @returns The completed partial witness outputted from the circuit
+ */
+export async function executeNativeCircuit(
+  inputWitness: WitnessMap,
+  bytecode: Buffer,
+  workingDirectory: string,
+  pathToAcvm: string,
+) {
+  const bytecodeFilename = 'bytecode';
+  const witnessFilename = 'input_witness.toml';
+
+  // convert the witness map to TOML format
+  let witnessMap = '';
+  inputWitness.forEach((value: string, key: number) => {
+    witnessMap = witnessMap.concat(`${key} = '${value}'\n`);
+  });
+
+  // In case the directory is still around from some time previously, remove it
+  await fs.rm(workingDirectory, { recursive: true, force: true });
+  // Create the new working directory
+  await fs.mkdir(workingDirectory, { recursive: true });
+  // Write the bytecode and input witness to the working directory
+  await fs.writeFile(`${workingDirectory}/${bytecodeFilename}`, bytecode);
+  await fs.writeFile(`${workingDirectory}/${witnessFilename}`, witnessMap);
+
+  // Execute the ACVM using the given args
+  const args = [
+    `execute`,
+    `--working-directory`,
+    `${workingDirectory}`,
+    `--bytecode`,
+    `${bytecodeFilename}`,
+    `--input-witness`,
+    `${witnessFilename}`,
+    `--print`,
+  ];
+  const processPromise = new Promise<string>((resolve, reject) => {
+    let outputWitness = Buffer.alloc(0);
+    let errorBuffer = Buffer.alloc(0);
+    const acvm = proc.spawn(pathToAcvm, args);
+    acvm.stdout.on('data', data => {
+      outputWitness = Buffer.concat([outputWitness, data]);
+    });
+    acvm.stderr.on('data', data => {
+      errorBuffer = Buffer.concat([errorBuffer, data]);
+    });
+    acvm.on('close', code => {
+      if (code === 0) {
+        resolve(outputWitness.toString('utf-8'));
+      } else {
+        reject(errorBuffer.toString('utf-8'));
+      }
+    });
+  });
+
+  try {
+    const output = await processPromise;
+    return parseIntoWitnessMap(output);
+  } finally {
+    // Clean up the working directory before we leave
+    await fs.rm(workingDirectory, { recursive: true, force: true });
+  }
+}
+
+export class NativeACVMSimulator implements SimulationProvider {
+  constructor(private workingDirectory: string, private pathToAcvm: string) {}
+  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+    // Execute the circuit on those initial witness values
+
+    // Decode the bytecode from base64 since the acvm does not know about base64 encoding
+    const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+
+    // Provide a unique working directory so we don't get clashes with parallel executions
+    const directory = `${this.workingDirectory}/${randomBytes(32).toString('hex')}`;
+    // Execute the circuit
+    const _witnessMap = await executeNativeCircuit(input, decodedBytecode, directory, this.pathToAcvm);
+
+    return _witnessMap;
+  }
+}

package/src/simulator/acvm_wasm.ts

@@ -0,0 +1,31 @@
+import { NoirCompiledCircuit } from '@aztec/types/noir';
+
+import { WasmBlackBoxFunctionSolver, createBlackBoxSolver, executeCircuitWithBlackBoxSolver } from '@noir-lang/acvm_js';
+import { WitnessMap } from '@noir-lang/types';
+
+import { SimulationProvider } from './simulation_provider.js';
+
+let solver: Promise<WasmBlackBoxFunctionSolver>;
+
+const getSolver = (): Promise<WasmBlackBoxFunctionSolver> => {
+  if (!solver) {
+    solver = createBlackBoxSolver();
+  }
+  return solver;
+};
+
+export class WASMSimulator implements SimulationProvider {
+  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+    // Execute the circuit on those initial witness values
+    //
+    // Decode the bytecode from base64 since the acvm does not know about base64 encoding
+    const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+    //
+    // Execute the circuit
+    const _witnessMap = await executeCircuitWithBlackBoxSolver(await getSolver(), decodedBytecode, input, () => {
+      throw Error('unexpected oracle during execution');
+    });
+
+    return _witnessMap;
+  }
+}

package/src/simulator/index.ts

@@ -0,0 +1,3 @@
+export * from './acvm_native.js';
+export * from './acvm_wasm.js';
+export * from './simulation_provider.js';

package/src/simulator/simulation_provider.ts

@@ -0,0 +1,10 @@
+import { NoirCompiledCircuit } from '@aztec/types/noir';
+
+import { WitnessMap } from '@noir-lang/types';
+
+/**
+ * Low level simulation interface
+ */
+export interface SimulationProvider {
+  simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap>;
+}

package/src/test/utils.ts

@@ -1,7 +1,7 @@
 import { L1Actor, L1ToL2Message, L2Actor } from '@aztec/circuit-types';
 import { AztecAddress, EthAddress, Fr } from '@aztec/circuits.js';
 import { computeMessageSecretHash } from '@aztec/circuits.js/hash';
-import { sha256 } from '@aztec/foundation/crypto';
+import { sha256ToField } from '@aztec/foundation/crypto';
 
 /**
  * Test utility function to craft an L1 to L2 message.
@@ -20,9 +20,7 @@ export const buildL1ToL2Message = (
   // Write the selector into a buffer.
   const selectorBuf = Buffer.from(selector, 'hex');
 
-  const contentBuf = Buffer.concat([selectorBuf, ...contentPreimage.map(field => field.toBuffer())]);
-  const content = Fr.fromBufferReduce(sha256(contentBuf));
-
+  const content = sha256ToField([selectorBuf, ...contentPreimage]);
   const secretHash = computeMessageSecretHash(secret);
 
   // Eventually the kernel will need to prove the kernel portal pair exists within the contract tree,

package/src/utils.ts

@@ -14,5 +14,5 @@ export function computeSlotForMapping(
     toField: () => Fr;
   },
 ) {
-  return pedersenHash([mappingSlot, key.toField()].map(field => field.toBuffer()));
+  return pedersenHash([mappingSlot, key.toField()]);
 }