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 <compare>
19#include <cstdint>
20#include <cstring>
21#include <optional>
22#include <string>
23#include <string_view>
24
25/** Template base class for fixed-sized opaque blobs. */
26template<unsigned int BITS>
27class base_blob
28{
29protected:
30    static constexpr int WIDTH = BITS / 8;
31    static_assert(BITS % 8 == 0, "base_blob currently only supports whole bytes.");
32    std::array<uint8_t, WIDTH> m_data;
33    static_assert(WIDTH == sizeof(m_data), "Sanity check");
34
35public:
36    /* construct 0 value by default */
37    constexpr base_blob() : m_data() {}
38
39    /* constructor for constants between 1 and 255 */
40    constexpr explicit base_blob(uint8_t v) : m_data{v} {}
41
42    constexpr explicit base_blob(std::span<const unsigned char> vch)
43    {
44        assert(vch.size() == WIDTH);
45        std::copy(vch.begin(), vch.end(), m_data.begin());
46    }
47
48    consteval explicit base_blob(std::string_view hex_str);
49
50    constexpr bool IsNull() const
51    {
52        return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
53            return val == 0;
54        });
55    }
56
57    constexpr void SetNull()
58    {
59        std::fill(m_data.begin(), m_data.end(), 0);
60    }
61
62    constexpr bool operator==(const base_blob&) const = default;
63
64    /** Lexicographic ordering
65     * @note Does NOT match the ordering on the corresponding \ref
66     *       base_uint::CompareTo, which starts comparing from the end.
67     */
68    constexpr std::strong_ordering operator<=>(const base_blob& other) const = default;
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    constexpr const unsigned char* data() const { return m_data.data(); }
99    constexpr unsigned char* data() { return m_data.data(); }
100
101    constexpr unsigned char* begin() { return m_data.data(); }
102    constexpr unsigned char* end() { return m_data.data() + WIDTH; }
103
104    constexpr const unsigned char* begin() const { return m_data.data(); }
105    constexpr const unsigned char* end() const { return m_data.data() + WIDTH; }
106
107    static constexpr unsigned int size() { return WIDTH; }
108
109    constexpr uint64_t GetUint64(int pos) const { return ReadLE64(m_data.data() + pos * 8); }
110
111    template<typename Stream>
112    void Serialize(Stream& s) const
113    {
114        s << std::span(m_data);
115    }
116
117    template<typename Stream>
118    void Unserialize(Stream& s)
119    {
120        s.read(MakeWritableByteSpan(m_data));
121    }
122};
123
124template <unsigned int BITS>
125consteval 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
135namespace 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 */
142template <class uintN_t>
143std::optional<uintN_t> FromHex(std::string_view str)
144{
145    if (uintN_t::size() * 2 != str.size() || !IsHex(str)) return std::nullopt;
146    uintN_t rv;
147    unsigned char* p1 = rv.begin();
148    unsigned char* pend = rv.end();
149    size_t digits = str.size();
150    while (digits > 0 && p1 < pend) {
151        *p1 = ::HexDigit(str[--digits]);
152        if (digits > 0) {
153            *p1 |= ((unsigned char)::HexDigit(str[--digits]) << 4);
154            p1++;
155        }
156    }
157    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 */
166template <class uintN_t>
167std::optional<uintN_t> FromUserHex(std::string_view input)
168{
169    input = util::RemovePrefixView(input, "0x");
170    constexpr auto expected_size{uintN_t::size() * 2};
171    if (input.size() < expected_size) {
172        auto padded = std::string(expected_size, '0');
173        std::copy(input.begin(), input.end(), padded.begin() + expected_size - input.size());
174        return FromHex<uintN_t>(padded);
175    }
176    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 */
184class uint160 : public base_blob<160> {
185public:
186    static std::optional<uint160> FromHex(std::string_view str) { return detail::FromHex<uint160>(str); }
187    constexpr uint160() = default;
188    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 */
196class uint256 : public base_blob<256> {
197public:
198    static std::optional<uint256> FromHex(std::string_view str) { return detail::FromHex<uint256>(str); }
199    static std::optional<uint256> FromUserHex(std::string_view str) { return detail::FromUserHex<uint256>(str); }
200    constexpr uint256() = default;
201    consteval explicit uint256(std::string_view hex_str) : base_blob<256>(hex_str) {}
202    constexpr explicit uint256(uint8_t v) : base_blob<256>(v) {}
203    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
209