aggregator_server Class Reference

Inheritance diagram for aggregator_server:

Collaboration diagram for aggregator_server:

Public Member Functions
	aggregator_server (aggregator_circuit &aggregator, const wsnark::keypair &keypair)
virtual	~aggregator_server ()
grpc::Status	GetConfiguration (grpc::ServerContext *, const proto::Empty *, zecale_proto::AggregatorConfiguration *response) override
grpc::Status	GetVerificationKey (grpc::ServerContext *, const proto::Empty *, zeth_proto::VerificationKey *response) override
grpc::Status	GetNestedVerificationKeyHash (grpc::ServerContext *, const zeth_proto::VerificationKey *request, zecale_proto::VerificationKeyHash *response) override
grpc::Status	RegisterApplication (grpc::ServerContext *, const zecale_proto::ApplicationDescription *registration, zecale_proto::VerificationKeyHash *response) override
grpc::Status	SubmitNestedTransaction (grpc::ServerContext *, const zecale_proto::NestedTransaction *transaction, proto::Empty *) override
grpc::Status	GenerateAggregatedTransaction (grpc::ServerContext *, const zecale_proto::AggregatedTransactionRequest *request, zecale_proto::AggregatedTransaction *response) override

Detailed Description

The aggregator_server class inherits from the Aggregator service defined in the proto files, and provides an implementation of the service.

Definition at line 80 of file aggregator_server.cpp.

Constructor & Destructor Documentation

aggregator_server()

aggregator_server::aggregator_server ( aggregator_circuit &  aggregator, const wsnark::keypair &  keypair  )

inlineexplicit

Definition at line 95 of file aggregator_server.cpp.

        : aggregator(aggregator), keypair(keypair)
    {
    }

~aggregator_server()

virtual aggregator_server::~aggregator_server ( )

inlinevirtual

Definition at line 101 of file aggregator_server.cpp.

    {
        // Release all application_pool objects.
        for (const auto &entry : application_pools) {
            delete entry.second;
        }
        application_pools.clear();
    }

Member Function Documentation

GenerateAggregatedTransaction()

grpc::Status aggregator_server::GenerateAggregatedTransaction ( grpc::ServerContext *  , const zecale_proto::AggregatedTransactionRequest *  request, zecale_proto::AggregatedTransaction *  response  )

inlineoverride

Definition at line 253 of file aggregator_server.cpp.

    {
        try {
            // Get the application_pool if it exists (otherwise an exception is
            // thrown, returning an error to the client).
            const std::string &app_name = request->application_name();
            std::cout << "[ACK] Aggregation tx request, app name: " << app_name
                      << std::endl;
            application_pool *const app_pool = application_pools.at(app_name);
 
            // Retrieve a batch from the pool.
            std::array<libzecale::nested_transaction<npp, nsnark>, batch_size>
                batch;
            const size_t num_entries = app_pool->get_next_batch(batch);
            std::cout << "[DEBUG] Got batch of size "
                      << std::to_string(num_entries) << " from the pool\n";
            if (num_entries == 0) {
                throw std::runtime_error("insufficient entries in pool");
            }
 
            // Extract the nested proofs
            std::array<const libzeth::extended_proof<npp, nsnark> *, batch_size>
                nested_proofs;
            for (size_t i = 0; i < batch_size; ++i) {
                nested_proofs[i] = &batch[i].extended_proof();
 
                std::cout << "[DEBUG] got tx " << std::to_string(i)
                          << " with ext proof:\n";
                nested_proofs[i]->write_json(std::cout);
            }
 
            // Retrieve the nested verification key for this application.
            const nsnark::verification_key &nested_vk =
                app_pool->verification_key();
 
            std::cout << "[DEBUG] Generating the batched proof...\n";
            libzeth::extended_proof<wpp, wsnark> wrapping_proof =
                aggregator.prove(nested_vk, nested_proofs, keypair.pk);
 
            std::cout << "[DEBUG] Generated extended proof:\n";
            wrapping_proof.write_json(std::cout);
 
            // Populate the response with name, extended_proof and
            // nested_parameters.
            response->set_application_name(app_name);
            zeth_proto::ExtendedProof *wrapping_proof_proto =
                new zeth_proto::ExtendedProof();
            wapi_handler::extended_proof_to_proto(
                wrapping_proof, wrapping_proof_proto);
            response->set_allocated_extended_proof(wrapping_proof_proto);
            for (size_t i = 0; i < batch_size; ++i) {
                const std::vector<uint8_t> &parameters = batch[i].parameters();
                response->add_nested_parameters(
                    (const char *)parameters.data(), parameters.size());
            }
            std::cout << "[DEBUG] Written to response" << std::endl;
        } catch (const std::exception &e) {
            std::cout << "[ERROR] " << e.what() << std::endl;
            return grpc::Status(
                grpc::StatusCode::INVALID_ARGUMENT, grpc::string(e.what()));
        } catch (...) {
            std::cout << "[ERROR] In catch all" << std::endl;
            return grpc::Status(grpc::StatusCode::UNKNOWN, "");
        }
 
        return grpc::Status::OK;
    }

GetConfiguration()

grpc::Status aggregator_server::GetConfiguration ( grpc::ServerContext *  , const proto::Empty *  , zecale_proto::AggregatorConfiguration *  response  )

inlineoverride

Definition at line 110 of file aggregator_server.cpp.

    {
        std::cout << "[INFO] Request for configuration\n";
        libzecale::aggregator_configuration_to_proto<npp, wpp, nsnark, wsnark>(
            *response);
        return grpc::Status::OK;
    }

GetNestedVerificationKeyHash()

grpc::Status aggregator_server::GetNestedVerificationKeyHash ( grpc::ServerContext *  , const zeth_proto::VerificationKey *  request, zecale_proto::VerificationKeyHash *  response  )

inlineoverride

Definition at line 144 of file aggregator_server.cpp.

    {
        typename nsnark::verification_key vk =
            napi_handler::verification_key_from_proto(*request);
        const libff::Fr<wpp> vk_hash =
            libzecale::verification_key_hash_gadget<wpp, nverifier>::
                compute_hash(vk, num_inputs_per_nested_proof);
        const std::string vk_hash_str = libzeth::field_element_to_json(vk_hash);
        response->set_hash(vk_hash_str);
 
        std::cout << "[DEBUG] GetNestedVerificationKeyHash: "
                  << "vk:\n";
        nsnark::verification_key_write_json(vk, std::cout);
        std::cout << "\n VK hash: " << vk_hash_str << "\n";
        return grpc::Status::OK;
    }

Here is the call graph for this function:

GetVerificationKey()

grpc::Status aggregator_server::GetVerificationKey ( grpc::ServerContext *  , const proto::Empty *  , zeth_proto::VerificationKey *  response  )

inlineoverride

Definition at line 121 of file aggregator_server.cpp.

    {
        std::cout << "[ACK] Received the request to get the verification key"
                  << std::endl;
        std::cout << "[DEBUG] Preparing verification key for response..."
                  << std::endl;
        try {
            wapi_handler::verification_key_to_proto(keypair.vk, response);
        } catch (const std::exception &e) {
            std::cout << "[ERROR] " << e.what() << std::endl;
            return grpc::Status(
                grpc::StatusCode::INVALID_ARGUMENT, grpc::string(e.what()));
        } catch (...) {
            std::cout << "[ERROR] In catch all" << std::endl;
            return grpc::Status(grpc::StatusCode::UNKNOWN, "");
        }
 
        return grpc::Status::OK;
    }

RegisterApplication()

grpc::Status aggregator_server::RegisterApplication ( grpc::ServerContext *  , const zecale_proto::ApplicationDescription *  registration, zecale_proto::VerificationKeyHash *  response  )

inlineoverride

Definition at line 164 of file aggregator_server.cpp.

    {
        std::cout << "[ACK] Received 'register application' request"
                  << std::endl;
        std::cout << "[DEBUG] Registering application..." << std::endl;
 
        try {
            // Ensure an app of the same name has not already been registered.
            const std::string &name = registration->application_name();
            if (application_pools.count(name)) {
                return grpc::Status(
                    grpc::StatusCode::INVALID_ARGUMENT,
                    grpc::string("application already registered"));
            }
 
            // Add the application to the list of supported applications on the
            // aggregator server.
            const zeth_proto::VerificationKey &vk_proto = registration->vk();
            typename nsnark::verification_key vk =
                napi_handler::verification_key_from_proto(vk_proto);
            application_pools[name] = new application_pool(name, vk);
            const libff::Fr<wpp> vk_hash =
                libzecale::verification_key_hash_gadget<wpp, nverifier>::
                    compute_hash(vk, num_inputs_per_nested_proof);
            const std::string vk_hash_str =
                libzeth::field_element_to_json(vk_hash);
            response->set_hash(vk_hash_str);
 
            std::cout << "[DEBUG] Registered application '" << name
                      << " with VK:\n";
            nsnark::verification_key_write_json(vk, std::cout);
            std::cout << "\n VK hash: " << vk_hash_str << "\n";
        } catch (const std::exception &e) {
            std::cout << "[ERROR] " << e.what() << std::endl;
            return grpc::Status(
                grpc::StatusCode::INVALID_ARGUMENT, grpc::string(e.what()));
        } catch (...) {
            std::cout << "[ERROR] In catch all" << std::endl;
            return grpc::Status(grpc::StatusCode::UNKNOWN, "");
        }
 
        return grpc::Status::OK;
    }

Here is the call graph for this function:

SubmitNestedTransaction()

grpc::Status aggregator_server::SubmitNestedTransaction ( grpc::ServerContext *  , const zecale_proto::NestedTransaction *  transaction, proto::Empty *    )

inlineoverride

Definition at line 211 of file aggregator_server.cpp.

    {
        try {
            // Get the application_pool if it exists (otherwise an exception is
            // thrown, returning an error to the client).
            const std::string &app_name = transaction->application_name();
            std::cout << "[ACK] Received nested transaction, app name: "
                      << app_name << std::endl;
            application_pool *const app_pool = application_pools.at(app_name);
 
            // Sanity-check the transaction (number of inputs).
            const libzecale::nested_transaction<npp, nsnark> tx =
                libzecale::nested_transaction_from_proto<npp, napi_handler>(
                    *transaction);
            if (tx.extended_proof().get_primary_inputs().size() !=
                num_inputs_per_nested_proof) {
                throw std::invalid_argument("invalid number of inputs");
            }
 
            // Add the proof to the pool for the named application.
            app_pool->add_tx(tx);
 
            std::cout << "[DEBUG] Registered tx with ext proof:\n";
            tx.extended_proof().write_json(std::cout) << "\n";
 
            std::cout << "[DEBUG] " << std::to_string(app_pool->tx_pool_size())
                      << " txs in pool\n";
        } catch (const std::exception &e) {
            std::cout << "[ERROR] " << e.what() << std::endl;
            return grpc::Status(
                grpc::StatusCode::INVALID_ARGUMENT, grpc::string(e.what()));
        } catch (...) {
            std::cout << "[ERROR] In catch all" << std::endl;
            return grpc::Status(grpc::StatusCode::UNKNOWN, "");
        }
 
        return grpc::Status::OK;
    }

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• /home/runner/work/zecale/zecale/aggregator_server/aggregator_server.cpp