purify
C++ Purify implementation with native circuit and BPP support
Loading...
Searching...
No Matches
bench_nonce_batch.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
5// Coalition proving is centralized. Certificate preparation receives only
6// public packets; it verifies existing proofs without compressing them.
7
8#include <charconv>
9#include <chrono>
10#include <cstddef>
11#include <cstdint>
12#include <iomanip>
13#include <iostream>
14#include <span>
15#include <string_view>
16#include <utility>
17#include <vector>
18
19#include "purify.hpp"
20#include "purify/bppp.hpp"
22
23namespace {
24
25using Clock = std::chrono::steady_clock;
26
27struct Dimensions {
28 std::size_t coalitions = 0;
29 std::size_t members = 0;
30 std::size_t topics = 0;
31 std::size_t domains = 0;
32};
33
34struct PublicCoalitionPacket {
35 std::vector<purify::NonceBatchGroup> groups;
36 purify::Bytes serialized_proof;
37};
38
39struct Measurements {
40 double preparation_ms = 0;
41 double proving_ms = 0;
42 double serialization_ms = 0;
43 double public_statement_reconstruction_ms = 0;
44 double public_verification_ms = 0;
45 std::size_t raw_proof_bytes = 0;
46 std::size_t commitment_bytes = 0;
47 std::size_t proof_payload_bytes = 0;
48 std::vector<std::size_t> coalition_gates;
49};
50
51struct ProverNonce {
53
54 ~ProverNonce() {
55 purify::detail::secure_clear_bytes(bytes.data(), bytes.size());
56 }
57};
58
59double elapsed_ms(Clock::time_point start) {
60 return std::chrono::duration<double, std::milli>(Clock::now() - start).count();
61}
62
63template <typename T>
64bool succeeded(const purify::Result<T>& result, std::string_view stage) {
65 if (result.has_value()) return true;
66 std::cerr << "Failed at " << stage << ": " << result.error().name() << '\n';
67 return false;
68}
69
70void usage(std::ostream& output, std::string_view executable) {
71 output << "Usage: " << executable
72 << " --coalitions N --members M --topics P --domains K\n"
73 << " Each dimension must be 1..100; N*M*P*K must be <=400.\n"
74 << " One centralized proof per coalition; public-only certificate preparation.\n"
75 << " Imported arithmetic backend; no MPC or succinct public aggregation.\n";
76}
77
78bool parse_dimensions(int argc, char** argv, Dimensions& dimensions) {
79 if (argc != 9) return false;
80 for (int i = 1; i < argc; i += 2) {
81 std::size_t* destination = nullptr;
82 const std::string_view option(argv[i]);
83 if (option == "--coalitions") destination = &dimensions.coalitions;
84 else if (option == "--members") destination = &dimensions.members;
85 else if (option == "--topics") destination = &dimensions.topics;
86 else if (option == "--domains") destination = &dimensions.domains;
87 if (destination == nullptr || *destination != 0) return false;
88 const std::string_view argument(argv[i + 1]);
89 const auto parsed = std::from_chars(argument.data(), argument.data() + argument.size(), *destination);
90 if (parsed.ec != std::errc() || parsed.ptr != argument.data() + argument.size()
91 || *destination < 1 || *destination > 100) return false;
92 }
93 // Bounding each multiplication also makes the check safe on narrow size_t.
94 std::size_t evaluations = 1;
95 for (const auto count : {dimensions.coalitions, dimensions.members, dimensions.topics, dimensions.domains}) {
96 if (count == 0 || count > 400 / evaluations) return false;
97 evaluations *= count;
98 }
99 return true;
100}
101
102purify::Bytes topic_bytes(std::size_t coalition, std::size_t domain, std::size_t slot) {
103 auto topic = purify::bytes_from_ascii("Purify/NonceBatch/Benchmark/Topic/V1");
104 for (const auto index : {coalition, domain, slot}) {
105 const auto value = static_cast<std::uint64_t>(index);
106 for (unsigned shift = 0; shift < 64; shift += 8) {
107 topic.push_back(static_cast<unsigned char>(value >> shift));
108 }
109 }
110 return topic;
111}
112
113const purify::Bytes& statement_binding() {
114 static const auto binding = purify::bytes_from_ascii("Purify/NonceBatch/Benchmark/Arithmetic/V1");
115 return binding;
116}
117
118bool build_coalition_packet(std::size_t coalition,
119 const Dimensions& dimensions,
120 purify_secp_context* context,
121 PublicCoalitionPacket& packet,
122 Measurements& measurements) {
123 auto stage = Clock::now();
124 std::vector<purify::GeneratedKey> keys;
125 keys.reserve(dimensions.members);
126 for (std::size_t member = 0; member < dimensions.members; ++member) {
127 auto key = purify::generate_key();
128 if (!succeeded(key, "member key generation")) return false;
129 keys.push_back(std::move(*key));
130 }
131
132 std::vector<std::vector<purify::BulletproofAssignmentData>> assignments;
133 const auto output_count = dimensions.topics * dimensions.domains;
134 packet.groups.reserve(output_count);
135 assignments.reserve(output_count);
136 for (std::size_t domain = 0; domain < dimensions.domains; ++domain) {
137 for (std::size_t slot = 0; slot < dimensions.topics; ++slot) {
138 auto topic = purify::puresign::TopicProofCache::build(topic_bytes(coalition, domain, slot));
139 if (!succeeded(topic, "topic preparation")) return false;
141 group.evaluation_input = topic->eval_input;
142 group.hosts.reserve(dimensions.members);
143 std::vector<purify::BulletproofAssignmentData> member_assignments;
144 member_assignments.reserve(dimensions.members);
145 for (const auto& key : keys) {
146 auto witness = purify::prove_assignment_data(group.evaluation_input, key.secret);
147 if (!succeeded(witness, "member witness generation")) return false;
148 group.hosts.push_back(witness->public_key);
149 member_assignments.push_back(std::move(witness->assignment));
150 }
151 packet.groups.push_back(std::move(group));
152 assignments.push_back(std::move(member_assignments));
153 }
154 }
155
156 auto circuit = purify::nonce_batch_circuit(packet.groups);
157 if (!succeeded(circuit, "coalition batch circuit")) return false;
158 auto assignment = purify::nonce_batch_assignments(packet.groups, assignments);
159 if (!succeeded(assignment, "coalition batch assignment")) return false;
160 assignments.clear();
161 keys.clear();
162 measurements.preparation_ms += elapsed_ms(stage);
163
164 ProverNonce nonce;
165 const auto entropy = purify::fill_secure_random(nonce.bytes);
166 if (!succeeded(entropy, "private prover randomness")) return false;
168 stage = Clock::now();
170 *circuit, *assignment, nonce.bytes, purify::bppp::base_generator(context), context,
171 statement_binding(), {}, &cache);
172 if (!succeeded(proof, "coalition proof generation")) return false;
173 measurements.proving_ms += elapsed_ms(stage);
174
175 stage = Clock::now();
176 auto serialized = proof->serialize();
177 if (!succeeded(serialized, "coalition proof serialization")) return false;
178 packet.serialized_proof = std::move(*serialized);
179 measurements.serialization_ms += elapsed_ms(stage);
180 return true;
181}
182
183// No assignment, secret key, or nonce scalar crosses this API. This diagnostic
184// verifies the immutable packets; it defines no certificate wire format.
185bool prepare_certificate(std::span<const PublicCoalitionPacket> packets,
186 purify_secp_context* context,
187 Measurements& measurements) {
188 for (const auto& packet : packets) {
189 auto stage = Clock::now();
190 auto circuit = purify::nonce_batch_circuit(packet.groups);
191 if (!succeeded(circuit, "public statement reconstruction")) return false;
192 auto proof = purify::ExperimentalBulletproofProof::deserialize(packet.serialized_proof);
193 if (!succeeded(proof, "public proof parsing")) return false;
194 measurements.public_statement_reconstruction_ms += elapsed_ms(stage);
195
196 // Each coalition starts with cold verifier resources.
198 stage = Clock::now();
200 *circuit, *proof, purify::bppp::base_generator(context), context,
201 statement_binding(), &cache);
202 if (!succeeded(verified, "public proof verification")) return false;
203 if (!*verified) {
204 std::cerr << "Public certificate preparation rejected a coalition proof\n";
205 return false;
206 }
207 measurements.public_verification_ms += elapsed_ms(stage);
208 measurements.coalition_gates.push_back(circuit->n_gates);
209 measurements.raw_proof_bytes += proof->proof.size();
210 measurements.commitment_bytes += proof->commitments.size() * sizeof(purify::BulletproofPointBytes);
211 measurements.proof_payload_bytes += packet.serialized_proof.size();
212 }
213 return true;
214}
215
216int benchmark(const Dimensions& dimensions) {
217 std::cerr << "Centralized coalition proofs; public-only verification and packing, no succinct merge.\n";
218 const auto start = Clock::now();
219 auto context = purify::make_secp_context();
220 if (context == nullptr) {
221 std::cerr << "Failed to create secp context\n";
222 return 1;
223 }
224 Measurements measurements;
225 std::vector<PublicCoalitionPacket> packets(dimensions.coalitions);
226 for (std::size_t coalition = 0; coalition < dimensions.coalitions; ++coalition) {
227 std::cerr << "Proving coalition " << coalition + 1 << '/' << dimensions.coalitions << '\n';
228 if (!build_coalition_packet(coalition, dimensions, context.get(), packets[coalition], measurements)) return 1;
229 }
230 std::cerr << "Preparing certificate from public packets\n";
231 if (!prepare_certificate(packets, context.get(), measurements)) return 1;
232
233 std::cout << std::fixed << std::setprecision(3)
234 << "{\n"
235 << " \"backend\": \"imported_legacy_arithmetic\",\n"
236 << " \"centralized_within_coalition\": true,\n"
237 << " \"mpc\": false,\n"
238 << " \"public_only_preparation\": true,\n"
239 << " \"succinct_post_coalition_aggregation\": false,\n"
240 << " \"coalitions\": " << dimensions.coalitions << ",\n"
241 << " \"members\": " << dimensions.members << ",\n"
242 << " \"topics\": " << dimensions.topics << ",\n"
243 << " \"domains\": " << dimensions.domains << ",\n"
244 << " \"member_evaluations\": " << dimensions.coalitions * dimensions.members * dimensions.topics * dimensions.domains << ",\n"
245 << " \"public_commitments\": " << dimensions.coalitions * dimensions.topics * dimensions.domains << ",\n"
246 << " \"coalition_gates\": [";
247 for (std::size_t i = 0; i < measurements.coalition_gates.size(); ++i) {
248 if (i != 0) std::cout << ", ";
249 std::cout << measurements.coalition_gates[i];
250 }
251 std::cout << "],\n"
252 << " \"raw_proof_bytes\": " << measurements.raw_proof_bytes << ",\n"
253 << " \"commitment_bytes\": " << measurements.commitment_bytes << ",\n"
254 << " \"proof_payload_bytes\": " << measurements.proof_payload_bytes << ",\n"
255 << " \"payload_excludes_manifest_bitcoin_and_signatures\": true,\n"
256 << " \"preparation_ms\": " << measurements.preparation_ms << ",\n"
257 << " \"proving_ms\": " << measurements.proving_ms << ",\n"
258 << " \"serialization_ms\": " << measurements.serialization_ms << ",\n"
259 << " \"public_statement_reconstruction_ms\": " << measurements.public_statement_reconstruction_ms << ",\n"
260 << " \"public_verification_ms\": " << measurements.public_verification_ms << ",\n"
261 << " \"total_ms\": " << elapsed_ms(start) << ",\n"
262 << " \"verified\": true\n"
263 << "}\n";
264 return 0;
265}
266
267} // namespace
268
269int main(int argc, char** argv) {
270 if (argc == 2 && std::string_view(argv[1]) == "--help") {
271 usage(std::cout, argv[0]);
272 return 0;
273 }
274 Dimensions dimensions;
275 if (!parse_dimensions(argc, argv, dimensions)) {
276 usage(std::cerr, argv[0]);
277 return 1;
278 }
279 return benchmark(dimensions);
280}
int main(int argc, char **argv)
C++ wrappers for the BPPP functionality used by Purify.
bool has_value() const noexcept
Definition expected.hpp:170
Caller-owned cache for reusable legacy Bulletproof backend resources keyed by gate count.
GeneratorBytes base_generator(purify_secp_context *secp_context)
Returns the serialized secp256k1 base generator used as the blind generator.
Definition bppp.cpp:1702
void secure_clear_bytes(void *data, std::size_t size) noexcept
Definition secret.hpp:22
Result< ExperimentalBulletproofProof > prove_experimental_circuit(const NativeBulletproofCircuit &circuit, const BulletproofAssignmentData &assignment, const BulletproofScalarBytes &nonce, const BulletproofGeneratorBytes &value_generator, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding={}, std::span< const BulletproofScalarBytes > blinds={}, ExperimentalBulletproofBackendCache *backend_cache=nullptr)
Proves a native circuit with the experimental imported Bulletproof circuit backend.
Result< BulletproofWitnessData > prove_assignment_data(const Bytes &message, const SecretKey &secret)
Computes the native Purify witness for a message and secret.
Definition api.cpp:243
Result< GeneratedKey > generate_key()
Generates a random Purify keypair using the built-in OS RNG.
Definition api.cpp:117
Result< bool > verify_experimental_circuit(const NativeBulletproofCircuit &circuit, const ExperimentalBulletproofProof &proof, const BulletproofGeneratorBytes &value_generator, purify_secp_context *secp_context, std::span< const unsigned char > statement_binding={}, ExperimentalBulletproofBackendCache *backend_cache=nullptr)
Verifies a proof produced by prove_experimental_circuit against the same native circuit and ordered o...
Bytes bytes_from_ascii(std::string_view input)
Encodes an ASCII string as a byte vector.
Definition curve.cpp:168
SecpContextPtr make_secp_context() noexcept
Definition common.hpp:52
Expected< T, Error > Result
Expected-returning convenience alias for Purify value-producing APIs.
Definition error.hpp:99
std::array< unsigned char, 33 > BulletproofPointBytes
Result< BulletproofAssignmentData > nonce_batch_assignments(std::span< const NonceBatchGroup > groups, std::span< const std::vector< BulletproofAssignmentData > > assignments)
Validates and combines member assignments for nonce_batch_circuit.
std::array< unsigned char, 32 > BulletproofScalarBytes
std::vector< unsigned char > Bytes
Dynamically sized byte string used for messages, serialized witnesses, and proofs.
Definition common.hpp:99
Result< NativeBulletproofCircuit > nonce_batch_circuit(std::span< const NonceBatchGroup > groups)
Builds a public verifier circuit with one output commitment per group.
Status fill_secure_random(std::span< unsigned char > bytes) noexcept
Fills a buffer with operating-system randomness.
Definition api.cpp:108
Umbrella header that re-exports the public Purify API.
constexpr std::string_view name() const noexcept
Definition error.hpp:310
static Result< ExperimentalBulletproofProof > deserialize(std::span< const unsigned char > bytes)
One ordered coalition/topic relation with its own summed nonce output.
std::vector< UInt512 > hosts
static Result< TopicProofCache > build(std::span< const unsigned char > topic)
Builds a reusable verifier template for one exact topic.
Definition legacy.cpp:798