@aztec/simulator 0.26.6 → 0.27.1

package/src/public/executor.ts

@@ -2,6 +2,10 @@ import { FunctionL2Logs } from '@aztec/circuit-types';
 import { GlobalVariables, Header, PublicCircuitPublicInputs } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+
 import { Oracle, acvm, extractCallStack, extractReturnWitness } from '../acvm/index.js';
 import { AvmContext } from '../avm/avm_context.js';
 import { AvmMachineState } from '../avm/avm_machine_state.js';
@@ -81,6 +85,7 @@ export async function executePublicFunction(
       newL2ToL1Messages: [],
       newNullifiers: [],
       nullifierReadRequests: [],
+      nullifierNonExistentReadRequests: [],
       contractStorageReads: [],
       contractStorageUpdateRequests: [],
       nestedExecutions: [],
@@ -98,12 +103,14 @@ export async function executePublicFunction(
   const {
     returnValues,
     nullifierReadRequests: nullifierReadRequestsPadded,
+    nullifierNonExistentReadRequests: nullifierNonExistentReadRequestsPadded,
     newL2ToL1Msgs,
     newNoteHashes: newNoteHashesPadded,
     newNullifiers: newNullifiersPadded,
   } = PublicCircuitPublicInputs.fromFields(returnWitness);
 
   const nullifierReadRequests = nullifierReadRequestsPadded.filter(v => !v.isEmpty());
+  const nullifierNonExistentReadRequests = nullifierNonExistentReadRequestsPadded.filter(v => !v.isEmpty());
   const newL2ToL1Messages = newL2ToL1Msgs.filter(v => !v.isEmpty());
   const newNoteHashes = newNoteHashesPadded.filter(v => !v.isEmpty());
   const newNullifiers = newNullifiersPadded.filter(v => !v.isEmpty());
@@ -130,6 +137,7 @@ export async function executePublicFunction(
     newL2ToL1Messages,
     newNullifiers,
     nullifierReadRequests,
+    nullifierNonExistentReadRequests,
     contractStorageReads,
     contractStorageUpdateRequests,
     returnValues,
@@ -220,4 +228,99 @@ export class PublicExecutor {
     const newWorldState = context.persistableState.flush();
     return temporaryConvertAvmResults(execution, newWorldState, result);
   }
+
+  /**
+   * These functions are currently housed in the temporary executor as it relies on access to
+   * oracles like the contractsDB and this is the least intrusive way to achieve this.
+   * When we remove this executor(tracking issue #4792) and have an interface that is compatible with the kernel circuits,
+   * this will be moved to sequencer-client/prover.
+   */
+
+  /**
+   * Generates a proof for an associated avm execution. This is currently only used for testing purposes,
+   * as proof generation is not fully complete in the AVM yet.
+   * @param execution - The execution to run.
+   * @returns An AVM proof and the verification key.
+   */
+  public async getAvmProof(avmExecution: PublicExecution): Promise<Buffer[]> {
+    // The paths for the barretenberg binary and the write path are hardcoded for now.
+    // We additionally need the path to a valid crs for proof generation.
+    // const bbPath = '../../barretenberg/cpp';
+    const bbPath = path.resolve('../../barretenberg/cpp');
+    const artifactsPath = path.resolve('target');
+
+    // Create the directory if it does not exist
+    await fs.mkdir(artifactsPath, { recursive: true });
+
+    const calldataPath = path.join(artifactsPath, 'calldata.bin');
+    const bytecodePath = path.join(artifactsPath, 'avm_bytecode.bin');
+    const proofPath = path.join(artifactsPath, 'proof');
+
+    const { args, functionData, contractAddress } = avmExecution;
+    const bytecode = await this.contractsDb.getBytecode(contractAddress, functionData.selector);
+    // Write call data and bytecode to files.
+    await Promise.all([
+      fs.writeFile(
+        calldataPath,
+        args.map(c => c.toBuffer()),
+      ),
+      fs.writeFile(bytecodePath, bytecode!),
+    ]);
+
+    const bbBinary = spawn(path.join(bbPath, 'build', 'bin', 'bb'), [
+      'avm_prove',
+      '-b',
+      bytecodePath,
+      '-d',
+      calldataPath,
+      '-c',
+      path.join(bbPath, 'srs_db', 'ignition'),
+      '-o',
+      proofPath,
+    ]);
+    // The binary writes the proof and the verification key to the write path.
+    return new Promise((resolve, reject) => {
+      bbBinary.on('close', () => {
+        resolve(Promise.all([fs.readFile(proofPath), fs.readFile(path.join(artifactsPath, 'vk'))]));
+      });
+      // Catch and propagate errors from spawning
+      bbBinary.on('error', err => {
+        reject(err);
+      });
+    });
+  }
+  /**
+   * Verifies an AVM proof. This function is currently only used for testing purposes, as verification
+   * is not fully complete in the AVM yet.
+   * @param vk - The verification key to use.
+   * @param proof - The proof to verify.
+   * @returns True if the proof is valid, false otherwise.
+   */
+  async verifyAvmProof(vk: Buffer, proof: Buffer): Promise<boolean> {
+    // The relative paths for the barretenberg binary and the write path are hardcoded for now.
+    const bbPath = path.resolve('../../barretenberg/cpp');
+    const artifactsPath = path.resolve('./target');
+
+    const vkPath = path.join(artifactsPath, 'vk');
+    const proofPath = path.join(artifactsPath, 'proof');
+
+    // Write the verification key and the proof to files.
+    await Promise.all([fs.writeFile(vkPath, vk), fs.writeFile(proofPath, proof)]);
+
+    const bbBinary = spawn(path.join(bbPath, 'build', 'bin', 'bb'), ['avm_verify', '-p', proofPath]);
+    // The binary prints to stdout 1 if the proof is valid and 0 if it is not.
+    return new Promise((resolve, reject) => {
+      let result = Buffer.alloc(0);
+      bbBinary.stdout.on('data', data => {
+        result += data;
+      });
+      bbBinary.on('close', () => {
+        resolve(result.toString() === '1');
+      });
+      // Catch and propagate errors from spawning
+      bbBinary.on('error', err => {
+        reject(err);
+      });
+    });
+  }
 }

package/src/public/public_execution_context.ts

@@ -186,7 +186,6 @@ export class PublicExecutionContext extends TypedOracle {
       storageContractAddress: isDelegateCall ? this.execution.contractAddress : targetContractAddress,
       portalContractAddress: portalAddress,
       functionSelector,
-      isContractDeployment: false,
       isDelegateCall,
       isStaticCall,
       startSideEffectCounter: 0, // TODO use counters in public execution