c_bind.cpp

Go to the documentation of this file.

#include "c_bind.hpp"
#include "../acir_format/acir_to_constraint_buf.hpp"
#include "barretenberg/chonk/chonk_verifier.hpp"
#include "barretenberg/chonk/private_execution_steps.hpp"
#include "barretenberg/common/mem.hpp"
#include "barretenberg/common/net.hpp"
#include "barretenberg/common/serialize.hpp"
#include "barretenberg/common/throw_or_abort.hpp"
#include "barretenberg/common/zip_view.hpp"
#include "barretenberg/dsl/acir_format/acir_format.hpp"
#include "barretenberg/dsl/acir_format/hypernova_recursion_constraint.hpp"
 
#include "barretenberg/honk/execution_trace/mega_execution_trace.hpp"
#include "barretenberg/serialize/msgpack.hpp"
#include "honk_contract.hpp"
#include <cstdint>
#include <memory>
 
WASM_EXPORT void acir_get_circuit_sizes(uint8_t const* acir_vec,
                                        bool const* has_ipa_claim,
                                        uint32_t* total,
                                        uint32_t* subgroup)
{
    const acir_format::ProgramMetadata metadata{ .has_ipa_claim = *has_ipa_claim };
    acir_format::AcirProgram program{
        acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec)), {}
    };
    auto builder = acir_format::create_circuit<UltraCircuitBuilder>(program, metadata);
    builder.finalize_circuit(/*ensure_nonzero=*/true);
    *total = htonl((uint32_t)builder.get_finalized_total_circuit_size());
    *subgroup = htonl((uint32_t)builder.get_circuit_subgroup_size(builder.get_finalized_total_circuit_size()));
}
 
WASM_EXPORT void acir_prove_and_verify_ultra_honk(uint8_t const* acir_vec, uint8_t const* witness_vec, bool* result)
{
    acir_format::AcirProgram program{
        acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec)),
        acir_format::witness_buf_to_witness_vector(from_buffer<std::vector<uint8_t>>(witness_vec))
    };
 
    auto builder = acir_format::create_circuit<UltraCircuitBuilder>(program);
 
    auto prover_instance = std::make_shared<ProverInstance_<UltraFlavor>>(builder);
    auto verification_key = std::make_shared<UltraFlavor::VerificationKey>(prover_instance->get_precomputed());
    UltraProver prover{ prover_instance, verification_key };
    auto proof = prover.construct_proof();
 
    UltraVerifier verifier{ std::make_shared<UltraFlavor::VKAndHash>(verification_key) };
 
    *result = verifier.verify_proof(proof).result;
    info("verified: ", *result);
}
 
WASM_EXPORT void acir_prove_and_verify_mega_honk(uint8_t const* acir_vec, uint8_t const* witness_vec, bool* result)
{
    acir_format::AcirProgram program{
        acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec)),
        acir_format::witness_buf_to_witness_vector(from_buffer<std::vector<uint8_t>>(witness_vec))
    };
 
    auto builder = acir_format::create_circuit<MegaCircuitBuilder>(program);
 
    auto prover_instance = std::make_shared<ProverInstance_<MegaFlavor>>(builder);
    auto verification_key = std::make_shared<MegaFlavor::VerificationKey>(prover_instance->get_precomputed());
    MegaProver prover{ prover_instance, verification_key };
    auto proof = prover.construct_proof();
 
    MegaVerifier verifier{ std::make_shared<MegaFlavor::VKAndHash>(verification_key) };
 
    *result = verifier.verify_proof(proof).result;
}
 
WASM_EXPORT void acir_prove_aztec_client(uint8_t const* ivc_inputs_buf, uint8_t** out_proof, uint8_t** out_vk)
{
    auto ivc_inputs_vec = from_buffer<std::vector<uint8_t>>(ivc_inputs_buf);
    // Accumulate the entire program stack into the IVC
    auto start = std::chrono::steady_clock::now();
    PrivateExecutionSteps steps;
    steps.parse(PrivateExecutionStepRaw::parse_uncompressed(ivc_inputs_vec));
    std::shared_ptr<Chonk> ivc = steps.accumulate();
    auto end = std::chrono::steady_clock::now();
    auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    vinfo("time to construct and accumulate all circuits: ", diff.count());
 
    vinfo("calling ivc.prove ...");
    ChonkProof proof = ivc->prove();
    end = std::chrono::steady_clock::now();
 
    diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    vinfo("time to construct, accumulate, prove all circuits: ", diff.count());
 
    start = std::chrono::steady_clock::now();
    *out_proof = proof.to_msgpack_heap_buffer();
    end = std::chrono::steady_clock::now();
    diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    vinfo("time to serialize proof: ", diff.count());
 
    start = std::chrono::steady_clock::now();
    auto vk_and_hash = ivc->get_hiding_kernel_vk_and_hash();
    *out_vk = to_heap_buffer(to_buffer(*vk_and_hash->vk));
    end = std::chrono::steady_clock::now();
    diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    vinfo("time to serialize hiding kernel vk: ", diff.count());
}
 
WASM_EXPORT void acir_verify_aztec_client(uint8_t const* proof_buf, uint8_t const* vk_buf, bool* result)
{
    using HidingKernelVK = Chonk::MegaVerificationKey;
    using HidingKernelVKAndHash = ChonkNativeVerifier::VKAndHash;
 
    const auto proof = ChonkProof::from_msgpack_buffer(proof_buf);
    auto hiding_kernel_vk = from_buffer<HidingKernelVK>(from_buffer<std::vector<uint8_t>>(vk_buf));
    auto vk_and_hash = std::make_shared<HidingKernelVKAndHash>(std::make_shared<HidingKernelVK>(hiding_kernel_vk));
 
    ChonkNativeVerifier verifier(vk_and_hash);
    *result = verifier.verify(proof);
}
 
WASM_EXPORT void acir_prove_ultra_zk_honk(uint8_t const* acir_vec,
                                          uint8_t const* witness_vec,
                                          uint8_t const* vk_buf,
                                          uint8_t** out)
{
    // Lambda function to ensure things get freed before proving.
    UltraZKProver prover = [&] {
        acir_format::AcirProgram program{
            acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec)),
            acir_format::witness_buf_to_witness_vector(from_buffer<std::vector<uint8_t>>(witness_vec))
        };
        auto builder = acir_format::create_circuit<UltraCircuitBuilder>(program);
        auto prover_instance = std::make_shared<ProverInstance_<UltraZKFlavor>>(builder);
        auto verification_key =
            std::make_shared<UltraZKFlavor::VerificationKey>(from_buffer<UltraZKFlavor::VerificationKey>(vk_buf));
 
        return UltraZKProver(prover_instance, verification_key);
    }();
 
    auto proof = prover.construct_proof();
    *out = to_heap_buffer(to_buffer(proof));
}
 
WASM_EXPORT void acir_prove_ultra_keccak_honk(uint8_t const* acir_vec,
                                              uint8_t const* witness_vec,
                                              uint8_t const* vk_buf,
                                              uint8_t** out)
{
    // Lambda function to ensure things get freed before proving.
    UltraKeccakProver prover = [&] {
        acir_format::AcirProgram program{
            acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec)),
            acir_format::witness_buf_to_witness_vector(from_buffer<std::vector<uint8_t>>(witness_vec))
        };
        auto builder = acir_format::create_circuit<UltraCircuitBuilder>(program);
 
        auto prover_instance = std::make_shared<ProverInstance_<UltraKeccakFlavor>>(builder);
        auto verification_key = std::make_shared<UltraKeccakFlavor::VerificationKey>(
            from_buffer<UltraKeccakFlavor::VerificationKey>(vk_buf));
        return UltraKeccakProver(prover_instance, verification_key);
    }();
    auto proof = prover.construct_proof();
    *out = to_heap_buffer(to_buffer(proof));
}
 
WASM_EXPORT void acir_prove_ultra_keccak_zk_honk(uint8_t const* acir_vec,
                                                 uint8_t const* witness_vec,
                                                 uint8_t const* vk_buf,
                                                 uint8_t** out)
{
    // Lambda function to ensure things get freed before proving.
    UltraKeccakZKProver prover = [&] {
        acir_format::AcirProgram program{
            acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec)),
            acir_format::witness_buf_to_witness_vector(from_buffer<std::vector<uint8_t>>(witness_vec))
        };
        auto builder = acir_format::create_circuit<UltraCircuitBuilder>(program);
 
        auto prover_instance = std::make_shared<ProverInstance_<UltraKeccakZKFlavor>>(builder);
        auto verification_key = std::make_shared<UltraKeccakZKFlavor::VerificationKey>(
            from_buffer<UltraKeccakZKFlavor::VerificationKey>(vk_buf));
        return UltraKeccakZKProver(prover_instance, verification_key);
    }();
    auto proof = prover.construct_proof();
    *out = to_heap_buffer(to_buffer(proof));
}
 
WASM_EXPORT void acir_prove_ultra_starknet_honk([[maybe_unused]] uint8_t const* acir_vec,
                                                [[maybe_unused]] uint8_t const* witness_vec,
                                                [[maybe_unused]] uint8_t const* vk_buf,
                                                [[maybe_unused]] uint8_t** out)
{
#ifdef STARKNET_GARAGA_FLAVORS
    // Lambda function to ensure things get freed before proving.
    UltraStarknetProver prover = [&] {
        acir_format::AcirProgram program{
            acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec)),
            acir_format::witness_buf_to_witness_vector(from_buffer<std::vector<uint8_t>>(witness_vec))
        };
        auto builder = acir_format::create_circuit<UltraCircuitBuilder>(program);
 
        return UltraStarknetProver(builder);
    }();
    auto proof = prover.construct_proof();
    *out = to_heap_buffer(to_buffer(proof));
#else
    throw_or_abort("bb wasm was not compiled with starknet garaga flavors!");
#endif
}
 
WASM_EXPORT void acir_prove_ultra_starknet_zk_honk([[maybe_unused]] uint8_t const* acir_vec,
                                                   [[maybe_unused]] uint8_t const* witness_vec,
                                                   [[maybe_unused]] uint8_t const* vk_buf,
                                                   [[maybe_unused]] uint8_t** out)
{
#ifdef STARKNET_GARAGA_FLAVORS
    // Lambda function to ensure things get freed before proving.
    UltraStarknetZKProver prover = [&] {
        acir_format::AcirProgram program{
            acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec)),
            acir_format::witness_buf_to_witness_vector(from_buffer<std::vector<uint8_t>>(witness_vec))
        };
        auto builder = acir_format::create_circuit<UltraCircuitBuilder>(program);
 
        return UltraStarknetZKProver(builder);
    }();
    auto proof = prover.construct_proof();
    *out = to_heap_buffer(to_buffer(proof));
#else
    throw_or_abort("bb wasm was not compiled with starknet garaga flavors!");
#endif
}
 
WASM_EXPORT void acir_verify_ultra_zk_honk(uint8_t const* proof_buf, uint8_t const* vk_buf, bool* result)
{
    using VerificationKey = UltraZKFlavor::VerificationKey;
    using Verifier = UltraVerifier_<UltraZKFlavor, DefaultIO>;
 
    auto proof = many_from_buffer<bb::fr>(from_buffer<std::vector<uint8_t>>(proof_buf));
    auto verification_key = std::make_shared<VerificationKey>(from_buffer<VerificationKey>(vk_buf));
 
    Verifier verifier{ std::make_shared<UltraZKFlavor::VKAndHash>(verification_key) };
 
    *result = verifier.verify_proof(proof).result;
}
 
WASM_EXPORT void acir_verify_ultra_keccak_honk(uint8_t const* proof_buf, uint8_t const* vk_buf, bool* result)
{
    using VerificationKey = UltraKeccakFlavor::VerificationKey;
    using Verifier = UltraVerifier_<UltraKeccakFlavor, DefaultIO>;
 
    auto proof = many_from_buffer<uint256_t>(from_buffer<std::vector<uint8_t>>(proof_buf));
    auto verification_key = std::make_shared<VerificationKey>(from_buffer<VerificationKey>(vk_buf));
 
    Verifier verifier{ std::make_shared<UltraKeccakFlavor::VKAndHash>(verification_key) };
 
    *result = verifier.verify_proof(proof).result;
}
 
WASM_EXPORT void acir_verify_ultra_keccak_zk_honk(uint8_t const* proof_buf, uint8_t const* vk_buf, bool* result)
{
    using VerificationKey = UltraKeccakZKFlavor::VerificationKey;
    using Verifier = UltraVerifier_<UltraKeccakZKFlavor, DefaultIO>;
 
    auto proof = many_from_buffer<uint256_t>(from_buffer<std::vector<uint8_t>>(proof_buf));
    auto verification_key = std::make_shared<VerificationKey>(from_buffer<VerificationKey>(vk_buf));
 
    Verifier verifier{ std::make_shared<UltraKeccakZKFlavor::VKAndHash>(verification_key) };
 
    *result = verifier.verify_proof(proof).result;
}
 
WASM_EXPORT void acir_verify_ultra_starknet_honk([[maybe_unused]] uint8_t const* proof_buf,
                                                 [[maybe_unused]] uint8_t const* vk_buf,
                                                 [[maybe_unused]] bool* result)
{
#ifdef STARKNET_GARAGA_FLAVORS
    using VerificationKey = UltraStarknetFlavor::VerificationKey;
    using Verifier = UltraVerifier_<UltraStarknetFlavor, DefaultIO>;
 
    auto proof = from_buffer<std::vector<bb::fr>>(from_buffer<std::vector<uint8_t>>(proof_buf));
    auto verification_key = std::make_shared<VerificationKey>(from_buffer<VerificationKey>(vk_buf));
 
    Verifier verifier{ std::make_shared<UltraStarknetFlavor::VKAndHash>(verification_key) };
 
    *result = verifier.verify_proof(proof).result;
#else
    throw_or_abort("bb wasm was not compiled with starknet garaga flavors!");
#endif
}
 
WASM_EXPORT void acir_verify_ultra_starknet_zk_honk([[maybe_unused]] uint8_t const* proof_buf,
                                                    [[maybe_unused]] uint8_t const* vk_buf,
                                                    [[maybe_unused]] bool* result)
{
#ifdef STARKNET_GARAGA_FLAVORS
    using VerificationKey = UltraStarknetZKFlavor::VerificationKey;
    using Verifier = UltraVerifier_<UltraStarknetZKFlavor, DefaultIO>;
 
    auto proof = many_from_buffer<bb::fr>(from_buffer<std::vector<uint8_t>>(proof_buf));
    auto verification_key = std::make_shared<VerificationKey>(from_buffer<VerificationKey>(vk_buf));
    Verifier verifier{ std::make_shared<UltraStarknetZKFlavor::VKAndHash>(verification_key) };
 
    *result = verifier.verify_proof(proof).result;
#else
    throw_or_abort("bb wasm was not compiled with starknet garaga flavors!");
#endif
}
 
WASM_EXPORT void acir_write_vk_ultra_honk(uint8_t const* acir_vec, uint8_t** out)
{
    using ProverInstance = ProverInstance_<UltraFlavor>;
    using VerificationKey = UltraFlavor::VerificationKey;
    // lambda to free the builder
    ProverInstance prover_instance = [&] {
        acir_format::AcirProgram program{
            acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec)), {}
        };
        auto builder = acir_format::create_circuit<UltraCircuitBuilder>(program);
        return ProverInstance(builder);
    }();
    VerificationKey vk(prover_instance.get_precomputed());
    vinfo("Constructed UltraHonk verification key");
    *out = to_heap_buffer(to_buffer(vk));
}
 
WASM_EXPORT void acir_write_vk_ultra_keccak_honk(uint8_t const* acir_vec, uint8_t** out)
{
    using ProverInstance = ProverInstance_<UltraKeccakFlavor>;
    using VerificationKey = UltraKeccakFlavor::VerificationKey;
 
    // lambda to free the builder
    ProverInstance prover_instance = [&] {
        acir_format::AcirProgram program{
            acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec)), {}
        };
        auto builder = acir_format::create_circuit<UltraCircuitBuilder>(program);
        return ProverInstance(builder);
    }();
    VerificationKey vk(prover_instance.get_precomputed());
    vinfo("Constructed UltraKeccakHonk verification key");
    *out = to_heap_buffer(to_buffer(vk));
}
 
WASM_EXPORT void acir_write_vk_ultra_keccak_zk_honk(uint8_t const* acir_vec, uint8_t** out)
{
    using ProverInstance = ProverInstance_<UltraKeccakZKFlavor>;
    using VerificationKey = UltraKeccakZKFlavor::VerificationKey;
 
    // lambda to free the builder
    ProverInstance prover_instance = [&] {
        acir_format::AcirProgram program{
            acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec)), {}
        };
        auto builder = acir_format::create_circuit<UltraCircuitBuilder>(program);
        return ProverInstance(builder);
    }();
    VerificationKey vk(prover_instance.get_precomputed());
    vinfo("Constructed UltraKeccakZKHonk verification key");
    *out = to_heap_buffer(to_buffer(vk));
}
 
WASM_EXPORT void acir_write_vk_ultra_starknet_honk([[maybe_unused]] uint8_t const* acir_vec,
                                                   [[maybe_unused]] uint8_t** out)
{
#ifdef STARKNET_GARAGA_FLAVORS
    using ProverInstance = ProverInstance_<UltraStarknetFlavor>;
    using VerificationKey = UltraStarknetFlavor::VerificationKey;
 
    // lambda to free the builder
    ProverInstance prover_instance = [&] {
        acir_format::AcirProgram program{
            acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec)), {}
        };
        auto builder = acir_format::create_circuit<UltraCircuitBuilder>(program);
        return ProverInstance(builder);
    }();
    VerificationKey vk(prover_instance.get_precomputed());
    vinfo("Constructed UltraStarknetHonk verification key");
    *out = to_heap_buffer(to_buffer(vk));
#else
    throw_or_abort("bb wasm was not compiled with starknet garaga flavors!");
#endif
}
 
WASM_EXPORT void acir_write_vk_ultra_starknet_zk_honk([[maybe_unused]] uint8_t const* acir_vec,
                                                      [[maybe_unused]] uint8_t** out)
{
#ifdef STARKNET_GARAGA_FLAVORS
    using ProverInstance = ProverInstance_<UltraStarknetZKFlavor>;
    using VerificationKey = UltraStarknetZKFlavor::VerificationKey;
 
    // lambda to free the builder
    ProverInstance prover_instance = [&] {
        acir_format::AcirProgram program{
            acir_format::circuit_buf_to_acir_format(from_buffer<std::vector<uint8_t>>(acir_vec)), {}
        };
        auto builder = acir_format::create_circuit<UltraCircuitBuilder>(program);
        return ProverInstance(builder);
    }();
    VerificationKey vk(prover_instance.get_precomputed());
    vinfo("Constructed UltraStarknetZKHonk verification key");
    *out = to_heap_buffer(to_buffer(vk));
#else
    throw_or_abort("bb wasm was not compiled with starknet garaga flavors!");
#endif
}
 
WASM_EXPORT void acir_honk_solidity_verifier(uint8_t const* proof_buf, uint8_t const* vk_buf, uint8_t** out)
{
    using VerificationKey = UltraKeccakFlavor::VerificationKey;
 
    auto proof = many_from_buffer<bb::fr>(from_buffer<std::vector<uint8_t>>(proof_buf));
    auto verification_key = from_buffer<VerificationKey>(vk_buf);
 
    auto str = get_honk_solidity_verifier(&verification_key);
    *out = to_heap_buffer(str);
}
 
WASM_EXPORT void acir_proof_as_fields_ultra_honk(uint8_t const* proof_buf, fr::vec_out_buf out)
{
    auto proof = many_from_buffer<bb::fr>(from_buffer<std::vector<uint8_t>>(proof_buf));
    *out = to_heap_buffer(proof);
}
 
WASM_EXPORT void acir_vk_as_fields_ultra_honk(uint8_t const* vk_buf, fr::vec_out_buf out_vkey)
{
    using VerificationKey = UltraFlavor::VerificationKey;
 
    auto verification_key = std::make_shared<VerificationKey>(from_buffer<VerificationKey>(vk_buf));
    std::vector<bb::fr> vkey_as_fields = verification_key->to_field_elements();
    *out_vkey = to_heap_buffer(vkey_as_fields);
}
 
WASM_EXPORT void acir_vk_as_fields_mega_honk(uint8_t const* vk_buf, fr::vec_out_buf out_vkey)
{
    using VerificationKey = MegaFlavor::VerificationKey;
 
    auto verification_key = std::make_shared<VerificationKey>(from_buffer<VerificationKey>(vk_buf));
    std::vector<bb::fr> vkey_as_fields = verification_key->to_field_elements();
    *out_vkey = to_heap_buffer(vkey_as_fields);
}
 
WASM_EXPORT void acir_gates_aztec_client(uint8_t const* ivc_inputs_buf, uint8_t** out)
{
    auto ivc_inputs_vec = from_buffer<std::vector<uint8_t>>(ivc_inputs_buf);
    // Note: we parse a stack, but only 'bytecode' needs to be set.
    auto raw_steps = PrivateExecutionStepRaw::parse_uncompressed(ivc_inputs_vec);
    std::vector<uint32_t> totals;
 
    auto ivc = std::make_shared<Chonk>(/*num_circuits=*/raw_steps.size());
    const acir_format::ProgramMetadata metadata{ ivc };
 
    for (const PrivateExecutionStepRaw& step : raw_steps) {
        std::vector<uint8_t> bytecode_vec(step.bytecode.begin(), step.bytecode.end());
        const acir_format::AcirFormat constraint_system =
            acir_format::circuit_buf_to_acir_format(std::move(bytecode_vec));
 
        // Create an acir program from the constraint system
        acir_format::AcirProgram program{ constraint_system, {} };
 
        auto builder = acir_format::create_circuit<MegaCircuitBuilder>(program);
        builder.finalize_circuit(/*ensure_nonzero=*/true);
        totals.push_back(static_cast<uint32_t>(builder.num_gates()));
    }
 
    *out = to_heap_buffer(to_buffer(totals));
}