bacs_ppzksnark.hpp

Go to the documentation of this file.

 
#ifndef BACS_PPZKSNARK_HPP_
#define BACS_PPZKSNARK_HPP_
 
#include <libsnark/relations/circuit_satisfaction_problems/bacs/bacs.hpp>
#include <libsnark/zk_proof_systems/ppzksnark/bacs_ppzksnark/bacs_ppzksnark_params.hpp>
#include <libsnark/zk_proof_systems/ppzksnark/r1cs_ppzksnark/r1cs_ppzksnark.hpp>
 
namespace libsnark
{
 
/******************************** Proving key ********************************/
 
template<typename ppT> class bacs_ppzksnark_proving_key;
 
template<typename ppT>
std::ostream &operator<<(
    std::ostream &out, const bacs_ppzksnark_proving_key<ppT> &pk);
 
template<typename ppT>
std::istream &operator>>(std::istream &in, bacs_ppzksnark_proving_key<ppT> &pk);
 
template<typename ppT> class bacs_ppzksnark_proving_key
{
public:
    bacs_ppzksnark_circuit<ppT> circuit;
    r1cs_ppzksnark_proving_key<ppT> r1cs_pk;
 
    bacs_ppzksnark_proving_key(){};
    bacs_ppzksnark_proving_key(const bacs_ppzksnark_proving_key<ppT> &other) =
        default;
    bacs_ppzksnark_proving_key(bacs_ppzksnark_proving_key<ppT> &&other) =
        default;
    bacs_ppzksnark_proving_key(
        const bacs_ppzksnark_circuit<ppT> &circuit,
        const r1cs_ppzksnark_proving_key<ppT> &r1cs_pk)
        : circuit(circuit), r1cs_pk(r1cs_pk)
    {
    }
    bacs_ppzksnark_proving_key(
        bacs_ppzksnark_circuit<ppT> &&circuit,
        r1cs_ppzksnark_proving_key<ppT> &&r1cs_pk)
        : circuit(std::move(circuit)), r1cs_pk(std::move(r1cs_pk))
    {
    }
 
    bacs_ppzksnark_proving_key<ppT> &operator=(
        const bacs_ppzksnark_proving_key<ppT> &other) = default;
 
    size_t G1_size() const { return r1cs_pk.G1_size(); }
 
    size_t G2_size() const { return r1cs_pk.G2_size(); }
 
    size_t G1_sparse_size() const { return r1cs_pk.G1_sparse_size(); }
 
    size_t G2_sparse_size() const { return r1cs_pk.G2_sparse_size(); }
 
    size_t size_in_bits() const { return r1cs_pk.size_in_bits(); }
 
    void print_size() const { r1cs_pk.print_size(); }
 
    bool operator==(const bacs_ppzksnark_proving_key<ppT> &other) const;
    friend std::ostream &operator<<<ppT>(
        std::ostream &out, const bacs_ppzksnark_proving_key<ppT> &pk);
    friend std::istream &operator>>
        <ppT>(std::istream &in, bacs_ppzksnark_proving_key<ppT> &pk);
};
 
/******************************* Verification key ****************************/
 
template<typename ppT>
using bacs_ppzksnark_verification_key = r1cs_ppzksnark_verification_key<ppT>;
 
/************************ Processed verification key *************************/
 
template<typename ppT>
using bacs_ppzksnark_processed_verification_key =
    r1cs_ppzksnark_processed_verification_key<ppT>;
 
/********************************** Key pair *********************************/
 
template<typename ppT> class bacs_ppzksnark_keypair
{
public:
    bacs_ppzksnark_proving_key<ppT> pk;
    bacs_ppzksnark_verification_key<ppT> vk;
 
    bacs_ppzksnark_keypair(){};
    bacs_ppzksnark_keypair(bacs_ppzksnark_keypair<ppT> &&other) = default;
    bacs_ppzksnark_keypair(
        const bacs_ppzksnark_proving_key<ppT> &pk,
        const bacs_ppzksnark_verification_key<ppT> &vk)
        : pk(pk), vk(vk)
    {
    }
 
    bacs_ppzksnark_keypair(
        bacs_ppzksnark_proving_key<ppT> &&pk,
        bacs_ppzksnark_verification_key<ppT> &&vk)
        : pk(std::move(pk)), vk(std::move(vk))
    {
    }
};
 
/*********************************** Proof ***********************************/
 
template<typename ppT> using bacs_ppzksnark_proof = r1cs_ppzksnark_proof<ppT>;
 
/***************************** Main algorithms *******************************/
 
template<typename ppT>
bacs_ppzksnark_keypair<ppT> bacs_ppzksnark_generator(
    const bacs_ppzksnark_circuit<ppT> &circuit);
 
template<typename ppT>
bacs_ppzksnark_proof<ppT> bacs_ppzksnark_prover(
    const bacs_ppzksnark_proving_key<ppT> &pk,
    const bacs_ppzksnark_primary_input<ppT> &primary_input,
    const bacs_ppzksnark_auxiliary_input<ppT> &auxiliary_input);
 
/*
 Below are four variants of verifier algorithm for the BACS ppzkSNARK.
 
 These are the four cases that arise from the following two choices:
 
 (1) The verifier accepts a (non-processed) verification key or, instead, a
 processed verification key. In the latter case, we call the algorithm an
 "online verifier".
 
 (2) The verifier checks for "weak" input consistency or, instead, "strong"
 input consistency. Strong input consistency requires that |primary_input| =
 C.num_inputs, whereas weak input consistency requires that |primary_input| <=
 C.num_inputs (and the primary input is implicitly padded with zeros up to
 length C.num_inputs).
 */
 
template<typename ppT>
bool bacs_ppzksnark_verifier_weak_IC(
    const bacs_ppzksnark_verification_key<ppT> &vk,
    const bacs_ppzksnark_primary_input<ppT> &primary_input,
    const bacs_ppzksnark_proof<ppT> &proof);
 
template<typename ppT>
bool bacs_ppzksnark_verifier_strong_IC(
    const bacs_ppzksnark_verification_key<ppT> &vk,
    const bacs_ppzksnark_primary_input<ppT> &primary_input,
    const bacs_ppzksnark_proof<ppT> &proof);
 
template<typename ppT>
bacs_ppzksnark_processed_verification_key<ppT> bacs_ppzksnark_verifier_process_vk(
    const bacs_ppzksnark_verification_key<ppT> &vk);
 
template<typename ppT>
bool bacs_ppzksnark_online_verifier_weak_IC(
    const bacs_ppzksnark_processed_verification_key<ppT> &pvk,
    const bacs_ppzksnark_primary_input<ppT> &primary_input,
    const bacs_ppzksnark_proof<ppT> &proof);
 
template<typename ppT>
bool bacs_ppzksnark_online_verifier_strong_IC(
    const bacs_ppzksnark_processed_verification_key<ppT> &pvk,
    const bacs_ppzksnark_primary_input<ppT> &primary_input,
    const bacs_ppzksnark_proof<ppT> &proof);
 
} // namespace libsnark
 
#include <libsnark/zk_proof_systems/ppzksnark/bacs_ppzksnark/bacs_ppzksnark.tcc>
 
#endif // BACS_PPZKSNARK_HPP_