Merge branch 'next' into merge-train/fairies

Author: AztecBot

barretenberg/cpp/src/barretenberg/api/api_avm.hpp

@@ -1,8 +1,38 @@
 #pragma once
 #include <filesystem>
+#include <vector>
+
+#include "barretenberg/ecc/curves/bn254/fr.hpp"
 
 namespace bb {
 
+/**
+ * @brief Result of in-memory AVM proving.
+ */
+struct AvmProveResult {
+    std::vector<bb::fr> proof;
+};
+
+/**
+ * @brief Prove an AVM transaction from serialized inputs (msgpack bytes).
+ * Callers that need to verify the proof should call avm_verify_from_bytes separately.
+ */
+AvmProveResult avm_prove_from_bytes(std::vector<uint8_t> inputs);
+
+/**
+ * @brief Verify an AVM proof from serialized data.
+ * @param proof The proof as a vector of field elements.
+ * @param public_inputs Serialized public inputs (msgpack bytes).
+ * @return true if verification succeeds.
+ */
+bool avm_verify_from_bytes(std::vector<bb::fr> proof, std::vector<uint8_t> public_inputs);
+
+/**
+ * @brief Check the AVM circuit from serialized inputs (msgpack bytes).
+ * @return true if the circuit check passes.
+ */
+bool avm_check_circuit_from_bytes(std::vector<uint8_t> inputs);
+
 // Global flag indicating AVM support is available
 extern const bool avm_enabled;
 

barretenberg/cpp/src/barretenberg/bbapi/bbapi_avm.cpp

@@ -0,0 +1,52 @@
+#include "barretenberg/bbapi/bbapi_avm.hpp"
+#include "barretenberg/api/api_avm.hpp"
+#include "barretenberg/vm2/tooling/stats.hpp"
+
+namespace bb::bbapi {
+
+namespace {
+
+// Reset the AVM per-stage timings registry so the snapshot we return reflects only this call.
+void reset_avm_stats()
+{
+    ::bb::avm2::Stats::get().reset();
+}
+
+// Take a snapshot of the AVM per-stage timings registry and convert it to the wire-format struct.
+std::vector<AvmStat> snapshot_avm_stats()
+{
+    auto snapshot = ::bb::avm2::Stats::get().snapshot();
+    std::vector<AvmStat> result;
+    result.reserve(snapshot.size());
+    for (auto& [name, value] : snapshot) {
+        result.push_back(AvmStat{ .name = std::move(name), .value_ms = value });
+    }
+    return result;
+}
+
+} // namespace
+
+AvmProve::Response AvmProve::execute(const BBApiRequest& /*request*/) &&
+{
+    reset_avm_stats();
+    auto result = avm_prove_from_bytes(std::move(inputs));
+    return Response{
+        .proof = std::move(result.proof),
+        .stats = snapshot_avm_stats(),
+    };
+}
+
+AvmVerify::Response AvmVerify::execute(const BBApiRequest& /*request*/) &&
+{
+    bool verified = avm_verify_from_bytes(std::move(proof), std::move(public_inputs));
+    return Response{ .verified = verified };
+}
+
+AvmCheckCircuit::Response AvmCheckCircuit::execute(const BBApiRequest& /*request*/) &&
+{
+    reset_avm_stats();
+    bool passed = avm_check_circuit_from_bytes(std::move(inputs));
+    return Response{ .passed = passed, .stats = snapshot_avm_stats() };
+}
+
+} // namespace bb::bbapi

barretenberg/cpp/src/barretenberg/bbapi/bbapi_avm.hpp

@@ -0,0 +1,102 @@
+#pragma once
+/**
+ * @file bbapi_avm.hpp
+ * @brief AVM-specific command definitions for the Barretenberg RPC API.
+ *
+ * This file contains command structures for AVM operations including proving,
+ * verification, and circuit checking. When built with bb (non-AVM), these
+ * commands return an error response. When built with bb-avm, they work normally.
+ */
+#include "barretenberg/bbapi/bbapi_shared.hpp"
+#include "barretenberg/common/named_union.hpp"
+#include "barretenberg/ecc/curves/bn254/fr.hpp"
+#include "barretenberg/serialize/msgpack.hpp"
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace bb::bbapi {
+
+/**
+ * @struct AvmStat
+ * @brief A single AVM per-stage timing entry. `value_ms` is wall-clock milliseconds captured by
+ * bb::avm2::Stats during a prove or check-circuit call.
+ */
+struct AvmStat {
+    static constexpr const char MSGPACK_SCHEMA_NAME[] = "AvmStat";
+
+    std::string name;
+    uint64_t value_ms;
+    SERIALIZATION_FIELDS(name, value_ms);
+    bool operator==(const AvmStat&) const = default;
+};
+
+/**
+ * @struct AvmProve
+ * @brief Prove an AVM transaction from serialized inputs.
+ * The inputs are opaque msgpack bytes of AvmProvingInputs. Callers should call AvmVerify
+ * separately if they need to verify the resulting proof.
+ */
+struct AvmProve {
+    static constexpr const char MSGPACK_SCHEMA_NAME[] = "AvmProve";
+
+    struct Response {
+        static constexpr const char MSGPACK_SCHEMA_NAME[] = "AvmProveResponse";
+
+        std::vector<bb::fr> proof;
+        std::vector<AvmStat> stats;
+        SERIALIZATION_FIELDS(proof, stats);
+        bool operator==(const Response&) const = default;
+    };
+
+    std::vector<uint8_t> inputs;
+    SERIALIZATION_FIELDS(inputs);
+    Response execute(const BBApiRequest& request = {}) &&;
+    bool operator==(const AvmProve&) const = default;
+};
+
+/**
+ * @struct AvmVerify
+ * @brief Verify an AVM proof against serialized public inputs.
+ */
+struct AvmVerify {
+    static constexpr const char MSGPACK_SCHEMA_NAME[] = "AvmVerify";
+
+    struct Response {
+        static constexpr const char MSGPACK_SCHEMA_NAME[] = "AvmVerifyResponse";
+
+        bool verified;
+        SERIALIZATION_FIELDS(verified);
+        bool operator==(const Response&) const = default;
+    };
+
+    std::vector<bb::fr> proof;
+    std::vector<uint8_t> public_inputs;
+    SERIALIZATION_FIELDS(proof, public_inputs);
+    Response execute(const BBApiRequest& request = {}) &&;
+    bool operator==(const AvmVerify&) const = default;
+};
+
+/**
+ * @struct AvmCheckCircuit
+ * @brief Check the AVM circuit from serialized inputs.
+ */
+struct AvmCheckCircuit {
+    static constexpr const char MSGPACK_SCHEMA_NAME[] = "AvmCheckCircuit";
+
+    struct Response {
+        static constexpr const char MSGPACK_SCHEMA_NAME[] = "AvmCheckCircuitResponse";
+
+        bool passed;
+        std::vector<AvmStat> stats;
+        SERIALIZATION_FIELDS(passed, stats);
+        bool operator==(const Response&) const = default;
+    };
+
+    std::vector<uint8_t> inputs;
+    SERIALIZATION_FIELDS(inputs);
+    Response execute(const BBApiRequest& request = {}) &&;
+    bool operator==(const AvmCheckCircuit&) const = default;
+};
+
+} // namespace bb::bbapi

barretenberg/cpp/src/barretenberg/bbapi/bbapi_execute.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "barretenberg/bbapi/bbapi_avm.hpp"
 #include "barretenberg/bbapi/bbapi_chonk.hpp"
 #include "barretenberg/bbapi/bbapi_crypto.hpp"
 #include "barretenberg/bbapi/bbapi_ecc.hpp"
@@ -13,7 +14,10 @@
 
 namespace bb::bbapi {
 
-using Command = NamedUnion<CircuitProve,
+using Command = NamedUnion<AvmProve,
+                           AvmVerify,
+                           AvmCheckCircuit,
+                           CircuitProve,
                            CircuitComputeVk,
                            CircuitStats,
                            CircuitVerify,
@@ -73,6 +77,9 @@ using Command = NamedUnion<CircuitProve,
                            Shutdown>;
 
 using CommandResponse = NamedUnion<ErrorResponse,
+                                   AvmProve::Response,
+                                   AvmVerify::Response,
+                                   AvmCheckCircuit::Response,
                                    CircuitProve::Response,
                                    CircuitComputeVk::Response,
                                    CircuitStats::Response,

barretenberg/cpp/src/barretenberg/vm2/api_avm.cpp

@@ -2,6 +2,7 @@
 
 #include <filesystem>
 
+#include "barretenberg/api/api_avm.hpp"
 #include "barretenberg/api/file_io.hpp"
 #include "barretenberg/common/map.hpp"
 #include "barretenberg/vm2/avm_api.hpp"
@@ -94,4 +95,39 @@ void avm_write_verification_key(const std::filesystem::path& output_path)
     write_file(output_path / "vk", vk);
 }
 
+AvmProveResult avm_prove_from_bytes(std::vector<uint8_t> inputs)
+{
+    avm2::AvmAPI avm;
+    auto proving_inputs = avm2::AvmAPI::ProvingInputs::from(inputs);
+    auto proof = avm.prove(proving_inputs);
+
+    print_avm_stats();
+
+    return AvmProveResult{ .proof = std::move(proof) };
+}
+
+bool avm_verify_from_bytes(std::vector<bb::fr> proof, std::vector<uint8_t> public_inputs)
+{
+    auto pi = avm2::PublicInputs::from(public_inputs);
+
+    avm2::AvmAPI avm;
+    bool res = avm.verify(proof, pi);
+    info("verification: ", res ? "success" : "failure");
+
+    print_avm_stats();
+    return res;
+}
+
+bool avm_check_circuit_from_bytes(std::vector<uint8_t> inputs)
+{
+    avm2::AvmAPI avm;
+    auto proving_inputs = avm2::AvmAPI::ProvingInputs::from(inputs);
+
+    bool res = avm.check_circuit(proving_inputs);
+    info("circuit check: ", res ? "success" : "failure");
+
+    print_avm_stats();
+    return res;
+}
+
 } // namespace bb

barretenberg/cpp/src/barretenberg/vm2/tooling/stats.cpp

@@ -52,4 +52,10 @@ std::string Stats::to_string(int depth) const
     return joined;
 }
 
+std::vector<std::pair<std::string, uint64_t>> Stats::snapshot() const
+{
+    std::lock_guard lock(stats_mutex);
+    return { stats.begin(), stats.end() };
+}
+
 } // namespace bb::avm2

barretenberg/cpp/src/barretenberg/vm2/tooling/stats.hpp

@@ -5,6 +5,8 @@
 #include <mutex>
 #include <string>
 #include <unordered_map>
+#include <utility>
+#include <vector>
 
 // To enable stats tracking, compile in RelWithAssert mode.
 // cmake --preset $PRESET -DCMAKE_BUILD_TYPE=RelWithAssert
@@ -46,6 +48,9 @@ class Stats {
     // prove/logderiv/relation_ms will not be shown.
     std::string to_string(int depth = 2) const;
 
+    // Returns a copy of the stats as (key, value_ms) pairs. Keys retain the "_ms" suffix added by time().
+    std::vector<std::pair<std::string, uint64_t>> snapshot() const;
+
   private:
     Stats() = default;
 

barretenberg/cpp/src/barretenberg/vm2_stub/api_avm.cpp

@@ -1,4 +1,5 @@
 #include "api_avm.hpp"
+#include "barretenberg/api/api_avm.hpp"
 #include "barretenberg/common/throw_or_abort.hpp"
 #include <stdexcept>
 
@@ -34,4 +35,20 @@ void avm_write_verification_key([[maybe_unused]] const std::filesystem::path& ou
     throw_or_abort("AVM is not supported in this build. Use the 'bb-avm' binary with full AVM support.");
 }
 
+AvmProveResult avm_prove_from_bytes([[maybe_unused]] std::vector<uint8_t> inputs)
+{
+    throw_or_abort("AVM is not supported in this build. Use the 'bb-avm' binary with full AVM support.");
+}
+
+bool avm_verify_from_bytes([[maybe_unused]] std::vector<bb::fr> proof,
+                           [[maybe_unused]] std::vector<uint8_t> public_inputs)
+{
+    throw_or_abort("AVM is not supported in this build. Use the 'bb-avm' binary with full AVM support.");
+}
+
+bool avm_check_circuit_from_bytes([[maybe_unused]] std::vector<uint8_t> inputs)
+{
+    throw_or_abort("AVM is not supported in this build. Use the 'bb-avm' binary with full AVM support.");
+}
+
 } // namespace bb

barretenberg/cpp/src/barretenberg/vm2_stub/stats.cpp

@@ -0,0 +1,34 @@
+// Stub implementations of bb::avm2::Stats. Linked into binaries that don't pull in vm2_sim
+// (e.g. lightweight `bb` and WASM builds), so callers like bbapi_avm.cpp resolve symbols in
+// every build mode. The stub no-ops because AVM proving cannot run on these targets anyway.
+
+#include "barretenberg/vm2/tooling/stats.hpp"
+
+namespace bb::avm2 {
+
+Stats& Stats::get()
+{
+    static Stats stats;
+    return stats;
+}
+
+void Stats::reset() {}
+
+void Stats::increment(const std::string& /*key*/, uint64_t /*value*/) {}
+
+void Stats::time(const std::string& /*key*/, const std::function<void()>& f)
+{
+    f();
+}
+
+std::string Stats::to_string(int /*depth*/) const
+{
+    return {};
+}
+
+std::vector<std::pair<std::string, uint64_t>> Stats::snapshot() const
+{
+    return {};
+}
+
+} // namespace bb::avm2

barretenberg/ts/src/index.ts

@@ -21,6 +21,7 @@ export { BBApiException } from './bbapi_exception.js';
 
 // Export Point types for use in foundation and other packages
 export type {
+  AvmStat,
   Bn254G1Point,
   Bn254G2Point,
   ChonkProof,