bppp.hpp

Go to the documentation of this file.

// Copyright (c) 2026 Judica, Inc.
// Distributed under the MIT software license, see the accompanying
// file COPYING or https://opensource.org/license/mit/.
 
#pragma once
 
#include <array>
#include <cstddef>
#include <memory>
#include <span>
#include <utility>
#include <vector>
 
#include "purify/api.hpp"
 
struct purify_bppp_backend_resources;
 
namespace purify::bppp {
 
namespace detail {
struct ExperimentalCircuitBackendAccess;
}
 
using ScalarBytes = std::array<unsigned char, 32>;
using PointBytes = std::array<unsigned char, 33>;
using GeneratorBytes = std::array<unsigned char, 33>;
 
GeneratorBytes base_generator(purify_secp_context* secp_context);
GeneratorBytes value_generator_h(purify_secp_context* secp_context);
Result<std::vector<PointBytes>> create_generators(std::size_t count, purify_secp_context* secp_context);
 
Result<PointBytes> pedersen_commit_char(const ScalarBytes& blind,
                                        const ScalarBytes& value,
                                        purify_secp_context* secp_context);
 
Result<PointBytes> pedersen_commit_char(const ScalarBytes& blind,
                                        const ScalarBytes& value,
                                        purify_secp_context* secp_context,
                                        const GeneratorBytes& value_gen,
                                        const GeneratorBytes& blind_gen);
 
inline ScalarBytes scalar_bytes(const FieldElement& value) {
    return value.to_bytes_be();
}
 
inline std::vector<ScalarBytes> scalar_bytes(const std::vector<FieldElement>& values) {
    std::vector<ScalarBytes> out;
    out.reserve(values.size());
    for (const FieldElement& value : values) {
        out.push_back(scalar_bytes(value));
    }
    return out;
}
 
struct NormArgInputs {
    ScalarBytes rho{};
    std::vector<PointBytes> generators;
    std::vector<ScalarBytes> n_vec;
    std::vector<ScalarBytes> l_vec;
    std::vector<ScalarBytes> c_vec;
};
 
Result<PointBytes> commit_norm_arg(const NormArgInputs& inputs, purify_secp_context* secp_context);
 
struct NormArgProof {
    ScalarBytes rho{};
    std::vector<PointBytes> generators;
    std::vector<ScalarBytes> c_vec;
    std::size_t n_vec_len = 0;
    PointBytes commitment{};
    Bytes proof;
};
 
class ExperimentalCircuitBackend {
public:
    ExperimentalCircuitBackend(const ExperimentalCircuitBackend&) = delete;
    ExperimentalCircuitBackend& operator=(const ExperimentalCircuitBackend&) = delete;
    ExperimentalCircuitBackend(ExperimentalCircuitBackend&&) noexcept = default;
    ExperimentalCircuitBackend& operator=(ExperimentalCircuitBackend&&) noexcept = default;
    virtual ~ExperimentalCircuitBackend();
 
protected:
    ExperimentalCircuitBackend() = default;
 
private:
    friend struct detail::ExperimentalCircuitBackendAccess;
 
    [[nodiscard]] virtual std::shared_ptr<const void> find_public_data_impl(
        const std::array<unsigned char, 32>& key) const = 0;
    virtual void insert_public_data_impl(std::array<unsigned char, 32> key,
                                         std::shared_ptr<const void> value) = 0;
    [[nodiscard]] virtual purify_bppp_backend_resources* get_or_create_backend_resources_impl(
        std::span<const PointBytes> generators,
        purify_secp_context* secp_context) = 0;
};
 
namespace detail {
struct ExperimentalCircuitBackendAccess {
    [[nodiscard]] static std::shared_ptr<const void> find_public_data(
        const ExperimentalCircuitBackend* backend,
        const std::array<unsigned char, 32>& key);
    static void insert_public_data(ExperimentalCircuitBackend* backend,
                                   std::array<unsigned char, 32> key,
                                   std::shared_ptr<const void> value);
    [[nodiscard]] static purify_bppp_backend_resources* get_or_create_backend_resources(
        ExperimentalCircuitBackend* backend,
        std::span<const PointBytes> generators,
        purify_secp_context* secp_context);
};
}  // namespace detail
 
class ExperimentalCircuitCacheLine final : public ExperimentalCircuitBackend {
public:
    ExperimentalCircuitCacheLine();
    ExperimentalCircuitCacheLine(const ExperimentalCircuitCacheLine&) = delete;
    ExperimentalCircuitCacheLine& operator=(const ExperimentalCircuitCacheLine&) = delete;
    ExperimentalCircuitCacheLine(ExperimentalCircuitCacheLine&& other) noexcept;
    ExperimentalCircuitCacheLine& operator=(ExperimentalCircuitCacheLine&& other) noexcept;
    ~ExperimentalCircuitCacheLine() override;
 
    [[nodiscard]] bool empty() const noexcept;
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
 
    [[nodiscard]] std::shared_ptr<const void> find_public_data_impl(
        const std::array<unsigned char, 32>& key) const override;
    void insert_public_data_impl(std::array<unsigned char, 32> key,
                                 std::shared_ptr<const void> value) override;
    [[nodiscard]] purify_bppp_backend_resources* get_or_create_backend_resources_impl(
        std::span<const PointBytes> generators,
        purify_secp_context* secp_context) override;
 
    friend class ExperimentalCircuitCache;
};
 
class ExperimentalCircuitCache final : public ExperimentalCircuitBackend {
public:
    ExperimentalCircuitCache();
    ExperimentalCircuitCache(const ExperimentalCircuitCache&) = delete;
    ExperimentalCircuitCache& operator=(const ExperimentalCircuitCache&) = delete;
    ExperimentalCircuitCache(ExperimentalCircuitCache&& other) noexcept;
    ExperimentalCircuitCache& operator=(ExperimentalCircuitCache&& other) noexcept;
    ~ExperimentalCircuitCache();
 
    void clear();
    [[nodiscard]] std::size_t size() const noexcept;
    [[nodiscard]] Result<ExperimentalCircuitCacheLine> clone_line_for_thread(
        std::span<const PointBytes> generators) const;
    [[nodiscard]] std::shared_ptr<const void> find_public_data(const std::array<unsigned char, 32>& key) const;
    void insert_public_data(std::array<unsigned char, 32> key, std::shared_ptr<const void> value);
    [[nodiscard]] purify_bppp_backend_resources* get_or_create_backend_resources(
        std::span<const PointBytes> generators,
        purify_secp_context* secp_context);
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
 
    [[nodiscard]] std::shared_ptr<const void> find_public_data_impl(
        const std::array<unsigned char, 32>& key) const override;
    void insert_public_data_impl(std::array<unsigned char, 32> key,
                                 std::shared_ptr<const void> value) override;
    [[nodiscard]] purify_bppp_backend_resources* get_or_create_backend_resources_impl(
        std::span<const PointBytes> generators,
        purify_secp_context* secp_context) override;
};
 
Result<NormArgProof> prove_norm_arg(const NormArgInputs& inputs, purify_secp_context* secp_context);
Result<NormArgProof> prove_norm_arg(NormArgInputs&& inputs, purify_secp_context* secp_context);
Result<NormArgProof> prove_norm_arg_to_commitment(const NormArgInputs& inputs,
                                                  const PointBytes& commitment,
                                                  purify_secp_context* secp_context);
bool verify_norm_arg(const NormArgProof& proof, purify_secp_context* secp_context);
 
struct ExperimentalCircuitNormArgProof {
    PointBytes witness_commitment{};
    Bytes proof;
};
 
struct ExperimentalCircuitZkNormArgProof {
    PointBytes a_commitment{};
    PointBytes s_commitment{};
    ScalarBytes t2{};
    Bytes proof;
};
 
Result<PointBytes> commit_experimental_circuit_witness(
    const NativeBulletproofCircuit& circuit,
    const BulletproofAssignmentData& assignment,
    purify_secp_context* secp_context,
    std::span<const unsigned char> statement_binding = {},
    ExperimentalCircuitBackend* cache = nullptr);
 
Result<ExperimentalCircuitNormArgProof> prove_experimental_circuit_norm_arg(
    const NativeBulletproofCircuit& circuit,
    const BulletproofAssignmentData& assignment,
    purify_secp_context* secp_context,
    std::span<const unsigned char> statement_binding = {},
    ExperimentalCircuitBackend* cache = nullptr);
 
Result<ExperimentalCircuitNormArgProof> prove_experimental_circuit_norm_arg_to_commitment(
    const NativeBulletproofCircuit& circuit,
    const BulletproofAssignmentData& assignment,
    const PointBytes& witness_commitment,
    purify_secp_context* secp_context,
    std::span<const unsigned char> statement_binding = {},
    ExperimentalCircuitBackend* cache = nullptr);
 
Result<bool> verify_experimental_circuit_norm_arg(
    const NativeBulletproofCircuit& circuit,
    const ExperimentalCircuitNormArgProof& proof,
    purify_secp_context* secp_context,
    std::span<const unsigned char> statement_binding = {},
    ExperimentalCircuitBackend* cache = nullptr);
 
Result<ExperimentalCircuitZkNormArgProof> prove_experimental_circuit_zk_norm_arg(
    const NativeBulletproofCircuit& circuit,
    const BulletproofAssignmentData& assignment,
    const ScalarBytes& nonce,
    purify_secp_context* secp_context,
    std::span<const unsigned char> statement_binding = {},
    ExperimentalCircuitBackend* cache = nullptr);
 
Result<bool> verify_experimental_circuit_zk_norm_arg(
    const NativeBulletproofCircuit& circuit,
    const ExperimentalCircuitZkNormArgProof& proof,
    purify_secp_context* secp_context,
    std::span<const unsigned char> statement_binding = {},
    ExperimentalCircuitBackend* cache = nullptr);
 
Result<ExperimentalCircuitZkNormArgProof> prove_experimental_circuit_zk_norm_arg_with_public_commitments(
    const NativeBulletproofCircuit& circuit,
    const BulletproofAssignmentData& assignment,
    const ScalarBytes& nonce,
    std::span<const PointBytes> public_commitments,
    purify_secp_context* secp_context,
    std::span<const unsigned char> statement_binding = {},
    ExperimentalCircuitBackend* cache = nullptr);
 
Result<bool> verify_experimental_circuit_zk_norm_arg_with_public_commitments(
    const NativeBulletproofCircuit& circuit,
    const ExperimentalCircuitZkNormArgProof& proof,
    std::span<const PointBytes> public_commitments,
    purify_secp_context* secp_context,
    std::span<const unsigned char> statement_binding = {},
    ExperimentalCircuitBackend* cache = nullptr);
 
struct CommittedPurifyWitness {
    UInt512 public_key;
    FieldElement output;
    BulletproofAssignmentData assignment;
    PointBytes commitment;
};
 
Result<CommittedPurifyWitness> commit_output_witness(const Bytes& message, const SecretKey& secret,
                                                     const ScalarBytes& blind,
                                                     purify_secp_context* secp_context);
 
Result<CommittedPurifyWitness> commit_output_witness(const Bytes& message,
                                                     const SecretKey& secret,
                                                     const ScalarBytes& blind,
                                                     purify_secp_context* secp_context,
                                                     const GeneratorBytes& value_gen,
                                                     const GeneratorBytes& blind_gen);
 
}  // namespace purify::bppp