22#include <unordered_map>
41 std::unique_ptr<purify_bppp_backend_resources, BpppBackendResourcesDeleter>;
45template <
typename Digest>
47 static_assert(
sizeof(std::size_t) <= std::tuple_size_v<Digest>,
48 "digest prefix hash must fit within digest output");
50 std::memcpy(&out, digest.data(),
sizeof(std::size_t));
64 std::span<const PointBytes> generators) {
66 auto serialized_view = std::as_bytes(generators);
67 const unsigned char *serialized =
68 serialized_view.empty()
70 :
reinterpret_cast<const unsigned char *
>(serialized_view.data());
71 purify_sha256(key.data(), serialized, serialized_view.size());
77std::shared_ptr<const void>
80 const std::array<unsigned char, 32> &key) {
81 return backend !=
nullptr ? backend->find_public_data_impl(key)
82 : std::shared_ptr<const void>{};
87 std::shared_ptr<const void> value) {
88 if (backend !=
nullptr) {
89 backend->insert_public_data_impl(std::move(key), std::move(value));
96 std::span<const PointBytes> generators,
98 return backend !=
nullptr
99 ? backend->get_or_create_backend_resources_impl(generators,
112 std::shared_ptr<const void>,
121 : impl_(std::make_unique<
Impl>()) {}
132 return impl_ ==
nullptr || impl_->backend_resources ==
nullptr;
135std::shared_ptr<const void> ExperimentalCircuitCacheLine::find_public_data_impl(
136 const std::array<unsigned char, 32> &key)
const {
141void ExperimentalCircuitCacheLine::insert_public_data_impl(
142 std::array<unsigned char, 32> key, std::shared_ptr<const void> value) {
148ExperimentalCircuitCacheLine::get_or_create_backend_resources_impl(
149 std::span<const PointBytes> generators,
152 if (impl_ ==
nullptr || impl_->backend_resources ==
nullptr ||
153 generators.empty() || !impl_->has_backend_key) {
157 ? impl_->backend_resources.get()
162 : impl_(std::make_unique<
Impl>()) {}
173 if (impl_ !=
nullptr) {
174 impl_->public_data.clear();
175 impl_->backend_resources.clear();
180 return impl_ !=
nullptr
181 ? impl_->public_data.
size() + impl_->backend_resources.size()
186 std::span<const PointBytes> generators)
const {
188 if (impl_ ==
nullptr || generators.empty()) {
193 auto it = impl_->backend_resources.find(key);
194 if (it == impl_->backend_resources.end()) {
200 if (cloned ==
nullptr) {
203 "ExperimentalCircuitCache::clone_line_for_thread:backend_resources");
205 clone.impl_->backend_key = key;
206 clone.impl_->has_backend_key =
true;
207 clone.impl_->backend_resources.reset(cloned);
212 const std::array<unsigned char, 32> &key)
const {
213 return find_public_data_impl(key);
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));
224 std::span<const PointBytes> generators,
226 return get_or_create_backend_resources_impl(generators, secp_context);
229std::shared_ptr<const void> ExperimentalCircuitCache::find_public_data_impl(
230 const std::array<unsigned char, 32> &key)
const {
231 if (impl_ ==
nullptr) {
234 auto it = impl_->public_data.find(key);
235 if (it == impl_->public_data.end()) {
241void ExperimentalCircuitCache::insert_public_data_impl(
242 std::array<unsigned char, 32> key,
243 std::shared_ptr<const void> value) {
244 if (impl_ ==
nullptr) {
247 impl_->public_data.emplace(std::move(key), std::move(value));
251ExperimentalCircuitCache::get_or_create_backend_resources_impl(
252 std::span<const PointBytes> generators,
254 if (impl_ ==
nullptr || secp_context ==
nullptr || generators.empty()) {
258 auto serialized_view = std::as_bytes(generators);
259 const unsigned char *serialized =
260 serialized_view.empty()
262 :
reinterpret_cast<const unsigned char *
>(serialized_view.data());
266 auto it = impl_->backend_resources.find(key);
267 if (it != impl_->backend_resources.end()) {
268 return it->second.get();
274 if (created ==
nullptr) {
280 return inserted.first->second.get();
288 SecretBytes() =
default;
289 SecretBytes(
const SecretBytes &) =
delete;
290 SecretBytes &operator=(
const SecretBytes &) =
delete;
296using SecretScalarBytes = ::purify::detail::Secret<ScalarBytes>;
298using ::purify::detail::WipeOnDestruction;
300void secure_clear_field_element(FieldElement &value)
noexcept {
301 static_assert(std::is_trivially_destructible_v<FieldElement>);
305template <
typename ByteArray>
constexpr void assert_packed_byte_array_layout() {
307 std::is_same_v<typename ByteArray::value_type, unsigned char>,
308 "byte-span bridge helpers require unsigned-char array elements");
310 std::is_trivially_copyable_v<ByteArray>,
311 "byte-span bridge helpers require trivially copyable array wrappers");
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 "
322template <
typename ByteArray>
323std::span<const unsigned char> byte_span(
const std::vector<ByteArray> &values) {
324 assert_packed_byte_array_layout<ByteArray>();
326 std::as_bytes(std::span<const ByteArray>(values.data(), values.size()));
327 return {
reinterpret_cast<const unsigned char *
>(bytes.data()), bytes.size()};
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()};
339bool require_ok(
int ok) {
return ok != 0; }
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);
389struct ResolvedBpppGeneratorBackend {
390 std::span<const unsigned char> serialized_bytes{};
391 std::size_t generator_count = 0;
395ResolvedBpppGeneratorBackend resolve_bppp_generator_backend(
397 const std::vector<PointBytes> &serialized_generators,
399 ResolvedBpppGeneratorBackend out;
400 out.serialized_bytes = byte_span(serialized_generators);
401 out.generator_count = serialized_generators.size();
403 if (cache ==
nullptr || serialized_generators.empty()) {
406 out.backend_resources =
408 cache, serialized_generators, secp_context);
413 const char *context) {
418 while (out < value) {
419 if (out > std::numeric_limits<std::size_t>::max() / 2) {
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));
434 const TaggedHash& tag,
436 Bytes prefix(seed.begin(), seed.end());
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);
447 tag.digest(std::span<const unsigned char>(input.data(), input.size()));
455 "derive_nonzero_scalar:exhausted");
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) {
462 prefix.value.reserve(seed.size() + 2 *
sizeof(std::uint64_t));
463 prefix.value.assign(seed.begin(), seed.end());
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) {
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;
488 "derive_scalar:exhausted");
491Status derive_secret_nonzero_scalar(FieldElement &out,
492 std::span<const unsigned char> seed,
493 const TaggedHash &tag,
496 prefix.value.reserve(seed.size() +
sizeof(std::uint64_t));
497 prefix.value.assign(seed.begin(), seed.end());
499 const auto &encoded_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) {
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;
525 "derive_secret_nonzero_scalar:exhausted");
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;
536 for (std::size_t i = 0; i < lhs.size(); ++i) {
537 total = total + (weight * lhs[i] * rhs[i]);
538 weight = weight * mu;
543struct CircuitNormArgPublicData {
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;
564using CircuitNormArgPublicDataPtr =
565 std::shared_ptr<const CircuitNormArgPublicData>;
567struct CircuitNormArgReduction {
568 CircuitNormArgPublicDataPtr public_data;
569 std::vector<FieldElement> n_vec;
570 std::vector<FieldElement> l_vec;
573struct CircuitNormArgChallenges {
575 FieldElement mul_scale;
576 FieldElement mul_ratio;
577 FieldElement row_ratio;
581 const FieldElement &scalar,
584 const FieldElement &scalar,
594 std::span<const unsigned char> binding_digest,
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());
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;
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;
617 "circuit_norm_arg_dimensions:minimum_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");
626 "circuit_norm_arg_dimensions:used_l");
630 "circuit_norm_arg_dimensions:n_vec_len");
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");
639 const NativeBulletproofCircuit &circuit,
640 const BulletproofAssignmentData &assignment,
641 std::span<const FieldElement> padding,
642 bool externalize_commitments,
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) {
650 "build_raw_circuit_norm_arg_inputs:assignment_shape");
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) {
660 "build_raw_circuit_norm_arg_inputs:padding_size");
663 std::size_t generator_count = 0;
667 "build_raw_circuit_norm_arg_inputs:generator_count");
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,
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];
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];
690 if (!padding.empty()) {
691 std::copy(padding.begin(), padding.end(),
692 raw_l.begin() + dimensions.used_l);
700 const NativeBulletproofCircuit &circuit,
701 std::span<const unsigned char> statement_binding,
704 bool externalize_commitments =
false,
706 const CircuitNormArgChallenges *explicit_challenges =
nullptr) {
710 "build_circuit_norm_arg_public_data:secp_context");
711 if (!circuit.has_valid_shape()) {
713 "build_circuit_norm_arg_public_data:circuit_shape");
718 "build_circuit_norm_arg_public_data:n_gates_power_of_two");
721 Bytes challenge_digest;
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;
732 if (raw_commitment ==
nullptr) {
735 "build_circuit_norm_arg_public_data:raw_commitment");
738 const auto &binding_digest,
740 "build_circuit_norm_arg_public_data:binding_digest");
743 circuit_norm_arg_precommit_digest(binding_digest, *raw_commitment),
744 "build_circuit_norm_arg_public_data:challenge_digest");
747 derive_nonzero_scalar(challenge_digest, kCircuitNormArgRhoTaggedHash,
749 "build_circuit_norm_arg_public_data:rho");
752 derive_nonzero_scalar(challenge_digest, kCircuitNormArgMulTaggedHash,
754 "build_circuit_norm_arg_public_data:mul_scale");
757 derive_nonzero_scalar(challenge_digest, kCircuitNormArgMulTaggedHash,
759 "build_circuit_norm_arg_public_data:mul_ratio");
760 if (!circuit.c.empty()) {
763 derive_nonzero_scalar(challenge_digest,
764 kCircuitNormArgConstraintTaggedHash, 0),
765 "build_circuit_norm_arg_public_data:constraint_ratio");
769 const auto &dimensions,
770 circuit_norm_arg_dimensions(circuit, externalize_commitments),
771 "build_circuit_norm_arg_public_data:dimensions");
774 "build_circuit_norm_arg_public_data:sqrt_minus_one");
779 const FieldElement inv2 = two.inverse();
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;
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) {
797 row_weight = row_weight * row_ratio;
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();
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]);
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);
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);
830 auto out = std::make_shared<CircuitNormArgPublicData>();
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);
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;
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());
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];
859 if (externalize_commitments) {
860 out->public_commitment_coeffs = std::move(commitment_coeffs);
862 for (std::size_t i = 0; i < circuit.n_commitments; ++i) {
863 out->c_vec[dimensions.gate_count + i] = commitment_coeffs[i];
866 out->target = constant.negate();
869 std::size_t raw_n_value_count = 0;
872 "build_circuit_norm_arg_public_data:raw_n_value_count");
874 std::size_t generator_count = 0;
879 "build_circuit_norm_arg_public_data:generator_count");
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);
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;
901 generator_scale(out->raw_generators[i],
902 rho_power * term.inverse(), secp_context),
903 "build_circuit_norm_arg_public_data:scale_generator");
905 generator_term = generator_term * mul_ratio;
907 rho_power = rho_power * rho;
909 CircuitNormArgPublicDataPtr shared = out;
914 const NativeBulletproofCircuit &circuit,
915 std::span<const unsigned char> statement_binding,
918 bool externalize_commitments =
false,
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);
927build_circuit_norm_arg_public_data_from_challenges(
928 const NativeBulletproofCircuit &circuit,
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);
938 const NativeBulletproofCircuit &circuit,
939 const BulletproofAssignmentData &assignment,
942 std::span<const unsigned char> statement_binding,
943 bool externalize_commitments =
false,
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) {
952 "reduce_experimental_circuit_to_norm_arg:assignment_shape");
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");
963 CircuitNormArgReduction out;
964 out.public_data = public_data;
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];
975 out.public_data->plus_terms[i] * plus_value * rho_weight_inv;
976 rho_weight_inv = rho_weight_inv * rho_inv;
978 FieldElement minus_value = assignment.left[i] - assignment.right[i] +
979 out.public_data->minus_shift[i];
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;
985 out.l_vec[i] = assignment.output[i];
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];
996NormArgInputs build_norm_arg_inputs(
const CircuitNormArgReduction &reduction) {
998 inputs.
rho = reduction.public_data->rho_bytes;
999 inputs.generators = reduction.public_data->generators;
1002 inputs.c_vec = reduction.public_data->c_vec_bytes;
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");
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");
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;
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);
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");
1056 const FieldElement &scalar,
1059 SecretScalarBytes scalar32;
1061 scalar32.value.data(),
1064 "offset_commitment:secp_context");
1066 scalar32.value.data(),
1069 "offset_commitment:backend");
1075 const FieldElement &scalar,
1078 SecretScalarBytes scalar32;
1080 scalar32.value.data(),
1083 "point_scale:secp_context");
1086 scalar32.value.data(), out.data()))) {
1088 "point_scale:backend");
1094 const FieldElement &scalar,
1097 SecretScalarBytes scalar32;
1099 scalar32.value.data(),
1103 "generator_scale:secp_context");
1105 secp_context, generator.data(), scalar32.value.data(),
1108 "generator_scale:backend");
1118 "generator_to_point:secp_context");
1120 secp_context, generator.data(), out.data()))) {
1122 "generator_to_point:backend");
1132 "point_add:secp_context");
1136 "point_add:backend");
1147 "point_add_allow_infinity:secp_context"),
1148 "point_add_allow_infinity:secp_context");
1150 secp_context, lhs.data(), rhs.data(), out.data()))) {
1152 "point_add_allow_infinity:backend");
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");
1176 SecretScalarBytes value;
1185struct BatchedPublicCommitment {
1187 std::vector<FieldElement> weights;
1191 std::span<const PointBytes> public_commitments,
1192 const FieldElement &eta,
1194 if (public_commitments.empty()) {
1196 "batch_public_commitments:empty");
1199 BatchedPublicCommitment out;
1200 out.point = public_commitments.front();
1201 out.weights.reserve(public_commitments.size());
1203 FieldElement weight = eta;
1204 for (std::size_t i = 1; i < public_commitments.size(); ++i) {
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;
1219 std::span<const PointBytes> public_commitments,
1220 std::span<const unsigned char> challenge_digest,
1224 derive_nonzero_scalar(challenge_digest, kCircuitDlogBatchTaggedHash, 0),
1225 "batch_public_commitments:eta");
1226 return batch_public_commitments_with_eta(public_commitments, eta,
1231 std::span<const unsigned char> challenge_digest,
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);
1240struct PublicCommitmentDlogProof {
1241 std::array<unsigned char, 32> nonce_xonly{};
1246 const BatchedPublicCommitment &batched,
1247 std::span<const FieldElement> commitment_values,
1248 std::span<const unsigned char> challenge_digest,
1251 if (batched.weights.size() != commitment_values.size()) {
1253 "prove_public_commitment_dlog:values");
1257 for (std::size_t i = 0; i < commitment_values.size(); ++i) {
1258 FieldElement term = batched.weights[i] * commitment_values[i];
1260 FieldElement next = value + term;
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());
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");
1288 PublicCommitmentDlogProof out;
1291 secp_context, nonce_point.data(), out.nonce_xonly.data(), &parity) ==
1294 "prove_public_commitment_dlog:nonce_xonly");
1296 FieldElement negated_nonce = nonce.negate();
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;
1305 const FieldElement response = nonce + challenge_value;
1306 if (response.is_zero()) {
1308 "prove_public_commitment_dlog:zero_response");
1314template <
typename ChallengeCallback>
1316 const BatchedPublicCommitment &batched,
1317 std::span<const FieldElement> commitment_values,
1318 std::span<const unsigned char> nonce_binding,
1321 ChallengeCallback &&challenge_callback) {
1322 if (batched.weights.size() != commitment_values.size()) {
1324 "prove_public_commitment_dlog_v4:values");
1328 for (std::size_t i = 0; i < commitment_values.size(); ++i) {
1329 FieldElement term = batched.weights[i] * commitment_values[i];
1331 FieldElement next = value + term;
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());
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");
1359 PublicCommitmentDlogProof out;
1362 secp_context, nonce_point.data(), out.nonce_xonly.data(), &parity) ==
1365 "prove_public_commitment_dlog_v4:nonce_xonly");
1367 FieldElement negated_nonce = nonce.negate();
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;
1375 const FieldElement response = nonce + challenge_value;
1376 if (response.is_zero()) {
1378 "prove_public_commitment_dlog_v4:zero_response");
1385 const BatchedPublicCommitment &batched,
1386 const FieldElement &challenge,
1387 const PublicCommitmentDlogProof &proof,
1391 "verify_public_commitment_dlog:response");
1392 if (response.is_zero()) {
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");
1407 point_add(nonce_point, scaled_commitment, secp_context);
1408 return rhs.has_value() && lhs == *rhs;
1412 const BatchedPublicCommitment &batched,
1413 std::span<const unsigned char> challenge_digest,
1414 const PublicCommitmentDlogProof &proof,
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,
1425 std::span<const PointBytes> public_commitments,
1426 std::span<const unsigned char> statement_binding) {
1428 const auto &encoded_commitment_count,
1430 "bind_public_commitments:count"),
1431 "bind_public_commitments:count");
1433 const auto &encoded_binding_size,
1435 "bind_public_commitments:statement_binding"),
1436 "bind_public_commitments:statement_binding");
1438 std::size_t point_bytes = 0;
1439 std::size_t total_size = 0;
1448 "bind_public_commitments:reserve");
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());
1455 append_u64_le(out, encoded_binding_size);
1456 out.insert(out.end(), statement_binding.begin(), statement_binding.end());
1461validate_public_commitments(std::span<const PointBytes> public_commitments,
1462 std::span<const FieldElement> commitments,
1464 if (public_commitments.size() != commitments.size()) {
1466 "validate_public_commitments:size");
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");
1482 std::span<const PointBytes> points,
1483 std::span<const FieldElement> scalars,
1485 if (points.size() != scalars.size()) {
1487 "add_scaled_points_allow_infinity:size");
1490 for (std::size_t i = 0; i < points.size(); ++i) {
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");
1506 const CircuitNormArgPublicData &public_data,
1507 std::span<const PointBytes> public_commitments,
1509 if (public_commitments.size() !=
1510 public_data.public_commitment_coeffs.size()) {
1512 "circuit_anchored_offset_v4:public_size");
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]);
1526 if (!public_data.target.is_zero()) {
1529 point_from_scalar_base(public_data.target, secp_context),
1530 "circuit_anchored_offset_v4:target");
1531 points.push_back(std::move(target));
1534 for (std::size_t i = 0; i < public_commitments.size(); ++i) {
1535 points.push_back(public_commitments[i]);
1537 public_data.public_commitment_coeffs[i].negate());
1539 return add_scaled_points_allow_infinity(
1540 PointBytes{}, points, scalars, secp_context);
1544anchor_zk_a_commitment(
const PointBytes &a_witness_commitment,
1545 const CircuitNormArgPublicData &public_data,
1546 std::span<const PointBytes> public_commitments,
1550 circuit_anchored_offset_v4(public_data, public_commitments,
1552 "anchor_zk_a_commitment:offset");
1554 const auto &anchored,
1555 point_add_allow_infinity(a_witness_commitment, offset,
1557 "anchor_zk_a_commitment:add");
1560 "anchor_zk_a_commitment:identity");
1566 const CircuitNormArgPublicData &public_data,
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(); });
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);
1583commit_explicit_norm_arg(
const NormArgInputs &inputs,
const FieldElement &value,
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);
1594 const FieldElement &challenge,
1595 const FieldElement &t2,
1598 "combine_zk_commitments:scale_s");
1600 "combine_zk_commitments:add");
1601 return offset_commitment(combined, challenge * challenge * t2, secp_context);
1604template <
typename Inputs>
1606prove_norm_arg_impl(Inputs &&inputs,
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");
1615 if (inputs.l_vec.size() != inputs.c_vec.size()) {
1617 "prove_norm_arg:l_c_size_mismatch");
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;
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 =
1637 Bytes proof(proof_len);
1639 if (proof_len == 0) {
1641 "prove_norm_arg:proof_len_zero");
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(),
1656 if (!require_ok(ok)) {
1658 "prove_norm_arg:backend");
1660 proof.resize(proof_len);
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);
1669 proof_generators = inputs.generators;
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);
1677 proof_c_vec = inputs.c_vec;
1681 std::move(proof_generators),
1682 std::move(proof_c_vec),
1683 inputs.n_vec.size(),
1689derive_zk_challenge(std::span<const unsigned char> binding_digest,
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());
1696 seed.insert(seed.end(), t2_bytes.begin(), t2_bytes.end());
1697 return derive_nonzero_scalar(seed, kCircuitZkChallengeTaggedHash, 0);
1704 bool ok = secp_context !=
nullptr
1706 assert(ok &&
"base_generator() requires a functioning backend");
1713 bool ok = secp_context !=
nullptr
1716 assert(ok &&
"value_generator_h() requires a functioning backend");
1723 std::vector<PointBytes> out(count);
1728 "create_generators:secp_context");
1729 std::span<unsigned char> serialized = writable_byte_span(out);
1730 std::size_t serialized_len = serialized.size();
1733 &serialized_len))) {
1735 "create_generators:backend");
1737 if (serialized_len != serialized.size()) {
1739 "create_generators:serialized_len");
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");
1754 if (inputs.
l_vec.size() != inputs.
c_vec.size()) {
1756 "commit_norm_arg:l_c_size_mismatch");
1759 const std::vector<PointBytes> *generators = &inputs.
generators;
1760 std::vector<PointBytes> generated_generators;
1761 if (generators->empty()) {
1764 "commit_norm_arg:create_generators");
1765 generated_generators = std::move(generated);
1766 generators = &generated_generators;
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);
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");
1808 "pedersen_commit_char:secp_context");
1810 secp_context, blind.data(), value.data(), value_gen.data(), blind_gen.data(),
1811 commitment.data()))) {
1813 "pedersen_commit_char:backend");
1820 return prove_norm_arg_impl(inputs, secp_context,
nullptr);
1825 return prove_norm_arg_impl(std::move(inputs), secp_context,
nullptr);
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");
1839 if (inputs.
l_vec.size() != inputs.
c_vec.size()) {
1841 "prove_norm_arg_to_commitment:l_c_size_mismatch");
1844 const std::vector<PointBytes> *generators = &inputs.
generators;
1845 std::vector<PointBytes> generated_generators;
1846 if (generators->empty()) {
1849 "prove_norm_arg_to_commitment:create_generators");
1850 generated_generators = std::move(generated);
1851 generators = &generated_generators;
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 =
1861 Bytes proof(proof_len);
1862 if (proof_len == 0) {
1864 "prove_norm_arg_to_commitment:proof_len_zero");
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(),
1880 if (!require_ok(ok)) {
1882 "prove_norm_arg_to_commitment:backend");
1884 proof.resize(proof_len);
1886 std::vector<PointBytes> proof_generators;
1887 if (!generated_generators.empty()) {
1888 proof_generators = std::move(generated_generators);
1894 commitment, std::move(proof)};
1900 std::vector<candidate::PackedPointPairV4>
rounds;
1905 const unsigned char point_pair65[65],
1907 unsigned char challenge32[32]) {
1909 if (round != callback.rounds.size()) {
1913 std::copy_n(point_pair65, pair.size(), pair.begin());
1915 callback.transcript->append_round(pair, callback.secp_context);
1916 if (!challenge.has_value()) {
1917 callback.error = challenge.error();
1920 const ScalarBytes encoded = challenge->scalar.to_bytes_be();
1921 std::copy(encoded.begin(), encoded.end(), challenge32);
1922 callback.rounds.push_back(pair);
1930 if (inputs.
n_vec.empty() || inputs.
l_vec.empty() || inputs.
c_vec.empty() ||
1931 inputs.
l_vec.size() != inputs.
c_vec.size() ||
1935 "prove_norm_arg_to_commitment_v4:inputs");
1939 if (proof_capacity == 0) {
1941 "prove_norm_arg_to_commitment_v4:proof_size");
1944 Bytes proof(proof_capacity);
1945 std::size_t proof_len = proof.size();
1947 const std::span<const unsigned char> 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(),
1955 l_vec.data(), inputs.
l_vec.size(), c_vec.data(), inputs.
c_vec.size(),
1959 if (callback.
error.has_value()) {
1961 "prove_norm_arg_to_commitment_v4:transcript");
1964 "prove_norm_arg_to_commitment_v4:backend");
1968 "prove_norm_arg_to_commitment_v4:rounds");
1970 proof.resize(proof_len);
1972 inputs.
n_vec.size(), commitment, std::move(proof)};
1978 if (secp_context ==
nullptr) {
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);
1989 resolved.backend_resources !=
nullptr
1991 resolved.backend_resources, proof.
rho.data(), c_vec.data(),
1995 secp_context, proof.
rho.data(), resolved.serialized_bytes.data(),
1996 resolved.generator_count, c_vec.data(), proof.
c_vec.size(),
1998 proof.
proof.size());
2005 std::size_t pair_bytes = 0;
2006 std::size_t expected_size = 0;
2010 proof.size() != expected_size) {
2012 "parse_norm_rounds_v4:proof_size");
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(),
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());
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());
2038 std::span<const candidate::CircuitChallengeV4> gammas,
2043 const std::span<const unsigned char> generators =
2045 const std::span<const unsigned char> c_vec = byte_span(norm.
c_vec);
2047 secp_context, norm.
rho.data(), generators.data(),
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");
2062 std::span<const candidate::CircuitChallengeV4> gammas,
2065 const std::span<const unsigned char> generators =
2067 const std::span<const unsigned char> c_vec = byte_span(norm.
c_vec);
2069 secp_context, norm.
rho.data(), generators.data(),
2073 reinterpret_cast<const unsigned char *
>(encoded_gammas.data()),
2074 encoded_gammas.size()) != 0;
2101 build_raw_circuit_norm_arg_inputs(circuit, assignment, {},
false,
2103 "commit_experimental_circuit_witness:raw_inputs");
2106 return commit_norm_arg_witness_only(raw_inputs, secp_context, cache);
2115 std::span<const unsigned char> statement_binding,
2120 "prove_experimental_circuit_norm_arg_to_commitment:circuit_shape");
2124 "prove_experimental_circuit_norm_arg_to_commitment:"
2125 "n_gates_power_of_two");
2133 "prove_experimental_circuit_norm_arg_to_commitment:assignment_shape");
2135 if (!circuit.
evaluate(assignment)) {
2138 "prove_experimental_circuit_norm_arg_to_commitment:assignment_invalid");
2143 build_raw_circuit_norm_arg_inputs(circuit, assignment, {},
false,
2145 "prove_experimental_circuit_norm_arg_to_commitment:raw_inputs");
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");
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");
2172 const auto &anchored_commitment,
2173 anchor_zk_a_commitment(witness_commitment, *reduction.public_data, {},
2175 "prove_experimental_circuit_norm_arg_to_commitment:anchor");
2180 secp_context,
nullptr),
2181 "prove_experimental_circuit_norm_arg_to_commitment:prove");
2183 std::move(proof.proof)};
2190 std::span<const unsigned char> statement_binding,
2193 const auto &witness_commitment,
2196 "prove_experimental_circuit_norm_arg:commit_witness");
2198 circuit, assignment, witness_commitment, secp_context, statement_binding, cache);
2205 std::span<const unsigned char> statement_binding,
2210 "verify_experimental_circuit_norm_arg:circuit_shape");
2215 "verify_experimental_circuit_norm_arg:n_gates_power_of_two");
2217 if (proof.
proof.empty()) {
2219 "verify_experimental_circuit_norm_arg:proof_empty");
2223 const auto &public_data,
2224 build_circuit_norm_arg_public_data(circuit, statement_binding,
2227 "verify_experimental_circuit_norm_arg:public_data");
2229 const auto &anchored_commitment,
2232 "verify_experimental_circuit_norm_arg:anchor");
2235 bundle.
rho = public_data->rho_bytes;
2237 bundle.
c_vec = public_data->c_vec_bytes;
2238 bundle.
n_vec_len = public_data->n_vec_len;
2249 std::span<const PointBytes> public_commitments,
2251 std::span<const unsigned char> statement_binding,
2256 "prove_experimental_circuit_zk_norm_arg_impl:circuit_shape");
2261 "prove_experimental_circuit_zk_norm_arg_impl:n_gates_power_of_two");
2269 "prove_experimental_circuit_zk_norm_arg_impl:assignment_shape");
2271 if (externalize_commitments &&
2275 "prove_experimental_circuit_zk_norm_arg_impl:public_commitment_count");
2277 if (!circuit.
evaluate(assignment)) {
2280 "prove_experimental_circuit_zk_norm_arg_impl:assignment_invalid");
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");
2290 bound_statement_binding =
2291 Bytes(statement_binding.begin(), statement_binding.end());
2293 if (externalize_commitments) {
2294 if (public_commitments.empty()) {
2297 "prove_experimental_circuit_zk_norm_arg_impl:public_commitments");
2300 validate_public_commitments(public_commitments, assignment.
commitments, secp_context),
2301 "prove_experimental_circuit_zk_norm_arg_impl:"
2302 "validate_public_commitments");
2306 const auto &binding_digest,
2308 "prove_experimental_circuit_zk_norm_arg_impl:binding_digest");
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;
2321 for (std::uint64_t attempt = 0; attempt < 32; ++attempt) {
2322 std::vector<FieldElement> padding(
2325 for (std::size_t i = 0; i < padding.size(); ++i) {
2327 derive_scalar(padding[i], seed.value, kCircuitZkBlindTaggedHash, i,
2329 "prove_experimental_circuit_zk_norm_arg_impl:blind");
2334 build_raw_circuit_norm_arg_inputs(circuit, assignment, padding,
2335 externalize_commitments,
2337 "prove_experimental_circuit_zk_norm_arg_impl:raw_inputs");
2341 commit_norm_arg_witness_only(raw_inputs, secp_context, cache);
2343 if (!masked_failure.has_value()) {
2345 raw_commitment.
error(),
2346 "prove_experimental_circuit_zk_norm_arg_impl:"
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");
2361 std::copy(padding.begin(), padding.end(),
2362 hidden.l_vec.begin() + dimensions.used_l);
2364 PublicCommitmentDlogProof dlog_proof;
2365 if (externalize_commitments) {
2367 public_commitments, hidden.public_data->challenge_digest,
2370 if (!masked_failure.has_value()) {
2373 "prove_experimental_circuit_zk_norm_arg_impl:"
2374 "batch_public_commitments")
2380 prove_public_commitment_dlog(
2382 hidden.public_data->challenge_digest, secret_prover_seed,
2385 if (!masked_failure.has_value()) {
2388 "prove_experimental_circuit_zk_norm_arg_impl:"
2389 "prove_public_commitment_dlog")
2399 for (std::size_t i = 0; i < mask_n.size(); ++i) {
2401 derive_scalar(mask_n[i], seed.value, kCircuitZkMaskNTaggedHash, i,
2403 "prove_experimental_circuit_zk_norm_arg_impl:mask_n");
2408 for (std::size_t i = 0; i < mask_l.size(); ++i) {
2410 derive_scalar(mask_l[i], seed.value, kCircuitZkMaskLTaggedHash, i,
2412 "prove_experimental_circuit_zk_norm_arg_impl:mask_l");
2416 weighted_bppp_inner_product(mask_n, mask_n, hidden.public_data->rho);
2422 weighted_bppp_inner_product(hidden.n_vec, mask_n,
2423 hidden.public_data->rho);
2425 for (std::size_t i = 0; i < mask_l.size(); ++i) {
2426 t1 = t1 + (mask_l[i] * hidden.public_data->c_vec[i]);
2430 mask_inputs.
rho = hidden.public_data->rho_bytes;
2431 mask_inputs.
generators = hidden.public_data->generators;
2434 mask_inputs.
c_vec = hidden.public_data->c_vec_bytes;
2439 *raw_commitment, *hidden.public_data, public_commitments, secp_context);
2441 if (!masked_failure.has_value()) {
2444 a_commitment.
error(),
2445 "prove_experimental_circuit_zk_norm_arg_impl:a_commitment")
2451 commit_explicit_norm_arg(mask_inputs, t1, secp_context,
nullptr);
2453 if (!masked_failure.has_value()) {
2456 s_commitment.
error(),
2457 "prove_experimental_circuit_zk_norm_arg_impl:s_commitment")
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");
2468 CircuitNormArgReduction masked = hidden;
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]);
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]);
2477 NormArgInputs masked_inputs = build_norm_arg_inputs(masked);
2482 combine_zk_commitments(*a_commitment, *s_commitment, challenge, t2, secp_context);
2484 if (!masked_failure.has_value()) {
2486 "prove_experimental_circuit_zk_norm_"
2487 "arg_impl:combined_commitment")
2495 if (!masked_failure.has_value()) {
2498 direct_commitment.
error(),
2499 "prove_experimental_circuit_zk_norm_arg_impl:direct_commitment")
2504 if (*combined_commitment != *direct_commitment) {
2507 "prove_experimental_circuit_zk_norm_arg_impl:commitment_mismatch");
2511 masked_inputs, *combined_commitment, secp_context,
nullptr);
2513 if (!masked_failure.has_value()) {
2516 "prove_experimental_circuit_zk_norm_arg_impl:"
2517 "prove_norm_arg_to_commitment")
2526 dlog_proof.nonce_xonly,
2527 dlog_proof.response,
2528 std::move(proof->proof)};
2531 if (masked_failure.has_value()) {
2534 "prove_experimental_circuit_zk_norm_arg_impl:masking_attempts");
2538 "prove_experimental_circuit_zk_norm_arg_impl:masking_attempts");
2543Status validate_prepared_circuit_proof(
2545 const ExperimentalCircuitZkNormArgProof &proof) {
2549 "prepare_experimental_circuit_zk_norm_arg:circuit_shape");
2554 "prepare_experimental_circuit_zk_norm_arg:n_gates_power_of_two");
2556 if (proof.proof.empty()) {
2559 "prepare_experimental_circuit_zk_norm_arg:proof_empty");
2564bool has_zero_public_commitment_dlog(
2566 const auto all_zero = [](
const auto &bytes) {
2567 return std::all_of(bytes.begin(), bytes.end(),
2568 [](
unsigned char byte) { return byte == 0; });
2570 return all_zero(proof.public_commitment_dlog_nonce) &&
2571 all_zero(proof.public_commitment_dlog_response);
2575finish_prepared_circuit_proof(
2577 const CircuitNormArgPublicDataPtr &public_data,
2578 std::span<const PointBytes> public_commitments,
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,
2597 "prepare_experimental_circuit_zk_norm_arg:commitment");
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 =
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;
2624 std::span<const PointBytes> public_commitments,
2626 std::span<const unsigned char> statement_binding,
2629 "prepare_experimental_circuit_zk_norm_arg:validate");
2630 if (public_commitments.empty()) {
2633 "prepare_experimental_circuit_zk_norm_arg:public_commitments");
2638 "prepare_experimental_circuit_zk_norm_arg:public_commitment_count");
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,
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,
2663 "prepare_experimental_circuit_zk_norm_arg:verify_public_commitment_dlog");
2665 return std::optional<PreparedExperimentalCircuitZkNormArg>{};
2669 finish_prepared_circuit_proof(proof, public_data, public_commitments,
2671 "prepare_experimental_circuit_zk_norm_arg:finish");
2672 return std::optional<PreparedExperimentalCircuitZkNormArg>(std::move(out));
2680 std::span<const unsigned char> statement_binding,
2683 "prepare_experimental_circuit_zk_norm_arg:validate");
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,
2692 "prepare_experimental_circuit_zk_norm_arg:public_data");
2693 if (!has_zero_public_commitment_dlog(proof)) {
2694 return std::optional<PreparedExperimentalCircuitZkNormArg>{};
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));
2707 std::span<const unsigned char> statement_binding,
2712 circuit, proof, secp_context, statement_binding, cache),
2713 "verify_experimental_circuit_zk_norm_arg_impl:prepare");
2714 if (!prepared.has_value()) {
2725 const auto &dimensions,
2726 circuit_norm_arg_dimensions(circuit, externalize_commitments),
2727 "circuit_shape_v4:dimensions");
2728 const auto mode = externalize_commitments
2733 dimensions.n_vec_len, dimensions.l_vec_len);
2737 const NativeBulletproofCircuit &circuit,
2738 std::span<const unsigned char> statement_binding) {
2742 "circuit_binding_digest_v4:digest");
2744 if (digest.size() != out.size()) {
2746 "circuit_binding_digest_v4:size");
2748 std::copy(digest.begin(), digest.end(), out.begin());
2755 std::size_t generator_count = 0;
2759 "raw_generator_digest_v4:generator_count");
2763 "raw_generator_digest_v4:generators");
2767bool is_identity_point_v4(
const PointBytes &point) {
2768 return std::all_of(point.begin(), point.end(),
2769 [](
unsigned char byte) { return byte == 0; });
2772Status validate_circuit_proof_v4_inputs(
2773 const NativeBulletproofCircuit &circuit,
2774 std::span<const PointBytes> public_commitments,
2777 "circuit_proof_v4:context"),
2778 "circuit_proof_v4:context");
2779 if (!circuit.has_valid_shape() ||
2782 "circuit_proof_v4:circuit_shape");
2784 if (externalize_commitments) {
2785 if (public_commitments.empty() ||
2786 public_commitments.size() != circuit.n_commitments) {
2788 "circuit_proof_v4:public_commitments");
2790 if (std::any_of(public_commitments.begin(), public_commitments.end(),
2791 is_identity_point_v4)) {
2793 "circuit_proof_v4:identity_public_commitment");
2795 }
else if (!public_commitments.empty()) {
2797 "circuit_proof_v4:hidden_commitments");
2804 const char *label) {
2805 std::array<unsigned char, 32> xonly{};
2808 secp_context, point.data(), xonly.data(), &parity) == 0) {
2814Status validate_circuit_zk_norm_arg_proof_v4_fixed_encoding_impl(
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");
2832 "circuit_proof_v4_encoding:t2");
2838 proof.public_commitment_dlog_nonce.data()) == 0) {
2841 "circuit_proof_v4_encoding:dlog_nonce");
2844 const auto response,
2846 proof.public_commitment_dlog_response),
2847 "circuit_proof_v4_encoding:dlog_response");
2848 if (response.is_zero()) {
2851 "circuit_proof_v4_encoding:dlog_response");
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; }) ||
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");
2873 terminal_n, terminal_l),
2874 "circuit_proof_v4_encoding:rounds");
2875 for (
const auto &round : rounds) {
2878 "circuit_proof_v4_encoding:round");
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;
2893Status validate_circuit_zk_norm_arg_proof_v4_encoding_impl(
2894 const NativeBulletproofCircuit &circuit,
2896 std::span<const PointBytes> public_commitments,
2899 validate_circuit_proof_v4_inputs(
2900 circuit, public_commitments, secp_context,
2901 externalize_commitments),
2902 "circuit_proof_v4_encoding:inputs");
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);
2912reconstruct_circuit_zk_norm_arg_publication_v4_impl(
2913 const NativeBulletproofCircuit &circuit,
2915 std::span<const PointBytes> public_commitments,
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");
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");
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)};
2943prove_circuit_zk_norm_arg_v4_impl(
2944 const NativeBulletproofCircuit &circuit,
2945 const BulletproofAssignmentData &assignment,
2947 std::span<const PointBytes> public_commitments,
2949 std::span<const unsigned char> statement_binding,
2952 validate_circuit_proof_v4_inputs(circuit, public_commitments,
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");
2963 if (!circuit.evaluate(assignment)) {
2965 "prove_circuit_zk_norm_arg_v4:assignment");
2967 if (externalize_commitments) {
2969 validate_public_commitments(public_commitments,
2970 assignment.commitments, secp_context),
2971 "prove_circuit_zk_norm_arg_v4:public_values");
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");
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;
2992 public_point_bytes) ||
2994 assignment_scalar_count) ||
2996 assignment_scalar_count) ||
2998 assignment.commitments.size(),
2999 assignment_scalar_count) ||
3001 assignment_bytes) ||
3003 assignment_bytes) ||
3005 seed_prefix_size) ||
3010 "prove_circuit_zk_norm_arg_v4:seed_size");
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());
3022 const auto append_assignment_values =
3023 [&](std::span<const FieldElement> values) ->
Status {
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());
3041 "prove_circuit_zk_norm_arg_v4:left_seed");
3043 "prove_circuit_zk_norm_arg_v4:right_seed");
3045 "prove_circuit_zk_norm_arg_v4:output_seed");
3047 "prove_circuit_zk_norm_arg_v4:commitment_seed");
3048 assert(seed.value.size() == seed_size);
3050 std::optional<Error> masked_failure;
3051 for (std::uint64_t attempt = 0; attempt < 32; ++attempt) {
3052 std::vector<FieldElement> padding(
3055 for (std::size_t i = 0; i < padding.size(); ++i) {
3057 derive_scalar(padding[i], seed.value, kCircuitZkBlindV4TaggedHash,
3059 "prove_circuit_zk_norm_arg_v4:blind");
3064 build_raw_circuit_norm_arg_inputs(circuit, assignment, padding,
3065 externalize_commitments,
3067 "prove_circuit_zk_norm_arg_v4:raw_inputs");
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();
3078 const auto precommitment,
3080 shape, binding_digest, public_commitments, *raw_commitment,
3082 "prove_circuit_zk_norm_arg_v4:precommitment");
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};
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");
3100 raw_generator_digest) {
3102 "prove_circuit_zk_norm_arg_v4:raw_basis");
3106 std::copy(padding.begin(), padding.end(),
3107 hidden.l_vec.begin() + dimensions.used_l);
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,
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");
3125 transcript.append_anchored_commitments(
3126 coefficient_commitment, anchored_offset, anchored_commitment,
3128 "prove_circuit_zk_norm_arg_v4:eta");
3130 PublicCommitmentDlogProof dlog_proof;
3131 if (externalize_commitments) {
3133 const auto &batched,
3134 batch_public_commitments_with_eta(public_commitments, eta.scalar,
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(
3148 "prove_circuit_zk_norm_arg_v4:dlog_e");
3150 return challenge->scalar;
3152 if (!dlog.has_value()) {
3153 if (!masked_failure.has_value()) masked_failure = dlog.error();
3160 transcript.append_public_opening(
3161 PointBytes{}, dlog_proof.nonce_xonly, secp_context),
3162 "prove_circuit_zk_norm_arg_v4:hidden_dlog");
3166 const auto &dlog_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");
3173 const ScalarBytes precommitment_bytes = precommitment.digest.bytes();
3174 std::size_t mask_seed_size = 0;
3178 "prove_circuit_zk_norm_arg_v4:mask_seed_size");
3180 SecretBytes mask_seed;
3181 mask_seed.value.reserve(mask_seed_size);
3182 mask_seed.value.insert(mask_seed.value.end(), seed.value.begin(),
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(),
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");
3196 std::vector<FieldElement> mask_l(hidden.l_vec.size(),
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");
3206 FieldElement t2 = weighted_bppp_inner_product(
3207 mask_n, mask_n, hidden.public_data->rho);
3209 if (t2.is_zero())
continue;
3212 weighted_bppp_inner_product(hidden.n_vec, mask_n,
3213 hidden.public_data->rho);
3215 for (std::size_t i = 0; i < mask_l.size(); ++i) {
3216 t1 = t1 + mask_l[i] * hidden.public_data->c_vec[i];
3220 mask_inputs.
rho = hidden.public_data->rho_bytes;
3221 mask_inputs.generators = hidden.public_data->generators;
3224 mask_inputs.c_vec = hidden.public_data->c_vec_bytes;
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();
3237 transcript.append_mask(*mask_commitment, t2, secp_context),
3238 "prove_circuit_zk_norm_arg_v4:alpha");
3240 CircuitNormArgReduction masked = hidden;
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];
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];
3249 NormArgInputs masked_inputs = build_norm_arg_inputs(masked);
3252 auto combined_commitment = combine_zk_commitments(
3253 anchored_commitment, *mask_commitment, alpha.scalar, t2,
3255 if (!combined_commitment.has_value()) {
3256 if (!masked_failure.has_value()) {
3257 masked_failure = combined_commitment.error();
3262 const auto &direct_commitment,
3264 "prove_circuit_zk_norm_arg_v4:direct_commitment");
3265 if (*combined_commitment != direct_commitment) {
3267 "prove_circuit_zk_norm_arg_v4:commitment");
3270 transcript.append_combined_commitment(*combined_commitment,
3272 "prove_circuit_zk_norm_arg_v4:combined_transcript");
3275 masked_inputs, *combined_commitment, transcript, secp_context);
3276 if (!norm.has_value()) {
3277 if (!masked_failure.has_value()) masked_failure = norm.error();
3286 "prove_circuit_zk_norm_arg_v4:parse_norm");
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");
3306 dlog_proof.nonce_xonly,
3307 dlog_proof.response,
3308 std::move(norm->proof)};
3310 precommitment.digest, std::move(proof)};
3313 if (masked_failure.has_value()) {
3315 "prove_circuit_zk_norm_arg_v4:attempts");
3318 "prove_circuit_zk_norm_arg_v4:attempts");
3327 return validate_circuit_zk_norm_arg_proof_v4_fixed_encoding_impl(
3328 proof, mode, round_count, secp_context);
3335 return validate_circuit_zk_norm_arg_proof_v4_encoding_impl(
3336 circuit, proof, {}, secp_context,
false);
3340validate_circuit_zk_norm_arg_proof_v4_encoding_with_public_commitments(
3343 std::span<const PointBytes> public_commitments,
3345 return validate_circuit_zk_norm_arg_proof_v4_encoding_impl(
3346 circuit, proof, public_commitments, secp_context,
true);
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,
3362reconstruct_circuit_zk_norm_arg_publication_v4_with_public_commitments(
3365 std::span<const PointBytes> public_commitments,
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);
3377 std::span<const PointBytes> public_commitments,
3379 std::span<const unsigned char> statement_binding,
3382 validate_circuit_proof_v4_inputs(circuit, public_commitments,
3384 externalize_commitments),
3385 "prepare_circuit_zk_norm_arg_v4:inputs");
3388 "prepare_circuit_zk_norm_arg_v4:proof");
3392 return std::optional<candidate::PreparedCircuitZkNormArgV4>{};
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,
3406 "prepare_circuit_zk_norm_arg_v4:precommitment");
3407 if (expected_precommitment.digest.bytes() !=
3409 return std::optional<candidate::PreparedCircuitZkNormArgV4>{};
3412 const auto &raw_generator_digest,
3413 raw_generator_digest_v4(shape, secp_context),
3414 "prepare_circuit_zk_norm_arg_v4: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(
3427 secp_context, externalize_commitments, cache, &challenges),
3428 "prepare_circuit_zk_norm_arg_v4:public_data");
3430 raw_generator_digest) {
3432 "prepare_circuit_zk_norm_arg_v4:raw_basis");
3435 const auto &anchored_commitment,
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>{};
3443 const auto &anchored_offset,
3444 point_subtract_allow_infinity(anchored_commitment,
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");
3454 transcript.append_anchored_commitments(
3455 coefficient_commitment, anchored_offset, anchored_commitment,
3457 "prepare_circuit_zk_norm_arg_v4:eta");
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,
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");
3483 return std::optional<candidate::PreparedCircuitZkNormArgV4>{};
3486 const auto all_zero = [](
const auto &bytes) {
3487 return std::all_of(bytes.begin(), bytes.end(),
3488 [](
unsigned char byte) { return byte == 0; });
3490 if (!all_zero(dlog_proof.nonce_xonly) ||
3491 !all_zero(dlog_proof.response)) {
3492 return std::optional<candidate::PreparedCircuitZkNormArgV4>{};
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;
3502 const auto &dlog_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");
3512 "prepare_circuit_zk_norm_arg_v4:t2");
3517 "prepare_circuit_zk_norm_arg_v4:alpha");
3519 const auto &combined_commitment,
3520 combine_zk_commitments(anchored_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>{};
3528 transcript.append_combined_commitment(combined_commitment,
3530 "prepare_circuit_zk_norm_arg_v4:combined_transcript");
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));
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");
3561 public_data->generators,
3562 public_data->c_vec_bytes,
3563 public_data->n_vec_len,
3564 combined_commitment,
3569 raw_generator_digest,
3570 coefficient_commitment,
3572 anchored_commitment,
3573 batched_public_commitment,
3574 dlog_proof.nonce_xonly,
3575 dlog_proof.response,
3578 combined_commitment,
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;
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");
3609 const auto &residual,
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");
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));
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);
3642 std::span<const PointBytes> public_commitments,
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);
3656 std::span<const unsigned char> statement_binding,
3659 circuit, publication, {}, secp_context, statement_binding,
false,
3667 std::span<const PointBytes> public_commitments,
3669 std::span<const unsigned char> statement_binding,
3672 circuit, publication, public_commitments, secp_context,
3673 statement_binding,
true, cache);
3679derive_circuit_norm_parent_constants_v4_impl(
3682 std::span<const PointBytes> public_commitments,
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");
3697 auto binding_digest,
3698 circuit_binding_digest_v4(circuit, statement_binding),
3699 "circuit_parent_constants_v4:binding");
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,
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");
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,
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)};
3747 std::span<const PointBytes> public_commitments,
3749 std::span<const unsigned char> statement_binding) {
3750 return derive_circuit_norm_parent_constants_v4_impl(
3751 circuit, precommitment, public_commitments, secp_context,
3759 std::span<const unsigned char> statement_binding,
3764 statement_binding, cache),
3765 "verify_circuit_zk_norm_arg_v4:prepare");
3766 return prepared.has_value() &&
3775 std::span<const PointBytes> public_commitments,
3777 std::span<const unsigned char> statement_binding,
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() &&
3796 std::span<const unsigned char> statement_binding,
3799 circuit, assignment, secret_prover_seed, {}, secp_context,
3800 statement_binding,
false, cache);
3807 std::span<const unsigned char> statement_binding,
3810 circuit, proof, secp_context, statement_binding, cache);
3818 std::span<const PointBytes> public_commitments,
3820 std::span<const unsigned char> statement_binding,
3823 circuit, assignment, secret_prover_seed, public_commitments,
3824 secp_context, statement_binding,
true, cache);
3830 std::span<const PointBytes> public_commitments,
3832 std::span<const unsigned char> statement_binding,
3837 circuit, proof, public_commitments, secp_context, statement_binding,
3839 "verify_experimental_circuit_zk_norm_arg_with_public_commitments:prepare");
3840 if (!prepared.has_value()) {
3860 "commit_output_witness:prove_assignment_data");
3861 SecretScalarBytes output;
3863 output.value.data(),
3866 const auto &commitment,
3869 "commit_output_witness:pedersen_commit_char");
3871 std::move(witness.assignment), commitment};
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
bool has_value() const noexcept
Field element modulo the backend scalar field used by this implementation.
static FieldElement one()
Returns the multiplicative identity of the scalar field.
static Result< FieldElement > try_from_bytes32(const std::array< unsigned char, 32 > &bytes)
Decodes a canonical 32-byte big-endian field element.
static FieldElement from_int(std::int64_t value)
Constructs a field element from a signed integer, reducing negatives modulo the field.
bool is_zero() const
Returns true when the element is zero.
static FieldElement zero()
Returns the additive identity of the scalar field.
Move-only packed Purify secret stored in dedicated heap memory.
Common interface for reusable experimental BPPP backend state.
virtual ~ExperimentalCircuitBackend()
Thread-local clone of one warmed experimental BPPP backend-resource line.
bool empty() const noexcept
ExperimentalCircuitCacheLine & operator=(const ExperimentalCircuitCacheLine &)=delete
~ExperimentalCircuitCacheLine() override
ExperimentalCircuitCacheLine()
Caller-owned cache for reusable experimental circuit reduction and BPPP backend data.
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.
ExperimentalCircuitCache()
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.
void insert_public_data(std::array< unsigned char, 32 > key, std::shared_ptr< const void > value)
Stores opaque cached reduction data by digest key.
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.
std::size_t size() const noexcept
~ExperimentalCircuitCache()
ScalarBytes bytes() const
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)
std::size_t round_count() const noexcept
#define PURIFY_RETURN_IF_ERROR(expr, context)
Evaluates an expected-like expression and returns the wrapped error on failure.
#define PURIFY_ASSIGN_OR_RETURN(lhs, expr, context)
Evaluates an expected-like expression, binds the value to lhs, and propagates errors.
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)
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)
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)
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)
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)
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)
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)
Status validate_circuit_zk_norm_arg_proof_v4_encoding(const NativeBulletproofCircuit &circuit, const CircuitZkNormArgProofV4 &proof, purify_secp_context *secp_context)
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)
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)
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)
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)
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)
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.
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.
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.
bool verify_norm_arg_with_cache(const NormArgProof &proof, purify_secp_context *secp_context, ExperimentalCircuitBackend *cache=nullptr)
std::size_t digest_prefix_hash(const Digest &digest) noexcept
std::unique_ptr< purify_bppp_backend_resources, BpppBackendResourcesDeleter > OwnedBpppBackendResources
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.
GeneratorBytes base_generator(purify_secp_context *secp_context)
Returns the serialized secp256k1 base generator used as the blind generator.
bool verify_norm_arg_v4(const NormArgProof &norm, std::span< const candidate::CircuitChallengeV4 > gammas, purify_secp_context *secp_context)
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.
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.
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.
Result< NormArgProof > prove_norm_arg_to_commitment_with_cache(const NormArgInputs &inputs, const PointBytes &commitment, purify_secp_context *secp_context, ExperimentalCircuitBackend *cache=nullptr)
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.
bool verify_norm_arg(const NormArgProof &proof, purify_secp_context *secp_context)
Verifies a standalone BPPP norm argument.
int append_circuit_norm_round(void *callback_data, const unsigned char point_pair65[65], size_t round, unsigned char challenge32[32])
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)
Result< PointBytes > commit_norm_arg_with_cache(const NormArgInputs &inputs, purify_secp_context *secp_context, ExperimentalCircuitBackend *cache=nullptr)
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.
GeneratorBackendCacheKeyHash CircuitNormArgPublicDataCacheKeyHash
GeneratorBytes value_generator_h(purify_secp_context *secp_context)
Returns the serialized alternate generator used for committed values.
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.
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)
Result< NormArgProof > prove_norm_arg(const NormArgInputs &inputs, purify_secp_context *secp_context)
Produces a standalone BPPP norm argument.
GeneratorBackendCacheKey generator_backend_cache_key(std::span< const PointBytes > generators)
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)
Result< std::vector< PointBytes > > create_generators(std::size_t count, purify_secp_context *secp_context)
Expands the BPPP generator list.
std::array< unsigned char, 33 > PointBytes
Compressed 33-byte curve-point encoding.
Result< NormArgProof > prove_norm_arg_to_commitment_v4(const NormArgInputs &inputs, const PointBytes &commitment, candidate::CircuitProofTranscriptV4 &transcript, purify_secp_context *secp_context)
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.
std::array< unsigned char, 33 > GeneratorBytes
Serialized generator encoding used by the BPPP bridge.
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...
ScalarBytes scalar_bytes(const FieldElement &value)
Serializes a Purify field element into the scalar encoding expected by the BPPP bridge.
Result< std::vector< candidate::PackedPointPairV4 > > parse_norm_rounds_v4(const Bytes &proof, std::size_t round_count, ScalarBytes &terminal_n, ScalarBytes &terminal_l)
std::array< unsigned char, 32 > ScalarBytes
Big-endian 32-byte scalar encoding.
std::array< unsigned char, 32 > CircuitNormArgPublicDataCacheKey
std::array< unsigned char, 32 > GeneratorBackendCacheKey
std::vector< ScalarBytes > scalar_challenges(std::span< const candidate::CircuitChallengeV4 > challenges)
void secure_clear_bytes(void *data, std::size_t size) noexcept
Status require_secp_context(const purify_secp_context *context, const char *error_context)
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.
Result< BulletproofWitnessData > prove_assignment_data(const Bytes &message, const SecretKey &secret)
Computes the native Purify witness for a message and secret.
bool is_power_of_two_size(std::size_t value) noexcept
Result< std::uint64_t > narrow_size_to_u64(std::size_t value, const char *context)
bool checked_mul_size(std::size_t lhs, std::size_t rhs, std::size_t &out) noexcept
Bytes bytes_from_ascii(std::string_view input)
Encodes an ASCII string as a byte vector.
Expected< T, Error > Result
Expected-returning convenience alias for Purify value-producing APIs.
Expected< void, Error > Status
Expected-returning convenience alias for Purify status-only APIs.
std::vector< unsigned char > Bytes
Dynamically sized byte string used for messages, serialized witnesses, and proofs.
bool checked_add_size(std::size_t lhs, std::size_t rhs, std::size_t &out) noexcept
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.
std::size_t n_commitments
void operator()(purify_bppp_backend_resources *resources) const noexcept
std::vector< candidate::PackedPointPairV4 > rounds
purify_secp_context * secp_context
candidate::CircuitProofTranscriptV4 * transcript
std::optional< Error > error
Purify witness bundle together with a Pedersen commitment to the output.
OwnedBpppBackendResources backend_resources
GeneratorBackendCacheKey backend_key
std::unordered_map< GeneratorBackendCacheKey, OwnedBpppBackendResources, GeneratorBackendCacheKeyHash > backend_resources
std::unordered_map< CircuitNormArgPublicDataCacheKey, std::shared_ptr< const void >, CircuitNormArgPublicDataCacheKeyHash > public_data
Experimental transparent circuit proof backed by the standalone BPPP norm argument.
PointBytes witness_commitment
Masked circuit proof with a pre-challenge raw-coordinate commitment.
std::array< unsigned char, 32 > public_commitment_dlog_nonce
Even-Y Schnorr nonce x-coordinate for the batched public-commitment DLog proof.
PointBytes a_commitment
Raw-coordinate commitment made before reduction challenges.
ScalarBytes public_commitment_dlog_response
Schnorr response for the batched public-commitment DLog proof.
std::size_t operator()(const GeneratorBackendCacheKey &key) const noexcept
Standalone BPPP norm-argument proof bundle with all verifier-side inputs.
std::vector< PointBytes > generators
std::vector< ScalarBytes > c_vec
PointBytes commitment
Finite compressed initial point; infinity is not accepted.
PointBytes mask_commitment
std::array< unsigned char, 32 > public_commitment_dlog_nonce
PointBytes raw_commitment
ScalarBytes public_commitment_dlog_response
CircuitPrecommitmentDigestV4 precommitment
CircuitZkNormArgProofV4 proof
static purify_bppp_backend_resources * get_or_create_backend_resources(ExperimentalCircuitBackend *backend, std::span< const PointBytes > generators, purify_secp_context *secp_context)
static std::shared_ptr< const void > find_public_data(const ExperimentalCircuitBackend *backend, const std::array< unsigned char, 32 > &key)
static void insert_public_data(ExperimentalCircuitBackend *backend, std::array< unsigned char, 32 > key, std::shared_ptr< const void > value)
static const purify_scalar & raw(const FieldElement &value) noexcept
int PURIFY_UINT_FN is_zero(const uint64_t value[PURIFY_UINT_WORDS])