/root/bitcoin/src/primitives/transaction_identifier.h

Source
// Copyright (c) 2023-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or https://opensource.org/license/mit.

#ifndef BITCOIN_PRIMITIVES_TRANSACTION_IDENTIFIER_H
#define BITCOIN_PRIMITIVES_TRANSACTION_IDENTIFIER_H

#include <attributes.h>
#include <uint256.h>
#include <util/types.h>

#include <compare>
#include <cstddef>
#include <optional>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <variant>

/** transaction_identifier represents the two canonical transaction identifier
 * types (txid, wtxid).*/
template <bool has_witness>
class transaction_identifier
{
    uint256 m_wrapped;

    // Note: Use FromUint256 externally instead.
    transaction_identifier(const uint256& wrapped) : m_wrapped{wrapped} {}

    constexpr int Compare(const transaction_identifier<has_witness>& other) const { return m_wrapped.Compare(other.m_wrapped); }
    template <typename Other>
    constexpr int Compare(const Other& other) const
    {
        static_assert(ALWAYS_FALSE<Other>, "Forbidden comparison type");
        return 0;
    }

public:
    transaction_identifier() : m_wrapped{} {}
    consteval explicit transaction_identifier(std::string_view hex_str) : m_wrapped{uint256{hex_str}} {}

    template <typename Other>
    bool operator==(const Other& other) const { return Compare(other) == 0; }
    template <typename Other>
    std::strong_ordering operator<=>(const Other& other) const { return Compare(other) <=> 0; }

    const uint256& ToUint256() const LIFETIMEBOUND { return m_wrapped; }
    static transaction_identifier FromUint256(const uint256& id) { return {id}; }

    /** Wrapped `uint256` methods. */
    constexpr bool IsNull() const { return m_wrapped.IsNull(); }
    constexpr void SetNull() { m_wrapped.SetNull(); }
    static std::optional<transaction_identifier> FromHex(std::string_view hex)
    {
        auto u{uint256::FromHex(hex)};
        if (!u) return std::nullopt;
        return FromUint256(*u);
    }
    std::string GetHex() const { return m_wrapped.GetHex(); }
    std::string ToString() const { return m_wrapped.ToString(); }
    static constexpr auto size() { return decltype(m_wrapped)::size(); }
    constexpr const std::byte* data() const { return reinterpret_cast<const std::byte*>(m_wrapped.data()); }
    constexpr const std::byte* begin() const { return reinterpret_cast<const std::byte*>(m_wrapped.begin()); }
    constexpr const std::byte* end() const { return reinterpret_cast<const std::byte*>(m_wrapped.end()); }
    template <typename Stream> void Serialize(Stream& s) const { m_wrapped.Serialize(s); }
    template <typename Stream> void Unserialize(Stream& s) { m_wrapped.Unserialize(s); }
};

/** Txid commits to all transaction fields except the witness. */
using Txid = transaction_identifier<false>;
/** Wtxid commits to all transaction fields including the witness. */
using Wtxid = transaction_identifier<true>;

template <typename T>
concept TxidOrWtxid = std::is_same_v<T, Txid> || std::is_same_v<T, Wtxid>;

class GenTxid : public std::variant<Txid, Wtxid>
{
public:
    using variant::variant;

    bool IsWtxid() const { return std::holds_alternative<Wtxid>(*this); }

    const uint256& ToUint256() const LIFETIMEBOUND
    {
        return std::visit([](const auto& id) -> const uint256& { return id.ToUint256(); }, *this);
    }

    friend auto operator<=>(const GenTxid& a, const GenTxid& b)
    {
        // Use a reference for read-only access to the hash, avoiding a copy that might not be optimized away.
        return std::tuple<bool, const uint256&>(a.IsWtxid(), a.ToUint256()) <=> std::tuple<bool, const uint256&>(b.IsWtxid(), b.ToUint256());
    }
};

#endif // BITCOIN_PRIMITIVES_TRANSACTION_IDENTIFIER_H

Line	Count	Source
1		// Copyright (c) 2023-present The Bitcoin Core developers
2		// Distributed under the MIT software license, see the accompanying
3		// file COPYING or https://opensource.org/license/mit.
4
5		#ifndef BITCOIN_PRIMITIVES_TRANSACTION_IDENTIFIER_H
6		#define BITCOIN_PRIMITIVES_TRANSACTION_IDENTIFIER_H
7
8		#include <attributes.h>
9		#include <uint256.h>
10		#include <util/types.h>
11
12		#include <compare>
13		#include <cstddef>
14		#include <optional>
15		#include <string>
16		#include <string_view>
17		#include <tuple>
18		#include <type_traits>
19		#include <variant>
20
21		/** transaction_identifier represents the two canonical transaction identifier
22		* types (txid, wtxid).*/
23		template <bool has_witness>
24		class transaction_identifier
25		{
26		uint256 m_wrapped;
27
28		// Note: Use FromUint256 externally instead.
29	0	transaction_identifier(const uint256& wrapped) : m_wrapped{wrapped} {} Unexecuted instantiation: _ZN22transaction_identifierILb0EEC2ERK7uint256 Unexecuted instantiation: _ZN22transaction_identifierILb1EEC2ERK7uint256
30
31	0	constexpr int Compare(const transaction_identifier<has_witness>& other) const { return m_wrapped.Compare(other.m_wrapped); } Unexecuted instantiation: _ZNK22transaction_identifierILb0EE7CompareERKS0_ Unexecuted instantiation: _ZNK22transaction_identifierILb1EE7CompareERKS0_
32		template <typename Other>
33		constexpr int Compare(const Other& other) const
34		{
35		static_assert(ALWAYS_FALSE<Other>, "Forbidden comparison type");
36		return 0;
37		}
38
39		public:
40	0	transaction_identifier() : m_wrapped{} {} Unexecuted instantiation: _ZN22transaction_identifierILb0EEC2Ev Unexecuted instantiation: _ZN22transaction_identifierILb1EEC2Ev
41		consteval explicit transaction_identifier(std::string_view hex_str) : m_wrapped{uint256{hex_str}} {}
42
43		template <typename Other>
44	0	bool operator==(const Other& other) const { return Compare(other) == 0; } Unexecuted instantiation: _ZNK22transaction_identifierILb0EEeqIS0_EEbRKT_ Unexecuted instantiation: _ZNK22transaction_identifierILb1EEeqIS0_EEbRKT_
45		template <typename Other>
46	0	std::strong_ordering operator<=>(const Other& other) const { return Compare(other) <=> 0; } Unexecuted instantiation: _ZNK22transaction_identifierILb0EEssIS0_EESt15strong_orderingRKT_ Unexecuted instantiation: _ZNK22transaction_identifierILb1EEssIS0_EESt15strong_orderingRKT_
47
48	0	const uint256& ToUint256() const LIFETIMEBOUND { return m_wrapped; } Unexecuted instantiation: _ZNK22transaction_identifierILb0EE9ToUint256Ev Unexecuted instantiation: _ZNK22transaction_identifierILb1EE9ToUint256Ev
49	0	static transaction_identifier FromUint256(const uint256& id) { return {id}; } Unexecuted instantiation: _ZN22transaction_identifierILb0EE11FromUint256ERK7uint256 Unexecuted instantiation: _ZN22transaction_identifierILb1EE11FromUint256ERK7uint256
50
51		/** Wrapped `uint256` methods. */
52	0	constexpr bool IsNull() const { return m_wrapped.IsNull(); }
53	0	constexpr void SetNull() { m_wrapped.SetNull(); }
54		static std::optional<transaction_identifier> FromHex(std::string_view hex)
55	0	{
56	0	auto u{uint256::FromHex(hex)};
57	0	if (!u) return std::nullopt; Branch (57:13): [True: 0, False: 0] Branch (57:13): [True: 0, False: 0]
58	0	return FromUint256(*u);
59	0	} Unexecuted instantiation: _ZN22transaction_identifierILb0EE7FromHexESt17basic_string_viewIcSt11char_traitsIcEE Unexecuted instantiation: _ZN22transaction_identifierILb1EE7FromHexESt17basic_string_viewIcSt11char_traitsIcEE
60	0	std::string GetHex() const { return m_wrapped.GetHex(); } Unexecuted instantiation: _ZNK22transaction_identifierILb0EE6GetHexB5cxx11Ev Unexecuted instantiation: _ZNK22transaction_identifierILb1EE6GetHexB5cxx11Ev
61	0	std::string ToString() const { return m_wrapped.ToString(); } Unexecuted instantiation: _ZNK22transaction_identifierILb0EE8ToStringB5cxx11Ev Unexecuted instantiation: _ZNK22transaction_identifierILb1EE8ToStringB5cxx11Ev
62		static constexpr auto size() { return decltype(m_wrapped)::size(); }
63		constexpr const std::byte* data() const { return reinterpret_cast<const std::byte*>(m_wrapped.data()); }
64	0	constexpr const std::byte* begin() const { return reinterpret_cast<const std::byte*>(m_wrapped.begin()); } Unexecuted instantiation: _ZNK22transaction_identifierILb1EE5beginEv Unexecuted instantiation: _ZNK22transaction_identifierILb0EE5beginEv
65	0	constexpr const std::byte* end() const { return reinterpret_cast<const std::byte*>(m_wrapped.end()); }
66	0	template <typename Stream> void Serialize(Stream& s) const { m_wrapped.Serialize(s); } Unexecuted instantiation: _ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR12SizeComputer20TransactionSerParamsEEEvRT_ Unexecuted instantiation: _ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR12VectorWriter20TransactionSerParamsEEEvRT_ Unexecuted instantiation: _ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_ Unexecuted instantiation: _ZNK22transaction_identifierILb0EE9SerializeI10DataStreamEEvRT_ Unexecuted instantiation: _ZNK22transaction_identifierILb0EE9SerializeI12SizeComputerEEvRT_ Unexecuted instantiation: _ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIRS2_IR12VectorWriter20TransactionSerParamsES5_EEEvRT_ Unexecuted instantiation: _ZNK22transaction_identifierILb0EE9SerializeI12VectorWriterEEvRT_ Unexecuted instantiation: _ZNK22transaction_identifierILb0EE9SerializeI8AutoFileEEvRT_ Unexecuted instantiation: _ZNK22transaction_identifierILb0EE9SerializeI10HashWriterEEvRT_ Unexecuted instantiation: _ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR14BufferedWriterI8AutoFileE20TransactionSerParamsEEEvRT_ Unexecuted instantiation: _ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR8AutoFile20TransactionSerParamsEEEvRT_ Unexecuted instantiation: _ZNK22transaction_identifierILb1EE9SerializeI10HashWriterEEvRT_ Unexecuted instantiation: _ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_
67	0	template <typename Stream> void Unserialize(Stream& s) { m_wrapped.Unserialize(s); } Unexecuted instantiation: _ZN22transaction_identifierILb0EE11UnserializeI12ParamsStreamIR10SpanReader20TransactionSerParamsEEEvRT_ Unexecuted instantiation: _ZN22transaction_identifierILb0EE11UnserializeI10SpanReaderEEvRT_ Unexecuted instantiation: _ZN22transaction_identifierILb0EE11UnserializeI10DataStreamEEvRT_ Unexecuted instantiation: _ZN22transaction_identifierILb0EE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_ Unexecuted instantiation: _ZN22transaction_identifierILb0EE11UnserializeI12ParamsStreamIR8AutoFile20TransactionSerParamsEEEvRT_ Unexecuted instantiation: _ZN22transaction_identifierILb0EE11UnserializeI8AutoFileEEvRT_ Unexecuted instantiation: _ZN22transaction_identifierILb0EE11UnserializeI12ParamsStreamIR12BufferedFile20TransactionSerParamsEEEvRT_
68		};
69
70		/** Txid commits to all transaction fields except the witness. */
71		using Txid = transaction_identifier<false>;
72		/** Wtxid commits to all transaction fields including the witness. */
73		using Wtxid = transaction_identifier<true>;
74
75		template <typename T>
76		concept TxidOrWtxid = std::is_same_v<T, Txid> \|\| std::is_same_v<T, Wtxid>;
77
78		class GenTxid : public std::variant<Txid, Wtxid>
79		{
80		public:
81		using variant::variant;
82
83	0	bool IsWtxid() const { return std::holds_alternative<Wtxid>(*this); }
84
85		const uint256& ToUint256() const LIFETIMEBOUND
86	0	{
87	0	return std::visit([](const auto& id) -> const uint256& { return id.ToUint256(); }, *this); Unexecuted instantiation: _ZZNK7GenTxid9ToUint256EvENKUlRKT_E_clI22transaction_identifierILb0EEEERK7uint256S2_ Unexecuted instantiation: _ZZNK7GenTxid9ToUint256EvENKUlRKT_E_clI22transaction_identifierILb1EEEERK7uint256S2_
88	0	}
89
90		friend auto operator<=>(const GenTxid& a, const GenTxid& b)
91	0	{
92		// Use a reference for read-only access to the hash, avoiding a copy that might not be optimized away.
93	0	return std::tuple<bool, const uint256&>(a.IsWtxid(), a.ToUint256()) <=> std::tuple<bool, const uint256&>(b.IsWtxid(), b.ToUint256());
94	0	}
95		};
96
97		#endif // BITCOIN_PRIMITIVES_TRANSACTION_IDENTIFIER_H

Coverage Report

Created: 2026-06-18 19:06