16constexpr std::string_view kPrecommitDomain =
17 "Purify/BPPP/CircuitNormArg/v4/precommit";
18constexpr std::string_view kProofDomain =
"Purify/BPPP/CircuitNormArg/v4/proof";
21 unsigned char prefix{0};
26 unsigned char parity{0};
31bool all_zero(std::span<const unsigned char> bytes) {
32 return std::all_of(bytes.begin(), bytes.end(),
33 [](
unsigned char value) { return value == 0; });
38 if (all_zero(encoded)) {
41 if ((encoded[0] != 2 && encoded[0] != 3) ||
48 std::copy(encoded.begin() + 1, encoded.end(), x.begin());
49 return ParsedPoint{encoded[0], x};
56 "circuit_v4:pair_parity");
59 out.parity = encoded[0];
60 const std::array offsets{std::size_t{1}, std::size_t{33}};
61 std::array<TranscriptBytes32 *, 2> outputs{&out.first_x, &out.second_x};
62 for (std::size_t index = 0; index < offsets.size(); ++index) {
63 const std::span<const unsigned char, 32> x(encoded.data() + offsets[index],
65 const unsigned char parity_mask =
static_cast<unsigned char>(2U >> index);
67 if ((encoded[0] & parity_mask) != 0) {
69 "circuit_v4:pair_identity");
75 "circuit_v4:pair_point");
77 std::copy(x.begin(), x.end(), outputs[index]->begin());
83 return transcript.append_bytes(std::span(
84 reinterpret_cast<const unsigned char *
>(bytes.data()), bytes.size()));
89 std::size_t public_commitment_count) {
91 const auto gate_count,
93 "circuit_v4:gate_count");
96 "circuit_v4:commitment_count"),
97 "circuit_v4:commitment_count");
101 "circuit_v4:n_vec_len");
103 const auto l_vec_len,
105 "circuit_v4:l_vec_len");
107 const auto public_count,
109 "circuit_v4:public_count");
110 transcript.append_u64(
static_cast<std::uint64_t
>(shape.mode()));
111 transcript.append_u64(gate_count);
112 transcript.append_u64(commitment_count);
113 transcript.append_u64(n_vec_len);
114 transcript.append_u64(l_vec_len);
115 transcript.append_u64(public_count);
122 "circuit_v4:append_point");
123 return transcript.append_point(point.prefix, point.x);
127 std::uint64_t index) {
129 "circuit_v4:challenge");
135 std::size_t public_commitment_count) {
136 if (public_commitment_count != shape.public_commitment_count()) {
148 parse_pair(encoded, secp_context),
149 "circuit_v4:validate_pair");
165 "circuit_v4:public_commitments");
167 std::size_t expected_n = 0;
182 return static_cast<std::size_t
>(std::bit_width(n_vec_len_) - 1);
192 "circuit_v4:precommitment_digest");
195 "circuit_v4:precommitment_zero");
197 return CircuitPrecommitmentDigestV4(std::move(
scalar));
203 std::span<const PointBytes> public_commitments,
208 "circuit_v4:context");
210 "circuit_v4:public_mode");
214 "circuit_v4:precommit_domain");
216 "circuit_v4:circuit_binding");
218 append_shape(transcript, shape, public_commitments.size()),
219 "circuit_v4:precommit_shape");
220 for (
const auto &point : public_commitments) {
222 "circuit_v4:public_commitment");
225 "circuit_v4:raw_commitment");
228 "circuit_v4:precommitment_challenge");
232 "circuit_v4:precommitment_digest");
242 "circuit_v4:proof_domain");
245 "circuit_v4:raw_generator_digest");
247 append_shape(transcript,
shape,
shape.public_commitment_count()),
248 "circuit_v4:proof_shape");
252 "circuit_v4:mul_scale");
254 "circuit_v4:mul_ratio");
256 "circuit_v4:row_ratio");
257 return CircuitProofTranscriptV4(
268 if (stage_ != Stage::AnchoredCommitments) {
270 "circuit_v4:anchored_stage");
274 append_point(transcript, coefficient_commitment, secp_context),
275 "circuit_v4:coefficient_commitment");
277 append_point(transcript, anchored_offset, secp_context),
278 "circuit_v4:anchored_offset");
280 append_point(transcript, anchored_commitment, secp_context),
281 "circuit_v4:anchored_commitment");
284 transcript_ = std::move(transcript);
285 stage_ = Stage::PublicOpening;
292 const std::array<unsigned char, 32> &dlog_nonce,
294 if (stage_ != Stage::PublicOpening) {
296 "circuit_v4:public_opening_stage");
299 if (!all_zero(batched_public_commitment) || !all_zero(dlog_nonce)) {
301 "circuit_v4:hidden_dlog");
304 secp_context, dlog_nonce.data()) == 0) {
306 "circuit_v4:dlog_nonce");
310 append_point(transcript, batched_public_commitment, secp_context),
311 "circuit_v4:batched_commitment");
313 "circuit_v4:dlog_nonce");
315 "circuit_v4:dlog_challenge");
316 transcript_ = std::move(transcript);
317 stage_ = Stage::DlogResponse;
323 if (stage_ != Stage::DlogResponse) {
325 "circuit_v4:dlog_response_stage");
330 "circuit_v4:hidden_dlog");
332 transcript_.append_scalar(dlog_response);
333 stage_ = Stage::Mask;
340 if (stage_ != Stage::Mask) {
342 "circuit_v4:mask_stage");
346 append_point(transcript, mask_commitment, secp_context),
347 "circuit_v4:mask_commitment");
351 transcript_ = std::move(transcript);
352 stage_ = Stage::CombinedCommitment;
359 if (stage_ != Stage::CombinedCommitment) {
361 "circuit_v4:combined_stage");
365 append_point(transcript, combined_commitment, secp_context),
366 "circuit_v4:combined_commitment");
367 transcript_ = std::move(transcript);
368 stage_ = shape_.round_count() == 0 ? Stage::Terminal : Stage::Rounds;
375 if (stage_ != Stage::Rounds || next_round_ >= shape_.round_count()) {
377 "circuit_v4:round_stage");
381 "circuit_v4:round_pair");
384 "circuit_v4:round_pair");
387 append_challenge(transcript,
388 7 +
static_cast<std::uint64_t
>(next_round_)),
390 transcript_ = std::move(transcript);
392 if (next_round_ == shape_.round_count()) stage_ = Stage::Terminal;
398 if (stage_ != Stage::Terminal) {
400 "circuit_v4:terminal_stage");
407 transcript.
challenge(7 +
static_cast<std::uint64_t
>(next_round_)),
408 "circuit_v4:prepared_binding");
410 transcript_ = std::move(transcript);
411 stage_ = Stage::Finished;
422 "circuit_v4:context");
429 "circuit_v4:dlog_response");
434 "circuit_v4:terminal_n");
437 "circuit_v4:terminal_l");
443 "circuit_v4:proof_prefix");
445 out.
rho = transcript.rho();
451 transcript.append_anchored_commitments(
454 "circuit_v4:anchored_commitments");
457 transcript.append_public_opening(
459 "circuit_v4:public_opening");
461 "circuit_v4:dlog_response");
467 transcript.append_combined_commitment(
469 "circuit_v4:combined_commitment");
472 for (
const auto &round : proof.
rounds) {
474 auto gamma, transcript.append_round(round, secp_context),
476 out.
gammas.push_back(std::move(gamma));
480 "circuit_v4:prepared_binding");
Field element modulo the backend scalar field used by this implementation.
static Result< FieldElement > try_from_bytes32(const std::array< unsigned char, 32 > &bytes)
Decodes a canonical 32-byte big-endian field element.
bool is_zero() const
Returns true when the element is zero.
const FieldElement & scalar() const noexcept
static Result< CircuitPrecommitmentDigestV4 > parse(const ScalarBytes &encoded)
Result< CircuitChallengeV4 > finish(const FieldElement &terminal_n, const FieldElement &terminal_l)
Status append_dlog_response(const FieldElement &dlog_response)
Result< CircuitChallengeV4 > append_mask(const PointBytes &mask_commitment, const FieldElement &t2, purify_secp_context *secp_context)
const CircuitChallengeV4 & mul_ratio() const noexcept
Result< CircuitChallengeV4 > append_public_opening(const PointBytes &batched_public_commitment, const std::array< unsigned char, 32 > &dlog_nonce, purify_secp_context *secp_context)
static Result< CircuitProofTranscriptV4 > create(const CircuitTranscriptShapeV4 &shape, const CircuitPrecommitmentDigestV4 &precommitment, const TranscriptDigest &raw_generator_digest)
const CircuitTranscriptShapeV4 & shape() const noexcept
Result< CircuitChallengeV4 > append_round(const PackedPointPairV4 &round, purify_secp_context *secp_context)
const CircuitChallengeV4 & mul_scale() const noexcept
Result< CircuitChallengeV4 > append_anchored_commitments(const PointBytes &coefficient_commitment, const PointBytes &anchored_offset, const PointBytes &anchored_commitment, purify_secp_context *secp_context)
Status append_combined_commitment(const PointBytes &combined_commitment, purify_secp_context *secp_context)
const CircuitChallengeV4 & rho() const noexcept
const CircuitChallengeV4 & row_ratio() const noexcept
std::size_t gate_count() const noexcept
std::size_t public_commitment_count() 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)
CircuitCommitmentModeV4 mode() const noexcept
std::size_t n_vec_len() const noexcept
std::size_t commitment_count() const noexcept
std::size_t l_vec_len() const noexcept
std::size_t round_count() const noexcept
void append_scalar(const FieldElement &value)
Result< Sha256Challenge > challenge(std::uint64_t round)
Status append_bytes(std::span< const unsigned char > bytes)
Status append_point_pair(unsigned char parity, const TranscriptBytes32 &first_x, const TranscriptBytes32 &second_x)
#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< 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)
Result< CircuitProofTranscriptResultV4 > derive_circuit_proof_transcript_v4(const CircuitTranscriptShapeV4 &shape, const CircuitPrecommitmentDigestV4 &precommitment, const CircuitProofTranscriptInputV4 &proof, purify_secp_context *secp_context)
std::array< unsigned char, 32 > TranscriptBytes32
std::array< unsigned char, 65 > PackedPointPairV4
TranscriptBytes32 TranscriptDigest
std::array< unsigned char, 33 > PointBytes
Compressed 33-byte curve-point encoding.
std::array< unsigned char, 32 > ScalarBytes
Big-endian 32-byte scalar encoding.
Status require_secp_context(const purify_secp_context *context, const char *error_context)
constexpr Unexpected< Error > unexpected_error(ErrorCode code, const char *context=nullptr)
Constructs an unexpected Error value from a machine-readable code.
bool size_fits_u64(std::size_t value) noexcept
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
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.
Narrow C ABI exposing secp256k1 scalar and HMAC helpers to the C++ headers.
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.
struct purify_secp_context purify_secp_context
Caller-owned reusable secp256k1 context handle shared across Purify C and C++ APIs.
CircuitChallengeV4 mul_ratio
std::vector< CircuitChallengeV4 > gammas
CircuitChallengeV4 row_ratio
CircuitChallengeV4 prepared_binding
CircuitChallengeV4 dlog_challenge
CircuitChallengeV4 mul_scale