prover_server.cpp File Reference

#include "libtool/tool_util.hpp"
#include "libzeth/circuits/circuit_types.hpp"
#include "libzeth/core/extended_proof.hpp"
#include "libzeth/core/utils.hpp"
#include "libzeth/serialization/proto_utils.hpp"
#include "libzeth/serialization/r1cs_serialization.hpp"
#include "libzeth/serialization/r1cs_variable_assignment_serialization.hpp"
#include "libzeth/zeth_constants.hpp"
#include "zeth_config.h"
#include <boost/program_options.hpp>
#include <fstream>
#include <grpc/grpc.h>
#include <grpcpp/security/server_credentials.h>
#include <grpcpp/server.h>
#include <grpcpp/server_builder.h>
#include <grpcpp/server_context.h>
#include <libsnark/common/data_structures/merkle_tree.hpp>
#include <memory>
#include <stdio.h>
#include <string>
#include <zeth/api/prover.grpc.pb.h>

Include dependency graph for prover_server.cpp:

Go to the source code of this file.

Classes
class	prover_server

Typedefs
using	pp = libzeth::defaults::pp
using	Field = libzeth::defaults::Field
using	snark = libzeth::defaults::snark
using	api_handler = libzeth::defaults::api_handler
using	circuit_wrapper = libzeth::JoinsplitCircuitT< pp, snark >

Functions
std::string	get_server_version ()
void	display_server_start_message ()
int	main (int argc, char **argv)

Typedef Documentation

api_handler

using api_handler = libzeth::defaults::api_handler

Definition at line 31 of file prover_server.cpp.

circuit_wrapper

using circuit_wrapper = libzeth::JoinsplitCircuitT<pp, snark>

Definition at line 32 of file prover_server.cpp.

Field

using Field = libzeth::defaults::Field

Definition at line 29 of file prover_server.cpp.

pp

using pp = libzeth::defaults::pp

Definition at line 28 of file prover_server.cpp.

snark

using snark = libzeth::defaults::snark

Definition at line 30 of file prover_server.cpp.

Function Documentation

display_server_start_message()

void display_server_start_message

(

)

Definition at line 275 of file prover_server.cpp.

{
    std::string copyright =
        "Copyright (c) 2015-2022 Clearmatics Technologies Ltd";
    std::string license = "SPDX-License-Identifier: LGPL-3.0+";
    std::string project =
        "R&D Department: PoC for Zerocash on Ethereum/Autonity";
    std::string version = get_server_version();
    std::string warning = "**WARNING:** This code is a research-quality proof "
                          "of concept, DO NOT use in production!";
 
    std::cout << "\n=====================================================\n";
    std::cout << copyright << "\n";
    std::cout << license << "\n";
    std::cout << project << "\n";
    std::cout << version << "\n";
    std::cout << warning << "\n";
    std::cout << "=====================================================\n"
              << std::endl;
}

Here is the call graph for this function:

get_server_version()

std::string get_server_version

(

)

Definition at line 261 of file prover_server.cpp.

{
    char buffer[100];
    int n;
    // Defined in the zethConfig file
    n = snprintf(
        buffer, 100, "Version %d.%d", ZETH_VERSION_MAJOR, ZETH_VERSION_MINOR);
    if (n < 0) {
        return "Version <Not specified>";
    }
    std::string version(buffer);
    return version;
}

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 334 of file prover_server.cpp.

{
    // Options
    po::options_description options("Options");
    options.add_options()("help,h", "This help");
    options.add_options()(
        "keypair,k",
        po::value<boost::filesystem::path>(),
        "file to load keypair from. If it doesn't exist, a new keypair will be "
        "generated and written to this file. (default: "
        "~/zeth_setup/keypair.bin)");
    options.add_options()(
        "r1cs,r",
        po::value<boost::filesystem::path>(),
        "file in which to export the r1cs (in json format)");
    options.add_options()(
        "proving-key-output",
        po::value<boost::filesystem::path>(),
        "write proving key to file (if generated)");
    options.add_options()(
        "verification-key-output",
        po::value<boost::filesystem::path>(),
        "write verification key to file (if generated)");
    options.add_options()(
        "extproof-json-output",
        po::value<boost::filesystem::path>(),
        "(DEBUG) write generated extended proofs (JSON) to file");
    options.add_options()(
        "proof-output",
        po::value<boost::filesystem::path>(),
        "(DEBUG) write generated proofs to file");
    options.add_options()(
        "primary-output",
        po::value<boost::filesystem::path>(),
        "(DEBUG) write primary input to file");
    options.add_options()(
        "assignment-output",
        po::value<boost::filesystem::path>(),
        "(DEBUG) write full assignment to file (INSECURE!)");
 
    auto usage = [&]() {
        std::cout << "Usage:"
                  << "\n"
                  << "  " << argv[0] << " [<options>]\n"
                  << "\n";
        std::cout << options;
        std::cout << std::endl;
    };
 
    boost::filesystem::path keypair_file;
    boost::filesystem::path r1cs_file;
    boost::filesystem::path proving_key_output_file;
    boost::filesystem::path verification_key_output_file;
    boost::filesystem::path extproof_json_output_file;
    boost::filesystem::path proof_output_file;
    boost::filesystem::path primary_output_file;
    boost::filesystem::path assignment_output_file;
    try {
        po::variables_map vm;
        po::store(
            po::command_line_parser(argc, argv).options(options).run(), vm);
        if (vm.count("help")) {
            usage();
            return 0;
        }
        if (vm.count("keypair")) {
            keypair_file = vm["keypair"].as<boost::filesystem::path>();
        }
        if (vm.count("r1cs")) {
            r1cs_file = vm["r1cs"].as<boost::filesystem::path>();
        }
        if (vm.count("proving-key-output")) {
            proving_key_output_file =
                vm["proving-key-output"].as<boost::filesystem::path>();
        }
        if (vm.count("verification-key-output")) {
            verification_key_output_file =
                vm["verification-key-output"].as<boost::filesystem::path>();
        }
        if (vm.count("extproof-json-output")) {
            extproof_json_output_file =
                vm["extproof-json-output"].as<boost::filesystem::path>();
        }
        if (vm.count("proof-output")) {
            proof_output_file =
                vm["proof-output"].as<boost::filesystem::path>();
        }
        if (vm.count("primary-output")) {
            primary_output_file =
                vm["primary-output"].as<boost::filesystem::path>();
        }
        if (vm.count("assignment-output")) {
            assignment_output_file =
                vm["assignment-output"].as<boost::filesystem::path>();
        }
    } catch (po::error &error) {
        std::cerr << " ERROR: " << error.what() << std::endl;
        usage();
        return 1;
    }
 
    // Default keypair_file if none given
    if (keypair_file.empty()) {
        boost::filesystem::path setup_dir =
            libzeth::get_path_to_setup_directory();
        if (!setup_dir.empty()) {
            boost::filesystem::create_directories(setup_dir);
        }
        keypair_file = setup_dir / "keypair.bin";
    }
 
    // Inititalize the curve parameters
    std::cout << "[INFO] Init params (" << libzeth::pp_name<pp>() << ")\n";
    pp::init_public_params();
 
    // If the keypair file exists, load and use it, otherwise generate a new
    // keypair and write it to the file.
    circuit_wrapper prover;
    snark::keypair keypair = [&keypair_file,
                              &proving_key_output_file,
                              &verification_key_output_file,
                              &prover]() {
        if (boost::filesystem::exists(keypair_file)) {
            std::cout << "[INFO] Loading keypair: " << keypair_file << "\n";
 
            snark::keypair keypair;
            std::ifstream in_s =
                libtool::open_binary_input_file(keypair_file.c_str());
            snark::keypair_read_bytes(keypair, in_s);
            return keypair;
        }
 
        std::cout << "[INFO] No keypair file " << keypair_file
                  << ". Generating.\n";
        const snark::keypair keypair = prover.generate_trusted_setup();
 
        if (!proving_key_output_file.empty()) {
            std::cout << "[DEBUG] Writing separate proving key to "
                      << proving_key_output_file << "\n";
            std::ofstream out_s = libtool::open_binary_output_file(
                proving_key_output_file.c_str());
            snark::proving_key_write_bytes(keypair.pk, out_s);
        }
        if (!verification_key_output_file.empty()) {
            std::cout << "[DEBUG] Writing separate verification key to "
                      << verification_key_output_file << "\n";
            std::ofstream out_s = libtool::open_binary_output_file(
                verification_key_output_file.c_str());
            snark::verification_key_write_bytes(keypair.vk, out_s);
        }
 
        // Write the keypair last. If something above fails, this same
        // code-path will be executed again on the next invocation.
        std::cout << "[INFO] Writing new keypair to " << keypair_file << "\n";
        std::ofstream out_s =
            libtool::open_binary_output_file(keypair_file.c_str());
        snark::keypair_write_bytes(keypair, out_s);
 
        return keypair;
    }();
 
    // If a file is given, export the JSON representation of the constraint
    // system.
    if (!r1cs_file.empty()) {
        std::cout << "[INFO] Writing R1CS to " << r1cs_file << "\n";
        std::ofstream r1cs_stream(r1cs_file.c_str());
        libzeth::r1cs_write_json(prover.get_constraint_system(), r1cs_stream);
    }
 
    std::cout << "[INFO] Setup successful, starting the server..." << std::endl;
    RunServer(
        prover,
        keypair,
        extproof_json_output_file,
        proof_output_file,
        primary_output_file,
        assignment_output_file);
    return 0;
}

Here is the call graph for this function: