bbapi_execute.hpp

Go to the documentation of this file.

#pragma once
 
#include "barretenberg/bbapi/bbapi_chonk.hpp"
#include "barretenberg/bbapi/bbapi_crypto.hpp"
#include "barretenberg/bbapi/bbapi_ecc.hpp"
#include "barretenberg/bbapi/bbapi_ecdsa.hpp"
#include "barretenberg/bbapi/bbapi_schnorr.hpp"
#include "barretenberg/bbapi/bbapi_shared.hpp"
#include "barretenberg/bbapi/bbapi_srs.hpp"
#include "barretenberg/bbapi/bbapi_ultra_honk.hpp"
#include "barretenberg/common/throw_or_abort.hpp"
#include <vector>
 
namespace bb::bbapi {
 
using Command = NamedUnion<CircuitProve,
                           CircuitComputeVk,
                           CircuitStats,
                           CircuitVerify,
                           ChonkComputeStandaloneVk,
                           ChonkComputeIvcVk,
                           ChonkStart,
                           ChonkLoad,
                           ChonkAccumulate,
                           ChonkProve,
                           ChonkVerify,
                           VkAsFields,
                           MegaVkAsFields,
                           CircuitWriteSolidityVerifier,
                           ChonkCheckPrecomputedVk,
                           ChonkStats,
                           Poseidon2Hash,
                           Poseidon2Permutation,
                           Poseidon2HashAccumulate,
                           PedersenCommit,
                           PedersenHash,
                           PedersenHashBuffer,
                           Blake2s,
                           Blake2sToField,
                           AesEncrypt,
                           AesDecrypt,
                           GrumpkinMul,
                           GrumpkinAdd,
                           GrumpkinBatchMul,
                           GrumpkinGetRandomFr,
                           GrumpkinReduce512,
                           Secp256k1Mul,
                           Secp256k1GetRandomFr,
                           Secp256k1Reduce512,
                           Bn254FrSqrt,
                           Bn254FqSqrt,
                           Bn254G1Mul,
                           Bn254G2Mul,
                           Bn254G1IsOnCurve,
                           Bn254G1FromCompressed,
                           SchnorrComputePublicKey,
                           SchnorrConstructSignature,
                           SchnorrVerifySignature,
                           EcdsaSecp256k1ComputePublicKey,
                           EcdsaSecp256r1ComputePublicKey,
                           EcdsaSecp256k1ConstructSignature,
                           EcdsaSecp256r1ConstructSignature,
                           EcdsaSecp256k1RecoverPublicKey,
                           EcdsaSecp256r1RecoverPublicKey,
                           EcdsaSecp256k1VerifySignature,
                           EcdsaSecp256r1VerifySignature,
                           SrsInitSrs,
                           SrsInitGrumpkinSrs,
                           Shutdown>;
 
using CommandResponse = NamedUnion<ErrorResponse,
                                   CircuitProve::Response,
                                   CircuitComputeVk::Response,
                                   CircuitStats::Response,
                                   CircuitVerify::Response,
                                   ChonkComputeStandaloneVk::Response,
                                   ChonkComputeIvcVk::Response,
                                   ChonkStart::Response,
                                   ChonkLoad::Response,
                                   ChonkAccumulate::Response,
                                   ChonkProve::Response,
                                   ChonkVerify::Response,
                                   VkAsFields::Response,
                                   MegaVkAsFields::Response,
                                   CircuitWriteSolidityVerifier::Response,
                                   ChonkCheckPrecomputedVk::Response,
                                   ChonkStats::Response,
                                   Poseidon2Hash::Response,
                                   Poseidon2Permutation::Response,
                                   Poseidon2HashAccumulate::Response,
                                   PedersenCommit::Response,
                                   PedersenHash::Response,
                                   PedersenHashBuffer::Response,
                                   Blake2s::Response,
                                   Blake2sToField::Response,
                                   AesEncrypt::Response,
                                   AesDecrypt::Response,
                                   GrumpkinMul::Response,
                                   GrumpkinAdd::Response,
                                   GrumpkinBatchMul::Response,
                                   GrumpkinGetRandomFr::Response,
                                   GrumpkinReduce512::Response,
                                   Secp256k1Mul::Response,
                                   Secp256k1GetRandomFr::Response,
                                   Secp256k1Reduce512::Response,
                                   Bn254FrSqrt::Response,
                                   Bn254FqSqrt::Response,
                                   Bn254G1Mul::Response,
                                   Bn254G2Mul::Response,
                                   Bn254G1IsOnCurve::Response,
                                   Bn254G1FromCompressed::Response,
                                   SchnorrComputePublicKey::Response,
                                   SchnorrConstructSignature::Response,
                                   SchnorrVerifySignature::Response,
                                   EcdsaSecp256k1ComputePublicKey::Response,
                                   EcdsaSecp256r1ComputePublicKey::Response,
                                   EcdsaSecp256k1ConstructSignature::Response,
                                   EcdsaSecp256r1ConstructSignature::Response,
                                   EcdsaSecp256k1RecoverPublicKey::Response,
                                   EcdsaSecp256r1RecoverPublicKey::Response,
                                   EcdsaSecp256k1VerifySignature::Response,
                                   EcdsaSecp256r1VerifySignature::Response,
                                   SrsInitSrs::Response,
                                   SrsInitGrumpkinSrs::Response,
                                   Shutdown::Response>;
 
inline CommandResponse execute(BBApiRequest& request, Command&& command)
{
    // Reset error state before execution
    request.error_message.clear();
 
    CommandResponse response = std::move(command).visit([&request](auto&& cmd) -> CommandResponse {
        using CmdType = std::decay_t<decltype(cmd)>;
        return std::forward<CmdType>(cmd).execute(request);
    });
 
    // Check if an error occurred during execution
    if (!request.error_message.empty()) {
        return ErrorResponse{ .message = std::move(request.error_message) };
    }
 
    return response;
}
 
// The msgpack scheme is an ad-hoc format that allows for cbind/compiler.ts to
// generate TypeScript bindings for the API.
std::string get_msgpack_schema_as_json();
 
} // namespace bb::bbapi