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