25using Clock = std::chrono::steady_clock;
28 std::size_t coalitions = 0;
29 std::size_t members = 0;
30 std::size_t topics = 0;
31 std::size_t domains = 0;
34struct PublicCoalitionPacket {
35 std::vector<purify::NonceBatchGroup> groups;
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;
59double elapsed_ms(Clock::time_point start) {
60 return std::chrono::duration<double, std::milli>(Clock::now() - start).count();
66 std::cerr <<
"Failed at " << stage <<
": " << result.
error().
name() <<
'\n';
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";
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;
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;
102purify::Bytes topic_bytes(std::size_t coalition, std::size_t domain, std::size_t slot) {
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));
118bool build_coalition_packet(std::size_t coalition,
119 const Dimensions& dimensions,
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) {
128 if (!succeeded(key,
"member key generation"))
return false;
129 keys.push_back(std::move(*key));
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) {
139 if (!succeeded(topic,
"topic preparation"))
return false;
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) {
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));
151 packet.groups.push_back(std::move(group));
152 assignments.push_back(std::move(member_assignments));
157 if (!succeeded(circuit,
"coalition batch circuit"))
return false;
159 if (!succeeded(assignment,
"coalition batch assignment"))
return false;
162 measurements.preparation_ms += elapsed_ms(stage);
166 if (!succeeded(entropy,
"private prover randomness"))
return false;
168 stage = Clock::now();
171 statement_binding(), {}, &cache);
172 if (!succeeded(proof,
"coalition proof generation"))
return false;
173 measurements.proving_ms += elapsed_ms(stage);
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);
185bool prepare_certificate(std::span<const PublicCoalitionPacket> packets,
187 Measurements& measurements) {
188 for (
const auto& packet : packets) {
189 auto stage = Clock::now();
191 if (!succeeded(circuit,
"public statement reconstruction"))
return false;
193 if (!succeeded(proof,
"public proof parsing"))
return false;
194 measurements.public_statement_reconstruction_ms += elapsed_ms(stage);
198 stage = Clock::now();
201 statement_binding(), &cache);
202 if (!succeeded(verified,
"public proof verification"))
return false;
204 std::cerr <<
"Public certificate preparation rejected a coalition proof\n";
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();
211 measurements.proof_payload_bytes += packet.serialized_proof.size();
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();
220 if (context ==
nullptr) {
221 std::cerr <<
"Failed to create secp context\n";
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;
230 std::cerr <<
"Preparing certificate from public packets\n";
231 if (!prepare_certificate(packets, context.get(), measurements))
return 1;
233 std::cout << std::fixed << std::setprecision(3)
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];
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"
269int main(
int argc,
char** argv) {
270 if (argc == 2 && std::string_view(argv[1]) ==
"--help") {
271 usage(std::cout, argv[0]);
274 Dimensions dimensions;
275 if (!parse_dimensions(argc, argv, dimensions)) {
276 usage(std::cerr, argv[0]);
279 return benchmark(dimensions);
int main(int argc, char **argv)
C++ wrappers for the BPPP functionality used by Purify.
bool has_value() const noexcept
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.
void secure_clear_bytes(void *data, std::size_t size) noexcept
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.
Result< GeneratedKey > generate_key()
Generates a random Purify keypair using the built-in OS RNG.
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.
SecpContextPtr make_secp_context() noexcept
Expected< T, Error > Result
Expected-returning convenience alias for Purify value-producing APIs.
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.
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.
Umbrella header that re-exports the public Purify API.
constexpr std::string_view name() const noexcept
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.