Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
proof_structures.hpp
Go to the documentation of this file.
1// === AUDIT STATUS ===
2// internal: { status: not started, auditors: [], date: YYYY-MM-DD }
3// external_1: { status: not started, auditors: [], date: YYYY-MM-DD }
4// external_2: { status: not started, auditors: [], date: YYYY-MM-DD }
5// =====================
6
7#pragma once
8
9#include "barretenberg/flavor/mega_flavor.hpp"
10#include "barretenberg/flavor/mega_zk_flavor.hpp"
11#include "barretenberg/flavor/ultra_flavor.hpp"
12#include "barretenberg/flavor/ultra_keccak_flavor.hpp"
13#include "barretenberg/flavor/ultra_keccak_zk_flavor.hpp"
14#include "barretenberg/flavor/ultra_zk_flavor.hpp"
15#include "barretenberg/transcript/transcript.hpp"
16
17namespace bb {
18
26template <typename Flavor> struct StructuredProof;
27
28// ============================================================================
29// Common base with type definitions and helper methods
30// ============================================================================
31template <typename Flavor> struct StructuredProofHelper {
32 using FF = typename Flavor::FF;
33 using Commitment = typename Flavor::Commitment;
34 using Transcript = typename Flavor::Transcript;
35 using Codec = typename Transcript::Codec;
36 using ProofData = typename Transcript::Proof;
37 static constexpr size_t BATCHED_RELATION_PARTIAL_LENGTH = Flavor::BATCHED_RELATION_PARTIAL_LENGTH;
38 static constexpr size_t NUM_ALL_ENTITIES = Flavor::NUM_ALL_ENTITIES;
39
40 protected:
41 template <typename T> static T deserialize_from_buffer(const ProofData& proof_data, size_t& offset)
42 {
43 constexpr size_t element_size = Codec::template calc_num_fields<T>();
44 BB_ASSERT_LTE(offset + element_size, proof_data.size());
45 auto element_span = std::span{ proof_data }.subspan(offset, element_size);
46 offset += element_size;
47 return Codec::template deserialize_from_fields<T>(element_span);
48 }
49
50 template <typename T> static void serialize_to_buffer(const T& element, ProofData& proof_data)
51 {
52 auto element_fields = Codec::serialize_to_fields(element);
53 proof_data.insert(proof_data.end(), element_fields.begin(), element_fields.end());
54 }
55};
56
57// ============================================================================
58// Ultra proof structure base with common fields and helper methods
59// ============================================================================
60template <typename Flavor> struct UltraStructuredProofBase : StructuredProofHelper<Flavor> {
61 using Base = StructuredProofHelper<Flavor>;
62 using Base::BATCHED_RELATION_PARTIAL_LENGTH;
63 using Base::NUM_ALL_ENTITIES;
64 using typename Base::Commitment;
65 using typename Base::FF;
66 using typename Base::ProofData;
67
68 // Common fields shared between ZK and non-ZK
69 std::vector<FF> public_inputs;
70 Commitment w_l_comm;
71 Commitment w_r_comm;
72 Commitment w_o_comm;
73 Commitment lookup_read_counts_comm;
74 Commitment lookup_read_tags_comm;
75 Commitment w_4_comm;
76 Commitment z_perm_comm;
77 Commitment lookup_inverses_comm;
78 std::vector<bb::Univariate<FF, BATCHED_RELATION_PARTIAL_LENGTH>> sumcheck_univariates;
79 std::array<FF, NUM_ALL_ENTITIES> sumcheck_evaluations;
80 std::vector<Commitment> gemini_fold_comms;
81 std::vector<FF> gemini_fold_evals;
82 Commitment shplonk_q_comm;
83 Commitment kzg_w_comm;
84
85 protected:
86 void clear_vectors()
87 {
88 public_inputs.clear();
89 sumcheck_univariates.clear();
90 gemini_fold_comms.clear();
91 gemini_fold_evals.clear();
92 }
93
94 // Helper: deserialize Ultra witness commitments
95 void deserialize_ultra_witness_comms(const ProofData& proof_data, size_t& offset)
96 {
97 w_l_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
98 w_r_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
99 w_o_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
100 lookup_read_counts_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
101 lookup_read_tags_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
102 w_4_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
103 lookup_inverses_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
104 z_perm_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
105 }
106
107 // Helper: serialize Ultra witness commitments
119
120 // Helper: deserialize sumcheck data
121 void deserialize_sumcheck(const ProofData& proof_data, size_t& offset, size_t log_n)
122 {
123 for (size_t i = 0; i < log_n; ++i) {
124 sumcheck_univariates.push_back(
125 this->template deserialize_from_buffer<bb::Univariate<FF, BATCHED_RELATION_PARTIAL_LENGTH>>(proof_data,
126 offset));
127 }
128 sumcheck_evaluations =
129 this->template deserialize_from_buffer<std::array<FF, NUM_ALL_ENTITIES>>(proof_data, offset);
130 }
131
132 // Helper: serialize sumcheck data
133 void serialize_sumcheck(ProofData& proof_data, size_t log_n) const
134 {
135 for (size_t i = 0; i < log_n; ++i) {
136 Base::serialize_to_buffer(sumcheck_univariates[i], proof_data);
137 }
138 Base::serialize_to_buffer(sumcheck_evaluations, proof_data);
139 }
140
141 // Helper: deserialize Gemini/Shplonk/KZG data
142 void deserialize_pcs(const ProofData& proof_data, size_t& offset, size_t log_n)
143 {
144 for (size_t i = 0; i < log_n - 1; ++i) {
145 gemini_fold_comms.push_back(this->template deserialize_from_buffer<Commitment>(proof_data, offset));
146 }
147 for (size_t i = 0; i < log_n; ++i) {
148 gemini_fold_evals.push_back(this->template deserialize_from_buffer<FF>(proof_data, offset));
149 }
150 shplonk_q_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
151 kzg_w_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
152 }
153
154 // Helper: serialize Gemini/Shplonk/KZG data
155 void serialize_pcs(ProofData& proof_data, size_t log_n) const
156 {
157 for (size_t i = 0; i < log_n - 1; ++i) {
158 Base::serialize_to_buffer(gemini_fold_comms[i], proof_data);
159 }
160 for (size_t i = 0; i < log_n; ++i) {
161 Base::serialize_to_buffer(gemini_fold_evals[i], proof_data);
162 }
163 Base::serialize_to_buffer(shplonk_q_comm, proof_data);
164 Base::serialize_to_buffer(kzg_w_comm, proof_data);
165 }
166
167 public:
168 void deserialize(ProofData& proof_data, size_t num_public_inputs, size_t log_n)
169 {
170 size_t offset = 0;
171 clear_vectors();
172
173 for (size_t i = 0; i < num_public_inputs; ++i) {
174 public_inputs.push_back(this->template deserialize_from_buffer<FF>(proof_data, offset));
175 }
176 deserialize_ultra_witness_comms(proof_data, offset);
177 deserialize_sumcheck(proof_data, offset, log_n);
178 deserialize_pcs(proof_data, offset, log_n);
179 }
180
181 void serialize(ProofData& proof_data, size_t log_n) const
182 {
183 size_t old_size = proof_data.size();
184 proof_data.clear();
185
186 for (const auto& pi : public_inputs) {
187 Base::serialize_to_buffer(pi, proof_data);
188 }
189 serialize_ultra_witness_comms(proof_data);
190 serialize_sumcheck(proof_data, log_n);
191 serialize_pcs(proof_data, log_n);
192
193 BB_ASSERT_EQ(proof_data.size(), old_size);
194 }
195};
196
197// ============================================================================
198// Ultra ZK proof structure - extends Ultra with ZK-specific fields
199// ============================================================================
200template <typename Flavor> struct UltraZKStructuredProofBase : UltraStructuredProofBase<Flavor> {
201 using Base = UltraStructuredProofBase<Flavor>;
202 using typename Base::Commitment;
203 using typename Base::FF;
204 using typename Base::ProofData;
205
206 // ZK-specific fields
207 Commitment hiding_polynomial_commitment;
208 Commitment libra_concatenation_commitment;
209 FF libra_sum;
210 FF libra_claimed_evaluation;
211 Commitment libra_grand_sum_commitment;
212 Commitment libra_quotient_commitment;
213 FF libra_concatenation_eval;
214 FF libra_shifted_grand_sum_eval;
215 FF libra_grand_sum_eval;
216 FF libra_quotient_eval;
217
218 void deserialize(ProofData& proof_data, size_t num_public_inputs, size_t log_n)
219 {
220 size_t offset = 0;
221 this->clear_vectors();
222
223 for (size_t i = 0; i < num_public_inputs; ++i) {
224 this->public_inputs.push_back(this->template deserialize_from_buffer<FF>(proof_data, offset));
225 }
226 hiding_polynomial_commitment = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
227 this->deserialize_ultra_witness_comms(proof_data, offset);
228 libra_concatenation_commitment = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
229 libra_sum = this->template deserialize_from_buffer<FF>(proof_data, offset);
230
231 // Sumcheck univariates
232 for (size_t i = 0; i < log_n; ++i) {
233 this->sumcheck_univariates.push_back(
234 this->template deserialize_from_buffer<bb::Univariate<FF, Base::BATCHED_RELATION_PARTIAL_LENGTH>>(
235 proof_data, offset));
236 }
237 libra_claimed_evaluation = this->template deserialize_from_buffer<FF>(proof_data, offset);
238 this->sumcheck_evaluations =
239 this->template deserialize_from_buffer<std::array<FF, Base::NUM_ALL_ENTITIES>>(proof_data, offset);
240 libra_grand_sum_commitment = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
241 libra_quotient_commitment = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
242
243 // Gemini
244 for (size_t i = 0; i < log_n - 1; ++i) {
245 this->gemini_fold_comms.push_back(this->template deserialize_from_buffer<Commitment>(proof_data, offset));
246 }
247 for (size_t i = 0; i < log_n; ++i) {
248 this->gemini_fold_evals.push_back(this->template deserialize_from_buffer<FF>(proof_data, offset));
249 }
250 libra_concatenation_eval = this->template deserialize_from_buffer<FF>(proof_data, offset);
251 libra_shifted_grand_sum_eval = this->template deserialize_from_buffer<FF>(proof_data, offset);
252 libra_grand_sum_eval = this->template deserialize_from_buffer<FF>(proof_data, offset);
253 libra_quotient_eval = this->template deserialize_from_buffer<FF>(proof_data, offset);
254 this->shplonk_q_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
255 this->kzg_w_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
256 }
257
258 void serialize(ProofData& proof_data, size_t log_n) const
259 {
260 size_t old_size = proof_data.size();
261 proof_data.clear();
262
263 for (const auto& pi : this->public_inputs) {
264 Base::serialize_to_buffer(pi, proof_data);
265 }
266 Base::serialize_to_buffer(hiding_polynomial_commitment, proof_data);
267 this->serialize_ultra_witness_comms(proof_data);
268 Base::serialize_to_buffer(libra_concatenation_commitment, proof_data);
269 Base::serialize_to_buffer(libra_sum, proof_data);
270
271 // Sumcheck univariates
272 for (size_t i = 0; i < log_n; ++i) {
273 Base::serialize_to_buffer(this->sumcheck_univariates[i], proof_data);
274 }
275 Base::serialize_to_buffer(libra_claimed_evaluation, proof_data);
276 Base::serialize_to_buffer(this->sumcheck_evaluations, proof_data);
277 Base::serialize_to_buffer(libra_grand_sum_commitment, proof_data);
278 Base::serialize_to_buffer(libra_quotient_commitment, proof_data);
279
280 // Gemini
281 for (size_t i = 0; i < log_n - 1; ++i) {
282 Base::serialize_to_buffer(this->gemini_fold_comms[i], proof_data);
283 }
284 for (size_t i = 0; i < log_n; ++i) {
285 Base::serialize_to_buffer(this->gemini_fold_evals[i], proof_data);
286 }
287 Base::serialize_to_buffer(libra_concatenation_eval, proof_data);
288 Base::serialize_to_buffer(libra_shifted_grand_sum_eval, proof_data);
289 Base::serialize_to_buffer(libra_grand_sum_eval, proof_data);
290 Base::serialize_to_buffer(libra_quotient_eval, proof_data);
291 Base::serialize_to_buffer(this->shplonk_q_comm, proof_data);
292 Base::serialize_to_buffer(this->kzg_w_comm, proof_data);
293
294 BB_ASSERT_EQ(proof_data.size(), old_size);
295 }
296};
297
298// ============================================================================
299// Mega proof structure base with common fields and helper methods
300// ============================================================================
301template <typename Flavor> struct MegaStructuredProofBase : StructuredProofHelper<Flavor> {
302 using Base = StructuredProofHelper<Flavor>;
303 using Base::BATCHED_RELATION_PARTIAL_LENGTH;
304 using Base::NUM_ALL_ENTITIES;
305 using typename Base::Commitment;
306 using typename Base::FF;
307 using typename Base::ProofData;
308
309 // Common fields shared between ZK and non-ZK
310 std::vector<FF> public_inputs;
311 Commitment w_l_comm;
312 Commitment w_r_comm;
313 Commitment w_o_comm;
314 Commitment ecc_op_wire_1_comm;
315 Commitment ecc_op_wire_2_comm;
316 Commitment ecc_op_wire_3_comm;
317 Commitment ecc_op_wire_4_comm;
318 Commitment calldata_comm;
319 Commitment calldata_read_counts_comm;
320 Commitment calldata_read_tags_comm;
321 Commitment secondary_calldata_comm;
322 Commitment secondary_calldata_read_counts_comm;
323 Commitment secondary_calldata_read_tags_comm;
324 Commitment return_data_comm;
325 Commitment return_data_read_counts_comm;
326 Commitment return_data_read_tags_comm;
327 Commitment lookup_read_counts_comm;
328 Commitment lookup_read_tags_comm;
329 Commitment w_4_comm;
330 Commitment lookup_inverses_comm;
331 Commitment calldata_inverses_comm;
332 Commitment secondary_calldata_inverses_comm;
333 Commitment return_data_inverses_comm;
334 Commitment z_perm_comm;
335 std::vector<bb::Univariate<FF, BATCHED_RELATION_PARTIAL_LENGTH>> sumcheck_univariates;
336 std::array<FF, NUM_ALL_ENTITIES> sumcheck_evaluations;
337 std::vector<Commitment> gemini_fold_comms;
338 std::vector<FF> gemini_fold_evals;
339 Commitment shplonk_q_comm;
340 Commitment kzg_w_comm;
341
342 protected:
343 void clear_vectors()
344 {
345 public_inputs.clear();
346 sumcheck_univariates.clear();
347 gemini_fold_comms.clear();
348 gemini_fold_evals.clear();
349 }
350
351 // Helper: deserialize Mega witness commitments
352 void deserialize_mega_witness_comms(const ProofData& proof_data, size_t& offset)
353 {
354 w_l_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
355 w_r_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
356 w_o_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
357 ecc_op_wire_1_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
358 ecc_op_wire_2_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
359 ecc_op_wire_3_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
360 ecc_op_wire_4_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
361 calldata_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
362 calldata_read_counts_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
363 calldata_read_tags_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
364 secondary_calldata_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
365 secondary_calldata_read_counts_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
366 secondary_calldata_read_tags_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
367 return_data_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
368 return_data_read_counts_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
369 return_data_read_tags_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
370 lookup_read_counts_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
371 lookup_read_tags_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
372 w_4_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
373 lookup_inverses_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
374 calldata_inverses_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
375 secondary_calldata_inverses_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
376 return_data_inverses_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
377 z_perm_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
378 }
379
380 // Helper: serialize Mega witness commitments
381 void serialize_mega_witness_comms(ProofData& proof_data) const
382 {
383 Base::serialize_to_buffer(w_l_comm, proof_data);
384 Base::serialize_to_buffer(w_r_comm, proof_data);
385 Base::serialize_to_buffer(w_o_comm, proof_data);
386 Base::serialize_to_buffer(ecc_op_wire_1_comm, proof_data);
387 Base::serialize_to_buffer(ecc_op_wire_2_comm, proof_data);
388 Base::serialize_to_buffer(ecc_op_wire_3_comm, proof_data);
389 Base::serialize_to_buffer(ecc_op_wire_4_comm, proof_data);
390 Base::serialize_to_buffer(calldata_comm, proof_data);
391 Base::serialize_to_buffer(calldata_read_counts_comm, proof_data);
392 Base::serialize_to_buffer(calldata_read_tags_comm, proof_data);
393 Base::serialize_to_buffer(secondary_calldata_comm, proof_data);
394 Base::serialize_to_buffer(secondary_calldata_read_counts_comm, proof_data);
395 Base::serialize_to_buffer(secondary_calldata_read_tags_comm, proof_data);
396 Base::serialize_to_buffer(return_data_comm, proof_data);
397 Base::serialize_to_buffer(return_data_read_counts_comm, proof_data);
398 Base::serialize_to_buffer(return_data_read_tags_comm, proof_data);
399 Base::serialize_to_buffer(lookup_read_counts_comm, proof_data);
400 Base::serialize_to_buffer(lookup_read_tags_comm, proof_data);
401 Base::serialize_to_buffer(w_4_comm, proof_data);
402 Base::serialize_to_buffer(lookup_inverses_comm, proof_data);
403 Base::serialize_to_buffer(calldata_inverses_comm, proof_data);
404 Base::serialize_to_buffer(secondary_calldata_inverses_comm, proof_data);
405 Base::serialize_to_buffer(return_data_inverses_comm, proof_data);
406 Base::serialize_to_buffer(z_perm_comm, proof_data);
407 }
408
409 // Helper: deserialize sumcheck data
410 void deserialize_sumcheck(const ProofData& proof_data, size_t& offset, size_t log_n)
411 {
412 for (size_t i = 0; i < log_n; ++i) {
413 sumcheck_univariates.push_back(
414 this->template deserialize_from_buffer<bb::Univariate<FF, BATCHED_RELATION_PARTIAL_LENGTH>>(proof_data,
415 offset));
416 }
417 sumcheck_evaluations =
418 this->template deserialize_from_buffer<std::array<FF, NUM_ALL_ENTITIES>>(proof_data, offset);
419 }
420
421 // Helper: serialize sumcheck data
422 void serialize_sumcheck(ProofData& proof_data, size_t log_n) const
423 {
424 for (size_t i = 0; i < log_n; ++i) {
425 Base::serialize_to_buffer(sumcheck_univariates[i], proof_data);
426 }
427 Base::serialize_to_buffer(sumcheck_evaluations, proof_data);
428 }
429
430 // Helper: deserialize Gemini/Shplonk/KZG data
431 void deserialize_pcs(const ProofData& proof_data, size_t& offset, size_t log_n)
432 {
433 for (size_t i = 0; i < log_n - 1; ++i) {
434 gemini_fold_comms.push_back(this->template deserialize_from_buffer<Commitment>(proof_data, offset));
435 }
436 for (size_t i = 0; i < log_n; ++i) {
437 gemini_fold_evals.push_back(this->template deserialize_from_buffer<FF>(proof_data, offset));
438 }
439 shplonk_q_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
440 kzg_w_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
441 }
442
443 // Helper: serialize Gemini/Shplonk/KZG data
444 void serialize_pcs(ProofData& proof_data, size_t log_n) const
445 {
446 for (size_t i = 0; i < log_n - 1; ++i) {
447 Base::serialize_to_buffer(gemini_fold_comms[i], proof_data);
448 }
449 for (size_t i = 0; i < log_n; ++i) {
450 Base::serialize_to_buffer(gemini_fold_evals[i], proof_data);
451 }
452 Base::serialize_to_buffer(shplonk_q_comm, proof_data);
453 Base::serialize_to_buffer(kzg_w_comm, proof_data);
454 }
455
456 public:
457 void deserialize(ProofData& proof_data, size_t num_public_inputs, size_t log_n)
458 {
459 size_t offset = 0;
460 clear_vectors();
461
462 for (size_t i = 0; i < num_public_inputs; ++i) {
463 public_inputs.push_back(this->template deserialize_from_buffer<FF>(proof_data, offset));
464 }
465 deserialize_mega_witness_comms(proof_data, offset);
466 deserialize_sumcheck(proof_data, offset, log_n);
467 deserialize_pcs(proof_data, offset, log_n);
468 }
469
470 void serialize(ProofData& proof_data, size_t log_n) const
471 {
472 size_t old_size = proof_data.size();
473 proof_data.clear();
474
475 for (const auto& pi : public_inputs) {
476 Base::serialize_to_buffer(pi, proof_data);
477 }
478 serialize_mega_witness_comms(proof_data);
479 serialize_sumcheck(proof_data, log_n);
480 serialize_pcs(proof_data, log_n);
481
482 BB_ASSERT_EQ(proof_data.size(), old_size);
483 }
484};
485
486// ============================================================================
487// Mega ZK proof structure - extends Mega with ZK-specific fields
488// ============================================================================
489template <typename Flavor> struct MegaZKStructuredProofBase : MegaStructuredProofBase<Flavor> {
490 using Base = MegaStructuredProofBase<Flavor>;
491 using typename Base::Commitment;
492 using typename Base::FF;
493 using typename Base::ProofData;
494
495 // ZK-specific fields
496 Commitment hiding_polynomial_commitment;
497 Commitment libra_concatenation_commitment;
498 FF libra_sum;
499 FF libra_claimed_evaluation;
500 Commitment libra_grand_sum_commitment;
501 Commitment libra_quotient_commitment;
502 FF libra_concatenation_eval;
503 FF libra_shifted_grand_sum_eval;
504 FF libra_grand_sum_eval;
505 FF libra_quotient_eval;
506
507 void deserialize(ProofData& proof_data, size_t num_public_inputs, size_t log_n)
508 {
509 size_t offset = 0;
510 this->clear_vectors();
511
512 for (size_t i = 0; i < num_public_inputs; ++i) {
513 this->public_inputs.push_back(this->template deserialize_from_buffer<FF>(proof_data, offset));
514 }
515 hiding_polynomial_commitment = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
516 this->deserialize_mega_witness_comms(proof_data, offset);
517 libra_concatenation_commitment = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
518 libra_sum = this->template deserialize_from_buffer<FF>(proof_data, offset);
519
520 // Sumcheck univariates
521 for (size_t i = 0; i < log_n; ++i) {
522 this->sumcheck_univariates.push_back(
523 this->template deserialize_from_buffer<bb::Univariate<FF, Base::BATCHED_RELATION_PARTIAL_LENGTH>>(
524 proof_data, offset));
525 }
526 libra_claimed_evaluation = this->template deserialize_from_buffer<FF>(proof_data, offset);
527 this->sumcheck_evaluations =
528 this->template deserialize_from_buffer<std::array<FF, Base::NUM_ALL_ENTITIES>>(proof_data, offset);
529 libra_grand_sum_commitment = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
530 libra_quotient_commitment = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
531
532 // Gemini
533 for (size_t i = 0; i < log_n - 1; ++i) {
534 this->gemini_fold_comms.push_back(this->template deserialize_from_buffer<Commitment>(proof_data, offset));
535 }
536 for (size_t i = 0; i < log_n; ++i) {
537 this->gemini_fold_evals.push_back(this->template deserialize_from_buffer<FF>(proof_data, offset));
538 }
539 libra_concatenation_eval = this->template deserialize_from_buffer<FF>(proof_data, offset);
540 libra_shifted_grand_sum_eval = this->template deserialize_from_buffer<FF>(proof_data, offset);
541 libra_grand_sum_eval = this->template deserialize_from_buffer<FF>(proof_data, offset);
542 libra_quotient_eval = this->template deserialize_from_buffer<FF>(proof_data, offset);
543 this->shplonk_q_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
544 this->kzg_w_comm = this->template deserialize_from_buffer<Commitment>(proof_data, offset);
545 }
546
547 void serialize(ProofData& proof_data, size_t log_n) const
548 {
549 size_t old_size = proof_data.size();
550 proof_data.clear();
551
552 for (const auto& pi : this->public_inputs) {
553 Base::serialize_to_buffer(pi, proof_data);
554 }
555 Base::serialize_to_buffer(hiding_polynomial_commitment, proof_data);
556 this->serialize_mega_witness_comms(proof_data);
557 Base::serialize_to_buffer(libra_concatenation_commitment, proof_data);
558 Base::serialize_to_buffer(libra_sum, proof_data);
559
560 // Sumcheck univariates
561 for (size_t i = 0; i < log_n; ++i) {
562 Base::serialize_to_buffer(this->sumcheck_univariates[i], proof_data);
563 }
564 Base::serialize_to_buffer(libra_claimed_evaluation, proof_data);
565 Base::serialize_to_buffer(this->sumcheck_evaluations, proof_data);
566 Base::serialize_to_buffer(libra_grand_sum_commitment, proof_data);
567 Base::serialize_to_buffer(libra_quotient_commitment, proof_data);
568
569 // Gemini
570 for (size_t i = 0; i < log_n - 1; ++i) {
571 Base::serialize_to_buffer(this->gemini_fold_comms[i], proof_data);
572 }
573 for (size_t i = 0; i < log_n; ++i) {
574 Base::serialize_to_buffer(this->gemini_fold_evals[i], proof_data);
575 }
576 Base::serialize_to_buffer(libra_concatenation_eval, proof_data);
577 Base::serialize_to_buffer(libra_shifted_grand_sum_eval, proof_data);
578 Base::serialize_to_buffer(libra_grand_sum_eval, proof_data);
579 Base::serialize_to_buffer(libra_quotient_eval, proof_data);
580 Base::serialize_to_buffer(this->shplonk_q_comm, proof_data);
581 Base::serialize_to_buffer(this->kzg_w_comm, proof_data);
582
583 BB_ASSERT_EQ(proof_data.size(), old_size);
584 }
585};
586
587// ============================================================================
588// Flavor Specializations
589// ============================================================================
590
591// Ultra flavors (non-ZK)
592template <> struct StructuredProof<UltraFlavor> : UltraStructuredProofBase<UltraFlavor> {};
593template <> struct StructuredProof<UltraKeccakFlavor> : UltraStructuredProofBase<UltraKeccakFlavor> {};
594
595// Ultra ZK flavors
596template <> struct StructuredProof<UltraZKFlavor> : UltraZKStructuredProofBase<UltraZKFlavor> {};
597template <> struct StructuredProof<UltraKeccakZKFlavor> : UltraZKStructuredProofBase<UltraKeccakZKFlavor> {};
598
599// Mega flavors
600template <> struct StructuredProof<MegaFlavor> : MegaStructuredProofBase<MegaFlavor> {};
601template <> struct StructuredProof<MegaZKFlavor> : MegaZKStructuredProofBase<MegaZKFlavor> {};
602
603} // namespace bb
BB_ASSERT_EQ
#define BB_ASSERT_EQ(actual, expected,...)
Definition assert.hpp:83
BB_ASSERT_LTE
#define BB_ASSERT_LTE(left, right,...)
Definition assert.hpp:158
bb::BaseTranscript::Proof
std::vector< DataType > Proof
Definition transcript.hpp:46
bb::ECCVMFlavor::FF
typename Curve::ScalarField FF
Definition eccvm_flavor.hpp:42
bb::ECCVMFlavor::NUM_ALL_ENTITIES
static constexpr size_t NUM_ALL_ENTITIES
Definition eccvm_flavor.hpp:76
bb::ECCVMFlavor::Commitment
typename G1::affine_element Commitment
Definition eccvm_flavor.hpp:46
bb::ECCVMFlavor::BATCHED_RELATION_PARTIAL_LENGTH
static constexpr size_t BATCHED_RELATION_PARTIAL_LENGTH
Definition eccvm_flavor.hpp:118
bb::ECCVMFlavor::Transcript
BaseTranscript< Codec, HashFunction > Transcript
Definition eccvm_flavor.hpp:52
bb::Univariate
A univariate polynomial represented by its values on {0, 1,..., domain_end - 1}.
Definition univariate.hpp:32
offset
ssize_t offset
Definition engine.cpp:46
mega_flavor.hpp
mega_zk_flavor.hpp
bb
Entry point for Barretenberg command-line interface.
Definition api.hpp:5
std::get
constexpr decltype(auto) get(::tuplet::tuple< T... > &&t) noexcept
Definition tuple.hpp:13
bb::MegaStructuredProofBase::deserialize_mega_witness_comms
void deserialize_mega_witness_comms(const ProofData &proof_data, size_t &offset)
Definition proof_structures.hpp:352
bb::MegaStructuredProofBase::Commitment
typename Flavor::Commitment Commitment
Definition proof_structures.hpp:33
bb::MegaStructuredProofBase::deserialize_pcs
void deserialize_pcs(const ProofData &proof_data, size_t &offset, size_t log_n)
Definition proof_structures.hpp:431
bb::MegaStructuredProofBase::gemini_fold_comms
std::vector< Commitment > gemini_fold_comms
Definition proof_structures.hpp:337
bb::MegaStructuredProofBase::serialize
void serialize(ProofData &proof_data, size_t log_n) const
Definition proof_structures.hpp:470
bb::MegaStructuredProofBase::serialize_mega_witness_comms
void serialize_mega_witness_comms(ProofData &proof_data) const
Definition proof_structures.hpp:381
bb::MegaStructuredProofBase::serialize_sumcheck
void serialize_sumcheck(ProofData &proof_data, size_t log_n) const
Definition proof_structures.hpp:422
bb::MegaStructuredProofBase::serialize_pcs
void serialize_pcs(ProofData &proof_data, size_t log_n) const
Definition proof_structures.hpp:444
bb::MegaStructuredProofBase::sumcheck_evaluations
std::array< FF, NUM_ALL_ENTITIES > sumcheck_evaluations
Definition proof_structures.hpp:336
bb::MegaStructuredProofBase::deserialize
void deserialize(ProofData &proof_data, size_t num_public_inputs, size_t log_n)
Definition proof_structures.hpp:457
bb::MegaStructuredProofBase::deserialize_sumcheck
void deserialize_sumcheck(const ProofData &proof_data, size_t &offset, size_t log_n)
Definition proof_structures.hpp:410
bb::MegaStructuredProofBase::sumcheck_univariates
std::vector< bb::Univariate< FF, BATCHED_RELATION_PARTIAL_LENGTH > > sumcheck_univariates
Definition proof_structures.hpp:335
bb::MegaStructuredProofBase::ProofData
typename Transcript::Proof ProofData
Definition proof_structures.hpp:36
bb::MegaZKStructuredProofBase::deserialize
void deserialize(ProofData &proof_data, size_t num_public_inputs, size_t log_n)
Definition proof_structures.hpp:507
bb::MegaZKStructuredProofBase::Commitment
typename Flavor::Commitment Commitment
Definition proof_structures.hpp:33
bb::MegaZKStructuredProofBase::ProofData
typename Transcript::Proof ProofData
Definition proof_structures.hpp:36
bb::MegaZKStructuredProofBase::serialize
void serialize(ProofData &proof_data, size_t log_n) const
Definition proof_structures.hpp:547
bb::StructuredProofHelper::serialize_to_buffer
static void serialize_to_buffer(const T &element, ProofData &proof_data)
Definition proof_structures.hpp:50
bb::StructuredProofHelper::NUM_ALL_ENTITIES
static constexpr size_t NUM_ALL_ENTITIES
Definition proof_structures.hpp:38
bb::StructuredProofHelper::deserialize_from_buffer
static T deserialize_from_buffer(const ProofData &proof_data, size_t &offset)
Definition proof_structures.hpp:41
bb::StructuredProofHelper::Commitment
typename Flavor::Commitment Commitment
Definition proof_structures.hpp:33
bb::StructuredProofHelper::BATCHED_RELATION_PARTIAL_LENGTH
static constexpr size_t BATCHED_RELATION_PARTIAL_LENGTH
Definition proof_structures.hpp:37
bb::StructuredProofHelper::Codec
typename Transcript::Codec Codec
Definition proof_structures.hpp:35
bb::StructuredProofHelper::ProofData
typename Transcript::Proof ProofData
Definition proof_structures.hpp:36
bb::StructuredProofHelper::Transcript
typename Flavor::Transcript Transcript
Definition proof_structures.hpp:34
bb::StructuredProof
Test utility for deserializing/serializing proof data into typed structures.
Definition proof_structures.hpp:26
bb::UltraStructuredProofBase::serialize
void serialize(ProofData &proof_data, size_t log_n) const
Definition proof_structures.hpp:181
bb::UltraStructuredProofBase::gemini_fold_comms
std::vector< Commitment > gemini_fold_comms
Definition proof_structures.hpp:80
bb::UltraStructuredProofBase::deserialize_ultra_witness_comms
void deserialize_ultra_witness_comms(const ProofData &proof_data, size_t &offset)
Definition proof_structures.hpp:95
bb::UltraStructuredProofBase::sumcheck_evaluations
std::array< FF, NUM_ALL_ENTITIES > sumcheck_evaluations
Definition proof_structures.hpp:79
bb::UltraStructuredProofBase::Commitment
typename Flavor::Commitment Commitment
Definition proof_structures.hpp:33
bb::UltraStructuredProofBase::deserialize_sumcheck
void deserialize_sumcheck(const ProofData &proof_data, size_t &offset, size_t log_n)
Definition proof_structures.hpp:121
bb::UltraStructuredProofBase::serialize_ultra_witness_comms
void serialize_ultra_witness_comms(ProofData &proof_data) const
Definition proof_structures.hpp:108
bb::UltraStructuredProofBase::deserialize
void deserialize(ProofData &proof_data, size_t num_public_inputs, size_t log_n)
Definition proof_structures.hpp:168
bb::UltraStructuredProofBase::sumcheck_univariates
std::vector< bb::Univariate< FF, BATCHED_RELATION_PARTIAL_LENGTH > > sumcheck_univariates
Definition proof_structures.hpp:78
bb::UltraStructuredProofBase::serialize_pcs
void serialize_pcs(ProofData &proof_data, size_t log_n) const
Definition proof_structures.hpp:155
bb::UltraStructuredProofBase::deserialize_pcs
void deserialize_pcs(const ProofData &proof_data, size_t &offset, size_t log_n)
Definition proof_structures.hpp:142
bb::UltraStructuredProofBase::serialize_sumcheck
void serialize_sumcheck(ProofData &proof_data, size_t log_n) const
Definition proof_structures.hpp:133
bb::UltraStructuredProofBase::ProofData
typename Transcript::Proof ProofData
Definition proof_structures.hpp:36
bb::UltraZKStructuredProofBase::serialize
void serialize(ProofData &proof_data, size_t log_n) const
Definition proof_structures.hpp:258
bb::UltraZKStructuredProofBase::Commitment
typename Flavor::Commitment Commitment
Definition proof_structures.hpp:33
bb::UltraZKStructuredProofBase::deserialize
void deserialize(ProofData &proof_data, size_t num_public_inputs, size_t log_n)
Definition proof_structures.hpp:218
bb::UltraZKStructuredProofBase::ProofData
typename Transcript::Proof ProofData
Definition proof_structures.hpp:36
ultra_flavor.hpp
ultra_keccak_flavor.hpp
ultra_keccak_zk_flavor.hpp
ultra_zk_flavor.hpp