purify
C++ Purify implementation with native circuit and BPP support
Loading...
Searching...
No Matches
accumulation.cpp
Go to the documentation of this file.
1// Copyright (c) 2026 Judica, Inc.
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or https://opensource.org/license/mit/.
4
6
8#include "bppp_bridge.h"
9#include "bppp_internal.hpp"
10#include "sha256_transcript.hpp"
11#if defined(PURIFY_INTERNAL_TEST_SUPPORT)
13#endif
14
16
17namespace {
18
19const TaggedHash kBasisHash("Purify/BPPP/NormAccumBasisV2");
20const TaggedHash kClaimsHash("Purify/BPPP/AccumClaimsV1");
21const TaggedHash kBatchHash("Purify/BPPP/AccumBatchV1");
22const TaggedHash kEvaluationHash("Purify/BPPP/AccumEvaluationV1");
23const TaggedHash kOpeningBaseHash("Purify/BPPP/AccumOpeningBaseV1");
24const TaggedHash kOpeningHash("Purify/BPPP/AccumOpeningV1");
25const TaggedHash kRoundHash("Purify/BPPP/AccumRoundV1");
26const TaggedHash kNormBindingHash("Purify/BPPP/NormReduction/StatementV1");
27const TaggedHash kCircuitNormBindingHash(
28 "Purify/BPPP/CircuitNormReduction/StatementV3");
29const TaggedHash kNormOpeningBaseHash("Purify/BPPP/NormReduction/OpeningBaseV1");
30const TaggedHash kNormOpeningHash("Purify/BPPP/NormReduction/OpeningV1");
31const TaggedHash kNormFusionHash("Purify/BPPP/NormReduction/FusionV1");
32const TaggedHash kOpeningPairHash(
33 "Purify/BPPP/OpeningGeneratorPairV2");
34
35constexpr std::uint64_t kReductionOpeningRole = 1;
36constexpr std::uint64_t kAccumulationOpeningRole = 2;
37constexpr std::size_t kMaxAlgebraicClaims = 1024;
38constexpr std::size_t kMaxAlgebraicRounds = 24;
39constexpr std::string_view kAlgebraicStepDomain =
40 "Purify/BPPP/CandidateAccumStep/v1";
41constexpr std::string_view kAlgebraicBoundStepDomain =
42 "Purify/BPPP/CandidateBoundAccumStep/v1";
43constexpr std::string_view kAlgebraicNormDomain =
44 "Purify/BPPP/CandidateNormReduction/v2";
45
46void append_size(Bytes& out, std::size_t value) {
47 static_assert(sizeof(std::size_t) <= sizeof(std::uint64_t));
48 const auto wide = static_cast<std::uint64_t>(value);
49 for (unsigned int i = 0; i < 8; ++i) {
50 out.push_back(static_cast<unsigned char>((wide >> (8 * i)) & 0xffU));
51 }
52}
53
54void append(Bytes& out, std::span<const unsigned char> bytes) {
55 out.insert(out.end(), bytes.begin(), bytes.end());
56}
57
58Digest generator_digest(std::span<const PointBytes> generators) {
59 Digest out{};
60 const auto bytes = std::as_bytes(generators);
61 purify_sha256(out.data(),
62 reinterpret_cast<const unsigned char*>(bytes.data()),
63 bytes.size());
64 return out;
65}
66
67std::size_t log2_dimension(std::size_t size) {
68 assert(is_power_of_two_size(size));
69 return static_cast<std::size_t>(std::bit_width(size) - 1);
70}
71
72Status validate_algebraic_dimension(std::size_t dimension) {
73 if (!is_power_of_two_size(dimension) ||
74 log2_dimension(dimension) > kMaxAlgebraicRounds) {
75 return unexpected_error(
77 "accumulation:algebraic_dimension");
78 }
79 return {};
80}
81
82FieldElement pow_size(FieldElement base, std::size_t exponent) {
83 auto out = FieldElement::one();
84 while (exponent != 0) {
85 if ((exponent & 1U) != 0) out = out * base;
86 base = base * base;
87 exponent >>= 1;
88 }
89 return out;
90}
91
92Result<FieldElement> challenge(const TaggedHash& hash, std::span<const unsigned char> seed) {
93 Bytes input(seed.begin(), seed.end());
94 for (std::size_t counter = 0; counter < 256; ++counter) {
95 input.resize(seed.size());
96 append_size(input, counter);
97 auto candidate = FieldElement::try_from_bytes32(hash.digest(input));
98 if (candidate.has_value() && !candidate->is_zero()) return candidate;
99 }
100 return unexpected_error(ErrorCode::InternalMismatch, "accumulation:challenge_exhausted");
101}
102
103Status validate_basis(const Basis& basis) {
104 std::size_t dimension = 0;
105 std::size_t generators = 0;
106 if (!is_power_of_two_size(basis.n_vec_len()) ||
107 !is_power_of_two_size(basis.l_vec_len()) ||
108 basis.l_vec_len() > basis.n_vec_len() ||
109 !checked_mul_size(basis.n_vec_len(), 2, dimension) ||
110 !checked_add_size(basis.n_vec_len(), basis.l_vec_len(), generators) ||
111 basis.dimension() != dimension || basis.norm_generators().size() != generators) {
112 return unexpected_error(ErrorCode::InvalidDimensions, "accumulation:basis_shape");
113 }
114 return {};
115}
116
117Status validate_prepared(const Basis& basis, const PreparedNorm& norm) {
118 if (norm.basis_digest() != basis.digest()) {
119 return unexpected_error(ErrorCode::BindingMismatch, "accumulation:prepared_basis");
120 }
121 const auto& g = norm.polynomial()[0];
122 const auto& h = norm.polynomial()[1];
123 if (norm.c_vec().size() != basis.l_vec_len() || g.offset != 0 || h.offset != basis.n_vec_len() ||
124 g.factors.size() != log2_dimension(basis.n_vec_len()) ||
125 h.factors.size() != log2_dimension(basis.l_vec_len())) {
126 return unexpected_error(ErrorCode::InvalidDimensions, "accumulation:prepared_shape");
127 }
128 return {};
129}
130
131Status validate_algebraic_prepared(
132 const Basis& basis, const AlgebraicPreparedNorm& norm) {
134 validate_algebraic_dimension(basis.dimension()),
135 "accumulation:algebraic_prepared_dimension");
136 if (norm.basis_digest() != basis.digest()) {
137 return unexpected_error(
139 "accumulation:algebraic_prepared_basis");
140 }
141 if (norm.prepared_binding().is_zero()) {
142 return unexpected_error(
144 "accumulation:algebraic_prepared_binding_zero");
145 }
146 const auto& g = norm.polynomial()[0];
147 const auto& h = norm.polynomial()[1];
148 if (norm.c_vec().size() != basis.l_vec_len() ||
149 g.offset != 0 || h.offset != basis.n_vec_len() ||
150 g.factors.size() != log2_dimension(basis.n_vec_len()) ||
151 h.factors.size() != log2_dimension(basis.l_vec_len())) {
152 return unexpected_error(
154 "accumulation:algebraic_prepared_shape");
155 }
156 return {};
157}
158
159void append_polynomial(Bytes& encoded, std::span<const PolynomialTerm> polynomial) {
160 append_size(encoded, polynomial.size());
161 for (const auto& term : polynomial) {
162 append(encoded, term.scale.to_bytes_be());
163 append_size(encoded, term.offset);
164 append_size(encoded, term.factors.size());
165 for (const auto& factor : term.factors) append(encoded, factor.to_bytes_be());
166 }
167}
168
169Status append_algebraic_point(
170 candidate::Sha256Transcript& transcript, const PointBytes& point) {
171 if (purify_bppp_public_point_validate(point.data()) == 0) {
172 return unexpected_error(
174 "accumulation:algebraic_point");
175 }
177 std::copy(point.begin() + 1, point.end(), x.begin());
178 return transcript.append_point(point[0], x);
179}
180
181Status append_algebraic_polynomial(
182 candidate::Sha256Transcript& transcript,
183 std::span<const PolynomialTerm> polynomial) {
184 if (!size_fits_u64(polynomial.size())) {
185 return unexpected_error(
187 "accumulation:algebraic_polynomial_size");
188 }
189 transcript.append_u64(static_cast<std::uint64_t>(polynomial.size()));
190 for (const auto& term : polynomial) {
191 if (!size_fits_u64(term.offset) ||
192 !size_fits_u64(term.factors.size())) {
193 return unexpected_error(
195 "accumulation:algebraic_term_size");
196 }
197 transcript.append_scalar(term.scale);
198 transcript.append_u64(static_cast<std::uint64_t>(term.offset));
199 transcript.append_u64(
200 static_cast<std::uint64_t>(term.factors.size()));
201 for (const auto& factor : term.factors) {
202 transcript.append_scalar(factor);
203 }
204 }
205 return {};
206}
207
208Status validate_claim(const Basis& basis, const PendingClaim& claim) {
209 if (claim.basis_digest() != basis.digest()) {
210 return unexpected_error(ErrorCode::BindingMismatch, "accumulation:claim_basis");
211 }
212 // A reduced norm has three coupled terms; an accumulated IPA has one.
213 if (claim.polynomial().empty() || claim.polynomial().size() > 3) {
214 return unexpected_error(ErrorCode::InvalidDimensions, "accumulation:polynomial_shape");
215 }
216 for (const auto& term : claim.polynomial()) {
217 if (term.factors.size() >= std::numeric_limits<std::size_t>::digits) {
218 return unexpected_error(ErrorCode::Overflow, "accumulation:polynomial_degree");
219 }
220 const std::size_t width = std::size_t{1} << term.factors.size();
221 if (width > basis.dimension() || term.offset > basis.dimension() - width) {
222 return unexpected_error(ErrorCode::InvalidDimensions, "accumulation:polynomial_degree");
223 }
224 }
225 return {};
226}
227
228FieldElement evaluate(std::span<const PolynomialTerm> polynomial, const FieldElement& x) {
229 auto sum = FieldElement::zero();
230 for (const auto& term : polynomial) {
231 auto value = term.scale * pow_size(x, term.offset);
232 auto x_power = x;
233 for (const auto& factor : term.factors) {
234 value = value * (FieldElement::one() + factor * x_power);
235 x_power = x_power * x_power;
236 }
237 sum = sum + value;
238 }
239 return sum;
240}
241
242void add_coefficients(std::vector<FieldElement>& out, std::span<const PolynomialTerm> polynomial,
243 const FieldElement& weight) {
244 for (const auto& term : polynomial) {
245 std::vector<FieldElement> coefficients{weight * term.scale};
246 for (const auto& factor : term.factors) {
247 const auto size = coefficients.size();
248 coefficients.resize(2 * size);
249 for (std::size_t i = 0; i < size; ++i) {
250 coefficients[size + i] = coefficients[i] * factor;
251 }
252 }
253 for (std::size_t i = 0; i < coefficients.size(); ++i) {
254 out[term.offset + i] = out[term.offset + i] + coefficients[i];
255 }
256 }
257}
258
259Result<PointBytes> msm(std::span<const PointBytes> points, std::span<const FieldElement> scalars,
260 purify_secp_context* context) {
261 if (points.size() != scalars.size()) {
262 return unexpected_error(ErrorCode::SizeMismatch, "accumulation:msm_shape");
263 }
264 std::vector<ScalarBytes> encoded;
265 encoded.reserve(scalars.size());
266 for (const auto& scalar : scalars) encoded.push_back(scalar.to_bytes_be());
267 PointBytes out{};
268 if (purify_bppp_public_msm(context,
269 reinterpret_cast<const unsigned char*>(points.data()),
270 reinterpret_cast<const unsigned char*>(encoded.data()), points.size(), out.data()) == 0) {
271 return unexpected_error(ErrorCode::BackendRejectedInput, "accumulation:public_msm");
272 }
273 return out;
274}
275
276Result<FieldElement> append_algebraic_challenge(
277 candidate::Sha256Transcript& transcript, std::uint64_t round) {
279 auto challenge, transcript.challenge(round),
280 "accumulation:algebraic_challenge");
281 return std::move(challenge.scalar);
282}
283
284Result<PointBytes> derive_algebraic_opening_base(
285 const Basis& basis, const candidate::Sha256Transcript& transcript,
286 std::uint64_t role, purify_secp_context* context) {
287 if (role != kReductionOpeningRole &&
288 role != kAccumulationOpeningRole) {
289 return unexpected_error(
291 "accumulation:opening_role");
292 }
294 auto challenge,
295 transcript.opening_base_scalar(basis.digest(), role),
296 "accumulation:opening_scalar");
297
298 std::array<PointBytes, 2> pair{};
299 for (std::size_t index = 0; index < pair.size(); ++index) {
300 Bytes message;
301 message.reserve(basis.digest().size() + 9);
302 append(message, basis.digest());
303 append_size(message, static_cast<std::size_t>(role));
304 message.push_back(static_cast<unsigned char>(index));
305 const auto seed = kOpeningPairHash.digest(message);
307 context, seed.data(), seed.size(),
308 pair[index].data()) == 0 ||
309 pair[index] == PointBytes{}) {
310 return unexpected_error(
312 "accumulation:opening_pair");
313 }
314 }
315 if (pair[0] == pair[1]) {
316 return unexpected_error(
318 "accumulation:opening_pair_duplicate");
319 }
320 const std::array<FieldElement, 2> scalars{
321 FieldElement::one(), challenge.scalar};
323 auto opening_base, msm(pair, scalars, context),
324 "accumulation:opening_pair_msm");
325 if (opening_base == PointBytes{}) {
326 return unexpected_error(
328 "accumulation:opening_pair_identity");
329 }
330 return opening_base;
331}
332
333Status validate_root_claim(const Basis& basis, const PendingClaim& claim,
334 purify_secp_context* context) {
336 require_secp_context(context, "accumulation:root_claim_context"),
337 "accumulation:root_claim_context");
338 PURIFY_RETURN_IF_ERROR(validate_claim(basis, claim),
339 "accumulation:root_claim");
340 if (claim.polynomial().size() != 1 ||
341 claim.polynomial()[0].offset != 0 ||
342 claim.polynomial()[0].factors.size() !=
343 log2_dimension(basis.dimension())) {
345 "accumulation:root_claim_shape");
346 }
347 const std::array<PointBytes, 1> points{claim.point()};
348 const std::array<FieldElement, 1> scalars{FieldElement::zero()};
350 const auto& identity, msm(points, scalars, context),
351 "accumulation:root_claim_point");
352 (void)identity;
353 return {};
354}
355
356template <typename Proof>
357Status validate_ipa_encoding(std::size_t dimension, const Proof& proof,
358 purify_secp_context* context) {
359 PURIFY_RETURN_IF_ERROR(require_secp_context(context, "accumulation:context"),
360 "accumulation:context");
361 if (!is_power_of_two_size(dimension)) {
362 return unexpected_error(ErrorCode::InvalidDimensions, "accumulation:ipa_encoding_dimension");
363 }
364 const auto rounds = log2_dimension(dimension);
365 if (proof.left.size() != rounds || proof.right.size() != rounds) {
366 return unexpected_error(ErrorCode::SizeMismatch, "accumulation:step_encoding_rounds");
367 }
368 PURIFY_ASSIGN_OR_RETURN(auto terminal, FieldElement::try_from_bytes32(proof.terminal_scalar),
369 "accumulation:step_encoding_scalar");
370 (void)terminal;
371 const auto is_canonical_point = [](const PointBytes& point) {
372 return purify_bppp_public_point_validate(point.data()) != 0;
373 };
374 for (std::size_t round = 0; round < rounds; ++round) {
375 if (!is_canonical_point(proof.left[round]) ||
376 !is_canonical_point(proof.right[round])) {
377 return unexpected_error(
379 "accumulation:step_encoding_points");
380 }
381 }
382 if (!is_canonical_point(proof.folded_generator)) {
383 return unexpected_error(
385 "accumulation:step_encoding_points");
386 }
387 return {};
388}
389
390template <typename Proof>
391void append_ipa(Bytes& out, const Proof& proof) {
392 for (std::size_t round = 0; round < proof.left.size(); ++round) {
393 append(out, proof.left[round]);
394 append(out, proof.right[round]);
395 }
396 append(out, proof.terminal_scalar);
397 append(out, proof.folded_generator);
398}
399
400template <typename Proof>
401Result<Proof> parse_ipa(std::size_t dimension,
402 std::span<const unsigned char> encoded,
403 purify_secp_context* context) {
404 const auto rounds = log2_dimension(dimension);
405 if (encoded.size() != 66 * rounds + 65) {
406 return unexpected_error(ErrorCode::InvalidFixedSize, "accumulation:parse_ipa_size");
407 }
408 Proof proof;
409 proof.left.resize(rounds);
410 proof.right.resize(rounds);
411 std::size_t offset = 0;
412 for (std::size_t round = 0; round < rounds; ++round) {
413 std::copy_n(encoded.data() + offset, 33, proof.left[round].begin());
414 offset += 33;
415 std::copy_n(encoded.data() + offset, 33, proof.right[round].begin());
416 offset += 33;
417 }
418 std::copy_n(encoded.data() + offset, 32, proof.terminal_scalar.begin());
419 offset += 32;
420 std::copy_n(encoded.data() + offset, 33, proof.folded_generator.begin());
421 PURIFY_RETURN_IF_ERROR(validate_ipa_encoding(dimension, proof, context), "accumulation:parse_ipa");
422 return proof;
423}
424
425struct StepContext {
426 FieldElement beta;
427 FieldElement x;
428 FieldElement y;
429 PointBytes commitment;
430 PointBytes opening_base;
431 Digest transcript;
432};
433
434Result<StepContext> make_step_context(const Basis& basis, std::span<const PendingClaim> claims,
435 purify_secp_context* context) {
436 PURIFY_RETURN_IF_ERROR(require_secp_context(context, "accumulation:context"),
437 "accumulation:context");
438 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
439 if (claims.empty()) {
440 return unexpected_error(ErrorCode::EmptyInput, "accumulation:claims");
441 }
442 Bytes encoded;
443 append(encoded, basis.digest());
444 append_size(encoded, claims.size());
445 for (const auto& claim : claims) {
446 PURIFY_RETURN_IF_ERROR(validate_claim(basis, claim), "accumulation:claim");
447 append(encoded, claim.point());
448 append_polynomial(encoded, claim.polynomial());
449 }
450 const auto claims_digest = kClaimsHash.digest(encoded);
451 StepContext out;
452 PURIFY_ASSIGN_OR_RETURN(out.beta, challenge(kBatchHash, claims_digest),
453 "accumulation:batch_challenge");
454 std::vector<PointBytes> commitments;
455 std::vector<FieldElement> weights;
456 commitments.reserve(claims.size());
457 weights.reserve(claims.size());
458 auto weight = FieldElement::one();
459 for (const auto& claim : claims) {
460 commitments.push_back(claim.point());
461 weights.push_back(weight);
462 weight = weight * out.beta;
463 }
464 PURIFY_ASSIGN_OR_RETURN(out.commitment, msm(commitments, weights, context),
465 "accumulation:batch_commitment");
466 encoded.clear();
467 append(encoded, claims_digest);
468 append(encoded, out.beta.to_bytes_be());
469 append(encoded, out.commitment);
470 PURIFY_ASSIGN_OR_RETURN(out.x, challenge(kEvaluationHash, encoded),
471 "accumulation:evaluation_challenge");
472 out.y = FieldElement::zero();
473 for (std::size_t i = 0; i < claims.size(); ++i) {
474 out.y = out.y + weights[i] * evaluate(claims[i].polynomial(), out.x);
475 }
476 append(encoded, out.x.to_bytes_be());
477 append(encoded, out.y.to_bytes_be());
478 // This independent generator is chosen AFTER the claimed evaluation is
479 // fixed. Hash-to-scalar times the standard generator is not a substitute.
480 const auto opening_seed = kOpeningBaseHash.digest(encoded);
481 if (purify_bppp_public_hash_to_point(context, opening_seed.data(), opening_seed.size(),
482 out.opening_base.data()) == 0) {
483 return unexpected_error(ErrorCode::BackendRejectedInput, "accumulation:opening_base");
484 }
485 append(encoded, out.opening_base);
486 out.transcript = kOpeningHash.digest(encoded);
487 return out;
488}
489
490struct AlgebraicStepContext {
491 FieldElement beta;
492 FieldElement x;
493 FieldElement y;
494 PointBytes commitment;
495 PointBytes opening_base;
496 candidate::Sha256Transcript transcript;
497};
498
499Result<AlgebraicStepContext> make_algebraic_step_context(
500 const Basis& basis, std::span<const PendingClaim> claims,
501 const Digest* statement_digest, purify_secp_context* context) {
503 require_secp_context(context, "accumulation:context"),
504 "accumulation:context");
506 validate_basis(basis), "accumulation:basis");
507 if (claims.empty()) {
508 return unexpected_error(
509 ErrorCode::EmptyInput, "accumulation:claims");
510 }
511 const auto rounds = log2_dimension(basis.dimension());
512 if (claims.size() > kMaxAlgebraicClaims) {
513 return unexpected_error(
515 "accumulation:algebraic_step_shape");
516 }
518 validate_algebraic_dimension(basis.dimension()),
519 "accumulation:algebraic_step_shape");
520 AlgebraicStepContext out;
521 const auto domain_name = statement_digest == nullptr
522 ? kAlgebraicStepDomain
523 : kAlgebraicBoundStepDomain;
524 const auto domain = std::span(
525 reinterpret_cast<const unsigned char*>(
526 domain_name.data()),
527 domain_name.size());
529 out.transcript.append_bytes(domain),
530 "accumulation:algebraic_step_domain");
531 if (statement_digest != nullptr) {
533 out.transcript.append_bytes(*statement_digest),
534 "accumulation:algebraic_step_statement");
535 }
537 out.transcript.append_bytes(basis.digest()),
538 "accumulation:algebraic_step_basis");
539 out.transcript.append_u64(
540 static_cast<std::uint64_t>(rounds));
541 out.transcript.append_u64(
542 static_cast<std::uint64_t>(claims.size()));
543 for (const auto& claim : claims) {
545 validate_claim(basis, claim), "accumulation:claim");
547 append_algebraic_point(out.transcript, claim.point()),
548 "accumulation:algebraic_claim_point");
550 append_algebraic_polynomial(
551 out.transcript, claim.polynomial()),
552 "accumulation:algebraic_claim_polynomial");
553 }
554
556 out.beta, append_algebraic_challenge(out.transcript, 0),
557 "accumulation:algebraic_batch_challenge");
558 std::vector<PointBytes> commitments;
559 std::vector<FieldElement> weights;
560 commitments.reserve(claims.size());
561 weights.reserve(claims.size());
562 auto weight = FieldElement::one();
563 for (const auto& claim : claims) {
564 commitments.push_back(claim.point());
565 weights.push_back(weight);
566 weight = weight * out.beta;
567 }
569 out.commitment, msm(commitments, weights, context),
570 "accumulation:algebraic_batch_commitment");
572 append_algebraic_point(out.transcript, out.commitment),
573 "accumulation:algebraic_commitment");
574
576 out.x, append_algebraic_challenge(out.transcript, 1),
577 "accumulation:algebraic_evaluation_challenge");
578 out.y = FieldElement::zero();
579 for (std::size_t i = 0; i < claims.size(); ++i) {
580 out.y = out.y +
581 weights[i] * evaluate(claims[i].polynomial(), out.x);
582 }
583 out.transcript.append_scalar(out.y);
584
586 out.opening_base,
587 derive_algebraic_opening_base(
588 basis, out.transcript, kAccumulationOpeningRole,
589 context),
590 "accumulation:algebraic_opening_base");
592 append_algebraic_point(out.transcript, out.opening_base),
593 "accumulation:algebraic_opening_point");
594 return out;
595}
596
597Result<FieldElement> round_challenge(Digest& transcript, std::size_t round,
598 const PointBytes& left, const PointBytes& right) {
599 Bytes encoded;
600 append(encoded, transcript);
601 append_size(encoded, round);
602 append(encoded, left);
603 append(encoded, right);
604 PURIFY_ASSIGN_OR_RETURN(auto t, challenge(kRoundHash, encoded), "accumulation:round_challenge");
605 append(encoded, t.to_bytes_be());
606 transcript = kRoundHash.digest(encoded);
607 return t;
608}
609
610PolynomialTerm geometric_tensor(const FieldElement& x, std::size_t dimension) {
611 PolynomialTerm out{FieldElement::one(), 0, {}};
612 auto power = x;
613 for (std::size_t i = 0; i < log2_dimension(dimension); ++i) {
614 out.factors.push_back(power);
615 power = power * power;
616 }
617 return out;
618}
619
620FieldElement tensor_inner_product(const PolynomialTerm& lhs, const PolynomialTerm& rhs) {
621 assert(lhs.offset == 0 && rhs.offset == 0 && lhs.factors.size() == rhs.factors.size());
622 auto out = lhs.scale * rhs.scale;
623 for (std::size_t i = 0; i < lhs.factors.size(); ++i) {
624 out = out * (FieldElement::one() + lhs.factors[i] * rhs.factors[i]);
625 }
626 return out;
627}
628
629template <typename Proof, typename RoundChallenge>
630Result<Proof> prove_ipa_with_challenges(
631 std::span<const PointBytes> basis, std::vector<FieldElement> a,
632 const PolynomialTerm& weights, const PointBytes& opening_base,
633 RoundChallenge&& round_challenge, purify_secp_context* context) {
634 assert(a.size() == basis.size() && is_power_of_two_size(a.size()));
635 assert(weights.offset == 0 && weights.factors.size() == log2_dimension(a.size()));
636 std::vector<FieldElement> b(a.size(), FieldElement::zero());
637 const std::array<PolynomialTerm, 1> tensor{weights};
638 add_coefficients(b, tensor, FieldElement::one());
639 std::vector<PointBytes> generators(basis.begin(), basis.end());
640 Proof proof;
641 const auto rounds = log2_dimension(a.size());
642 proof.left.reserve(rounds);
643 proof.right.reserve(rounds);
644 for (std::size_t round = 0; round < rounds; ++round) {
645 const auto half = a.size() / 2;
646 std::vector<PointBytes> left_points, right_points;
647 std::vector<FieldElement> left_scalars, right_scalars;
648 left_points.reserve(half + 1);
649 right_points.reserve(half + 1);
650 left_scalars.reserve(half + 1);
651 right_scalars.reserve(half + 1);
652 auto left_inner = FieldElement::zero();
653 auto right_inner = FieldElement::zero();
654 for (std::size_t i = 0; i < half; ++i) {
655 left_points.push_back(generators[half + i]);
656 left_scalars.push_back(a[i]);
657 right_points.push_back(generators[i]);
658 right_scalars.push_back(a[half + i]);
659 left_inner = left_inner + a[i] * b[half + i];
660 right_inner = right_inner + a[half + i] * b[i];
661 }
662 left_points.push_back(opening_base);
663 right_points.push_back(opening_base);
664 left_scalars.push_back(left_inner);
665 right_scalars.push_back(right_inner);
666 PURIFY_ASSIGN_OR_RETURN(auto left, msm(left_points, left_scalars, context),
667 "accumulation:prove_left");
668 PURIFY_ASSIGN_OR_RETURN(auto right, msm(right_points, right_scalars, context),
669 "accumulation:prove_right");
670 proof.left.push_back(left);
671 proof.right.push_back(right);
673 round_challenge(round, left, right),
674 "accumulation:prove_round");
675 const auto t_inv = t.inverse();
676 for (std::size_t i = 0; i < half; ++i) {
677 a[i] = t * a[i] + t_inv * a[half + i];
678 b[i] = t_inv * b[i] + t * b[half + i];
679 const std::array<PointBytes, 2> pair{generators[i], generators[half + i]};
680 const std::array<FieldElement, 2> fold_weights{t_inv, t};
681 PURIFY_ASSIGN_OR_RETURN(generators[i], msm(pair, fold_weights, context),
682 "accumulation:prove_fold_basis");
683 }
684 a.resize(half);
685 b.resize(half);
686 generators.resize(half);
687 }
688 proof.terminal_scalar = a[0].to_bytes_be();
689 proof.folded_generator = generators[0];
690 return proof;
691}
692
693Result<StepProof> prove_ipa(
694 std::span<const PointBytes> basis, std::vector<FieldElement> a,
695 const PolynomialTerm& weights, const PointBytes& opening_base,
696 Digest transcript, purify_secp_context* context) {
697 return prove_ipa_with_challenges<StepProof>(
698 basis, std::move(a), weights, opening_base,
699 [&transcript](std::size_t round, const PointBytes& left,
700 const PointBytes& right) {
701 return round_challenge(transcript, round, left, right);
702 },
703 context);
704}
705
706struct IpaVerification {
707 PolynomialTerm folded;
708 PointBytes residual;
709};
710
711template <typename Proof, typename RoundChallenge>
712Result<IpaVerification> evaluate_ipa_with_challenges(
713 std::size_t dimension, const Proof& proof,
714 const PolynomialTerm& weights, const PointBytes& commitment,
715 const FieldElement& evaluation, const PointBytes& opening_base,
716 RoundChallenge&& round_challenge, purify_secp_context* context) {
717 assert(is_power_of_two_size(dimension));
718 assert(weights.offset == 0 && weights.factors.size() == log2_dimension(dimension));
719 const auto rounds = log2_dimension(dimension);
720 if (proof.left.size() != rounds || proof.right.size() != rounds) {
721 return unexpected_error(ErrorCode::SizeMismatch, "accumulation:step_proof_rounds");
722 }
723 PURIFY_ASSIGN_OR_RETURN(auto a, FieldElement::try_from_bytes32(proof.terminal_scalar),
724 "accumulation:step_terminal_scalar");
725 PolynomialTerm folded{FieldElement::one(), 0, {}};
726 folded.factors.resize(rounds);
727 std::vector<PointBytes> points{commitment};
728 std::vector<FieldElement> scalars{FieldElement::one()};
729 for (std::size_t round = 0; round < rounds; ++round) {
731 round_challenge(round, proof.left[round],
732 proof.right[round]),
733 "accumulation:verify_round");
734 const auto t_inv = t.inverse();
735 const auto t_squared = t * t;
736 folded.scale = folded.scale * t_inv;
737 // Half-splitting uses the most significant index bit first.
738 folded.factors[rounds - 1 - round] = t_squared;
739 points.push_back(proof.left[round]);
740 scalars.push_back(t_squared);
741 points.push_back(proof.right[round]);
742 scalars.push_back(t_inv * t_inv);
743 }
744 const auto b_final = tensor_inner_product(weights, folded);
745 points.push_back(opening_base);
746 scalars.push_back(evaluation - a * b_final);
747 points.push_back(proof.folded_generator);
748 scalars.push_back(a.negate());
749 PURIFY_ASSIGN_OR_RETURN(auto residual, msm(points, scalars, context),
750 "accumulation:verify_equation");
751 return IpaVerification{std::move(folded), residual};
752}
753
754template <typename Proof, typename RoundChallenge>
755Result<PolynomialTerm> verify_ipa_with_challenges(
756 std::size_t dimension, const Proof& proof,
757 const PolynomialTerm& weights, const PointBytes& commitment,
758 const FieldElement& evaluation, const PointBytes& opening_base,
759 RoundChallenge&& round_challenge, purify_secp_context* context) {
761 auto verified,
762 evaluate_ipa_with_challenges(
763 dimension, proof, weights, commitment, evaluation,
764 opening_base, std::forward<RoundChallenge>(round_challenge),
765 context),
766 "accumulation:evaluate_ipa");
767 if (verified.residual != PointBytes{}) {
768 return unexpected_error(
769 ErrorCode::EquationMismatch, "accumulation:step_equation");
770 }
771 return std::move(verified.folded);
772}
773
774Result<PolynomialTerm> verify_ipa(
775 std::size_t dimension, const StepProof& proof,
776 const PolynomialTerm& weights, const PointBytes& commitment,
777 const FieldElement& evaluation, const PointBytes& opening_base,
778 Digest transcript, purify_secp_context* context) {
779 return verify_ipa_with_challenges(
780 dimension, proof, weights, commitment, evaluation, opening_base,
781 [&transcript](std::size_t round, const PointBytes& left,
782 const PointBytes& right) {
783 return round_challenge(transcript, round, left, right);
784 },
785 context);
786}
787
788Result<AlgebraicStepProof> prove_algebraic_ipa(
789 std::span<const PointBytes> basis, std::vector<FieldElement> a,
790 const PolynomialTerm& weights, const PointBytes& opening_base,
791 candidate::Sha256Transcript& transcript,
792 std::uint64_t first_round, purify_secp_context* context) {
793 return prove_ipa_with_challenges<AlgebraicStepProof>(
794 basis, std::move(a), weights, opening_base,
795 [&transcript, first_round](
796 std::size_t round, const PointBytes& left,
797 const PointBytes& right) -> Result<FieldElement> {
799 append_algebraic_point(transcript, left),
800 "accumulation:algebraic_left");
802 append_algebraic_point(transcript, right),
803 "accumulation:algebraic_right");
804 return append_algebraic_challenge(
805 transcript,
806 first_round + static_cast<std::uint64_t>(round));
807 },
808 context);
809}
810
811Result<IpaVerification> evaluate_algebraic_ipa(
812 std::size_t dimension, const AlgebraicStepProof& proof,
813 const PolynomialTerm& weights, const PointBytes& commitment,
814 const FieldElement& evaluation, const PointBytes& opening_base,
815 candidate::Sha256Transcript& transcript,
816 std::uint64_t first_round, purify_secp_context* context) {
817 return evaluate_ipa_with_challenges(
818 dimension, proof, weights, commitment, evaluation, opening_base,
819 [&transcript, first_round](
820 std::size_t round, const PointBytes& left,
821 const PointBytes& right) -> Result<FieldElement> {
823 append_algebraic_point(transcript, left),
824 "accumulation:algebraic_left");
826 append_algebraic_point(transcript, right),
827 "accumulation:algebraic_right");
828 return append_algebraic_challenge(
829 transcript,
830 first_round + static_cast<std::uint64_t>(round));
831 },
832 context);
833}
834
835Result<PolynomialTerm> verify_algebraic_ipa(
836 std::size_t dimension, const AlgebraicStepProof& proof,
837 const PolynomialTerm& weights, const PointBytes& commitment,
838 const FieldElement& evaluation, const PointBytes& opening_base,
839 candidate::Sha256Transcript& transcript,
840 std::uint64_t first_round, purify_secp_context* context) {
842 auto verified,
843 evaluate_algebraic_ipa(
844 dimension, proof, weights, commitment, evaluation,
845 opening_base, transcript, first_round, context),
846 "accumulation:evaluate_algebraic_ipa");
847 if (verified.residual != PointBytes{}) {
848 return unexpected_error(
849 ErrorCode::EquationMismatch, "accumulation:step_equation");
850 }
851 return std::move(verified.folded);
852}
853
854struct NormOpeningContext {
855 FieldElement evaluation;
856 PolynomialTerm weights;
857 PointBytes opening_base;
858 Digest transcript;
859};
860
861Result<NormOpeningContext> make_norm_context(const Basis& basis, const PreparedNorm& norm,
862 const ScalarBytes& evaluation,
863 purify_secp_context* context) {
864 PURIFY_RETURN_IF_ERROR(require_secp_context(context, "accumulation:context"), "accumulation:context");
865 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
866 PURIFY_RETURN_IF_ERROR(validate_prepared(basis, norm), "accumulation:prepared");
867 NormOpeningContext out;
869 "accumulation:coefficient_evaluation");
870 out.weights = PolynomialTerm{FieldElement::one(), 0, norm.polynomial()[1].factors};
871 Bytes encoded;
872 append(encoded, basis.digest());
873 append(encoded, norm.transcript_digest());
874 append(encoded, norm.coefficient_commitment());
875 const std::array<PolynomialTerm, 1> weights{out.weights};
876 append_polynomial(encoded, weights);
877 append(encoded, evaluation);
878 // C_c and the claimed tensor evaluation are fixed before choosing U.
879 const auto seed = kNormOpeningBaseHash.digest(encoded);
880 if (purify_bppp_public_hash_to_point(context, seed.data(), seed.size(), out.opening_base.data()) == 0) {
881 return unexpected_error(ErrorCode::BackendRejectedInput, "accumulation:coefficient_opening_base");
882 }
883 append(encoded, out.opening_base);
884 out.transcript = kNormOpeningHash.digest(encoded);
885 return out;
886}
887
888struct AlgebraicNormOpeningContext {
889 FieldElement evaluation;
890 PolynomialTerm weights;
891 PointBytes opening_base;
892 candidate::Sha256Transcript transcript;
893};
894
895Result<AlgebraicNormOpeningContext> make_algebraic_norm_context(
896 const Basis& basis, const AlgebraicPreparedNorm& norm,
897 const ScalarBytes& evaluation, purify_secp_context* context) {
899 require_secp_context(context, "accumulation:context"),
900 "accumulation:context");
902 validate_basis(basis), "accumulation:basis");
904 validate_algebraic_prepared(basis, norm),
905 "accumulation:algebraic_prepared");
906
907 AlgebraicNormOpeningContext out;
908 const auto rounds = log2_dimension(basis.l_vec_len());
910 validate_algebraic_dimension(basis.l_vec_len()),
911 "accumulation:algebraic_norm_shape");
913 out.evaluation,
915 "accumulation:coefficient_evaluation");
916 out.weights = PolynomialTerm{
918 norm.polynomial()[1].factors};
919
920 const auto domain = std::span(
921 reinterpret_cast<const unsigned char*>(
922 kAlgebraicNormDomain.data()),
923 kAlgebraicNormDomain.size());
925 out.transcript.append_bytes(domain),
926 "accumulation:algebraic_norm_domain");
928 out.transcript.append_bytes(basis.digest()),
929 "accumulation:algebraic_norm_basis");
930 out.transcript.append_u64(
931 static_cast<std::uint64_t>(rounds));
932 out.transcript.append_scalar(norm.prepared_binding());
934 append_algebraic_point(
935 out.transcript, norm.coefficient_commitment()),
936 "accumulation:algebraic_norm_commitment");
937 const std::array<PolynomialTerm, 1> weights{out.weights};
939 append_algebraic_polynomial(out.transcript, weights),
940 "accumulation:algebraic_norm_weights");
941 out.transcript.append_scalar(out.evaluation);
942
944 out.opening_base,
945 derive_algebraic_opening_base(
946 basis, out.transcript, kReductionOpeningRole,
947 context),
948 "accumulation:algebraic_norm_opening_base");
950 append_algebraic_point(out.transcript, out.opening_base),
951 "accumulation:algebraic_norm_opening_point");
952 return out;
953}
954
955struct CircuitPreparedNorm {
956 Digest transcript_digest{};
957 std::vector<ScalarBytes> c_vec;
958 PointBytes coefficient_commitment{};
959 PointBytes residual{};
960 std::array<PolynomialTerm, 2> polynomial;
961};
962
963Result<CircuitPreparedNorm> prepare_circuit_norm_components(
964 const Basis& basis,
965 const detail::PreparedExperimentalCircuitZkNormArg& prepared,
966 const ExperimentalCircuitZkNormArgProof& proof,
967 std::span<const PointBytes> public_commitments,
968 purify_secp_context* context,
969 std::span<const unsigned char> statement_binding) {
970 const auto& norm = prepared.norm;
971 if (norm.n_vec_len != basis.n_vec_len() ||
972 norm.c_vec.size() != basis.l_vec_len() ||
973 norm.generators.size() !=
974 basis.n_vec_len() + basis.l_vec_len() ||
975 prepared.raw_generator_digest !=
976 generator_digest(basis.norm_generators())) {
978 "accumulation:circuit_raw_basis");
979 }
980
981 const auto rounds = log2_dimension(basis.n_vec_len());
982 std::vector<ScalarBytes> gammas(rounds);
983 ScalarBytes n_bytes{}, l_bytes{};
984 PointBytes residual{};
986 context, norm.rho.data(),
987 reinterpret_cast<const unsigned char*>(norm.generators.data()),
988 norm.generators.size(),
989 reinterpret_cast<const unsigned char*>(norm.c_vec.data()),
990 norm.c_vec.size(), norm.n_vec_len, norm.commitment.data(),
991 norm.proof.data(), norm.proof.size(), n_bytes.data(),
992 l_bytes.data(),
993 reinterpret_cast<unsigned char*>(gammas.data()), gammas.size(),
994 residual.data()) == 0) {
996 "accumulation:circuit_inner_norm");
997 }
998
1000 const auto& n, FieldElement::try_from_bytes32(n_bytes),
1001 "accumulation:circuit_norm_n");
1003 const auto& l, FieldElement::try_from_bytes32(l_bytes),
1004 "accumulation:circuit_norm_l");
1006 const auto& rho, FieldElement::try_from_bytes32(norm.rho),
1007 "accumulation:circuit_norm_rho");
1009 const auto& sqrt_minus_one,
1011 "accumulation:circuit_sqrt_minus_one");
1012
1014 n * pow_size(rho, basis.n_vec_len()) *
1015 prepared.mul_scale.inverse(),
1016 0,
1017 {}};
1018 PolynomialTerm h{l, basis.n_vec_len(), {}};
1019 const auto h_rounds = log2_dimension(basis.l_vec_len());
1020 auto ratio_inv_power = prepared.mul_ratio.inverse();
1021 for (std::size_t j = 0; j < rounds; ++j) {
1023 const auto& gamma, FieldElement::try_from_bytes32(gammas[j]),
1024 "accumulation:circuit_norm_gamma");
1025 if (j == 0) {
1026 g.factors.push_back(gamma * sqrt_minus_one.inverse());
1027 } else {
1028 g.factors.push_back(gamma * ratio_inv_power);
1029 ratio_inv_power = ratio_inv_power * ratio_inv_power;
1030 }
1031 if (j < h_rounds) h.factors.push_back(gamma);
1032 }
1033
1034 std::vector<FieldElement> coefficients;
1035 coefficients.reserve(norm.c_vec.size());
1036 for (const auto& encoded : norm.c_vec) {
1038 const auto& coefficient,
1040 "accumulation:circuit_norm_coefficient");
1041 coefficients.push_back(coefficient);
1042 }
1043 const auto h_basis = std::span(basis.points())
1044 .subspan(basis.n_vec_len(),
1045 basis.l_vec_len());
1047 auto coefficient_commitment,
1048 msm(h_basis, coefficients, context),
1049 "accumulation:circuit_coefficient_commitment");
1050
1051 Bytes encoded;
1052 append(encoded, basis.digest());
1053 append(encoded, prepared.raw_generator_digest);
1054 append(encoded, prepared.challenge_digest);
1055 append(encoded, norm.rho);
1056 append(encoded, prepared.mul_scale.to_bytes_be());
1057 append(encoded, prepared.mul_ratio.to_bytes_be());
1058 append_size(encoded, statement_binding.size());
1059 append(encoded, statement_binding);
1060 append_size(encoded, public_commitments.size());
1061 for (const auto& point : public_commitments) append(encoded, point);
1062 append(encoded, proof.a_commitment);
1063 append(encoded, proof.s_commitment);
1064 append(encoded, proof.t2);
1065 append(encoded, proof.public_commitment_dlog_nonce);
1066 append(encoded, proof.public_commitment_dlog_response);
1067 append(encoded, norm.commitment);
1068 for (const auto& coefficient : norm.c_vec) append(encoded, coefficient);
1069 append(encoded, coefficient_commitment);
1070 append_size(encoded, norm.proof.size());
1071 append(encoded, norm.proof);
1072
1073 return CircuitPreparedNorm{
1074 kCircuitNormBindingHash.digest(encoded), norm.c_vec,
1075 coefficient_commitment, residual,
1076 {std::move(g), std::move(h)}};
1077}
1078
1079} // namespace
1080
1082 std::string_view semantic_domain, purify_secp_context* context) {
1083 PURIFY_RETURN_IF_ERROR(require_secp_context(context, "accumulation:context"),
1084 "accumulation:context");
1085 std::size_t dimension = 0;
1088 return unexpected_error(ErrorCode::InvalidDimensions, "accumulation:create_basis_shape");
1089 }
1090 if (semantic_domain.empty()) {
1091 return unexpected_error(ErrorCode::EmptyInput, "accumulation:basis_semantic_domain");
1092 }
1093 Basis out;
1094 out.n_vec_len_ = n_vec_len;
1095 out.l_vec_len_ = l_vec_len;
1096 PURIFY_ASSIGN_OR_RETURN(auto generators, create_generators(dimension, context),
1097 "accumulation:deterministic_generators");
1098 out.points_.resize(dimension);
1100 reinterpret_cast<const unsigned char*>(generators.data()), generators.size(),
1101 reinterpret_cast<unsigned char*>(out.points_.data())) == 0) {
1102 return unexpected_error(ErrorCode::BackendRejectedInput, "accumulation:raw_basis");
1103 }
1104 generators.resize(n_vec_len + l_vec_len);
1105 out.norm_generators_ = std::move(generators);
1106 Bytes encoded;
1107 append_size(encoded, semantic_domain.size());
1108 append(encoded, std::span(reinterpret_cast<const unsigned char*>(semantic_domain.data()),
1109 semantic_domain.size()));
1110 append_size(encoded, n_vec_len);
1111 append_size(encoded, l_vec_len);
1112 for (const auto& point : out.points_) append(encoded, point);
1113 out.digest_ = kBasisHash.digest(encoded);
1114 return out;
1115}
1116
1117Result<Bytes> serialize_step(const Basis& basis, const StepProof& proof,
1118 purify_secp_context* context) {
1119 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
1120 PURIFY_RETURN_IF_ERROR(validate_ipa_encoding(basis.dimension(), proof, context),
1121 "accumulation:serialize_step");
1122 Bytes out;
1123 out.reserve(66 * log2_dimension(basis.dimension()) + 66);
1124 out.push_back(1);
1125 append_ipa(out, proof);
1126 return out;
1127}
1128
1129Result<StepProof> parse_step(const Basis& basis, std::span<const unsigned char> encoded,
1130 purify_secp_context* context) {
1131 PURIFY_RETURN_IF_ERROR(require_secp_context(context, "accumulation:context"), "accumulation:context");
1132 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
1133 if (encoded.size() != 66 * log2_dimension(basis.dimension()) + 66) {
1134 return unexpected_error(ErrorCode::InvalidFixedSize, "accumulation:parse_step_size");
1135 }
1136 if (encoded[0] != 1) {
1137 return unexpected_error(ErrorCode::UnsupportedSymbol, "accumulation:parse_step_version");
1138 }
1139 return parse_ipa<StepProof>(
1140 basis.dimension(), encoded.subspan(1), context);
1141}
1142
1144 const Basis& basis, const AlgebraicStepProof& proof,
1145 purify_secp_context* context) {
1147 validate_basis(basis), "accumulation:basis");
1149 validate_algebraic_dimension(basis.dimension()),
1150 "accumulation:algebraic_step_dimension");
1152 validate_ipa_encoding(
1153 basis.dimension(), proof, context),
1154 "accumulation:serialize_algebraic_step");
1155 Bytes out;
1156 out.reserve(
1157 66 * log2_dimension(basis.dimension()) + 66);
1158 out.push_back(2);
1159 append_ipa(out, proof);
1160 return out;
1161}
1162
1164 const Basis& basis, std::span<const unsigned char> encoded,
1165 purify_secp_context* context) {
1167 require_secp_context(context, "accumulation:context"),
1168 "accumulation:context");
1170 validate_basis(basis), "accumulation:basis");
1172 validate_algebraic_dimension(basis.dimension()),
1173 "accumulation:algebraic_step_dimension");
1174 if (encoded.size() !=
1175 66 * log2_dimension(basis.dimension()) + 66) {
1176 return unexpected_error(
1178 "accumulation:parse_algebraic_step_size");
1179 }
1180 if (encoded[0] != 2) {
1181 return unexpected_error(
1183 "accumulation:parse_algebraic_step_version");
1184 }
1185 return parse_ipa<AlgebraicStepProof>(
1186 basis.dimension(), encoded.subspan(1), context);
1187}
1188
1190 const PendingClaim& claim,
1191 purify_secp_context* context) {
1192 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
1194 validate_root_claim(basis, claim, context),
1195 "accumulation:serialize_root_claim");
1196 const auto& polynomial = claim.polynomial()[0];
1197 Bytes out;
1198 out.reserve(65 + 32 * polynomial.factors.size());
1199 append(out, claim.point());
1200 append(out, polynomial.scale.to_bytes_be());
1201 for (const auto& factor : polynomial.factors) {
1202 append(out, factor.to_bytes_be());
1203 }
1204 return out;
1205}
1206
1208 const Basis& basis, std::span<const unsigned char> encoded,
1209 purify_secp_context* context) {
1210 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
1211 const auto factor_count = log2_dimension(basis.dimension());
1212 if (encoded.size() != 65 + 32 * factor_count) {
1214 "accumulation:parse_root_claim_size");
1215 }
1216
1217 PointBytes point{};
1218 std::copy_n(encoded.begin(), point.size(), point.begin());
1219 ScalarBytes scalar{};
1220 std::copy_n(encoded.begin() + static_cast<std::ptrdiff_t>(point.size()),
1221 scalar.size(), scalar.begin());
1223 auto scale, FieldElement::try_from_bytes32(scalar),
1224 "accumulation:parse_root_claim_scale");
1225 std::vector<FieldElement> factors;
1226 factors.reserve(factor_count);
1227 std::size_t offset = point.size() + scalar.size();
1228 for (std::size_t i = 0; i < factor_count; ++i) {
1229 std::copy_n(encoded.begin() + static_cast<std::ptrdiff_t>(offset),
1230 scalar.size(), scalar.begin());
1231 offset += scalar.size();
1233 auto factor, FieldElement::try_from_bytes32(scalar),
1234 "accumulation:parse_root_claim_factor");
1235 factors.push_back(factor);
1236 }
1237 PendingClaim out(basis.digest(), point,
1238 {PolynomialTerm{scale, 0, std::move(factors)}});
1240 validate_root_claim(basis, out, context),
1241 "accumulation:parse_root_claim");
1242 return out;
1243}
1244
1246 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
1248 validate_algebraic_dimension(basis.dimension()),
1249 "accumulation:zero_claim_dimension");
1250 return PendingClaim(
1251 basis.digest(), PointBytes{},
1252 {PolynomialTerm{
1253 FieldElement::zero(), 0,
1254 std::vector<FieldElement>(
1255 log2_dimension(basis.dimension()),
1256 FieldElement::zero())}});
1257}
1258
1260 purify_secp_context* context) {
1261 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
1263 "accumulation:serialize_reduction_evaluation");
1264 (void)evaluation;
1265 PURIFY_RETURN_IF_ERROR(validate_ipa_encoding(basis.l_vec_len(), proof.coefficient_opening, context),
1266 "accumulation:serialize_reduction");
1267 Bytes out;
1268 out.reserve(66 * log2_dimension(basis.l_vec_len()) + 98);
1269 out.push_back(1);
1270 append(out, proof.coefficient_evaluation);
1271 append_ipa(out, proof.coefficient_opening);
1272 return out;
1273}
1274
1275Result<NormReductionProof> parse_norm_reduction(const Basis& basis, std::span<const unsigned char> encoded,
1276 purify_secp_context* context) {
1277 PURIFY_RETURN_IF_ERROR(require_secp_context(context, "accumulation:context"), "accumulation:context");
1278 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
1279 if (encoded.size() != 66 * log2_dimension(basis.l_vec_len()) + 98) {
1280 return unexpected_error(ErrorCode::InvalidFixedSize, "accumulation:parse_reduction_size");
1281 }
1282 if (encoded[0] != 1) {
1283 return unexpected_error(ErrorCode::UnsupportedSymbol, "accumulation:parse_reduction_version");
1284 }
1285 NormReductionProof proof;
1286 std::copy_n(encoded.data() + 1, 32, proof.coefficient_evaluation.begin());
1288 "accumulation:parse_reduction_evaluation");
1289 (void)evaluation;
1291 parse_ipa<StepProof>(basis.l_vec_len(), encoded.subspan(33),
1292 context),
1293 "accumulation:parse_reduction_ipa");
1294 return proof;
1295}
1296
1298 const Basis& basis,
1299 const AlgebraicNormReductionProof& proof,
1300 purify_secp_context* context) {
1302 validate_basis(basis), "accumulation:basis");
1304 validate_algebraic_dimension(basis.dimension()),
1305 "accumulation:algebraic_reduction_dimension");
1307 validate_algebraic_dimension(basis.l_vec_len()),
1308 "accumulation:algebraic_reduction_dimension");
1310 auto evaluation,
1313 "accumulation:serialize_algebraic_evaluation");
1314 (void)evaluation;
1316 validate_ipa_encoding(
1317 basis.l_vec_len(), proof.coefficient_opening,
1318 context),
1319 "accumulation:serialize_algebraic_reduction");
1320 Bytes out;
1321 out.reserve(
1322 66 * log2_dimension(basis.l_vec_len()) + 98);
1323 out.push_back(2);
1324 append(out, proof.coefficient_evaluation);
1325 append_ipa(out, proof.coefficient_opening);
1326 return out;
1327}
1328
1331 const Basis& basis, std::span<const unsigned char> encoded,
1332 purify_secp_context* context) {
1334 require_secp_context(context, "accumulation:context"),
1335 "accumulation:context");
1337 validate_basis(basis), "accumulation:basis");
1339 validate_algebraic_dimension(basis.dimension()),
1340 "accumulation:algebraic_reduction_dimension");
1342 validate_algebraic_dimension(basis.l_vec_len()),
1343 "accumulation:algebraic_reduction_dimension");
1344 if (encoded.size() !=
1345 66 * log2_dimension(basis.l_vec_len()) + 98) {
1346 return unexpected_error(
1348 "accumulation:parse_algebraic_reduction_size");
1349 }
1350 if (encoded[0] != 2) {
1351 return unexpected_error(
1353 "accumulation:parse_algebraic_reduction_version");
1354 }
1356 std::copy_n(
1357 encoded.data() + 1, 32,
1358 proof.coefficient_evaluation.begin());
1360 auto evaluation,
1363 "accumulation:parse_algebraic_evaluation");
1364 (void)evaluation;
1366 proof.coefficient_opening,
1367 parse_ipa<AlgebraicStepProof>(
1368 basis.l_vec_len(), encoded.subspan(33), context),
1369 "accumulation:parse_algebraic_reduction_ipa");
1370 return proof;
1371}
1372
1374 purify_secp_context* context) {
1375 PURIFY_RETURN_IF_ERROR(require_secp_context(context, "accumulation:context"),
1376 "accumulation:context");
1377 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
1378 if (proof.n_vec_len != basis.n_vec_len() || proof.c_vec.size() != basis.l_vec_len() ||
1379 proof.generators != basis.norm_generators()) {
1380 return unexpected_error(ErrorCode::BindingMismatch, "accumulation:norm_basis");
1381 }
1382 const auto rounds = log2_dimension(basis.n_vec_len());
1383 std::vector<ScalarBytes> gammas(rounds);
1384 ScalarBytes n_bytes{}, l_bytes{};
1386 if (purify_bppp_prepare_norm_arg_claim(context, proof.rho.data(),
1387 reinterpret_cast<const unsigned char*>(proof.generators.data()), proof.generators.size(),
1388 reinterpret_cast<const unsigned char*>(proof.c_vec.data()), proof.c_vec.size(),
1389 proof.n_vec_len, proof.commitment.data(), proof.proof.data(), proof.proof.size(),
1390 n_bytes.data(), l_bytes.data(), reinterpret_cast<unsigned char*>(gammas.data()),
1391 gammas.size(), residual.data()) == 0) {
1392 return unexpected_error(ErrorCode::BackendRejectedInput, "accumulation:prepare_norm");
1393 }
1394 PURIFY_ASSIGN_OR_RETURN(auto n, FieldElement::try_from_bytes32(n_bytes), "accumulation:norm_n");
1395 PURIFY_ASSIGN_OR_RETURN(auto l, FieldElement::try_from_bytes32(l_bytes), "accumulation:norm_l");
1396 PURIFY_ASSIGN_OR_RETURN(auto rho, FieldElement::try_from_bytes32(proof.rho), "accumulation:norm_rho");
1397 PolynomialTerm g{n * pow_size(rho, basis.n_vec_len() - 1), 0, {}};
1398 PolynomialTerm h{l, basis.n_vec_len(), {}};
1399 auto rho_inv_power = rho.inverse();
1400 const auto h_rounds = log2_dimension(basis.l_vec_len());
1401 for (std::size_t j = 0; j < rounds; ++j) {
1403 "accumulation:norm_gamma");
1404 g.factors.push_back(gamma * rho_inv_power);
1405 if (j < h_rounds) h.factors.push_back(gamma);
1406 rho_inv_power = rho_inv_power * rho_inv_power;
1407 }
1408 std::vector<FieldElement> coefficients;
1409 coefficients.reserve(proof.c_vec.size());
1410 for (const auto& encoded : proof.c_vec) {
1412 "accumulation:norm_coefficient");
1413 coefficients.push_back(coefficient);
1414 }
1415 const auto h_basis = std::span(basis.points()).subspan(basis.n_vec_len(), basis.l_vec_len());
1416 PURIFY_ASSIGN_OR_RETURN(auto commitment, msm(h_basis, coefficients, context),
1417 "accumulation:coefficient_commitment");
1418 Bytes encoded;
1419 append(encoded, basis.digest());
1420 append(encoded, proof.rho);
1421 append(encoded, proof.commitment);
1422 for (const auto& coefficient : proof.c_vec) append(encoded, coefficient);
1423 append(encoded, commitment);
1424 append_size(encoded, proof.proof.size());
1425 append(encoded, proof.proof);
1426 return PreparedNorm(basis.digest(), kNormBindingHash.digest(encoded), proof.c_vec,
1427 commitment, residual, {std::move(g), std::move(h)});
1428}
1429
1432 const Basis& basis, const NativeBulletproofCircuit& circuit,
1434 purify_secp_context* context,
1435 std::span<const unsigned char> statement_binding,
1438 require_secp_context(context, "accumulation:circuit_context"),
1439 "accumulation:circuit_context");
1440 PURIFY_RETURN_IF_ERROR(validate_basis(basis),
1441 "accumulation:circuit_basis");
1443 auto prepared,
1445 circuit, proof, context, statement_binding, cache),
1446 "accumulation:circuit_prepare");
1447 if (!prepared.has_value()) {
1449 "accumulation:circuit_zero_dlog");
1450 }
1452 auto components,
1453 prepare_circuit_norm_components(
1454 basis, *prepared, proof, {}, context, statement_binding),
1455 "accumulation:circuit_components");
1456 return PreparedNorm(
1457 basis.digest(), components.transcript_digest,
1458 std::move(components.c_vec), components.coefficient_commitment,
1459 components.residual, std::move(components.polynomial));
1460}
1461
1464 const Basis& basis, const NativeBulletproofCircuit& circuit,
1466 std::span<const PointBytes> public_commitments,
1467 purify_secp_context* context,
1468 std::span<const unsigned char> statement_binding,
1471 require_secp_context(context, "accumulation:circuit_context"),
1472 "accumulation:circuit_context");
1473 PURIFY_RETURN_IF_ERROR(validate_basis(basis),
1474 "accumulation:circuit_basis");
1476 auto prepared,
1478 circuit, proof, public_commitments, context, statement_binding,
1479 cache),
1480 "accumulation:circuit_prepare");
1481 if (!prepared.has_value()) {
1483 "accumulation:circuit_public_dlog");
1484 }
1486 auto components,
1487 prepare_circuit_norm_components(
1488 basis, *prepared, proof, public_commitments, context,
1489 statement_binding),
1490 "accumulation:circuit_components");
1491 return PreparedNorm(
1492 basis.digest(), components.transcript_digest,
1493 std::move(components.c_vec), components.coefficient_commitment,
1494 components.residual, std::move(components.polynomial));
1495}
1496
1499 const Basis& basis, candidate::PreparedCircuitZkNormArgV4 prepared,
1500 purify_secp_context* context) {
1502 require_secp_context(context, "accumulation:v4_context"),
1503 "accumulation:v4_context");
1505 validate_basis(basis), "accumulation:v4_basis");
1507 validate_algebraic_dimension(basis.dimension()),
1508 "accumulation:v4_dimension");
1509
1510 const auto& shape = prepared.shape();
1511 const auto& transcript_input = prepared.transcript_input();
1512 const auto& transcript = prepared.transcript();
1513 const auto& norm = prepared.norm();
1514 const auto rounds = shape.round_count();
1515 std::size_t generator_count = 0;
1516 if (!checked_add_size(shape.n_vec_len(), shape.l_vec_len(),
1517 generator_count)) {
1518 return unexpected_error(
1520 "accumulation:v4_generator_count");
1521 }
1522 // The V4 transcript binds this raw digest. Exact generator equality
1523 // bridges it to the purpose owner's selected semantic basis.
1524 if (shape.n_vec_len() != basis.n_vec_len() ||
1525 shape.l_vec_len() != basis.l_vec_len() ||
1526 prepared.raw_generators().size() != generator_count ||
1527 prepared.raw_generators() != basis.norm_generators()) {
1528 return unexpected_error(
1530 "accumulation:v4_raw_basis");
1531 }
1532 const auto raw_generator_digest =
1533 generator_digest(prepared.raw_generators());
1534 if (transcript_input.raw_generator_digest != raw_generator_digest ||
1535 generator_digest(basis.norm_generators()) != raw_generator_digest) {
1536 return unexpected_error(
1538 "accumulation:v4_raw_basis_digest");
1539 }
1540 if (norm.n_vec_len != shape.n_vec_len() ||
1541 norm.generators.size() != generator_count ||
1542 norm.c_vec.size() != shape.l_vec_len() ||
1543 norm.rho != transcript.rho.scalar.to_bytes_be() ||
1544 norm.commitment != transcript_input.combined_commitment ||
1545 transcript_input.rounds.size() != rounds ||
1546 transcript.gammas.size() != rounds) {
1547 return unexpected_error(
1549 "accumulation:v4_prepared_shape");
1550 }
1551
1552 if (transcript.rho.scalar.is_zero() ||
1553 transcript.mul_scale.scalar.is_zero() ||
1554 transcript.mul_ratio.scalar.is_zero() ||
1555 transcript.prepared_binding.scalar.is_zero() ||
1556 std::any_of(
1557 transcript.gammas.begin(), transcript.gammas.end(),
1558 [](const candidate::CircuitChallengeV4& gamma) {
1559 return gamma.scalar.is_zero();
1560 })) {
1561 return unexpected_error(
1563 "accumulation:v4_zero_challenge");
1564 }
1566 const auto& sqrt_minus_one,
1568 "accumulation:v4_sqrt_minus_one");
1569
1570 // Reconstruct every transformed G generator rather than trusting the
1571 // prepared object's duplicate list. The H suffix stays exactly raw.
1572 auto rho_power = transcript.rho.scalar;
1573 auto generator_term = transcript.mul_scale.scalar;
1574 for (std::size_t i = 0; i < shape.n_vec_len(); ++i) {
1575 const auto term = (i % 2 == 0)
1576 ? generator_term
1577 : sqrt_minus_one * generator_term;
1578 const auto scale = rho_power * term.inverse();
1579 const auto encoded_scale = scale.to_bytes_be();
1580 PointBytes expected_generator{};
1582 context, prepared.raw_generators()[i].data(),
1583 encoded_scale.data(), expected_generator.data()) == 0) {
1584 return unexpected_error(
1586 "accumulation:v4_scale_generator");
1587 }
1588 if (norm.generators[i] != expected_generator) {
1589 return unexpected_error(
1591 "accumulation:v4_scaled_basis");
1592 }
1593 if (i % 2 == 1) {
1594 generator_term =
1595 generator_term * transcript.mul_ratio.scalar;
1596 }
1597 rho_power = rho_power * transcript.rho.scalar;
1598 }
1599 if (!std::equal(
1600 norm.generators.begin() +
1601 static_cast<std::ptrdiff_t>(shape.n_vec_len()),
1602 norm.generators.end(),
1603 prepared.raw_generators().begin() +
1604 static_cast<std::ptrdiff_t>(shape.n_vec_len()))) {
1605 return unexpected_error(
1607 "accumulation:v4_linear_basis");
1608 }
1609
1610 std::size_t round_bytes = 0;
1611 std::size_t expected_proof_size = 0;
1612 if (!checked_mul_size(rounds,
1614 round_bytes) ||
1615 !checked_add_size(round_bytes, 2 * sizeof(ScalarBytes),
1616 expected_proof_size)) {
1617 return unexpected_error(
1619 "accumulation:v4_proof_size");
1620 }
1621 if (norm.proof.size() != expected_proof_size) {
1622 return unexpected_error(
1624 "accumulation:v4_proof_size");
1625 }
1626 for (std::size_t i = 0; i < rounds; ++i) {
1627 const auto offset = i * sizeof(candidate::PackedPointPairV4);
1628 if (!std::equal(
1629 transcript_input.rounds[i].begin(),
1630 transcript_input.rounds[i].end(),
1631 norm.proof.begin() +
1632 static_cast<std::ptrdiff_t>(offset))) {
1633 return unexpected_error(
1635 "accumulation:v4_round_payload");
1636 }
1637 }
1638 if (!std::equal(
1639 transcript_input.terminal_n.begin(),
1640 transcript_input.terminal_n.end(),
1641 norm.proof.begin() +
1642 static_cast<std::ptrdiff_t>(round_bytes)) ||
1643 !std::equal(
1644 transcript_input.terminal_l.begin(),
1645 transcript_input.terminal_l.end(),
1646 norm.proof.begin() + static_cast<std::ptrdiff_t>(
1647 round_bytes + sizeof(ScalarBytes)))) {
1648 return unexpected_error(
1650 "accumulation:v4_terminal_payload");
1651 }
1652
1653 std::vector<ScalarBytes> encoded_gammas;
1654 encoded_gammas.reserve(rounds);
1655 for (const auto& gamma : transcript.gammas) {
1656 encoded_gammas.push_back(gamma.scalar.to_bytes_be());
1657 }
1658 ScalarBytes terminal_n_bytes{};
1659 ScalarBytes terminal_l_bytes{};
1661 // This reconstructs the pending short equation with authenticated V4
1662 // challenges. It is not norm-proof acceptance.
1664 context, norm.rho.data(),
1665 reinterpret_cast<const unsigned char*>(
1666 norm.generators.data()),
1667 norm.generators.size(),
1668 reinterpret_cast<const unsigned char*>(norm.c_vec.data()),
1669 norm.c_vec.size(), norm.n_vec_len, norm.commitment.data(),
1670 norm.proof.data(), norm.proof.size(),
1671 reinterpret_cast<const unsigned char*>(
1672 encoded_gammas.data()),
1673 encoded_gammas.size(), terminal_n_bytes.data(),
1674 terminal_l_bytes.data(), residual.data()) == 0) {
1675 return unexpected_error(
1677 "accumulation:v4_inner_norm");
1678 }
1679 if (terminal_n_bytes != transcript_input.terminal_n ||
1680 terminal_l_bytes != transcript_input.terminal_l ||
1681 residual != prepared.pending_norm_residual()) {
1682 return unexpected_error(
1684 "accumulation:v4_prepared_norm");
1685 }
1686
1688 const auto& terminal_n,
1689 FieldElement::try_from_bytes32(terminal_n_bytes),
1690 "accumulation:v4_terminal_n");
1692 const auto& terminal_l,
1693 FieldElement::try_from_bytes32(terminal_l_bytes),
1694 "accumulation:v4_terminal_l");
1695 // These are the two compact terms installed by the constrained V4 leaf.
1697 terminal_n *
1698 pow_size(transcript.rho.scalar, shape.n_vec_len()) *
1699 transcript.mul_scale.scalar.inverse(),
1700 0,
1701 {}};
1702 PolynomialTerm h{terminal_l, shape.n_vec_len(), {}};
1703 g.factors.reserve(rounds);
1704 h.factors.reserve(rounds);
1705 auto ratio_inverse_power =
1706 transcript.mul_ratio.scalar.inverse();
1707 for (std::size_t i = 0; i < rounds; ++i) {
1708 const auto& gamma = transcript.gammas[i].scalar;
1709 if (i == 0) {
1710 g.factors.push_back(gamma * sqrt_minus_one.inverse());
1711 } else {
1712 g.factors.push_back(gamma * ratio_inverse_power);
1713 ratio_inverse_power =
1714 ratio_inverse_power * ratio_inverse_power;
1715 }
1716 h.factors.push_back(gamma);
1717 }
1718
1719 std::vector<FieldElement> coefficients;
1720 coefficients.reserve(norm.c_vec.size());
1721 for (const auto& encoded : norm.c_vec) {
1723 auto coefficient,
1725 "accumulation:v4_coefficient");
1726 coefficients.push_back(std::move(coefficient));
1727 }
1728 const auto coefficient_basis =
1729 std::span(basis.points())
1730 .subspan(basis.n_vec_len(), basis.l_vec_len());
1732 const auto coefficient_commitment,
1733 msm(coefficient_basis, coefficients, context),
1734 "accumulation:v4_coefficient_commitment");
1736 transcript_input.coefficient_commitment) {
1737 return unexpected_error(
1739 "accumulation:v4_coefficient_binding");
1740 }
1741
1742 const auto prepared_binding =
1743 transcript.prepared_binding.scalar;
1744 auto norm_data = std::move(prepared).take_norm();
1745 auto c_vec = std::move(norm_data.c_vec);
1746 return AlgebraicPreparedNorm(
1747 basis.digest(), prepared_binding, std::move(c_vec),
1749 std::array<PolynomialTerm, 2>{std::move(g), std::move(h)});
1750}
1751
1753 purify_secp_context* context) {
1754 PURIFY_RETURN_IF_ERROR(require_secp_context(context, "accumulation:context"), "accumulation:context");
1755 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
1756 PURIFY_RETURN_IF_ERROR(validate_prepared(basis, norm), "accumulation:prepared");
1757 std::vector<FieldElement> coefficients;
1758 coefficients.reserve(norm.c_vec().size());
1759 for (const auto& encoded : norm.c_vec()) {
1761 "accumulation:coefficient_scalar");
1762 coefficients.push_back(coefficient);
1763 }
1764 const PolynomialTerm weights{FieldElement::one(), 0, norm.polynomial()[1].factors};
1765 const std::array<PolynomialTerm, 1> tensor{weights};
1766 std::vector<FieldElement> expanded_weights(basis.l_vec_len(), FieldElement::zero());
1767 add_coefficients(expanded_weights, tensor, FieldElement::one());
1768 auto evaluation = FieldElement::zero();
1769 for (std::size_t i = 0; i < coefficients.size(); ++i) {
1770 evaluation = evaluation + coefficients[i] * expanded_weights[i];
1771 }
1772 NormReductionProof proof;
1773 proof.coefficient_evaluation = evaluation.to_bytes_be();
1774 PURIFY_ASSIGN_OR_RETURN(auto state, make_norm_context(basis, norm, proof.coefficient_evaluation, context),
1775 "accumulation:prove_reduction_context");
1776 const auto h_basis = std::span(basis.points()).subspan(basis.n_vec_len(), basis.l_vec_len());
1778 prove_ipa(h_basis, std::move(coefficients), state.weights, state.opening_base,
1779 state.transcript, context), "accumulation:prove_coefficient_ipa");
1780 // This checks only the short reduction, never accepts the original norm.
1781 PURIFY_ASSIGN_OR_RETURN(auto pending, verify_norm_reduction(basis, norm, proof, context),
1782 "accumulation:prove_reduction_check");
1783 (void)pending;
1784 return proof;
1785}
1786
1788 const NormReductionProof& proof, purify_secp_context* context) {
1789 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
1790 PURIFY_RETURN_IF_ERROR(validate_prepared(basis, norm), "accumulation:prepared");
1791 const auto rounds = log2_dimension(basis.l_vec_len());
1792 const auto& opening = proof.coefficient_opening;
1793 if (opening.left.size() != rounds || opening.right.size() != rounds) {
1794 return unexpected_error(ErrorCode::SizeMismatch, "accumulation:reduction_rounds");
1795 }
1796 PURIFY_ASSIGN_OR_RETURN(auto terminal, FieldElement::try_from_bytes32(opening.terminal_scalar),
1797 "accumulation:reduction_terminal");
1798 (void)terminal;
1799 PURIFY_ASSIGN_OR_RETURN(auto state, make_norm_context(basis, norm, proof.coefficient_evaluation, context),
1800 "accumulation:verify_reduction_context");
1801 PURIFY_ASSIGN_OR_RETURN(auto folded,
1802 verify_ipa(basis.l_vec_len(), opening, state.weights, norm.coefficient_commitment(),
1803 state.evaluation, state.opening_base, state.transcript, context),
1804 "accumulation:verify_coefficient_ipa");
1805 folded.offset = basis.n_vec_len();
1806
1807 const auto generator_encoding = base_generator(context);
1808 PointBytes generator{};
1809 if (purify_bppp_generators_to_points(context, generator_encoding.data(), 1, generator.data()) == 0) {
1810 return unexpected_error(ErrorCode::BackendRejectedInput, "accumulation:standard_generator");
1811 }
1812 const std::array<PointBytes, 2> norm_points{norm.residual(), generator};
1813 const std::array<FieldElement, 2> norm_scalars{
1814 FieldElement::one(), (norm.polynomial()[1].scale * state.evaluation).negate()};
1815 PURIFY_ASSIGN_OR_RETURN(auto norm_point, msm(norm_points, norm_scalars, context),
1816 "accumulation:unshifted_norm_claim");
1817
1818 // Both equations and the complete opening transcript are fixed before chi.
1819 // Returning their random combination prevents dropping the opening side.
1820 Bytes encoded;
1821 append(encoded, basis.digest());
1822 append(encoded, norm.transcript_digest());
1823 append(encoded, state.transcript);
1824 append(encoded, proof.coefficient_evaluation);
1825 append_ipa(encoded, opening);
1826 append(encoded, norm_point);
1827 append_polynomial(encoded, norm.polynomial());
1828 append(encoded, opening.folded_generator);
1829 const std::array<PolynomialTerm, 1> folded_polynomial{folded};
1830 append_polynomial(encoded, folded_polynomial);
1831 PURIFY_ASSIGN_OR_RETURN(auto chi, challenge(kNormFusionHash, encoded), "accumulation:reduction_fusion");
1832 const std::array<PointBytes, 2> fusion_points{norm_point, opening.folded_generator};
1833 const std::array<FieldElement, 2> fusion_scalars{FieldElement::one(), chi};
1834 PURIFY_ASSIGN_OR_RETURN(auto combined_point, msm(fusion_points, fusion_scalars, context),
1835 "accumulation:combined_reduction_claim");
1836 std::vector<PolynomialTerm> polynomial(norm.polynomial().begin(), norm.polynomial().end());
1837 folded.scale = folded.scale * chi;
1838 polynomial.push_back(std::move(folded));
1839 return PendingClaim(basis.digest(), combined_point, std::move(polynomial));
1840}
1841
1844 const Basis& basis, const AlgebraicPreparedNorm& norm,
1845 purify_secp_context* context) {
1847 require_secp_context(context, "accumulation:context"),
1848 "accumulation:context");
1850 validate_basis(basis), "accumulation:basis");
1852 validate_algebraic_prepared(basis, norm),
1853 "accumulation:algebraic_prepared");
1854
1855 std::vector<FieldElement> coefficients;
1856 coefficients.reserve(norm.c_vec().size());
1857 for (const auto& encoded : norm.c_vec()) {
1859 auto coefficient,
1861 "accumulation:algebraic_coefficient_scalar");
1862 coefficients.push_back(coefficient);
1863 }
1864 const PolynomialTerm weights{
1865 FieldElement::one(), 0,
1866 norm.polynomial()[1].factors};
1867 const std::array<PolynomialTerm, 1> tensor{weights};
1868 std::vector<FieldElement> expanded_weights(
1869 basis.l_vec_len(), FieldElement::zero());
1870 add_coefficients(
1871 expanded_weights, tensor, FieldElement::one());
1872 auto evaluation = FieldElement::zero();
1873 for (std::size_t i = 0; i < coefficients.size(); ++i) {
1874 evaluation = evaluation +
1875 coefficients[i] * expanded_weights[i];
1876 }
1877
1879 proof.coefficient_evaluation = evaluation.to_bytes_be();
1881 auto state,
1882 make_algebraic_norm_context(
1883 basis, norm, proof.coefficient_evaluation, context),
1884 "accumulation:prove_algebraic_reduction_context");
1885 const auto h_basis = std::span(basis.points()).subspan(
1886 basis.n_vec_len(), basis.l_vec_len());
1888 proof.coefficient_opening,
1889 prove_algebraic_ipa(
1890 h_basis, std::move(coefficients), state.weights,
1891 state.opening_base, state.transcript, 0, context),
1892 "accumulation:prove_algebraic_coefficient_ipa");
1894 auto pending,
1896 basis, norm, proof, context),
1897 "accumulation:prove_algebraic_reduction_check");
1898 (void)pending;
1899 return proof;
1900}
1901
1903 const Basis& basis, const AlgebraicPreparedNorm& norm,
1904 const AlgebraicNormReductionProof& proof,
1905 purify_secp_context* context) {
1907 validate_basis(basis), "accumulation:basis");
1909 validate_algebraic_prepared(basis, norm),
1910 "accumulation:algebraic_prepared");
1911 const auto rounds = log2_dimension(basis.l_vec_len());
1912 const auto& opening = proof.coefficient_opening;
1913 if (opening.left.size() != rounds ||
1914 opening.right.size() != rounds) {
1915 return unexpected_error(
1917 "accumulation:algebraic_reduction_rounds");
1918 }
1920 auto terminal,
1921 FieldElement::try_from_bytes32(opening.terminal_scalar),
1922 "accumulation:algebraic_reduction_terminal");
1924 auto state,
1925 make_algebraic_norm_context(
1926 basis, norm, proof.coefficient_evaluation, context),
1927 "accumulation:verify_algebraic_reduction_context");
1929 auto folded,
1930 verify_algebraic_ipa(
1931 basis.l_vec_len(), opening, state.weights,
1932 norm.coefficient_commitment(), state.evaluation,
1933 state.opening_base, state.transcript, 0, context),
1934 "accumulation:verify_algebraic_coefficient_ipa");
1935 folded.offset = basis.n_vec_len();
1936
1937 const auto generator_encoding = base_generator(context);
1938 PointBytes generator{};
1940 context, generator_encoding.data(), 1,
1941 generator.data()) == 0) {
1942 return unexpected_error(
1944 "accumulation:algebraic_standard_generator");
1945 }
1946 const std::array<PointBytes, 2> norm_points{
1947 norm.residual(), generator};
1948 const std::array<FieldElement, 2> norm_scalars{
1950 (norm.polynomial()[1].scale * state.evaluation).negate()};
1952 auto norm_point, msm(norm_points, norm_scalars, context),
1953 "accumulation:algebraic_unshifted_norm_claim");
1954
1955 // The fusion challenge follows the complete coefficient opening and
1956 // both pending equations. No field is encoded by untyped concatenation.
1957 state.transcript.append_scalar(terminal);
1959 append_algebraic_point(
1960 state.transcript, opening.folded_generator),
1961 "accumulation:algebraic_folded_generator");
1963 append_algebraic_point(state.transcript, norm_point),
1964 "accumulation:algebraic_norm_point");
1966 append_algebraic_polynomial(
1967 state.transcript, norm.polynomial()),
1968 "accumulation:algebraic_norm_polynomial");
1969 const std::array<PolynomialTerm, 1> folded_polynomial{folded};
1971 append_algebraic_polynomial(
1972 state.transcript, folded_polynomial),
1973 "accumulation:algebraic_folded_polynomial");
1975 auto chi,
1976 append_algebraic_challenge(
1977 state.transcript,
1978 static_cast<std::uint64_t>(rounds)),
1979 "accumulation:algebraic_reduction_fusion");
1980
1981 const std::array<PointBytes, 2> fusion_points{
1982 norm_point, opening.folded_generator};
1983 const std::array<FieldElement, 2> fusion_scalars{
1984 FieldElement::one(), chi};
1986 auto combined_point,
1987 msm(fusion_points, fusion_scalars, context),
1988 "accumulation:algebraic_combined_reduction_claim");
1989 std::vector<PolynomialTerm> polynomial(
1990 norm.polynomial().begin(), norm.polynomial().end());
1991 folded.scale = folded.scale * chi;
1992 polynomial.push_back(std::move(folded));
1993 return PendingClaim(
1994 basis.digest(), combined_point, std::move(polynomial));
1995}
1996
1997Result<StepProof> prove_step(const Basis& basis, std::span<const PendingClaim> claims,
1998 purify_secp_context* context) {
1999 PURIFY_ASSIGN_OR_RETURN(auto state, make_step_context(basis, claims, context),
2000 "accumulation:prove_context");
2001 std::vector<FieldElement> a(basis.dimension(), FieldElement::zero());
2002 auto weight = FieldElement::one();
2003 for (const auto& claim : claims) {
2004 add_coefficients(a, claim.polynomial(), weight);
2005 weight = weight * state.beta;
2006 }
2007 const auto weights = geometric_tensor(state.x, basis.dimension());
2008 PURIFY_ASSIGN_OR_RETURN(auto proof,
2009 prove_ipa(basis.points(), std::move(a), weights, state.opening_base, state.transcript, context),
2010 "accumulation:prove_ipa");
2011 // Check the aggregated short equation before returning a generated proof.
2012 // This needs no additional fixed-basis MSM; batching is probabilistic.
2013 PURIFY_ASSIGN_OR_RETURN(auto pending, verify_step(basis, claims, proof, context),
2014 "accumulation:prove_check");
2015 (void)pending;
2016 return proof;
2017}
2018
2019Result<PendingClaim> verify_step(const Basis& basis, std::span<const PendingClaim> claims,
2020 const StepProof& proof, purify_secp_context* context) {
2021 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
2022 const auto rounds = log2_dimension(basis.dimension());
2023 if (proof.left.size() != rounds || proof.right.size() != rounds) {
2024 return unexpected_error(ErrorCode::SizeMismatch, "accumulation:step_proof_rounds");
2025 }
2027 "accumulation:step_terminal_scalar");
2028 (void)terminal;
2029 PURIFY_ASSIGN_OR_RETURN(auto state, make_step_context(basis, claims, context),
2030 "accumulation:verify_context");
2031 const auto weights = geometric_tensor(state.x, basis.dimension());
2032 PURIFY_ASSIGN_OR_RETURN(auto folded,
2033 verify_ipa(basis.dimension(), proof, weights, state.commitment, state.y,
2034 state.opening_base, state.transcript, context), "accumulation:verify_ipa");
2035 return PendingClaim(basis.digest(), proof.folded_generator, {std::move(folded)});
2036}
2037
2038namespace {
2039
2040Result<AlgebraicStepProof> prove_algebraic_step_impl(
2041 const Basis& basis, std::span<const PendingClaim> claims,
2042 const Digest* statement_digest, purify_secp_context* context) {
2044 auto state,
2045 make_algebraic_step_context(
2046 basis, claims, statement_digest, context),
2047 "accumulation:prove_algebraic_context");
2048 std::vector<FieldElement> coefficients(
2049 basis.dimension(), FieldElement::zero());
2050 auto weight = FieldElement::one();
2051 for (const auto& claim : claims) {
2052 add_coefficients(
2053 coefficients, claim.polynomial(), weight);
2054 weight = weight * state.beta;
2055 }
2056 const auto weights =
2057 geometric_tensor(state.x, basis.dimension());
2059 auto proof,
2060 prove_algebraic_ipa(
2061 basis.points(), std::move(coefficients), weights,
2062 state.opening_base, state.transcript, 2, context),
2063 "accumulation:prove_algebraic_ipa");
2065 auto pending,
2066 statement_digest == nullptr
2067 ? verify_algebraic_step(
2068 basis, claims, proof, context)
2069 : verify_bound_algebraic_step(
2070 basis, claims, *statement_digest, proof, context),
2071 "accumulation:prove_algebraic_check");
2072 (void)pending;
2073 return proof;
2074}
2075
2076struct AlgebraicStepPendingData {
2077 PointBytes point;
2078 PolynomialTerm polynomial;
2079};
2080
2081Result<AlgebraicStepPendingData> verify_algebraic_step_impl(
2082 const Basis& basis, std::span<const PendingClaim> claims,
2083 const Digest* statement_digest, const AlgebraicStepProof& proof,
2084 purify_secp_context* context) {
2086 validate_basis(basis), "accumulation:basis");
2087 const auto rounds = log2_dimension(basis.dimension());
2088 if (proof.left.size() != rounds ||
2089 proof.right.size() != rounds) {
2090 return unexpected_error(
2092 "accumulation:algebraic_step_rounds");
2093 }
2095 auto terminal,
2096 FieldElement::try_from_bytes32(proof.terminal_scalar),
2097 "accumulation:algebraic_step_terminal_scalar");
2098 (void)terminal;
2100 auto state,
2101 make_algebraic_step_context(
2102 basis, claims, statement_digest, context),
2103 "accumulation:verify_algebraic_context");
2104 const auto weights =
2105 geometric_tensor(state.x, basis.dimension());
2107 auto folded,
2108 verify_algebraic_ipa(
2109 basis.dimension(), proof, weights,
2110 state.commitment, state.y, state.opening_base,
2111 state.transcript, 2, context),
2112 "accumulation:verify_algebraic_ipa");
2113 return AlgebraicStepPendingData{
2114 proof.folded_generator, std::move(folded)};
2115}
2116
2117} // namespace
2118
2120 const Basis& basis, std::span<const PendingClaim> claims,
2121 purify_secp_context* context) {
2122 return prove_algebraic_step_impl(
2123 basis, claims, nullptr, context);
2124}
2125
2127 const Basis& basis, std::span<const PendingClaim> claims,
2128 const AlgebraicStepProof& proof,
2129 purify_secp_context* context) {
2131 auto pending,
2132 verify_algebraic_step_impl(
2133 basis, claims, nullptr, proof, context),
2134 "accumulation:verify_algebraic_step");
2135 return PendingClaim(
2136 basis.digest(), pending.point,
2137 {std::move(pending.polynomial)});
2138}
2139
2141 const Basis& basis, std::span<const PendingClaim> claims,
2142 const Digest& statement_digest, purify_secp_context* context) {
2143 return prove_algebraic_step_impl(
2144 basis, claims, &statement_digest, context);
2145}
2146
2148 const Basis& basis, std::span<const PendingClaim> claims,
2149 const Digest& statement_digest, const AlgebraicStepProof& proof,
2150 purify_secp_context* context) {
2152 auto pending,
2153 verify_algebraic_step_impl(
2154 basis, claims, &statement_digest, proof, context),
2155 "accumulation:verify_bound_algebraic_step");
2156 return PendingClaim(
2157 basis.digest(), pending.point,
2158 {std::move(pending.polynomial)});
2159}
2160
2161#if defined(PURIFY_INTERNAL_TEST_SUPPORT)
2162namespace test_support {
2163
2164Result<PointBytes> algebraic_step_equation_residual(
2165 const Basis& basis, std::span<const PendingClaim> claims,
2166 const AlgebraicStepProof& proof,
2167 purify_secp_context* context) {
2169 validate_basis(basis), "accumulation:test_basis");
2170 const auto rounds = log2_dimension(basis.dimension());
2171 if (proof.left.size() != rounds ||
2172 proof.right.size() != rounds) {
2173 return unexpected_error(
2175 "accumulation:test_step_rounds");
2176 }
2178 auto state,
2179 make_algebraic_step_context(basis, claims, nullptr, context),
2180 "accumulation:test_step_context");
2181 const auto weights =
2182 geometric_tensor(state.x, basis.dimension());
2184 auto evaluated,
2185 evaluate_algebraic_ipa(
2186 basis.dimension(), proof, weights,
2187 state.commitment, state.y, state.opening_base,
2188 state.transcript, 2, context),
2189 "accumulation:test_step_evaluate");
2190 return evaluated.residual;
2191}
2192
2193} // namespace test_support
2194#endif
2195
2196Status decide(const Basis& basis, const PendingClaim& claim, purify_secp_context* context) {
2197 PURIFY_RETURN_IF_ERROR(require_secp_context(context, "accumulation:context"),
2198 "accumulation:context");
2199 PURIFY_RETURN_IF_ERROR(validate_basis(basis), "accumulation:basis");
2200 PURIFY_RETURN_IF_ERROR(validate_claim(basis, claim), "accumulation:claim");
2201 std::vector<FieldElement> coefficients(basis.dimension(), FieldElement::zero());
2202 add_coefficients(coefficients, claim.polynomial(), FieldElement::one());
2203 PURIFY_ASSIGN_OR_RETURN(auto expected, msm(basis.points(), coefficients, context),
2204 "accumulation:decide_msm");
2205 if (expected != claim.point()) {
2206 return unexpected_error(ErrorCode::EquationMismatch, "accumulation:final_decider");
2207 }
2208 return {};
2209}
2210
2211} // namespace purify::bppp::accumulation
int purify_bppp_prepare_norm_arg_claim_with_challenges(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *c_vec32, size_t c_vec_len, size_t n_vec_len, const unsigned char commitment33[33], const unsigned char *proof, size_t proof_len, const unsigned char *gammas32, size_t gamma_count, unsigned char terminal_n32[32], unsigned char terminal_l32[32], unsigned char residual33[33])
int purify_bppp_scale_generator(purify_secp_context *context, const unsigned char generator33[33], const unsigned char scalar32[32], unsigned char out33[33])
int purify_bppp_prepare_norm_arg_claim(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *c_vec32, size_t c_vec_len, size_t n_vec_len, const unsigned char commitment33[33], const unsigned char *proof, size_t proof_len, unsigned char terminal_n32[32], unsigned char terminal_l32[32], unsigned char *gammas32, size_t gamma_count, unsigned char residual33[33])
int purify_bppp_public_point_validate(const unsigned char point33[33])
int purify_bppp_public_msm(purify_secp_context *context, const unsigned char *points33, const unsigned char *scalars32, size_t count, unsigned char out33[33])
int purify_bppp_public_hash_to_point(purify_secp_context *context, const unsigned char *input, size_t input_len, unsigned char out33[33])
int purify_bppp_generators_to_points(purify_secp_context *context, const unsigned char *generators33, size_t generators_count, unsigned char *points_out33)
C ABI bridging Purify C++ code to secp256k1-zkp BPPP functionality.
static FieldElement one()
Returns the multiplicative identity of the scalar field.
Definition numeric.cpp:36
static Result< FieldElement > try_from_bytes32(const std::array< unsigned char, 32 > &bytes)
Decodes a canonical 32-byte big-endian field element.
Definition numeric.cpp:53
FieldElement negate() const
Returns the additive inverse modulo the field prime.
Definition numeric.cpp:121
static FieldElement zero()
Returns the additive identity of the scalar field.
Definition numeric.cpp:32
std::array< unsigned char, 32 > to_bytes_be() const
Serializes the field element in big-endian form.
Definition numeric.cpp:84
Common interface for reusable experimental BPPP backend state.
Definition bppp.hpp:129
friend Result< AlgebraicPreparedNorm > prepare_v4_circuit_norm_for_algebraic_reduction(const Basis &, candidate::PreparedCircuitZkNormArgV4, purify_secp_context *)
const std::vector< ScalarBytes > & c_vec() const
const std::array< PolynomialTerm, 2 > & polynomial() const
static Result< Basis > create(std::size_t n_vec_len, std::size_t l_vec_len, std::string_view semantic_domain, purify_secp_context *context)
const Digest & digest() const
const std::vector< PointBytes > & points() const
const std::vector< PointBytes > & norm_generators() const
friend Result< PendingClaim > verify_algebraic_norm_reduction(const Basis &, const AlgebraicPreparedNorm &, const AlgebraicNormReductionProof &, purify_secp_context *)
const std::vector< PolynomialTerm > & polynomial() const
friend Result< PendingClaim > verify_algebraic_step(const Basis &, std::span< const PendingClaim >, const AlgebraicStepProof &, purify_secp_context *)
friend Result< PendingClaim > canonical_zero_claim(const Basis &)
friend Result< PendingClaim > verify_norm_reduction(const Basis &, const PreparedNorm &, const NormReductionProof &, purify_secp_context *)
friend Result< PendingClaim > verify_bound_algebraic_step(const Basis &, std::span< const PendingClaim >, const Digest &, const AlgebraicStepProof &, purify_secp_context *)
friend Result< PendingClaim > verify_step(const Basis &, std::span< const PendingClaim >, const StepProof &, purify_secp_context *)
const std::array< PolynomialTerm, 2 > & polynomial() const
const PointBytes & residual() const
friend Result< PreparedNorm > prepare_experimental_circuit_zk_norm_arg(const Basis &, const NativeBulletproofCircuit &, const ExperimentalCircuitZkNormArgProof &, purify_secp_context *, std::span< const unsigned char >, ExperimentalCircuitBackend *)
friend Result< PreparedNorm > prepare_norm(const Basis &, const NormArgProof &, purify_secp_context *)
friend Result< PreparedNorm > prepare_experimental_circuit_zk_norm_arg_with_public_commitments(const Basis &, const NativeBulletproofCircuit &, const ExperimentalCircuitZkNormArgProof &, std::span< const PointBytes >, purify_secp_context *, std::span< const unsigned char >, ExperimentalCircuitBackend *)
const PointBytes & coefficient_commitment() const
const std::vector< ScalarBytes > & c_vec() const
const std::vector< PointBytes > & raw_generators() const noexcept
const CircuitProofTranscriptResultV4 & transcript() const noexcept
const CircuitTranscriptShapeV4 & shape() const noexcept
const CircuitProofTranscriptInputV4 & transcript_input() const noexcept
#define PURIFY_RETURN_IF_ERROR(expr, context)
Evaluates an expected-like expression and returns the wrapped error on failure.
Definition error.hpp:329
#define PURIFY_ASSIGN_OR_RETURN(lhs, expr, context)
Evaluates an expected-like expression, binds the value to lhs, and propagates errors.
Definition error.hpp:338
Result< StepProof > prove_step(const Basis &basis, std::span< const PendingClaim > claims, purify_secp_context *context)
Result< Bytes > serialize_root_claim(const Basis &basis, const PendingClaim &claim, purify_secp_context *context)
Result< PendingClaim > parse_root_claim(const Basis &basis, std::span< const unsigned char > encoded, purify_secp_context *context)
Result< AlgebraicNormReductionProof > prove_algebraic_norm_reduction(const Basis &basis, const AlgebraicPreparedNorm &norm, purify_secp_context *context)
Result< AlgebraicStepProof > parse_algebraic_step(const Basis &basis, std::span< const unsigned char > encoded, purify_secp_context *context)
Result< PendingClaim > verify_norm_reduction(const Basis &basis, const PreparedNorm &norm, const NormReductionProof &proof, purify_secp_context *context)
Result< NormReductionProof > parse_norm_reduction(const Basis &basis, std::span< const unsigned char > encoded, purify_secp_context *context)
Result< AlgebraicNormReductionProof > parse_algebraic_norm_reduction(const Basis &basis, std::span< const unsigned char > encoded, purify_secp_context *context)
Result< AlgebraicStepProof > prove_algebraic_step(const Basis &basis, std::span< const PendingClaim > claims, purify_secp_context *context)
Result< PendingClaim > verify_algebraic_norm_reduction(const Basis &basis, const AlgebraicPreparedNorm &norm, const AlgebraicNormReductionProof &proof, purify_secp_context *context)
Result< Bytes > serialize_norm_reduction(const Basis &basis, const NormReductionProof &proof, purify_secp_context *context)
Result< StepProof > parse_step(const Basis &basis, std::span< const unsigned char > encoded, purify_secp_context *context)
Status decide(const Basis &basis, const PendingClaim &claim, purify_secp_context *context)
Result< AlgebraicStepProof > prove_bound_algebraic_step(const Basis &basis, std::span< const PendingClaim > claims, const Digest &statement_digest, purify_secp_context *context)
std::array< unsigned char, 32 > Digest
Result< NormReductionProof > prove_norm_reduction(const Basis &basis, const PreparedNorm &norm, purify_secp_context *context)
Result< Bytes > serialize_algebraic_norm_reduction(const Basis &basis, const AlgebraicNormReductionProof &proof, purify_secp_context *context)
Result< Bytes > serialize_algebraic_step(const Basis &basis, const AlgebraicStepProof &proof, purify_secp_context *context)
Result< Bytes > serialize_step(const Basis &basis, const StepProof &proof, purify_secp_context *context)
Result< PendingClaim > verify_step(const Basis &basis, std::span< const PendingClaim > claims, const StepProof &proof, purify_secp_context *context)
std::array< unsigned char, 32 > TranscriptBytes32
std::array< unsigned char, 65 > PackedPointPairV4
Result< std::optional< PreparedExperimentalCircuitZkNormArg > > prepare_experimental_circuit_zk_norm_arg(const NativeBulletproofCircuit &circuit, const ExperimentalCircuitZkNormArgProof &proof, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding, ExperimentalCircuitBackend *cache)
Definition bppp.cpp:2676
Result< std::optional< PreparedExperimentalCircuitZkNormArg > > prepare_experimental_circuit_zk_norm_arg_with_public_commitments(const NativeBulletproofCircuit &circuit, const ExperimentalCircuitZkNormArgProof &proof, std::span< const PointBytes > public_commitments, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding, ExperimentalCircuitBackend *cache)
Definition bppp.cpp:2621
Result< FieldElement > canonical_sqrt_minus_one()
GeneratorBytes base_generator(purify_secp_context *secp_context)
Returns the serialized secp256k1 base generator used as the blind generator.
Definition bppp.cpp:1702
Result< std::vector< PointBytes > > create_generators(std::size_t count, purify_secp_context *secp_context)
Expands the BPPP generator list.
Definition bppp.cpp:1721
std::array< unsigned char, 33 > PointBytes
Compressed 33-byte curve-point encoding.
Definition bppp.hpp:32
std::array< unsigned char, 32 > ScalarBytes
Big-endian 32-byte scalar encoding.
Definition bppp.hpp:30
Status require_secp_context(const purify_secp_context *context, const char *error_context)
Definition common.hpp:56
constexpr Unexpected< Error > unexpected_error(ErrorCode code, const char *context=nullptr)
Constructs an unexpected Error value from a machine-readable code.
Definition error.hpp:293
bool size_fits_u64(std::size_t value) noexcept
Definition common.hpp:83
bool is_power_of_two_size(std::size_t value) noexcept
Definition common.hpp:94
bool checked_mul_size(std::size_t lhs, std::size_t rhs, std::size_t &out) noexcept
Definition common.hpp:71
Expected< T, Error > Result
Expected-returning convenience alias for Purify value-producing APIs.
Definition error.hpp:99
Expected< void, Error > Status
Expected-returning convenience alias for Purify status-only APIs.
Definition error.hpp:102
std::vector< unsigned char > Bytes
Dynamically sized byte string used for messages, serialized witnesses, and proofs.
Definition common.hpp:99
bool checked_add_size(std::size_t lhs, std::size_t rhs, std::size_t &out) noexcept
Definition common.hpp:63
void purify_sha256(unsigned char output32[32], const unsigned char *data, size_t data_len)
Computes SHA-256 over a byte string.
struct purify_secp_context purify_secp_context
Caller-owned reusable secp256k1 context handle shared across Purify C and C++ APIs.
Native in-memory representation of a Bulletproof-style arithmetic circuit.
Masked circuit proof with a pre-challenge raw-coordinate commitment.
Definition bppp.hpp:268
Standalone BPPP norm-argument proof bundle with all verifier-side inputs.
Definition bppp.hpp:118
std::vector< PointBytes > generators
Definition bppp.hpp:120
std::vector< ScalarBytes > c_vec
Definition bppp.hpp:121
PointBytes commitment
Finite compressed initial point; infinity is not accepted.
Definition bppp.hpp:124