feat(avm): plumb execution hints from TS to AVM prover

Author: dbanks12

barretenberg/cpp/src/barretenberg/bb/main.cpp

@@ -516,27 +516,33 @@ void vk_as_fields(const std::string& vk_path, const std::string& output_path)
  *
  * @param bytecode_path Path to the file containing the serialised bytecode
  * @param calldata_path Path to the file containing the serialised calldata (could be empty)
- * @param crs_path Path to the file containing the CRS (ignition is suitable for now)
+ * @param public_inputs_path Path to the file containing the serialised avm public inputs
+ * @param hints_path Path to the file containing the serialised avm circuit hints
  * @param output_path Path (directory) to write the output proof and verification keys
  */
 void avm_prove(const std::filesystem::path& bytecode_path,
                const std::filesystem::path& calldata_path,
+               const std::filesystem::path& public_inputs_path,
+               const std::filesystem::path& hints_path,
                const std::filesystem::path& output_path)
 {
     // Get Bytecode
-    std::vector<uint8_t> const avm_bytecode =
+    std::vector<uint8_t> const bytecode =
         bytecode_path.extension() == ".gz" ? gunzip(bytecode_path) : read_file(bytecode_path);
-    std::vector<uint8_t> call_data_bytes{};
-    if (std::filesystem::exists(calldata_path)) {
-        call_data_bytes = read_file(calldata_path);
+    std::vector<fr> const calldata = many_from_buffer<fr>(read_file(calldata_path));
+    std::vector<fr> const public_inputs_vec = many_from_buffer<fr>(read_file(public_inputs_path));
+    std::vector<uint8_t> avm_hints;
+    try {
+        avm_hints = read_file(hints_path);
+    } catch (std::runtime_error const& err) {
+        vinfo("No hints were provided for avm proving.... Might be fine!");
     }
-    std::vector<fr> const call_data = many_from_buffer<fr>(call_data_bytes);
 
     // Hardcoded circuit size for now, with enough to support 16-bit range checks
     init_bn254_crs(1 << 17);
 
     // Prove execution and return vk
-    auto const [verification_key, proof] = avm_trace::Execution::prove(avm_bytecode, call_data);
+    auto const [verification_key, proof] = avm_trace::Execution::prove(bytecode, calldata);
     // TODO(ilyas): <#4887>: Currently we only need these two parts of the vk, look into pcs_verification key reqs
     std::vector<uint64_t> vk_vector = { verification_key.circuit_size, verification_key.num_public_inputs };
     std::vector<fr> vk_as_fields = { verification_key.circuit_size, verification_key.num_public_inputs };
@@ -891,11 +897,14 @@ int main(int argc, char* argv[])
             std::string output_path = get_option(args, "-o", vk_path + "_fields.json");
             vk_as_fields(vk_path, output_path);
         } else if (command == "avm_prove") {
-            std::filesystem::path avm_bytecode_path = get_option(args, "-b", "./target/avm_bytecode.bin");
-            std::filesystem::path calldata_path = get_option(args, "-d", "./target/call_data.bin");
+            std::filesystem::path avm_bytecode_path = get_option(args, "--avm-bytecode", "./target/avm_bytecode.bin");
+            std::filesystem::path avm_calldata_path = get_option(args, "--avm-calldata", "./target/avm_calldata.bin");
+            std::filesystem::path avm_public_inputs_path =
+                get_option(args, "--avm-public-inputs", "./target/avm_public_inputs.bin");
+            std::filesystem::path avm_hints_path = get_option(args, "--avm-hints", "./target/avm_hints.bin");
             // This outputs both files: proof and vk, under the given directory.
             std::filesystem::path output_path = get_option(args, "-o", "./proofs");
-            avm_prove(avm_bytecode_path, calldata_path, output_path);
+            avm_prove(avm_bytecode_path, avm_calldata_path, avm_public_inputs_path, avm_hints_path, output_path);
         } else if (command == "avm_verify") {
             return avm_verify(proof_path, vk_path) ? 0 : 1;
         } else if (command == "prove_ultra_honk") {

yarn-project/bb-prover/src/avm_proving.test.ts

@@ -1,3 +1,4 @@
+import { AvmCircuitInputs, Gas, PublicCircuitPublicInputs } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { AvmSimulator } from '@aztec/simulator';
@@ -7,6 +8,10 @@ import fs from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'path';
 
+import {
+  convertAvmResultsToPxResult,
+  createPublicExecution,
+} from '../../simulator/src/public/transitional_adaptors.js';
 import { type BBSuccess, BB_RESULT, generateAvmProof, verifyAvmProof } from './bb/execute.js';
 import { extractVkData } from './verification_key/verification_key_data.js';
 
@@ -16,8 +21,14 @@ describe('AVM WitGen, proof generation and verification', () => {
   it(
     'Should prove valid execution contract function that performs addition',
     async () => {
+      const startSideEffectCounter = 0;
       const calldata: Fr[] = [new Fr(1), new Fr(2)];
-      const context = initContext({ env: initExecutionEnvironment({ calldata }) });
+      const environment = initExecutionEnvironment({ calldata });
+      const context = initContext({ env: environment });
+
+      const startGas = new Gas(context.machineState.gasLeft.daGas, context.machineState.gasLeft.l2Gas);
+      const oldPublicExecution = createPublicExecution(startSideEffectCounter, environment, calldata);
+
       const internalLogger = createDebugLogger('aztec:avm-proving-test');
       const logger = (msg: string, _data?: any) => internalLogger.verbose(msg);
       const bytecode = getAvmTestContractBytecode('add_args_return');
@@ -27,18 +38,30 @@ describe('AVM WitGen, proof generation and verification', () => {
 
       // First we simulate (though it's not needed in this simple case).
       const simulator = new AvmSimulator(context);
-      const results = await simulator.executeBytecode(bytecode);
-      expect(results.reverted).toBe(false);
+      const avmResult = await simulator.executeBytecode(bytecode);
+      expect(avmResult.reverted).toBe(false);
 
-      // Then we prove.
+      const pxResult = convertAvmResultsToPxResult(
+        avmResult,
+        startSideEffectCounter,
+        oldPublicExecution,
+        startGas,
+        context,
+        simulator.getBytecode(),
+      );
+      // TODO(dbanks12): public inputs should not be empty.... Need to construct them from AvmContext?
       const uncompressedBytecode = simulator.getBytecode()!;
-      const proofRes = await generateAvmProof(
-        bbPath,
-        bbWorkingDirectory,
+      const publicInputs = PublicCircuitPublicInputs.empty();
+      publicInputs.startGasLeft = startGas;
+      const avmCircuitInputs = new AvmCircuitInputs(
         uncompressedBytecode,
         context.environment.calldata,
-        logger,
+        publicInputs,
+        pxResult.avmHints,
       );
+
+      // Then we prove.
+      const proofRes = await generateAvmProof(bbPath, bbWorkingDirectory, avmCircuitInputs, logger);
       expect(proofRes.status).toEqual(BB_RESULT.SUCCESS);
 
       // Then we test VK extraction.

yarn-project/bb-prover/src/bb/execute.ts

@@ -1,4 +1,4 @@
-import { type Fr } from '@aztec/circuits.js';
+import { type AvmCircuitInputs } from '@aztec/circuits.js';
 import { sha256 } from '@aztec/foundation/crypto';
 import { type LogFn } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
@@ -265,8 +265,7 @@ export async function generateProof(
 export async function generateAvmProof(
   pathToBB: string,
   workingDirectory: string,
-  bytecode: Buffer,
-  calldata: Fr[],
+  input: AvmCircuitInputs,
   log: LogFn,
 ): Promise<BBFailure | BBSuccess> {
   // Check that the working directory exists
@@ -277,8 +276,10 @@ export async function generateAvmProof(
   }
 
   // Paths for the inputs
-  const calldataPath = join(workingDirectory, 'calldata.bin');
   const bytecodePath = join(workingDirectory, 'avm_bytecode.bin');
+  const calldataPath = join(workingDirectory, 'avm_calldata.bin');
+  const publicInputsPath = join(workingDirectory, 'avm_public_inputs.bin');
+  const avmHintsPath = join(workingDirectory, 'avm_hints.bin');
 
   // The proof is written to e.g. /workingDirectory/proof
   const outputPath = workingDirectory;
@@ -296,19 +297,45 @@ export async function generateAvmProof(
 
   try {
     // Write the inputs to the working directory.
-    await fs.writeFile(bytecodePath, bytecode);
+    await fs.writeFile(bytecodePath, input.bytecode);
     if (!filePresent(bytecodePath)) {
       return { status: BB_RESULT.FAILURE, reason: `Could not write bytecode at ${bytecodePath}` };
     }
     await fs.writeFile(
       calldataPath,
-      calldata.map(fr => fr.toBuffer()),
+      input.calldata.map(fr => fr.toBuffer()),
     );
     if (!filePresent(calldataPath)) {
       return { status: BB_RESULT.FAILURE, reason: `Could not write calldata at ${calldataPath}` };
     }
 
-    const args = ['-b', bytecodePath, '-d', calldataPath, '-o', outputPath];
+    // public inputs are used directly as a vector of fields in C++,
+    // so we serialize them as such here instead of just using toBuffer
+    await fs.writeFile(
+      publicInputsPath,
+      input.publicInputs.toFields().map(fr => fr.toBuffer()),
+    );
+    if (!filePresent(publicInputsPath)) {
+      return { status: BB_RESULT.FAILURE, reason: `Could not write publicInputs at ${publicInputsPath}` };
+    }
+
+    await fs.writeFile(avmHintsPath, input.avmHints.toBuffer());
+    if (!filePresent(avmHintsPath)) {
+      return { status: BB_RESULT.FAILURE, reason: `Could not write avmHints at ${avmHintsPath}` };
+    }
+
+    const args = [
+      '--avm-bytecode',
+      bytecodePath,
+      '--avm-calldata',
+      calldataPath,
+      '--avm-public-inputs',
+      publicInputsPath,
+      '--avm-hints',
+      avmHintsPath,
+      '-o',
+      outputPath,
+    ];
     const timer = new Timer();
     const logFunction = (message: string) => {
       log(`AvmCircuit (prove) BB out - ${message}`);

yarn-project/bb-prover/src/prover/bb_prover.ts

@@ -465,13 +465,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   private async generateAvmProofWithBB(input: AvmCircuitInputs, workingDirectory: string): Promise<BBSuccess> {
     logger.debug(`Proving avm-circuit...`);
 
-    const provingResult = await generateAvmProof(
-      this.config.bbBinaryPath,
-      workingDirectory,
-      input.bytecode,
-      input.calldata,
-      logger.debug,
-    );
+    const provingResult = await generateAvmProof(this.config.bbBinaryPath, workingDirectory, input, logger.debug);
 
     if (provingResult.status === BB_RESULT.FAILURE) {
       logger.error(`Failed to generate proof for avm-circuit: ${provingResult.reason}`);

yarn-project/circuit-types/src/tx/processed_tx.ts

@@ -10,6 +10,7 @@ import {
   UnencryptedTxL2Logs,
 } from '@aztec/circuit-types';
 import {
+  type AvmExecutionHints,
   Fr,
   type Gas,
   type GasFees,
@@ -55,6 +56,7 @@ export type AvmProvingRequest = {
   type: typeof AVM_REQUEST;
   bytecode: Buffer;
   calldata: Fr[];
+  avmHints: AvmExecutionHints;
   kernelRequest: PublicKernelNonTailRequest;
 };
 

yarn-project/circuits.js/src/structs/avm/avm.ts

@@ -1,10 +1,86 @@
 import { type Fr } from '@aztec/foundation/fields';
-import { serializeToBuffer } from '@aztec/foundation/serialize';
+import { serializeArrayOfBufferableToVector, serializeToBuffer } from '@aztec/foundation/serialize';
 import { type FieldsOf } from '@aztec/foundation/types';
 
-// TODO(https://github.com/AztecProtocol/aztec-packages/issues/6774): add public inputs.
+import { type PublicCircuitPublicInputs } from '../public_circuit_public_inputs.js';
+
+export class AvmHint {
+  constructor(public readonly key: Fr, public readonly value: Fr) {}
+
+  /**
+   * Serializes the inputs to a buffer.
+   * @returns - The inputs serialized to a buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(...AvmHint.getFields(this));
+  }
+
+  /**
+   * Serializes the inputs to a hex string.
+   * @returns The instance serialized to a hex string.
+   */
+  toString() {
+    return this.toBuffer().toString('hex');
+  }
+
+  /**
+   * Extracts fields from an instance.
+   * @param fields - Fields to create the instance from.
+   * @returns An array of fields.
+   */
+  static getFields(fields: FieldsOf<AvmHint>) {
+    return [fields.key, fields.value] as const;
+  }
+}
+
+export class AvmExecutionHints {
+  constructor(
+    public readonly storageValues: AvmHint[],
+    public readonly noteHashExists: AvmHint[],
+    public readonly nullifierExists: AvmHint[],
+    public readonly l1ToL2MessageExists: AvmHint[],
+  ) {}
+
+  /**
+   * Serializes the inputs to a buffer.
+   * @returns - The inputs serialized to a buffer.
+   */
+  toBuffer() {
+    // Need to use serializeArrayOfBufferableToVector here to include array length in serialization
+    return serializeToBuffer(
+      AvmExecutionHints.getFields(this).map(hintArray => serializeArrayOfBufferableToVector(hintArray)),
+    );
+  }
+
+  /**
+   * Serializes the inputs to a hex string.
+   * @returns The instance serialized to a hex string.
+   */
+  toString() {
+    return this.toBuffer().toString('hex');
+  }
+
+  /**
+   * Extracts fields from an instance.
+   * @param fields - Fields to create the instance from.
+   * @returns An array of fields.
+   */
+  static getFields(fields: FieldsOf<AvmExecutionHints>) {
+    return [fields.storageValues, fields.noteHashExists, fields.nullifierExists, fields.l1ToL2MessageExists] as const;
+  }
+
+  static empty() {
+    return new AvmExecutionHints([], [], [], []);
+  }
+}
+
 export class AvmCircuitInputs {
-  constructor(public readonly bytecode: Buffer, public readonly calldata: Fr[]) {}
+  constructor(
+    public readonly bytecode: Buffer,
+    public readonly calldata: Fr[],
+    public readonly publicInputs: PublicCircuitPublicInputs,
+    public readonly avmHints: AvmExecutionHints,
+  ) {}
 
   /**
    * Serializes the inputs to a buffer.
@@ -37,6 +113,6 @@ export class AvmCircuitInputs {
    * @returns An array of fields.
    */
   static getFields(fields: FieldsOf<AvmCircuitInputs>) {
-    return [fields.bytecode, fields.calldata] as const;
+    return [fields.bytecode, fields.calldata, fields.publicInputs, fields.avmHints] as const;
   }
 }

yarn-project/prover-client/src/orchestrator/orchestrator.ts

@@ -765,6 +765,8 @@ export class ProvingOrchestrator {
         const inputs: AvmCircuitInputs = new AvmCircuitInputs(
           publicFunction.vmRequest!.bytecode,
           publicFunction.vmRequest!.calldata,
+          publicFunction.vmRequest!.kernelRequest.inputs.publicCall.callStackItem.publicInputs,
+          publicFunction.vmRequest!.avmHints,
         );
         try {
           return await this.prover.getAvmProof(inputs, signal);

yarn-project/simulator/src/avm/journal/trace.test.ts

@@ -86,6 +86,7 @@ describe('world state access trace', () => {
         leafIndex: leafIndex,
         msgHash: utxo,
         exists: exists,
+        counter: new Fr(0),
       };
       expect(trace.l1ToL2MessageChecks).toEqual([expectedCheck]);
       expect(trace.getAccessCounter()).toEqual(1);

yarn-project/simulator/src/avm/journal/trace.ts

@@ -1,3 +1,4 @@
+import { AvmExecutionHints, AvmHint } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 
 import {
@@ -131,6 +132,7 @@ export class WorldStateAccessTrace {
       leafIndex: msgLeafIndex,
       msgHash: msgHash,
       exists: exists,
+      counter: new Fr(this.accessCounter),
       //endLifetime: Fr.ZERO, // FIXME
     };
     this.l1ToL2MessageChecks.push(traced);
@@ -169,4 +171,14 @@ export class WorldStateAccessTrace {
     // it is assumed that the incoming trace was initialized with this as parent, so accept counter
     this.accessCounter = incomingTrace.accessCounter;
   }
+
+  // TODO(dbanks12): should only return hints for one call.... shouldn't include nested calls (merged in traces)
+  public toHints(): AvmExecutionHints {
+    return new AvmExecutionHints(
+      this.publicStorageReads.map(read => new AvmHint(read.counter, read.value)),
+      this.noteHashChecks.map(check => new AvmHint(check.counter, new Fr(check.exists ? 1 : 0))),
+      this.nullifierChecks.map(check => new AvmHint(check.counter, new Fr(check.exists ? 1 : 0))),
+      this.l1ToL2MessageChecks.map(check => new AvmHint(check.counter, new Fr(check.exists ? 1 : 0))),
+    );
+  }
 }

yarn-project/simulator/src/avm/journal/trace_types.ts

@@ -71,6 +71,7 @@ export type TracedL1toL2MessageCheck = {
   leafIndex: Fr;
   msgHash: Fr;
   exists: boolean;
+  counter: Fr;
   //endLifetime: Fr;
 };