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 =
44 kCertificateParentPublicFrameMagic.size() + 2 * kDigestSize +
45 2 *
sizeof(std::uint64_t) ==
47static_assert(kLinearHeaderSize == 120);
48static_assert(kLinearMemberSize == 2'984);
50template <std::
size_t N>
51void append(
Bytes& output,
const std::array<unsigned char, N>& bytes)
53 output.insert(output.end(), bytes.begin(), bytes.end());
56void append(
Bytes& output, std::span<const unsigned char> bytes)
58 output.insert(output.end(), bytes.begin(), bytes.end());
61void append_u32(
Bytes& output, std::uint32_t value)
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));
69void append_u64(
Bytes& output, std::uint64_t value)
71 for (
unsigned int shift = 56; shift != 0; shift -= 8) {
72 output.push_back(
static_cast<unsigned char>(value >> shift));
74 output.push_back(
static_cast<unsigned char>(value));
77struct AcceptedResponse {
78 std::vector<PreparedCertificateNonceLeaf> leaves;
79 std::vector<Bytes> proofs;
82Status add_size(std::size_t& total, std::size_t value)
87 "certificate_nonce_parent_witness:encoded_size");
98 const auto step_count = resolution.
step_digests().size();
102 "certificate_parent_public_frame:step_count");
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();
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);
117 frame[offset++] =
static_cast<unsigned char>(value);
120 append(kCertificateParentPublicFrameMagic);
123 append_u64(
static_cast<std::uint64_t
>(step_count));
125 assert(offset == frame.size());
132 std::span<const CertificateNonceResponseProverView>
139 secp_context,
"certificate_nonce_parent_witness:context"),
140 "certificate_nonce_parent_witness:context");
141 if (ordered_responses.size() != receipt.
responses().size()) {
144 "certificate_nonce_parent_witness:response_count");
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 !=
157 frame.total_responses != ordered_responses.size() ||
158 frame.response_ordinal != response_index ||
159 inputs.statement_digest() !=
160 receipt.
responses()[response_index].statement_digest()) {
163 "certificate_nonce_parent_witness:response_frame");
165 if (view.ordered_hosts().size() !=
166 view.ordered_proofs().size() ||
167 view.ordered_proofs().size() !=
168 inputs.leaf_bindings().size()) {
171 "certificate_nonce_parent_witness:member_count");
175 const auto nonce_input,
177 view.context(), secp_context),
178 "certificate_nonce_parent_witness:nonce_input");
181 "certificate_nonce_parent_witness:topic_cache");
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();
192 view.ordered_hosts()[member_index], topic_cache,
193 view.ordered_proofs()[member_index], secp_context,
195 "certificate_nonce_parent_witness:prepare_leaf");
198 view.ordered_proofs()[member_index].serialize(
200 "certificate_nonce_parent_witness:serialize_proof");
204 "certificate_nonce_parent_witness:proof_size");
206 const auto& constants = leaf.parent_constants();
207 if (raw_generator_digest.has_value() &&
208 *raw_generator_digest != constants.raw_generator_digest) {
211 "certificate_nonce_parent_witness:raw_generator_digest");
213 raw_generator_digest = constants.raw_generator_digest;
214 response.leaves.push_back(std::move(leaf));
215 response.proofs.push_back(std::move(proof));
217 accepted.push_back(std::move(response));
219 if (!raw_generator_digest.has_value()) {
222 "certificate_nonce_parent_witness:empty_leaves");
225 std::vector<CertificateNonceResponseVerificationView>
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);
234 receipt, verification_views, secp_context),
235 "certificate_nonce_parent_witness:verify_receipt");
238 const auto receipt_bytes,
240 accumulator, receipt, secp_context),
241 "certificate_nonce_parent_witness:serialize_receipt");
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;
254 accepted[index].proofs.size(),
259 "certificate_nonce_parent_witness:proof_bytes");
262 add_size(expected_size, proof_bytes),
263 "certificate_nonce_parent_witness:proof_bytes");
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");
276 "certificate_nonce_parent_witness:framing");
280 encoded.reserve(expected_size);
281 append(encoded, kJoinedWitnessMagic);
282 append(encoded, *raw_generator_digest);
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();
289 accepted[index].proofs.size() >
290 std::numeric_limits<std::uint32_t>::max()) {
293 "certificate_nonce_parent_witness:response_framing");
296 encoded,
static_cast<std::uint64_t
>(canonical.size()));
297 append(encoded, canonical);
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();
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]);
313 encoded,
static_cast<std::uint64_t
>(receipt_bytes.size()));
314 append(encoded, receipt_bytes);
315 if (encoded.size() != expected_size) {
318 "certificate_nonce_parent_witness:final_size");
327 std::span<const CertificateNonceResponseProverView>
335 "certificate_nonce_linear_witness:context"),
336 "certificate_nonce_linear_witness:context");
337 if (ordered_responses.size() != receipt.
responses().size()) {
340 "certificate_nonce_linear_witness:response_count");
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 !=
353 frame.total_responses != ordered_responses.size() ||
354 frame.response_ordinal != response_index) {
357 "certificate_nonce_linear_witness:response_frame");
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()) {
367 "certificate_nonce_linear_witness:member_count");
371 const auto nonce_input,
373 view.context(), secp_context),
374 "certificate_nonce_linear_witness:nonce_input");
377 "certificate_nonce_linear_witness:topic_cache");
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();
388 view.ordered_hosts()[member_index], topic_cache,
389 view.ordered_proofs()[member_index], secp_context,
391 "certificate_nonce_linear_witness:prepare_leaf");
394 view.ordered_proofs()[member_index].serialize(
396 "certificate_nonce_linear_witness:serialize_proof");
400 "certificate_nonce_linear_witness:proof_size");
402 const auto& constants = leaf.parent_constants();
403 if (raw_generator_digest.has_value() &&
404 *raw_generator_digest != constants.raw_generator_digest) {
407 "certificate_nonce_linear_witness:generator_digest");
409 raw_generator_digest = constants.raw_generator_digest;
410 response.leaves.push_back(std::move(leaf));
411 response.proofs.push_back(std::move(proof));
413 accepted.push_back(std::move(response));
415 if (!raw_generator_digest.has_value()) {
418 "certificate_nonce_linear_witness:empty_leaves");
421 std::vector<CertificateNonceResponseVerificationView>
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);
430 receipt, verification_views, secp_context),
431 "certificate_nonce_linear_witness:verify_receipt");
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");
441 ordered_responses[index]
445 "certificate_nonce_linear_witness:response_inputs");
446 std::size_t member_bytes = 0;
448 accepted[index].proofs.size(), kLinearMemberSize,
452 "certificate_nonce_linear_witness:member_bytes");
455 add_size(expected_size, member_bytes),
456 "certificate_nonce_linear_witness:member_bytes");
461 "certificate_nonce_linear_witness:response_count");
465 encoded.reserve(expected_size);
466 append(encoded, kLinearJoinedWitnessMagic);
467 append(encoded, *raw_generator_digest);
471 encoded,
static_cast<std::uint64_t
>(ordered_responses.size()));
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];
479 response.proofs.size() >
480 std::numeric_limits<std::uint32_t>::max()) {
483 "certificate_nonce_linear_witness:response_framing");
486 encoded,
static_cast<std::uint64_t
>(canonical.size()));
487 append(encoded, canonical);
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]);
500 const auto& member = receipt.
responses()[response_index]
501 .members[member_index];
505 serialize_algebraic_norm_reduction(
506 basis, member.reduction, secp_context),
507 "certificate_nonce_linear_witness:reduction");
508 if (reduction.size() !=
510 kReductionSerializedSize) {
513 "certificate_nonce_linear_witness:reduction_size");
515 append(encoded, reduction);
519 basis, member.accumulation, secp_context),
520 "certificate_nonce_linear_witness:step");
525 "certificate_nonce_linear_witness:step_size");
527 append(encoded, step);
530 if (encoded.size() != expected_size) {
533 "certificate_nonce_linear_witness:final_size");
Common interface for reusable experimental BPPP backend state.
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
const bppp::accumulation::Basis & basis() const noexcept
static constexpr std::size_t kReductionSerializedSize
std::span< const CertificateNonceLinearResponseProof > responses() const noexcept
const bppp::accumulation::Digest & certificate_context_digest() const noexcept
static constexpr std::size_t kStepSerializedSize
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
const CertificateNonceLeafAccumulator & leaves() const noexcept
Status verify_linear_receipt(const CertificateNonceLinearReceipt &receipt, std::span< const CertificateNonceResponseVerificationView > ordered_responses, purify_secp_context *secp_context) const
const bppp::accumulation::Digest & certificate_context_digest() const noexcept
std::span< const bppp::accumulation::Digest > step_digests() const noexcept
const CertificateNonceRecursiveManifest & manifest() const noexcept
std::uint64_t total_responses() const noexcept
const bppp::ScalarBytes & bytes() 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.
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)
constexpr std::size_t kCertificateParentPublicFrameSize
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)
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 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.
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
static constexpr std::size_t kSerializedSize
static Result< TopicProofCache > build(std::span< const unsigned char > topic)
Builds a reusable verifier template for one exact topic.