bbapi_shared.hpp

Go to the documentation of this file.

#pragma once
#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>
 
namespace bb::bbapi {
 
template <typename VK> inline void validate_vk_size(const std::vector<uint8_t>& vk_bytes)
{
    const size_t expected_size = VK::calc_num_data_types() * sizeof(bb::fr);
    if (vk_bytes.size() != expected_size) {
        throw_or_abort("verification key has wrong size: expected " + std::to_string(expected_size) + ", got " +
                       std::to_string(vk_bytes.size()));
    }
}
 
enum class VkPolicy {
    DEFAULT,   // Use the provided VK as-is (default behavior)
    CHECK,     // Verify the provided VK matches the computed VK, throw error if mismatch
    RECOMPUTE, // Always ignore the provided VK and treat it as nullptr
    REWRITE    // Check the VK and rewrite the input file with correct VK if mismatch (for check command)
};
 
struct CircuitInputNoVK {
    std::string name;
 
    std::vector<uint8_t> bytecode;
 
    SERIALIZATION_FIELDS(name, bytecode);
    bool operator==(const CircuitInputNoVK& other) const = default;
};
 
struct CircuitInput {
    std::string name;
 
    std::vector<uint8_t> bytecode;
 
    std::vector<uint8_t> verification_key;
 
    SERIALIZATION_FIELDS(name, bytecode, verification_key);
    bool operator==(const CircuitInput& other) const = default;
};
 
struct ProofSystemSettings {
    bool ipa_accumulation = false;
 
    std::string oracle_hash_type = "poseidon2";
 
    bool disable_zk = false;
 
    // TODO(md): remove this once considered stable
    bool optimized_solidity_verifier = false;
 
    SERIALIZATION_FIELDS(ipa_accumulation, oracle_hash_type, disable_zk, optimized_solidity_verifier);
    bool operator==(const ProofSystemSettings& other) const = default;
};
 
enum class OracleHashType { POSEIDON2, KECCAK, STARKNET };
 
inline OracleHashType parse_oracle_hash_type(const std::string& type)
{
    if (type == "keccak") {
        return OracleHashType::KECCAK;
    }
    if (type == "starknet") {
        return OracleHashType::STARKNET;
    }
    return OracleHashType::POSEIDON2; // default
}
 
inline VkPolicy parse_vk_policy(const std::string& policy)
{
    if (policy == "check") {
        return VkPolicy::CHECK;
    }
    if (policy == "recompute") {
        return VkPolicy::RECOMPUTE;
    }
    if (policy == "rewrite") {
        return VkPolicy::REWRITE;
    }
    return VkPolicy::DEFAULT; // default
}
 
#ifndef __wasm__
// Forward declaration — defined in bbapi_chonk.hpp
class ChonkBatchVerifierService;
#endif
 
struct BBApiRequest {
    // Current depth of the IVC stack for this request
    uint32_t ivc_stack_depth = 0;
    std::shared_ptr<IVCBase> ivc_in_progress;
    // Name of the last loaded circuit
    std::string loaded_circuit_name;
    // Store the parsed constraint system to get ahead of parsing before accumulate
    std::optional<acir_format::AcirFormat> loaded_circuit_constraints;
    // Store the verification key passed with the circuit
    std::vector<uint8_t> loaded_circuit_vk;
    // Policy for handling verification keys during accumulation
    VkPolicy vk_policy = VkPolicy::DEFAULT;
    // Error message - empty string means no error
    std::string error_message;
#ifndef __wasm__
    // Batch verifier service instance (persists across RPC calls)
    std::shared_ptr<ChonkBatchVerifierService> batch_verifier_service;
#endif
};
 
struct ErrorResponse {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ErrorResponse";
    std::string message;
    SERIALIZATION_FIELDS(message);
    bool operator==(const ErrorResponse&) const = default;
};
 
#define BBAPI_ERROR(request, msg)                                                                                      \
    do {                                                                                                               \
        (request).error_message = (msg);                                                                               \
        return {};                                                                                                     \
    } while (0)
 
struct Shutdown {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "Shutdown";
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ShutdownResponse";
        // Empty response - success indicated by no exception
        void msgpack(auto&& pack_fn) { pack_fn(); }
        bool operator==(const Response&) const = default;
    };
    void msgpack(auto&& pack_fn) { pack_fn(); }
    Response execute(const BBApiRequest&) && { return {}; }
    bool operator==(const Shutdown&) const = default;
};
 
template <typename Flavor>
inline typename Flavor::Transcript::Proof concatenate_proof(const std::vector<uint256_t>& public_inputs,
                                                            const std::vector<uint256_t>& proof)
{
    using FF = typename Flavor::FF;
    // Reject non-canonical field encodings (values >= field modulus) to ensure consistent
    // verifier behavior across native and Solidity targets.
    for (const auto& val : public_inputs) {
        if (val >= FF::modulus) {
            throw_or_abort("Non-canonical public input: value >= field modulus");
        }
    }
    for (const auto& val : proof) {
        if (val >= FF::modulus) {
            throw_or_abort("Non-canonical proof element: value >= field modulus");
        }
    }
    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;
}
 
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());
    }
}
 
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 + "'");
    }
}
 
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