purify
C++ Purify implementation with native circuit and BPP support
Loading...
Searching...
No Matches
certificate_nonce_parent_prover_input.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 <array>
9#include <cassert>
10#include <cstdint>
11#include <limits>
12#include <optional>
13#include <utility>
14#include <vector>
15
17namespace {
18
19constexpr std::array<unsigned char, 16> kJoinedWitnessMagic{
20 'P', 'u', 'r', 'i', 'f', 'y', '/', 'C',
21 'e', 'r', 't', 'J', 'W', 'i', 't', '2'};
22constexpr std::array<unsigned char, 16> kLinearJoinedWitnessMagic{
23 'P', 'u', 'r', 'i', 'f', 'y', '/', 'C',
24 'e', 'r', 't', 'J', 'W', 'i', 't', '3'};
25constexpr std::array<unsigned char, 16>
26 kCertificateParentPublicFrameMagic{
27 'P', 'u', 'r', 'i', 'f', 'y', '/', 'C',
28 'e', 'r', 't', 'P', 'u', 'b', '1', 0};
29constexpr std::size_t kDigestSize = 32;
30constexpr std::size_t kPointSize = 33;
31constexpr std::size_t kParentConstantsSize =
32 kDigestSize + 2 * kPointSize;
33constexpr std::size_t kHeaderSize =
34 kJoinedWitnessMagic.size() + kDigestSize + 8;
35constexpr std::size_t kResponseHeaderSize = 8 + 4;
36constexpr std::size_t kReceiptHeaderSize = 8;
37constexpr std::size_t kLinearHeaderSize =
38 kLinearJoinedWitnessMagic.size() + 3 * kDigestSize + 8;
39constexpr std::size_t kLinearMemberSize =
40 kParentConstantsSize + NonceProof::kSerializedSize +
43static_assert(
44 kCertificateParentPublicFrameMagic.size() + 2 * kDigestSize +
45 2 * sizeof(std::uint64_t) ==
47static_assert(kLinearHeaderSize == 120);
48static_assert(kLinearMemberSize == 2'984);
49
50template <std::size_t N>
51void append(Bytes& output, const std::array<unsigned char, N>& bytes)
52{
53 output.insert(output.end(), bytes.begin(), bytes.end());
54}
55
56void append(Bytes& output, std::span<const unsigned char> bytes)
57{
58 output.insert(output.end(), bytes.begin(), bytes.end());
59}
60
61void append_u32(Bytes& output, std::uint32_t value)
62{
63 output.push_back(static_cast<unsigned char>(value >> 24));
64 output.push_back(static_cast<unsigned char>(value >> 16));
65 output.push_back(static_cast<unsigned char>(value >> 8));
66 output.push_back(static_cast<unsigned char>(value));
67}
68
69void append_u64(Bytes& output, std::uint64_t value)
70{
71 for (unsigned int shift = 56; shift != 0; shift -= 8) {
72 output.push_back(static_cast<unsigned char>(value >> shift));
73 }
74 output.push_back(static_cast<unsigned char>(value));
75}
76
77struct AcceptedResponse {
78 std::vector<PreparedCertificateNonceLeaf> leaves;
79 std::vector<Bytes> proofs;
80};
81
82Status add_size(std::size_t& total, std::size_t value)
83{
84 if (!checked_add_size(total, value, total)) {
85 return unexpected_error(
87 "certificate_nonce_parent_witness:encoded_size");
88 }
89 return {};
90}
91
92} // namespace
93
97{
98 const auto step_count = resolution.step_digests().size();
99 if (!size_fits_u64(step_count)) {
100 return unexpected_error(
102 "certificate_parent_public_frame:step_count");
103 }
104
106 std::size_t offset = 0;
107 const auto append = [&](std::span<const unsigned char> bytes) {
108 assert(bytes.size() <= frame.size() - offset);
109 std::copy(bytes.begin(), bytes.end(), frame.begin() + offset);
110 offset += bytes.size();
111 };
112 const auto append_u64 = [&](std::uint64_t value) {
113 assert(sizeof(value) <= frame.size() - offset);
114 for (unsigned int shift = 56; shift != 0; shift -= 8) {
115 frame[offset++] = static_cast<unsigned char>(value >> shift);
116 }
117 frame[offset++] = static_cast<unsigned char>(value);
118 };
119
120 append(kCertificateParentPublicFrameMagic);
121 append(resolution.certificate_context_digest());
122 append_u64(resolution.total_responses());
123 append_u64(static_cast<std::uint64_t>(step_count));
124 append(resolution.manifest().bytes());
125 assert(offset == frame.size());
126 return frame;
127}
128
130 const CertificateNonceParentAccumulator& accumulator,
131 const CertificateNonceNativeReceipt& receipt,
132 std::span<const CertificateNonceResponseProverView>
133 ordered_responses,
134 purify_secp_context* secp_context,
136{
139 secp_context, "certificate_nonce_parent_witness:context"),
140 "certificate_nonce_parent_witness:context");
141 if (ordered_responses.size() != receipt.responses().size()) {
142 return unexpected_error(
144 "certificate_nonce_parent_witness:response_count");
145 }
146
147 std::vector<AcceptedResponse> accepted;
148 accepted.reserve(ordered_responses.size());
149 std::optional<std::array<unsigned char, 32>> raw_generator_digest;
150 for (std::size_t response_index = 0;
151 response_index < ordered_responses.size(); ++response_index) {
152 const auto& view = ordered_responses[response_index];
153 const auto& inputs = view.inputs();
154 const auto& frame = inputs.frame();
155 if (frame.certificate_context_digest !=
156 receipt.certificate_context_digest() ||
157 frame.total_responses != ordered_responses.size() ||
158 frame.response_ordinal != response_index ||
159 inputs.statement_digest() !=
160 receipt.responses()[response_index].statement_digest()) {
161 return unexpected_error(
163 "certificate_nonce_parent_witness:response_frame");
164 }
165 if (view.ordered_hosts().size() !=
166 view.ordered_proofs().size() ||
167 view.ordered_proofs().size() !=
168 inputs.leaf_bindings().size()) {
169 return unexpected_error(
171 "certificate_nonce_parent_witness:member_count");
172 }
173
175 const auto nonce_input,
177 view.context(), secp_context),
178 "certificate_nonce_parent_witness:nonce_input");
180 const auto topic_cache, TopicProofCache::build(nonce_input),
181 "certificate_nonce_parent_witness:topic_cache");
182
183 AcceptedResponse response;
184 response.leaves.reserve(view.ordered_proofs().size());
185 response.proofs.reserve(view.ordered_proofs().size());
186 for (std::size_t member_index = 0;
187 member_index < view.ordered_proofs().size();
188 ++member_index) {
190 auto leaf,
191 accumulator.leaves().prepare(
192 view.ordered_hosts()[member_index], topic_cache,
193 view.ordered_proofs()[member_index], secp_context,
194 cache),
195 "certificate_nonce_parent_witness:prepare_leaf");
197 auto proof,
198 view.ordered_proofs()[member_index].serialize(
199 secp_context),
200 "certificate_nonce_parent_witness:serialize_proof");
201 if (proof.size() != NonceProof::kSerializedSize) {
202 return unexpected_error(
204 "certificate_nonce_parent_witness:proof_size");
205 }
206 const auto& constants = leaf.parent_constants();
207 if (raw_generator_digest.has_value() &&
208 *raw_generator_digest != constants.raw_generator_digest) {
209 return unexpected_error(
211 "certificate_nonce_parent_witness:raw_generator_digest");
212 }
213 raw_generator_digest = constants.raw_generator_digest;
214 response.leaves.push_back(std::move(leaf));
215 response.proofs.push_back(std::move(proof));
216 }
217 accepted.push_back(std::move(response));
218 }
219 if (!raw_generator_digest.has_value()) {
220 return unexpected_error(
222 "certificate_nonce_parent_witness:empty_leaves");
223 }
224
225 std::vector<CertificateNonceResponseVerificationView>
226 verification_views;
227 verification_views.reserve(ordered_responses.size());
228 for (std::size_t index = 0; index < ordered_responses.size(); ++index) {
229 verification_views.emplace_back(
230 ordered_responses[index].inputs(), accepted[index].leaves);
231 }
233 accumulator.verify_native_receipt(
234 receipt, verification_views, secp_context),
235 "certificate_nonce_parent_witness:verify_receipt");
236
238 const auto receipt_bytes,
240 accumulator, receipt, secp_context),
241 "certificate_nonce_parent_witness:serialize_receipt");
242
243 std::size_t expected_size = kHeaderSize;
244 for (std::size_t index = 0; index < ordered_responses.size(); ++index) {
246 add_size(expected_size, kResponseHeaderSize),
247 "certificate_nonce_parent_witness:response_header");
249 add_size(expected_size,
250 ordered_responses[index].inputs().canonical_bytes().size()),
251 "certificate_nonce_parent_witness:response_inputs");
252 std::size_t proof_bytes = 0;
253 if (!checked_mul_size(
254 accepted[index].proofs.size(),
255 kParentConstantsSize + NonceProof::kSerializedSize,
256 proof_bytes)) {
257 return unexpected_error(
259 "certificate_nonce_parent_witness:proof_bytes");
260 }
262 add_size(expected_size, proof_bytes),
263 "certificate_nonce_parent_witness:proof_bytes");
264 }
266 add_size(expected_size, kReceiptHeaderSize),
267 "certificate_nonce_parent_witness:receipt_header");
269 add_size(expected_size, receipt_bytes.size()),
270 "certificate_nonce_parent_witness:receipt");
271
272 if (!size_fits_u64(ordered_responses.size()) ||
273 !size_fits_u64(receipt_bytes.size())) {
274 return unexpected_error(
276 "certificate_nonce_parent_witness:framing");
277 }
278
279 Bytes encoded;
280 encoded.reserve(expected_size);
281 append(encoded, kJoinedWitnessMagic);
282 append(encoded, *raw_generator_digest);
283 append_u64(
284 encoded, static_cast<std::uint64_t>(ordered_responses.size()));
285 for (std::size_t index = 0; index < ordered_responses.size(); ++index) {
286 const auto canonical =
287 ordered_responses[index].inputs().canonical_bytes();
288 if (!size_fits_u64(canonical.size()) ||
289 accepted[index].proofs.size() >
290 std::numeric_limits<std::uint32_t>::max()) {
291 return unexpected_error(
293 "certificate_nonce_parent_witness:response_framing");
294 }
295 append_u64(
296 encoded, static_cast<std::uint64_t>(canonical.size()));
297 append(encoded, canonical);
298 append_u32(
299 encoded,
300 static_cast<std::uint32_t>(accepted[index].proofs.size()));
301 for (std::size_t member_index = 0;
302 member_index < accepted[index].proofs.size();
303 ++member_index) {
304 const auto& constants =
305 accepted[index].leaves[member_index].parent_constants();
306 append(encoded, constants.circuit_binding_digest);
307 append(encoded, constants.coefficient_commitment);
308 append(encoded, constants.anchored_offset);
309 append(encoded, accepted[index].proofs[member_index]);
310 }
311 }
312 append_u64(
313 encoded, static_cast<std::uint64_t>(receipt_bytes.size()));
314 append(encoded, receipt_bytes);
315 if (encoded.size() != expected_size) {
316 return unexpected_error(
318 "certificate_nonce_parent_witness:final_size");
319 }
320 return encoded;
321}
322
325 const CertificateNonceParentAccumulator& accumulator,
326 const CertificateNonceLinearReceipt& receipt,
327 std::span<const CertificateNonceResponseProverView>
328 ordered_responses,
329 purify_secp_context* secp_context,
331{
334 secp_context,
335 "certificate_nonce_linear_witness:context"),
336 "certificate_nonce_linear_witness:context");
337 if (ordered_responses.size() != receipt.responses().size()) {
338 return unexpected_error(
340 "certificate_nonce_linear_witness:response_count");
341 }
342
343 std::vector<AcceptedResponse> accepted;
344 accepted.reserve(ordered_responses.size());
345 std::optional<std::array<unsigned char, 32>> raw_generator_digest;
346 for (std::size_t response_index = 0;
347 response_index < ordered_responses.size(); ++response_index) {
348 const auto& view = ordered_responses[response_index];
349 const auto& inputs = view.inputs();
350 const auto& frame = inputs.frame();
351 if (frame.certificate_context_digest !=
352 receipt.certificate_context_digest() ||
353 frame.total_responses != ordered_responses.size() ||
354 frame.response_ordinal != response_index) {
355 return unexpected_error(
357 "certificate_nonce_linear_witness:response_frame");
358 }
359 if (view.ordered_hosts().size() !=
360 view.ordered_proofs().size() ||
361 view.ordered_proofs().size() !=
362 inputs.leaf_bindings().size() ||
363 view.ordered_proofs().size() !=
364 receipt.responses()[response_index].members.size()) {
365 return unexpected_error(
367 "certificate_nonce_linear_witness:member_count");
368 }
369
371 const auto nonce_input,
373 view.context(), secp_context),
374 "certificate_nonce_linear_witness:nonce_input");
376 const auto topic_cache, TopicProofCache::build(nonce_input),
377 "certificate_nonce_linear_witness:topic_cache");
378
379 AcceptedResponse response;
380 response.leaves.reserve(view.ordered_proofs().size());
381 response.proofs.reserve(view.ordered_proofs().size());
382 for (std::size_t member_index = 0;
383 member_index < view.ordered_proofs().size();
384 ++member_index) {
386 auto leaf,
387 accumulator.leaves().prepare(
388 view.ordered_hosts()[member_index], topic_cache,
389 view.ordered_proofs()[member_index], secp_context,
390 cache),
391 "certificate_nonce_linear_witness:prepare_leaf");
393 auto proof,
394 view.ordered_proofs()[member_index].serialize(
395 secp_context),
396 "certificate_nonce_linear_witness:serialize_proof");
397 if (proof.size() != NonceProof::kSerializedSize) {
398 return unexpected_error(
400 "certificate_nonce_linear_witness:proof_size");
401 }
402 const auto& constants = leaf.parent_constants();
403 if (raw_generator_digest.has_value() &&
404 *raw_generator_digest != constants.raw_generator_digest) {
405 return unexpected_error(
407 "certificate_nonce_linear_witness:generator_digest");
408 }
409 raw_generator_digest = constants.raw_generator_digest;
410 response.leaves.push_back(std::move(leaf));
411 response.proofs.push_back(std::move(proof));
412 }
413 accepted.push_back(std::move(response));
414 }
415 if (!raw_generator_digest.has_value()) {
416 return unexpected_error(
418 "certificate_nonce_linear_witness:empty_leaves");
419 }
420
421 std::vector<CertificateNonceResponseVerificationView>
422 verification_views;
423 verification_views.reserve(ordered_responses.size());
424 for (std::size_t index = 0; index < ordered_responses.size(); ++index) {
425 verification_views.emplace_back(
426 ordered_responses[index].inputs(), accepted[index].leaves);
427 }
429 accumulator.verify_linear_receipt(
430 receipt, verification_views, secp_context),
431 "certificate_nonce_linear_witness:verify_receipt");
432
433 std::size_t expected_size = kLinearHeaderSize;
434 for (std::size_t index = 0; index < ordered_responses.size(); ++index) {
436 add_size(expected_size, kResponseHeaderSize),
437 "certificate_nonce_linear_witness:response_header");
439 add_size(
440 expected_size,
441 ordered_responses[index]
442 .inputs()
443 .canonical_bytes()
444 .size()),
445 "certificate_nonce_linear_witness:response_inputs");
446 std::size_t member_bytes = 0;
447 if (!checked_mul_size(
448 accepted[index].proofs.size(), kLinearMemberSize,
449 member_bytes)) {
450 return unexpected_error(
452 "certificate_nonce_linear_witness:member_bytes");
453 }
455 add_size(expected_size, member_bytes),
456 "certificate_nonce_linear_witness:member_bytes");
457 }
458 if (!size_fits_u64(ordered_responses.size())) {
459 return unexpected_error(
461 "certificate_nonce_linear_witness:response_count");
462 }
463
464 Bytes encoded;
465 encoded.reserve(expected_size);
466 append(encoded, kLinearJoinedWitnessMagic);
467 append(encoded, *raw_generator_digest);
468 append(encoded, accumulator.leaves().basis().digest());
469 append(encoded, receipt.certificate_context_digest());
470 append_u64(
471 encoded, static_cast<std::uint64_t>(ordered_responses.size()));
472 const auto& basis = accumulator.leaves().basis();
473 for (std::size_t response_index = 0;
474 response_index < ordered_responses.size(); ++response_index) {
475 const auto canonical =
476 ordered_responses[response_index].inputs().canonical_bytes();
477 const auto& response = accepted[response_index];
478 if (!size_fits_u64(canonical.size()) ||
479 response.proofs.size() >
480 std::numeric_limits<std::uint32_t>::max()) {
481 return unexpected_error(
483 "certificate_nonce_linear_witness:response_framing");
484 }
485 append_u64(
486 encoded, static_cast<std::uint64_t>(canonical.size()));
487 append(encoded, canonical);
488 append_u32(
489 encoded,
490 static_cast<std::uint32_t>(response.proofs.size()));
491 for (std::size_t member_index = 0;
492 member_index < response.proofs.size(); ++member_index) {
493 const auto& constants =
494 response.leaves[member_index].parent_constants();
495 append(encoded, constants.circuit_binding_digest);
496 append(encoded, constants.coefficient_commitment);
497 append(encoded, constants.anchored_offset);
498 append(encoded, response.proofs[member_index]);
499
500 const auto& member = receipt.responses()[response_index]
501 .members[member_index];
503 auto reduction,
505 serialize_algebraic_norm_reduction(
506 basis, member.reduction, secp_context),
507 "certificate_nonce_linear_witness:reduction");
508 if (reduction.size() !=
510 kReductionSerializedSize) {
511 return unexpected_error(
513 "certificate_nonce_linear_witness:reduction_size");
514 }
515 append(encoded, reduction);
517 auto step,
519 basis, member.accumulation, secp_context),
520 "certificate_nonce_linear_witness:step");
521 if (step.size() !=
523 return unexpected_error(
525 "certificate_nonce_linear_witness:step_size");
526 }
527 append(encoded, step);
528 }
529 }
530 if (encoded.size() != expected_size) {
531 return unexpected_error(
533 "certificate_nonce_linear_witness:final_size");
534 }
535 return encoded;
536}
537
538} // namespace purify::puresign_plusplus
Accepted joined witness for a certificate-parent prover.
Common interface for reusable experimental BPPP backend state.
Definition bppp.hpp:129
const Digest & digest() const
Result< PreparedCertificateNonceLeaf > prepare(const PublicKey &public_key, const TopicProofCache &cache, const NonceProof &proof, purify_secp_context *secp_context, bppp::ExperimentalCircuitBackend *circuit_cache=nullptr) const
Definition bppp.cpp:1193
std::span< const CertificateNonceLinearResponseProof > responses() const noexcept
const bppp::accumulation::Digest & certificate_context_digest() const noexcept
const bppp::accumulation::Digest & certificate_context_digest() const noexcept
std::span< const CertificateNonceNativeResponse > responses() const noexcept
Status verify_native_receipt(const CertificateNonceNativeReceipt &receipt, std::span< const CertificateNonceResponseVerificationView > ordered_responses, purify_secp_context *secp_context) const
Status verify_linear_receipt(const CertificateNonceLinearReceipt &receipt, std::span< const CertificateNonceResponseVerificationView > ordered_responses, purify_secp_context *secp_context) const
std::span< const bppp::accumulation::Digest > step_digests() const noexcept
#define PURIFY_RETURN_IF_ERROR(expr, context)
Evaluates an expected-like expression and returns the wrapped error on failure.
Definition error.hpp:329
#define PURIFY_ASSIGN_OR_RETURN(lhs, expr, context)
Evaluates an expected-like expression, binds the value to lhs, and propagates errors.
Definition error.hpp:338
Result< std::array< unsigned char, 32 > > nonce_evaluation_input(const ConflictContext &context, purify_secp_context *secp_context)
Derive the candidate deterministic Purify input from the registered slot.
Result< Bytes > serialize_algebraic_step(const Basis &basis, const AlgebraicStepProof &proof, purify_secp_context *context)
Result< Bytes > serialize_accepted_linear_certificate_nonce_parent_witness(const CertificateNonceParentAccumulator &accumulator, const CertificateNonceLinearReceipt &receipt, std::span< const CertificateNonceResponseProverView > ordered_responses, purify_secp_context *secp_context, bppp::ExperimentalCircuitBackend *cache=nullptr)
Result< Bytes > serialize_accepted_certificate_nonce_parent_witness(const CertificateNonceParentAccumulator &accumulator, const CertificateNonceNativeReceipt &receipt, std::span< const CertificateNonceResponseProverView > ordered_responses, purify_secp_context *secp_context, bppp::ExperimentalCircuitBackend *cache=nullptr)
Result< CertificateParentPublicFrame > serialize_certificate_parent_public_frame(const CertificateNonceRecursiveManifestResolution &resolution)
std::array< unsigned char, kCertificateParentPublicFrameSize > CertificateParentPublicFrame
Result< Bytes > serialize_certificate_nonce_native_receipt(const CertificateNonceParentAccumulator &accumulator, const CertificateNonceNativeReceipt &receipt, purify_secp_context *secp_context)
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 checked_mul_size(std::size_t lhs, std::size_t rhs, std::size_t &out) noexcept
Definition common.hpp:71
Expected< T, Error > Result
Expected-returning convenience alias for Purify value-producing APIs.
Definition error.hpp:99
Expected< void, Error > Status
Expected-returning convenience alias for Purify status-only APIs.
Definition error.hpp:102
std::vector< unsigned char > Bytes
Dynamically sized byte string used for messages, serialized witnesses, and proofs.
Definition common.hpp:99
bool checked_add_size(std::size_t lhs, std::size_t rhs, std::size_t &out) noexcept
Definition common.hpp:63
static constexpr std::size_t kSerializedSize
Definition bppp.hpp:298
static Result< TopicProofCache > build(std::span< const unsigned char > topic)
Builds a reusable verifier template for one exact topic.
Definition bppp.cpp:389