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"
 
#ifndef __wasm__
#include "barretenberg/chonk/batch_verifier_types.hpp"
#include "barretenberg/chonk/chonk_batch_verifier.hpp"
#include "barretenberg/chonk/chonk_proof.hpp"
#include <condition_variable>
#include <mutex>
#include <queue>
#include <thread>
#endif
 
#include <string>
#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.
    uint32_t num_circuits;
    Response execute(BBApiRequest& request) &&;
    SERIALIZATION_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) &&;
    SERIALIZATION_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) &&;
    SERIALIZATION_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";
 
        ChonkProof proof;
        SERIALIZATION_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;
        SERIALIZATION_FIELDS(valid);
        bool operator==(const Response&) const = default;
    };
 
    ChonkProof proof;
    std::vector<uint8_t> vk;
    Response execute(const BBApiRequest& request = {}) &&;
    SERIALIZATION_FIELDS(proof, vk);
    bool operator==(const ChonkVerify&) const = default;
};
 
struct ChonkComputeVk {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkComputeVk";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkComputeVkResponse";
 
        std::vector<uint8_t> bytes;
        std::vector<bb::fr> fields;
        SERIALIZATION_FIELDS(bytes, fields);
        bool operator==(const Response&) const = default;
    };
 
    CircuitInputNoVK circuit;
    bool use_zk_flavor = false;
    Response execute([[maybe_unused]] const BBApiRequest& request = {}) &&;
    SERIALIZATION_FIELDS(circuit, use_zk_flavor);
    bool operator==(const ChonkComputeVk&) 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;
        SERIALIZATION_FIELDS(valid, actual_vk);
        bool operator==(const Response&) const = default;
    };
 
    CircuitInput circuit;
    bool use_zk_flavor = false;
 
    Response execute(const BBApiRequest& request = {}) &&;
    SERIALIZATION_FIELDS(circuit, use_zk_flavor);
    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;
        SERIALIZATION_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) &&;
    SERIALIZATION_FIELDS(circuit, include_gates_per_opcode);
    bool operator==(const ChonkStats&) const = default;
};
 
struct ChonkBatchVerify {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkBatchVerify";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkBatchVerifyResponse";
        bool valid;
        SERIALIZATION_FIELDS(valid);
        bool operator==(const Response&) const = default;
    };
 
    std::vector<ChonkProof> proofs;
    std::vector<std::vector<uint8_t>> vks;
    Response execute(const BBApiRequest& request = {}) &&;
    SERIALIZATION_FIELDS(proofs, vks);
    bool operator==(const ChonkBatchVerify&) const = default;
};
 
struct ChonkCompressProof {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkCompressProof";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkCompressProofResponse";
        std::vector<uint8_t> compressed_proof;
        SERIALIZATION_FIELDS(compressed_proof);
        bool operator==(const Response&) const = default;
    };
 
    ChonkProof proof;
    Response execute(const BBApiRequest& request = {}) &&;
    SERIALIZATION_FIELDS(proof);
    bool operator==(const ChonkCompressProof&) const = default;
};
 
struct ChonkDecompressProof {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkDecompressProof";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkDecompressProofResponse";
        ChonkProof proof;
        SERIALIZATION_FIELDS(proof);
        bool operator==(const Response&) const = default;
    };
 
    std::vector<uint8_t> compressed_proof;
    Response execute(const BBApiRequest& request = {}) &&;
    SERIALIZATION_FIELDS(compressed_proof);
    bool operator==(const ChonkDecompressProof&) const = default;
};
 
#ifndef __wasm__
class ChonkBatchVerifierService {
  public:
    ChonkBatchVerifierService() = default;
    ~ChonkBatchVerifierService();
 
    ChonkBatchVerifierService(const ChonkBatchVerifierService&) = delete;
    ChonkBatchVerifierService& operator=(const ChonkBatchVerifierService&) = delete;
 
    void start(std::vector<std::shared_ptr<MegaZKFlavor::VKAndHash>> vks,
               uint32_t num_cores,
               uint32_t batch_size,
               const std::string& fifo_path);
    void enqueue(VerifyRequest request);
    void stop();
    bool is_running() const { return running_; }
 
  private:
    void writer_loop(const std::string& fifo_path);
 
    ChonkBatchVerifier verifier_;
 
    std::mutex result_mutex_;
    std::condition_variable result_cv_;
    std::queue<VerifyResult> result_queue_;
    bool writer_shutdown_ = false;
    std::thread writer_thread_;
 
    bool running_ = false;
};
#endif // __wasm__
 
struct ChonkBatchVerifierStart {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkBatchVerifierStart";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkBatchVerifierStartResponse";
        void msgpack(auto&& pack_fn) { pack_fn(); }
        bool operator==(const Response&) const = default;
    };
 
    std::vector<std::vector<uint8_t>> vks; // Serialized verification keys
    uint32_t num_cores = 0;                // 0 = auto
    uint32_t batch_size = 8;
    std::string fifo_path;
 
    Response execute(BBApiRequest& request) &&;
    SERIALIZATION_FIELDS(vks, num_cores, batch_size, fifo_path);
    bool operator==(const ChonkBatchVerifierStart&) const = default;
};
 
struct ChonkBatchVerifierQueue {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkBatchVerifierQueue";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkBatchVerifierQueueResponse";
        void msgpack(auto&& pack_fn) { pack_fn(); }
        bool operator==(const Response&) const = default;
    };
 
    uint64_t request_id = 0;
    uint32_t vk_index = 0;
    std::vector<bb::fr> proof_fields;
 
    Response execute(BBApiRequest& request) &&;
    SERIALIZATION_FIELDS(request_id, vk_index, proof_fields);
    bool operator==(const ChonkBatchVerifierQueue&) const = default;
};
 
struct ChonkBatchVerifierStop {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkBatchVerifierStop";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "ChonkBatchVerifierStopResponse";
        void msgpack(auto&& pack_fn) { pack_fn(); }
        bool operator==(const Response&) const = default;
    };
 
    Response execute(BBApiRequest& request) &&;
    void msgpack(auto&& pack_fn) { pack_fn(); }
    bool operator==(const ChonkBatchVerifierStop&) const = default;
};
 
} // namespace bb::bbapi