purify
C++ Purify implementation with native circuit and BPP support
Loading...
Searching...
No Matches
bulletproof.hpp
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
9
10#pragma once
11
12#include <algorithm>
13#include <array>
14#include <cstddef>
15#include <memory>
16#include <optional>
17#include <span>
18#include <string>
19#include <type_traits>
20#include <utility>
21#include <vector>
22
23#include "purify/curve.hpp"
24#include "purify/expr.hpp"
25
28
29namespace purify {
30
31using BulletproofScalarBytes = std::array<unsigned char, 32>;
32using BulletproofPointBytes = std::array<unsigned char, 33>;
33using BulletproofGeneratorBytes = std::array<unsigned char, 33>;
35 std::vector<FieldElement, detail::SecureAllocator<FieldElement>>;
36
47
53
56 std::vector<NativeBulletproofCircuitTerm> entries;
57
59 void add(std::size_t idx, const FieldElement& scalar);
60
68 std::size_t size = 0;
69 std::size_t capacity = 0;
70
71 [[nodiscard]] std::span<const NativeBulletproofCircuitTerm> entries_view() const noexcept {
72 return std::span<const NativeBulletproofCircuitTerm>(data, size);
73 }
74 };
75};
76
85 std::size_t constraint_slack = 0;
86 std::vector<std::size_t> wl;
87 std::vector<std::size_t> wr;
88 std::vector<std::size_t> wo;
89 std::vector<std::size_t> wv;
90 };
91
101 public:
102 PackedWithSlack() = default;
103 PackedWithSlack(const PackedWithSlack& other);
105 PackedWithSlack(PackedWithSlack&& other) noexcept;
106 PackedWithSlack& operator=(PackedWithSlack&& other) noexcept;
107
109 [[nodiscard]] static Result<PackedWithSlack> from_circuit(
110 const NativeBulletproofCircuit& circuit,
111 const PackedSlackPlan& slack);
112
113 [[nodiscard]] std::size_t n_gates() const noexcept {
114 return n_gates_;
115 }
116
117 [[nodiscard]] std::size_t n_commitments() const noexcept {
118 return n_commitments_;
119 }
120
121 [[nodiscard]] std::size_t n_bits() const noexcept {
122 return n_bits_;
123 }
124
125 [[nodiscard]] std::size_t constraint_count() const noexcept {
126 return constraint_size_;
127 }
128
129 [[nodiscard]] std::size_t constraint_capacity() const noexcept {
130 return constraint_capacity_;
131 }
132
133 [[nodiscard]] bool has_valid_shape() const noexcept;
134
136 void reset() noexcept;
137
139 std::size_t add_constraint(const FieldElement& constant = FieldElement::zero());
140
142 void add_left_term(std::size_t gate_idx, std::size_t constraint_idx, const FieldElement& scalar);
143
145 void add_right_term(std::size_t gate_idx, std::size_t constraint_idx, const FieldElement& scalar);
146
148 void add_output_term(std::size_t gate_idx, std::size_t constraint_idx, const FieldElement& scalar);
149
151 void add_commitment_term(std::size_t commitment_idx, std::size_t constraint_idx, const FieldElement& scalar);
152
154 [[nodiscard]] bool evaluate(const BulletproofAssignmentData& assignment) const;
155
157 [[nodiscard]] Result<NativeBulletproofCircuit> unpack() const;
158
160 [[nodiscard]] NativeBulletproofCircuitRow::PackedWithSlack left_row(std::size_t gate_idx) const noexcept;
162 [[nodiscard]] NativeBulletproofCircuitRow::PackedWithSlack right_row(std::size_t gate_idx) const noexcept;
164 [[nodiscard]] NativeBulletproofCircuitRow::PackedWithSlack output_row(std::size_t gate_idx) const noexcept;
166 [[nodiscard]] NativeBulletproofCircuitRow::PackedWithSlack commitment_row(std::size_t commitment_idx) const noexcept;
167
169 [[nodiscard]] std::span<const FieldElement> constants() const noexcept;
170
171 private:
172 struct PackedRowHeader {
173 std::size_t offset = 0;
174 std::size_t size = 0;
175 std::size_t base_size = 0;
176 std::size_t capacity = 0;
177 };
178
179 enum class RowFamily : unsigned char {
180 Left,
181 Right,
182 Output,
184 };
185
186 PackedRowHeader& row_header(RowFamily family, std::size_t idx) noexcept;
187 const PackedRowHeader& row_header(RowFamily family, std::size_t idx) const noexcept;
188 NativeBulletproofCircuitTerm* term_data() noexcept;
189 const NativeBulletproofCircuitTerm* term_data() const noexcept;
190 FieldElement* constant_data() noexcept;
191 const FieldElement* constant_data() const noexcept;
192 unsigned char* raw_storage_bytes() noexcept;
193 const unsigned char* raw_storage_bytes() const noexcept;
194 static bool compute_storage_layout(std::size_t row_count, std::size_t term_capacity,
195 std::size_t constraint_capacity, std::size_t& term_bytes_offset,
196 std::size_t& constant_bytes_offset, std::size_t& storage_bytes) noexcept;
197 static constexpr std::size_t kPackedStorageAlignment =
198 std::max(std::max(alignof(PackedRowHeader), alignof(NativeBulletproofCircuitTerm)),
199 alignof(FieldElement));
200 static std::byte* allocate_storage(std::size_t bytes);
201 void reset_to_empty() noexcept;
202 void start_storage_lifetimes() noexcept;
203 NativeBulletproofCircuitRow::PackedWithSlack row_view(const PackedRowHeader& header) const noexcept;
204 void add_row_term(RowFamily family, std::size_t expected_size, std::size_t row_idx,
205 std::size_t constraint_idx, const FieldElement& scalar);
206
207 struct PackedStorageDeleter {
208 void operator()(std::byte* storage) const noexcept;
209 };
210
211 using PackedStorageOwner = std::unique_ptr<std::byte[], PackedStorageDeleter>;
212
213 std::size_t n_gates_ = 0;
214 std::size_t n_commitments_ = 0;
215 std::size_t n_bits_ = 0;
216 std::size_t constraint_size_ = 0;
217 std::size_t constraint_base_size_ = 0;
218 std::size_t constraint_capacity_ = 0;
219 std::size_t term_capacity_ = 0;
220 std::size_t term_bytes_offset_ = 0;
221 std::size_t constant_bytes_offset_ = 0;
222 std::size_t storage_bytes_ = 0;
223 PackedStorageOwner storage_;
224
225 static_assert(std::is_trivially_copyable_v<PackedRowHeader>,
226 "PackedWithSlack row headers must remain trivially copyable");
227 static_assert(std::is_trivially_destructible_v<PackedRowHeader>,
228 "PackedWithSlack row headers must remain trivially destructible");
229 static_assert(std::is_trivially_copyable_v<NativeBulletproofCircuitTerm>,
230 "PackedWithSlack sparse terms must remain trivially copyable");
231 static_assert(std::is_trivially_destructible_v<NativeBulletproofCircuitTerm>,
232 "PackedWithSlack sparse terms must remain trivially destructible");
233 static_assert(std::is_trivially_copyable_v<FieldElement>,
234 "PackedWithSlack constants must remain trivially copyable");
235 static_assert(std::is_trivially_destructible_v<FieldElement>,
236 "PackedWithSlack constants must remain trivially destructible");
237 static_assert(alignof(PackedRowHeader) <= kPackedStorageAlignment,
238 "PackedWithSlack slab alignment must cover row headers");
239 static_assert(alignof(NativeBulletproofCircuitTerm) <= kPackedStorageAlignment,
240 "PackedWithSlack slab alignment must cover sparse terms");
241 static_assert(alignof(FieldElement) <= kPackedStorageAlignment,
242 "PackedWithSlack slab alignment must cover constants");
243 static_assert(std::is_same_v<decltype(&PackedWithSlack::storage_), PackedStorageOwner PackedWithSlack::*>,
244 "PackedWithSlack must keep its backing storage in one owning slab");
245
246 };
247
248 std::size_t n_gates = 0;
249 std::size_t n_commitments = 0;
250 std::size_t n_bits = 0;
251 std::vector<NativeBulletproofCircuitRow> wl;
252 std::vector<NativeBulletproofCircuitRow> wr;
253 std::vector<NativeBulletproofCircuitRow> wo;
254 std::vector<NativeBulletproofCircuitRow> wv;
255 std::vector<FieldElement> c;
256
258 NativeBulletproofCircuit(std::size_t gates, std::size_t commitments, std::size_t bits = 0);
259
261 void resize(std::size_t gates, std::size_t commitments, std::size_t bits = 0);
262
264 bool has_valid_shape() const;
265
267 std::size_t add_constraint(const FieldElement& constant = FieldElement::zero());
268
270 void add_left_term(std::size_t gate_idx, std::size_t constraint_idx, const FieldElement& scalar);
271
273 void add_right_term(std::size_t gate_idx, std::size_t constraint_idx, const FieldElement& scalar);
274
276 void add_output_term(std::size_t gate_idx, std::size_t constraint_idx, const FieldElement& scalar);
277
279 void add_commitment_term(std::size_t commitment_idx, std::size_t constraint_idx, const FieldElement& scalar);
280
282 bool evaluate(const BulletproofAssignmentData& assignment) const;
283
288
289private:
291 static void add_row_term(std::vector<NativeBulletproofCircuitRow>& rows, std::size_t expected_size,
292 std::size_t row_idx, std::size_t constraint_idx, const FieldElement& scalar);
293};
294
304 static constexpr unsigned char kSerializationVersion = 3;
305
306 std::vector<BulletproofPointBytes> commitments;
308
309 Result<Bytes> serialize() const;
310 static Result<ExperimentalBulletproofProof> deserialize(std::span<const unsigned char> bytes);
311};
312
343
352public:
354 [[nodiscard]] static NativeBulletproofCircuitTemplate from_parts(
356 Expr p1x,
357 Expr p2x,
358 Expr out);
359
362
364 Result<bool> final_evaluate(const BulletproofAssignmentData& assignment, const UInt512& pubkey) const;
365
368
371
380 Result<NativeBulletproofCircuit> instantiate_sum(std::span<const UInt512> public_keys) const;
381
390 std::span<const UInt512> public_keys,
391 std::span<const BulletproofAssignmentData> assignments) const;
392
393private:
395 Expr p1x_;
396 Expr p2x_;
397 Expr out_;
398};
399
408 const NativeBulletproofCircuit& circuit,
409 const BulletproofAssignmentData& assignment,
410 const BulletproofScalarBytes& nonce,
411 const BulletproofGeneratorBytes& value_generator,
412 purify_secp_context* secp_context,
413 std::span<const unsigned char> statement_binding = {},
414 std::span<const BulletproofScalarBytes> blinds = {},
415 ExperimentalBulletproofBackendCache* backend_cache = nullptr);
417 const NativeBulletproofCircuit::PackedWithSlack& circuit,
418 const BulletproofAssignmentData& assignment,
419 const BulletproofScalarBytes& nonce,
420 const BulletproofGeneratorBytes& value_generator,
421 purify_secp_context* secp_context,
422 std::span<const unsigned char> statement_binding = {},
423 std::span<const BulletproofScalarBytes> blinds = {},
424 ExperimentalBulletproofBackendCache* backend_cache = nullptr);
425
428 const NativeBulletproofCircuit& circuit,
429 const ExperimentalBulletproofProof& proof,
430 const BulletproofGeneratorBytes& value_generator,
431 purify_secp_context* secp_context,
432 std::span<const unsigned char> statement_binding = {},
433 ExperimentalBulletproofBackendCache* backend_cache = nullptr);
435 const NativeBulletproofCircuit::PackedWithSlack& circuit,
436 const ExperimentalBulletproofProof& proof,
437 const BulletproofGeneratorBytes& value_generator,
438 purify_secp_context* secp_context,
439 std::span<const unsigned char> statement_binding = {},
440 ExperimentalBulletproofBackendCache* backend_cache = nullptr);
441
444
449public:
452
454 bool replace_and_insert(Expr& expr, Symbol symbol);
455
457 void add_assignment(Symbol symbol, Expr expr);
458
466 Status from_transcript(const Transcript& transcript, std::size_t n_bits,
467 std::size_t minimum_gate_count = 1);
468
478
480 Status add_pubkey_and_out(const UInt512& pubkey, Expr p1x, Expr p2x, Expr out);
481
483 std::string to_string() const;
484
486 bool evaluate(const WitnessAssignments& vars, const FieldElement& commitment) const;
487
490
493
496
499
500private:
501 struct Assignment {
502 Symbol symbol;
503 Expr expr;
504 bool is_v;
505 };
506
507 static bool is_transcript_var(Symbol symbol);
508 static bool contains_transcript_var(const Expr& expr);
509 Result<BulletproofAssignmentData> assignment_data_impl(const WitnessAssignments& vars, const FieldElement* commitment) const;
510
511 std::vector<Assignment> assignments_;
512 std::vector<std::pair<Expr, Expr>> constraints_;
513 std::vector<std::optional<Symbol>> witness_to_a_;
514 std::vector<std::pair<std::uint32_t, Symbol>> witness_to_a_order_;
515 std::size_t n_witnesses_ = 0;
516 std::size_t n_muls_ = 0;
517 std::size_t n_commitments_ = 1;
518 std::size_t n_bits_ = 0;
519};
520
522Expr circuit_1bit(const std::array<FieldElement, 2>& values, Transcript& transcript, const Expr& x);
523
525Expr circuit_2bit(const std::array<FieldElement, 4>& values, Transcript& transcript, const Expr& x, const Expr& y);
526
528Expr circuit_3bit(const std::array<FieldElement, 8>& values, Transcript& transcript,
529 const Expr& x, const Expr& y, const Expr& z);
530
532using ExprPoint = std::pair<Expr, Expr>;
533
535ExprPoint circuit_1bit_point(const EllipticCurve& curve, const std::array<JacobianPoint, 2>& points,
536 Transcript& transcript, const Expr& b0);
537
539ExprPoint circuit_2bit_point(const EllipticCurve& curve, const std::array<JacobianPoint, 4>& points,
540 Transcript& transcript, const Expr& b0, const Expr& b1);
541
543ExprPoint circuit_3bit_point(const EllipticCurve& curve, const std::array<JacobianPoint, 8>& points,
544 Transcript& transcript, const Expr& b0, const Expr& b1, const Expr& b2);
545
547ExprPoint circuit_optionally_negate_ec(const ExprPoint& point, Transcript& transcript, const Expr& negate_bit);
548
550ExprPoint circuit_ec_add(Transcript& transcript, const ExprPoint& p1, const ExprPoint& p2);
551
553Expr circuit_ec_add_x(Transcript& transcript, const ExprPoint& p1, const ExprPoint& p2);
554
557 const JacobianPoint& point, const std::vector<Expr>& bits);
558
560Expr circuit_ec_multiply_x(const EllipticCurve& curve, Transcript& transcript,
561 const JacobianPoint& point, const std::vector<Expr>& bits);
562
564Expr circuit_combine(Transcript& transcript, const Expr& x1, const Expr& x2);
565
573
576 const std::optional<UInt256>& z1 = std::nullopt,
577 const std::optional<UInt256>& z2 = std::nullopt);
578
579} // namespace purify
Lowering helper that converts a symbolic transcript into native Bulletproof witness and circuit forms...
bool replace_and_insert(Expr &expr, Symbol symbol)
Detects simple witness aliases and records them for later assignment lowering.
Status from_transcript(const Transcript &transcript, std::size_t n_bits, std::size_t minimum_gate_count=1)
Imports a symbolic transcript with a fixed power-of-two gate floor.
Status bind_output_to_commitment(Expr output)
Binds a scalar expression to public commitment slot zero.
bool evaluate(const WitnessAssignments &vars, const FieldElement &commitment) const
Evaluates the lowered symbolic constraints with a concrete commitment value.
std::string to_string() const
Renders the lowered circuit in the legacy textual verifier format.
void add_assignment(Symbol symbol, Expr expr)
Adds one symbolic wire assignment to the lowering state.
void replace_expr_v_with_bp_var(Expr &expr)
Rewrites transcript variable names to their eventual Bulletproof wire aliases.
Status add_pubkey_and_out(const UInt512 &pubkey, Expr p1x, Expr p2x, Expr out)
Binds packed public-key coordinates and the output commitment into explicit constraints.
NativeBulletproofCircuit native_circuit() const
Builds the native sparse circuit object from the lowered assignments and constraints.
Result< BulletproofAssignmentData > assignment_data(const WitnessAssignments &vars) const
Materializes the witness columns expected by the native circuit representation.
Result< Bytes > serialize_assignment(const WitnessAssignments &vars) const
Serializes the derived witness assignment using the legacy blob format.
Minimal elliptic-curve arithmetic over the Purify base field.
Definition curve.hpp:46
ExperimentalBulletproofBackendCache(const ExperimentalBulletproofBackendCache &)=delete
ExperimentalBulletproofBackendCache & operator=(const ExperimentalBulletproofBackendCache &)=delete
ExperimentalBulletproofBackendCache & operator=(ExperimentalBulletproofBackendCache &&other) noexcept
purify_bulletproof_backend_resources * get_or_create(std::size_t n_gates, purify_secp_context *secp_context)
Returns cached backend resources for this gate count, creating them on first use.
Result< ExperimentalBulletproofBackendCache > clone_for_thread(std::size_t n_gates) const
Clones one warmed backend-resource entry for independent use on another thread.
ExperimentalBulletproofBackendCache(ExperimentalBulletproofBackendCache &&other) noexcept
Symbolic affine expression over indexed variables and field coefficients.
Definition expr.hpp:73
Field element modulo the backend scalar field used by this implementation.
Definition numeric.hpp:834
static FieldElement zero()
Returns the additive identity of the scalar field.
Definition numeric.cpp:32
Public-key-agnostic native verifier-circuit template.
Result< BulletproofAssignmentData > sum_assignments(std::span< const UInt512 > public_keys, std::span< const BulletproofAssignmentData > assignments) const
Validates and concatenates local assignments for instantiate_sum.
Result< NativeBulletproofCircuit::PackedWithSlack > instantiate_packed(const UInt512 &pubkey) const
Result< NativeBulletproofCircuit > instantiate(const UInt512 &pubkey) const
Result< bool > partial_evaluate(const BulletproofAssignmentData &assignment) const
Evaluates only the public-key-agnostic base circuit cached inside the template.
Result< Bytes > integrity_digest() const
Returns a stable digest of the packed base circuit plus late-bound expressions.
static NativeBulletproofCircuitTemplate from_parts(NativeBulletproofCircuit::PackedWithSlack base_packed, Expr p1x, Expr p2x, Expr out)
Builds a template from a lowered base circuit plus late-bound public expressions.
Result< bool > final_evaluate(const BulletproofAssignmentData &assignment, const UInt512 &pubkey) const
Evaluates only the late-bound public-key/output constraints against one assignment.
Result< NativeBulletproofCircuit > instantiate_sum(std::span< const UInt512 > public_keys) const
Builds one circuit binding the sum of distinct hosts' outputs to one commitment.
Resettable packed circuit representation backed by one aligned owning slab.
PackedWithSlack & operator=(const PackedWithSlack &other)
Result< NativeBulletproofCircuit > unpack() const
Materializes the packed circuit back into the ergonomic row-vector representation.
void reset() noexcept
Restores the packed circuit to its original base row sizes and constraint count.
NativeBulletproofCircuitRow::PackedWithSlack right_row(std::size_t gate_idx) const noexcept
Returns a read-only packed right-wire row view.
NativeBulletproofCircuitRow::PackedWithSlack left_row(std::size_t gate_idx) const noexcept
Returns a read-only packed left-wire row view.
NativeBulletproofCircuitRow::PackedWithSlack output_row(std::size_t gate_idx) const noexcept
Returns a read-only packed output-wire row view.
std::span< const FieldElement > constants() const noexcept
Returns the live constraint constants stored in the slab.
NativeBulletproofCircuitRow::PackedWithSlack commitment_row(std::size_t commitment_idx) const noexcept
Returns a read-only packed commitment row view.
static Result< PackedWithSlack > from_circuit(const NativeBulletproofCircuit &circuit, const PackedSlackPlan &slack)
Packs a native circuit into one aligned slab with caller-supplied row and constraint slack.
Mutable transcript used to record symbolic multiplication, division, and boolean constraints.
Definition expr.hpp:215
Elliptic-curve helpers, fixed parameters, and hash-to-curve utilities for Purify.
Symbolic expression and transcript machinery used to derive Purify circuits.
ExprPoint circuit_3bit_point(const EllipticCurve &curve, const std::array< JacobianPoint, 8 > &points, Transcript &transcript, const Expr &b0, const Expr &b1, const Expr &b2)
Selects between eight affine point constants using three boolean expression bits.
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.
BigUInt< 8 > UInt512
512-bit unsigned integer used for private and packed public keys.
Definition numeric.hpp:821
Result< NativeBulletproofCircuitTemplate > verifier_circuit_template(const Bytes &message)
Builds a reusable public-key-agnostic verifier-circuit template for a message.
Definition api.cpp:217
Expr circuit_combine(Transcript &transcript, const Expr &x1, const Expr &x2)
Builds the symbolic Purify output combiner over two x-coordinates.
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...
ExprPoint circuit_ec_add(Transcript &transcript, const ExprPoint &p1, const ExprPoint &p2)
Symbolically adds two affine elliptic-curve points.
std::array< unsigned char, 33 > BulletproofGeneratorBytes
Expr circuit_ec_add_x(Transcript &transcript, const ExprPoint &p1, const ExprPoint &p2)
Symbolically adds two affine points and returns only the resulting x-coordinate.
Expr circuit_ec_multiply_x(const EllipticCurve &curve, Transcript &transcript, const JacobianPoint &point, const std::vector< Expr > &bits)
Builds the symbolic x-coordinate multiplication gadget for one curve point.
Result< CircuitMainResult > circuit_main(Transcript &transcript, const JacobianPoint &m1, const JacobianPoint &m2, const std::optional< UInt256 > &z1=std::nullopt, const std::optional< UInt256 > &z2=std::nullopt)
Builds the full symbolic Purify circuit from message points and optional witness scalars.
Expected< T, Error > Result
Expected-returning convenience alias for Purify value-producing APIs.
Definition error.hpp:99
std::vector< WitnessAssignment, detail::SecureAllocator< WitnessAssignment > > WitnessAssignments
Definition expr.hpp:64
Expr circuit_1bit(const std::array< FieldElement, 2 > &values, Transcript &transcript, const Expr &x)
Selects one of two field constants using a single boolean expression bit.
std::pair< Expr, Expr > ExprPoint
Symbolic affine point represented as independent x and y expressions.
std::array< unsigned char, 33 > BulletproofPointBytes
Expected< void, Error > Status
Expected-returning convenience alias for Purify status-only APIs.
Definition error.hpp:102
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
ExprPoint circuit_ec_multiply_point(const EllipticCurve &curve, Transcript &transcript, const JacobianPoint &point, const std::vector< Expr > &bits)
Builds the symbolic affine-point multiplication gadget for one curve point.
Expr circuit_3bit(const std::array< FieldElement, 8 > &values, Transcript &transcript, const Expr &x, const Expr &y, const Expr &z)
Selects one of eight field constants using three boolean expression bits.
ExprPoint circuit_1bit_point(const EllipticCurve &curve, const std::array< JacobianPoint, 2 > &points, Transcript &transcript, const Expr &b0)
Selects between two affine point constants using one boolean expression bit.
ExprPoint circuit_optionally_negate_ec(const ExprPoint &point, Transcript &transcript, const Expr &negate_bit)
Conditionally negates an elliptic-curve point encoded as symbolic affine expressions.
std::vector< FieldElement, detail::SecureAllocator< FieldElement > > BulletproofWitnessColumn
ExprPoint circuit_2bit_point(const EllipticCurve &curve, const std::array< JacobianPoint, 4 > &points, Transcript &transcript, const Expr &b0, const Expr &b1)
Selects between four affine point constants using two boolean expression bits.
Expr circuit_2bit(const std::array< FieldElement, 4 > &values, Transcript &transcript, const Expr &x, const Expr &y)
Selects one of four field constants using two boolean expression bits.
struct purify_secp_context purify_secp_context
Caller-owned reusable secp256k1 context handle shared across Purify C and C++ APIs.
Columnar witness assignment compatible with the native Bulletproof circuit layout.
BulletproofWitnessColumn left
BulletproofWitnessColumn output
BulletproofWitnessColumn commitments
BulletproofWitnessColumn right
Result< Bytes > serialize() const
Serializes the witness columns in the legacy assignment blob format.
Result bundle returned by the main symbolic Purify circuit construction.
Experimental single-proof wrapper over the imported legacy Bulletproof circuit backend.
std::vector< BulletproofPointBytes > commitments
static constexpr unsigned char kSerializationVersion
static Result< ExperimentalBulletproofProof > deserialize(std::span< const unsigned char > bytes)
Jacobian point representation used for curve arithmetic.
Definition curve.hpp:17
Non-owning packed row view used by NativeBulletproofCircuit::PackedWithSlack.
const NativeBulletproofCircuitTerm * data
std::span< const NativeBulletproofCircuitTerm > entries_view() const noexcept
One sparse row of circuit coefficients.
void add(std::size_t idx, const FieldElement &scalar)
Appends a sparse coefficient to the row, skipping zero entries.
std::vector< NativeBulletproofCircuitTerm > entries
One sparse matrix entry in a native circuit row.
Native in-memory representation of a Bulletproof-style arithmetic circuit.
std::size_t add_constraint(const FieldElement &constant=FieldElement::zero())
Appends a new linear constraint constant term and returns its index.
std::vector< NativeBulletproofCircuitRow > wv
void resize(std::size_t gates, std::size_t commitments, std::size_t bits=0)
Reinitializes the circuit shape and clears all accumulated constraints.
bool evaluate(const BulletproofAssignmentData &assignment) const
Evaluates the circuit against a witness assignment and checks all gate and row equations.
std::vector< NativeBulletproofCircuitRow > wr
bool has_valid_shape() const
Checks declared dimensions and every sparse constraint index.
std::vector< NativeBulletproofCircuitRow > wl
void add_left_term(std::size_t gate_idx, std::size_t constraint_idx, const FieldElement &scalar)
Adds a coefficient to the left-wire matrix.
std::vector< NativeBulletproofCircuitRow > wo
Result< PackedWithSlack > pack_with_slack() const
Packs the circuit into one aligned slab with no additional row or constraint slack.
void add_right_term(std::size_t gate_idx, std::size_t constraint_idx, const FieldElement &scalar)
Adds a coefficient to the right-wire matrix.
void add_output_term(std::size_t gate_idx, std::size_t constraint_idx, const FieldElement &scalar)
Adds a coefficient to the output-wire matrix.
std::vector< FieldElement > c
void add_commitment_term(std::size_t commitment_idx, std::size_t constraint_idx, const FieldElement &scalar)
Adds a coefficient to the commitment matrix using the Bulletproof sign convention.
Compact symbolic variable identifier used inside expressions and transcripts.
Definition expr.hpp:35