bip352.h

Go to the documentation of this file.

// Copyright (c) 2023 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_COMMON_BIP352_H
#define BITCOIN_COMMON_BIP352_H
 
#include <addresstype.h>
#include <attributes.h>
#include <compat/byteswap.h>
#include <key.h>
#include <primitives/transaction.h>
#include <pubkey.h>
#include <uint256.h>
#include <util/expected.h>
 
#include <array>
#include <compare>
#include <cstdint>
#include <cstring>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <variant>
#include <vector>
 
struct secp256k1_silentpayments_label;
struct secp256k1_silentpayments_prevouts_summary;
struct secp256k1_pubkey;
class CChainParams;
class CScript;
class Coin;
 
namespace bip352 {
 
using PubKey = std::variant<CPubKey, XOnlyPubKey>;
 
class PrevoutsSummary
{
private:
    std::unique_ptr<secp256k1_silentpayments_prevouts_summary> m_prevouts_summary;
 
public:
    PrevoutsSummary(const secp256k1_silentpayments_prevouts_summary& prevouts_summary);
    PrevoutsSummary(PrevoutsSummary&&) noexcept;
    PrevoutsSummary& operator=(PrevoutsSummary&&) noexcept;
    ~PrevoutsSummary();
 
    // Delete copy constructors
    PrevoutsSummary(const PrevoutsSummary&) = delete;
    PrevoutsSummary& operator=(const PrevoutsSummary&) = delete;
 
    const secp256k1_silentpayments_prevouts_summary* Get() const LIFETIMEBOUND;
};
 
struct BIP352Comparator {
    bool operator()(const COutPoint& a, const COutPoint& b) const {
        // BIP352 defines the "smallest outpoint" based on a lexicographic
        // sort of the outpoints, using the 36-byte serialization:
        // <txid, 32-bytes little-endian>:<vout, 4-bytes little-endian>
        if (a.hash != b.hash) return a.hash < b.hash;
        return internal_bswap_32(a.n) < internal_bswap_32(b.n);
    }
};
 
struct SilentPaymentsDestination
{
private:
    uint8_t m_version;
    CPubKey m_scan_pubkey;
    CPubKey m_spend_pubkey;
    std::vector<unsigned char> m_extension_data;
 
    SilentPaymentsDestination(
        uint8_t version,
        const CPubKey& scan_pubkey,
        const CPubKey& spend_pubkey,
        std::span<const unsigned char> extension_data = {}
    ) : m_version(version), m_scan_pubkey(scan_pubkey),
        m_spend_pubkey(spend_pubkey),
        m_extension_data(extension_data.begin(), extension_data.end()) {};
public:
    static std::optional<SilentPaymentsDestination> From(
        const CPubKey& scan_pubkey,
        const CPubKey& spend_pubkey,
        uint8_t version = 0,
        std::span<const unsigned char> extension_data = {}
    );
 
    uint8_t GetVersion() const { return m_version; }
    const CPubKey& GetScanPubKey() const { return m_scan_pubkey; }
    const CPubKey& GetSpendPubKey() const { return m_spend_pubkey; }
    std::span<const unsigned char> GetExtensionData() const { return m_extension_data; }
 
    bool operator==(const SilentPaymentsDestination&) const = default;
};
 
util::Expected<SilentPaymentsDestination, std::string> DecodeSilentPaymentsAddress(
    const std::string& str, const CChainParams& params);
 
class SilentPaymentsLabel {
private:
    std::unique_ptr<secp256k1_silentpayments_label> m_label;
    unsigned char m_vch[CPubKey::COMPRESSED_SIZE];
 
    static std::optional<SilentPaymentsLabel> FromBytes(std::span<const unsigned char, CPubKey::COMPRESSED_SIZE> vch);
 
public:
    SilentPaymentsLabel(const secp256k1_silentpayments_label& label);
 
    SilentPaymentsLabel(SilentPaymentsLabel&&) noexcept;
    SilentPaymentsLabel& operator=(SilentPaymentsLabel&&) noexcept;
    SilentPaymentsLabel(const SilentPaymentsLabel&);
    SilentPaymentsLabel& operator=(const SilentPaymentsLabel&);
 
    ~SilentPaymentsLabel();
 
    friend bool operator==(const SilentPaymentsLabel& a, const SilentPaymentsLabel& b) {
        return memcmp(a.m_vch,  b.m_vch, CPubKey::COMPRESSED_SIZE) == 0;
    }
    friend bool operator<(const SilentPaymentsLabel& a, const SilentPaymentsLabel& b) {
        return memcmp(a.m_vch,  b.m_vch, CPubKey::COMPRESSED_SIZE) < 0;
    }
    friend bool operator>(const SilentPaymentsLabel& a, const SilentPaymentsLabel& b) {
        return b < a;
    }
    friend bool operator<(const SilentPaymentsLabel& a, std::span<const unsigned char, CPubKey::COMPRESSED_SIZE> b) {
        return memcmp(a.m_vch, b.data(), CPubKey::COMPRESSED_SIZE) < 0;
    }
    friend bool operator<(std::span<const unsigned char, CPubKey::COMPRESSED_SIZE> a, const SilentPaymentsLabel& b) {
        return memcmp(a.data(), b.m_vch, CPubKey::COMPRESSED_SIZE) < 0;
    }
 
    template <typename Stream>
    void Serialize(Stream& s) const
    {
        s << std::span{m_vch, CPubKey::COMPRESSED_SIZE};
    }
 
    template <typename Stream>
    static std::optional<SilentPaymentsLabel> Unserialize(Stream& s)
    {
        std::array<unsigned char, CPubKey::COMPRESSED_SIZE> vch;
        s >> std::span{vch};
        return FromBytes(std::span{vch});
    }
 
    const secp256k1_silentpayments_label* Get() const LIFETIMEBOUND;
};
 
struct SilentPaymentsOutput {
    XOnlyPubKey output;
    uint256 tweak;
    std::optional<SilentPaymentsLabel> label;
};
 
std::optional<PubKey> GetPubKeyFromInput(const CTxIn& txin, const CScript& spk);
 
std::optional<std::map<size_t, WitnessV1Taproot>> GenerateSilentPaymentsTaprootDestinations(const std::map<size_t, SilentPaymentsDestination>& sp_dests, const std::vector<CKey>& plain_keys, const std::vector<KeyPair>& taproot_keys, const COutPoint& smallest_outpoint);
 
enum class PrevoutsSummaryError {
    MISSING_COIN,
    NOT_ELIGIBLE,
};
 
util::Expected<PrevoutsSummary, PrevoutsSummaryError> GetSilentPaymentsPrevoutsSummary(const std::vector<CTxIn>& vin, const std::map<COutPoint, Coin>& coins);
 
using LabelTweakMap = std::map<SilentPaymentsLabel, uint256, std::less<>>;
 
class SilentPaymentsReceiver {
private:
    CKey m_scan_key;
    CPubKey m_spend_pubkey;
    std::unique_ptr<secp256k1_pubkey> m_spend_pubkey_obj;
    LabelTweakMap m_labels;
    LabelTweakMap::const_iterator m_change_it;
 
    SilentPaymentsDestination BuildLabeledDestination(const SilentPaymentsLabel& label) const;
 
public:
    SilentPaymentsReceiver(const CKey& scan_key, const CPubKey& spend_pubkey, const LabelTweakMap& labels = {});
    ~SilentPaymentsReceiver();
 
    // Default move would leave m_scan_key and m_labels empty while
    // m_spend_pubkey remains fully populated, leaving the
    // SilentPaymentsReceiver object in an inconsistent state.
    SilentPaymentsReceiver(SilentPaymentsReceiver&&) = delete;
    SilentPaymentsReceiver& operator=(SilentPaymentsReceiver&&) = delete;
 
    SilentPaymentsReceiver(const SilentPaymentsReceiver&) = delete;
    SilentPaymentsReceiver& operator=(const SilentPaymentsReceiver&) = delete;
 
    const LabelTweakMap& GetLabels() const;
 
    SilentPaymentsDestination GenerateLabeledAddress(uint32_t m);
 
    SilentPaymentsDestination GetChangeDestination() const;
 
    std::optional<std::vector<SilentPaymentsOutput>> Scan(const PrevoutsSummary& prevouts_summary, const std::vector<XOnlyPubKey>& tx_outputs) const;
};
}; // namespace bip352
#endif // BITCOIN_COMMON_BIP352_H