chore(bb): Add verification after proof generation in bbapi_ultrahonk

Add verification after proof generation in bbapi_ultrahonk

Author: federicobarbacovi

barretenberg/cpp/src/barretenberg/bbapi/bbapi_ultra_honk.cpp

@@ -60,49 +60,6 @@ std::shared_ptr<ProverInstance_<Flavor>> _compute_prover_instance(std::vector<ui
 
     return prover_instance;
 }
-template <typename Flavor, typename IO>
-CircuitProve::Response _prove(std::vector<uint8_t>&& bytecode,
-                              std::vector<uint8_t>&& witness,
-                              std::vector<uint8_t>&& vk_bytes)
-{
-    using Proof = typename Flavor::Transcript::Proof;
-    using VerificationKey = typename Flavor::VerificationKey;
-
-    auto prover_instance = _compute_prover_instance<Flavor, IO>(std::move(bytecode), std::move(witness));
-
-    // Create or deserialize VK
-    std::shared_ptr<VerificationKey> vk;
-    if (vk_bytes.empty()) {
-        info("WARNING: computing verification key while proving. Pass in a precomputed vk for better performance.");
-        vk = std::make_shared<VerificationKey>(prover_instance->get_precomputed());
-    } else {
-        validate_vk_size<VerificationKey>(vk_bytes);
-        vk = std::make_shared<VerificationKey>(from_buffer<VerificationKey>(vk_bytes));
-    }
-
-    // Construct proof
-    UltraProver_<Flavor> prover{ prover_instance, vk };
-    Proof full_proof = prover.construct_proof();
-
-    // Compute where to split (inner public inputs vs everything else)
-    size_t num_public_inputs = prover.num_public_inputs();
-    BB_ASSERT_GTE(num_public_inputs, IO::PUBLIC_INPUTS_SIZE, "Public inputs should contain the expected IO structure.");
-    size_t num_inner_public_inputs = num_public_inputs - IO::PUBLIC_INPUTS_SIZE;
-
-    // Optimization: if vk not provided, include it in response
-    CircuitComputeVk::Response vk_response;
-    if (vk_bytes.empty()) {
-        vk_response = { .bytes = to_buffer(*vk), .fields = vk_to_uint256_fields(*vk), .hash = to_buffer(vk->hash()) };
-    }
-
-    // Split proof: inner public inputs at front, rest is the "proof"
-    return { .public_inputs =
-                 std::vector<uint256_t>{ full_proof.begin(),
-                                         full_proof.begin() + static_cast<std::ptrdiff_t>(num_inner_public_inputs) },
-             .proof = std::vector<uint256_t>{ full_proof.begin() + static_cast<std::ptrdiff_t>(num_inner_public_inputs),
-                                              full_proof.end() },
-             .vk = std::move(vk_response) };
-}
 
 template <typename Flavor, typename IO>
 bool _verify(const std::vector<uint8_t>& vk_bytes,
@@ -145,6 +102,59 @@ bool _verify(const std::vector<uint8_t>& vk_bytes,
     return verified;
 }
 
+template <typename Flavor, typename IO>
+CircuitProve::Response _prove(std::vector<uint8_t>&& bytecode,
+                              std::vector<uint8_t>&& witness,
+                              std::vector<uint8_t>&& vk_bytes)
+{
+    using Proof = typename Flavor::Transcript::Proof;
+    using VerificationKey = typename Flavor::VerificationKey;
+
+    auto prover_instance = _compute_prover_instance<Flavor, IO>(std::move(bytecode), std::move(witness));
+
+    // Create or deserialize VK
+    std::shared_ptr<VerificationKey> vk;
+    if (vk_bytes.empty()) {
+        info("WARNING: computing verification key while proving. Pass in a precomputed vk for better performance.");
+        vk = std::make_shared<VerificationKey>(prover_instance->get_precomputed());
+    } else {
+        validate_vk_size<VerificationKey>(vk_bytes);
+        vk = std::make_shared<VerificationKey>(from_buffer<VerificationKey>(vk_bytes));
+    }
+
+    // Construct proof
+    UltraProver_<Flavor> prover{ prover_instance, vk };
+    Proof full_proof = prover.construct_proof();
+
+    // Compute where to split (inner public inputs vs everything else)
+    size_t num_public_inputs = prover.num_public_inputs();
+    BB_ASSERT_GTE(num_public_inputs, IO::PUBLIC_INPUTS_SIZE, "Public inputs should contain the expected IO structure.");
+    size_t num_inner_public_inputs = num_public_inputs - IO::PUBLIC_INPUTS_SIZE;
+
+    // Optimization: if vk not provided, include it in response
+    CircuitComputeVk::Response vk_response;
+    if (vk_bytes.empty()) {
+        vk_response = { .bytes = to_buffer(*vk), .fields = vk_to_uint256_fields(*vk), .hash = to_buffer(vk->hash()) };
+    }
+
+    // Split proof: inner public inputs at front, rest is the "proof"
+    CircuitProve::Response response{
+        .public_inputs =
+            std::vector<uint256_t>{ full_proof.begin(),
+                                    full_proof.begin() + static_cast<std::ptrdiff_t>(num_inner_public_inputs) },
+        .proof = std::vector<uint256_t>{ full_proof.begin() + static_cast<std::ptrdiff_t>(num_inner_public_inputs),
+                                         full_proof.end() },
+        .vk = std::move(vk_response)
+    };
+
+    // Sanity-check the generated proof
+    if (!_verify<Flavor, IO>(to_buffer(*vk), response.public_inputs, response.proof)) {
+        throw_or_abort("Failed to verify the generated proof!");
+    }
+
+    return response;
+}
+
 CircuitProve::Response CircuitProve::execute(BB_UNUSED const BBApiRequest& request) &&
 {
     BB_BENCH_NAME(MSGPACK_SCHEMA_NAME);