bbapi_shared.hpp

Go to the documentation of this file.

#pragma once
#include "barretenberg/chonk/chonk.hpp"
#include "barretenberg/dsl/acir_format/acir_format.hpp"
#include "barretenberg/honk/execution_trace/mega_execution_trace.hpp"
#include <cstdint>
#include <string>
#include <vector>
 
namespace bb::bbapi {
 
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;
 
    MSGPACK_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;
 
    MSGPACK_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;
 
    MSGPACK_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
}
 
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;
};
 
struct ErrorResponse {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ErrorResponse";
    std::string message;
    MSGPACK_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;
};
 
} // namespace bb::bbapi