Branch data     Line data    Source code

       1                 :             : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :             : // Copyright (c) 2009-2022 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_PRIMITIVES_BLOCK_H
       7                 :             : #define BITCOIN_PRIMITIVES_BLOCK_H
       8                 :             : 
       9                 :             : #include <primitives/transaction.h>
      10                 :             : #include <serialize.h>
      11                 :             : #include <uint256.h>
      12                 :             : #include <util/time.h>
      13                 :             : 
      14                 :             : /** Nodes collect new transactions into a block, hash them into a hash tree,
      15                 :             :  * and scan through nonce values to make the block's hash satisfy proof-of-work
      16                 :             :  * requirements.  When they solve the proof-of-work, they broadcast the block
      17                 :             :  * to everyone and the block is added to the block chain.  The first transaction
      18                 :             :  * in the block is a special one that creates a new coin owned by the creator
      19                 :             :  * of the block.
      20                 :             :  */
      21                 :             : class CBlockHeader
      22                 :             : {
      23                 :             : public:
      24                 :             :     // header
      25                 :             :     int32_t nVersion;
      26                 :             :     uint256 hashPrevBlock;
      27                 :             :     uint256 hashMerkleRoot;
      28                 :             :     uint32_t nTime;
      29                 :             :     uint32_t nBits;
      30                 :             :     uint32_t nNonce;
      31                 :             : 
      32                 :     3593639 :     CBlockHeader()
      33                 :             :     {
      34                 :     3593639 :         SetNull();
      35                 :     3593639 :     }
      36                 :             : 
      37                 :    23630781 :     SERIALIZE_METHODS(CBlockHeader, obj) { READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce); }
      38                 :             : 
      39                 :     4281955 :     void SetNull()
      40                 :             :     {
      41                 :     4281955 :         nVersion = 0;
      42                 :     4281955 :         hashPrevBlock.SetNull();
      43                 :     4281955 :         hashMerkleRoot.SetNull();
      44                 :     4281955 :         nTime = 0;
      45                 :     4281955 :         nBits = 0;
      46                 :     4281955 :         nNonce = 0;
      47                 :     4281955 :     }
      48                 :             : 
      49                 :     2041107 :     bool IsNull() const
      50                 :             :     {
      51                 :     2041107 :         return (nBits == 0);
      52                 :             :     }
      53                 :             : 
      54                 :             :     uint256 GetHash() const;
      55                 :             : 
      56                 :      436147 :     NodeSeconds Time() const
      57                 :             :     {
      58                 :      436147 :         return NodeSeconds{std::chrono::seconds{nTime}};
      59                 :             :     }
      60                 :             : 
      61                 :     1379631 :     int64_t GetBlockTime() const
      62                 :             :     {
      63                 :     1379631 :         return (int64_t)nTime;
      64                 :             :     }
      65                 :             : };
      66                 :             : 
      67                 :             : 
      68                 :             : class CBlock : public CBlockHeader
      69                 :             : {
      70                 :             : public:
      71                 :             :     // network and disk
      72                 :             :     std::vector<CTransactionRef> vtx;
      73                 :             : 
      74                 :             :     // Memory-only flags for caching expensive checks
      75                 :             :     mutable bool fChecked;                            // CheckBlock()
      76                 :      650541 :     mutable bool m_checked_witness_commitment{false}; // CheckWitnessCommitment()
      77                 :      650541 :     mutable bool m_checked_merkle_root{false};        // CheckMerkleRoot()
      78                 :             : 
      79                 :      448442 :     CBlock()
      80                 :             :     {
      81         [ +  - ]:      448442 :         SetNull();
      82                 :      448442 :     }
      83                 :             : 
      84                 :      202099 :     CBlock(const CBlockHeader &header)
      85                 :             :     {
      86         [ +  - ]:      202099 :         SetNull();
      87                 :      202099 :         *(static_cast<CBlockHeader*>(this)) = header;
      88                 :      202099 :     }
      89                 :             : 
      90                 :     6993477 :     SERIALIZE_METHODS(CBlock, obj)
      91                 :             :     {
      92                 :     2331159 :         READWRITE(AsBase<CBlockHeader>(obj), obj.vtx);
      93                 :     2331159 :     }
      94                 :             : 
      95                 :      687610 :     void SetNull()
      96                 :             :     {
      97                 :      687610 :         CBlockHeader::SetNull();
      98                 :      687610 :         vtx.clear();
      99                 :      687610 :         fChecked = false;
     100                 :      687610 :         m_checked_witness_commitment = false;
     101                 :      687610 :         m_checked_merkle_root = false;
     102                 :      687610 :     }
     103                 :             : 
     104                 :        2003 :     CBlockHeader GetBlockHeader() const
     105                 :             :     {
     106                 :        2003 :         CBlockHeader block;
     107                 :        2003 :         block.nVersion       = nVersion;
     108                 :        2003 :         block.hashPrevBlock  = hashPrevBlock;
     109                 :        2003 :         block.hashMerkleRoot = hashMerkleRoot;
     110                 :        2003 :         block.nTime          = nTime;
     111                 :        2003 :         block.nBits          = nBits;
     112                 :        2003 :         block.nNonce         = nNonce;
     113                 :        2003 :         return block;
     114                 :             :     }
     115                 :             : 
     116                 :             :     std::string ToString() const;
     117                 :             : };
     118                 :             : 
     119                 :             : /** Describes a place in the block chain to another node such that if the
     120                 :             :  * other node doesn't have the same branch, it can find a recent common trunk.
     121                 :             :  * The further back it is, the further before the fork it may be.
     122                 :             :  */
     123                 :             : struct CBlockLocator
     124                 :             : {
     125                 :             :     /** Historically CBlockLocator's version field has been written to network
     126                 :             :      * streams as the negotiated protocol version and to disk streams as the
     127                 :             :      * client version, but the value has never been used.
     128                 :             :      *
     129                 :             :      * Hard-code to the highest protocol version ever written to a network stream.
     130                 :             :      * SerParams can be used if the field requires any meaning in the future,
     131                 :             :      **/
     132                 :             :     static constexpr int DUMMY_VERSION = 70016;
     133                 :             : 
     134                 :             :     std::vector<uint256> vHave;
     135                 :             : 
     136                 :        2900 :     CBlockLocator() = default;
     137                 :             : 
     138                 :      477659 :     explicit CBlockLocator(std::vector<uint256>&& have) : vHave(std::move(have)) {}
     139                 :             : 
     140                 :       30645 :     SERIALIZE_METHODS(CBlockLocator, obj)
     141                 :             :     {
     142                 :       10215 :         int nVersion = DUMMY_VERSION;
     143                 :       10215 :         READWRITE(nVersion);
     144                 :       10215 :         READWRITE(obj.vHave);
     145                 :       10215 :     }
     146                 :             : 
     147                 :          18 :     void SetNull()
     148                 :             :     {
     149                 :          18 :         vHave.clear();
     150                 :          18 :     }
     151                 :             : 
     152                 :      339602 :     bool IsNull() const
     153                 :             :     {
     154                 :      339602 :         return vHave.empty();
     155                 :             :     }
     156                 :             : };
     157                 :             : 
     158                 :             : #endif // BITCOIN_PRIMITIVES_BLOCK_H