bbapi_client_ivc.hpp

Go to the documentation of this file.

#pragma once
#include "barretenberg/bbapi/bbapi_shared.hpp"
#include "barretenberg/client_ivc/client_ivc.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 ClientIvcStart {
    static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcStart";
 
    struct Response {
        static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcStartResponse";
        // 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 ClientIvcStart&) const = default;
};
 
struct ClientIvcLoad {
    static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcLoad";
 
    struct Response {
        static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcLoadResponse";
        // 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 ClientIvcLoad&) const = default;
};
 
struct ClientIvcAccumulate {
    static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcAccumulate";
 
    struct Response {
        static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcAccumulateResponse";
        // 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 ClientIvcAccumulate&) const = default;
};
 
struct ClientIvcProve {
    static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcProve";
 
    struct Response {
        static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcProveResponse";
 
        ClientIVC::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 ClientIvcProve&) const = default;
};
 
struct ClientIvcVerify {
    static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcVerify";
 
    struct Response {
        static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcVerifyResponse";
 
        bool valid;
        MSGPACK_FIELDS(valid);
        bool operator==(const Response&) const = default;
    };
 
    ClientIVC::Proof proof;
    std::vector<uint8_t> vk;
    Response execute(const BBApiRequest& request = {}) &&;
    MSGPACK_FIELDS(proof, vk);
    bool operator==(const ClientIvcVerify&) const = default;
};
 
struct ClientIvcComputeStandaloneVk {
    static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcComputeStandaloneVk";
 
    struct Response {
        static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcComputeStandaloneVkResponse";
 
        std::vector<uint8_t> bytes;
        std::vector<bb::fr> fields;
        MSGPACK_FIELDS(bytes, fields);
        bool operator==(const Response&) const = default;
    };
 
    CircuitInputNoVK circuit;
    Response execute(const BBApiRequest& request = {}) &&;
    MSGPACK_FIELDS(circuit);
    bool operator==(const ClientIvcComputeStandaloneVk&) const = default;
};
 
struct ClientIvcComputeIvcVk {
    static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcComputeIvcVk";
 
    struct Response {
        static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcComputeIvcVkResponse";
 
        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 ClientIvcComputeIvcVk&) const = default;
};
 
struct ClientIvcCheckPrecomputedVk {
    static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcCheckPrecomputedVk";
 
    struct Response {
        static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcCheckPrecomputedVkResponse";
 
        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 ClientIvcCheckPrecomputedVk&) const = default;
};
 
struct ClientIvcStats {
    static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcStats";
 
    struct Response {
        static constexpr const char* MSGPACK_SCHEMA_NAME = "ClientIvcStatsResponse";
 
        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 ClientIvcStats&) const = default;
};
 
} // namespace bb::bbapi