@aztec/simulator 0.30.0 → 0.31.0

package/src/public/public_execution_context.ts

@@ -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.
@@ -21,8 +21,7 @@ export const buildL1ToL2Message = (
   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(contentBuf);
   const secretHash = computeMessageSecretHash(secret);
 
   // Eventually the kernel will need to prove the kernel portal pair exists within the contract tree,