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 <cstdint>
#include <span>
#include <utility>
 
#include "purify/api.hpp"
#include "purify/bppp.hpp"
 
namespace purify::puresign_plusplus {
 
using Scalar32 = std::array<unsigned char, 32>;
using XOnly32 = std::array<unsigned char, 32>;
using Signature64 = std::array<unsigned char, 64>;
 
struct MessageProofCache;
struct TopicProofCache;
struct Signature;
class PreparedNonce;
 
struct NonceProof;
struct ProvenSignature;
 
struct PublicKey {
    static constexpr std::size_t kSerializedSize = 96;
 
    UInt512 purify_pubkey;
    XOnly32 bip340_pubkey{};
 
    [[nodiscard]] Bytes serialize() const;
 
    [[nodiscard]] static Result<PublicKey> deserialize(std::span<const unsigned char> serialized,
                                                       purify_secp_context* secp_context);
 
    [[nodiscard]] static Result<PublicKey> from_secret(const SecretKey& secret,
                                                       purify_secp_context* secp_context);
 
    [[nodiscard]] Result<bool> verify_signature(std::span<const unsigned char> message,
                                                const Signature& signature,
                                                purify_secp_context* secp_context) const;
 
    [[nodiscard]] Result<bool> verify_message_nonce_proof(
        std::span<const unsigned char> message,
        const NonceProof& nonce_proof,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<bool> verify_message_nonce_proof(
        const MessageProofCache& cache,
        const NonceProof& nonce_proof,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<bool> verify_topic_nonce_proof(
        std::span<const unsigned char> topic,
        const NonceProof& nonce_proof,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<bool> verify_topic_nonce_proof(
        const TopicProofCache& cache,
        const NonceProof& nonce_proof,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<bool> verify_message_signature_with_proof(
        std::span<const unsigned char> message,
        const ProvenSignature& signature,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<bool> verify_message_signature_with_proof(
        const MessageProofCache& cache,
        const ProvenSignature& signature,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<bool> verify_topic_signature_with_proof(
        std::span<const unsigned char> message,
        std::span<const unsigned char> topic,
        const ProvenSignature& signature,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<bool> verify_topic_signature_with_proof(
        const TopicProofCache& cache,
        std::span<const unsigned char> message,
        const ProvenSignature& signature,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
};
 
struct Nonce {
    static constexpr std::size_t kSerializedSize = 32;
 
    XOnly32 xonly{};
 
    [[nodiscard]] Bytes serialize() const;
    [[nodiscard]] static Result<Nonce> deserialize(std::span<const unsigned char> serialized,
                                                   purify_secp_context* secp_context);
};
 
struct Signature {
    static constexpr std::size_t kSerializedSize = 64;
 
    Signature64 bytes{};
 
    [[nodiscard]] Nonce nonce() const;
    [[nodiscard]] Scalar32 s() const;
    [[nodiscard]] Bytes serialize() const;
    [[nodiscard]] static Result<Signature> deserialize(std::span<const unsigned char> serialized,
                                                       purify_secp_context* secp_context);
};
 
struct MessageProofCache {
    Bytes message;
    Bytes eval_input;
    NativeBulletproofCircuitTemplate circuit_template;
    Bytes template_digest;
    mutable bppp::ExperimentalCircuitCache backend_cache;
 
    [[nodiscard]] static Result<MessageProofCache> build(std::span<const unsigned char> message);
};
 
struct TopicProofCache {
    Bytes topic;
    Bytes eval_input;
    NativeBulletproofCircuitTemplate circuit_template;
    Bytes template_digest;
    mutable bppp::ExperimentalCircuitCache backend_cache;
 
    [[nodiscard]] static Result<TopicProofCache> build(std::span<const unsigned char> topic);
};
 
struct NonceProof {
    static constexpr unsigned char kSerializationVersion = 1;
 
    Nonce nonce;
    bppp::PointBytes commitment_point{};
    bppp::ExperimentalCircuitZkNormArgProof proof;
 
    [[nodiscard]] Result<Bytes> serialize(purify_secp_context* secp_context) const;
    [[nodiscard]] static Result<NonceProof> deserialize(std::span<const unsigned char> serialized,
                                                        purify_secp_context* secp_context);
};
 
struct ProvenSignature {
    static constexpr unsigned char kSerializationVersion = 1;
 
    Signature signature;
    NonceProof nonce_proof;
 
    [[nodiscard]] Result<Bytes> serialize(purify_secp_context* secp_context) const;
    [[nodiscard]] static Result<ProvenSignature> deserialize(std::span<const unsigned char> serialized,
                                                             purify_secp_context* secp_context);
};
 
class PreparedNonce {
public:
    enum class Scope : std::uint8_t {
        Message,
        Topic,
    };
 
    PreparedNonce(const PreparedNonce&) = delete;
    PreparedNonce& operator=(const PreparedNonce&) = delete;
 
    PreparedNonce(PreparedNonce&& other) noexcept;
    PreparedNonce& operator=(PreparedNonce&& other) noexcept;
    ~PreparedNonce();
 
    [[nodiscard]] const Nonce& public_nonce() const noexcept {
        return nonce_;
    }
 
    [[nodiscard]] Scalar32 scalar() const {
        return scalar_;
    }
 
    [[nodiscard]] static PreparedNonce from_parts(Scope scope, const Scalar32& scalar, const Nonce& nonce,
                                                  const XOnly32& signer_pubkey, const XOnly32& binding_digest);
 
    [[nodiscard]] Result<Signature> sign_message(const Bip340Key& signer,
                                                 std::span<const unsigned char> message,
                                                 purify_secp_context* secp_context) &&;
 
    [[nodiscard]] Result<Signature> sign_topic_message(const Bip340Key& signer,
                                                       std::span<const unsigned char> message,
                                                       purify_secp_context* secp_context) &&;
 
private:
    PreparedNonce(Scope scope, const Scalar32& scalar, const Nonce& nonce,
                  const XOnly32& signer_pubkey, const XOnly32& binding_digest);
 
    void clear() noexcept;
 
    Scope scope_{Scope::Message};
    Scalar32 scalar_{};
    Nonce nonce_{};
    XOnly32 signer_pubkey_{};
    XOnly32 binding_digest_{};
};
 
class PreparedNonceWithProof {
public:
    PreparedNonceWithProof(const PreparedNonceWithProof&) = delete;
    PreparedNonceWithProof& operator=(const PreparedNonceWithProof&) = delete;
 
    PreparedNonceWithProof(PreparedNonceWithProof&& other) noexcept = default;
    PreparedNonceWithProof& operator=(PreparedNonceWithProof&& other) noexcept = default;
    ~PreparedNonceWithProof() = default;
 
    [[nodiscard]] const Nonce& public_nonce() const noexcept {
        return prepared_.public_nonce();
    }
 
    [[nodiscard]] const NonceProof& proof() const noexcept {
        return proof_;
    }
 
    [[nodiscard]] Scalar32 scalar() const {
        return prepared_.scalar();
    }
 
    [[nodiscard]] static PreparedNonceWithProof from_parts(PreparedNonce prepared, NonceProof proof);
 
    [[nodiscard]] Result<ProvenSignature> sign_message(const SecretKey& secret,
                                                       std::span<const unsigned char> message,
                                                       purify_secp_context* secp_context) &&;
 
    [[nodiscard]] Result<ProvenSignature> sign_topic_message(const SecretKey& secret,
                                                             std::span<const unsigned char> message,
                                                             purify_secp_context* secp_context) &&;
 
private:
    PreparedNonceWithProof(PreparedNonce prepared, NonceProof proof)
        : prepared_(std::move(prepared)), proof_(std::move(proof)) {}
 
    PreparedNonce prepared_;
    NonceProof proof_;
};
 
class KeyPair {
public:
    KeyPair(const KeyPair&) = delete;
    KeyPair& operator=(const KeyPair&) = delete;
    KeyPair(KeyPair&& other) noexcept = default;
    KeyPair& operator=(KeyPair&& other) noexcept = default;
    ~KeyPair() = default;
 
    [[nodiscard]] static Result<KeyPair> from_secret(const SecretKey& secret,
                                                     purify_secp_context* secp_context);
 
    [[nodiscard]] static Result<KeyPair> from_secret(SecretKey&& secret,
                                                     purify_secp_context* secp_context);
 
    [[nodiscard]] const PublicKey& public_key() const noexcept {
        return public_key_;
    }
 
    [[nodiscard]] Result<PreparedNonce> prepare_message_nonce(std::span<const unsigned char> message,
                                                              purify_secp_context* secp_context) const;
 
    [[nodiscard]] Result<PreparedNonceWithProof> prepare_message_nonce_with_proof(
        std::span<const unsigned char> message,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<PreparedNonceWithProof> prepare_message_nonce_with_proof(
        const MessageProofCache& cache,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<PreparedNonce> prepare_topic_nonce(std::span<const unsigned char> topic,
                                                            purify_secp_context* secp_context) const;
 
    [[nodiscard]] Result<PreparedNonceWithProof> prepare_topic_nonce_with_proof(
        std::span<const unsigned char> topic,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<PreparedNonceWithProof> prepare_topic_nonce_with_proof(
        const TopicProofCache& cache,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<Signature> sign_message(std::span<const unsigned char> message,
                                                 purify_secp_context* secp_context) const;
 
    [[nodiscard]] Result<Signature> sign_message_with_prepared(std::span<const unsigned char> message,
                                                               PreparedNonce&& prepared,
                                                               purify_secp_context* secp_context) const;
 
    [[nodiscard]] Result<ProvenSignature> sign_message_with_prepared_proof(
        std::span<const unsigned char> message,
        PreparedNonceWithProof&& prepared,
        purify_secp_context* secp_context) const;
 
    [[nodiscard]] Result<Signature> sign_with_topic(std::span<const unsigned char> message,
                                                    std::span<const unsigned char> topic,
                                                    purify_secp_context* secp_context) const;
    [[nodiscard]] Result<Signature> sign_with_prepared_topic(std::span<const unsigned char> message,
                                                             PreparedNonce&& prepared,
                                                             purify_secp_context* secp_context) const;
 
    [[nodiscard]] Result<ProvenSignature> sign_with_prepared_topic_proof(
        std::span<const unsigned char> message,
        PreparedNonceWithProof&& prepared,
        purify_secp_context* secp_context) const;
 
    [[nodiscard]] Result<ProvenSignature> sign_message_with_proof(
        std::span<const unsigned char> message,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<ProvenSignature> sign_message_with_proof(
        const MessageProofCache& cache,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<ProvenSignature> sign_with_topic_proof(
        std::span<const unsigned char> message,
        std::span<const unsigned char> topic,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
    [[nodiscard]] Result<ProvenSignature> sign_with_topic_proof(
        std::span<const unsigned char> message,
        const TopicProofCache& cache,
        purify_secp_context* secp_context,
        bppp::ExperimentalCircuitBackend* circuit_cache = nullptr) const;
 
private:
    KeyPair(SecretKey secret, PublicKey public_key)
        : secret_(std::move(secret)), public_key_(std::move(public_key)) {}
 
    SecretKey secret_;
    PublicKey public_key_{};
};
 
}  // namespace purify::puresign_plusplus