purify
C++ Purify implementation with native circuit and BPP support
Loading...
Searching...
No Matches
bppp.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
9
10#include "purify/bppp.hpp"
11
12#include <algorithm>
13#include <cstdint>
14#include <cstring>
15#include <limits>
16#include <memory>
17#include <span>
18#include <string>
19#include <string_view>
20#include <tuple>
21#include <type_traits>
22#include <unordered_map>
23#include <vector>
24
25#include "bppp_bridge.h"
27#include "bppp_internal.hpp"
29#include "purify/secp_bridge.h"
30#include "secure_cleanup.hpp"
31
32namespace purify::bppp {
33
39
41 std::unique_ptr<purify_bppp_backend_resources, BpppBackendResourcesDeleter>;
42
43using GeneratorBackendCacheKey = std::array<unsigned char, 32>;
44
45template <typename Digest>
46std::size_t digest_prefix_hash(const Digest &digest) noexcept {
47 static_assert(sizeof(std::size_t) <= std::tuple_size_v<Digest>,
48 "digest prefix hash must fit within digest output");
49 std::size_t out = 0;
50 std::memcpy(&out, digest.data(), sizeof(std::size_t));
51 return out;
52}
53
55 std::size_t operator()(const GeneratorBackendCacheKey &key) const noexcept {
56 return digest_prefix_hash(key);
57 }
58};
59
60using CircuitNormArgPublicDataCacheKey = std::array<unsigned char, 32>;
62
64 std::span<const PointBytes> generators) {
66 auto serialized_view = std::as_bytes(generators);
67 const unsigned char *serialized =
68 serialized_view.empty()
69 ? nullptr
70 : reinterpret_cast<const unsigned char *>(serialized_view.data());
71 purify_sha256(key.data(), serialized, serialized_view.size());
72 return key;
73}
74
76
77std::shared_ptr<const void>
79 const ExperimentalCircuitBackend *backend,
80 const std::array<unsigned char, 32> &key) {
81 return backend != nullptr ? backend->find_public_data_impl(key)
82 : std::shared_ptr<const void>{};
83}
84
86 ExperimentalCircuitBackend *backend, std::array<unsigned char, 32> key,
87 std::shared_ptr<const void> value) {
88 if (backend != nullptr) {
89 backend->insert_public_data_impl(std::move(key), std::move(value));
90 }
91}
92
96 std::span<const PointBytes> generators,
97 purify_secp_context *secp_context) {
98 return backend != nullptr
99 ? backend->get_or_create_backend_resources_impl(generators,
100 secp_context)
101 : nullptr;
102}
103
109
119
122
124 ExperimentalCircuitCacheLine &&other) noexcept = default;
125
127 ExperimentalCircuitCacheLine &&other) noexcept = default;
128
130
132 return impl_ == nullptr || impl_->backend_resources == nullptr;
133}
134
135std::shared_ptr<const void> ExperimentalCircuitCacheLine::find_public_data_impl(
136 const std::array<unsigned char, 32> &key) const {
137 (void)key;
138 return {};
139}
140
141void ExperimentalCircuitCacheLine::insert_public_data_impl(
142 std::array<unsigned char, 32> key, std::shared_ptr<const void> value) {
143 (void)key;
144 (void)value;
145}
146
148ExperimentalCircuitCacheLine::get_or_create_backend_resources_impl(
149 std::span<const PointBytes> generators,
150 purify_secp_context *secp_context) {
151 (void)secp_context;
152 if (impl_ == nullptr || impl_->backend_resources == nullptr ||
153 generators.empty() || !impl_->has_backend_key) {
154 return nullptr;
155 }
156 return generator_backend_cache_key(generators) == impl_->backend_key
157 ? impl_->backend_resources.get()
158 : nullptr;
159}
160
162 : impl_(std::make_unique<Impl>()) {}
163
165 ExperimentalCircuitCache &&other) noexcept = default;
166
168 ExperimentalCircuitCache &&other) noexcept = default;
169
171
173 if (impl_ != nullptr) {
174 impl_->public_data.clear();
175 impl_->backend_resources.clear();
176 }
177}
178
179std::size_t ExperimentalCircuitCache::size() const noexcept {
180 return impl_ != nullptr
181 ? impl_->public_data.size() + impl_->backend_resources.size()
182 : 0;
183}
184
186 std::span<const PointBytes> generators) const {
188 if (impl_ == nullptr || generators.empty()) {
189 return clone;
190 }
191
193 auto it = impl_->backend_resources.find(key);
194 if (it == impl_->backend_resources.end()) {
195 return clone;
196 }
197
199 purify_bppp_backend_resources_clone(it->second.get());
200 if (cloned == nullptr) {
201 return unexpected_error(
203 "ExperimentalCircuitCache::clone_line_for_thread:backend_resources");
204 }
205 clone.impl_->backend_key = key;
206 clone.impl_->has_backend_key = true;
207 clone.impl_->backend_resources.reset(cloned);
208 return clone;
209}
210
212 const std::array<unsigned char, 32> &key) const {
213 return find_public_data_impl(key);
214}
215
217 std::array<unsigned char, 32> key,
218 std::shared_ptr<const void> value) {
219 insert_public_data_impl(std::move(key), std::move(value));
220}
221
224 std::span<const PointBytes> generators,
225 purify_secp_context *secp_context) {
226 return get_or_create_backend_resources_impl(generators, secp_context);
227}
228
229std::shared_ptr<const void> ExperimentalCircuitCache::find_public_data_impl(
230 const std::array<unsigned char, 32> &key) const {
231 if (impl_ == nullptr) {
232 return {};
233 }
234 auto it = impl_->public_data.find(key);
235 if (it == impl_->public_data.end()) {
236 return {};
237 }
238 return it->second;
239}
240
241void ExperimentalCircuitCache::insert_public_data_impl(
242 std::array<unsigned char, 32> key,
243 std::shared_ptr<const void> value) {
244 if (impl_ == nullptr) {
245 return;
246 }
247 impl_->public_data.emplace(std::move(key), std::move(value));
248}
249
251ExperimentalCircuitCache::get_or_create_backend_resources_impl(
252 std::span<const PointBytes> generators,
253 purify_secp_context *secp_context) {
254 if (impl_ == nullptr || secp_context == nullptr || generators.empty()) {
255 return nullptr;
256 }
257
258 auto serialized_view = std::as_bytes(generators);
259 const unsigned char *serialized =
260 serialized_view.empty()
261 ? nullptr
262 : reinterpret_cast<const unsigned char *>(serialized_view.data());
263
265
266 auto it = impl_->backend_resources.find(key);
267 if (it != impl_->backend_resources.end()) {
268 return it->second.get();
269 }
270
272 purify_bppp_backend_resources_create(secp_context, serialized,
273 generators.size());
274 if (created == nullptr) {
275 return nullptr;
276 }
277
278 auto inserted =
279 impl_->backend_resources.emplace(key, OwnedBpppBackendResources(created));
280 return inserted.first->second.get();
281}
282
283namespace {
284
285struct SecretBytes {
286 Bytes value;
287
288 SecretBytes() = default;
289 SecretBytes(const SecretBytes &) = delete;
290 SecretBytes &operator=(const SecretBytes &) = delete;
291 ~SecretBytes() {
292 ::purify::detail::secure_clear_bytes(value.data(), value.size());
293 }
294};
295
296using SecretScalarBytes = ::purify::detail::Secret<ScalarBytes>;
297
298using ::purify::detail::WipeOnDestruction;
299
300void secure_clear_field_element(FieldElement &value) noexcept {
301 static_assert(std::is_trivially_destructible_v<FieldElement>);
302 ::purify::detail::secure_clear_bytes(&value, sizeof(value));
303}
304
305template <typename ByteArray> constexpr void assert_packed_byte_array_layout() {
306 static_assert(
307 std::is_same_v<typename ByteArray::value_type, unsigned char>,
308 "byte-span bridge helpers require unsigned-char array elements");
309 static_assert(
310 std::is_trivially_copyable_v<ByteArray>,
311 "byte-span bridge helpers require trivially copyable array wrappers");
312 static_assert(
313 std::is_standard_layout_v<ByteArray>,
314 "byte-span bridge helpers require standard-layout array wrappers");
315 static_assert(alignof(ByteArray) == alignof(unsigned char),
316 "byte-span bridge helpers require byte-aligned array wrappers");
317 static_assert(sizeof(ByteArray) == std::tuple_size_v<ByteArray>,
318 "byte-span bridge helpers require tightly packed byte arrays "
319 "with no padding");
320}
321
322template <typename ByteArray>
323std::span<const unsigned char> byte_span(const std::vector<ByteArray> &values) {
324 assert_packed_byte_array_layout<ByteArray>();
325 auto bytes =
326 std::as_bytes(std::span<const ByteArray>(values.data(), values.size()));
327 return {reinterpret_cast<const unsigned char *>(bytes.data()), bytes.size()};
328}
329
330template <typename ByteArray>
331std::span<unsigned char> writable_byte_span(std::vector<ByteArray> &values) {
332 assert_packed_byte_array_layout<ByteArray>();
333 auto bytes = std::as_writable_bytes(
334 std::span<ByteArray>(values.data(), values.size()));
335 return {reinterpret_cast<unsigned char *>(bytes.data()), bytes.size()};
336}
337
339bool require_ok(int ok) { return ok != 0; }
340
341constexpr std::string_view kCircuitNormArgRhoTag =
342 "Purify/BPPP/CircuitNormArgV3/Rho";
343constexpr std::string_view kCircuitNormArgMulTag =
344 "Purify/BPPP/CircuitNormArgV3/Mul";
345constexpr std::string_view kCircuitNormArgConstraintTag =
346 "Purify/BPPP/CircuitNormArgV3/Constraint";
347constexpr std::string_view kCircuitNormArgPublicCommitmentTag =
348 "Purify/BPPP/CircuitNormArgV3/PublicCommitments";
349constexpr std::string_view kCircuitNormArgPrecommitTag =
350 "Purify/BPPP/CircuitNormArgV3/Precommit";
351constexpr std::string_view kCircuitZkBlindTag =
352 "Purify/BPPP/CircuitNormArgV3/ZKBlind";
353constexpr std::string_view kCircuitZkMaskNTag =
354 "Purify/BPPP/CircuitNormArgV3/ZKMaskN";
355constexpr std::string_view kCircuitZkMaskLTag =
356 "Purify/BPPP/CircuitNormArgV3/ZKMaskL";
357constexpr std::string_view kCircuitZkChallengeTag =
358 "Purify/BPPP/CircuitNormArgV3/ZKChallenge";
359constexpr std::string_view kCircuitDlogBatchTag =
360 "Purify/BPPP/CircuitNormArgV3/DLogBatch";
361constexpr std::string_view kCircuitDlogNonceTag =
362 "Purify/BPPP/CircuitNormArgV3/DLogNonce";
363constexpr std::string_view kCircuitDlogChallengeTag =
364 "Purify/BPPP/CircuitNormArgV3/DLogChallenge";
365constexpr std::string_view kCircuitZkBlindV4Tag =
366 "Purify/BPPP/CircuitNormArg/v4/ZKBlind";
367constexpr std::string_view kCircuitZkMaskNV4Tag =
368 "Purify/BPPP/CircuitNormArg/v4/ZKMaskN";
369constexpr std::string_view kCircuitZkMaskLV4Tag =
370 "Purify/BPPP/CircuitNormArg/v4/ZKMaskL";
371constexpr std::string_view kCircuitDlogNonceV4Tag =
372 "Purify/BPPP/CircuitNormArg/v4/DLogNonce";
373const TaggedHash kCircuitNormArgRhoTaggedHash(kCircuitNormArgRhoTag);
374const TaggedHash kCircuitNormArgMulTaggedHash(kCircuitNormArgMulTag);
375const TaggedHash kCircuitNormArgConstraintTaggedHash(kCircuitNormArgConstraintTag);
376const TaggedHash kCircuitNormArgPrecommitTaggedHash(kCircuitNormArgPrecommitTag);
377const TaggedHash kCircuitZkBlindTaggedHash(kCircuitZkBlindTag);
378const TaggedHash kCircuitZkMaskNTaggedHash(kCircuitZkMaskNTag);
379const TaggedHash kCircuitZkMaskLTaggedHash(kCircuitZkMaskLTag);
380const TaggedHash kCircuitZkChallengeTaggedHash(kCircuitZkChallengeTag);
381const TaggedHash kCircuitDlogBatchTaggedHash(kCircuitDlogBatchTag);
382const TaggedHash kCircuitDlogNonceTaggedHash(kCircuitDlogNonceTag);
383const TaggedHash kCircuitDlogChallengeTaggedHash(kCircuitDlogChallengeTag);
384const TaggedHash kCircuitZkBlindV4TaggedHash(kCircuitZkBlindV4Tag);
385const TaggedHash kCircuitZkMaskNV4TaggedHash(kCircuitZkMaskNV4Tag);
386const TaggedHash kCircuitZkMaskLV4TaggedHash(kCircuitZkMaskLV4Tag);
387const TaggedHash kCircuitDlogNonceV4TaggedHash(kCircuitDlogNonceV4Tag);
388
389struct ResolvedBpppGeneratorBackend {
390 std::span<const unsigned char> serialized_bytes{};
391 std::size_t generator_count = 0;
392 purify_bppp_backend_resources *backend_resources = nullptr;
393};
394
395ResolvedBpppGeneratorBackend resolve_bppp_generator_backend(
397 const std::vector<PointBytes> &serialized_generators,
398 purify_secp_context *secp_context) {
399 ResolvedBpppGeneratorBackend out;
400 out.serialized_bytes = byte_span(serialized_generators);
401 out.generator_count = serialized_generators.size();
402
403 if (cache == nullptr || serialized_generators.empty()) {
404 return out;
405 }
406 out.backend_resources =
408 cache, serialized_generators, secp_context);
409 return out;
410}
411
412Result<std::size_t> round_up_power_of_two(std::size_t value,
413 const char *context) {
414 if (value == 0) {
415 return unexpected_error(ErrorCode::Overflow, context);
416 }
417 std::size_t out = 1;
418 while (out < value) {
419 if (out > std::numeric_limits<std::size_t>::max() / 2) {
420 return unexpected_error(ErrorCode::Overflow, context);
421 }
422 out <<= 1;
423 }
424 return out;
425}
426
427void append_u64_le(Bytes &out, std::uint64_t value) {
428 for (int i = 0; i < 8; ++i) {
429 out.push_back(static_cast<unsigned char>((value >> (8 * i)) & 0xffU));
430 }
431}
432
433Result<FieldElement> derive_nonzero_scalar(std::span<const unsigned char> seed,
434 const TaggedHash& tag,
435 std::size_t index) {
436 Bytes prefix(seed.begin(), seed.end());
437 PURIFY_ASSIGN_OR_RETURN(const auto &encoded_index,
438 narrow_size_to_u64(index,
439 "derive_nonzero_scalar:index"),
440 "derive_nonzero_scalar:index");
441 append_u64_le(prefix, encoded_index);
442 for (std::uint64_t counter = 0; counter < 256; ++counter) {
443 Bytes input = prefix;
444 append_u64_le(input, counter);
445 ScalarBytes candidate_bytes{};
446 candidate_bytes =
447 tag.digest(std::span<const unsigned char>(input.data(), input.size()));
449 FieldElement::try_from_bytes32(candidate_bytes);
450 if (candidate.has_value() && !candidate->is_zero()) {
451 return candidate;
452 }
453 }
455 "derive_nonzero_scalar:exhausted");
456}
457
458Status derive_scalar(FieldElement &out, std::span<const unsigned char> seed,
459 const TaggedHash &tag, std::size_t index,
460 std::uint64_t attempt = 0) {
461 SecretBytes prefix;
462 prefix.value.reserve(seed.size() + 2 * sizeof(std::uint64_t));
463 prefix.value.assign(seed.begin(), seed.end());
464 PURIFY_ASSIGN_OR_RETURN(const auto &encoded_index,
465 narrow_size_to_u64(index, "derive_scalar:index"),
466 "derive_scalar:index");
467 append_u64_le(prefix.value, encoded_index);
468 append_u64_le(prefix.value, attempt);
469 for (std::uint64_t counter = 0; counter < 256; ++counter) {
470 SecretBytes input;
471 input.value.reserve(prefix.value.size() + sizeof(std::uint64_t));
472 input.value.assign(prefix.value.begin(), prefix.value.end());
473 append_u64_le(input.value, counter);
474 SecretScalarBytes candidate_bytes;
475 ScalarBytes digest = tag.digest(std::span<const unsigned char>(
476 input.value.data(), input.value.size()));
477 candidate_bytes.value = digest;
478 ::purify::detail::secure_clear_bytes(digest.data(), digest.size());
480 FieldElement::try_from_bytes32(candidate_bytes.value);
481 if (candidate.has_value()) {
482 out = *candidate;
483 secure_clear_field_element(*candidate);
484 return {};
485 }
486 }
488 "derive_scalar:exhausted");
489}
490
491Status derive_secret_nonzero_scalar(FieldElement &out,
492 std::span<const unsigned char> seed,
493 const TaggedHash &tag,
494 std::size_t index) {
495 SecretBytes prefix;
496 prefix.value.reserve(seed.size() + sizeof(std::uint64_t));
497 prefix.value.assign(seed.begin(), seed.end());
499 const auto &encoded_index,
500 narrow_size_to_u64(index, "derive_secret_nonzero_scalar:index"),
501 "derive_secret_nonzero_scalar:index");
502 append_u64_le(prefix.value, encoded_index);
503 for (std::uint64_t counter = 0; counter < 256; ++counter) {
504 SecretBytes input;
505 input.value.reserve(prefix.value.size() + sizeof(std::uint64_t));
506 input.value.assign(prefix.value.begin(), prefix.value.end());
507 append_u64_le(input.value, counter);
508 SecretScalarBytes candidate_bytes;
509 ScalarBytes digest = tag.digest(std::span<const unsigned char>(
510 input.value.data(), input.value.size()));
511 candidate_bytes.value = digest;
512 ::purify::detail::secure_clear_bytes(digest.data(), digest.size());
514 FieldElement::try_from_bytes32(candidate_bytes.value);
515 if (candidate.has_value()) {
516 if (!candidate->is_zero()) {
517 out = *candidate;
518 secure_clear_field_element(*candidate);
519 return {};
520 }
521 secure_clear_field_element(*candidate);
522 }
523 }
525 "derive_secret_nonzero_scalar:exhausted");
526}
527
528FieldElement weighted_bppp_inner_product(std::span<const FieldElement> lhs,
529 std::span<const FieldElement> rhs,
530 const FieldElement &rho) {
531 assert(lhs.size() == rhs.size() &&
532 "weighted_bppp_inner_product requires matching vector lengths");
533 FieldElement mu = rho * rho;
534 FieldElement weight = mu;
535 FieldElement total = FieldElement::zero();
536 for (std::size_t i = 0; i < lhs.size(); ++i) {
537 total = total + (weight * lhs[i] * rhs[i]);
538 weight = weight * mu;
539 }
540 return total;
541}
542
543struct CircuitNormArgPublicData {
544 FieldElement rho = FieldElement::zero();
545 FieldElement mul_scale = FieldElement::zero();
546 FieldElement mul_ratio = FieldElement::zero();
547 ScalarBytes rho_bytes{};
548 FieldElement target = FieldElement::zero();
549 Bytes challenge_digest;
550 std::vector<PointBytes> generators;
551 std::vector<PointBytes> raw_generators;
552 std::vector<PointBytes> raw_generator_points;
553 std::vector<FieldElement> c_vec;
554 std::vector<ScalarBytes> c_vec_bytes;
555 std::vector<FieldElement> public_commitment_coeffs;
556 std::vector<FieldElement> plus_shift;
557 std::vector<FieldElement> minus_shift;
558 std::vector<FieldElement> plus_terms;
559 std::vector<FieldElement> minus_terms;
560 std::size_t n_vec_len = 0;
561 std::size_t used_l = 0;
562};
563
564using CircuitNormArgPublicDataPtr =
565 std::shared_ptr<const CircuitNormArgPublicData>;
566
567struct CircuitNormArgReduction {
568 CircuitNormArgPublicDataPtr public_data;
569 std::vector<FieldElement> n_vec;
570 std::vector<FieldElement> l_vec;
571};
572
573struct CircuitNormArgChallenges {
574 FieldElement rho;
575 FieldElement mul_scale;
576 FieldElement mul_ratio;
577 FieldElement row_ratio;
578};
579
580Result<PointBytes> point_scale(const PointBytes &point,
581 const FieldElement &scalar,
582 purify_secp_context *secp_context);
583Result<PointBytes> generator_scale(const PointBytes &generator,
584 const FieldElement &scalar,
585 purify_secp_context *secp_context);
586Result<PointBytes> generator_to_point(const PointBytes &generator,
587 purify_secp_context *secp_context);
589commit_norm_arg_witness_only(const NormArgInputs &inputs,
590 purify_secp_context *secp_context,
592
593Result<Bytes> circuit_norm_arg_precommit_digest(
594 std::span<const unsigned char> binding_digest,
595 const PointBytes &raw_commitment) {
596 Bytes seed(binding_digest.begin(), binding_digest.end());
597 seed.insert(seed.end(), raw_commitment.begin(), raw_commitment.end());
598 const ScalarBytes digest = kCircuitNormArgPrecommitTaggedHash.digest(seed);
599 return Bytes(digest.begin(), digest.end());
600}
601
602struct CircuitNormArgDimensions {
603 std::size_t gate_count = 0;
604 std::size_t n_vec_len = 0;
605 std::size_t l_vec_len = 0;
606 std::size_t used_l = 0;
607};
608
609Result<CircuitNormArgDimensions> circuit_norm_arg_dimensions(
610 const NativeBulletproofCircuit &circuit, bool externalize_commitments) {
611 CircuitNormArgDimensions out;
612 const std::size_t committed_values =
613 externalize_commitments ? 0 : circuit.n_commitments;
614 std::size_t minimum_gate_count = 0;
615 if (!checked_add_size(committed_values, 1, minimum_gate_count)) {
617 "circuit_norm_arg_dimensions:minimum_gate_count");
618 }
620 out.gate_count,
621 round_up_power_of_two(std::max(circuit.n_gates, minimum_gate_count),
622 "circuit_norm_arg_dimensions:gate_count"),
623 "circuit_norm_arg_dimensions:gate_count");
624 if (!checked_add_size(out.gate_count, committed_values, out.used_l)) {
626 "circuit_norm_arg_dimensions:used_l");
627 }
628 if (!checked_mul_size(out.gate_count, 2, out.n_vec_len)) {
630 "circuit_norm_arg_dimensions:n_vec_len");
631 }
632 out.l_vec_len = out.n_vec_len;
633 assert(out.used_l < out.l_vec_len &&
634 "virtual gate padding must leave a hiding coordinate");
635 return out;
636}
637
638Result<NormArgInputs> build_raw_circuit_norm_arg_inputs(
639 const NativeBulletproofCircuit &circuit,
640 const BulletproofAssignmentData &assignment,
641 std::span<const FieldElement> padding,
642 bool externalize_commitments,
643 purify_secp_context *secp_context) {
644 if (assignment.left.size() != circuit.n_gates ||
645 assignment.right.size() != circuit.n_gates ||
646 assignment.output.size() != circuit.n_gates ||
647 assignment.commitments.size() != circuit.n_commitments) {
648 return unexpected_error(
650 "build_raw_circuit_norm_arg_inputs:assignment_shape");
651 }
653 const auto &dimensions,
654 circuit_norm_arg_dimensions(circuit, externalize_commitments),
655 "build_raw_circuit_norm_arg_inputs:dimensions");
656 const std::size_t padding_size = dimensions.l_vec_len - dimensions.used_l;
657 if (!padding.empty() && padding.size() != padding_size) {
658 return unexpected_error(
660 "build_raw_circuit_norm_arg_inputs:padding_size");
661 }
662
663 std::size_t generator_count = 0;
664 if (!checked_add_size(dimensions.n_vec_len, dimensions.l_vec_len,
665 generator_count)) {
667 "build_raw_circuit_norm_arg_inputs:generator_count");
668 }
669
670 NormArgInputs out;
672 out.generators, create_generators(generator_count, secp_context),
673 "build_raw_circuit_norm_arg_inputs:create_generators");
674 std::vector<FieldElement> raw_n(dimensions.n_vec_len,
676 std::vector<FieldElement> raw_l(dimensions.l_vec_len,
678 WipeOnDestruction raw_n_wiper(raw_n);
679 WipeOnDestruction raw_l_wiper(raw_l);
680 for (std::size_t i = 0; i < circuit.n_gates; ++i) {
681 raw_n[2 * i] = assignment.left[i] + assignment.right[i];
682 raw_n[2 * i + 1] = assignment.left[i] - assignment.right[i];
683 raw_l[i] = assignment.output[i];
684 }
685 if (!externalize_commitments) {
686 for (std::size_t i = 0; i < circuit.n_commitments; ++i) {
687 raw_l[dimensions.gate_count + i] = assignment.commitments[i];
688 }
689 }
690 if (!padding.empty()) {
691 std::copy(padding.begin(), padding.end(),
692 raw_l.begin() + dimensions.used_l);
693 }
694 out.n_vec = scalar_bytes(raw_n);
695 out.l_vec = scalar_bytes(raw_l);
696 return out;
697}
698
699Result<CircuitNormArgPublicDataPtr> build_circuit_norm_arg_public_data_impl(
700 const NativeBulletproofCircuit &circuit,
701 std::span<const unsigned char> statement_binding,
702 const PointBytes *raw_commitment,
703 purify_secp_context *secp_context,
704 bool externalize_commitments = false,
705 ExperimentalCircuitBackend *cache = nullptr,
706 const CircuitNormArgChallenges *explicit_challenges = nullptr) {
707 (void)cache;
709 require_secp_context(secp_context, "build_circuit_norm_arg_public_data:secp_context"),
710 "build_circuit_norm_arg_public_data:secp_context");
711 if (!circuit.has_valid_shape()) {
713 "build_circuit_norm_arg_public_data:circuit_shape");
714 }
715 if (!is_power_of_two_size(circuit.n_gates)) {
716 return unexpected_error(
718 "build_circuit_norm_arg_public_data:n_gates_power_of_two");
719 }
720
721 Bytes challenge_digest;
722 FieldElement rho = FieldElement::zero();
723 FieldElement mul_scale = FieldElement::zero();
724 FieldElement mul_ratio = FieldElement::zero();
725 FieldElement row_ratio = FieldElement::zero();
726 if (explicit_challenges != nullptr) {
727 rho = explicit_challenges->rho;
728 mul_scale = explicit_challenges->mul_scale;
729 mul_ratio = explicit_challenges->mul_ratio;
730 row_ratio = explicit_challenges->row_ratio;
731 } else {
732 if (raw_commitment == nullptr) {
733 return unexpected_error(
735 "build_circuit_norm_arg_public_data:raw_commitment");
736 }
738 const auto &binding_digest,
739 experimental_circuit_binding_digest(circuit, statement_binding),
740 "build_circuit_norm_arg_public_data:binding_digest");
742 challenge_digest,
743 circuit_norm_arg_precommit_digest(binding_digest, *raw_commitment),
744 "build_circuit_norm_arg_public_data:challenge_digest");
746 rho,
747 derive_nonzero_scalar(challenge_digest, kCircuitNormArgRhoTaggedHash,
748 0),
749 "build_circuit_norm_arg_public_data:rho");
751 mul_scale,
752 derive_nonzero_scalar(challenge_digest, kCircuitNormArgMulTaggedHash,
753 0),
754 "build_circuit_norm_arg_public_data:mul_scale");
756 mul_ratio,
757 derive_nonzero_scalar(challenge_digest, kCircuitNormArgMulTaggedHash,
758 1),
759 "build_circuit_norm_arg_public_data:mul_ratio");
760 if (!circuit.c.empty()) {
762 row_ratio,
763 derive_nonzero_scalar(challenge_digest,
764 kCircuitNormArgConstraintTaggedHash, 0),
765 "build_circuit_norm_arg_public_data:constraint_ratio");
766 }
767 }
769 const auto &dimensions,
770 circuit_norm_arg_dimensions(circuit, externalize_commitments),
771 "build_circuit_norm_arg_public_data:dimensions");
773 const auto &sqrt_minus_one, detail::canonical_sqrt_minus_one(),
774 "build_circuit_norm_arg_public_data:sqrt_minus_one");
775
776 const FieldElement zero = FieldElement::zero();
777 const FieldElement two = FieldElement::from_int(2);
778 const FieldElement four = FieldElement::from_int(4);
779 const FieldElement inv2 = two.inverse();
780
781 std::vector<FieldElement> mul_weights(dimensions.gate_count, zero);
782 std::vector<FieldElement> plus_terms(dimensions.gate_count, zero);
783 std::vector<FieldElement> minus_terms(dimensions.gate_count, zero);
784 FieldElement mul_term = mul_scale;
785 for (std::size_t i = 0; i < dimensions.gate_count; ++i) {
786 plus_terms[i] = mul_term;
787 minus_terms[i] = sqrt_minus_one * mul_term;
788 mul_weights[i] = four * mul_term * mul_term;
789 mul_term = mul_term * mul_ratio;
790 }
791
792 std::vector<FieldElement> row_weights(circuit.c.size(), zero);
793 if (!row_weights.empty()) {
794 FieldElement row_weight = row_ratio;
795 for (FieldElement &weight : row_weights) {
796 weight = row_weight;
797 row_weight = row_weight * row_ratio;
798 }
799 }
800
801 std::vector<FieldElement> left_coeffs(dimensions.gate_count, zero);
802 std::vector<FieldElement> right_coeffs(dimensions.gate_count, zero);
803 std::vector<FieldElement> output_coeffs(dimensions.gate_count, zero);
804 std::vector<FieldElement> commitment_coeffs(circuit.n_commitments, zero);
805 for (std::size_t i = 0; i < dimensions.gate_count; ++i) {
806 output_coeffs[i] = mul_weights[i].negate();
807 }
808
809 FieldElement constant = zero;
810 for (std::size_t j = 0; j < circuit.c.size(); ++j) {
811 constant = constant - (row_weights[j] * circuit.c[j]);
812 }
813
814 auto accumulate_coeffs =
815 [&](const std::vector<NativeBulletproofCircuitRow> &rows,
816 std::vector<FieldElement> &coeffs, bool negate_entries) {
817 for (std::size_t i = 0; i < rows.size(); ++i) {
818 for (const NativeBulletproofCircuitTerm &entry : rows[i].entries) {
819 const FieldElement scalar =
820 negate_entries ? entry.scalar.negate() : entry.scalar;
821 coeffs[i] = coeffs[i] + (row_weights[entry.idx] * scalar);
822 }
823 }
824 };
825 accumulate_coeffs(circuit.wl, left_coeffs, false);
826 accumulate_coeffs(circuit.wr, right_coeffs, false);
827 accumulate_coeffs(circuit.wo, output_coeffs, false);
828 accumulate_coeffs(circuit.wv, commitment_coeffs, true);
829
830 auto out = std::make_shared<CircuitNormArgPublicData>();
831 out->rho = rho;
832 out->rho_bytes = scalar_bytes(rho);
833 out->mul_scale = mul_scale;
834 out->mul_ratio = mul_ratio;
835 out->challenge_digest = challenge_digest;
836 out->plus_terms = std::move(plus_terms);
837 out->minus_terms = std::move(minus_terms);
838 out->plus_shift.resize(dimensions.gate_count, zero);
839 out->minus_shift.resize(dimensions.gate_count, zero);
840
841 for (std::size_t i = 0; i < dimensions.gate_count; ++i) {
842 const FieldElement d_plus = out->plus_terms[i] * out->plus_terms[i];
843 const FieldElement d_minus = d_plus.negate();
844 const FieldElement e_plus = (left_coeffs[i] + right_coeffs[i]) * inv2;
845 const FieldElement e_minus = (left_coeffs[i] - right_coeffs[i]) * inv2;
846
847 out->plus_shift[i] = e_plus * (two * d_plus).inverse();
848 out->minus_shift[i] = e_minus * (two * d_minus).inverse();
849 constant = constant - ((e_plus * e_plus) * (four * d_plus).inverse());
850 constant = constant - ((e_minus * e_minus) * (four * d_minus).inverse());
851 }
852
853 out->used_l = dimensions.used_l;
854 out->n_vec_len = dimensions.n_vec_len;
855 out->c_vec.assign(dimensions.l_vec_len, zero);
856 for (std::size_t i = 0; i < dimensions.gate_count; ++i) {
857 out->c_vec[i] = output_coeffs[i];
858 }
859 if (externalize_commitments) {
860 out->public_commitment_coeffs = std::move(commitment_coeffs);
861 } else {
862 for (std::size_t i = 0; i < circuit.n_commitments; ++i) {
863 out->c_vec[dimensions.gate_count + i] = commitment_coeffs[i];
864 }
865 }
866 out->target = constant.negate();
867 out->c_vec_bytes = scalar_bytes(out->c_vec);
868
869 std::size_t raw_n_value_count = 0;
870 if (!checked_mul_size(dimensions.gate_count, 2, raw_n_value_count)) {
872 "build_circuit_norm_arg_public_data:raw_n_value_count");
873 }
874 std::size_t generator_count = 0;
875 if (!checked_add_size(out->n_vec_len, out->c_vec.size(),
876 generator_count)) {
877 return unexpected_error(
879 "build_circuit_norm_arg_public_data:generator_count");
880 }
882 auto generators, create_generators(generator_count, secp_context),
883 "build_circuit_norm_arg_public_data:create_generators");
884 out->raw_generators = generators;
885 out->generators = std::move(generators);
886 out->raw_generator_points.reserve(raw_n_value_count);
887 for (std::size_t i = 0; i < raw_n_value_count; ++i) {
889 auto point, generator_to_point(out->raw_generators[i], secp_context),
890 "build_circuit_norm_arg_public_data:generator_to_point");
891 out->raw_generator_points.push_back(point);
892 }
893
894 FieldElement rho_power = rho;
895 FieldElement generator_term = mul_scale;
896 for (std::size_t i = 0; i < out->n_vec_len; ++i) {
897 const FieldElement term =
898 (i % 2 == 0) ? generator_term : sqrt_minus_one * generator_term;
900 out->generators[i],
901 generator_scale(out->raw_generators[i],
902 rho_power * term.inverse(), secp_context),
903 "build_circuit_norm_arg_public_data:scale_generator");
904 if (i % 2 == 1) {
905 generator_term = generator_term * mul_ratio;
906 }
907 rho_power = rho_power * rho;
908 }
909 CircuitNormArgPublicDataPtr shared = out;
910 return shared;
911}
912
913Result<CircuitNormArgPublicDataPtr> build_circuit_norm_arg_public_data(
914 const NativeBulletproofCircuit &circuit,
915 std::span<const unsigned char> statement_binding,
916 const PointBytes &raw_commitment,
917 purify_secp_context *secp_context,
918 bool externalize_commitments = false,
919 ExperimentalCircuitBackend *cache = nullptr,
920 const CircuitNormArgChallenges *explicit_challenges = nullptr) {
921 return build_circuit_norm_arg_public_data_impl(
922 circuit, statement_binding, &raw_commitment, secp_context,
923 externalize_commitments, cache, explicit_challenges);
924}
925
927build_circuit_norm_arg_public_data_from_challenges(
928 const NativeBulletproofCircuit &circuit,
929 purify_secp_context *secp_context, bool externalize_commitments,
931 const CircuitNormArgChallenges &explicit_challenges) {
932 return build_circuit_norm_arg_public_data_impl(
933 circuit, {}, nullptr, secp_context, externalize_commitments, cache,
934 &explicit_challenges);
935}
936
937Result<CircuitNormArgReduction> reduce_experimental_circuit_to_norm_arg(
938 const NativeBulletproofCircuit &circuit,
939 const BulletproofAssignmentData &assignment,
940 const PointBytes &raw_commitment,
941 purify_secp_context *secp_context,
942 std::span<const unsigned char> statement_binding,
943 bool externalize_commitments = false,
944 ExperimentalCircuitBackend *cache = nullptr,
945 const CircuitNormArgChallenges *explicit_challenges = nullptr) {
946 if (assignment.left.size() != circuit.n_gates ||
947 assignment.right.size() != circuit.n_gates ||
948 assignment.output.size() != circuit.n_gates ||
949 assignment.commitments.size() != circuit.n_commitments) {
950 return unexpected_error(
952 "reduce_experimental_circuit_to_norm_arg:assignment_shape");
953 }
954
956 const auto &public_data,
957 build_circuit_norm_arg_public_data(circuit, statement_binding,
958 raw_commitment, secp_context,
959 externalize_commitments, cache,
960 explicit_challenges),
961 "reduce_experimental_circuit_to_norm_arg:public_data");
962
963 CircuitNormArgReduction out;
964 out.public_data = public_data;
965 out.n_vec.assign(out.public_data->n_vec_len, FieldElement::zero());
966 out.l_vec.assign(out.public_data->c_vec.size(), FieldElement::zero());
967
968 const FieldElement rho_inv = out.public_data->rho.inverse();
969 FieldElement rho_weight_inv = rho_inv;
970 for (std::size_t i = 0; i < circuit.n_gates; ++i) {
971 FieldElement plus_value = assignment.left[i] + assignment.right[i] +
972 out.public_data->plus_shift[i];
973 WipeOnDestruction plus_value_wiper(plus_value);
974 out.n_vec[2 * i] =
975 out.public_data->plus_terms[i] * plus_value * rho_weight_inv;
976 rho_weight_inv = rho_weight_inv * rho_inv;
977
978 FieldElement minus_value = assignment.left[i] - assignment.right[i] +
979 out.public_data->minus_shift[i];
980 WipeOnDestruction minus_value_wiper(minus_value);
981 out.n_vec[2 * i + 1] =
982 out.public_data->minus_terms[i] * minus_value * rho_weight_inv;
983 rho_weight_inv = rho_weight_inv * rho_inv;
984
985 out.l_vec[i] = assignment.output[i];
986 }
987 if (!externalize_commitments) {
988 for (std::size_t i = 0; i < circuit.n_commitments; ++i) {
989 out.l_vec[out.public_data->plus_terms.size() + i] =
990 assignment.commitments[i];
991 }
992 }
993 return out;
994}
995
996NormArgInputs build_norm_arg_inputs(const CircuitNormArgReduction &reduction) {
997 NormArgInputs inputs;
998 inputs.rho = reduction.public_data->rho_bytes;
999 inputs.generators = reduction.public_data->generators;
1000 inputs.n_vec = scalar_bytes(reduction.n_vec);
1001 inputs.l_vec = scalar_bytes(reduction.l_vec);
1002 inputs.c_vec = reduction.public_data->c_vec_bytes;
1003 return inputs;
1004}
1005
1007commit_norm_arg_witness_only(const NormArgInputs &inputs,
1008 purify_secp_context *secp_context,
1009 ExperimentalCircuitBackend *cache = nullptr) {
1011 require_secp_context(secp_context, "commit_norm_arg_witness_only:secp_context"),
1012 "commit_norm_arg_witness_only:secp_context");
1013 if (inputs.n_vec.empty() || inputs.l_vec.empty()) {
1015 "commit_norm_arg_witness_only:empty_vectors");
1016 }
1017 if (!inputs.generators.empty() &&
1018 inputs.generators.size() != inputs.n_vec.size() + inputs.l_vec.size()) {
1020 "commit_norm_arg_witness_only:generator_size");
1021 }
1022
1023 const std::vector<PointBytes> *generators = &inputs.generators;
1024 std::vector<PointBytes> generated_generators;
1025 if (generators->empty()) {
1027 auto generated, create_generators(inputs.n_vec.size() + inputs.l_vec.size(), secp_context),
1028 "commit_norm_arg_witness_only:create_generators");
1029 generated_generators = std::move(generated);
1030 generators = &generated_generators;
1031 }
1032
1033 std::span<const unsigned char> n_vec = byte_span(inputs.n_vec);
1034 std::span<const unsigned char> l_vec = byte_span(inputs.l_vec);
1035 ResolvedBpppGeneratorBackend resolved =
1036 resolve_bppp_generator_backend(cache, *generators, secp_context);
1037 PointBytes commitment{};
1038 const int ok =
1039 resolved.backend_resources != nullptr
1041 resolved.backend_resources, n_vec.data(), inputs.n_vec.size(),
1042 l_vec.data(), inputs.l_vec.size(), commitment.data())
1044 secp_context, resolved.serialized_bytes.data(),
1045 resolved.generator_count,
1046 n_vec.data(), inputs.n_vec.size(), l_vec.data(),
1047 inputs.l_vec.size(), commitment.data());
1048 if (!require_ok(ok)) {
1050 "commit_norm_arg_witness_only:backend");
1051 }
1052 return commitment;
1053}
1054
1055Result<PointBytes> offset_commitment(const PointBytes &commitment,
1056 const FieldElement &scalar,
1057 purify_secp_context *secp_context) {
1058 PointBytes out{};
1059 SecretScalarBytes scalar32;
1061 scalar32.value.data(),
1063 PURIFY_RETURN_IF_ERROR(require_secp_context(secp_context, "offset_commitment:secp_context"),
1064 "offset_commitment:secp_context");
1065 if (!require_ok(purify_bppp_offset_commitment(secp_context, commitment.data(),
1066 scalar32.value.data(),
1067 out.data()))) {
1069 "offset_commitment:backend");
1070 }
1071 return out;
1072}
1073
1074Result<PointBytes> point_scale(const PointBytes &point,
1075 const FieldElement &scalar,
1076 purify_secp_context *secp_context) {
1077 PointBytes out{};
1078 SecretScalarBytes scalar32;
1080 scalar32.value.data(),
1082 PURIFY_RETURN_IF_ERROR(require_secp_context(secp_context, "point_scale:secp_context"),
1083 "point_scale:secp_context");
1084 if (!require_ok(
1085 purify_point_scale(secp_context, point.data(),
1086 scalar32.value.data(), out.data()))) {
1088 "point_scale:backend");
1089 }
1090 return out;
1091}
1092
1093Result<PointBytes> generator_scale(const PointBytes &generator,
1094 const FieldElement &scalar,
1095 purify_secp_context *secp_context) {
1096 PointBytes out{};
1097 SecretScalarBytes scalar32;
1099 scalar32.value.data(),
1102 require_secp_context(secp_context, "generator_scale:secp_context"),
1103 "generator_scale:secp_context");
1104 if (!require_ok(purify_bppp_scale_generator(
1105 secp_context, generator.data(), scalar32.value.data(),
1106 out.data()))) {
1108 "generator_scale:backend");
1109 }
1110 return out;
1111}
1112
1113Result<PointBytes> generator_to_point(const PointBytes &generator,
1114 purify_secp_context *secp_context) {
1115 PointBytes out{};
1117 require_secp_context(secp_context, "generator_to_point:secp_context"),
1118 "generator_to_point:secp_context");
1119 if (!require_ok(purify_bppp_generator_to_point(
1120 secp_context, generator.data(), out.data()))) {
1122 "generator_to_point:backend");
1123 }
1124 return out;
1125}
1126
1127Result<PointBytes> point_add(const PointBytes &lhs,
1128 const PointBytes &rhs,
1129 purify_secp_context *secp_context) {
1130 PointBytes out{};
1131 PURIFY_RETURN_IF_ERROR(require_secp_context(secp_context, "point_add:secp_context"),
1132 "point_add:secp_context");
1133 if (!require_ok(
1134 purify_point_add(secp_context, lhs.data(), rhs.data(), out.data()))) {
1136 "point_add:backend");
1137 }
1138 return out;
1139}
1140
1141Result<PointBytes> point_add_allow_infinity(
1142 const PointBytes &lhs, const PointBytes &rhs,
1143 purify_secp_context *secp_context) {
1144 PointBytes out{};
1146 require_secp_context(secp_context,
1147 "point_add_allow_infinity:secp_context"),
1148 "point_add_allow_infinity:secp_context");
1149 if (!require_ok(purify_point_add_allow_infinity(
1150 secp_context, lhs.data(), rhs.data(), out.data()))) {
1152 "point_add_allow_infinity:backend");
1153 }
1154 return out;
1155}
1156
1157Result<PointBytes> point_subtract_allow_infinity(
1158 const PointBytes &lhs, const PointBytes &rhs,
1159 purify_secp_context *secp_context) {
1160 PointBytes out{};
1162 require_secp_context(secp_context,
1163 "point_subtract_allow_infinity:secp_context"),
1164 "point_subtract_allow_infinity:secp_context");
1166 secp_context, lhs.data(), rhs.data(), out.data()))) {
1168 "point_subtract_allow_infinity:backend");
1169 }
1170 return out;
1171}
1172
1173Result<PointBytes> point_from_scalar_base(const FieldElement &scalar,
1174 purify_secp_context *secp_context) {
1175 ScalarBytes blind{};
1176 SecretScalarBytes value;
1178 value.value.data(),
1180 return pedersen_commit_char(blind, value.value, secp_context,
1181 base_generator(secp_context),
1182 base_generator(secp_context));
1183}
1184
1185struct BatchedPublicCommitment {
1186 PointBytes point{};
1187 std::vector<FieldElement> weights;
1188};
1189
1190Result<BatchedPublicCommitment> batch_public_commitments_with_eta(
1191 std::span<const PointBytes> public_commitments,
1192 const FieldElement &eta,
1193 purify_secp_context *secp_context) {
1194 if (public_commitments.empty()) {
1196 "batch_public_commitments:empty");
1197 }
1198
1199 BatchedPublicCommitment out;
1200 out.point = public_commitments.front();
1201 out.weights.reserve(public_commitments.size());
1202 out.weights.push_back(FieldElement::one());
1203 FieldElement weight = eta;
1204 for (std::size_t i = 1; i < public_commitments.size(); ++i) {
1206 const auto &scaled,
1207 point_scale(public_commitments[i], weight, secp_context),
1208 "batch_public_commitments:scale");
1210 out.point, point_add(out.point, scaled, secp_context),
1211 "batch_public_commitments:add");
1212 out.weights.push_back(weight);
1213 weight = weight * eta;
1214 }
1215 return out;
1216}
1217
1218Result<BatchedPublicCommitment> batch_public_commitments(
1219 std::span<const PointBytes> public_commitments,
1220 std::span<const unsigned char> challenge_digest,
1221 purify_secp_context *secp_context) {
1223 const auto &eta,
1224 derive_nonzero_scalar(challenge_digest, kCircuitDlogBatchTaggedHash, 0),
1225 "batch_public_commitments:eta");
1226 return batch_public_commitments_with_eta(public_commitments, eta,
1227 secp_context);
1228}
1229
1230Result<FieldElement> dlog_challenge(
1231 std::span<const unsigned char> challenge_digest,
1232 const PointBytes &batched_commitment,
1233 const std::array<unsigned char, 32> &nonce_xonly) {
1234 Bytes seed(challenge_digest.begin(), challenge_digest.end());
1235 seed.insert(seed.end(), batched_commitment.begin(), batched_commitment.end());
1236 seed.insert(seed.end(), nonce_xonly.begin(), nonce_xonly.end());
1237 return derive_nonzero_scalar(seed, kCircuitDlogChallengeTaggedHash, 0);
1238}
1239
1240struct PublicCommitmentDlogProof {
1241 std::array<unsigned char, 32> nonce_xonly{};
1242 ScalarBytes response{};
1243};
1244
1245Result<PublicCommitmentDlogProof> prove_public_commitment_dlog(
1246 const BatchedPublicCommitment &batched,
1247 std::span<const FieldElement> commitment_values,
1248 std::span<const unsigned char> challenge_digest,
1249 const ScalarBytes &secret_prover_seed,
1250 purify_secp_context *secp_context) {
1251 if (batched.weights.size() != commitment_values.size()) {
1253 "prove_public_commitment_dlog:values");
1254 }
1255 FieldElement value = FieldElement::zero();
1256 WipeOnDestruction value_wiper(value);
1257 for (std::size_t i = 0; i < commitment_values.size(); ++i) {
1258 FieldElement term = batched.weights[i] * commitment_values[i];
1259 WipeOnDestruction term_wiper(term);
1260 FieldElement next = value + term;
1261 WipeOnDestruction next_wiper(next);
1262 value = next;
1263 }
1264
1265 SecretScalarBytes value_bytes;
1267 value_bytes.value.data(),
1269 SecretBytes nonce_seed;
1270 nonce_seed.value.reserve(secret_prover_seed.size() + value_bytes.value.size() +
1271 challenge_digest.size());
1272 nonce_seed.value.insert(nonce_seed.value.end(), secret_prover_seed.begin(),
1273 secret_prover_seed.end());
1274 nonce_seed.value.insert(nonce_seed.value.end(), value_bytes.value.begin(),
1275 value_bytes.value.end());
1276 nonce_seed.value.insert(nonce_seed.value.end(), challenge_digest.begin(),
1277 challenge_digest.end());
1278 FieldElement nonce = FieldElement::zero();
1279 WipeOnDestruction nonce_wiper(nonce);
1281 derive_secret_nonzero_scalar(nonce, nonce_seed.value,
1282 kCircuitDlogNonceTaggedHash, 0),
1283 "prove_public_commitment_dlog:nonce");
1285 const auto &nonce_point, point_from_scalar_base(nonce, secp_context),
1286 "prove_public_commitment_dlog:nonce_point");
1287
1288 PublicCommitmentDlogProof out;
1289 int parity = 0;
1291 secp_context, nonce_point.data(), out.nonce_xonly.data(), &parity) ==
1292 0) {
1294 "prove_public_commitment_dlog:nonce_xonly");
1295 }
1296 FieldElement negated_nonce = nonce.negate();
1297 WipeOnDestruction negated_nonce_wiper(negated_nonce);
1298 nonce.conditional_assign(negated_nonce, parity != 0);
1300 const auto &challenge,
1301 dlog_challenge(challenge_digest, batched.point, out.nonce_xonly),
1302 "prove_public_commitment_dlog:challenge");
1303 FieldElement challenge_value = challenge * value;
1304 WipeOnDestruction challenge_value_wiper(challenge_value);
1305 const FieldElement response = nonce + challenge_value;
1306 if (response.is_zero()) {
1308 "prove_public_commitment_dlog:zero_response");
1309 }
1310 out.response = scalar_bytes(response);
1311 return out;
1312}
1313
1314template <typename ChallengeCallback>
1315Result<PublicCommitmentDlogProof> prove_public_commitment_dlog_v4(
1316 const BatchedPublicCommitment &batched,
1317 std::span<const FieldElement> commitment_values,
1318 std::span<const unsigned char> nonce_binding,
1319 const ScalarBytes &secret_prover_seed,
1320 purify_secp_context *secp_context,
1321 ChallengeCallback &&challenge_callback) {
1322 if (batched.weights.size() != commitment_values.size()) {
1324 "prove_public_commitment_dlog_v4:values");
1325 }
1326 FieldElement value = FieldElement::zero();
1327 WipeOnDestruction value_wiper(value);
1328 for (std::size_t i = 0; i < commitment_values.size(); ++i) {
1329 FieldElement term = batched.weights[i] * commitment_values[i];
1330 WipeOnDestruction term_wiper(term);
1331 FieldElement next = value + term;
1332 WipeOnDestruction next_wiper(next);
1333 value = next;
1334 }
1335
1336 SecretScalarBytes value_bytes;
1338 value_bytes.value.data(),
1340 SecretBytes nonce_seed;
1341 nonce_seed.value.reserve(secret_prover_seed.size() +
1342 value_bytes.value.size() + nonce_binding.size());
1343 nonce_seed.value.insert(nonce_seed.value.end(), secret_prover_seed.begin(),
1344 secret_prover_seed.end());
1345 nonce_seed.value.insert(nonce_seed.value.end(), value_bytes.value.begin(),
1346 value_bytes.value.end());
1347 nonce_seed.value.insert(nonce_seed.value.end(), nonce_binding.begin(),
1348 nonce_binding.end());
1349 FieldElement nonce = FieldElement::zero();
1350 WipeOnDestruction nonce_wiper(nonce);
1352 derive_secret_nonzero_scalar(nonce, nonce_seed.value,
1353 kCircuitDlogNonceV4TaggedHash, 0),
1354 "prove_public_commitment_dlog_v4:nonce");
1356 const auto &nonce_point, point_from_scalar_base(nonce, secp_context),
1357 "prove_public_commitment_dlog_v4:nonce_point");
1358
1359 PublicCommitmentDlogProof out;
1360 int parity = 0;
1362 secp_context, nonce_point.data(), out.nonce_xonly.data(), &parity) ==
1363 0) {
1365 "prove_public_commitment_dlog_v4:nonce_xonly");
1366 }
1367 FieldElement negated_nonce = nonce.negate();
1368 WipeOnDestruction negated_nonce_wiper(negated_nonce);
1369 nonce.conditional_assign(negated_nonce, parity != 0);
1371 const auto &challenge, challenge_callback(out.nonce_xonly),
1372 "prove_public_commitment_dlog_v4:challenge");
1373 FieldElement challenge_value = challenge * value;
1374 WipeOnDestruction challenge_value_wiper(challenge_value);
1375 const FieldElement response = nonce + challenge_value;
1376 if (response.is_zero()) {
1378 "prove_public_commitment_dlog_v4:zero_response");
1379 }
1380 out.response = scalar_bytes(response);
1381 return out;
1382}
1383
1384Result<bool> verify_public_commitment_dlog(
1385 const BatchedPublicCommitment &batched,
1386 const FieldElement &challenge,
1387 const PublicCommitmentDlogProof &proof,
1388 purify_secp_context *secp_context) {
1390 const auto &response, FieldElement::try_from_bytes32(proof.response),
1391 "verify_public_commitment_dlog:response");
1392 if (response.is_zero()) {
1393 return false;
1394 }
1395 PointBytes nonce_point{};
1396 nonce_point[0] = 0x02;
1397 std::copy(proof.nonce_xonly.begin(), proof.nonce_xonly.end(),
1398 nonce_point.begin() + 1);
1400 const auto &lhs, point_from_scalar_base(response, secp_context),
1401 "verify_public_commitment_dlog:lhs");
1403 const auto &scaled_commitment,
1404 point_scale(batched.point, challenge, secp_context),
1405 "verify_public_commitment_dlog:scale_commitment");
1406 Result<PointBytes> rhs =
1407 point_add(nonce_point, scaled_commitment, secp_context);
1408 return rhs.has_value() && lhs == *rhs;
1409}
1410
1411Result<bool> verify_public_commitment_dlog(
1412 const BatchedPublicCommitment &batched,
1413 std::span<const unsigned char> challenge_digest,
1414 const PublicCommitmentDlogProof &proof,
1415 purify_secp_context *secp_context) {
1417 const auto &challenge,
1418 dlog_challenge(challenge_digest, batched.point, proof.nonce_xonly),
1419 "verify_public_commitment_dlog:challenge");
1420 return verify_public_commitment_dlog(batched, challenge, proof,
1421 secp_context);
1422}
1423
1424Result<Bytes> bind_public_commitments(
1425 std::span<const PointBytes> public_commitments,
1426 std::span<const unsigned char> statement_binding) {
1428 const auto &encoded_commitment_count,
1429 narrow_size_to_u64(public_commitments.size(),
1430 "bind_public_commitments:count"),
1431 "bind_public_commitments:count");
1433 const auto &encoded_binding_size,
1434 narrow_size_to_u64(statement_binding.size(),
1435 "bind_public_commitments:statement_binding"),
1436 "bind_public_commitments:statement_binding");
1437
1438 std::size_t point_bytes = 0;
1439 std::size_t total_size = 0;
1440 Bytes out = bytes_from_ascii(kCircuitNormArgPublicCommitmentTag);
1441 if (!checked_mul_size(public_commitments.size(), sizeof(PointBytes),
1442 point_bytes) ||
1443 !checked_add_size(out.size(), 8, total_size) ||
1444 !checked_add_size(total_size, point_bytes, total_size) ||
1445 !checked_add_size(total_size, 8, total_size) ||
1446 !checked_add_size(total_size, statement_binding.size(), total_size)) {
1448 "bind_public_commitments:reserve");
1449 }
1450 out.reserve(total_size);
1451 append_u64_le(out, encoded_commitment_count);
1452 for (const PointBytes &point : public_commitments) {
1453 out.insert(out.end(), point.begin(), point.end());
1454 }
1455 append_u64_le(out, encoded_binding_size);
1456 out.insert(out.end(), statement_binding.begin(), statement_binding.end());
1457 return out;
1458}
1459
1460Status
1461validate_public_commitments(std::span<const PointBytes> public_commitments,
1462 std::span<const FieldElement> commitments,
1463 purify_secp_context *secp_context) {
1464 if (public_commitments.size() != commitments.size()) {
1466 "validate_public_commitments:size");
1467 }
1468 for (std::size_t i = 0; i < commitments.size(); ++i) {
1470 const auto &expected, point_from_scalar_base(commitments[i], secp_context),
1471 "validate_public_commitments:point_from_scalar_base");
1472 if (expected != public_commitments[i]) {
1474 "validate_public_commitments:mismatch");
1475 }
1476 }
1477 return {};
1478}
1479
1480Result<PointBytes> add_scaled_points_allow_infinity(
1481 const PointBytes &base_commitment,
1482 std::span<const PointBytes> points,
1483 std::span<const FieldElement> scalars,
1484 purify_secp_context *secp_context) {
1485 if (points.size() != scalars.size()) {
1487 "add_scaled_points_allow_infinity:size");
1488 }
1489 PointBytes out = base_commitment;
1490 for (std::size_t i = 0; i < points.size(); ++i) {
1491 if (scalars[i].is_zero()) {
1492 continue;
1493 }
1495 const auto &scaled,
1496 point_scale(points[i], scalars[i], secp_context),
1497 "add_scaled_points_allow_infinity:scale");
1499 out, point_add_allow_infinity(out, scaled, secp_context),
1500 "add_scaled_points_allow_infinity:add");
1501 }
1502 return out;
1503}
1504
1505Result<PointBytes> circuit_anchored_offset_v4(
1506 const CircuitNormArgPublicData &public_data,
1507 std::span<const PointBytes> public_commitments,
1508 purify_secp_context *secp_context) {
1509 if (public_commitments.size() !=
1510 public_data.public_commitment_coeffs.size()) {
1512 "circuit_anchored_offset_v4:public_size");
1513 }
1514
1515 std::vector<PointBytes> points;
1516 std::vector<FieldElement> scalars;
1517 points.reserve(public_data.plus_shift.size() * 2 +
1518 public_commitments.size() + 1);
1519 scalars.reserve(points.capacity());
1520 for (std::size_t i = 0; i < public_data.plus_shift.size(); ++i) {
1521 points.push_back(public_data.raw_generator_points[2 * i]);
1522 scalars.push_back(public_data.plus_shift[i]);
1523 points.push_back(public_data.raw_generator_points[2 * i + 1]);
1524 scalars.push_back(public_data.minus_shift[i]);
1525 }
1526 if (!public_data.target.is_zero()) {
1528 auto target,
1529 point_from_scalar_base(public_data.target, secp_context),
1530 "circuit_anchored_offset_v4:target");
1531 points.push_back(std::move(target));
1532 scalars.push_back(FieldElement::one());
1533 }
1534 for (std::size_t i = 0; i < public_commitments.size(); ++i) {
1535 points.push_back(public_commitments[i]);
1536 scalars.push_back(
1537 public_data.public_commitment_coeffs[i].negate());
1538 }
1539 return add_scaled_points_allow_infinity(
1540 PointBytes{}, points, scalars, secp_context);
1541}
1542
1544anchor_zk_a_commitment(const PointBytes &a_witness_commitment,
1545 const CircuitNormArgPublicData &public_data,
1546 std::span<const PointBytes> public_commitments,
1547 purify_secp_context *secp_context) {
1549 const auto &offset,
1550 circuit_anchored_offset_v4(public_data, public_commitments,
1551 secp_context),
1552 "anchor_zk_a_commitment:offset");
1554 const auto &anchored,
1555 point_add_allow_infinity(a_witness_commitment, offset,
1556 secp_context),
1557 "anchor_zk_a_commitment:add");
1558 if (anchored == PointBytes{}) {
1560 "anchor_zk_a_commitment:identity");
1561 }
1562 return anchored;
1563}
1564
1565Result<PointBytes> coefficient_commitment_v4(
1566 const CircuitNormArgPublicData &public_data,
1567 purify_secp_context *secp_context) {
1568 const bool all_zero =
1569 std::all_of(public_data.c_vec.begin(), public_data.c_vec.end(),
1570 [](const FieldElement &value) { return value.is_zero(); });
1571 if (all_zero) {
1572 return PointBytes{};
1573 }
1574
1575 NormArgInputs inputs;
1576 inputs.generators = public_data.raw_generators;
1577 inputs.n_vec.assign(public_data.n_vec_len, ScalarBytes{});
1578 inputs.l_vec = public_data.c_vec_bytes;
1579 return commit_norm_arg_witness_only(inputs, secp_context, nullptr);
1580}
1581
1583commit_explicit_norm_arg(const NormArgInputs &inputs, const FieldElement &value,
1584 purify_secp_context *secp_context,
1585 ExperimentalCircuitBackend *cache = nullptr) {
1587 const auto &witness_commitment, commit_norm_arg_witness_only(inputs, secp_context, cache),
1588 "commit_explicit_norm_arg:witness_commitment");
1589 return offset_commitment(witness_commitment, value, secp_context);
1590}
1591
1592Result<PointBytes> combine_zk_commitments(const PointBytes &a_commitment,
1593 const PointBytes &s_commitment,
1594 const FieldElement &challenge,
1595 const FieldElement &t2,
1596 purify_secp_context *secp_context) {
1597 PURIFY_ASSIGN_OR_RETURN(const auto &scaled_s, point_scale(s_commitment, challenge, secp_context),
1598 "combine_zk_commitments:scale_s");
1599 PURIFY_ASSIGN_OR_RETURN(const auto &combined, point_add(a_commitment, scaled_s, secp_context),
1600 "combine_zk_commitments:add");
1601 return offset_commitment(combined, challenge * challenge * t2, secp_context);
1602}
1603
1604template <typename Inputs>
1606prove_norm_arg_impl(Inputs &&inputs,
1607 purify_secp_context *secp_context,
1608 ExperimentalCircuitBackend *cache = nullptr) {
1609 PURIFY_RETURN_IF_ERROR(require_secp_context(secp_context, "prove_norm_arg:secp_context"),
1610 "prove_norm_arg:secp_context");
1611 if (inputs.n_vec.empty() || inputs.l_vec.empty() || inputs.c_vec.empty()) {
1613 "prove_norm_arg:empty_vectors");
1614 }
1615 if (inputs.l_vec.size() != inputs.c_vec.size()) {
1617 "prove_norm_arg:l_c_size_mismatch");
1618 }
1619
1620 const std::vector<PointBytes> *generators = &inputs.generators;
1621 std::vector<PointBytes> generated_generators;
1622 if (generators->empty()) {
1624 auto generated, create_generators(inputs.n_vec.size() + inputs.l_vec.size(), secp_context),
1625 "prove_norm_arg:create_generators");
1626 generated_generators = std::move(generated);
1627 generators = &generated_generators;
1628 }
1629 std::span<const unsigned char> n_vec = byte_span(inputs.n_vec);
1630 std::span<const unsigned char> l_vec = byte_span(inputs.l_vec);
1631 std::span<const unsigned char> c_vec = byte_span(inputs.c_vec);
1632 ResolvedBpppGeneratorBackend resolved =
1633 resolve_bppp_generator_backend(cache, *generators, secp_context);
1634 std::size_t proof_len =
1635 purify_bppp_required_proof_size(inputs.n_vec.size(), inputs.c_vec.size());
1636 PointBytes commitment{};
1637 Bytes proof(proof_len);
1638
1639 if (proof_len == 0) {
1641 "prove_norm_arg:proof_len_zero");
1642 }
1643 const int ok =
1644 resolved.backend_resources != nullptr
1646 resolved.backend_resources, inputs.rho.data(), n_vec.data(),
1647 inputs.n_vec.size(), l_vec.data(), inputs.l_vec.size(),
1648 c_vec.data(), inputs.c_vec.size(), commitment.data(),
1649 proof.data(), &proof_len)
1651 secp_context, inputs.rho.data(), resolved.serialized_bytes.data(),
1652 resolved.generator_count, n_vec.data(), inputs.n_vec.size(),
1653 l_vec.data(), inputs.l_vec.size(), c_vec.data(),
1654 inputs.c_vec.size(), commitment.data(), proof.data(),
1655 &proof_len);
1656 if (!require_ok(ok)) {
1658 "prove_norm_arg:backend");
1659 }
1660 proof.resize(proof_len);
1661
1662 std::vector<PointBytes> proof_generators;
1663 if (!generated_generators.empty()) {
1664 proof_generators = std::move(generated_generators);
1665 } else if constexpr (!std::is_const_v<std::remove_reference_t<Inputs>> &&
1666 std::is_rvalue_reference_v<Inputs &&>) {
1667 proof_generators = std::move(inputs.generators);
1668 } else {
1669 proof_generators = inputs.generators;
1670 }
1671
1672 std::vector<ScalarBytes> proof_c_vec;
1673 if constexpr (!std::is_const_v<std::remove_reference_t<Inputs>> &&
1674 std::is_rvalue_reference_v<Inputs &&>) {
1675 proof_c_vec = std::move(inputs.c_vec);
1676 } else {
1677 proof_c_vec = inputs.c_vec;
1678 }
1679
1680 return NormArgProof{inputs.rho,
1681 std::move(proof_generators),
1682 std::move(proof_c_vec),
1683 inputs.n_vec.size(),
1684 commitment,
1685 std::move(proof)};
1686}
1687
1689derive_zk_challenge(std::span<const unsigned char> binding_digest,
1690 const PointBytes &a_commitment,
1691 const PointBytes &s_commitment, const FieldElement &t2) {
1692 Bytes seed(binding_digest.begin(), binding_digest.end());
1693 seed.insert(seed.end(), a_commitment.begin(), a_commitment.end());
1694 seed.insert(seed.end(), s_commitment.begin(), s_commitment.end());
1695 ScalarBytes t2_bytes = scalar_bytes(t2);
1696 seed.insert(seed.end(), t2_bytes.begin(), t2_bytes.end());
1697 return derive_nonzero_scalar(seed, kCircuitZkChallengeTaggedHash, 0);
1698}
1699
1700} // namespace
1701
1703 GeneratorBytes out{};
1704 bool ok = secp_context != nullptr
1705 && require_ok(purify_bppp_base_generator(secp_context, out.data()));
1706 assert(ok && "base_generator() requires a functioning backend");
1707 (void)ok;
1708 return out;
1709}
1710
1712 GeneratorBytes out{};
1713 bool ok = secp_context != nullptr
1714 && require_ok(
1715 purify_bppp_value_generator_h(secp_context, out.data()));
1716 assert(ok && "value_generator_h() requires a functioning backend");
1717 (void)ok;
1718 return out;
1719}
1720
1722 purify_secp_context *secp_context) {
1723 std::vector<PointBytes> out(count);
1724 if (count == 0) {
1725 return out;
1726 }
1727 PURIFY_RETURN_IF_ERROR(require_secp_context(secp_context, "create_generators:secp_context"),
1728 "create_generators:secp_context");
1729 std::span<unsigned char> serialized = writable_byte_span(out);
1730 std::size_t serialized_len = serialized.size();
1731 if (!require_ok(purify_bppp_create_generators(secp_context, count,
1732 serialized.data(),
1733 &serialized_len))) {
1735 "create_generators:backend");
1736 }
1737 if (serialized_len != serialized.size()) {
1739 "create_generators:serialized_len");
1740 }
1741 return out;
1742}
1743
1746 purify_secp_context *secp_context,
1747 ExperimentalCircuitBackend *cache = nullptr) {
1748 PURIFY_RETURN_IF_ERROR(require_secp_context(secp_context, "commit_norm_arg:secp_context"),
1749 "commit_norm_arg:secp_context");
1750 if (inputs.n_vec.empty() || inputs.l_vec.empty() || inputs.c_vec.empty()) {
1752 "commit_norm_arg:empty_vectors");
1753 }
1754 if (inputs.l_vec.size() != inputs.c_vec.size()) {
1756 "commit_norm_arg:l_c_size_mismatch");
1757 }
1758
1759 const std::vector<PointBytes> *generators = &inputs.generators;
1760 std::vector<PointBytes> generated_generators;
1761 if (generators->empty()) {
1763 auto generated, create_generators(inputs.n_vec.size() + inputs.l_vec.size(), secp_context),
1764 "commit_norm_arg:create_generators");
1765 generated_generators = std::move(generated);
1766 generators = &generated_generators;
1767 }
1768
1769 std::span<const unsigned char> n_vec = byte_span(inputs.n_vec);
1770 std::span<const unsigned char> l_vec = byte_span(inputs.l_vec);
1771 std::span<const unsigned char> c_vec = byte_span(inputs.c_vec);
1772 ResolvedBpppGeneratorBackend resolved =
1773 resolve_bppp_generator_backend(cache, *generators, secp_context);
1774 PointBytes commitment{};
1775 const int ok =
1776 resolved.backend_resources != nullptr
1778 resolved.backend_resources, inputs.rho.data(), n_vec.data(),
1779 inputs.n_vec.size(), l_vec.data(), inputs.l_vec.size(),
1780 c_vec.data(), inputs.c_vec.size(), commitment.data())
1782 secp_context, inputs.rho.data(), resolved.serialized_bytes.data(),
1783 resolved.generator_count, n_vec.data(), inputs.n_vec.size(),
1784 l_vec.data(), inputs.l_vec.size(), c_vec.data(),
1785 inputs.c_vec.size(), commitment.data());
1786 if (!require_ok(ok)) {
1788 "commit_norm_arg:backend");
1789 }
1790 return commitment;
1791}
1792
1794 const ScalarBytes &value,
1795 purify_secp_context *secp_context) {
1796 return pedersen_commit_char(blind, value, secp_context,
1797 value_generator_h(secp_context),
1798 base_generator(secp_context));
1799}
1800
1802 const ScalarBytes &value,
1803 purify_secp_context *secp_context,
1804 const GeneratorBytes &value_gen,
1805 const GeneratorBytes &blind_gen) {
1806 PointBytes commitment{};
1807 PURIFY_RETURN_IF_ERROR(require_secp_context(secp_context, "pedersen_commit_char:secp_context"),
1808 "pedersen_commit_char:secp_context");
1809 if (!require_ok(purify_pedersen_commit_char(
1810 secp_context, blind.data(), value.data(), value_gen.data(), blind_gen.data(),
1811 commitment.data()))) {
1813 "pedersen_commit_char:backend");
1814 }
1815 return commitment;
1816}
1817
1819 purify_secp_context *secp_context) {
1820 return prove_norm_arg_impl(inputs, secp_context, nullptr);
1821}
1822
1824 purify_secp_context *secp_context) {
1825 return prove_norm_arg_impl(std::move(inputs), secp_context, nullptr);
1826}
1827
1829 const NormArgInputs &inputs, const PointBytes &commitment,
1830 purify_secp_context *secp_context,
1831 ExperimentalCircuitBackend *cache = nullptr) {
1833 require_secp_context(secp_context, "prove_norm_arg_to_commitment:secp_context"),
1834 "prove_norm_arg_to_commitment:secp_context");
1835 if (inputs.n_vec.empty() || inputs.l_vec.empty() || inputs.c_vec.empty()) {
1837 "prove_norm_arg_to_commitment:empty_vectors");
1838 }
1839 if (inputs.l_vec.size() != inputs.c_vec.size()) {
1841 "prove_norm_arg_to_commitment:l_c_size_mismatch");
1842 }
1843
1844 const std::vector<PointBytes> *generators = &inputs.generators;
1845 std::vector<PointBytes> generated_generators;
1846 if (generators->empty()) {
1848 auto generated, create_generators(inputs.n_vec.size() + inputs.l_vec.size(), secp_context),
1849 "prove_norm_arg_to_commitment:create_generators");
1850 generated_generators = std::move(generated);
1851 generators = &generated_generators;
1852 }
1853
1854 std::span<const unsigned char> n_vec = byte_span(inputs.n_vec);
1855 std::span<const unsigned char> l_vec = byte_span(inputs.l_vec);
1856 std::span<const unsigned char> c_vec = byte_span(inputs.c_vec);
1857 ResolvedBpppGeneratorBackend resolved =
1858 resolve_bppp_generator_backend(cache, *generators, secp_context);
1859 std::size_t proof_len =
1860 purify_bppp_required_proof_size(inputs.n_vec.size(), inputs.c_vec.size());
1861 Bytes proof(proof_len);
1862 if (proof_len == 0) {
1864 "prove_norm_arg_to_commitment:proof_len_zero");
1865 }
1866 const int ok =
1867 resolved.backend_resources != nullptr
1869 resolved.backend_resources, inputs.rho.data(), n_vec.data(),
1870 inputs.n_vec.size(), l_vec.data(), inputs.l_vec.size(),
1871 c_vec.data(), inputs.c_vec.size(), commitment.data(),
1872 proof.data(), &proof_len)
1874 secp_context, inputs.rho.data(),
1875 resolved.serialized_bytes.data(),
1876 resolved.generator_count, n_vec.data(), inputs.n_vec.size(),
1877 l_vec.data(), inputs.l_vec.size(), c_vec.data(),
1878 inputs.c_vec.size(), commitment.data(), proof.data(),
1879 &proof_len);
1880 if (!require_ok(ok)) {
1882 "prove_norm_arg_to_commitment:backend");
1883 }
1884 proof.resize(proof_len);
1885
1886 std::vector<PointBytes> proof_generators;
1887 if (!generated_generators.empty()) {
1888 proof_generators = std::move(generated_generators);
1889 } else {
1890 proof_generators = inputs.generators;
1891 }
1892 return NormArgProof{inputs.rho, std::move(proof_generators),
1893 inputs.c_vec, inputs.n_vec.size(),
1894 commitment, std::move(proof)};
1895}
1896
1900 std::vector<candidate::PackedPointPairV4> rounds;
1901 std::optional<Error> error;
1902};
1903
1904int append_circuit_norm_round(void *callback_data,
1905 const unsigned char point_pair65[65],
1906 size_t round,
1907 unsigned char challenge32[32]) {
1908 auto &callback = *static_cast<CircuitNormRoundCallback *>(callback_data);
1909 if (round != callback.rounds.size()) {
1910 return 0;
1911 }
1913 std::copy_n(point_pair65, pair.size(), pair.begin());
1914 auto challenge =
1915 callback.transcript->append_round(pair, callback.secp_context);
1916 if (!challenge.has_value()) {
1917 callback.error = challenge.error();
1918 return 0;
1919 }
1920 const ScalarBytes encoded = challenge->scalar.to_bytes_be();
1921 std::copy(encoded.begin(), encoded.end(), challenge32);
1922 callback.rounds.push_back(pair);
1923 return 1;
1924}
1925
1927 const NormArgInputs &inputs, const PointBytes &commitment,
1929 purify_secp_context *secp_context) {
1930 if (inputs.n_vec.empty() || inputs.l_vec.empty() || inputs.c_vec.empty() ||
1931 inputs.l_vec.size() != inputs.c_vec.size() ||
1932 inputs.generators.size() !=
1933 inputs.n_vec.size() + inputs.l_vec.size()) {
1935 "prove_norm_arg_to_commitment_v4:inputs");
1936 }
1937 const std::size_t proof_capacity = purify_bppp_required_proof_size(
1938 inputs.n_vec.size(), inputs.c_vec.size());
1939 if (proof_capacity == 0) {
1941 "prove_norm_arg_to_commitment_v4:proof_size");
1942 }
1943
1944 Bytes proof(proof_capacity);
1945 std::size_t proof_len = proof.size();
1946 CircuitNormRoundCallback callback{&transcript, secp_context, {}, {}};
1947 const std::span<const unsigned char> generators =
1948 byte_span(inputs.generators);
1949 const std::span<const unsigned char> n_vec = byte_span(inputs.n_vec);
1950 const std::span<const unsigned char> l_vec = byte_span(inputs.l_vec);
1951 const std::span<const unsigned char> c_vec = byte_span(inputs.c_vec);
1953 secp_context, inputs.rho.data(), generators.data(),
1954 inputs.generators.size(), n_vec.data(), inputs.n_vec.size(),
1955 l_vec.data(), inputs.l_vec.size(), c_vec.data(), inputs.c_vec.size(),
1956 commitment.data(), append_circuit_norm_round, &callback, proof.data(),
1957 &proof_len);
1958 if (ok == 0) {
1959 if (callback.error.has_value()) {
1960 return unexpected_error(*callback.error,
1961 "prove_norm_arg_to_commitment_v4:transcript");
1962 }
1964 "prove_norm_arg_to_commitment_v4:backend");
1965 }
1966 if (callback.rounds.size() != transcript.shape().round_count()) {
1968 "prove_norm_arg_to_commitment_v4:rounds");
1969 }
1970 proof.resize(proof_len);
1971 return NormArgProof{inputs.rho, inputs.generators, inputs.c_vec,
1972 inputs.n_vec.size(), commitment, std::move(proof)};
1973}
1974
1976 purify_secp_context *secp_context,
1977 ExperimentalCircuitBackend *cache = nullptr) {
1978 if (secp_context == nullptr) {
1979 return false;
1980 }
1981 if (proof.n_vec_len == 0 || proof.c_vec.empty()) {
1982 return false;
1983 }
1984
1985 std::span<const unsigned char> c_vec = byte_span(proof.c_vec);
1986 ResolvedBpppGeneratorBackend resolved =
1987 resolve_bppp_generator_backend(cache, proof.generators, secp_context);
1988 const int ok =
1989 resolved.backend_resources != nullptr
1991 resolved.backend_resources, proof.rho.data(), c_vec.data(),
1992 proof.c_vec.size(), proof.n_vec_len, proof.commitment.data(),
1993 proof.proof.data(), proof.proof.size())
1995 secp_context, proof.rho.data(), resolved.serialized_bytes.data(),
1996 resolved.generator_count, c_vec.data(), proof.c_vec.size(),
1997 proof.n_vec_len, proof.commitment.data(), proof.proof.data(),
1998 proof.proof.size());
1999 return ok != 0;
2000}
2001
2003parse_norm_rounds_v4(const Bytes &proof, std::size_t round_count,
2004 ScalarBytes &terminal_n, ScalarBytes &terminal_l) {
2005 std::size_t pair_bytes = 0;
2006 std::size_t expected_size = 0;
2007 if (!checked_mul_size(round_count,
2008 sizeof(candidate::PackedPointPairV4), pair_bytes) ||
2009 !checked_add_size(pair_bytes, 2 * sizeof(ScalarBytes), expected_size) ||
2010 proof.size() != expected_size) {
2012 "parse_norm_rounds_v4:proof_size");
2013 }
2014 std::vector<candidate::PackedPointPairV4> rounds(round_count);
2015 for (std::size_t i = 0; i < rounds.size(); ++i) {
2016 std::copy_n(proof.begin() + i * rounds[i].size(), rounds[i].size(),
2017 rounds[i].begin());
2018 }
2019 std::copy_n(proof.begin() + pair_bytes, terminal_n.size(),
2020 terminal_n.begin());
2021 std::copy_n(proof.begin() + pair_bytes + terminal_n.size(),
2022 terminal_l.size(), terminal_l.begin());
2023 return rounds;
2024}
2025
2026std::vector<ScalarBytes> scalar_challenges(
2027 std::span<const candidate::CircuitChallengeV4> challenges) {
2028 std::vector<ScalarBytes> out;
2029 out.reserve(challenges.size());
2030 for (const auto &challenge : challenges) {
2031 out.push_back(challenge.scalar.to_bytes_be());
2032 }
2033 return out;
2034}
2035
2037 const NormArgProof &norm,
2038 std::span<const candidate::CircuitChallengeV4> gammas,
2039 ScalarBytes &terminal_n, ScalarBytes &terminal_l,
2040 purify_secp_context *secp_context) {
2041 const std::vector<ScalarBytes> encoded_gammas = scalar_challenges(gammas);
2042 PointBytes residual{};
2043 const std::span<const unsigned char> generators =
2044 byte_span(norm.generators);
2045 const std::span<const unsigned char> c_vec = byte_span(norm.c_vec);
2047 secp_context, norm.rho.data(), generators.data(),
2048 norm.generators.size(), c_vec.data(), norm.c_vec.size(),
2049 norm.n_vec_len, norm.commitment.data(), norm.proof.data(),
2050 norm.proof.size(),
2051 reinterpret_cast<const unsigned char *>(encoded_gammas.data()),
2052 encoded_gammas.size(), terminal_n.data(), terminal_l.data(),
2053 residual.data()) == 0) {
2055 "prepare_norm_arg_v4:backend");
2056 }
2057 return residual;
2058}
2059
2061 const NormArgProof &norm,
2062 std::span<const candidate::CircuitChallengeV4> gammas,
2063 purify_secp_context *secp_context) {
2064 const std::vector<ScalarBytes> encoded_gammas = scalar_challenges(gammas);
2065 const std::span<const unsigned char> generators =
2066 byte_span(norm.generators);
2067 const std::span<const unsigned char> c_vec = byte_span(norm.c_vec);
2069 secp_context, norm.rho.data(), generators.data(),
2070 norm.generators.size(), c_vec.data(), norm.c_vec.size(),
2071 norm.n_vec_len, norm.commitment.data(), norm.proof.data(),
2072 norm.proof.size(),
2073 reinterpret_cast<const unsigned char *>(encoded_gammas.data()),
2074 encoded_gammas.size()) != 0;
2075}
2076
2078 purify_secp_context *secp_context) {
2079 return commit_norm_arg_with_cache(inputs, secp_context, nullptr);
2080}
2081
2084 const PointBytes &commitment,
2085 purify_secp_context *secp_context) {
2086 return prove_norm_arg_to_commitment_with_cache(inputs, commitment, secp_context, nullptr);
2087}
2088
2090 purify_secp_context *secp_context) {
2091 return verify_norm_arg_with_cache(proof, secp_context, nullptr);
2092}
2093
2095 const NativeBulletproofCircuit &circuit,
2096 const BulletproofAssignmentData &assignment,
2097 purify_secp_context *secp_context,
2100 auto raw_inputs,
2101 build_raw_circuit_norm_arg_inputs(circuit, assignment, {}, false,
2102 secp_context),
2103 "commit_experimental_circuit_witness:raw_inputs");
2104 WipeOnDestruction raw_n_wiper(raw_inputs.n_vec);
2105 WipeOnDestruction raw_l_wiper(raw_inputs.l_vec);
2106 return commit_norm_arg_witness_only(raw_inputs, secp_context, cache);
2107}
2108
2111 const NativeBulletproofCircuit &circuit,
2112 const BulletproofAssignmentData &assignment,
2113 const PointBytes &witness_commitment,
2114 purify_secp_context *secp_context,
2115 std::span<const unsigned char> statement_binding,
2117 if (!circuit.has_valid_shape()) {
2118 return unexpected_error(
2120 "prove_experimental_circuit_norm_arg_to_commitment:circuit_shape");
2121 }
2122 if (!is_power_of_two_size(circuit.n_gates)) {
2124 "prove_experimental_circuit_norm_arg_to_commitment:"
2125 "n_gates_power_of_two");
2126 }
2127 if (assignment.left.size() != circuit.n_gates ||
2128 assignment.right.size() != circuit.n_gates ||
2129 assignment.output.size() != circuit.n_gates ||
2130 assignment.commitments.size() != circuit.n_commitments) {
2131 return unexpected_error(
2133 "prove_experimental_circuit_norm_arg_to_commitment:assignment_shape");
2134 }
2135 if (!circuit.evaluate(assignment)) {
2136 return unexpected_error(
2138 "prove_experimental_circuit_norm_arg_to_commitment:assignment_invalid");
2139 }
2140
2142 auto raw_inputs,
2143 build_raw_circuit_norm_arg_inputs(circuit, assignment, {}, false,
2144 secp_context),
2145 "prove_experimental_circuit_norm_arg_to_commitment:raw_inputs");
2146 WipeOnDestruction raw_n_wiper(raw_inputs.n_vec);
2147 WipeOnDestruction raw_l_wiper(raw_inputs.l_vec);
2149 const auto &computed_witness_commitment,
2150 commit_norm_arg_witness_only(raw_inputs, secp_context, cache),
2151 "prove_experimental_circuit_norm_arg_to_commitment:commit_witness");
2152 if (computed_witness_commitment != witness_commitment) {
2154 "prove_experimental_circuit_norm_arg_to_commitment:"
2155 "witness_commitment_mismatch");
2156 }
2157
2159 auto reduction,
2160 reduce_experimental_circuit_to_norm_arg(
2161 circuit, assignment, witness_commitment, secp_context,
2162 statement_binding, false, cache),
2163 "prove_experimental_circuit_norm_arg_to_commitment:reduce");
2164 WipeOnDestruction reduction_n_wiper(reduction.n_vec);
2165 WipeOnDestruction reduction_l_wiper(reduction.l_vec);
2166
2167 NormArgInputs inputs = build_norm_arg_inputs(reduction);
2168 WipeOnDestruction input_n_wiper(inputs.n_vec);
2169 WipeOnDestruction input_l_wiper(inputs.l_vec);
2170
2172 const auto &anchored_commitment,
2173 anchor_zk_a_commitment(witness_commitment, *reduction.public_data, {},
2174 secp_context),
2175 "prove_experimental_circuit_norm_arg_to_commitment:anchor");
2176
2178 auto proof,
2179 prove_norm_arg_to_commitment_with_cache(inputs, anchored_commitment,
2180 secp_context, nullptr),
2181 "prove_experimental_circuit_norm_arg_to_commitment:prove");
2182 return ExperimentalCircuitNormArgProof{witness_commitment,
2183 std::move(proof.proof)};
2184}
2185
2187 const NativeBulletproofCircuit &circuit,
2188 const BulletproofAssignmentData &assignment,
2189 purify_secp_context *secp_context,
2190 std::span<const unsigned char> statement_binding,
2193 const auto &witness_commitment,
2194 commit_experimental_circuit_witness(circuit, assignment, secp_context,
2195 cache),
2196 "prove_experimental_circuit_norm_arg:commit_witness");
2198 circuit, assignment, witness_commitment, secp_context, statement_binding, cache);
2199}
2200
2202 const NativeBulletproofCircuit &circuit,
2204 purify_secp_context *secp_context,
2205 std::span<const unsigned char> statement_binding,
2207 if (!circuit.has_valid_shape()) {
2208 return unexpected_error(
2210 "verify_experimental_circuit_norm_arg:circuit_shape");
2211 }
2212 if (!is_power_of_two_size(circuit.n_gates)) {
2213 return unexpected_error(
2215 "verify_experimental_circuit_norm_arg:n_gates_power_of_two");
2216 }
2217 if (proof.proof.empty()) {
2219 "verify_experimental_circuit_norm_arg:proof_empty");
2220 }
2221
2223 const auto &public_data,
2224 build_circuit_norm_arg_public_data(circuit, statement_binding,
2225 proof.witness_commitment, secp_context,
2226 false, cache),
2227 "verify_experimental_circuit_norm_arg:public_data");
2229 const auto &anchored_commitment,
2230 anchor_zk_a_commitment(proof.witness_commitment, *public_data, {},
2231 secp_context),
2232 "verify_experimental_circuit_norm_arg:anchor");
2233
2234 NormArgProof bundle;
2235 bundle.rho = public_data->rho_bytes;
2236 bundle.generators = public_data->generators;
2237 bundle.c_vec = public_data->c_vec_bytes;
2238 bundle.n_vec_len = public_data->n_vec_len;
2239 bundle.commitment = anchored_commitment;
2240 bundle.proof = proof.proof;
2241 return verify_norm_arg_with_cache(bundle, secp_context, nullptr);
2242}
2243
2246 const NativeBulletproofCircuit &circuit,
2247 const BulletproofAssignmentData &assignment,
2248 const ScalarBytes &secret_prover_seed,
2249 std::span<const PointBytes> public_commitments,
2250 purify_secp_context *secp_context,
2251 std::span<const unsigned char> statement_binding,
2252 bool externalize_commitments, ExperimentalCircuitBackend *cache) {
2253 if (!circuit.has_valid_shape()) {
2254 return unexpected_error(
2256 "prove_experimental_circuit_zk_norm_arg_impl:circuit_shape");
2257 }
2258 if (!is_power_of_two_size(circuit.n_gates)) {
2259 return unexpected_error(
2261 "prove_experimental_circuit_zk_norm_arg_impl:n_gates_power_of_two");
2262 }
2263 if (assignment.left.size() != circuit.n_gates ||
2264 assignment.right.size() != circuit.n_gates ||
2265 assignment.output.size() != circuit.n_gates ||
2266 assignment.commitments.size() != circuit.n_commitments) {
2267 return unexpected_error(
2269 "prove_experimental_circuit_zk_norm_arg_impl:assignment_shape");
2270 }
2271 if (externalize_commitments &&
2272 public_commitments.size() != circuit.n_commitments) {
2273 return unexpected_error(
2275 "prove_experimental_circuit_zk_norm_arg_impl:public_commitment_count");
2276 }
2277 if (!circuit.evaluate(assignment)) {
2278 return unexpected_error(
2280 "prove_experimental_circuit_zk_norm_arg_impl:assignment_invalid");
2281 }
2282
2283 Bytes bound_statement_binding;
2284 if (externalize_commitments) {
2286 bound_statement_binding,
2287 bind_public_commitments(public_commitments, statement_binding),
2288 "prove_experimental_circuit_zk_norm_arg_impl:bound_statement_binding");
2289 } else {
2290 bound_statement_binding =
2291 Bytes(statement_binding.begin(), statement_binding.end());
2292 }
2293 if (externalize_commitments) {
2294 if (public_commitments.empty()) {
2295 return unexpected_error(
2297 "prove_experimental_circuit_zk_norm_arg_impl:public_commitments");
2298 }
2300 validate_public_commitments(public_commitments, assignment.commitments, secp_context),
2301 "prove_experimental_circuit_zk_norm_arg_impl:"
2302 "validate_public_commitments");
2303 }
2304
2306 const auto &binding_digest,
2307 experimental_circuit_binding_digest(circuit, bound_statement_binding),
2308 "prove_experimental_circuit_zk_norm_arg_impl:binding_digest");
2309 SecretBytes seed;
2310 seed.value.reserve(binding_digest.size() + secret_prover_seed.size());
2311 seed.value.insert(seed.value.end(), binding_digest.begin(),
2312 binding_digest.end());
2313 seed.value.insert(seed.value.end(), secret_prover_seed.begin(),
2314 secret_prover_seed.end());
2316 const auto &dimensions,
2317 circuit_norm_arg_dimensions(circuit, externalize_commitments),
2318 "prove_experimental_circuit_zk_norm_arg_impl:dimensions");
2319 std::optional<Error> masked_failure;
2320
2321 for (std::uint64_t attempt = 0; attempt < 32; ++attempt) {
2322 std::vector<FieldElement> padding(
2323 dimensions.l_vec_len - dimensions.used_l, FieldElement::zero());
2324 WipeOnDestruction padding_wiper(padding);
2325 for (std::size_t i = 0; i < padding.size(); ++i) {
2327 derive_scalar(padding[i], seed.value, kCircuitZkBlindTaggedHash, i,
2328 attempt),
2329 "prove_experimental_circuit_zk_norm_arg_impl:blind");
2330 }
2331
2333 auto raw_inputs,
2334 build_raw_circuit_norm_arg_inputs(circuit, assignment, padding,
2335 externalize_commitments,
2336 secp_context),
2337 "prove_experimental_circuit_zk_norm_arg_impl:raw_inputs");
2338 WipeOnDestruction raw_n_wiper(raw_inputs.n_vec);
2339 WipeOnDestruction raw_l_wiper(raw_inputs.l_vec);
2340 Result<PointBytes> raw_commitment =
2341 commit_norm_arg_witness_only(raw_inputs, secp_context, cache);
2342 if (!raw_commitment.has_value()) {
2343 if (!masked_failure.has_value()) {
2344 masked_failure = unexpected_error(
2345 raw_commitment.error(),
2346 "prove_experimental_circuit_zk_norm_arg_impl:"
2347 "raw_commitment")
2348 .error();
2349 }
2350 continue;
2351 }
2352
2354 auto hidden,
2355 reduce_experimental_circuit_to_norm_arg(
2356 circuit, assignment, *raw_commitment, secp_context,
2357 bound_statement_binding, externalize_commitments, cache),
2358 "prove_experimental_circuit_zk_norm_arg_impl:reduce");
2359 WipeOnDestruction hidden_n_wiper(hidden.n_vec);
2360 WipeOnDestruction hidden_l_wiper(hidden.l_vec);
2361 std::copy(padding.begin(), padding.end(),
2362 hidden.l_vec.begin() + dimensions.used_l);
2363
2364 PublicCommitmentDlogProof dlog_proof;
2365 if (externalize_commitments) {
2366 Result<BatchedPublicCommitment> batched = batch_public_commitments(
2367 public_commitments, hidden.public_data->challenge_digest,
2368 secp_context);
2369 if (!batched.has_value()) {
2370 if (!masked_failure.has_value()) {
2371 masked_failure = unexpected_error(
2372 batched.error(),
2373 "prove_experimental_circuit_zk_norm_arg_impl:"
2374 "batch_public_commitments")
2375 .error();
2376 }
2377 continue;
2378 }
2380 prove_public_commitment_dlog(
2381 *batched, assignment.commitments,
2382 hidden.public_data->challenge_digest, secret_prover_seed,
2383 secp_context);
2384 if (!dlog.has_value()) {
2385 if (!masked_failure.has_value()) {
2386 masked_failure = unexpected_error(
2387 dlog.error(),
2388 "prove_experimental_circuit_zk_norm_arg_impl:"
2389 "prove_public_commitment_dlog")
2390 .error();
2391 }
2392 continue;
2393 }
2394 dlog_proof = *dlog;
2395 }
2396
2397 std::vector<FieldElement> mask_n(hidden.n_vec.size(), FieldElement::zero());
2398 WipeOnDestruction mask_n_wiper(mask_n);
2399 for (std::size_t i = 0; i < mask_n.size(); ++i) {
2401 derive_scalar(mask_n[i], seed.value, kCircuitZkMaskNTaggedHash, i,
2402 attempt),
2403 "prove_experimental_circuit_zk_norm_arg_impl:mask_n");
2404 }
2405
2406 std::vector<FieldElement> mask_l(hidden.l_vec.size(), FieldElement::zero());
2407 WipeOnDestruction mask_l_wiper(mask_l);
2408 for (std::size_t i = 0; i < mask_l.size(); ++i) {
2410 derive_scalar(mask_l[i], seed.value, kCircuitZkMaskLTaggedHash, i,
2411 attempt),
2412 "prove_experimental_circuit_zk_norm_arg_impl:mask_l");
2413 }
2414
2415 FieldElement t2 =
2416 weighted_bppp_inner_product(mask_n, mask_n, hidden.public_data->rho);
2417 WipeOnDestruction t2_wiper(t2);
2418 if (t2.is_zero()) {
2419 continue;
2420 }
2422 weighted_bppp_inner_product(hidden.n_vec, mask_n,
2423 hidden.public_data->rho);
2424 WipeOnDestruction t1_wiper(t1);
2425 for (std::size_t i = 0; i < mask_l.size(); ++i) {
2426 t1 = t1 + (mask_l[i] * hidden.public_data->c_vec[i]);
2427 }
2428
2429 NormArgInputs mask_inputs;
2430 mask_inputs.rho = hidden.public_data->rho_bytes;
2431 mask_inputs.generators = hidden.public_data->generators;
2432 mask_inputs.n_vec = scalar_bytes(mask_n);
2433 mask_inputs.l_vec = scalar_bytes(mask_l);
2434 mask_inputs.c_vec = hidden.public_data->c_vec_bytes;
2435 WipeOnDestruction mask_input_n_wiper(mask_inputs.n_vec);
2436 WipeOnDestruction mask_input_l_wiper(mask_inputs.l_vec);
2437
2438 Result<PointBytes> a_commitment = anchor_zk_a_commitment(
2439 *raw_commitment, *hidden.public_data, public_commitments, secp_context);
2440 if (!a_commitment.has_value()) {
2441 if (!masked_failure.has_value()) {
2442 masked_failure =
2444 a_commitment.error(),
2445 "prove_experimental_circuit_zk_norm_arg_impl:a_commitment")
2446 .error();
2447 }
2448 continue;
2449 }
2450 Result<PointBytes> s_commitment =
2451 commit_explicit_norm_arg(mask_inputs, t1, secp_context, nullptr);
2452 if (!s_commitment.has_value()) {
2453 if (!masked_failure.has_value()) {
2454 masked_failure =
2456 s_commitment.error(),
2457 "prove_experimental_circuit_zk_norm_arg_impl:s_commitment")
2458 .error();
2459 }
2460 continue;
2461 }
2463 const auto &challenge,
2464 derive_zk_challenge(hidden.public_data->challenge_digest,
2465 *a_commitment, *s_commitment, t2),
2466 "prove_experimental_circuit_zk_norm_arg_impl:challenge");
2467
2468 CircuitNormArgReduction masked = hidden;
2469 WipeOnDestruction masked_n_wiper(masked.n_vec);
2470 WipeOnDestruction masked_l_wiper(masked.l_vec);
2471 for (std::size_t i = 0; i < masked.n_vec.size(); ++i) {
2472 masked.n_vec[i] = masked.n_vec[i] + (challenge * mask_n[i]);
2473 }
2474 for (std::size_t i = 0; i < masked.l_vec.size(); ++i) {
2475 masked.l_vec[i] = masked.l_vec[i] + (challenge * mask_l[i]);
2476 }
2477 NormArgInputs masked_inputs = build_norm_arg_inputs(masked);
2478 WipeOnDestruction masked_input_n_wiper(masked_inputs.n_vec);
2479 WipeOnDestruction masked_input_l_wiper(masked_inputs.l_vec);
2480
2481 Result<PointBytes> combined_commitment =
2482 combine_zk_commitments(*a_commitment, *s_commitment, challenge, t2, secp_context);
2483 if (!combined_commitment.has_value()) {
2484 if (!masked_failure.has_value()) {
2485 masked_failure = unexpected_error(combined_commitment.error(),
2486 "prove_experimental_circuit_zk_norm_"
2487 "arg_impl:combined_commitment")
2488 .error();
2489 }
2490 continue;
2491 }
2492 Result<PointBytes> direct_commitment =
2493 commit_norm_arg_with_cache(masked_inputs, secp_context, nullptr);
2494 if (!direct_commitment.has_value()) {
2495 if (!masked_failure.has_value()) {
2496 masked_failure =
2498 direct_commitment.error(),
2499 "prove_experimental_circuit_zk_norm_arg_impl:direct_commitment")
2500 .error();
2501 }
2502 continue;
2503 }
2504 if (*combined_commitment != *direct_commitment) {
2505 return unexpected_error(
2507 "prove_experimental_circuit_zk_norm_arg_impl:commitment_mismatch");
2508 }
2509
2511 masked_inputs, *combined_commitment, secp_context, nullptr);
2512 if (!proof.has_value()) {
2513 if (!masked_failure.has_value()) {
2514 masked_failure =
2515 unexpected_error(proof.error(),
2516 "prove_experimental_circuit_zk_norm_arg_impl:"
2517 "prove_norm_arg_to_commitment")
2518 .error();
2519 }
2520 continue;
2521 }
2523 *raw_commitment,
2524 *s_commitment,
2525 scalar_bytes(t2),
2526 dlog_proof.nonce_xonly,
2527 dlog_proof.response,
2528 std::move(proof->proof)};
2529 }
2530
2531 if (masked_failure.has_value()) {
2532 return unexpected_error(
2533 *masked_failure,
2534 "prove_experimental_circuit_zk_norm_arg_impl:masking_attempts");
2535 }
2536 return unexpected_error(
2538 "prove_experimental_circuit_zk_norm_arg_impl:masking_attempts");
2539}
2540
2541namespace {
2542
2543Status validate_prepared_circuit_proof(
2544 const NativeBulletproofCircuit &circuit,
2545 const ExperimentalCircuitZkNormArgProof &proof) {
2546 if (!circuit.has_valid_shape()) {
2547 return unexpected_error(
2549 "prepare_experimental_circuit_zk_norm_arg:circuit_shape");
2550 }
2551 if (!is_power_of_two_size(circuit.n_gates)) {
2552 return unexpected_error(
2554 "prepare_experimental_circuit_zk_norm_arg:n_gates_power_of_two");
2555 }
2556 if (proof.proof.empty()) {
2557 return unexpected_error(
2559 "prepare_experimental_circuit_zk_norm_arg:proof_empty");
2560 }
2561 return {};
2562}
2563
2564bool has_zero_public_commitment_dlog(
2565 const ExperimentalCircuitZkNormArgProof &proof) {
2566 const auto all_zero = [](const auto &bytes) {
2567 return std::all_of(bytes.begin(), bytes.end(),
2568 [](unsigned char byte) { return byte == 0; });
2569 };
2570 return all_zero(proof.public_commitment_dlog_nonce) &&
2571 all_zero(proof.public_commitment_dlog_response);
2572}
2573
2575finish_prepared_circuit_proof(
2577 const CircuitNormArgPublicDataPtr &public_data,
2578 std::span<const PointBytes> public_commitments,
2579 purify_secp_context *secp_context) {
2581 const auto &t2, FieldElement::try_from_bytes32(proof.t2),
2582 "prepare_experimental_circuit_zk_norm_arg:t2");
2584 const auto &a_commitment,
2585 anchor_zk_a_commitment(proof.a_commitment, *public_data,
2586 public_commitments, secp_context),
2587 "prepare_experimental_circuit_zk_norm_arg:a_commitment");
2589 const auto &challenge,
2590 derive_zk_challenge(public_data->challenge_digest, a_commitment,
2591 proof.s_commitment, t2),
2592 "prepare_experimental_circuit_zk_norm_arg:challenge");
2594 const auto &commitment,
2595 combine_zk_commitments(a_commitment, proof.s_commitment, challenge, t2,
2596 secp_context),
2597 "prepare_experimental_circuit_zk_norm_arg:commitment");
2598
2600 out.norm.rho = public_data->rho_bytes;
2601 out.norm.generators = public_data->generators;
2602 out.norm.c_vec = public_data->c_vec_bytes;
2603 out.norm.n_vec_len = public_data->n_vec_len;
2604 out.norm.commitment = commitment;
2605 out.norm.proof = proof.proof;
2606 out.raw_generator_digest =
2607 generator_backend_cache_key(public_data->raw_generators);
2608 assert(public_data->challenge_digest.size() ==
2609 out.challenge_digest.size());
2610 std::copy(public_data->challenge_digest.begin(),
2611 public_data->challenge_digest.end(),
2612 out.challenge_digest.begin());
2613 out.mul_scale = public_data->mul_scale;
2614 out.mul_ratio = public_data->mul_ratio;
2615 return out;
2616}
2617
2618} // namespace
2619
2622 const NativeBulletproofCircuit &circuit,
2624 std::span<const PointBytes> public_commitments,
2625 purify_secp_context *secp_context,
2626 std::span<const unsigned char> statement_binding,
2628 PURIFY_RETURN_IF_ERROR(validate_prepared_circuit_proof(circuit, proof),
2629 "prepare_experimental_circuit_zk_norm_arg:validate");
2630 if (public_commitments.empty()) {
2631 return unexpected_error(
2633 "prepare_experimental_circuit_zk_norm_arg:public_commitments");
2634 }
2635 if (public_commitments.size() != circuit.n_commitments) {
2636 return unexpected_error(
2638 "prepare_experimental_circuit_zk_norm_arg:public_commitment_count");
2639 }
2641 const auto &bound_statement_binding,
2642 bind_public_commitments(public_commitments, statement_binding),
2643 "prepare_experimental_circuit_zk_norm_arg:bound_statement_binding");
2645 const auto &public_data,
2646 build_circuit_norm_arg_public_data(
2647 circuit, bound_statement_binding, proof.a_commitment, secp_context,
2648 true, cache),
2649 "prepare_experimental_circuit_zk_norm_arg:public_data");
2651 const auto &batched,
2652 batch_public_commitments(public_commitments,
2653 public_data->challenge_digest, secp_context),
2654 "prepare_experimental_circuit_zk_norm_arg:batch_public_commitments");
2655 const PublicCommitmentDlogProof dlog_proof{
2659 const auto &dlog_ok,
2660 verify_public_commitment_dlog(
2661 batched, public_data->challenge_digest, dlog_proof,
2662 secp_context),
2663 "prepare_experimental_circuit_zk_norm_arg:verify_public_commitment_dlog");
2664 if (!dlog_ok) {
2665 return std::optional<PreparedExperimentalCircuitZkNormArg>{};
2666 }
2668 auto out,
2669 finish_prepared_circuit_proof(proof, public_data, public_commitments,
2670 secp_context),
2671 "prepare_experimental_circuit_zk_norm_arg:finish");
2672 return std::optional<PreparedExperimentalCircuitZkNormArg>(std::move(out));
2673}
2674
2677 const NativeBulletproofCircuit &circuit,
2679 purify_secp_context *secp_context,
2680 std::span<const unsigned char> statement_binding,
2682 PURIFY_RETURN_IF_ERROR(validate_prepared_circuit_proof(circuit, proof),
2683 "prepare_experimental_circuit_zk_norm_arg:validate");
2684
2685 const Bytes bound_statement_binding(statement_binding.begin(),
2686 statement_binding.end());
2688 const auto &public_data,
2689 build_circuit_norm_arg_public_data(
2690 circuit, bound_statement_binding, proof.a_commitment, secp_context,
2691 false, cache),
2692 "prepare_experimental_circuit_zk_norm_arg:public_data");
2693 if (!has_zero_public_commitment_dlog(proof)) {
2694 return std::optional<PreparedExperimentalCircuitZkNormArg>{};
2695 }
2697 auto out,
2698 finish_prepared_circuit_proof(proof, public_data, {}, secp_context),
2699 "prepare_experimental_circuit_zk_norm_arg:finish");
2700 return std::optional<PreparedExperimentalCircuitZkNormArg>(std::move(out));
2701}
2702
2704 const NativeBulletproofCircuit &circuit,
2706 purify_secp_context *secp_context,
2707 std::span<const unsigned char> statement_binding,
2710 auto prepared,
2712 circuit, proof, secp_context, statement_binding, cache),
2713 "verify_experimental_circuit_zk_norm_arg_impl:prepare");
2714 if (!prepared.has_value()) {
2715 return false;
2716 }
2717 return verify_norm_arg_with_cache(prepared->norm, secp_context, nullptr);
2718}
2719
2720namespace {
2721
2723 const NativeBulletproofCircuit &circuit, bool externalize_commitments) {
2725 const auto &dimensions,
2726 circuit_norm_arg_dimensions(circuit, externalize_commitments),
2727 "circuit_shape_v4:dimensions");
2728 const auto mode = externalize_commitments
2732 mode, dimensions.gate_count, circuit.n_commitments,
2733 dimensions.n_vec_len, dimensions.l_vec_len);
2734}
2735
2736Result<candidate::TranscriptDigest> circuit_binding_digest_v4(
2737 const NativeBulletproofCircuit &circuit,
2738 std::span<const unsigned char> statement_binding) {
2740 const auto &digest,
2741 experimental_circuit_binding_digest(circuit, statement_binding),
2742 "circuit_binding_digest_v4:digest");
2744 if (digest.size() != out.size()) {
2746 "circuit_binding_digest_v4:size");
2747 }
2748 std::copy(digest.begin(), digest.end(), out.begin());
2749 return out;
2750}
2751
2752Result<candidate::TranscriptDigest> raw_generator_digest_v4(
2754 purify_secp_context *secp_context) {
2755 std::size_t generator_count = 0;
2756 if (!checked_add_size(shape.n_vec_len(), shape.l_vec_len(),
2757 generator_count)) {
2759 "raw_generator_digest_v4:generator_count");
2760 }
2762 const auto &generators, create_generators(generator_count, secp_context),
2763 "raw_generator_digest_v4:generators");
2764 return generator_backend_cache_key(generators);
2765}
2766
2767bool is_identity_point_v4(const PointBytes &point) {
2768 return std::all_of(point.begin(), point.end(),
2769 [](unsigned char byte) { return byte == 0; });
2770}
2771
2772Status validate_circuit_proof_v4_inputs(
2773 const NativeBulletproofCircuit &circuit,
2774 std::span<const PointBytes> public_commitments,
2775 purify_secp_context *secp_context, bool externalize_commitments) {
2777 "circuit_proof_v4:context"),
2778 "circuit_proof_v4:context");
2779 if (!circuit.has_valid_shape() ||
2780 !is_power_of_two_size(circuit.n_gates)) {
2782 "circuit_proof_v4:circuit_shape");
2783 }
2784 if (externalize_commitments) {
2785 if (public_commitments.empty() ||
2786 public_commitments.size() != circuit.n_commitments) {
2788 "circuit_proof_v4:public_commitments");
2789 }
2790 if (std::any_of(public_commitments.begin(), public_commitments.end(),
2791 is_identity_point_v4)) {
2793 "circuit_proof_v4:identity_public_commitment");
2794 }
2795 } else if (!public_commitments.empty()) {
2797 "circuit_proof_v4:hidden_commitments");
2798 }
2799 return {};
2800}
2801
2802Status validate_finite_point_v4(const PointBytes &point,
2803 purify_secp_context *secp_context,
2804 const char *label) {
2805 std::array<unsigned char, 32> xonly{};
2806 int parity = 0;
2808 secp_context, point.data(), xonly.data(), &parity) == 0) {
2810 }
2811 return {};
2812}
2813
2814Status validate_circuit_zk_norm_arg_proof_v4_fixed_encoding_impl(
2816 candidate::CircuitCommitmentModeV4 mode, std::size_t round_count,
2817 purify_secp_context *secp_context) {
2819 require_secp_context(secp_context,
2820 "circuit_proof_v4_encoding:context"),
2821 "circuit_proof_v4_encoding:context");
2823 validate_finite_point_v4(proof.raw_commitment, secp_context,
2824 "circuit_proof_v4_encoding:raw"),
2825 "circuit_proof_v4_encoding:raw");
2827 validate_finite_point_v4(proof.mask_commitment, secp_context,
2828 "circuit_proof_v4_encoding:mask"),
2829 "circuit_proof_v4_encoding:mask");
2831 const auto t2, FieldElement::try_from_bytes32(proof.t2),
2832 "circuit_proof_v4_encoding:t2");
2833 (void)t2;
2834
2837 secp_context,
2838 proof.public_commitment_dlog_nonce.data()) == 0) {
2839 return unexpected_error(
2841 "circuit_proof_v4_encoding:dlog_nonce");
2842 }
2844 const auto response,
2846 proof.public_commitment_dlog_response),
2847 "circuit_proof_v4_encoding:dlog_response");
2848 if (response.is_zero()) {
2849 return unexpected_error(
2851 "circuit_proof_v4_encoding:dlog_response");
2852 }
2853 } else if (mode != candidate::CircuitCommitmentModeV4::Hidden) {
2855 "circuit_proof_v4_encoding:mode");
2856 } else if (!std::all_of(
2857 proof.public_commitment_dlog_nonce.begin(),
2858 proof.public_commitment_dlog_nonce.end(),
2859 [](unsigned char byte) { return byte == 0; }) ||
2860 !std::all_of(
2861 proof.public_commitment_dlog_response.begin(),
2862 proof.public_commitment_dlog_response.end(),
2863 [](unsigned char byte) { return byte == 0; })) {
2865 "circuit_proof_v4_encoding:hidden_dlog");
2866 }
2867
2868 ScalarBytes terminal_n{};
2869 ScalarBytes terminal_l{};
2871 const auto rounds,
2872 parse_norm_rounds_v4(proof.norm_proof, round_count,
2873 terminal_n, terminal_l),
2874 "circuit_proof_v4_encoding:rounds");
2875 for (const auto &round : rounds) {
2877 candidate::validate_packed_point_pair_v4(round, secp_context),
2878 "circuit_proof_v4_encoding:round");
2879 }
2881 const auto terminal_n_scalar,
2883 "circuit_proof_v4_encoding:terminal_n");
2885 const auto terminal_l_scalar,
2887 "circuit_proof_v4_encoding:terminal_l");
2888 (void)terminal_n_scalar;
2889 (void)terminal_l_scalar;
2890 return {};
2891}
2892
2893Status validate_circuit_zk_norm_arg_proof_v4_encoding_impl(
2894 const NativeBulletproofCircuit &circuit,
2896 std::span<const PointBytes> public_commitments,
2897 purify_secp_context *secp_context, bool externalize_commitments) {
2899 validate_circuit_proof_v4_inputs(
2900 circuit, public_commitments, secp_context,
2901 externalize_commitments),
2902 "circuit_proof_v4_encoding:inputs");
2904 const auto shape,
2905 circuit_shape_v4(circuit, externalize_commitments),
2906 "circuit_proof_v4_encoding:shape");
2907 return validate_circuit_zk_norm_arg_proof_v4_fixed_encoding_impl(
2908 proof, shape.mode(), shape.round_count(), secp_context);
2909}
2910
2912reconstruct_circuit_zk_norm_arg_publication_v4_impl(
2913 const NativeBulletproofCircuit &circuit,
2915 std::span<const PointBytes> public_commitments,
2916 purify_secp_context *secp_context,
2917 std::span<const unsigned char> statement_binding,
2918 bool externalize_commitments) {
2920 validate_circuit_zk_norm_arg_proof_v4_encoding_impl(
2921 circuit, proof, public_commitments, secp_context,
2922 externalize_commitments),
2923 "reconstruct_circuit_proof_v4:encoding");
2925 const auto shape,
2926 circuit_shape_v4(circuit, externalize_commitments),
2927 "reconstruct_circuit_proof_v4:shape");
2929 const auto binding_digest,
2930 circuit_binding_digest_v4(circuit, statement_binding),
2931 "reconstruct_circuit_proof_v4:binding");
2933 auto precommitment,
2935 shape, binding_digest, public_commitments,
2936 proof.raw_commitment, secp_context),
2937 "reconstruct_circuit_proof_v4:precommitment");
2939 std::move(precommitment.digest), std::move(proof)};
2940}
2941
2943prove_circuit_zk_norm_arg_v4_impl(
2944 const NativeBulletproofCircuit &circuit,
2945 const BulletproofAssignmentData &assignment,
2946 const ScalarBytes &secret_prover_seed,
2947 std::span<const PointBytes> public_commitments,
2948 purify_secp_context *secp_context,
2949 std::span<const unsigned char> statement_binding,
2950 bool externalize_commitments, ExperimentalCircuitBackend *cache) {
2952 validate_circuit_proof_v4_inputs(circuit, public_commitments,
2953 secp_context,
2954 externalize_commitments),
2955 "prove_circuit_zk_norm_arg_v4:inputs");
2956 if (assignment.left.size() != circuit.n_gates ||
2957 assignment.right.size() != circuit.n_gates ||
2958 assignment.output.size() != circuit.n_gates ||
2959 assignment.commitments.size() != circuit.n_commitments) {
2961 "prove_circuit_zk_norm_arg_v4:assignment_shape");
2962 }
2963 if (!circuit.evaluate(assignment)) {
2965 "prove_circuit_zk_norm_arg_v4:assignment");
2966 }
2967 if (externalize_commitments) {
2969 validate_public_commitments(public_commitments,
2970 assignment.commitments, secp_context),
2971 "prove_circuit_zk_norm_arg_v4:public_values");
2972 }
2973
2975 const auto &binding_digest,
2976 circuit_binding_digest_v4(circuit, statement_binding),
2977 "prove_circuit_zk_norm_arg_v4:binding_digest");
2979 const auto &dimensions,
2980 circuit_norm_arg_dimensions(circuit, externalize_commitments),
2981 "prove_circuit_zk_norm_arg_v4:dimensions");
2983 const auto shape, circuit_shape_v4(circuit, externalize_commitments),
2984 "prove_circuit_zk_norm_arg_v4:shape");
2985
2986 std::size_t public_point_bytes = 0;
2987 std::size_t assignment_scalar_count = 0;
2988 std::size_t assignment_bytes = 0;
2989 std::size_t seed_prefix_size = 0;
2990 std::size_t seed_size = 0;
2991 if (!checked_mul_size(public_commitments.size(), sizeof(PointBytes),
2992 public_point_bytes) ||
2993 !checked_add_size(assignment.left.size(), assignment.right.size(),
2994 assignment_scalar_count) ||
2995 !checked_add_size(assignment_scalar_count, assignment.output.size(),
2996 assignment_scalar_count) ||
2997 !checked_add_size(assignment_scalar_count,
2998 assignment.commitments.size(),
2999 assignment_scalar_count) ||
3000 !checked_mul_size(assignment_scalar_count, sizeof(ScalarBytes),
3001 assignment_bytes) ||
3002 !checked_add_size(assignment_bytes, 4 * sizeof(std::uint64_t),
3003 assignment_bytes) ||
3004 !checked_add_size(binding_digest.size(), secret_prover_seed.size(),
3005 seed_prefix_size) ||
3006 !checked_add_size(seed_prefix_size, 1, seed_prefix_size) ||
3007 !checked_add_size(seed_prefix_size, public_point_bytes, seed_size) ||
3008 !checked_add_size(seed_size, assignment_bytes, seed_size)) {
3010 "prove_circuit_zk_norm_arg_v4:seed_size");
3011 }
3012 SecretBytes seed;
3013 seed.value.reserve(seed_size);
3014 seed.value.insert(seed.value.end(), binding_digest.begin(),
3015 binding_digest.end());
3016 seed.value.insert(seed.value.end(), secret_prover_seed.begin(),
3017 secret_prover_seed.end());
3018 seed.value.push_back(externalize_commitments ? 1 : 0);
3019 for (const auto &point : public_commitments) {
3020 seed.value.insert(seed.value.end(), point.begin(), point.end());
3021 }
3022 const auto append_assignment_values =
3023 [&](std::span<const FieldElement> values) -> Status {
3025 const auto &count,
3026 narrow_size_to_u64(values.size(),
3027 "prove_circuit_zk_norm_arg_v4:assignment_count"),
3028 "prove_circuit_zk_norm_arg_v4:assignment_count");
3029 append_u64_le(seed.value, count);
3030 for (const auto &value : values) {
3031 SecretScalarBytes encoded;
3033 encoded.value.data(),
3035 seed.value.insert(seed.value.end(), encoded.value.begin(),
3036 encoded.value.end());
3037 }
3038 return {};
3039 };
3040 PURIFY_RETURN_IF_ERROR(append_assignment_values(assignment.left),
3041 "prove_circuit_zk_norm_arg_v4:left_seed");
3042 PURIFY_RETURN_IF_ERROR(append_assignment_values(assignment.right),
3043 "prove_circuit_zk_norm_arg_v4:right_seed");
3044 PURIFY_RETURN_IF_ERROR(append_assignment_values(assignment.output),
3045 "prove_circuit_zk_norm_arg_v4:output_seed");
3046 PURIFY_RETURN_IF_ERROR(append_assignment_values(assignment.commitments),
3047 "prove_circuit_zk_norm_arg_v4:commitment_seed");
3048 assert(seed.value.size() == seed_size);
3049
3050 std::optional<Error> masked_failure;
3051 for (std::uint64_t attempt = 0; attempt < 32; ++attempt) {
3052 std::vector<FieldElement> padding(
3053 dimensions.l_vec_len - dimensions.used_l, FieldElement::zero());
3054 WipeOnDestruction padding_wiper(padding);
3055 for (std::size_t i = 0; i < padding.size(); ++i) {
3057 derive_scalar(padding[i], seed.value, kCircuitZkBlindV4TaggedHash,
3058 i, attempt),
3059 "prove_circuit_zk_norm_arg_v4:blind");
3060 }
3061
3063 auto raw_inputs,
3064 build_raw_circuit_norm_arg_inputs(circuit, assignment, padding,
3065 externalize_commitments,
3066 secp_context),
3067 "prove_circuit_zk_norm_arg_v4:raw_inputs");
3068 WipeOnDestruction raw_n_wiper(raw_inputs.n_vec);
3069 WipeOnDestruction raw_l_wiper(raw_inputs.l_vec);
3070 auto raw_commitment =
3071 commit_norm_arg_witness_only(raw_inputs, secp_context, cache);
3072 if (!raw_commitment.has_value()) {
3073 if (!masked_failure.has_value()) masked_failure = raw_commitment.error();
3074 continue;
3075 }
3076
3078 const auto precommitment,
3080 shape, binding_digest, public_commitments, *raw_commitment,
3081 secp_context),
3082 "prove_circuit_zk_norm_arg_v4:precommitment");
3083 const candidate::TranscriptDigest raw_generator_digest =
3084 generator_backend_cache_key(raw_inputs.generators);
3086 auto transcript,
3088 shape, precommitment.digest, raw_generator_digest),
3089 "prove_circuit_zk_norm_arg_v4:transcript");
3090 const CircuitNormArgChallenges challenges{
3091 transcript.rho().scalar, transcript.mul_scale().scalar,
3092 transcript.mul_ratio().scalar, transcript.row_ratio().scalar};
3094 auto hidden,
3095 reduce_experimental_circuit_to_norm_arg(
3096 circuit, assignment, *raw_commitment, secp_context,
3097 statement_binding, externalize_commitments, cache, &challenges),
3098 "prove_circuit_zk_norm_arg_v4:reduce");
3099 if (generator_backend_cache_key(hidden.public_data->raw_generators) !=
3100 raw_generator_digest) {
3102 "prove_circuit_zk_norm_arg_v4:raw_basis");
3103 }
3104 WipeOnDestruction hidden_n_wiper(hidden.n_vec);
3105 WipeOnDestruction hidden_l_wiper(hidden.l_vec);
3106 std::copy(padding.begin(), padding.end(),
3107 hidden.l_vec.begin() + dimensions.used_l);
3108
3110 const auto &anchored_commitment,
3111 anchor_zk_a_commitment(*raw_commitment, *hidden.public_data,
3112 public_commitments, secp_context),
3113 "prove_circuit_zk_norm_arg_v4:anchored_commitment");
3115 const auto &anchored_offset,
3116 point_subtract_allow_infinity(anchored_commitment, *raw_commitment,
3117 secp_context),
3118 "prove_circuit_zk_norm_arg_v4:anchored_offset");
3120 const auto &coefficient_commitment,
3121 coefficient_commitment_v4(*hidden.public_data, secp_context),
3122 "prove_circuit_zk_norm_arg_v4:coefficient_commitment");
3124 const auto &eta,
3125 transcript.append_anchored_commitments(
3126 coefficient_commitment, anchored_offset, anchored_commitment,
3127 secp_context),
3128 "prove_circuit_zk_norm_arg_v4:eta");
3129
3130 PublicCommitmentDlogProof dlog_proof;
3131 if (externalize_commitments) {
3133 const auto &batched,
3134 batch_public_commitments_with_eta(public_commitments, eta.scalar,
3135 secp_context),
3136 "prove_circuit_zk_norm_arg_v4:batch_public");
3137 const ScalarBytes nonce_binding = precommitment.digest.bytes();
3138 auto dlog = prove_public_commitment_dlog_v4(
3139 batched, assignment.commitments, nonce_binding,
3140 secret_prover_seed, secp_context,
3141 [&](const std::array<unsigned char, 32> &nonce)
3143 auto challenge = transcript.append_public_opening(
3144 batched.point, nonce, secp_context);
3145 if (!challenge.has_value()) {
3146 return unexpected_error(
3147 challenge.error(),
3148 "prove_circuit_zk_norm_arg_v4:dlog_e");
3149 }
3150 return challenge->scalar;
3151 });
3152 if (!dlog.has_value()) {
3153 if (!masked_failure.has_value()) masked_failure = dlog.error();
3154 continue;
3155 }
3156 dlog_proof = *dlog;
3157 } else {
3159 const auto ignored,
3160 transcript.append_public_opening(
3161 PointBytes{}, dlog_proof.nonce_xonly, secp_context),
3162 "prove_circuit_zk_norm_arg_v4:hidden_dlog");
3163 (void)ignored;
3164 }
3166 const auto &dlog_response,
3167 FieldElement::try_from_bytes32(dlog_proof.response),
3168 "prove_circuit_zk_norm_arg_v4:dlog_response_scalar");
3170 transcript.append_dlog_response(dlog_response),
3171 "prove_circuit_zk_norm_arg_v4:dlog_response");
3172
3173 const ScalarBytes precommitment_bytes = precommitment.digest.bytes();
3174 std::size_t mask_seed_size = 0;
3175 if (!checked_add_size(seed.value.size(), precommitment_bytes.size(),
3176 mask_seed_size)) {
3178 "prove_circuit_zk_norm_arg_v4:mask_seed_size");
3179 }
3180 SecretBytes mask_seed;
3181 mask_seed.value.reserve(mask_seed_size);
3182 mask_seed.value.insert(mask_seed.value.end(), seed.value.begin(),
3183 seed.value.end());
3184 mask_seed.value.insert(mask_seed.value.end(), precommitment_bytes.begin(),
3185 precommitment_bytes.end());
3186 assert(mask_seed.value.size() == mask_seed_size);
3187 std::vector<FieldElement> mask_n(hidden.n_vec.size(),
3189 WipeOnDestruction mask_n_wiper(mask_n);
3190 for (std::size_t i = 0; i < mask_n.size(); ++i) {
3192 derive_scalar(mask_n[i], mask_seed.value,
3193 kCircuitZkMaskNV4TaggedHash, i, attempt),
3194 "prove_circuit_zk_norm_arg_v4:mask_n");
3195 }
3196 std::vector<FieldElement> mask_l(hidden.l_vec.size(),
3198 WipeOnDestruction mask_l_wiper(mask_l);
3199 for (std::size_t i = 0; i < mask_l.size(); ++i) {
3201 derive_scalar(mask_l[i], mask_seed.value,
3202 kCircuitZkMaskLV4TaggedHash, i, attempt),
3203 "prove_circuit_zk_norm_arg_v4:mask_l");
3204 }
3205
3206 FieldElement t2 = weighted_bppp_inner_product(
3207 mask_n, mask_n, hidden.public_data->rho);
3208 WipeOnDestruction t2_wiper(t2);
3209 if (t2.is_zero()) continue;
3210 FieldElement t1 =
3212 weighted_bppp_inner_product(hidden.n_vec, mask_n,
3213 hidden.public_data->rho);
3214 WipeOnDestruction t1_wiper(t1);
3215 for (std::size_t i = 0; i < mask_l.size(); ++i) {
3216 t1 = t1 + mask_l[i] * hidden.public_data->c_vec[i];
3217 }
3218
3219 NormArgInputs mask_inputs;
3220 mask_inputs.rho = hidden.public_data->rho_bytes;
3221 mask_inputs.generators = hidden.public_data->generators;
3222 mask_inputs.n_vec = scalar_bytes(mask_n);
3223 mask_inputs.l_vec = scalar_bytes(mask_l);
3224 mask_inputs.c_vec = hidden.public_data->c_vec_bytes;
3225 WipeOnDestruction mask_input_n_wiper(mask_inputs.n_vec);
3226 WipeOnDestruction mask_input_l_wiper(mask_inputs.l_vec);
3227 auto mask_commitment =
3228 commit_explicit_norm_arg(mask_inputs, t1, secp_context, nullptr);
3229 if (!mask_commitment.has_value()) {
3230 if (!masked_failure.has_value()) {
3231 masked_failure = mask_commitment.error();
3232 }
3233 continue;
3234 }
3236 const auto &alpha,
3237 transcript.append_mask(*mask_commitment, t2, secp_context),
3238 "prove_circuit_zk_norm_arg_v4:alpha");
3239
3240 CircuitNormArgReduction masked = hidden;
3241 WipeOnDestruction masked_n_wiper(masked.n_vec);
3242 WipeOnDestruction masked_l_wiper(masked.l_vec);
3243 for (std::size_t i = 0; i < masked.n_vec.size(); ++i) {
3244 masked.n_vec[i] = masked.n_vec[i] + alpha.scalar * mask_n[i];
3245 }
3246 for (std::size_t i = 0; i < masked.l_vec.size(); ++i) {
3247 masked.l_vec[i] = masked.l_vec[i] + alpha.scalar * mask_l[i];
3248 }
3249 NormArgInputs masked_inputs = build_norm_arg_inputs(masked);
3250 WipeOnDestruction masked_input_n_wiper(masked_inputs.n_vec);
3251 WipeOnDestruction masked_input_l_wiper(masked_inputs.l_vec);
3252 auto combined_commitment = combine_zk_commitments(
3253 anchored_commitment, *mask_commitment, alpha.scalar, t2,
3254 secp_context);
3255 if (!combined_commitment.has_value()) {
3256 if (!masked_failure.has_value()) {
3257 masked_failure = combined_commitment.error();
3258 }
3259 continue;
3260 }
3262 const auto &direct_commitment,
3263 commit_norm_arg_with_cache(masked_inputs, secp_context, nullptr),
3264 "prove_circuit_zk_norm_arg_v4:direct_commitment");
3265 if (*combined_commitment != direct_commitment) {
3267 "prove_circuit_zk_norm_arg_v4:commitment");
3268 }
3270 transcript.append_combined_commitment(*combined_commitment,
3271 secp_context),
3272 "prove_circuit_zk_norm_arg_v4:combined_transcript");
3273
3275 masked_inputs, *combined_commitment, transcript, secp_context);
3276 if (!norm.has_value()) {
3277 if (!masked_failure.has_value()) masked_failure = norm.error();
3278 continue;
3279 }
3280 ScalarBytes terminal_n{};
3281 ScalarBytes terminal_l{};
3283 const auto &rounds,
3284 parse_norm_rounds_v4(norm->proof, shape.round_count(), terminal_n,
3285 terminal_l),
3286 "prove_circuit_zk_norm_arg_v4:parse_norm");
3287 (void)rounds;
3289 const auto &terminal_n_scalar,
3291 "prove_circuit_zk_norm_arg_v4:terminal_n");
3293 const auto &terminal_l_scalar,
3295 "prove_circuit_zk_norm_arg_v4:terminal_l");
3297 const auto finished,
3298 transcript.finish(terminal_n_scalar, terminal_l_scalar),
3299 "prove_circuit_zk_norm_arg_v4:finish_transcript");
3300 (void)finished;
3301
3303 *raw_commitment,
3304 *mask_commitment,
3305 scalar_bytes(t2),
3306 dlog_proof.nonce_xonly,
3307 dlog_proof.response,
3308 std::move(norm->proof)};
3310 precommitment.digest, std::move(proof)};
3311 }
3312
3313 if (masked_failure.has_value()) {
3314 return unexpected_error(*masked_failure,
3315 "prove_circuit_zk_norm_arg_v4:attempts");
3316 }
3318 "prove_circuit_zk_norm_arg_v4:attempts");
3319}
3320
3321} // namespace
3322
3324 const CircuitZkNormArgProofV4 &proof,
3325 CircuitCommitmentModeV4 mode, std::size_t round_count,
3326 purify_secp_context *secp_context) {
3327 return validate_circuit_zk_norm_arg_proof_v4_fixed_encoding_impl(
3328 proof, mode, round_count, secp_context);
3329}
3330
3332 const NativeBulletproofCircuit &circuit,
3333 const CircuitZkNormArgProofV4 &proof,
3334 purify_secp_context *secp_context) {
3335 return validate_circuit_zk_norm_arg_proof_v4_encoding_impl(
3336 circuit, proof, {}, secp_context, false);
3337}
3338
3339Status candidate::
3340validate_circuit_zk_norm_arg_proof_v4_encoding_with_public_commitments(
3341 const NativeBulletproofCircuit &circuit,
3342 const CircuitZkNormArgProofV4 &proof,
3343 std::span<const PointBytes> public_commitments,
3344 purify_secp_context *secp_context) {
3345 return validate_circuit_zk_norm_arg_proof_v4_encoding_impl(
3346 circuit, proof, public_commitments, secp_context, true);
3347}
3348
3351 const NativeBulletproofCircuit &circuit,
3353 purify_secp_context *secp_context,
3354 std::span<const unsigned char> statement_binding) {
3355 return reconstruct_circuit_zk_norm_arg_publication_v4_impl(
3356 circuit, std::move(proof), {}, secp_context, statement_binding,
3357 false);
3358}
3359
3361candidate::
3362reconstruct_circuit_zk_norm_arg_publication_v4_with_public_commitments(
3363 const NativeBulletproofCircuit &circuit,
3365 std::span<const PointBytes> public_commitments,
3366 purify_secp_context *secp_context,
3367 std::span<const unsigned char> statement_binding) {
3368 return reconstruct_circuit_zk_norm_arg_publication_v4_impl(
3369 circuit, std::move(proof), public_commitments, secp_context,
3370 statement_binding, true);
3371}
3372
3375 const NativeBulletproofCircuit &circuit,
3377 std::span<const PointBytes> public_commitments,
3378 purify_secp_context *secp_context,
3379 std::span<const unsigned char> statement_binding,
3380 bool externalize_commitments, ExperimentalCircuitBackend *cache) {
3382 validate_circuit_proof_v4_inputs(circuit, public_commitments,
3383 secp_context,
3384 externalize_commitments),
3385 "prepare_circuit_zk_norm_arg_v4:inputs");
3386 if (publication.proof.norm_proof.empty()) {
3388 "prepare_circuit_zk_norm_arg_v4:proof");
3389 }
3390 if (is_identity_point_v4(publication.proof.raw_commitment) ||
3391 is_identity_point_v4(publication.proof.mask_commitment)) {
3392 return std::optional<candidate::PreparedCircuitZkNormArgV4>{};
3393 }
3395 const auto shape, circuit_shape_v4(circuit, externalize_commitments),
3396 "prepare_circuit_zk_norm_arg_v4:shape");
3398 const auto &binding_digest,
3399 circuit_binding_digest_v4(circuit, statement_binding),
3400 "prepare_circuit_zk_norm_arg_v4:binding_digest");
3402 const auto &expected_precommitment,
3404 shape, binding_digest, public_commitments,
3405 publication.proof.raw_commitment, secp_context),
3406 "prepare_circuit_zk_norm_arg_v4:precommitment");
3407 if (expected_precommitment.digest.bytes() !=
3408 publication.precommitment.bytes()) {
3409 return std::optional<candidate::PreparedCircuitZkNormArgV4>{};
3410 }
3412 const auto &raw_generator_digest,
3413 raw_generator_digest_v4(shape, secp_context),
3414 "prepare_circuit_zk_norm_arg_v4:raw_generator_digest");
3416 auto transcript,
3418 shape, publication.precommitment, raw_generator_digest),
3419 "prepare_circuit_zk_norm_arg_v4:transcript");
3420 const CircuitNormArgChallenges challenges{
3421 transcript.rho().scalar, transcript.mul_scale().scalar,
3422 transcript.mul_ratio().scalar, transcript.row_ratio().scalar};
3424 const auto &public_data,
3425 build_circuit_norm_arg_public_data(
3426 circuit, statement_binding, publication.proof.raw_commitment,
3427 secp_context, externalize_commitments, cache, &challenges),
3428 "prepare_circuit_zk_norm_arg_v4:public_data");
3429 if (generator_backend_cache_key(public_data->raw_generators) !=
3430 raw_generator_digest) {
3432 "prepare_circuit_zk_norm_arg_v4:raw_basis");
3433 }
3435 const auto &anchored_commitment,
3436 anchor_zk_a_commitment(publication.proof.raw_commitment, *public_data,
3437 public_commitments, secp_context),
3438 "prepare_circuit_zk_norm_arg_v4:anchored_commitment");
3439 if (is_identity_point_v4(anchored_commitment)) {
3440 return std::optional<candidate::PreparedCircuitZkNormArgV4>{};
3441 }
3443 const auto &anchored_offset,
3444 point_subtract_allow_infinity(anchored_commitment,
3445 publication.proof.raw_commitment,
3446 secp_context),
3447 "prepare_circuit_zk_norm_arg_v4:anchored_offset");
3449 const auto &coefficient_commitment,
3450 coefficient_commitment_v4(*public_data, secp_context),
3451 "prepare_circuit_zk_norm_arg_v4:coefficient_commitment");
3453 const auto &eta,
3454 transcript.append_anchored_commitments(
3455 coefficient_commitment, anchored_offset, anchored_commitment,
3456 secp_context),
3457 "prepare_circuit_zk_norm_arg_v4:eta");
3458
3459 PointBytes batched_public_commitment{};
3460 std::optional<candidate::CircuitChallengeV4> staged_dlog_challenge;
3461 PublicCommitmentDlogProof dlog_proof{
3464 if (externalize_commitments) {
3466 const auto &batched,
3467 batch_public_commitments_with_eta(public_commitments, eta.scalar,
3468 secp_context),
3469 "prepare_circuit_zk_norm_arg_v4:batch_public");
3470 batched_public_commitment = batched.point;
3472 const auto &dlog_challenge,
3473 transcript.append_public_opening(
3474 batched.point, dlog_proof.nonce_xonly, secp_context),
3475 "prepare_circuit_zk_norm_arg_v4:dlog_e");
3476 staged_dlog_challenge = dlog_challenge;
3478 const bool dlog_valid,
3479 verify_public_commitment_dlog(batched, dlog_challenge.scalar,
3480 dlog_proof, secp_context),
3481 "prepare_circuit_zk_norm_arg_v4:dlog");
3482 if (!dlog_valid) {
3483 return std::optional<candidate::PreparedCircuitZkNormArgV4>{};
3484 }
3485 } else {
3486 const auto all_zero = [](const auto &bytes) {
3487 return std::all_of(bytes.begin(), bytes.end(),
3488 [](unsigned char byte) { return byte == 0; });
3489 };
3490 if (!all_zero(dlog_proof.nonce_xonly) ||
3491 !all_zero(dlog_proof.response)) {
3492 return std::optional<candidate::PreparedCircuitZkNormArgV4>{};
3493 }
3495 const auto hidden_dlog_challenge,
3496 transcript.append_public_opening(
3497 batched_public_commitment, dlog_proof.nonce_xonly, secp_context),
3498 "prepare_circuit_zk_norm_arg_v4:hidden_dlog");
3499 staged_dlog_challenge = hidden_dlog_challenge;
3500 }
3502 const auto &dlog_response,
3503 FieldElement::try_from_bytes32(dlog_proof.response),
3504 "prepare_circuit_zk_norm_arg_v4:dlog_response_scalar");
3506 transcript.append_dlog_response(dlog_response),
3507 "prepare_circuit_zk_norm_arg_v4:dlog_response");
3508
3510 const auto &t2,
3512 "prepare_circuit_zk_norm_arg_v4:t2");
3514 const auto &alpha,
3515 transcript.append_mask(publication.proof.mask_commitment,
3516 t2, secp_context),
3517 "prepare_circuit_zk_norm_arg_v4:alpha");
3519 const auto &combined_commitment,
3520 combine_zk_commitments(anchored_commitment,
3521 publication.proof.mask_commitment,
3522 alpha.scalar, t2, secp_context),
3523 "prepare_circuit_zk_norm_arg_v4:combined_commitment");
3524 if (is_identity_point_v4(combined_commitment)) {
3525 return std::optional<candidate::PreparedCircuitZkNormArgV4>{};
3526 }
3528 transcript.append_combined_commitment(combined_commitment,
3529 secp_context),
3530 "prepare_circuit_zk_norm_arg_v4:combined_transcript");
3531
3532 ScalarBytes terminal_n{};
3533 ScalarBytes terminal_l{};
3535 const auto &rounds,
3537 shape.round_count(), terminal_n, terminal_l),
3538 "prepare_circuit_zk_norm_arg_v4:rounds");
3539 std::vector<candidate::CircuitChallengeV4> staged_gammas;
3540 staged_gammas.reserve(rounds.size());
3541 for (const auto &round : rounds) {
3543 auto gamma, transcript.append_round(round, secp_context),
3544 "prepare_circuit_zk_norm_arg_v4:gamma");
3545 staged_gammas.push_back(std::move(gamma));
3546 }
3548 const auto &terminal_n_scalar,
3550 "prepare_circuit_zk_norm_arg_v4:terminal_n");
3552 const auto &terminal_l_scalar,
3554 "prepare_circuit_zk_norm_arg_v4:terminal_l");
3556 const auto prepared_binding,
3557 transcript.finish(terminal_n_scalar, terminal_l_scalar),
3558 "prepare_circuit_zk_norm_arg_v4:finish");
3559
3560 NormArgProof norm{public_data->rho_bytes,
3561 public_data->generators,
3562 public_data->c_vec_bytes,
3563 public_data->n_vec_len,
3564 combined_commitment,
3565 publication.proof.norm_proof};
3566 ScalarBytes prepared_n{};
3567 ScalarBytes prepared_l{};
3569 raw_generator_digest,
3570 coefficient_commitment,
3571 anchored_offset,
3572 anchored_commitment,
3573 batched_public_commitment,
3574 dlog_proof.nonce_xonly,
3575 dlog_proof.response,
3576 publication.proof.mask_commitment,
3577 publication.proof.t2,
3578 combined_commitment,
3579 rounds,
3580 terminal_n,
3581 terminal_l};
3583 auto transcript_result,
3585 shape, publication.precommitment, transcript_input, secp_context),
3586 "prepare_circuit_zk_norm_arg_v4:replay");
3587 const auto same_challenge = [](const auto &lhs, const auto &rhs) {
3588 return lhs.scalar == rhs.scalar;
3589 };
3590 const bool matching_gammas =
3591 staged_gammas.size() == transcript_result.gammas.size() &&
3592 std::equal(staged_gammas.begin(), staged_gammas.end(),
3593 transcript_result.gammas.begin(), same_challenge);
3594 if (!staged_dlog_challenge.has_value() ||
3595 !same_challenge(transcript.rho(), transcript_result.rho) ||
3596 !same_challenge(transcript.mul_scale(), transcript_result.mul_scale) ||
3597 !same_challenge(transcript.mul_ratio(), transcript_result.mul_ratio) ||
3598 !same_challenge(transcript.row_ratio(), transcript_result.row_ratio) ||
3599 !same_challenge(eta, transcript_result.eta) ||
3600 !same_challenge(*staged_dlog_challenge,
3601 transcript_result.dlog_challenge) ||
3602 !same_challenge(alpha, transcript_result.alpha) || !matching_gammas ||
3603 !same_challenge(prepared_binding,
3604 transcript_result.prepared_binding)) {
3606 "prepare_circuit_zk_norm_arg_v4:replay");
3607 }
3609 const auto &residual,
3610 prepare_norm_arg_v4(norm, transcript_result.gammas, prepared_n,
3611 prepared_l, secp_context),
3612 "prepare_circuit_zk_norm_arg_v4:norm");
3613 if (prepared_n != terminal_n || prepared_l != terminal_l) {
3615 "prepare_circuit_zk_norm_arg_v4:terminal");
3616 }
3617 return std::optional<candidate::PreparedCircuitZkNormArgV4>(
3619 shape, binding_digest, public_data->raw_generators,
3620 std::move(transcript_input),
3621 std::move(transcript_result), std::move(norm), residual));
3622}
3623
3626 const NativeBulletproofCircuit &circuit,
3627 const BulletproofAssignmentData &assignment,
3628 const ScalarBytes &secret_prover_seed,
3629 purify_secp_context *secp_context,
3630 std::span<const unsigned char> statement_binding,
3632 return prove_circuit_zk_norm_arg_v4_impl(
3633 circuit, assignment, secret_prover_seed, {}, secp_context,
3634 statement_binding, false, cache);
3635}
3636
3639 const NativeBulletproofCircuit &circuit,
3640 const BulletproofAssignmentData &assignment,
3641 const ScalarBytes &secret_prover_seed,
3642 std::span<const PointBytes> public_commitments,
3643 purify_secp_context *secp_context,
3644 std::span<const unsigned char> statement_binding,
3646 return prove_circuit_zk_norm_arg_v4_impl(
3647 circuit, assignment, secret_prover_seed, public_commitments,
3648 secp_context, statement_binding, true, cache);
3649}
3650
3653 const NativeBulletproofCircuit &circuit,
3654 const CircuitZkNormArgPublicationV4 &publication,
3655 purify_secp_context *secp_context,
3656 std::span<const unsigned char> statement_binding,
3659 circuit, publication, {}, secp_context, statement_binding, false,
3660 cache);
3661}
3662
3665 const NativeBulletproofCircuit &circuit,
3666 const CircuitZkNormArgPublicationV4 &publication,
3667 std::span<const PointBytes> public_commitments,
3668 purify_secp_context *secp_context,
3669 std::span<const unsigned char> statement_binding,
3672 circuit, publication, public_commitments, secp_context,
3673 statement_binding, true, cache);
3674}
3675
3676namespace {
3677
3679derive_circuit_norm_parent_constants_v4_impl(
3680 const NativeBulletproofCircuit &circuit,
3681 const candidate::CircuitPrecommitmentDigestV4 &precommitment,
3682 std::span<const PointBytes> public_commitments,
3683 purify_secp_context *secp_context,
3684 std::span<const unsigned char> statement_binding) {
3686 validate_circuit_proof_v4_inputs(
3687 circuit, public_commitments, secp_context, true),
3688 "circuit_parent_constants_v4:inputs");
3689 for (const auto &point : public_commitments) {
3691 validate_finite_point_v4(
3692 point, secp_context,
3693 "circuit_parent_constants_v4:public_commitment"),
3694 "circuit_parent_constants_v4:public_commitment");
3695 }
3697 auto binding_digest,
3698 circuit_binding_digest_v4(circuit, statement_binding),
3699 "circuit_parent_constants_v4:binding");
3701 const auto shape,
3702 circuit_shape_v4(circuit, true),
3703 "circuit_parent_constants_v4:shape");
3705 const auto raw_generator_digest,
3706 raw_generator_digest_v4(shape, secp_context),
3707 "circuit_parent_constants_v4:raw_basis");
3709 const auto transcript,
3710 candidate::CircuitProofTranscriptV4::create(
3711 shape, precommitment, raw_generator_digest),
3712 "circuit_parent_constants_v4:transcript");
3713 const CircuitNormArgChallenges challenges{
3714 transcript.rho().scalar, transcript.mul_scale().scalar,
3715 transcript.mul_ratio().scalar, transcript.row_ratio().scalar};
3717 const auto public_data,
3718 build_circuit_norm_arg_public_data_from_challenges(
3719 circuit, secp_context, true, nullptr,
3720 challenges),
3721 "circuit_parent_constants_v4:public_data");
3722 if (generator_backend_cache_key(public_data->raw_generators) !=
3723 raw_generator_digest) {
3725 "circuit_parent_constants_v4:raw_digest");
3726 }
3728 auto coefficient_commitment,
3729 coefficient_commitment_v4(*public_data, secp_context),
3730 "circuit_parent_constants_v4:coefficient_commitment");
3732 auto anchored_offset,
3733 circuit_anchored_offset_v4(*public_data, public_commitments,
3734 secp_context),
3735 "circuit_parent_constants_v4:anchored_offset");
3736 return candidate::CircuitNormParentConstantsV4{
3737 std::move(binding_digest), std::move(raw_generator_digest),
3738 std::move(coefficient_commitment), std::move(anchored_offset)};
3739}
3740
3741} // namespace
3742
3745 const NativeBulletproofCircuit &circuit,
3746 const CircuitPrecommitmentDigestV4 &precommitment,
3747 std::span<const PointBytes> public_commitments,
3748 purify_secp_context *secp_context,
3749 std::span<const unsigned char> statement_binding) {
3750 return derive_circuit_norm_parent_constants_v4_impl(
3751 circuit, precommitment, public_commitments, secp_context,
3752 statement_binding);
3753}
3754
3756 const NativeBulletproofCircuit &circuit,
3757 const CircuitZkNormArgPublicationV4 &publication,
3758 purify_secp_context *secp_context,
3759 std::span<const unsigned char> statement_binding,
3762 auto prepared,
3763 prepare_circuit_zk_norm_arg_v4(circuit, publication, secp_context,
3764 statement_binding, cache),
3765 "verify_circuit_zk_norm_arg_v4:prepare");
3766 return prepared.has_value() &&
3767 verify_norm_arg_v4(prepared->norm(), prepared->transcript().gammas,
3768 secp_context);
3769}
3770
3773 const NativeBulletproofCircuit &circuit,
3774 const CircuitZkNormArgPublicationV4 &publication,
3775 std::span<const PointBytes> public_commitments,
3776 purify_secp_context *secp_context,
3777 std::span<const unsigned char> statement_binding,
3780 auto prepared,
3782 circuit, publication, public_commitments, secp_context,
3783 statement_binding, cache),
3784 "verify_circuit_zk_norm_arg_v4_public:prepare");
3785 return prepared.has_value() &&
3786 verify_norm_arg_v4(prepared->norm(), prepared->transcript().gammas,
3787 secp_context);
3788}
3789
3792 const NativeBulletproofCircuit &circuit,
3793 const BulletproofAssignmentData &assignment,
3794 const ScalarBytes &secret_prover_seed,
3795 purify_secp_context *secp_context,
3796 std::span<const unsigned char> statement_binding,
3799 circuit, assignment, secret_prover_seed, {}, secp_context,
3800 statement_binding, false, cache);
3801}
3802
3804 const NativeBulletproofCircuit &circuit,
3806 purify_secp_context *secp_context,
3807 std::span<const unsigned char> statement_binding,
3810 circuit, proof, secp_context, statement_binding, cache);
3811}
3812
3815 const NativeBulletproofCircuit &circuit,
3816 const BulletproofAssignmentData &assignment,
3817 const ScalarBytes &secret_prover_seed,
3818 std::span<const PointBytes> public_commitments,
3819 purify_secp_context *secp_context,
3820 std::span<const unsigned char> statement_binding,
3823 circuit, assignment, secret_prover_seed, public_commitments,
3824 secp_context, statement_binding, true, cache);
3825}
3826
3828 const NativeBulletproofCircuit &circuit,
3830 std::span<const PointBytes> public_commitments,
3831 purify_secp_context *secp_context,
3832 std::span<const unsigned char> statement_binding,
3835 auto prepared,
3837 circuit, proof, public_commitments, secp_context, statement_binding,
3838 cache),
3839 "verify_experimental_circuit_zk_norm_arg_with_public_commitments:prepare");
3840 if (!prepared.has_value()) {
3841 return false;
3842 }
3843 return verify_norm_arg_with_cache(prepared->norm, secp_context, nullptr);
3844}
3845
3847commit_output_witness(const Bytes &message, const SecretKey &secret,
3848 const ScalarBytes &blind, purify_secp_context *secp_context) {
3849 return commit_output_witness(message, secret, blind, secp_context,
3850 value_generator_h(secp_context),
3851 base_generator(secp_context));
3852}
3853
3855commit_output_witness(const Bytes &message, const SecretKey &secret,
3856 const ScalarBytes &blind, purify_secp_context *secp_context,
3857 const GeneratorBytes &value_gen,
3858 const GeneratorBytes &blind_gen) {
3859 PURIFY_ASSIGN_OR_RETURN(auto witness, prove_assignment_data(message, secret),
3860 "commit_output_witness:prove_assignment_data");
3861 SecretScalarBytes output;
3863 output.value.data(),
3866 const auto &commitment,
3867 pedersen_commit_char(blind, output.value, secp_context, value_gen,
3868 blind_gen),
3869 "commit_output_witness:pedersen_commit_char");
3870 return CommittedPurifyWitness{witness.public_key, witness.output,
3871 std::move(witness.assignment), commitment};
3872}
3873
3874} // namespace purify::bppp
C++ wrappers for the BPPP functionality used by Purify.
int purify_bppp_verify_norm_arg_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)
int purify_bppp_prove_norm_arg_to_commitment_with_resources(purify_bppp_backend_resources *resources, const unsigned char rho32[32], const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, const unsigned char commitment33[33], unsigned char *proof_out, size_t *proof_len)
int purify_bppp_commit_witness_only_with_resources(purify_bppp_backend_resources *resources, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, unsigned char commitment_out33[33])
int purify_point_subtract_allow_infinity(purify_secp_context *context, const unsigned char lhs33[33], const unsigned char rhs33[33], unsigned char out33[33])
int purify_point_scale(purify_secp_context *context, const unsigned char point33[33], const unsigned char scalar32[32], unsigned char out33[33])
int purify_bppp_prove_norm_arg_to_commitment_with_callback(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, const unsigned char commitment33[33], purify_bppp_round_challenge_callback challenge_callback, void *callback_data, unsigned char *proof_out, size_t *proof_len)
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_generator_to_point(purify_secp_context *context, const unsigned char generator33[33], unsigned char out33[33])
int purify_bppp_prove_norm_arg(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, unsigned char commitment_out33[33], unsigned char *proof_out, size_t *proof_len)
Produces a standalone BPPP norm argument.
int purify_bppp_commit_witness_only(purify_secp_context *context, const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, unsigned char commitment_out33[33])
int purify_bppp_commit_norm_arg(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, unsigned char commitment_out33[33])
void purify_bppp_backend_resources_destroy(purify_bppp_backend_resources *resources)
int purify_bppp_value_generator_h(purify_secp_context *context, unsigned char out33[33])
Serializes the alternate value generator used by Pedersen commitments.
int purify_bppp_create_generators(purify_secp_context *context, size_t count, unsigned char *out, size_t *out_len)
Expands the generator list required by the BPPP prover and verifier.
purify_bppp_backend_resources * purify_bppp_backend_resources_clone(const purify_bppp_backend_resources *resources)
int purify_point_add(purify_secp_context *context, const unsigned char lhs33[33], const unsigned char rhs33[33], unsigned char out33[33])
int purify_bppp_verify_norm_arg(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)
Verifies a standalone BPPP norm argument.
int purify_pedersen_commit_char(purify_secp_context *context, const unsigned char blind32[32], const unsigned char value32[32], const unsigned char value_gen33[33], const unsigned char blind_gen33[33], unsigned char commitment_out33[33])
Computes a Pedersen commitment to an arbitrary 32-byte scalar value.
int purify_bppp_prove_norm_arg_with_resources(purify_bppp_backend_resources *resources, const unsigned char rho32[32], const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, unsigned char commitment_out33[33], unsigned char *proof_out, size_t *proof_len)
int purify_bppp_offset_commitment(purify_secp_context *context, const unsigned char commitment33[33], const unsigned char scalar32[32], unsigned char commitment_out33[33])
int purify_bppp_prove_norm_arg_to_commitment(purify_secp_context *context, const unsigned char rho32[32], const unsigned char *generators33, size_t generators_count, const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, const unsigned char commitment33[33], unsigned char *proof_out, size_t *proof_len)
int purify_point_add_allow_infinity(purify_secp_context *context, const unsigned char lhs33[33], const unsigned char rhs33[33], unsigned char out33[33])
int purify_bppp_base_generator(purify_secp_context *context, unsigned char out33[33])
Serializes the secp256k1 base generator into compressed form.
int purify_bppp_commit_norm_arg_with_resources(purify_bppp_backend_resources *resources, const unsigned char rho32[32], const unsigned char *n_vec32, size_t n_vec_len, const unsigned char *l_vec32, size_t l_vec_len, const unsigned char *c_vec32, size_t c_vec_len, unsigned char commitment_out33[33])
size_t purify_bppp_required_proof_size(size_t n_vec_len, size_t c_vec_len)
Computes the maximum serialized size of a BPPP norm proof.
purify_bppp_backend_resources * purify_bppp_backend_resources_create(purify_secp_context *context, const unsigned char *generators33, size_t generators_count)
int purify_bppp_verify_norm_arg_with_resources(purify_bppp_backend_resources *resources, const unsigned char rho32[32], 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)
C ABI bridging Purify C++ code to secp256k1-zkp BPPP functionality.
struct purify_bppp_backend_resources purify_bppp_backend_resources
Definition bppp_bridge.h:20
bool has_value() const noexcept
Definition expected.hpp:170
Field element modulo the backend scalar field used by this implementation.
Definition numeric.hpp:834
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
static FieldElement from_int(std::int64_t value)
Constructs a field element from a signed integer, reducing negatives modulo the field.
Definition numeric.cpp:46
bool is_zero() const
Returns true when the element is zero.
Definition numeric.cpp:104
static FieldElement zero()
Returns the additive identity of the scalar field.
Definition numeric.cpp:32
Move-only packed Purify secret stored in dedicated heap memory.
Definition secret.hpp:95
Common interface for reusable experimental BPPP backend state.
Definition bppp.hpp:129
Thread-local clone of one warmed experimental BPPP backend-resource line.
Definition bppp.hpp:169
ExperimentalCircuitCacheLine & operator=(const ExperimentalCircuitCacheLine &)=delete
Caller-owned cache for reusable experimental circuit reduction and BPPP backend data.
Definition bppp.hpp:196
ExperimentalCircuitCache & operator=(const ExperimentalCircuitCache &)=delete
Result< ExperimentalCircuitCacheLine > clone_line_for_thread(std::span< const PointBytes > generators) const
Clones one warmed backend-resource line for thread-local use.
Definition bppp.cpp:185
std::shared_ptr< const void > find_public_data(const std::array< unsigned char, 32 > &key) const
Looks up opaque cached reduction data by digest key.
Definition bppp.cpp:211
void insert_public_data(std::array< unsigned char, 32 > key, std::shared_ptr< const void > value)
Stores opaque cached reduction data by digest key.
Definition bppp.cpp:216
purify_bppp_backend_resources * get_or_create_backend_resources(std::span< const PointBytes > generators, purify_secp_context *secp_context)
Returns cached backend resources for this generator set, creating them on first use.
Definition bppp.cpp:223
std::size_t size() const noexcept
Definition bppp.cpp:179
static Result< CircuitProofTranscriptV4 > create(const CircuitTranscriptShapeV4 &shape, const CircuitPrecommitmentDigestV4 &precommitment, const TranscriptDigest &raw_generator_digest)
const CircuitTranscriptShapeV4 & shape() const noexcept
static Result< CircuitTranscriptShapeV4 > create(CircuitCommitmentModeV4 mode, std::size_t gate_count, std::size_t commitment_count, std::size_t n_vec_len, std::size_t l_vec_len)
#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
Status validate_packed_point_pair_v4(const PackedPointPairV4 &encoded, purify_secp_context *secp_context)
Result< CircuitZkNormArgPublicationV4 > prove_circuit_zk_norm_arg_v4_with_public_commitments(const NativeBulletproofCircuit &circuit, const BulletproofAssignmentData &assignment, const ScalarBytes &secret_prover_seed, std::span< const PointBytes > public_commitments, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding, ExperimentalCircuitBackend *cache=nullptr)
Definition bppp.cpp:3638
Result< bool > verify_circuit_zk_norm_arg_v4_with_public_commitments(const NativeBulletproofCircuit &circuit, const CircuitZkNormArgPublicationV4 &publication, std::span< const PointBytes > public_commitments, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding, ExperimentalCircuitBackend *cache=nullptr)
Definition bppp.cpp:3772
Result< CircuitPrecommitmentResultV4 > derive_circuit_precommitment_v4(const CircuitTranscriptShapeV4 &shape, const TranscriptDigest &circuit_binding_digest, std::span< const PointBytes > public_commitments, const PointBytes &raw_commitment, purify_secp_context *secp_context)
Status validate_circuit_zk_norm_arg_proof_v4_fixed_encoding(const CircuitZkNormArgProofV4 &proof, CircuitCommitmentModeV4 mode, std::size_t round_count, purify_secp_context *secp_context)
Definition bppp.cpp:3323
Result< CircuitProofTranscriptResultV4 > derive_circuit_proof_transcript_v4(const CircuitTranscriptShapeV4 &shape, const CircuitPrecommitmentDigestV4 &precommitment, const CircuitProofTranscriptInputV4 &proof, purify_secp_context *secp_context)
Result< std::optional< PreparedCircuitZkNormArgV4 > > prepare_circuit_zk_norm_arg_v4_with_public_commitments(const NativeBulletproofCircuit &circuit, const CircuitZkNormArgPublicationV4 &publication, std::span< const PointBytes > public_commitments, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding, ExperimentalCircuitBackend *cache=nullptr)
Definition bppp.cpp:3664
Result< std::optional< PreparedCircuitZkNormArgV4 > > prepare_circuit_zk_norm_arg_v4_impl(const NativeBulletproofCircuit &circuit, const CircuitZkNormArgPublicationV4 &publication, std::span< const PointBytes > public_commitments, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding, bool externalize_commitments, ExperimentalCircuitBackend *cache)
Definition bppp.cpp:3374
Result< CircuitNormParentConstantsV4 > derive_circuit_norm_parent_constants_v4_with_public_commitments(const NativeBulletproofCircuit &circuit, const CircuitPrecommitmentDigestV4 &precommitment, std::span< const PointBytes > public_commitments, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding)
Definition bppp.cpp:3744
Result< CircuitZkNormArgPublicationV4 > prove_circuit_zk_norm_arg_v4(const NativeBulletproofCircuit &circuit, const BulletproofAssignmentData &assignment, const ScalarBytes &secret_prover_seed, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding, ExperimentalCircuitBackend *cache=nullptr)
Definition bppp.cpp:3625
Status validate_circuit_zk_norm_arg_proof_v4_encoding(const NativeBulletproofCircuit &circuit, const CircuitZkNormArgProofV4 &proof, purify_secp_context *secp_context)
Definition bppp.cpp:3331
Result< bool > verify_circuit_zk_norm_arg_v4(const NativeBulletproofCircuit &circuit, const CircuitZkNormArgPublicationV4 &publication, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding, ExperimentalCircuitBackend *cache=nullptr)
Definition bppp.cpp:3755
Result< CircuitZkNormArgPublicationV4 > reconstruct_circuit_zk_norm_arg_publication_v4(const NativeBulletproofCircuit &circuit, CircuitZkNormArgProofV4 proof, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding)
Definition bppp.cpp:3350
std::array< unsigned char, 65 > PackedPointPairV4
Result< std::optional< PreparedCircuitZkNormArgV4 > > prepare_circuit_zk_norm_arg_v4(const NativeBulletproofCircuit &circuit, const CircuitZkNormArgPublicationV4 &publication, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding, ExperimentalCircuitBackend *cache=nullptr)
Definition bppp.cpp:3652
TranscriptBytes32 TranscriptDigest
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()
Result< NormArgProof > prove_norm_arg_to_commitment(const NormArgInputs &inputs, const PointBytes &commitment, purify_secp_context *secp_context)
Produces a standalone BPPP norm argument anchored to a caller-supplied public commitment.
Definition bppp.cpp:2083
Result< ExperimentalCircuitNormArgProof > prove_experimental_circuit_norm_arg_to_commitment(const NativeBulletproofCircuit &circuit, const BulletproofAssignmentData &assignment, const PointBytes &witness_commitment, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding={}, ExperimentalCircuitBackend *cache=nullptr)
Produces an anchored transparent circuit proof against a caller-supplied raw-coordinate commitment.
Definition bppp.cpp:2110
Result< PointBytes > commit_norm_arg(const NormArgInputs &inputs, purify_secp_context *secp_context)
Computes the public BPPP commitment for a standalone norm-argument input bundle.
Definition bppp.cpp:2077
bool verify_norm_arg_with_cache(const NormArgProof &proof, purify_secp_context *secp_context, ExperimentalCircuitBackend *cache=nullptr)
Definition bppp.cpp:1975
std::size_t digest_prefix_hash(const Digest &digest) noexcept
Definition bppp.cpp:46
std::unique_ptr< purify_bppp_backend_resources, BpppBackendResourcesDeleter > OwnedBpppBackendResources
Definition bppp.cpp:40
Result< bool > verify_experimental_circuit_norm_arg(const NativeBulletproofCircuit &circuit, const ExperimentalCircuitNormArgProof &proof, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding={}, ExperimentalCircuitBackend *cache=nullptr)
Verifies an experimental transparent circuit proof produced by prove_experimental_circuit_norm_arg.
Definition bppp.cpp:2201
GeneratorBytes base_generator(purify_secp_context *secp_context)
Returns the serialized secp256k1 base generator used as the blind generator.
Definition bppp.cpp:1702
bool verify_norm_arg_v4(const NormArgProof &norm, std::span< const candidate::CircuitChallengeV4 > gammas, purify_secp_context *secp_context)
Definition bppp.cpp:2060
Result< PointBytes > commit_experimental_circuit_witness(const NativeBulletproofCircuit &circuit, const BulletproofAssignmentData &assignment, purify_secp_context *secp_context, ExperimentalCircuitBackend *cache=nullptr)
Commits to raw circuit coordinates before reduction challenges exist.
Definition bppp.cpp:2094
Result< bool > verify_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=nullptr)
Verifies an experimental masked circuit proof against explicit public commitment points.
Definition bppp.cpp:3827
Result< ExperimentalCircuitZkNormArgProof > prove_experimental_circuit_zk_norm_arg(const NativeBulletproofCircuit &circuit, const BulletproofAssignmentData &assignment, const ScalarBytes &secret_prover_seed, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding={}, ExperimentalCircuitBackend *cache=nullptr)
Produces an experimental masked circuit proof over the reduced BPPP relation.
Definition bppp.cpp:3791
Result< NormArgProof > prove_norm_arg_to_commitment_with_cache(const NormArgInputs &inputs, const PointBytes &commitment, purify_secp_context *secp_context, ExperimentalCircuitBackend *cache=nullptr)
Definition bppp.cpp:1828
Result< ExperimentalCircuitZkNormArgProof > prove_experimental_circuit_zk_norm_arg_with_public_commitments(const NativeBulletproofCircuit &circuit, const BulletproofAssignmentData &assignment, const ScalarBytes &secret_prover_seed, std::span< const PointBytes > public_commitments, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding={}, ExperimentalCircuitBackend *cache=nullptr)
Produces an experimental masked circuit proof bound to explicit public commitment points.
Definition bppp.cpp:3814
bool verify_norm_arg(const NormArgProof &proof, purify_secp_context *secp_context)
Verifies a standalone BPPP norm argument.
Definition bppp.cpp:2089
int append_circuit_norm_round(void *callback_data, const unsigned char point_pair65[65], size_t round, unsigned char challenge32[32])
Definition bppp.cpp:1904
Result< ExperimentalCircuitZkNormArgProof > prove_experimental_circuit_zk_norm_arg_impl(const NativeBulletproofCircuit &circuit, const BulletproofAssignmentData &assignment, const ScalarBytes &secret_prover_seed, std::span< const PointBytes > public_commitments, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding, bool externalize_commitments, ExperimentalCircuitBackend *cache)
Definition bppp.cpp:2245
Result< PointBytes > commit_norm_arg_with_cache(const NormArgInputs &inputs, purify_secp_context *secp_context, ExperimentalCircuitBackend *cache=nullptr)
Definition bppp.cpp:1745
Result< ExperimentalCircuitNormArgProof > prove_experimental_circuit_norm_arg(const NativeBulletproofCircuit &circuit, const BulletproofAssignmentData &assignment, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding={}, ExperimentalCircuitBackend *cache=nullptr)
Produces an anchored transparent circuit proof using the experimental circuit-to-BPPP reduction.
Definition bppp.cpp:2186
GeneratorBackendCacheKeyHash CircuitNormArgPublicDataCacheKeyHash
Definition bppp.cpp:61
GeneratorBytes value_generator_h(purify_secp_context *secp_context)
Returns the serialized alternate generator used for committed values.
Definition bppp.cpp:1711
Result< CommittedPurifyWitness > commit_output_witness(const Bytes &message, const SecretKey &secret, const ScalarBytes &blind, purify_secp_context *secp_context)
Evaluates Purify, derives its witness, and commits to the output using Purify's default generators.
Definition bppp.cpp:3847
Result< bool > verify_experimental_circuit_zk_norm_arg_impl(const NativeBulletproofCircuit &circuit, const ExperimentalCircuitZkNormArgProof &proof, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding, ExperimentalCircuitBackend *cache)
Definition bppp.cpp:2703
Result< NormArgProof > prove_norm_arg(const NormArgInputs &inputs, purify_secp_context *secp_context)
Produces a standalone BPPP norm argument.
Definition bppp.cpp:1818
GeneratorBackendCacheKey generator_backend_cache_key(std::span< const PointBytes > generators)
Definition bppp.cpp:63
Result< PointBytes > prepare_norm_arg_v4(const NormArgProof &norm, std::span< const candidate::CircuitChallengeV4 > gammas, ScalarBytes &terminal_n, ScalarBytes &terminal_l, purify_secp_context *secp_context)
Definition bppp.cpp:2036
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
Result< NormArgProof > prove_norm_arg_to_commitment_v4(const NormArgInputs &inputs, const PointBytes &commitment, candidate::CircuitProofTranscriptV4 &transcript, purify_secp_context *secp_context)
Definition bppp.cpp:1926
Result< bool > verify_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=nullptr)
Verifies an experimental masked circuit proof produced by prove_experimental_circuit_zk_norm_arg.
Definition bppp.cpp:3803
std::array< unsigned char, 33 > GeneratorBytes
Serialized generator encoding used by the BPPP bridge.
Definition bppp.hpp:34
Result< PointBytes > pedersen_commit_char(const ScalarBytes &blind, const ScalarBytes &value, purify_secp_context *secp_context)
Computes a Pedersen commitment to an arbitrary 32-byte scalar value using Purify's default generators...
Definition bppp.cpp:1793
ScalarBytes scalar_bytes(const FieldElement &value)
Serializes a Purify field element into the scalar encoding expected by the BPPP bridge.
Definition bppp.hpp:78
Result< std::vector< candidate::PackedPointPairV4 > > parse_norm_rounds_v4(const Bytes &proof, std::size_t round_count, ScalarBytes &terminal_n, ScalarBytes &terminal_l)
Definition bppp.cpp:2003
std::array< unsigned char, 32 > ScalarBytes
Big-endian 32-byte scalar encoding.
Definition bppp.hpp:30
std::array< unsigned char, 32 > CircuitNormArgPublicDataCacheKey
Definition bppp.cpp:60
std::array< unsigned char, 32 > GeneratorBackendCacheKey
Definition bppp.cpp:43
std::vector< ScalarBytes > scalar_challenges(std::span< const candidate::CircuitChallengeV4 > challenges)
Definition bppp.cpp:2026
void secure_clear_bytes(void *data, std::size_t size) noexcept
Definition secret.hpp:22
Status require_secp_context(const purify_secp_context *context, const char *error_context)
Definition common.hpp:56
Result< Bytes > experimental_circuit_binding_digest(const NativeBulletproofCircuit &circuit, std::span< const unsigned char > statement_binding)
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
Result< BulletproofWitnessData > prove_assignment_data(const Bytes &message, const SecretKey &secret)
Computes the native Purify witness for a message and secret.
Definition api.cpp:243
bool is_power_of_two_size(std::size_t value) noexcept
Definition common.hpp:94
Result< std::uint64_t > narrow_size_to_u64(std::size_t value, const char *context)
Definition common.hpp:87
bool checked_mul_size(std::size_t lhs, std::size_t rhs, std::size_t &out) noexcept
Definition common.hpp:71
Bytes bytes_from_ascii(std::string_view input)
Encodes an ASCII string as a byte vector.
Definition curve.cpp:168
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
Narrow C ABI exposing secp256k1 scalar and HMAC helpers to the C++ headers.
int purify_bip340_xonly_from_point(purify_secp_context *context, const unsigned char point33[33], unsigned char xonly32[32], int *parity_out)
Converts a compressed secp256k1 point into its x-only public key encoding.
void purify_sha256(unsigned char output32[32], const unsigned char *data, size_t data_len)
Computes SHA-256 over a byte string.
int purify_bip340_validate_xonly_pubkey(purify_secp_context *context, const unsigned char xonly_pubkey32[32])
Returns nonzero when the x-only public key encoding parses successfully.
void purify_scalar_get_b32(unsigned char output32[32], const purify_scalar *value)
Serializes a scalar as 32 big-endian bytes.
struct purify_secp_context purify_secp_context
Caller-owned reusable secp256k1 context handle shared across Purify C and C++ APIs.
Columnar witness assignment compatible with the native Bulletproof circuit layout.
BulletproofWitnessColumn left
BulletproofWitnessColumn output
BulletproofWitnessColumn commitments
BulletproofWitnessColumn right
Native in-memory representation of a Bulletproof-style arithmetic circuit.
bool evaluate(const BulletproofAssignmentData &assignment) const
Evaluates the circuit against a witness assignment and checks all gate and row equations.
bool has_valid_shape() const
Checks declared dimensions and every sparse constraint index.
void operator()(purify_bppp_backend_resources *resources) const noexcept
Definition bppp.cpp:35
std::vector< candidate::PackedPointPairV4 > rounds
Definition bppp.cpp:1900
purify_secp_context * secp_context
Definition bppp.cpp:1899
candidate::CircuitProofTranscriptV4 * transcript
Definition bppp.cpp:1898
std::optional< Error > error
Definition bppp.cpp:1901
Purify witness bundle together with a Pedersen commitment to the output.
Definition bppp.hpp:422
OwnedBpppBackendResources backend_resources
Definition bppp.cpp:107
std::unordered_map< GeneratorBackendCacheKey, OwnedBpppBackendResources, GeneratorBackendCacheKeyHash > backend_resources
Definition bppp.cpp:117
std::unordered_map< CircuitNormArgPublicDataCacheKey, std::shared_ptr< const void >, CircuitNormArgPublicDataCacheKeyHash > public_data
Definition bppp.cpp:114
Experimental transparent circuit proof backed by the standalone BPPP norm argument.
Definition bppp.hpp:262
Masked circuit proof with a pre-challenge raw-coordinate commitment.
Definition bppp.hpp:268
std::array< unsigned char, 32 > public_commitment_dlog_nonce
Even-Y Schnorr nonce x-coordinate for the batched public-commitment DLog proof.
Definition bppp.hpp:274
PointBytes a_commitment
Raw-coordinate commitment made before reduction challenges.
Definition bppp.hpp:270
ScalarBytes public_commitment_dlog_response
Schnorr response for the batched public-commitment DLog proof.
Definition bppp.hpp:276
std::size_t operator()(const GeneratorBackendCacheKey &key) const noexcept
Definition bppp.cpp:55
Inputs for norm commitment computation and standalone BPPP proofs. Proving requires power-of-two vect...
Definition bppp.hpp:106
std::vector< ScalarBytes > l_vec
Definition bppp.hpp:110
std::vector< PointBytes > generators
Definition bppp.hpp:108
std::vector< ScalarBytes > n_vec
Definition bppp.hpp:109
std::vector< ScalarBytes > c_vec
Definition bppp.hpp:111
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
static purify_bppp_backend_resources * get_or_create_backend_resources(ExperimentalCircuitBackend *backend, std::span< const PointBytes > generators, purify_secp_context *secp_context)
Definition bppp.cpp:94
static std::shared_ptr< const void > find_public_data(const ExperimentalCircuitBackend *backend, const std::array< unsigned char, 32 > &key)
Definition bppp.cpp:78
static void insert_public_data(ExperimentalCircuitBackend *backend, std::array< unsigned char, 32 > key, std::shared_ptr< const void > value)
Definition bppp.cpp:85
static const purify_scalar & raw(const FieldElement &value) noexcept
Definition numeric.hpp:940
int PURIFY_UINT_FN is_zero(const uint64_t value[PURIFY_UINT_WORDS])
Definition uint_impl.h:38