bbapi_ultra_honk.hpp

Go to the documentation of this file.

#pragma once
#include "barretenberg/bbapi/bbapi_shared.hpp"
#include "barretenberg/common/named_union.hpp"
#include "barretenberg/honk/proof_system/types/proof.hpp"
#include "barretenberg/numeric/uint256/uint256.hpp"
#include "barretenberg/serialize/msgpack.hpp"
#include <cstdint>
#include <map>
#include <vector>
 
namespace bb::bbapi {
 
struct CircuitComputeVk {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "CircuitComputeVk";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "CircuitComputeVkResponse";
 
        std::vector<uint8_t> bytes;    // Serialized verification key
        std::vector<uint256_t> fields; // VK as field elements (unless keccak, then just uint256_t's)
        std::vector<uint8_t> hash;     // The VK hash
        MSGPACK_FIELDS(bytes, fields, hash);
        bool operator==(const Response&) const = default;
    };
 
    CircuitInputNoVK circuit;
    ProofSystemSettings settings;
    MSGPACK_FIELDS(circuit, settings);
    Response execute(const BBApiRequest& request = {}) &&;
    bool operator==(const CircuitComputeVk&) const = default;
};
 
struct CircuitProve {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "CircuitProve";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "CircuitProveResponse";
 
        std::vector<uint256_t> public_inputs;
        std::vector<uint256_t> proof;
        CircuitComputeVk::Response vk;
        MSGPACK_FIELDS(public_inputs, proof, vk);
        bool operator==(const Response&) const = default;
    };
 
    CircuitInput circuit;
    std::vector<uint8_t> witness;
    ProofSystemSettings settings;
    MSGPACK_FIELDS(circuit, witness, settings);
    Response execute(const BBApiRequest& request = {}) &&;
    bool operator==(const CircuitProve&) const = default;
};
 
struct CircuitStats {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "CircuitStats";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "CircuitInfoResponse";
 
        uint32_t num_gates{};
        uint32_t num_gates_dyadic{};
        uint32_t num_acir_opcodes{};
        std::vector<size_t> gates_per_opcode;
        MSGPACK_FIELDS(num_gates, num_gates_dyadic, num_acir_opcodes, gates_per_opcode);
        bool operator==(const Response&) const = default;
    };
 
    CircuitInput circuit;
    bool include_gates_per_opcode = false;
    ProofSystemSettings settings;
    MSGPACK_FIELDS(circuit, include_gates_per_opcode, settings);
    Response execute(const BBApiRequest& request = {}) &&;
    bool operator==(const CircuitStats&) const = default;
};
 
struct CircuitVerify {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "CircuitVerify";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "CircuitVerifyResponse";
 
        bool verified;
        MSGPACK_FIELDS(verified);
        bool operator==(const Response&) const = default;
    };
 
    std::vector<uint8_t> verification_key;
    std::vector<uint256_t> public_inputs;
    std::vector<uint256_t> proof;
    ProofSystemSettings settings;
    MSGPACK_FIELDS(verification_key, public_inputs, proof, settings);
    Response execute(const BBApiRequest& request = {}) &&;
    bool operator==(const CircuitVerify&) const = default;
};
 
struct VkAsFields {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "VkAsFields";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "VkAsFieldsResponse";
 
        std::vector<bb::fr> fields;
        MSGPACK_FIELDS(fields);
        bool operator==(const Response&) const = default;
    };
 
    std::vector<uint8_t> verification_key;
    MSGPACK_FIELDS(verification_key);
    Response execute(const BBApiRequest& request = {}) &&;
    bool operator==(const VkAsFields&) const = default;
};
 
struct MegaVkAsFields {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "MegaVkAsFields";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "MegaVkAsFieldsResponse";
 
        std::vector<bb::fr> fields;
        MSGPACK_FIELDS(fields);
        bool operator==(const Response&) const = default;
    };
 
    std::vector<uint8_t> verification_key;
    MSGPACK_FIELDS(verification_key);
    Response execute(const BBApiRequest& request = {}) &&;
    bool operator==(const MegaVkAsFields&) const = default;
};
 
struct CircuitWriteSolidityVerifier {
    static constexpr const char MSGPACK_SCHEMA_NAME[] = "CircuitWriteSolidityVerifier";
 
    struct Response {
        static constexpr const char MSGPACK_SCHEMA_NAME[] = "CircuitWriteSolidityVerifierResponse";
 
        std::string solidity_code;
        MSGPACK_FIELDS(solidity_code);
        bool operator==(const Response&) const = default;
    };
 
    std::vector<uint8_t> verification_key;
    ProofSystemSettings settings;
    MSGPACK_FIELDS(verification_key, settings);
    Response execute(const BBApiRequest& request = {}) &&;
    bool operator==(const CircuitWriteSolidityVerifier&) const = default;
};
 
} // namespace bb::bbapi