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 */
26class CBlockHeader
27{
28public:
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
73class CBlock : public CBlockHeader
74{
75public:
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 */
116struct 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