Zeth - Zerocash on Ethereum  0.8
Reference implementation of the Zeth protocol by Clearmatics
Public Member Functions | List of all members
prover_server Class Referencefinal
Inheritance diagram for prover_server:
Inheritance graph
[legend]
Collaboration diagram for prover_server:
Collaboration graph
[legend]

Public Member Functions

 prover_server (circuit_wrapper &prover, const snark::keypair &keypair, const boost::filesystem::path &extproof_json_output_file, const boost::filesystem::path &proof_output_file, const boost::filesystem::path &primary_output_file, const boost::filesystem::path &assignment_output_file)
 
grpc::Status GetConfiguration (grpc::ServerContext *, const proto::Empty *, zeth_proto::ProverConfiguration *response) override
 
grpc::Status GetVerificationKey (grpc::ServerContext *, const proto::Empty *, zeth_proto::VerificationKey *response) override
 
grpc::Status Prove (grpc::ServerContext *, const zeth_proto::ProofInputs *proof_inputs, zeth_proto::ExtendedProofAndPublicData *proof_and_public_data) override
 

Detailed Description

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

Definition at line 48 of file prover_server.cpp.

Constructor & Destructor Documentation

◆ prover_server()

prover_server::prover_server ( circuit_wrapper &  prover,
const snark::keypair &  keypair,
const boost::filesystem::path &  extproof_json_output_file,
const boost::filesystem::path &  proof_output_file,
const boost::filesystem::path &  primary_output_file,
const boost::filesystem::path &  assignment_output_file 
)
inlineexplicit

Definition at line 69 of file prover_server.cpp.

76  : prover(prover)
77  , keypair(keypair)
78  , extproof_json_output_file(extproof_json_output_file)
79  , proof_output_file(proof_output_file)
80  , primary_output_file(primary_output_file)
81  , assignment_output_file(assignment_output_file)
82  {
83  }

Member Function Documentation

◆ GetConfiguration()

grpc::Status prover_server::GetConfiguration ( grpc::ServerContext *  ,
const proto::Empty *  ,
zeth_proto::ProverConfiguration *  response 
)
inlineoverride

Definition at line 85 of file prover_server.cpp.

89  {
90  std::cout << "[ACK] Received the request for configuration\n";
91  prover_configuration_to_proto(*response);
92  return grpc::Status::OK;
93  }

◆ GetVerificationKey()

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

Definition at line 95 of file prover_server.cpp.

99  {
100  std::cout << "[ACK] Received the request to get the verification key"
101  << std::endl;
102  std::cout << "[DEBUG] Preparing verification key for response..."
103  << std::endl;
104  try {
105  api_handler::verification_key_to_proto(this->keypair.vk, response);
106  } catch (const std::exception &e) {
107  std::cout << "[ERROR] " << e.what() << std::endl;
108  return grpc::Status(
109  grpc::StatusCode::INVALID_ARGUMENT, grpc::string(e.what()));
110  } catch (...) {
111  std::cout << "[ERROR] In catch all" << std::endl;
112  return grpc::Status(grpc::StatusCode::UNKNOWN, "");
113  }
114 
115  return grpc::Status::OK;
116  }

◆ Prove()

grpc::Status prover_server::Prove ( grpc::ServerContext *  ,
const zeth_proto::ProofInputs *  proof_inputs,
zeth_proto::ExtendedProofAndPublicData *  proof_and_public_data 
)
inlineoverride

Definition at line 118 of file prover_server.cpp.

122  {
123  std::cout << "[ACK] Received the request to generate a proof"
124  << std::endl;
125  std::cout << "[DEBUG] Parse received message to compute proof..."
126  << std::endl;
127 
128  // Parse received message to feed to the prover
129  try {
130  // TODO: Factor this into more maintainable smaller functions
131 
132  Field root = libzeth::base_field_element_from_hex<Field>(
133  proof_inputs->mk_root());
134  libzeth::bits64 vpub_in =
135  libzeth::bits64::from_hex(proof_inputs->pub_in_value());
136  libzeth::bits64 vpub_out =
137  libzeth::bits64::from_hex(proof_inputs->pub_out_value());
138  libzeth::bits256 h_sig_in =
139  libzeth::bits256::from_hex(proof_inputs->h_sig());
140  libzeth::bits256 phi_in =
141  libzeth::bits256::from_hex(proof_inputs->phi());
142 
143  if (libzeth::ZETH_NUM_JS_INPUTS != proof_inputs->js_inputs_size()) {
144  std::cout << "[INFO] Request with "
145  << proof_inputs->js_inputs_size()
146  << " inputs. Expecting "
147  << libzeth::ZETH_NUM_JS_INPUTS << "\n";
148  throw std::invalid_argument("Invalid number of JS inputs");
149  }
150  if (libzeth::ZETH_NUM_JS_OUTPUTS !=
151  proof_inputs->js_outputs_size()) {
152  throw std::invalid_argument("Invalid number of JS outputs");
153  }
154 
155  std::cout << "[DEBUG] Process all inputs of the JoinSplit"
156  << std::endl;
157  std::array<
158  libzeth::
159  joinsplit_input<Field, libzeth::ZETH_MERKLE_TREE_DEPTH>,
160  libzeth::ZETH_NUM_JS_INPUTS>
161  joinsplit_inputs;
162  for (size_t i = 0; i < libzeth::ZETH_NUM_JS_INPUTS; i++) {
163  printf(
164  "\r input (%zu / %zu)\n", i, libzeth::ZETH_NUM_JS_INPUTS);
165  const zeth_proto::JoinsplitInput &received_input =
166  proof_inputs->js_inputs(i);
167  joinsplit_inputs[i] = libzeth::joinsplit_input_from_proto<
168  Field,
169  libzeth::ZETH_MERKLE_TREE_DEPTH>(received_input);
170  }
171 
172  std::cout << "[DEBUG] Process all outputs of the JoinSplit"
173  << std::endl;
174  std::array<libzeth::zeth_note, libzeth::ZETH_NUM_JS_OUTPUTS>
175  joinsplit_outputs;
176  for (size_t i = 0; i < libzeth::ZETH_NUM_JS_OUTPUTS; i++) {
177  printf(
178  "\r output (%zu / %zu)\n",
179  i,
180  libzeth::ZETH_NUM_JS_OUTPUTS);
181  const zeth_proto::ZethNote &received_output =
182  proof_inputs->js_outputs(i);
183  libzeth::zeth_note parsed_output =
184  libzeth::zeth_note_from_proto(received_output);
185  joinsplit_outputs[i] = parsed_output;
186  }
187 
188  std::cout << "[DEBUG] Data parsed successfully" << std::endl;
189  std::cout << "[DEBUG] Generating the proof..." << std::endl;
190 
191  std::vector<Field> public_data;
192  libzeth::extended_proof<pp, snark> ext_proof = this->prover.prove(
193  root,
194  joinsplit_inputs,
195  joinsplit_outputs,
196  vpub_in,
197  vpub_out,
198  h_sig_in,
199  phi_in,
200  this->keypair.pk,
201  public_data);
202 
203  std::cout << "[DEBUG] Displaying extended proof and public data\n";
204  ext_proof.write_json(std::cout);
205  for (const Field &f : public_data) {
206  std::cout << libzeth::base_field_element_to_hex(f) << "\n";
207  }
208 
209  // Write a copy of the proof for debugging.
210  if (!extproof_json_output_file.empty()) {
211  std::cout << "[DEBUG] Writing extended proof (JSON) to "
212  << extproof_json_output_file << "\n";
213  std::ofstream out_s(extproof_json_output_file.c_str());
214  ext_proof.write_json(out_s);
215  }
216  if (!proof_output_file.empty()) {
217  std::cout << "[DEBUG] Writing proof to " << proof_output_file
218  << "\n";
219  std::ofstream out_s =
220  libtool::open_binary_output_file(proof_output_file.c_str());
221  snark::proof_write_bytes(ext_proof.get_proof(), out_s);
222  }
223  if (!primary_output_file.empty()) {
224  std::cout << "[DEBUG] Writing primary input to "
225  << primary_output_file << "\n";
226  std::ofstream out_s = libtool::open_binary_output_file(
227  primary_output_file.c_str());
228  libzeth::r1cs_variable_assignment_write_bytes(
229  ext_proof.get_primary_inputs(), out_s);
230  }
231  if (!assignment_output_file.empty()) {
232  std::cout << "[DEBUG] WARNING! Writing assignment to "
233  << assignment_output_file << "\n";
234  std::ofstream out_s = libtool::open_binary_output_file(
235  assignment_output_file.c_str());
236  libzeth::r1cs_variable_assignment_write_bytes(
237  prover.get_last_assignment(), out_s);
238  }
239 
240  std::cout << "[DEBUG] Preparing response..." << std::endl;
241  api_handler::extended_proof_to_proto(
242  ext_proof, proof_and_public_data->mutable_extended_proof());
243  for (size_t i = 0; i < public_data.size(); ++i) {
244  proof_and_public_data->add_public_data(
245  libzeth::base_field_element_to_hex(public_data[i]));
246  }
247 
248  } catch (const std::exception &e) {
249  std::cout << "[ERROR] " << e.what() << std::endl;
250  return grpc::Status(
251  grpc::StatusCode::INVALID_ARGUMENT, grpc::string(e.what()));
252  } catch (...) {
253  std::cout << "[ERROR] In catch all" << std::endl;
254  return grpc::Status(grpc::StatusCode::UNKNOWN, "");
255  }
256 
257  return grpc::Status::OK;
258  }
Here is the call graph for this function:
The documentation for this class was generated from the following file:
Field
libzeth::defaults::Field Field
Definition: prover_server.cpp:29
libzeth::extended_proof
Definition: extended_proof.hpp:17
Field
libzeth::defaults::Field Field
Definition: mpc_subcommand.hpp:11
libzeth::extended_proof::get_proof
const snarkT::proof & get_proof() const
libzeth::bits< 64 >
libtool::open_binary_output_file
std::ofstream open_binary_output_file(const std::string &filename)
Utility function to open a binary file for writing, with appropriate flags.
Definition: tool_util.cpp:19
libzeth::joinsplit_input_from_proto
joinsplit_input< FieldT, TreeDepth > joinsplit_input_from_proto(const zeth_proto::JoinsplitInput &input)
libzeth::r1cs_variable_assignment_write_bytes
void r1cs_variable_assignment_write_bytes(const libsnark::r1cs_variable_assignment< FieldT > &assignment, std::ostream &out_s)
libzeth::zeth_note_from_proto
zeth_note zeth_note_from_proto(const zeth_proto::ZethNote &note)
Definition: proto_utils.cpp:32
libzeth::extended_proof::get_primary_inputs
const libsnark::r1cs_primary_input< libff::Fr< ppT > > & get_primary_inputs() const
libzeth::extended_proof::write_json
std::ostream & write_json(std::ostream &) const
libzeth::circuit_wrapper::prove
extended_proof< ppT, snarkT > prove(const Field &root, const std::array< joinsplit_input< Field, TreeDepth >, NumInputs > &inputs, const std::array< zeth_note, NumOutputs > &outputs, const bits64 &vpub_in, const bits64 &vpub_out, const bits256 &h_sig_in, const bits256 &phi_in, const typename snarkT::proving_key &proving_key, std::vector< Field > &out_public_data) const
libzeth::circuit_wrapper::get_last_assignment
const std::vector< Field > & get_last_assignment() const
libzeth::zeth_note
Definition: note.hpp:15
libzeth::base_field_element_to_hex
std::string base_field_element_to_hex(const FieldT &field_el)
libzeth::bits< 64 >::from_hex
static bits from_hex(const std::string &hex)
Generated on Mon Nov 28 2022 10:29:03 for Zeth - Zerocash on Ethereum by   doxygen 1.8.17