feat: merge-train/barretenberg (#16345)

See
[merge-train-readme.md](https://github.com/AztecProtocol/aztec-packages/blob/next/.github/workflows/merge-train-readme.md).

BEGIN_COMMIT_OVERRIDE
refactor(bbapi): ultrahonk unified api (#16090)
chore: assert poseidon hashes only witnesses (#16341)
chore: simplify is_accum (#16291)
END_COMMIT_OVERRIDE

Author: ludamad

.test_patterns.yml

@@ -49,6 +49,10 @@ tests:
     error_regex: "Failed to fetch"
     owners:
       - *adam
+  - regex: "barretenberg/acir_tests/scripts/run_test_browser.sh"
+    error_regex: "Failed to fetch"
+    owners:
+      - *adam
   - regex: "barretenberg/acir_tests/scripts/run_test_browser.sh"
     error_regex: "RuntimeError: Out of bounds memory access"
     owners:

barretenberg/cpp/src/barretenberg/api/api_client_ivc.cpp

@@ -2,7 +2,6 @@
 #include "barretenberg/api/file_io.hpp"
 #include "barretenberg/api/get_bytecode.hpp"
 #include "barretenberg/api/log.hpp"
-#include "barretenberg/api/write_prover_output.hpp"
 #include "barretenberg/bbapi/bbapi.hpp"
 #include "barretenberg/client_ivc/client_ivc.hpp"
 #include "barretenberg/client_ivc/mock_circuit_producer.hpp"
@@ -257,7 +256,7 @@ void gate_count_for_ivc(const std::string& bytecode_path, bool include_gates_per
     bbapi::BBApiRequest request{ .trace_settings = { AZTEC_TRACE_STRUCTURE } };
 
     auto bytecode = get_bytecode(bytecode_path);
-    auto response = bbapi::ClientIvcGates{ .circuit = { .name = "ivc_circuit", .bytecode = std::move(bytecode) },
+    auto response = bbapi::ClientIvcStats{ .circuit = { .name = "ivc_circuit", .bytecode = std::move(bytecode) },
                                            .include_gates_per_opcode = include_gates_per_opcode }
                         .execute(request);
 

barretenberg/cpp/src/barretenberg/api/api_ultra_honk.cpp

@@ -0,0 +1,258 @@
+#include "api_ultra_honk.hpp"
+#include "barretenberg/api/file_io.hpp"
+#include "barretenberg/bbapi/bbapi_ultra_honk.hpp"
+#include "barretenberg/client_ivc/acir_bincode_mocks.hpp"
+#include "barretenberg/common/serialize.hpp"
+#include "barretenberg/dsl/acir_format/acir_format.hpp"
+#include "barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp"
+#include "barretenberg/dsl/acir_format/proof_surgeon.hpp"
+#include "barretenberg/flavor/ultra_flavor.hpp"
+#include "barretenberg/flavor/ultra_rollup_flavor.hpp"
+#include <chrono>
+#include <cstddef>
+#include <cstdlib>
+#include <filesystem>
+#include <gtest/gtest.h>
+#include <math.h>
+#include <sstream>
+#include <string_view>
+
+namespace bb {
+std::vector<uint8_t> compress(const std::vector<uint8_t>& input);
+std::vector<uint8_t> decompress(const void* bytes, size_t size);
+} // namespace bb
+
+using namespace bb;
+
+namespace {
+// Create a unique temporary directory for each test run
+// Uniqueness needed because tests are run in parallel and write to same file names.
+std::filesystem::path get_test_dir(const std::string_view& test_name)
+{
+    std::filesystem::path temp_dir = "tmp_api_ultra_honk_test";
+    std::filesystem::create_directories(temp_dir);
+    std::filesystem::create_directories(temp_dir / test_name);
+    return temp_dir / test_name;
+}
+
+// Create test data
+std::pair<std::filesystem::path, std::filesystem::path> create_test_circuit_files(const std::filesystem::path& test_dir)
+{
+    auto [bytecode, witness] = acir_bincode_mocks::create_simple_circuit_bytecode();
+
+    auto bytecode_path = test_dir / "circuit.gz";
+    auto witness_path = test_dir / "witness.gz";
+
+    write_file(bytecode_path, bb::compress(bytecode));
+    write_file(witness_path, bb::compress(witness));
+
+    return { bytecode_path, witness_path };
+}
+
+} // namespace
+
+class ApiUltraHonkTest : public ::testing::Test {
+  protected:
+    static void SetUpTestSuite() { bb::srs::init_file_crs_factory(bb::srs::bb_crs_path()); }
+
+    void SetUp() override
+    {
+        const auto* info = ::testing::UnitTest::GetInstance()->current_test_info();
+        test_dir = get_test_dir(info->name());
+    }
+
+    void TearDown() override
+    {
+        if (std::filesystem::exists(test_dir)) {
+            std::filesystem::remove_all(test_dir);
+        }
+    }
+
+    std::filesystem::path test_dir;
+};
+
+TEST_F(ApiUltraHonkTest, ProveAndVerify)
+{
+    auto [bytecode_path, witness_path] = create_test_circuit_files(test_dir);
+
+    API::Flags flags;
+    flags.output_format = "bytes";
+    flags.oracle_hash_type = "poseidon2"; // Set default oracle hash type
+
+    UltraHonkAPI api;
+
+    // Generate VK first
+    auto vk_output_path = test_dir / "vk";
+    std::filesystem::create_directories(vk_output_path);
+    api.write_vk(flags, bytecode_path, vk_output_path);
+    EXPECT_TRUE(std::filesystem::exists(vk_output_path / "vk"));
+
+    // Generate proof
+    auto proof_output_dir = test_dir / "proof";
+    std::filesystem::create_directories(proof_output_dir);
+    api.prove(flags, bytecode_path, witness_path, vk_output_path / "vk", proof_output_dir);
+
+    // Check that proof files were created
+    EXPECT_TRUE(std::filesystem::exists(proof_output_dir / "proof"));
+    EXPECT_TRUE(std::filesystem::exists(proof_output_dir / "public_inputs"));
+
+    // Verify the proof
+    bool verified =
+        api.verify(flags, proof_output_dir / "public_inputs", proof_output_dir / "proof", vk_output_path / "vk");
+    EXPECT_TRUE(verified);
+}
+
+TEST_F(ApiUltraHonkTest, ProveWithWriteVk)
+{
+    auto [bytecode_path, witness_path] = create_test_circuit_files(test_dir);
+
+    API::Flags flags;
+    flags.output_format = "bytes_and_fields"; // Test both output formats
+    flags.oracle_hash_type = "poseidon2";
+    flags.write_vk = true;
+
+    UltraHonkAPI api;
+
+    // Generate proof with write_vk flag (will compute and write VK)
+    auto proof_output_dir = test_dir / "proof";
+    std::filesystem::create_directories(proof_output_dir);
+    api.prove(flags, bytecode_path, witness_path, "", proof_output_dir);
+
+    // Check that proof and VK files were created
+    EXPECT_TRUE(std::filesystem::exists(proof_output_dir / "proof"));
+    EXPECT_TRUE(std::filesystem::exists(proof_output_dir / "public_inputs"));
+    EXPECT_TRUE(std::filesystem::exists(proof_output_dir / "vk"));
+    EXPECT_TRUE(std::filesystem::exists(proof_output_dir / "vk_hash"));
+    EXPECT_TRUE(std::filesystem::exists(proof_output_dir / "vk_fields.json"));
+    EXPECT_TRUE(std::filesystem::exists(proof_output_dir / "vk_hash_fields.json"));
+
+    // Verify the proof
+    bool verified =
+        api.verify(flags, proof_output_dir / "public_inputs", proof_output_dir / "proof", proof_output_dir / "vk");
+    EXPECT_TRUE(verified);
+}
+
+TEST_F(ApiUltraHonkTest, ProveAndVerifyWithFields)
+{
+    auto [bytecode_path, witness_path] = create_test_circuit_files(test_dir);
+
+    // First generate VK in bytes format for the prove step
+    API::Flags vk_flags;
+    vk_flags.output_format = "bytes";
+    vk_flags.oracle_hash_type = "poseidon2";
+
+    UltraHonkAPI api;
+
+    auto vk_output_path = test_dir / "vk";
+    std::filesystem::create_directories(vk_output_path);
+    api.write_vk(vk_flags, bytecode_path, vk_output_path);
+    EXPECT_TRUE(std::filesystem::exists(vk_output_path / "vk"));
+
+    // Now test fields format for proof generation
+    API::Flags flags;
+    flags.output_format = "fields";
+    flags.oracle_hash_type = "poseidon2";
+
+    // Generate proof with fields output
+    auto proof_output_dir = test_dir / "proof";
+    std::filesystem::create_directories(proof_output_dir);
+    api.prove(flags, bytecode_path, witness_path, vk_output_path / "vk", proof_output_dir);
+
+    // Check that proof field files were created
+    EXPECT_TRUE(std::filesystem::exists(proof_output_dir / "proof_fields.json"));
+    EXPECT_TRUE(std::filesystem::exists(proof_output_dir / "public_inputs_fields.json"));
+}
+
+TEST_F(ApiUltraHonkTest, ProveWithDifferentSettings)
+{
+    auto [bytecode_path, witness_path] = create_test_circuit_files(test_dir);
+
+    // Test different oracle hash types
+    const std::vector<std::pair<std::string, bool>> test_cases = { { "poseidon2",
+                                                                     false }, // oracle_hash_type, disable_zk
+                                                                   { "poseidon2", true },
+                                                                   { "keccak", false },
+                                                                   { "keccak", true } };
+
+    for (const auto& [oracle_hash_type, disable_zk] : test_cases) {
+        API::Flags flags;
+        flags.output_format = "bytes";
+        flags.oracle_hash_type = oracle_hash_type;
+        flags.disable_zk = disable_zk;
+        flags.write_vk = true;
+
+        auto case_dir = test_dir / (oracle_hash_type + "_" + (disable_zk ? "no_zk" : "zk"));
+        std::filesystem::create_directories(case_dir);
+
+        UltraHonkAPI api;
+
+        // Generate proof
+        api.prove(flags, bytecode_path, witness_path, "", case_dir);
+
+        // Verify the proof
+        bool verified = api.verify(flags, case_dir / "public_inputs", case_dir / "proof", case_dir / "vk");
+        EXPECT_TRUE(verified) << "Failed with oracle_hash_type=" << oracle_hash_type << ", disable_zk=" << disable_zk;
+    }
+}
+
+TEST_F(ApiUltraHonkTest, WriteVk)
+{
+    auto [bytecode_path, witness_path] = create_test_circuit_files(test_dir);
+
+    // Smoke test fields format (no real verification)
+    {
+        API::Flags flags;
+        flags.output_format = "fields";
+        flags.oracle_hash_type = "poseidon2";
+
+        UltraHonkAPI api;
+        api.write_vk(flags, bytecode_path, test_dir);
+
+        EXPECT_TRUE(std::filesystem::exists(test_dir / "vk_fields.json"));
+        EXPECT_TRUE(std::filesystem::exists(test_dir / "vk_hash_fields.json"));
+
+        EXPECT_FALSE(std::filesystem::exists(test_dir / "vk"));
+        EXPECT_FALSE(std::filesystem::exists(test_dir / "vk_hash"));
+    }
+
+    // Test with bytes format, simple vk recalculation
+    {
+        API::Flags flags;
+        flags.output_format = "bytes";
+        flags.oracle_hash_type = "poseidon2";
+
+        UltraHonkAPI api;
+        api.write_vk(flags, bytecode_path, test_dir);
+
+        // Test against bbapi::CircuitComputeVk
+        auto bytecode = read_file(bytecode_path);
+        auto expected_vk =
+            bbapi::CircuitComputeVk({ .circuit = { .bytecode = bb::decompress(bytecode.data(), bytecode.size()) },
+                                      .settings = { .oracle_hash_type = flags.oracle_hash_type } })
+                .execute();
+
+        info("after write_vk, expected_vk size: {}", expected_vk.bytes.size());
+        EXPECT_EQ(expected_vk.bytes, read_file(test_dir / "vk"));
+        EXPECT_EQ(expected_vk.hash, read_file(test_dir / "vk_hash"));
+    }
+}
+
+// NOTE: very light test
+TEST_F(ApiUltraHonkTest, GatesWithOpcodesSmokeTest)
+{
+    auto [bytecode_path, witness_path] = create_test_circuit_files(test_dir);
+
+    // Capture stdout
+    testing::internal::CaptureStdout();
+
+    API::Flags flags;
+    flags.oracle_hash_type = "poseidon2";
+    flags.include_gates_per_opcode = true;
+    UltraHonkAPI api;
+    api.gates(flags, bytecode_path);
+
+    std::string output = testing::internal::GetCapturedStdout();
+
+    // Check that output contains per-opcode information
+    EXPECT_TRUE(output.find("gates_per_opcode") != std::string::npos);
+}

barretenberg/cpp/src/barretenberg/api/api_ultra_honk.test.cpp

@@ -1,12 +1,14 @@
 #pragma once
 #include "barretenberg/common/log.hpp"
 #include "barretenberg/common/try_catch_shim.hpp"
+#include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include <cstdint>
 #include <cstring>
 #include <fcntl.h>
 #include <fstream>
 #include <ios>
 #include <iostream>
+#include <sstream>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <vector>
@@ -84,4 +86,18 @@ inline void write_file(const std::string& filename, std::vector<uint8_t> const&
         file.close();
     }
 }
+
+template <typename Fr> inline std::string field_elements_to_json(const std::vector<Fr>& fields)
+{
+    std::stringstream ss;
+    ss << "[";
+    for (size_t i = 0; i < fields.size(); ++i) {
+        ss << '"' << fields[i] << '"';
+        if (i != fields.size() - 1) {
+            ss << ",";
+        }
+    }
+    ss << "]";
+    return ss.str();
+}
 } // namespace bb