bbapi_chonk.hpp

Go to the documentation of this file.

#pragma once
#include "barretenberg/bbapi/bbapi_shared.hpp"
#include "barretenberg/chonk/chonk.hpp"
#include "barretenberg/common/named_union.hpp"
#include "barretenberg/honk/proof_system/types/proof.hpp"
#include "barretenberg/serialize/msgpack.hpp"
#include <vector>
 
namespace bb::bbapi {
 
struct ChonkStart {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkStart";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkStartResponse";
        // Empty response - success indicated by no exception
        void msgpack(auto&& pack_fn) { pack_fn(); }
        bool operator==(const Response&) const = default;
    };
    // Number of circuits to be accumulated.
    size_t num_circuits;
    Response execute(BBApiRequest& request) &&;
    MSGPACK_FIELDS(num_circuits);
    bool operator==(const ChonkStart&) const = default;
};
 
struct ChonkLoad {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkLoad";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkLoadResponse";
        // Empty response - success indicated by no exception
        void msgpack(auto&& pack_fn) { pack_fn(); }
        bool operator==(const Response&) const = default;
    };
 
    CircuitInput circuit;
    Response execute(BBApiRequest& request) &&;
    MSGPACK_FIELDS(circuit);
    bool operator==(const ChonkLoad&) const = default;
};
 
struct ChonkAccumulate {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkAccumulate";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkAccumulateResponse";
        // Empty response - success indicated by no exception
        void msgpack(auto&& pack_fn) { pack_fn(); }
        bool operator==(const Response&) const = default;
    };
 
    std::vector<uint8_t> witness;
    Response execute(BBApiRequest& request) &&;
    MSGPACK_FIELDS(witness);
    bool operator==(const ChonkAccumulate&) const = default;
};
 
struct ChonkProve {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkProve";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkProveResponse";
 
        Chonk::Proof proof;
        MSGPACK_FIELDS(proof);
        bool operator==(const Response&) const = default;
    };
    Response execute(BBApiRequest& request) &&;
    void msgpack(auto&& pack_fn) { pack_fn(); }
    bool operator==(const ChonkProve&) const = default;
};
 
struct ChonkVerify {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkVerify";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkVerifyResponse";
 
        bool valid;
        MSGPACK_FIELDS(valid);
        bool operator==(const Response&) const = default;
    };
 
    Chonk::Proof proof;
    std::vector<uint8_t> vk;
    Response execute(const BBApiRequest& request = {}) &&;
    MSGPACK_FIELDS(proof, vk);
    bool operator==(const ChonkVerify&) const = default;
};
 
struct ChonkComputeStandaloneVk {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkComputeStandaloneVk";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkComputeStandaloneVkResponse";
 
        std::vector<uint8_t> bytes;
        std::vector<bb::fr> fields;
        MSGPACK_FIELDS(bytes, fields);
        bool operator==(const Response&) const = default;
    };
 
    CircuitInputNoVK circuit;
    Response execute([[maybe_unused]] const BBApiRequest& request = {}) &&;
    MSGPACK_FIELDS(circuit);
    bool operator==(const ChonkComputeStandaloneVk&) const = default;
};
 
struct ChonkComputeIvcVk {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkComputeIvcVk";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkComputeIvcVkResponse";
 
        std::vector<uint8_t> bytes;
        MSGPACK_FIELDS(bytes);
        bool operator==(const Response&) const = default;
    };
 
    CircuitInputNoVK circuit;
    Response execute(const BBApiRequest& request = {}) &&;
    MSGPACK_FIELDS(circuit);
    bool operator==(const ChonkComputeIvcVk&) const = default;
};
 
struct ChonkCheckPrecomputedVk {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkCheckPrecomputedVk";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkCheckPrecomputedVkResponse";
 
        bool valid;
        std::vector<uint8_t> actual_vk;
        MSGPACK_FIELDS(valid, actual_vk);
        bool operator==(const Response&) const = default;
    };
 
    CircuitInput circuit;
 
    Response execute(const BBApiRequest& request = {}) &&;
    MSGPACK_FIELDS(circuit);
    bool operator==(const ChonkCheckPrecomputedVk&) const = default;
};
 
struct ChonkStats {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkStats";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkStatsResponse";
 
        uint32_t acir_opcodes;
        uint32_t circuit_size;
        std::vector<uint32_t> gates_per_opcode;
        MSGPACK_FIELDS(acir_opcodes, circuit_size, gates_per_opcode);
        bool operator==(const Response&) const = default;
    };
 
    CircuitInputNoVK circuit;
    bool include_gates_per_opcode;
    Response execute(BBApiRequest& request) &&;
    MSGPACK_FIELDS(circuit, include_gates_per_opcode);
    bool operator==(const ChonkStats&) const = default;
};
 
} // namespace bb::bbapi