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