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 <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 : 2190812 : constexpr base_blob() : m_data() {}
36 : :
37 : : /* constructor for constants between 1 and 255 */
38 : 0 : constexpr explicit base_blob(uint8_t v) : m_data{v} {}
39 : :
40 [ - + ]: 4280 : constexpr explicit base_blob(std::span<const unsigned char> vch)
41 : : {
42 [ - + ]: 4280 : assert(vch.size() == WIDTH);
43 : 4280 : std::copy(vch.begin(), vch.end(), m_data.begin());
44 : 4280 : }
45 : :
46 : : consteval explicit base_blob(std::string_view hex_str);
47 : :
48 : 372099 : constexpr bool IsNull() const
49 : : {
50 : 372099 : return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
51 : : return val == 0;
52 : 372099 : });
53 : : }
54 : :
55 : 1672411 : constexpr void SetNull()
56 : : {
57 [ + - ]: 3344834 : std::fill(m_data.begin(), m_data.end(), 0);
58 : : }
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 [ # # # # ]: 25668 : constexpr int Compare(const base_blob& other) const { return std::memcmp(m_data.data(), other.m_data.data(), WIDTH); }
[ # # ][ # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # #
# ][ # # #
# # # # #
# # # # ]
[ # # # #
# # # # ]
[ # # # #
# # # # #
# # # # #
# # # # #
# ][ # # #
# # # # #
# # # # #
# # # # #
# # ][ # #
# # # # #
# # # ][ #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
[ # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ][ #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ][ # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ][ # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
65 : :
66 [ # # ]: 29927 : friend constexpr bool operator==(const base_blob& a, const base_blob& b) { return a.Compare(b) == 0; }
[ # # # # ]
[ - + - +
- + - + -
+ - + - +
- + - + -
+ ][ - + -
- - - - -
- - ][ # #
# # # # #
# # # # #
# # ][ # #
# # # # #
# # # # #
# # # # ]
[ # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ][ #
# # # # #
# # # # #
# # # # #
# # ][ # #
# # # # #
# ][ # # #
# # # # #
# # # # #
# # # #
# ][ - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- + - - -
- - - - -
- - - + -
+ + - - -
- - - - ]
67 [ # # # # : 237995 : friend constexpr bool operator!=(const base_blob& a, const base_blob& b) { return a.Compare(b) != 0; }
# # ][ - +
+ + # # ]
[ + - ][ - -
- - - - +
- - + ][ #
# # # # #
# # ]
68 [ # # # # : 12950 : 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(), FromHex() and
73 : : * SetHexDeprecated() is unusual, since it shows bytes of the base_blob in
74 : : * reverse order. For example, a 4-byte blob {0x12, 0x34, 0x56, 0x78} is
75 : : * represented as "78563412" instead of the more typical "12345678"
76 : : * representation 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 : : /** Unlike FromHex this accepts any invalid input, thus it is fragile and deprecated!
96 : : *
97 : : * - Hex numbers that don't specify enough bytes to fill the internal array
98 : : * will be treated as setting the beginning of it, which corresponds to
99 : : * the least significant bytes when converted to base_uint.
100 : : *
101 : : * - Hex numbers specifying too many bytes will have the numerically most
102 : : * significant bytes (the beginning of the string) narrowed away.
103 : : *
104 : : * - An odd count of hex digits will result in the high bits of the leftmost
105 : : * byte being zero.
106 : : * "0x123" => {0x23, 0x1, 0x0, ..., 0x0}
107 : : */
108 : : void SetHexDeprecated(std::string_view str);
109 : : std::string ToString() const;
110 : : /**@}*/
111 : :
112 [ # # # # : 11886 : constexpr const unsigned char* data() const { return m_data.data(); }
# # # # #
# # # # #
# # # # #
# # # #
# ][ # # #
# # # # #
# # # # #
# # # #
# ][ # # #
# # # # #
# # # # #
# # # #
# ][ # # #
# # # #
# ][ # # ]
113 [ # # # # : 927575 : constexpr unsigned char* data() { return m_data.data(); }
# # ][ # # ]
[ - - - -
# # ]
114 : :
115 [ # # # # : 2944509 : constexpr unsigned char* begin() { return m_data.data(); }
# # ][ + - ]
[ + + + +
# # # # ]
[ - - - -
+ - + - ]
116 : 0 : constexpr unsigned char* end() { return m_data.data() + WIDTH; }
117 : :
118 [ # # ][ # # : 305064 : constexpr const unsigned char* begin() const { return m_data.data(); }
# # # # #
# # # ]
119 [ # # # # : 40 : constexpr const unsigned char* end() const { return m_data.data() + WIDTH; }
# # # # #
# ]
120 : :
121 : : static constexpr unsigned int size() { return WIDTH; }
122 : :
123 [ # # ]: 12486 : constexpr uint64_t GetUint64(int pos) const { return ReadLE64(m_data.data() + pos * 8); }
124 : :
125 : : template<typename Stream>
126 : 3472150 : void Serialize(Stream& s) const
127 : : {
128 : 3472150 : s << std::span(m_data);
129 : : }
130 : :
131 : : template<typename Stream>
132 : 488920 : void Unserialize(Stream& s)
133 : : {
134 : 488920 : s.read(MakeWritableByteSpan(m_data));
135 : 488920 : }
136 : : };
137 : :
138 : : template <unsigned int BITS>
139 : : consteval base_blob<BITS>::base_blob(std::string_view hex_str)
140 : : {
141 : : if (hex_str.length() != m_data.size() * 2) throw "Hex string must fit exactly";
142 : : auto str_it = hex_str.rbegin();
143 : : for (auto& elem : m_data) {
144 : : auto lo = util::ConstevalHexDigit(*(str_it++));
145 : : elem = (util::ConstevalHexDigit(*(str_it++)) << 4) | lo;
146 : : }
147 : : }
148 : :
149 : : namespace detail {
150 : : /**
151 : : * Writes the hex string (in reverse byte order) into a new uintN_t object
152 : : * and only returns a value iff all of the checks pass:
153 : : * - Input length is uintN_t::size()*2
154 : : * - All characters are hex
155 : : */
156 : : template <class uintN_t>
157 [ # # ]: 0 : std::optional<uintN_t> FromHex(std::string_view str)
158 : : {
159 [ # # # # ]: 0 : if (uintN_t::size() * 2 != str.size() || !IsHex(str)) return std::nullopt;
160 : 0 : uintN_t rv;
161 : 0 : rv.SetHexDeprecated(str);
162 : 0 : return rv;
163 : : }
164 : : /**
165 : : * @brief Like FromHex(std::string_view str), but allows an "0x" prefix
166 : : * and pads the input with leading zeroes if it is shorter than
167 : : * the expected length of uintN_t::size()*2.
168 : : *
169 : : * Designed to be used when dealing with user input.
170 : : */
171 : : template <class uintN_t>
172 : 0 : std::optional<uintN_t> FromUserHex(std::string_view input)
173 : : {
174 : 0 : input = util::RemovePrefixView(input, "0x");
175 [ # # ]: 0 : constexpr auto expected_size{uintN_t::size() * 2};
176 [ # # ]: 0 : if (input.size() < expected_size) {
177 : 0 : auto padded = std::string(expected_size, '0');
178 [ # # ]: 0 : std::copy(input.begin(), input.end(), padded.begin() + expected_size - input.size());
179 [ # # ]: 0 : return FromHex<uintN_t>(padded);
180 : 0 : }
181 : 0 : return FromHex<uintN_t>(input);
182 : : }
183 : : } // namespace detail
184 : :
185 : : /** 160-bit opaque blob.
186 : : * @note This type is called uint160 for historical reasons only. It is an opaque
187 : : * blob of 160 bits and has no integer operations.
188 : : */
189 : : class uint160 : public base_blob<160> {
190 : : public:
191 : : static std::optional<uint160> FromHex(std::string_view str) { return detail::FromHex<uint160>(str); }
192 [ # # ][ # # : 0 : constexpr uint160() = default;
# # # #
# ]
193 : 0 : constexpr explicit uint160(std::span<const unsigned char> vch) : base_blob<160>(vch) {}
194 : : };
195 : :
196 : : /** 256-bit opaque blob.
197 : : * @note This type is called uint256 for historical reasons only. It is an
198 : : * opaque blob of 256 bits and has no integer operations. Use arith_uint256 if
199 : : * those are required.
200 : : */
201 : : class uint256 : public base_blob<256> {
202 : : public:
203 [ # # ][ # # : 0 : static std::optional<uint256> FromHex(std::string_view str) { return detail::FromHex<uint256>(str); }
# # # # #
# # # #
# ]
[ # # # # ]
204 [ # # # # ]: 0 : static std::optional<uint256> FromUserHex(std::string_view str) { return detail::FromUserHex<uint256>(str); }
205 [ + - - - : 2151624 : constexpr uint256() = default;
+ - ][ + + ]
[ # # # # ]
[ # # # #
# # # # #
# # # # #
# # # # #
# # # ]
206 : : consteval explicit uint256(std::string_view hex_str) : base_blob<256>(hex_str) {}
207 [ # # ]: 0 : constexpr explicit uint256(uint8_t v) : base_blob<256>(v) {}
208 : 4280 : constexpr explicit uint256(std::span<const unsigned char> vch) : base_blob<256>(vch) {}
209 : : static const uint256 ZERO;
210 : : static const uint256 ONE;
211 : : };
212 : :
213 : : #endif // BITCOIN_UINT256_H
|
