feat: merge-train/barretenberg (#20051)

BEGIN_COMMIT_OVERRIDE
chore: rm ultra rollup flavor (#19984)
END_COMMIT_OVERRIDE

Author: AztecBot

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

@@ -7,15 +7,7 @@
 #include "barretenberg/common/get_bytecode.hpp"
 #include "barretenberg/common/map.hpp"
 #include "barretenberg/common/throw_or_abort.hpp"
-#include "barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp"
-#include "barretenberg/dsl/acir_proofs/honk_contract.hpp"
-#include "barretenberg/dsl/acir_proofs/honk_optimized_contract.hpp"
-#include "barretenberg/dsl/acir_proofs/honk_zk_contract.hpp"
-#include "barretenberg/honk/proof_system/types/proof.hpp"
 #include "barretenberg/numeric/uint256/uint256.hpp"
-#include "barretenberg/special_public_inputs/special_public_inputs.hpp"
-#include "barretenberg/srs/global_crs.hpp"
-#include <optional>
 
 namespace bb {
 
@@ -205,7 +197,6 @@ void UltraHonkAPI::gates([[maybe_unused]] const Flags& flags,
     std::string functions_string = "{\"functions\": [\n  ";
 
     // For now, treat the entire bytecode as a single circuit
-    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1074): Handle multi-circuit programs properly
     // Convert flags to ProofSystemSettings
     bbapi::ProofSystemSettings settings{ .ipa_accumulation = flags.ipa_accumulation,
                                          .oracle_hash_type = flags.oracle_hash_type,

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

@@ -1,9 +1,6 @@
 #pragma once
 
 #include "barretenberg/api/api.hpp"
-#include "barretenberg/flavor/ultra_flavor.hpp"
-#include "barretenberg/flavor/ultra_rollup_flavor.hpp"
-#include "barretenberg/flavor/ultra_zk_flavor.hpp"
 #include <filesystem>
 #include <string>
 

barretenberg/cpp/src/barretenberg/bb/cli.cpp

@@ -28,7 +28,6 @@
 #include "barretenberg/common/bb_bench.hpp"
 #include "barretenberg/common/thread.hpp"
 #include "barretenberg/common/version.hpp"
-#include "barretenberg/flavor/ultra_rollup_flavor.hpp"
 #include "barretenberg/srs/factories/native_crs_factory.hpp"
 #include "barretenberg/srs/global_crs.hpp"
 #include "barretenberg/vm2/api_avm.hpp"

barretenberg/cpp/src/barretenberg/bbapi/bbapi_shared.hpp

@@ -10,7 +10,17 @@
 #include "barretenberg/chonk/chonk.hpp"
 #include "barretenberg/common/throw_or_abort.hpp"
 #include "barretenberg/dsl/acir_format/acir_format.hpp"
+#include "barretenberg/flavor/ultra_flavor.hpp"
+#include "barretenberg/flavor/ultra_keccak_flavor.hpp"
+#include "barretenberg/flavor/ultra_keccak_zk_flavor.hpp"
+#include "barretenberg/flavor/ultra_zk_flavor.hpp"
 #include "barretenberg/honk/execution_trace/mega_execution_trace.hpp"
+#include "barretenberg/stdlib/special_public_inputs/special_public_inputs.hpp"
+#include "barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp"
+#ifdef STARKNET_GARAGA_FLAVORS
+#include "barretenberg/flavor/ultra_starknet_flavor.hpp"
+#include "barretenberg/flavor/ultra_starknet_zk_flavor.hpp"
+#endif
 #include <cstdint>
 #include <string>
 #include <vector>
@@ -208,4 +218,116 @@ struct Shutdown {
     bool operator==(const Shutdown&) const = default;
 };
 
+/**
+ * @brief Concatenate public inputs and proof into a complete proof for verification
+ * @details Joins the separated public_inputs and proof portions back together.
+ * Handles implicit conversion from uint256_t to the flavor's DataType.
+ *
+ * The proof structure after concatenation is: [public_inputs | honk_proof (| ipa_proof)]
+ * For rollup circuits (RollupIO), the proof portion includes the IPA proof appended at the end.
+ * This must match the split done in _prove() and the verification in _verify().
+ *
+ * @param public_inputs The ACIR public inputs (user inputs, not including IO-specific data)
+ * @param proof The proof data (Honk proof, plus IPA proof for rollup circuits)
+ */
+template <typename Flavor>
+inline typename Flavor::Transcript::Proof concatenate_proof(const std::vector<uint256_t>& public_inputs,
+                                                            const std::vector<uint256_t>& proof)
+{
+    typename Flavor::Transcript::Proof result;
+    result.reserve(public_inputs.size() + proof.size());
+    result.insert(result.end(), public_inputs.begin(), public_inputs.end());
+    result.insert(result.end(), proof.begin(), proof.end());
+    return result;
+}
+
+/**
+ * @brief Convert VK to uint256 field elements, handling flavor-specific return types
+ */
+template <typename VK> std::vector<uint256_t> vk_to_uint256_fields(const VK& vk)
+{
+    auto fields = vk.to_field_elements();
+    if constexpr (std::is_same_v<decltype(fields), std::vector<uint256_t>>) {
+        return fields;
+    } else {
+        return std::vector<uint256_t>(fields.begin(), fields.end());
+    }
+}
+
+/**
+ * @brief Validate rollup circuit settings
+ * @details Rollup circuits require poseidon2 oracle hash for efficient recursion.
+ *          The disable_zk flag is ignored - rollup always uses UltraFlavor (non-ZK).
+ *
+ * @throws If oracle_hash_type is not poseidon2
+ */
+inline void validate_rollup_settings(const ProofSystemSettings& settings)
+{
+    if (!settings.ipa_accumulation) {
+        return; // Not a rollup circuit, no validation needed
+    }
+
+    // Rollup circuits must use poseidon2 for efficient recursive verification
+    if (settings.oracle_hash_type != "poseidon2") {
+        throw_or_abort("Rollup circuits (ipa_accumulation=true) must use oracle_hash_type='poseidon2', got '" +
+                       settings.oracle_hash_type + "'");
+    }
+}
+
+/**
+ * @brief Dispatch to the correct Flavor and IO type based on proof system settings
+ * @details Maps settings (ipa_accumulation, oracle_hash_type, disable_zk) to the appropriate Flavor and IO template
+ * parameters.
+ *
+ * Rollup Path:
+ * - When ipa_accumulation=true, uses UltraFlavor with RollupIO (includes IPA claim for ECCVM)
+ * - Validates that rollup settings are compatible (poseidon2, disable_zk=true)
+ *
+ * Non-Rollup Paths:
+ * - Routes to appropriate Flavor based on oracle_hash_type and disable_zk
+ * - Uses DefaultIO (includes only pairing points, no IPA)
+ *
+ * @param settings The proof system settings determining which flavor/IO to use
+ * @param operation A callable object that will be invoked with <Flavor, IO> template parameters
+ * @return The result of calling operation.template operator()<Flavor, IO>()
+ *
+ */
+template <typename Operation> auto dispatch_by_settings(const ProofSystemSettings& settings, Operation&& operation)
+{
+    // Rollup circuits: UltraFlavor with RollupIO (includes IPA accumulation for ECCVM)
+    if (settings.ipa_accumulation) {
+        validate_rollup_settings(settings);
+        return operation.template operator()<UltraFlavor, RollupIO>();
+    }
+
+    // Non-rollup circuits: route based on oracle hash type and ZK setting
+    if (settings.oracle_hash_type == "poseidon2") {
+        if (settings.disable_zk) {
+            return operation.template operator()<UltraFlavor, DefaultIO>();
+        }
+        return operation.template operator()<UltraZKFlavor, DefaultIO>();
+    }
+
+    if (settings.oracle_hash_type == "keccak") {
+        if (settings.disable_zk) {
+            return operation.template operator()<UltraKeccakFlavor, DefaultIO>();
+        }
+        return operation.template operator()<UltraKeccakZKFlavor, DefaultIO>();
+    }
+
+#ifdef STARKNET_GARAGA_FLAVORS
+    if (settings.oracle_hash_type == "starknet") {
+        if (settings.disable_zk) {
+            return operation.template operator()<UltraStarknetFlavor, DefaultIO>();
+        }
+        return operation.template operator()<UltraStarknetZKFlavor, DefaultIO>();
+    }
+#endif
+
+    // Invalid configuration
+    throw_or_abort("Invalid proof system settings: oracle_hash_type='" + settings.oracle_hash_type +
+                   "', disable_zk=" + std::to_string(settings.disable_zk) +
+                   ", ipa_accumulation=" + std::to_string(settings.ipa_accumulation));
+}
+
 } // namespace bb::bbapi