@aztec/simulator 0.26.5 → 0.27.0

package/src/public/executor.ts

@@ -1,6 +1,11 @@
+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';
@@ -11,10 +16,10 @@ import {
   temporaryConvertAvmResults,
   temporaryCreateAvmExecutionEnvironment,
 } from '../avm/temporary_executor_migration.js';
+import { AcirSimulator } from '../client/simulator.js';
 import { ExecutionError, createSimulationError } from '../common/errors.js';
 import { SideEffectCounter } from '../common/index.js';
 import { PackedArgsCache } from '../common/packed_args_cache.js';
-import { AcirSimulator } from '../index.js';
 import { CommitmentsDB, PublicContractsDB, PublicStateDB } from './db.js';
 import { PublicExecution, PublicExecutionResult, checkValidStaticCall } from './execution.js';
 import { PublicExecutionContext } from './public_execution_context.js';
@@ -25,6 +30,7 @@ import { PublicExecutionContext } from './public_execution_context.js';
 export async function executePublicFunction(
   context: PublicExecutionContext,
   acir: Buffer,
+  nested: boolean,
   log = createDebugLogger('aztec:simulator:public_execution'),
 ): Promise<PublicExecutionResult> {
   const execution = context.execution;
@@ -34,9 +40,19 @@ export async function executePublicFunction(
 
   const initialWitness = context.getInitialWitness();
   const acvmCallback = new Oracle(context);
-  const { partialWitness } = await acvm(await AcirSimulator.getSolver(), acir, initialWitness, acvmCallback).catch(
-    (err: Error) => {
-      throw new ExecutionError(
+  const { partialWitness, reverted, revertReason } = await acvm(
+    await AcirSimulator.getSolver(),
+    acir,
+    initialWitness,
+    acvmCallback,
+  )
+    .then(result => ({
+      partialWitness: result.partialWitness,
+      reverted: false,
+      revertReason: undefined,
+    }))
+    .catch((err: Error) => {
+      const ee = new ExecutionError(
         err.message,
         {
           contractAddress,
@@ -45,17 +61,53 @@ export async function executePublicFunction(
         extractCallStack(err),
         { cause: err },
       );
-    },
-  );
+
+      if (nested) {
+        // If we're nested, throw the error so the parent can handle it
+        throw ee;
+      } else {
+        return {
+          partialWitness: undefined,
+          reverted: true,
+          revertReason: createSimulationError(ee),
+        };
+      }
+    });
+  if (reverted) {
+    if (!revertReason) {
+      throw new Error('Reverted but no revert reason');
+    }
+
+    return {
+      execution,
+      returnValues: [],
+      newNoteHashes: [],
+      newL2ToL1Messages: [],
+      newNullifiers: [],
+      nullifierReadRequests: [],
+      contractStorageReads: [],
+      contractStorageUpdateRequests: [],
+      nestedExecutions: [],
+      unencryptedLogs: FunctionL2Logs.empty(),
+      reverted,
+      revertReason,
+    };
+  }
+
+  if (!partialWitness) {
+    throw new Error('No partial witness returned from ACVM');
+  }
 
   const returnWitness = extractReturnWitness(acir, partialWitness);
   const {
     returnValues,
+    nullifierReadRequests: nullifierReadRequestsPadded,
     newL2ToL1Msgs,
     newNoteHashes: newNoteHashesPadded,
     newNullifiers: newNullifiersPadded,
   } = PublicCircuitPublicInputs.fromFields(returnWitness);
 
+  const nullifierReadRequests = nullifierReadRequestsPadded.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());
@@ -81,11 +133,14 @@ export async function executePublicFunction(
     newNoteHashes,
     newL2ToL1Messages,
     newNullifiers,
+    nullifierReadRequests,
     contractStorageReads,
     contractStorageUpdateRequests,
     returnValues,
     nestedExecutions,
     unencryptedLogs,
+    reverted: false,
+    revertReason: undefined,
   };
 }
 
@@ -130,13 +185,7 @@ export class PublicExecutor {
       this.commitmentsDb,
     );
 
-    let executionResult;
-
-    try {
-      executionResult = await executePublicFunction(context, acir);
-    } catch (err) {
-      throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during public execution'));
-    }
+    const executionResult = await executePublicFunction(context, acir, false /** nested */);
 
     if (executionResult.execution.callContext.isStaticCall) {
       checkValidStaticCall(
@@ -175,4 +224,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
@@ -211,7 +210,7 @@ export class PublicExecutionContext extends TypedOracle {
       this.log,
     );
 
-    const childExecutionResult = await executePublicFunction(context, acir);
+    const childExecutionResult = await executePublicFunction(context, acir, true /** nested */);
 
     if (isStaticCall) {
       checkValidStaticCall(