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      CBlockHeader()
 33      {
 34          SetNull();
 35      }
 36  
 37      SERIALIZE_METHODS(CBlockHeader, obj) { READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce); }
 38  
 39      void SetNull()
 40      {
 41          nVersion = 0;
 42          hashPrevBlock.SetNull();
 43          hashMerkleRoot.SetNull();
 44          nTime = 0;
 45          nBits = 0;
 46          nNonce = 0;
 47      }
 48  
 49      bool IsNull() const
 50      {
 51          return (nBits == 0);
 52      }
 53  
 54      uint256 GetHash() const;
 55  
 56      NodeSeconds Time() const
 57      {
 58          return NodeSeconds{std::chrono::seconds{nTime}};
 59      }
 60  
 61      int64_t GetBlockTime() const
 62      {
 63          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      mutable bool m_checked_witness_commitment{false}; // CheckWitnessCommitment()
 77      mutable bool m_checked_merkle_root{false};        // CheckMerkleRoot()
 78  
 79      CBlock()
 80      {
 81          SetNull();
 82      }
 83  
 84      CBlock(const CBlockHeader &header)
 85      {
 86          SetNull();
 87          *(static_cast<CBlockHeader*>(this)) = header;
 88      }
 89  
 90      SERIALIZE_METHODS(CBlock, obj)
 91      {
 92          READWRITE(AsBase<CBlockHeader>(obj), obj.vtx);
 93      }
 94  
 95      void SetNull()
 96      {
 97          CBlockHeader::SetNull();
 98          vtx.clear();
 99          fChecked = false;
100          m_checked_witness_commitment = false;
101          m_checked_merkle_root = false;
102      }
103  
104      CBlockHeader GetBlockHeader() const
105      {
106          CBlockHeader block;
107          block.nVersion       = nVersion;
108          block.hashPrevBlock  = hashPrevBlock;
109          block.hashMerkleRoot = hashMerkleRoot;
110          block.nTime          = nTime;
111          block.nBits          = nBits;
112          block.nNonce         = nNonce;
113          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      CBlockLocator() = default;
137  
138      explicit CBlockLocator(std::vector<uint256>&& have) : vHave(std::move(have)) {}
139  
140      SERIALIZE_METHODS(CBlockLocator, obj)
141      {
142          int nVersion = DUMMY_VERSION;
143          READWRITE(nVersion);
144          READWRITE(obj.vHave);
145      }
146  
147      void SetNull()
148      {
149          vHave.clear();
150      }
151  
152      bool IsNull() const
153      {
154          return vHave.empty();
155      }
156  };
157  
158  #endif // BITCOIN_PRIMITIVES_BLOCK_H