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