uint256.h

Go to the documentation of this file.

// 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 <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(Span<const uint8_t> vch) {
        assert(vch.size() == WIDTH);
        std::copy(vch.begin(), vch.end(), m_data.begin());
    }
 
    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); }
 
    constexpr int Compare(const base_blob &other) const {
        for (size_t i = 0; i < WIDTH; i++) {
            uint8_t a = m_data[WIDTH - 1 - i];
            uint8_t b = other.m_data[WIDTH - 1 - i];
            if (a > b) {
                return 1;
            }
            if (a < b) {
                return -1;
            }
        }
 
        return 0;
    }
 
    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;
    }
    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;
    }
    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;
    }
 
    std::string GetHex() const;
 
    void SetHexDeprecated(std::string_view str);
    std::string ToString() const { return GetHex(); }
 
    constexpr const uint8_t *data() const { return m_data.data(); }
    constexpr uint8_t *data() { return m_data.data(); }
 
    constexpr uint8_t *begin() { return m_data.data(); }
    constexpr uint8_t *end() { return m_data.data() + WIDTH; }
 
    constexpr const uint8_t *begin() const { return m_data.data(); }
    constexpr const uint8_t *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 << Span(m_data);
    }
 
    template <typename Stream> void Unserialize(Stream &s) {
        s.read(MakeWritableByteSpan(m_data));
    }
};
 
namespace detail {
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;
    rv.SetHexDeprecated(str);
    return rv;
}
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
 
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(Span<const uint8_t> vch) : base_blob<160>(vch) {}
};
 
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;
    constexpr explicit uint256(uint8_t v) : base_blob<256>(v) {}
    constexpr explicit uint256(Span<const uint8_t> vch) : base_blob<256>(vch) {}
    static const uint256 ZERO;
    static const uint256 ONE;
};
 
inline uint256 uint256S(std::string_view str) {
    uint256 rv;
    rv.SetHexDeprecated(str);
    return rv;
}
 
#endif // BITCOIN_UINT256_H