35 std::vector<FieldElement, detail::SecureAllocator<FieldElement>>;
56 std::vector<NativeBulletproofCircuitTerm>
entries;
71 [[nodiscard]] std::span<const NativeBulletproofCircuitTerm>
entries_view() const noexcept {
72 return std::span<const NativeBulletproofCircuitTerm>(
data,
size);
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;
113 [[nodiscard]] std::size_t
n_gates() const noexcept {
118 return n_commitments_;
121 [[nodiscard]] std::size_t
n_bits() const noexcept {
126 return constraint_size_;
130 return constraint_capacity_;
136 void reset() noexcept;
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;
179 enum class RowFamily :
unsigned char {
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,
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);
207 struct PackedStorageDeleter {
208 void operator()(std::byte* storage)
const noexcept;
211 using PackedStorageOwner = std::unique_ptr<std::byte[], PackedStorageDeleter>;
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_;
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");
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;
261 void resize(std::size_t gates, std::size_t commitments, std::size_t bits = 0);
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);
324 [[nodiscard]] std::size_t
size() const noexcept;
341 std::unique_ptr<
Impl> impl_;
390 std::span<const UInt512> public_keys,
391 std::span<const BulletproofAssignmentData> assignments)
const;
413 std::span<const unsigned char> statement_binding = {},
414 std::span<const BulletproofScalarBytes> blinds = {},
417 const NativeBulletproofCircuit::PackedWithSlack& circuit,
418 const BulletproofAssignmentData& assignment,
422 std::span<const unsigned char> statement_binding = {},
423 std::span<const BulletproofScalarBytes> blinds = {},
428 const NativeBulletproofCircuit& circuit,
429 const ExperimentalBulletproofProof& proof,
432 std::span<const unsigned char> statement_binding = {},
435 const NativeBulletproofCircuit::PackedWithSlack& circuit,
436 const ExperimentalBulletproofProof& proof,
439 std::span<const unsigned char> statement_binding = {},
467 std::size_t minimum_gate_count = 1);
507 static bool is_transcript_var(
Symbol symbol);
508 static bool contains_transcript_var(
const Expr& expr);
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;
576 const std::optional<UInt256>& z1 = std::nullopt,
577 const std::optional<UInt256>& z2 = std::nullopt);
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.
ExperimentalBulletproofBackendCache()
ExperimentalBulletproofBackendCache(const ExperimentalBulletproofBackendCache &)=delete
ExperimentalBulletproofBackendCache & operator=(const ExperimentalBulletproofBackendCache &)=delete
~ExperimentalBulletproofBackendCache()
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
std::size_t size() const noexcept
Symbolic affine expression over indexed variables and field coefficients.
Field element modulo the backend scalar field used by this implementation.
static FieldElement zero()
Returns the additive identity of the scalar field.
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)
std::size_t constraint_capacity() const noexcept
std::size_t n_commitments() const noexcept
Result< NativeBulletproofCircuit > unpack() const
Materializes the packed circuit back into the ergonomic row-vector representation.
bool has_valid_shape() const noexcept
std::size_t n_gates() const noexcept
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.
std::size_t constraint_count() const noexcept
PackedWithSlack()=default
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.
std::size_t n_bits() const noexcept
Mutable transcript used to record symbolic multiplication, division, and boolean constraints.
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.
Result< NativeBulletproofCircuitTemplate > verifier_circuit_template(const Bytes &message)
Builds a reusable public-key-agnostic verifier-circuit template for a message.
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.
std::vector< WitnessAssignment, detail::SecureAllocator< WitnessAssignment > > WitnessAssignments
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.
std::array< unsigned char, 32 > BulletproofScalarBytes
std::vector< unsigned char > Bytes
Dynamically sized byte string used for messages, serialized witnesses, and proofs.
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
Result< Bytes > serialize() const
static Result< ExperimentalBulletproofProof > deserialize(std::span< const unsigned char > bytes)
Jacobian point representation used for curve arithmetic.
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.
std::vector< std::size_t > wl
std::vector< std::size_t > wr
std::vector< std::size_t > wv
std::size_t constraint_slack
std::vector< std::size_t > wo
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.
NativeBulletproofCircuit()=default
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
std::size_t n_commitments
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.