purify
C++ Purify implementation with native circuit and BPP support
Loading...
Searching...
No Matches
sha256_circuit_transcript.cpp
Go to the documentation of this file.
1// Copyright (c) 2026 Judica, Inc.
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or https://opensource.org/license/mit/.
4
6
7#include <algorithm>
8#include <bit>
9#include <string_view>
10
11#include "purify/secp_bridge.h"
12
14namespace {
15
16constexpr std::string_view kPrecommitDomain =
17 "Purify/BPPP/CircuitNormArg/v4/precommit";
18constexpr std::string_view kProofDomain = "Purify/BPPP/CircuitNormArg/v4/proof";
19
20struct ParsedPoint {
21 unsigned char prefix{0};
23};
24
25struct ParsedPair {
26 unsigned char parity{0};
27 TranscriptBytes32 first_x{};
28 TranscriptBytes32 second_x{};
29};
30
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; });
34}
35
36Result<ParsedPoint> parse_point(const PointBytes &encoded,
37 purify_secp_context *secp_context) {
38 if (all_zero(encoded)) {
39 return ParsedPoint{};
40 }
41 if ((encoded[0] != 2 && encoded[0] != 3) ||
42 purify_bip340_validate_xonly_pubkey(secp_context, encoded.data() + 1) ==
43 0) {
45 "circuit_v4:point");
46 }
48 std::copy(encoded.begin() + 1, encoded.end(), x.begin());
49 return ParsedPoint{encoded[0], x};
50}
51
52Result<ParsedPair> parse_pair(const PackedPointPairV4 &encoded,
53 purify_secp_context *secp_context) {
54 if (encoded[0] > 3) {
56 "circuit_v4:pair_parity");
57 }
58 ParsedPair out;
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],
64 32);
65 const unsigned char parity_mask = static_cast<unsigned char>(2U >> index);
66 if (all_zero(x)) {
67 if ((encoded[0] & parity_mask) != 0) {
69 "circuit_v4:pair_identity");
70 }
71 continue;
72 }
73 if (purify_bip340_validate_xonly_pubkey(secp_context, x.data()) == 0) {
75 "circuit_v4:pair_point");
76 }
77 std::copy(x.begin(), x.end(), outputs[index]->begin());
78 }
79 return out;
80}
81
82Status append_bytes(Sha256Transcript &transcript, std::string_view bytes) {
83 return transcript.append_bytes(std::span(
84 reinterpret_cast<const unsigned char *>(bytes.data()), bytes.size()));
85}
86
87Status append_shape(Sha256Transcript &transcript,
88 const CircuitTranscriptShapeV4 &shape,
89 std::size_t public_commitment_count) {
91 const auto gate_count,
92 narrow_size_to_u64(shape.gate_count(), "circuit_v4:gate_count"),
93 "circuit_v4:gate_count");
94 PURIFY_ASSIGN_OR_RETURN(const auto commitment_count,
95 narrow_size_to_u64(shape.commitment_count(),
96 "circuit_v4:commitment_count"),
97 "circuit_v4:commitment_count");
99 const auto n_vec_len,
100 narrow_size_to_u64(shape.n_vec_len(), "circuit_v4:n_vec_len"),
101 "circuit_v4:n_vec_len");
103 const auto l_vec_len,
104 narrow_size_to_u64(shape.l_vec_len(), "circuit_v4:l_vec_len"),
105 "circuit_v4:l_vec_len");
107 const auto public_count,
108 narrow_size_to_u64(public_commitment_count, "circuit_v4: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);
116 return {};
117}
118
119Status append_point(Sha256Transcript &transcript, const PointBytes &encoded,
120 purify_secp_context *secp_context) {
121 PURIFY_ASSIGN_OR_RETURN(const auto point, parse_point(encoded, secp_context),
122 "circuit_v4:append_point");
123 return transcript.append_point(point.prefix, point.x);
124}
125
126Result<CircuitChallengeV4> append_challenge(Sha256Transcript &transcript,
127 std::uint64_t index) {
128 PURIFY_ASSIGN_OR_RETURN(auto challenge, transcript.challenge(index),
129 "circuit_v4:challenge");
130 CircuitChallengeV4 out{std::move(challenge.scalar)};
131 return out;
132}
133
134Status validate_public_mode(const CircuitTranscriptShapeV4 &shape,
135 std::size_t public_commitment_count) {
136 if (public_commitment_count != shape.public_commitment_count()) {
137 return unexpected_error(ErrorCode::SizeMismatch, "circuit_v4:public_count");
138 }
139 return {};
140}
141
142} // namespace
143
145 const PackedPointPairV4 &encoded,
146 purify_secp_context *secp_context) {
147 PURIFY_ASSIGN_OR_RETURN(const auto parsed,
148 parse_pair(encoded, secp_context),
149 "circuit_v4:validate_pair");
150 (void)parsed;
151 return {};
152}
153
156 std::size_t gate_count,
157 std::size_t commitment_count,
158 std::size_t n_vec_len, std::size_t l_vec_len) {
161 return unexpected_error(ErrorCode::UnsupportedSymbol, "circuit_v4:mode");
162 }
165 "circuit_v4:public_commitments");
166 }
167 std::size_t expected_n = 0;
171 !checked_mul_size(gate_count, 2, expected_n) || n_vec_len != expected_n ||
175 return unexpected_error(ErrorCode::InvalidDimensions, "circuit_v4:shape");
176 }
177 return CircuitTranscriptShapeV4(mode, gate_count, commitment_count, n_vec_len,
178 l_vec_len);
179}
180
181std::size_t CircuitTranscriptShapeV4::round_count() const noexcept {
182 return static_cast<std::size_t>(std::bit_width(n_vec_len_) - 1);
183}
184
186 return mode_ == CircuitCommitmentModeV4::Public ? commitment_count_ : 0;
187}
188
192 "circuit_v4:precommitment_digest");
193 if (scalar.is_zero()) {
195 "circuit_v4:precommitment_zero");
196 }
197 return CircuitPrecommitmentDigestV4(std::move(scalar));
198}
199
202 const TranscriptDigest &circuit_binding_digest,
203 std::span<const PointBytes> public_commitments,
204 const PointBytes &raw_commitment,
205 purify_secp_context *secp_context) {
207 require_secp_context(secp_context, "circuit_v4:context"),
208 "circuit_v4:context");
209 PURIFY_RETURN_IF_ERROR(validate_public_mode(shape, public_commitments.size()),
210 "circuit_v4:public_mode");
211
212 Sha256Transcript transcript;
213 PURIFY_RETURN_IF_ERROR(append_bytes(transcript, kPrecommitDomain),
214 "circuit_v4:precommit_domain");
215 PURIFY_RETURN_IF_ERROR(transcript.append_bytes(circuit_binding_digest),
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) {
221 PURIFY_RETURN_IF_ERROR(append_point(transcript, point, secp_context),
222 "circuit_v4:public_commitment");
223 }
224 PURIFY_RETURN_IF_ERROR(append_point(transcript, raw_commitment, secp_context),
225 "circuit_v4:raw_commitment");
226
227 PURIFY_ASSIGN_OR_RETURN(auto challenge, transcript.challenge(0),
228 "circuit_v4:precommitment_challenge");
230 auto digest,
231 CircuitPrecommitmentDigestV4::parse(challenge.scalar.to_bytes_be()),
232 "circuit_v4:precommitment_digest");
233 return CircuitPrecommitmentResultV4{std::move(digest)};
234}
235
238 const CircuitPrecommitmentDigestV4 &precommitment,
239 const TranscriptDigest &raw_generator_digest) {
240 Sha256Transcript transcript;
241 PURIFY_RETURN_IF_ERROR(append_bytes(transcript, kProofDomain),
242 "circuit_v4:proof_domain");
243 transcript.append_scalar(precommitment.scalar());
244 PURIFY_RETURN_IF_ERROR(transcript.append_bytes(raw_generator_digest),
245 "circuit_v4:raw_generator_digest");
247 append_shape(transcript, shape, shape.public_commitment_count()),
248 "circuit_v4:proof_shape");
249 PURIFY_ASSIGN_OR_RETURN(auto rho, append_challenge(transcript, 0),
250 "circuit_v4:rho");
251 PURIFY_ASSIGN_OR_RETURN(auto mul_scale, append_challenge(transcript, 1),
252 "circuit_v4:mul_scale");
253 PURIFY_ASSIGN_OR_RETURN(auto mul_ratio, append_challenge(transcript, 2),
254 "circuit_v4:mul_ratio");
255 PURIFY_ASSIGN_OR_RETURN(auto row_ratio, append_challenge(transcript, 3),
256 "circuit_v4:row_ratio");
257 return CircuitProofTranscriptV4(
258 shape, std::move(transcript), std::move(rho), std::move(mul_scale),
259 std::move(mul_ratio), std::move(row_ratio));
260}
261
264 const PointBytes &coefficient_commitment,
265 const PointBytes &anchored_offset,
266 const PointBytes &anchored_commitment,
267 purify_secp_context *secp_context) {
268 if (stage_ != Stage::AnchoredCommitments) {
270 "circuit_v4:anchored_stage");
271 }
272 Sha256Transcript transcript = transcript_;
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");
282 PURIFY_ASSIGN_OR_RETURN(auto eta, append_challenge(transcript, 4),
283 "circuit_v4:eta");
284 transcript_ = std::move(transcript);
285 stage_ = Stage::PublicOpening;
286 return eta;
287}
288
291 const PointBytes &batched_public_commitment,
292 const std::array<unsigned char, 32> &dlog_nonce,
293 purify_secp_context *secp_context) {
294 if (stage_ != Stage::PublicOpening) {
296 "circuit_v4:public_opening_stage");
297 }
298 if (shape_.mode() == CircuitCommitmentModeV4::Hidden) {
299 if (!all_zero(batched_public_commitment) || !all_zero(dlog_nonce)) {
301 "circuit_v4:hidden_dlog");
302 }
304 secp_context, dlog_nonce.data()) == 0) {
306 "circuit_v4:dlog_nonce");
307 }
308 Sha256Transcript transcript = transcript_;
310 append_point(transcript, batched_public_commitment, secp_context),
311 "circuit_v4:batched_commitment");
312 PURIFY_RETURN_IF_ERROR(transcript.append_bytes(dlog_nonce),
313 "circuit_v4:dlog_nonce");
314 PURIFY_ASSIGN_OR_RETURN(auto challenge, append_challenge(transcript, 5),
315 "circuit_v4:dlog_challenge");
316 transcript_ = std::move(transcript);
317 stage_ = Stage::DlogResponse;
318 return challenge;
319}
320
322 const FieldElement &dlog_response) {
323 if (stage_ != Stage::DlogResponse) {
325 "circuit_v4:dlog_response_stage");
326 }
327 if (shape_.mode() == CircuitCommitmentModeV4::Hidden &&
328 !dlog_response.is_zero()) {
330 "circuit_v4:hidden_dlog");
331 }
332 transcript_.append_scalar(dlog_response);
333 stage_ = Stage::Mask;
334 return {};
335}
336
338 const PointBytes &mask_commitment, const FieldElement &t2,
339 purify_secp_context *secp_context) {
340 if (stage_ != Stage::Mask) {
342 "circuit_v4:mask_stage");
343 }
344 Sha256Transcript transcript = transcript_;
346 append_point(transcript, mask_commitment, secp_context),
347 "circuit_v4:mask_commitment");
348 transcript.append_scalar(t2);
349 PURIFY_ASSIGN_OR_RETURN(auto alpha, append_challenge(transcript, 6),
350 "circuit_v4:alpha");
351 transcript_ = std::move(transcript);
352 stage_ = Stage::CombinedCommitment;
353 return alpha;
354}
355
357 const PointBytes &combined_commitment,
358 purify_secp_context *secp_context) {
359 if (stage_ != Stage::CombinedCommitment) {
361 "circuit_v4:combined_stage");
362 }
363 Sha256Transcript transcript = transcript_;
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;
369 return {};
370}
371
373 const PackedPointPairV4 &round,
374 purify_secp_context *secp_context) {
375 if (stage_ != Stage::Rounds || next_round_ >= shape_.round_count()) {
377 "circuit_v4:round_stage");
378 }
379 Sha256Transcript transcript = transcript_;
380 PURIFY_ASSIGN_OR_RETURN(const auto pair, parse_pair(round, secp_context),
381 "circuit_v4:round_pair");
383 transcript.append_point_pair(pair.parity, pair.first_x, pair.second_x),
384 "circuit_v4:round_pair");
386 auto gamma,
387 append_challenge(transcript,
388 7 + static_cast<std::uint64_t>(next_round_)),
389 "circuit_v4:gamma");
390 transcript_ = std::move(transcript);
391 ++next_round_;
392 if (next_round_ == shape_.round_count()) stage_ = Stage::Terminal;
393 return gamma;
394}
395
397 const FieldElement &terminal_n, const FieldElement &terminal_l) {
398 if (stage_ != Stage::Terminal) {
400 "circuit_v4:terminal_stage");
401 }
402 Sha256Transcript transcript = transcript_;
403 transcript.append_scalar(terminal_n);
404 transcript.append_scalar(terminal_l);
406 auto challenge,
407 transcript.challenge(7 + static_cast<std::uint64_t>(next_round_)),
408 "circuit_v4:prepared_binding");
409 CircuitChallengeV4 prepared{std::move(challenge.scalar)};
410 transcript_ = std::move(transcript);
411 stage_ = Stage::Finished;
412 return prepared;
413}
414
416 const CircuitTranscriptShapeV4 &shape,
417 const CircuitPrecommitmentDigestV4 &precommitment,
419 purify_secp_context *secp_context) {
421 require_secp_context(secp_context, "circuit_v4:context"),
422 "circuit_v4:context");
423 if (proof.rounds.size() != shape.round_count()) {
424 return unexpected_error(ErrorCode::SizeMismatch, "circuit_v4:round_count");
425 }
426
427 PURIFY_ASSIGN_OR_RETURN(const auto dlog_response,
429 "circuit_v4:dlog_response");
431 const auto t2, FieldElement::try_from_bytes32(proof.t2), "circuit_v4:t2");
432 PURIFY_ASSIGN_OR_RETURN(const auto terminal_n,
434 "circuit_v4:terminal_n");
435 PURIFY_ASSIGN_OR_RETURN(const auto terminal_l,
437 "circuit_v4:terminal_l");
438
440 auto transcript,
442 shape, precommitment, proof.raw_generator_digest),
443 "circuit_v4:proof_prefix");
445 out.rho = transcript.rho();
446 out.mul_scale = transcript.mul_scale();
447 out.mul_ratio = transcript.mul_ratio();
448 out.row_ratio = transcript.row_ratio();
450 out.eta,
451 transcript.append_anchored_commitments(
453 proof.anchored_commitment, secp_context),
454 "circuit_v4:anchored_commitments");
456 out.dlog_challenge,
457 transcript.append_public_opening(
458 proof.batched_public_commitment, proof.dlog_nonce, secp_context),
459 "circuit_v4:public_opening");
460 PURIFY_RETURN_IF_ERROR(transcript.append_dlog_response(dlog_response),
461 "circuit_v4:dlog_response");
463 out.alpha,
464 transcript.append_mask(proof.mask_commitment, t2, secp_context),
465 "circuit_v4:mask");
467 transcript.append_combined_commitment(
468 proof.combined_commitment, secp_context),
469 "circuit_v4:combined_commitment");
470
471 out.gammas.reserve(proof.rounds.size());
472 for (const auto &round : proof.rounds) {
474 auto gamma, transcript.append_round(round, secp_context),
475 "circuit_v4:gamma");
476 out.gammas.push_back(std::move(gamma));
477 }
479 out.prepared_binding, transcript.finish(terminal_n, terminal_l),
480 "circuit_v4:prepared_binding");
481 return out;
482}
483
484} // namespace purify::bppp::candidate
Field element modulo the backend scalar field used by this implementation.
Definition numeric.hpp:834
static Result< FieldElement > try_from_bytes32(const std::array< unsigned char, 32 > &bytes)
Decodes a canonical 32-byte big-endian field element.
Definition numeric.cpp:53
bool is_zero() const
Returns true when the element is zero.
Definition numeric.cpp:104
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
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)
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.
Definition error.hpp:329
#define PURIFY_ASSIGN_OR_RETURN(lhs, expr, context)
Evaluates an expected-like expression, binds the value to lhs, and propagates errors.
Definition error.hpp:338
Status validate_packed_point_pair_v4(const PackedPointPairV4 &encoded, purify_secp_context *secp_context)
Result< 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.
Definition bppp.hpp:32
std::array< unsigned char, 32 > ScalarBytes
Big-endian 32-byte scalar encoding.
Definition bppp.hpp:30
Status require_secp_context(const purify_secp_context *context, const char *error_context)
Definition common.hpp:56
constexpr Unexpected< Error > unexpected_error(ErrorCode code, const char *context=nullptr)
Constructs an unexpected Error value from a machine-readable code.
Definition error.hpp:293
bool size_fits_u64(std::size_t value) noexcept
Definition common.hpp:83
bool is_power_of_two_size(std::size_t value) noexcept
Definition common.hpp:94
Result< std::uint64_t > narrow_size_to_u64(std::size_t value, const char *context)
Definition common.hpp:87
bool checked_mul_size(std::size_t lhs, std::size_t rhs, std::size_t &out) noexcept
Definition common.hpp:71
Expected< T, Error > Result
Expected-returning convenience alias for Purify value-producing APIs.
Definition error.hpp:99
Expected< void, Error > Status
Expected-returning convenience alias for Purify status-only APIs.
Definition error.hpp:102
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.