aggregator_server.cpp File Reference

#include "libzecale/circuits/aggregator_circuit.hpp"
#include "libzecale/core/application_pool.hpp"
#include "libzecale/serialization/proto_utils.hpp"
#include "zecale_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 <iostream>
#include <libsnark/common/data_structures/merkle_tree.hpp>
#include <libtool/tool_util.hpp>
#include <libzeth/circuits/circuit_types.hpp>
#include <libzeth/core/utils.hpp>
#include <libzeth/serialization/proto_utils.hpp>
#include <libzeth/serialization/r1cs_serialization.hpp>
#include <libzeth/zeth_constants.hpp>
#include <map>
#include <memory>
#include <stdio.h>
#include <string>
#include <zecale/api/aggregator.grpc.pb.h>

Include dependency graph for aggregator_server.cpp:

Go to the source code of this file.

Classes
class	aggregator_server

Typedefs
using	npp = libsnark::other_curve< wpp >
using	nsnark = typename nverifier::snark
using	aggregator_circuit = libzecale::aggregator_circuit< wpp, wsnark, nverifier, batch_size >

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

Typedef Documentation

aggregator_circuit

using aggregator_circuit = libzecale::aggregator_circuit<wpp, wsnark, nverifier, batch_size>

Definition at line 76 of file aggregator_server.cpp.

npp

using npp = libsnark::other_curve<wpp>

Definition at line 49 of file aggregator_server.cpp.

nsnark

using nsnark = typename nverifier::snark

Definition at line 70 of file aggregator_server.cpp.

Function Documentation

display_server_start_message()

void display_server_start_message

(

)

Definition at line 343 of file aggregator_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 a privacy preserving "
                          "scalability solution on Ethereum";
    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 325 of file aggregator_server.cpp.

{
    char buffer[100];
    int n;
    // Defined in the zecale_config file
    n = snprintf(
        buffer,
        100,
        "Version %d.%d",
        ZECALE_VERSION_MAJOR,
        ZECALE_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 392 of file aggregator_server.cpp.

{
    // Options
    po::options_description options("");
    options.add_options()(
        "keypair,k",
        po::value<boost::filesystem::path>(),
        "file to load keypair from");
#ifdef DEBUG
    options.add_options()(
        "r1cs,r",
        po::value<boost::filesystem::path>(),
        "file in which to export the r1cs in json format");
#endif
 
    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;
    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>();
        }
    } 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 / "zecale_keypair.bin";
    }
 
    // Inititalize the curve parameters
    std::cout << "[INFO] Init params of both curves" << std::endl;
    npp::init_public_params();
    wpp::init_public_params();
 
    // Set up the aggregator circuit
    aggregator_circuit aggregator(num_inputs_per_nested_proof);
 
    // Load or generate the keypair
    wsnark::keypair keypair = [&keypair_file, &aggregator]() {
        if (boost::filesystem::exists(keypair_file)) {
            std::cout << "[INFO] Loading keypair: " << keypair_file << "\n";
            wsnark::keypair keypair;
            std::ifstream in_s =
                libtool::open_binary_input_file(keypair_file.c_str());
            wsnark::keypair_read_bytes(keypair, in_s);
 
            // Check the VK is for the correct number of inputs.
            if (keypair.vk.ABC_g1.size() != aggregator.num_primary_inputs()) {
                throw std::invalid_argument("invalid VK");
            }
 
            return keypair;
        }
 
        std::cout << "[INFO] No keypair file " << keypair_file
                  << ". Generating.\n";
        const wsnark::keypair keypair = aggregator.generate_trusted_setup();
 
        // Check the VK is for the correct number of inputs.
        if (keypair.vk.ABC_g1.size() != aggregator.num_primary_inputs()) {
            throw std::invalid_argument("invalid VK");
        }
 
        const size_t num_constraints =
            aggregator.get_constraint_system().num_constraints();
        std::cout << "[INFO] Circuit has " << std::to_string(num_constraints)
                  << " constraints\n";
 
        std::cout << "[INFO] Writing new keypair to " << keypair_file << "\n";
        std::ofstream out_s =
            libtool::open_binary_output_file(keypair_file.c_str());
        wsnark::keypair_write_bytes(keypair, out_s);
        return keypair;
    }();
 
    // If a file has been given for the JSON representation of the circuit,
    // write it out.
    if (!r1cs_file.empty()) {
        std::cout << "[INFO] Writing R1CS to " << std::endl;
        std::ofstream r1cs_stream(r1cs_file.c_str());
        libzeth::r1cs_write_json(
            aggregator.get_constraint_system(), r1cs_stream);
    }
 
    // Launch the server
    std::cout << "[INFO] Setup successful, starting the server..." << std::endl;
    RunServer(aggregator, keypair);
    return 0;
}