/root/bitcoin/src/uint256.h

Source
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-present 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_UINT256_H
#define BITCOIN_UINT256_H

#include <crypto/common.h>
#include <span.h>
#include <util/strencodings.h>
#include <util/string.h>

#include <algorithm>
#include <array>
#include <cassert>
#include <cstdint>
#include <cstring>
#include <optional>
#include <string>
#include <string_view>

/** Template base class for fixed-sized opaque blobs. */
template<unsigned int BITS>
class base_blob
{
protected:
    static constexpr int WIDTH = BITS / 8;
    static_assert(BITS % 8 == 0, "base_blob currently only supports whole bytes.");
    std::array<uint8_t, WIDTH> m_data;
    static_assert(WIDTH == sizeof(m_data), "Sanity check");

public:
    /* construct 0 value by default */
    constexpr base_blob() : m_data() {}

    /* constructor for constants between 1 and 255 */
    constexpr explicit base_blob(uint8_t v) : m_data{v} {}

    constexpr explicit base_blob(std::span<const unsigned char> vch)
    {
        assert(vch.size() == WIDTH);
        std::copy(vch.begin(), vch.end(), m_data.begin());
    }

    consteval explicit base_blob(std::string_view hex_str);

    constexpr bool IsNull() const
    {
        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
            return val == 0;
        });
    }

    constexpr void SetNull()
    {
        std::fill(m_data.begin(), m_data.end(), 0);
    }

    /** Lexicographic ordering
     * @note Does NOT match the ordering on the corresponding \ref
     *       base_uint::CompareTo, which starts comparing from the end.
     */
    constexpr int Compare(const base_blob& other) const { return std::memcmp(m_data.data(), other.m_data.data(), WIDTH); }

    friend constexpr bool operator==(const base_blob& a, const base_blob& b) { return a.Compare(b) == 0; }
    friend constexpr bool operator<(const base_blob& a, const base_blob& b) { return a.Compare(b) < 0; }

    /** @name Hex representation
     *
     * The hex representation used by GetHex(), ToString(), and FromHex()
     * is unusual, since it shows bytes of the base_blob in reverse order.
     * For example, a 4-byte blob {0x12, 0x34, 0x56, 0x78} is represented
     * as "78563412" instead of the more typical "12345678" representation
     * that would be shown in a hex editor or used by typical
     * byte-array / hex conversion functions like python's bytes.hex() and
     * bytes.fromhex().
     *
     * The nice thing about the reverse-byte representation, even though it is
     * unusual, is that if a blob contains an arithmetic number in little endian
     * format (with least significant bytes first, and most significant bytes
     * last), the GetHex() output will match the way the number would normally
     * be written in base-16 (with most significant digits first and least
     * significant digits last).
     *
     * This means, for example, that ArithToUint256(num).GetHex() can be used to
     * display an arith_uint256 num value as a number, because
     * ArithToUint256() converts the number to a blob in little-endian format,
     * so the arith_uint256 class doesn't need to have its own number parsing
     * and formatting functions.
     *
     * @{*/
    std::string GetHex() const;
    std::string ToString() const;
    /**@}*/

    constexpr const unsigned char* data() const { return m_data.data(); }
    constexpr unsigned char* data() { return m_data.data(); }

    constexpr unsigned char* begin() { return m_data.data(); }
    constexpr unsigned char* end() { return m_data.data() + WIDTH; }

    constexpr const unsigned char* begin() const { return m_data.data(); }
    constexpr const unsigned char* end() const { return m_data.data() + WIDTH; }

    static constexpr unsigned int size() { return WIDTH; }

    constexpr uint64_t GetUint64(int pos) const { return ReadLE64(m_data.data() + pos * 8); }

    template<typename Stream>
    void Serialize(Stream& s) const
    {
        s << std::span(m_data);
    }

    template<typename Stream>
    void Unserialize(Stream& s)
    {
        s.read(MakeWritableByteSpan(m_data));
    }
};

template <unsigned int BITS>
consteval base_blob<BITS>::base_blob(std::string_view hex_str)
{
    if (hex_str.length() != m_data.size() * 2) throw "Hex string must fit exactly";
    auto str_it = hex_str.rbegin();
    for (auto& elem : m_data) {
        auto lo = util::ConstevalHexDigit(*(str_it++));
        elem = (util::ConstevalHexDigit(*(str_it++)) << 4) | lo;
    }
}

namespace detail {
/**
 * Writes the hex string (in reverse byte order) into a new uintN_t object
 * and only returns a value iff all of the checks pass:
 *   - Input length is uintN_t::size()*2
 *   - All characters are hex
 */
template <class uintN_t>
std::optional<uintN_t> FromHex(std::string_view str)
{
    if (uintN_t::size() * 2 != str.size() || !IsHex(str)) return std::nullopt;
    uintN_t rv;
    unsigned char* p1 = rv.begin();
    unsigned char* pend = rv.end();
    size_t digits = str.size();
    while (digits > 0 && p1 < pend) {
        *p1 = ::HexDigit(str[--digits]);
        if (digits > 0) {
            *p1 |= ((unsigned char)::HexDigit(str[--digits]) << 4);
            p1++;
        }
    }
    return rv;
}
/**
 * @brief Like FromHex(std::string_view str), but allows an "0x" prefix
 *        and pads the input with leading zeroes if it is shorter than
 *        the expected length of uintN_t::size()*2.
 *
 *        Designed to be used when dealing with user input.
 */
template <class uintN_t>
std::optional<uintN_t> FromUserHex(std::string_view input)
{
    input = util::RemovePrefixView(input, "0x");
    constexpr auto expected_size{uintN_t::size() * 2};
    if (input.size() < expected_size) {
        auto padded = std::string(expected_size, '0');
        std::copy(input.begin(), input.end(), padded.begin() + expected_size - input.size());
        return FromHex<uintN_t>(padded);
    }
    return FromHex<uintN_t>(input);
}
} // namespace detail

/** 160-bit opaque blob.
 * @note This type is called uint160 for historical reasons only. It is an opaque
 * blob of 160 bits and has no integer operations.
 */
class uint160 : public base_blob<160> {
public:
    static std::optional<uint160> FromHex(std::string_view str) { return detail::FromHex<uint160>(str); }
    constexpr uint160() = default;
    constexpr explicit uint160(std::span<const unsigned char> vch) : base_blob<160>(vch) {}
};

/** 256-bit opaque blob.
 * @note This type is called uint256 for historical reasons only. It is an
 * opaque blob of 256 bits and has no integer operations. Use arith_uint256 if
 * those are required.
 */
class uint256 : public base_blob<256> {
public:
    static std::optional<uint256> FromHex(std::string_view str) { return detail::FromHex<uint256>(str); }
    static std::optional<uint256> FromUserHex(std::string_view str) { return detail::FromUserHex<uint256>(str); }
    constexpr uint256() = default;
    consteval explicit uint256(std::string_view hex_str) : base_blob<256>(hex_str) {}
    constexpr explicit uint256(uint8_t v) : base_blob<256>(v) {}
    constexpr explicit uint256(std::span<const unsigned char> vch) : base_blob<256>(vch) {}
    static const uint256 ZERO;
    static const uint256 ONE;
};

#endif // BITCOIN_UINT256_H

Bitcoin Core Fuzz Coverage Report

Coverage Report

Created: 2026-03-24 13:57

Line	Count	Source
1		// Copyright (c) 2009-2010 Satoshi Nakamoto
2		// Copyright (c) 2009-present The Bitcoin Core developers
3		// Distributed under the MIT software license, see the accompanying
4		// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6		#ifndef BITCOIN_UINT256_H
7		#define BITCOIN_UINT256_H
8
9		#include <crypto/common.h>
10		#include <span.h>
11		#include <util/strencodings.h>
12		#include <util/string.h>
13
14		#include <algorithm>
15		#include <array>
16		#include <cassert>
17		#include <cstdint>
18		#include <cstring>
19		#include <optional>
20		#include <string>
21		#include <string_view>
22
23		/** Template base class for fixed-sized opaque blobs. */
24		template<unsigned int BITS>
25		class base_blob
26		{
27		protected:
28		static constexpr int WIDTH = BITS / 8;
29		static_assert(BITS % 8 == 0, "base_blob currently only supports whole bytes.");
30		std::array<uint8_t, WIDTH> m_data;
31		static_assert(WIDTH == sizeof(m_data), "Sanity check");
32
33		public:
34		/* construct 0 value by default */
35	0	constexpr base_blob() : m_data() {} Unexecuted instantiation: base_blob<256u>::base_blob() Unexecuted instantiation: base_blob<160u>::base_blob()
36
37		/* constructor for constants between 1 and 255 */
38	0	constexpr explicit base_blob(uint8_t v) : m_data{v} {}
39
40		constexpr explicit base_blob(std::span<const unsigned char> vch)
41	0	{
42	0	assert(vch.size() == WIDTH);
43	0	std::copy(vch.begin(), vch.end(), m_data.begin());
44	0	} Unexecuted instantiation: base_blob<256u>::base_blob(std::span<unsigned char const, 18446744073709551615ul>) Unexecuted instantiation: base_blob<160u>::base_blob(std::span<unsigned char const, 18446744073709551615ul>)
45
46		consteval explicit base_blob(std::string_view hex_str);
47
48		constexpr bool IsNull() const
49	0	{
50	0	return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
51	0	return val == 0;
52	0	}); Unexecuted instantiation: base_blob<256u>::IsNull() const::'lambda'(unsigned char)::operator()(unsigned char) const Unexecuted instantiation: base_blob<160u>::IsNull() const::'lambda'(unsigned char)::operator()(unsigned char) const
53	0	} Unexecuted instantiation: base_blob<256u>::IsNull() const Unexecuted instantiation: base_blob<160u>::IsNull() const
54
55		constexpr void SetNull()
56	0	{
57	0	std::fill(m_data.begin(), m_data.end(), 0);
58	0	} Unexecuted instantiation: base_blob<256u>::SetNull() Unexecuted instantiation: base_blob<160u>::SetNull()
59
60		/** Lexicographic ordering
61		* @note Does NOT match the ordering on the corresponding \ref
62		* base_uint::CompareTo, which starts comparing from the end.
63		*/
64	0	constexpr int Compare(const base_blob& other) const { return std::memcmp(m_data.data(), other.m_data.data(), WIDTH); } Unexecuted instantiation: base_blob<256u>::Compare(base_blob<256u> const&) const Unexecuted instantiation: base_blob<160u>::Compare(base_blob<160u> const&) const
65
66	0	friend constexpr bool operator==(const base_blob& a, const base_blob& b) { return a.Compare(b) == 0; } Unexecuted instantiation: operator==(base_blob<256u> const&, base_blob<256u> const&) Unexecuted instantiation: operator==(base_blob<160u> const&, base_blob<160u> const&)
67	0	friend constexpr bool operator<(const base_blob& a, const base_blob& b) { return a.Compare(b) < 0; } Unexecuted instantiation: operator<(base_blob<256u> const&, base_blob<256u> const&) Unexecuted instantiation: operator<(base_blob<160u> const&, base_blob<160u> const&)
68
69		/** @name Hex representation
70		*
71		* The hex representation used by GetHex(), ToString(), and FromHex()
72		* is unusual, since it shows bytes of the base_blob in reverse order.
73		* For example, a 4-byte blob {0x12, 0x34, 0x56, 0x78} is represented
74		* as "78563412" instead of the more typical "12345678" representation
75		* that would be shown in a hex editor or used by typical
76		* byte-array / hex conversion functions like python's bytes.hex() and
77		* bytes.fromhex().
78		*
79		* The nice thing about the reverse-byte representation, even though it is
80		* unusual, is that if a blob contains an arithmetic number in little endian
81		* format (with least significant bytes first, and most significant bytes
82		* last), the GetHex() output will match the way the number would normally
83		* be written in base-16 (with most significant digits first and least
84		* significant digits last).
85		*
86		* This means, for example, that ArithToUint256(num).GetHex() can be used to
87		* display an arith_uint256 num value as a number, because
88		* ArithToUint256() converts the number to a blob in little-endian format,
89		* so the arith_uint256 class doesn't need to have its own number parsing
90		* and formatting functions.
91		*
92		* @{*/
93		std::string GetHex() const;
94		std::string ToString() const;
95		/*@}/
96
97	0	constexpr const unsigned char* data() const { return m_data.data(); } Unexecuted instantiation: base_blob<160u>::data() const Unexecuted instantiation: base_blob<256u>::data() const
98	0	constexpr unsigned char* data() { return m_data.data(); } Unexecuted instantiation: base_blob<160u>::data() Unexecuted instantiation: base_blob<256u>::data()
99
100	0	constexpr unsigned char* begin() { return m_data.data(); } Unexecuted instantiation: base_blob<160u>::begin() Unexecuted instantiation: base_blob<256u>::begin()
101	0	constexpr unsigned char* end() { return m_data.data() + WIDTH; } Unexecuted instantiation: base_blob<160u>::end() Unexecuted instantiation: base_blob<256u>::end()
102
103	0	constexpr const unsigned char* begin() const { return m_data.data(); } Unexecuted instantiation: base_blob<160u>::begin() const Unexecuted instantiation: base_blob<256u>::begin() const
104	0	constexpr const unsigned char* end() const { return m_data.data() + WIDTH; } Unexecuted instantiation: base_blob<160u>::end() const Unexecuted instantiation: base_blob<256u>::end() const
105
106	0	static constexpr unsigned int size() { return WIDTH; } Unexecuted instantiation: base_blob<160u>::size() Unexecuted instantiation: base_blob<256u>::size()
107
108	0	constexpr uint64_t GetUint64(int pos) const { return ReadLE64(m_data.data() + pos * 8); }
109
110		template<typename Stream>
111		void Serialize(Stream& s) const
112	0	{
113	0	s << std::span(m_data);
114	0	} Unexecuted instantiation: void base_blob<256u>::Serialize<ParamsStream<SizeComputer&, TransactionSerParams> >(ParamsStream<SizeComputer&, TransactionSerParams>&) const Unexecuted instantiation: void base_blob<256u>::Serialize<DataStream>(DataStream&) const Unexecuted instantiation: void base_blob<256u>::Serialize<ParamsStream<DataStream&, TransactionSerParams> >(ParamsStream<DataStream&, TransactionSerParams>&) const Unexecuted instantiation: void base_blob<256u>::Serialize<SizeComputer>(SizeComputer&) const Unexecuted instantiation: void base_blob<256u>::Serialize<VectorWriter>(VectorWriter&) const Unexecuted instantiation: void base_blob<160u>::Serialize<DataStream>(DataStream&) const Unexecuted instantiation: void base_blob<256u>::Serialize<ParamsStream<VectorWriter&, TransactionSerParams> >(ParamsStream<VectorWriter&, TransactionSerParams>&) const Unexecuted instantiation: void base_blob<256u>::Serialize<ParamsStream<ParamsStream<VectorWriter&, TransactionSerParams>&, TransactionSerParams> >(ParamsStream<ParamsStream<VectorWriter&, TransactionSerParams>&, TransactionSerParams>&) const Unexecuted instantiation: void base_blob<256u>::Serialize<AutoFile>(AutoFile&) const Unexecuted instantiation: void base_blob<256u>::Serialize<HashWriter>(HashWriter&) const Unexecuted instantiation: void base_blob<256u>::Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams> >(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&) const Unexecuted instantiation: void base_blob<256u>::Serialize<ParamsStream<DataStream&, CAddress::SerParams> >(ParamsStream<DataStream&, CAddress::SerParams>&) const Unexecuted instantiation: void base_blob<256u>::Serialize<BufferedWriter<AutoFile> >(BufferedWriter<AutoFile>&) const Unexecuted instantiation: void base_blob<256u>::Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams> >(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&) const Unexecuted instantiation: void base_blob<256u>::Serialize<ParamsStream<AutoFile&, TransactionSerParams> >(ParamsStream<AutoFile&, TransactionSerParams>&) const Unexecuted instantiation: void base_blob<256u>::Serialize<ParamsStream<HashWriter&, TransactionSerParams> >(ParamsStream<HashWriter&, TransactionSerParams>&) const
115
116		template<typename Stream>
117		void Unserialize(Stream& s)
118	0	{
119	0	s.read(MakeWritableByteSpan(m_data));
120	0	} Unexecuted instantiation: void base_blob<256u>::Unserialize<ParamsStream<SpanReader&, TransactionSerParams> >(ParamsStream<SpanReader&, TransactionSerParams>&) Unexecuted instantiation: void base_blob<256u>::Unserialize<SpanReader>(SpanReader&) Unexecuted instantiation: void base_blob<256u>::Unserialize<DataStream>(DataStream&) Unexecuted instantiation: void base_blob<160u>::Unserialize<SpanReader>(SpanReader&) Unexecuted instantiation: void base_blob<160u>::Unserialize<DataStream>(DataStream&) Unexecuted instantiation: void base_blob<256u>::Unserialize<AutoFile>(AutoFile&) Unexecuted instantiation: void base_blob<256u>::Unserialize<ParamsStream<DataStream&, TransactionSerParams> >(ParamsStream<DataStream&, TransactionSerParams>&) Unexecuted instantiation: void base_blob<256u>::Unserialize<ParamsStream<AutoFile&, CAddress::SerParams> >(ParamsStream<AutoFile&, CAddress::SerParams>&) Unexecuted instantiation: void base_blob<256u>::Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams> >(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&) Unexecuted instantiation: void base_blob<256u>::Unserialize<ParamsStream<DataStream&, CAddress::SerParams> >(ParamsStream<DataStream&, CAddress::SerParams>&) Unexecuted instantiation: void base_blob<256u>::Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams> >(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&) Unexecuted instantiation: void base_blob<256u>::Unserialize<BufferedReader<AutoFile> >(BufferedReader<AutoFile>&) Unexecuted instantiation: void base_blob<256u>::Unserialize<ParamsStream<AutoFile&, TransactionSerParams> >(ParamsStream<AutoFile&, TransactionSerParams>&) Unexecuted instantiation: void base_blob<256u>::Unserialize<BufferedFile>(BufferedFile&) Unexecuted instantiation: void base_blob<256u>::Unserialize<ParamsStream<BufferedFile&, TransactionSerParams> >(ParamsStream<BufferedFile&, TransactionSerParams>&)
121		};
122
123		template <unsigned int BITS>
124		consteval base_blob<BITS>::base_blob(std::string_view hex_str)
125		{
126		if (hex_str.length() != m_data.size() * 2) throw "Hex string must fit exactly";
127		auto str_it = hex_str.rbegin();
128		for (auto& elem : m_data) {
129		auto lo = util::ConstevalHexDigit(*(str_it++));
130		elem = (util::ConstevalHexDigit(*(str_it++)) << 4) \| lo;
131		}
132		}
133
134		namespace detail {
135		/**
136		* Writes the hex string (in reverse byte order) into a new uintN_t object
137		* and only returns a value iff all of the checks pass:
138		* - Input length is uintN_t::size()*2
139		* - All characters are hex
140		*/
141		template <class uintN_t>
142		std::optional<uintN_t> FromHex(std::string_view str)
143	0	{
144	0	if (uintN_t::size() * 2 != str.size() \|\| !IsHex(str)) return std::nullopt;
145	0	uintN_t rv;
146	0	unsigned char* p1 = rv.begin();
147	0	unsigned char* pend = rv.end();
148	0	size_t digits = str.size();
149	0	while (digits > 0 && p1 < pend) {
150	0	*p1 = ::HexDigit(str[--digits]);
151	0	if (digits > 0) {
152	0	*p1 \|= ((unsigned char)::HexDigit(str[--digits]) << 4);
153	0	p1++;
154	0	}
155	0	}
156	0	return rv;
157	0	} Unexecuted instantiation: std::optional<uint160> detail::FromHex<uint160>(std::basic_string_view<char, std::char_traits<char> >) Unexecuted instantiation: std::optional<uint256> detail::FromHex<uint256>(std::basic_string_view<char, std::char_traits<char> >)
158		/**
159		* @brief Like FromHex(std::string_view str), but allows an "0x" prefix
160		* and pads the input with leading zeroes if it is shorter than
161		* the expected length of uintN_t::size()*2.
162		*
163		* Designed to be used when dealing with user input.
164		*/
165		template <class uintN_t>
166		std::optional<uintN_t> FromUserHex(std::string_view input)
167	0	{
168	0	input = util::RemovePrefixView(input, "0x");
169	0	constexpr auto expected_size{uintN_t::size() * 2};
170	0	if (input.size() < expected_size) {
171	0	auto padded = std::string(expected_size, '0');
172	0	std::copy(input.begin(), input.end(), padded.begin() + expected_size - input.size());
173	0	return FromHex<uintN_t>(padded);
174	0	}
175	0	return FromHex<uintN_t>(input);
176	0	}
177		} // namespace detail
178
179		/** 160-bit opaque blob.
180		* @note This type is called uint160 for historical reasons only. It is an opaque
181		* blob of 160 bits and has no integer operations.
182		*/
183		class uint160 : public base_blob<160> {
184		public:
185	0	static std::optional<uint160> FromHex(std::string_view str) { return detail::FromHex<uint160>(str); }
186	0	constexpr uint160() = default;
187	0	constexpr explicit uint160(std::span<const unsigned char> vch) : base_blob<160>(vch) {}
188		};
189
190		/** 256-bit opaque blob.
191		* @note This type is called uint256 for historical reasons only. It is an
192		* opaque blob of 256 bits and has no integer operations. Use arith_uint256 if
193		* those are required.
194		*/
195		class uint256 : public base_blob<256> {
196		public:
197	0	static std::optional<uint256> FromHex(std::string_view str) { return detail::FromHex<uint256>(str); }
198	0	static std::optional<uint256> FromUserHex(std::string_view str) { return detail::FromUserHex<uint256>(str); }
199	0	constexpr uint256() = default;
200	0	consteval explicit uint256(std::string_view hex_str) : base_blob<256>(hex_str) {}
201	0	constexpr explicit uint256(uint8_t v) : base_blob<256>(v) {}
202	0	constexpr explicit uint256(std::span<const unsigned char> vch) : base_blob<256>(vch) {}
203		static const uint256 ZERO;
204		static const uint256 ONE;
205		};
206
207		#endif // BITCOIN_UINT256_H