20std::array<unsigned char, 8> encode_u64(std::size_t value) {
21 std::array<unsigned char, 8> out{};
22 const auto encoded =
static_cast<std::uint64_t
>(value);
23 for (std::size_t i = 0; i < out.size(); ++i) {
24 out[out.size() - 1 - i] =
25 static_cast<unsigned char>(encoded >> (8 * i));
30template <
typename Roster>
33 std::span<const puresign_plusplus::PublicKey> ordered_hosts,
37 "accountable:nonce_hosts_context"),
38 "accountable:nonce_hosts_context");
39 if (roster.members().empty()) {
41 "accountable:nonce_hosts_empty");
43 if (ordered_hosts.size() != roster.members().size()) {
45 "accountable:nonce_hosts_count");
49 "accountable:nonce_hosts_count");
52 const auto count = encode_u64(ordered_hosts.size());
53 std::size_t encoded_size = 0;
58 "accountable:nonce_hosts_size");
61 preimage.reserve(encoded_size);
62 preimage.insert(preimage.end(), roster.signing_key().begin(),
63 roster.signing_key().end());
64 preimage.insert(preimage.end(), roster.key_list_hash().begin(),
65 roster.key_list_hash().end());
66 preimage.insert(preimage.end(), count.begin(), count.end());
68 for (std::size_t i = 0; i < ordered_hosts.size(); ++i) {
69 const auto& member = roster.members()[i];
70 const auto& host = ordered_hosts[i];
71 if (member.public_key[0] != 0x02 ||
72 !std::equal(host.bip340_pubkey.begin(),
73 host.bip340_pubkey.end(),
74 member.public_key.begin() + 1)) {
76 "accountable:nonce_host_member_key");
79 "accountable:nonce_host_purify_key");
81 secp_context, host.bip340_pubkey.data()) == 0) {
83 "accountable:nonce_host_signing_key");
85 for (std::size_t j = 0; j < i; ++j) {
86 if (ordered_hosts[j].purify_pubkey == host.purify_pubkey) {
88 "accountable:duplicate_nonce_host");
91 const auto encoded_host = host.serialize();
92 preimage.insert(preimage.end(), member.public_key.begin(),
93 member.public_key.end());
94 preimage.insert(preimage.end(), encoded_host.begin(),
97 static const TaggedHash hash(
98 "Purify/Accountable/NonceHostRoster/v1");
99 return hash.digest(preimage);
106 std::span<const unsigned char> canonical_body,
108 if (context.signing_key != roster.signing_key() ||
109 context.host_commitment != roster.nonce_host_commitment() ||
110 context.coalition_core_digest != roster.coalition_core_digest() ||
111 nonce_set.signing_key() != roster.signing_key() ||
112 nonce_set.host_commitment() != roster.nonce_host_commitment() ||
113 nonce_set.coalition_core_digest() !=
114 roster.coalition_core_digest()) {
116 "accountable:response_roster_binding");
119 const auto& nonce_input,
121 "accountable:response_nonce_input");
122 if (nonce_input != nonce_set.nonce_input()) {
124 "accountable:response_nonce_context");
130 const std::array<unsigned char, 33>& key,
131 const FieldElement& weighted_challenge,
134 const auto negative_weight = weighted_challenge.negate().to_bytes_be();
135 std::array<unsigned char, 33> key_term{};
137 negative_weight.data(), key_term.data()) == 0) {
139 "accountable:response_key_term");
141 const auto scalar = response.serialize();
142 std::array<unsigned char, 33> nonce{};
144 secp_context, key_term.data(), scalar.data(),
145 nonce.data()) == 0) {
147 "accountable:response_nonce_at_infinity");
154 const std::array<unsigned char, 33>& verified_nonce,
159 response_nonce(member.public_key,
160 challenge * member.coefficient,
161 partial.response, secp_context),
162 "accountable:partial_nonce");
163 if (nonce != verified_nonce) {
165 "accountable:partial_response_equation");
174 std::span<const puresign_plusplus::PublicKey> ordered_hosts,
176 return compute_nonce_host_commitment(roster, ordered_hosts,
182 std::span<const puresign_plusplus::PublicKey> ordered_hosts,
184 return compute_nonce_host_commitment(roster, ordered_hosts,
190 std::span<const puresign_plusplus::PublicKey> ordered_hosts,
193 std::move(roster), formation.
core_digest(), ordered_hosts,
200 std::span<const puresign_plusplus::PublicKey> ordered_hosts,
203 const auto& commitment,
205 "accountable:bind_nonce_hosts");
206 return NonceHostBoundSigningRoster(
213 std::span<const puresign_plusplus::PublicKey> ordered_hosts,
214 std::span<const puresign_plusplus::NonceProof> ordered_proofs,
217 if (ordered_proofs.size() != ordered_hosts.size() ||
218 ordered_hosts.size() != roster.
members().size()) {
220 "accountable:nonce_proof_count");
223 const auto& registered_hosts,
225 "accountable:nonce_host_commitment");
231 "accountable:nonce_roster_binding");
236 "accountable:nonce_input");
240 "accountable:nonce_proof_cache");
244 std::optional<VerifiedCoalitionNonceSet::Point> aggregate;
245 for (std::size_t i = 0; i < ordered_proofs.size(); ++i) {
247 const auto& accepted,
248 ordered_hosts[i].verify_topic_nonce_proof(
249 proof_cache, ordered_proofs[i], secp_context, cache),
250 "accountable:nonce_proof");
253 "accountable:nonce_proof");
255 const auto point = ordered_proofs[i].commitment_point;
259 }
else if ((*aggregate)[0] != point[0] &&
260 std::equal(aggregate->begin() + 1, aggregate->end(),
261 point.begin() + 1)) {
268 point.data(), next.data()) == 0) {
270 "accountable:aggregate_nonce_sum");
277 "accountable:aggregate_nonce_infinity");
279 return VerifiedCoalitionNonceSet(
286 const VerifiedCoalitionNonceSet& nonce_set,
288 std::span<const unsigned char> canonical_body,
291 if (member_index >= roster.
members().size() ||
292 member_index >= nonce_set.member_nonces_.size()) {
294 "accountable:response_member_index");
297 const auto& challenge,
298 roster_challenge(roster, nonce_set, context, canonical_body,
300 "accountable:partial_challenge");
301 return check_partial(roster.
members()[member_index],
302 nonce_set.member_nonces_[member_index], challenge,
303 partial, secp_context);
308 const VerifiedCoalitionNonceSet& nonce_set,
310 std::span<const unsigned char> canonical_body,
314 roster_challenge(roster, nonce_set, context, canonical_body,
316 "accountable:scalar_response_context");
318 const auto& reconstructed,
320 "accountable:scalar_response_nonce");
321 if (reconstructed != nonce_set.aggregate_nonce_) {
323 "accountable:scalar_response_nonce");
329 Bytes(canonical_body.begin(), canonical_body.end()));
334 const VerifiedCoalitionNonceSet& nonce_set,
336 std::span<const unsigned char> canonical_body,
337 std::span<const PartialResponse> partials,
339 if (roster.
members().empty()) {
341 "accountable:empty_response_roster");
343 if (partials.size() != roster.
members().size() ||
344 partials.size() != nonce_set.member_nonces_.size()) {
346 "accountable:response_member_count");
349 const auto& challenge,
350 roster_challenge(roster, nonce_set, context, canonical_body,
352 "accountable:aggregate_challenge");
354 for (std::size_t i = 0; i < partials.size(); ++i) {
356 check_partial(roster.
members()[i], nonce_set.member_nonces_[i],
357 challenge, partials[i], secp_context),
358 "accountable:aggregate_partial");
360 partials[i].response.serialize());
363 const auto& response,
365 "accountable:aggregate_response");
367 canonical_body, response, secp_context);
371 const VerifiedScalarResponse& first,
372 const VerifiedScalarResponse& second,
374 if (first.signing_key_ != second.signing_key_ ||
375 first.host_commitment_ != second.host_commitment_ ||
376 first.coalition_core_digest_ != second.coalition_core_digest_ ||
377 first.slot_ != second.slot_ || first.nonce_ != second.nonce_) {
379 "accountable:verified_conflict_binding");
381 if (first.body_ == second.body_) {
383 "accountable:verified_conflict_body");
386 first.signing_key_, first.host_commitment_,
387 first.coalition_core_digest_, first.slot_};
389 const auto& recovered,
391 second.body_, second.response_, secp_context),
392 "accountable:verified_conflict_recover");
395 first.host_commitment_, first.coalition_core_digest_);
int purify_point_scale(purify_secp_context *context, const unsigned char point33[33], const unsigned char scalar32[32], unsigned char out33[33])
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_offset_commitment(purify_secp_context *context, const unsigned char commitment33[33], const unsigned char scalar32[32], unsigned char commitment_out33[33])
C ABI bridging Purify C++ code to secp256k1-zkp BPPP functionality.
static FieldElement from_bytes32(const std::array< unsigned char, 32 > &bytes)
Decodes a 32-byte big-endian field element.
static FieldElement zero()
Returns the additive identity of the scalar field.
An ordered signing roster bound to one core and nonce-host list.
std::span< const SigningRosterMember > members() const
const std::array< unsigned char, 32 > & signing_key() const
const NonceHostCommitment & nonce_host_commitment() const
const CoalitionCoreDigest & coalition_core_digest() const
Canonical 32-byte scalar response; carries no nonce or proof.
static Result< ScalarSignature > deserialize(std::span< const unsigned char > bytes)
Parse exactly 32 big-endian bytes below the group order, including zero.
Experimental public key aggregation for one ordered coalition roster.
const std::array< unsigned char, 32 > & nonce_input() const
std::span< const Point > member_nonces() const
std::array< unsigned char, 33 > Point
Common interface for reusable experimental BPPP backend state.
#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, 33 > > reconstruct_nonce(const ConflictContext &context, std::span< const unsigned char > canonical_body, const ScalarSignature &signature, purify_secp_context *secp_context)
Reconstruct the full nonce point as sigma*G - e*Q, rejecting infinity.
Result< NonceHostCommitment > nonce_host_commitment(const SigningRoster &roster, std::span< const puresign_plusplus::PublicKey > ordered_hosts, purify_secp_context *secp_context)
Result< VerifiedCoalitionNonceSet > verify_coalition_nonce_set(const NonceHostBoundSigningRoster &roster, const ConflictContext &context, std::span< const puresign_plusplus::PublicKey > ordered_hosts, std::span< const puresign_plusplus::NonceProof > ordered_proofs, purify_secp_context *secp_context, bppp::ExperimentalCircuitBackend *cache=nullptr)
Result< ExposedCoalitionKey > recover_verified_same_slot_key(const VerifiedScalarResponse &first, const VerifiedScalarResponse &second, purify_secp_context *secp_context)
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< NonceHostBoundSigningRoster > bind_nonce_hosts(SigningRoster roster, const CoalitionCoreDigest &coalition_core_digest, std::span< const puresign_plusplus::PublicKey > ordered_hosts, purify_secp_context *secp_context)
std::array< unsigned char, 32 > CoalitionCoreDigest
Status verify_partial_response(const NonceHostBoundSigningRoster &roster, const VerifiedCoalitionNonceSet &nonce_set, std::size_t member_index, const ConflictContext &context, std::span< const unsigned char > canonical_body, const PartialResponse &partial, purify_secp_context *secp_context)
Result< VerifiedScalarResponse > verify_scalar_response(const NonceHostBoundSigningRoster &roster, const VerifiedCoalitionNonceSet &nonce_set, const ConflictContext &context, std::span< const unsigned char > canonical_body, const ScalarSignature &response, purify_secp_context *secp_context)
Result< FieldElement > signature_challenge(const ConflictContext &context, std::span< const unsigned char > canonical_body, purify_secp_context *secp_context)
Compute the versioned Q/U/core/T/body challenge, without a nonce point.
Result< VerifiedScalarResponse > aggregate_responses(const NonceHostBoundSigningRoster &roster, const VerifiedCoalitionNonceSet &nonce_set, const ConflictContext &context, std::span< const unsigned char > canonical_body, std::span< const PartialResponse > partials, purify_secp_context *secp_context)
Result< std::array< unsigned char, 32 > > recover_same_slot_key(const ConflictContext &context, std::span< const unsigned char > first_body, const ScalarSignature &first_signature, std::span< const unsigned char > second_body, const ScalarSignature &second_signature, purify_secp_context *secp_context)
Recover the exact signing scalar exposed by two same-slot responses.
Result< NonceHostBoundSigningRoster > bind_formation_nonce_hosts(SigningRoster roster, const CoalitionFormation &formation, std::span< const puresign_plusplus::PublicKey > ordered_hosts, 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
Status validate_public_key(const UInt512 &packed)
Validates the packed public-key encoding range.
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_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.
Public context shared by conflicting statements in one slashable slot.
std::array< unsigned char, 32 > host_commitment
std::span< const unsigned char > slot
std::array< unsigned char, 32 > signing_key
CoalitionCoreDigest coalition_core_digest
An ordered individual signing key and its normalized public weight.
static Result< TopicProofCache > build(std::span< const unsigned char > topic)
Builds a reusable verifier template for one exact topic.