LCOV - code coverage report
Current view: top level - src - uint256.h (source / functions) Coverage Total Hit
Test: fuzz_coverage.info Lines: 100.0 % 55 55
Test Date: 2025-04-25 04:10:03 Functions: 85.0 % 20 17
Branches: 24.8 % 2693 668

             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                 :  1026290372 :     constexpr base_blob() : m_data() {}
      36                 :             : 
      37                 :             :     /* constructor for constants between 1 and 255 */
      38                 :        8085 :     constexpr explicit base_blob(uint8_t v) : m_data{v} {}
      39                 :             : 
      40         [ -  + ]:    11518719 :     constexpr explicit base_blob(std::span<const unsigned char> vch)
      41                 :             :     {
      42         [ -  + ]:    11518719 :         assert(vch.size() == WIDTH);
      43                 :    11518719 :         std::copy(vch.begin(), vch.end(), m_data.begin());
      44                 :    11518719 :     }
      45                 :             : 
      46                 :             :     consteval explicit base_blob(std::string_view hex_str);
      47                 :             : 
      48                 :    22290459 :     constexpr bool IsNull() const
      49                 :             :     {
      50                 :    22290459 :         return std::all_of(m_data.begin(), m_data.end(), [](uint8_t val) {
      51                 :             :             return val == 0;
      52                 :    22290459 :         });
      53                 :             :     }
      54                 :             : 
      55                 :     5703600 :     constexpr void SetNull()
      56                 :             :     {
      57         [ +  + ]:    10779140 :         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   [ +  +  +  + ]:  2593271349 :     constexpr int Compare(const base_blob& other) const { return std::memcmp(m_data.data(), other.m_data.data(), WIDTH); }
           [ -  -  +  -  
          +  -  +  -  +  
           +  -  - ][ -  
          -  -  -  -  -  
          -  -  -  -  -  
          +  +  +  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
           # ][ +  -  -  
          +  -  +  +  -  
          +  -  +  -  -  
          -  -  -  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  -  -  -  -  
          +  +  +  +  +  
          +  +  -  -  -  
           -  - ][ +  +  
          +  +  -  +  -  
              - ][ +  + ]
           [ +  +  +  +  
          +  +  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
           # ][ -  -  -  
          -  -  -  +  -  
          +  +  +  -  -  
          -  -  -  -  -  
           -  - ][ #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
           # ][ +  -  -  
          +  -  -  -  -  
          -  -  -  -  -  
          -  -  -  +  +  
          +  +  +  +  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  +  +  -  -  
          +  -  -  +  +  
          -  -  -  -  -  
             +  -  -  + ]
           [ -  -  -  +  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  #  
          #  #  #  #  #  
             #  #  #  # ]
           [ -  +  +  -  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  -  -  +  +  
             +  +  +  + ]
           [ -  -  -  -  
          -  -  -  +  -  
          -  -  -  +  +  
          +  -  +  -  +  
          -  -  -  -  -  
          +  +  -  -  +  
          -  -  -  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                      # ]
      65                 :             : 
      66   [ -  +  -  +  :    73467169 :     friend constexpr bool operator==(const base_blob& a, const base_blob& b) { return a.Compare(b) == 0; }
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
              + ][ +  + ]
           [ -  +  -  -  
          -  -  -  +  -  
                -  -  - ]
           [ +  +  +  + ]
           [ +  +  +  +  
          +  -  +  -  #  
          #  #  #  #  #  
           #  # ][ -  +  
          +  -  -  +  +  
          -  +  +  -  -  
             -  -  -  - ]
           [ -  -  -  -  
          -  -  +  +  +  
          +  +  +  -  -  
             -  -  -  + ]
           [ +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
           #  #  # ][ +  
          +  -  -  -  -  
          +  +  -  -  #  
          #  #  #  #  #  
           #  # ][ -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  +  +  
          +  -  +  -  +  
          -  -  -  +  -  
          +  -  -  -  +  
          -  +  +  +  -  
             +  -  -  -  
           - ][ -  +  -  
                +  -  + ]
      67   [ -  +  -  +  :     1680013 :     friend constexpr bool operator!=(const base_blob& a, const base_blob& b) { return a.Compare(b) != 0; }
                   +  + ]
           [ +  +  +  + ]
           [ +  +  #  #  
          #  #  #  #  #  
           # ][ +  -  -  
             -  -  -  -  
           - ][ -  -  +  
          -  -  -  +  -  
                   +  + ]
      68   [ +  +  +  -  :   610958400 :     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   [ +  -  +  - ]:    23344878 :     constexpr const unsigned char* data() const { return m_data.data(); }
           [ -  -  -  -  
          -  -  -  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  -  -  
          -  -  -  -  +  
           - ][ +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
             -  +  -  +  
           - ][ -  -  -  
             -  -  -  +  
              - ][ +  - ]
      99         [ +  - ]:    45597741 :     constexpr unsigned char* data() { return m_data.data(); }
           [ +  -  +  - ]
           [ -  -  -  -  
                   +  - ]
     100                 :             : 
     101 [ +  - ][ +  -  :   189844649 :     constexpr unsigned char* begin() { return m_data.data(); }
          +  +  +  -  +  
                      - ]
           [ +  +  +  + ]
           [ +  -  +  +  
                   +  - ]
     102                 :        5270 :     constexpr unsigned char* end() { return m_data.data() + WIDTH; }
     103                 :             : 
     104   [ +  -  +  -  :    15742695 :     constexpr const unsigned char* begin() const { return m_data.data(); }
          +  -  +  -  +  
              - ][ +  + ]
     105   [ +  -  +  -  :     7335894 :     constexpr const unsigned char* end() const { return m_data.data() + WIDTH; }
          +  -  +  -  +  
                      - ]
     106                 :             : 
     107                 :             :     static constexpr unsigned int size() { return WIDTH; }
     108                 :             : 
     109         [ -  + ]:   272600659 :     constexpr uint64_t GetUint64(int pos) const { return ReadLE64(m_data.data() + pos * 8); }
     110                 :             : 
     111                 :             :     template<typename Stream>
     112                 :  1038234236 :     void Serialize(Stream& s) const
     113                 :             :     {
     114                 :  1038234236 :         s << std::span(m_data);
     115                 :             :     }
     116                 :             : 
     117                 :             :     template<typename Stream>
     118                 :    12412723 :     void Unserialize(Stream& s)
     119                 :             :     {
     120                 :    12412723 :         s.read(MakeWritableByteSpan(m_data));
     121                 :    12320903 :     }
     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         [ +  + ]:        4370 : std::optional<uintN_t> FromHex(std::string_view str)
     144                 :             : {
     145   [ +  +  +  + ]:        4370 :     if (uintN_t::size() * 2 != str.size() || !IsHex(str)) return std::nullopt;
     146                 :         497 :     uintN_t rv;
     147                 :         497 :     unsigned char* p1 = rv.begin();
     148                 :         497 :     unsigned char* pend = rv.end();
     149                 :         497 :     size_t digits = str.size();
     150         [ +  + ]:       16898 :     while (digits > 0 && p1 < pend) {
     151                 :       15904 :         *p1 = ::HexDigit(str[--digits]);
     152         [ -  + ]:       15904 :         if (digits > 0) {
     153                 :       15904 :             *p1 |= ((unsigned char)::HexDigit(str[--digits]) << 4);
     154                 :       15904 :             p1++;
     155                 :             :         }
     156                 :             :     }
     157                 :         497 :     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                 :         232 : std::optional<uintN_t> FromUserHex(std::string_view input)
     168                 :             : {
     169                 :         232 :     input = util::RemovePrefixView(input, "0x");
     170         [ +  + ]:         232 :     constexpr auto expected_size{uintN_t::size() * 2};
     171         [ +  + ]:         232 :     if (input.size() < expected_size) {
     172                 :          43 :         auto padded = std::string(expected_size, '0');
     173         [ +  - ]:          43 :         std::copy(input.begin(), input.end(), padded.begin() + expected_size - input.size());
     174         [ +  - ]:          43 :         return FromHex<uintN_t>(padded);
     175                 :          43 :     }
     176                 :         189 :     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 [ +  + ][ -  -  :     3435559 :     constexpr uint160() = default;
             -  -  -  -  
                      - ]
     188                 :     8704060 :     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   [ #  #  #  #  :        4138 :     static std::optional<uint256> FromHex(std::string_view str) { return detail::FromHex<uint256>(str); }
          #  #  #  #  #  
                #  #  # ]
                 [ +  - ]
           [ +  -  +  - ]
     199   [ +  -  +  - ]:         232 :     static std::optional<uint256> FromUserHex(std::string_view str) { return detail::FromUserHex<uint256>(str); }
     200   [ +  +  +  +  :   999441384 :     constexpr uint256() = default;
           +  + ][ +  -  
          +  -  +  -  +  
          -  -  +  +  -  
          +  +  +  -  +  
             -  +  +  +  
              - ][ +  + ]
           [ +  -  +  + ]
     201                 :             :     consteval explicit uint256(std::string_view hex_str) : base_blob<256>(hex_str) {}
     202         [ +  - ]:        8085 :     constexpr explicit uint256(uint8_t v) : base_blob<256>(v) {}
     203                 :     2798530 :     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
        

Generated by: LCOV version 2.0-1