/root/bitcoin/src/primitives/block.h

Source (jump to first uncovered line)
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2022 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#ifndef BITCOIN_PRIMITIVES_BLOCK_H
#define BITCOIN_PRIMITIVES_BLOCK_H

#include <primitives/transaction.h>
#include <serialize.h>
#include <uint256.h>
#include <util/time.h>

/** Nodes collect new transactions into a block, hash them into a hash tree,
 * and scan through nonce values to make the block's hash satisfy proof-of-work
 * requirements.  When they solve the proof-of-work, they broadcast the block
 * to everyone and the block is added to the block chain.  The first transaction
 * in the block is a special one that creates a new coin owned by the creator
 * of the block.
 */
class CBlockHeader
{
public:
    // header
    int32_t nVersion;
    uint256 hashPrevBlock;
    uint256 hashMerkleRoot;
    uint32_t nTime;
    uint32_t nBits;
    uint32_t nNonce;

    CBlockHeader()
    {
        SetNull();
    }

    SERIALIZE_METHODS(CBlockHeader, obj) { READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce); }

    void SetNull()
    {
        nVersion = 0;
        hashPrevBlock.SetNull();
        hashMerkleRoot.SetNull();
        nTime = 0;
        nBits = 0;
        nNonce = 0;
    }

    bool IsNull() const
    {
        return (nBits == 0);
    }

    uint256 GetHash() const;

    NodeSeconds Time() const
    {
        return NodeSeconds{std::chrono::seconds{nTime}};
    }

    int64_t GetBlockTime() const
    {
        return (int64_t)nTime;
    }
};


class CBlock : public CBlockHeader
{
public:
    // network and disk
    std::vector<CTransactionRef> vtx;

    // Memory-only flags for caching expensive checks
    mutable bool fChecked;                            // CheckBlock()
    mutable bool m_checked_witness_commitment{false}; // CheckWitnessCommitment()
    mutable bool m_checked_merkle_root{false};        // CheckMerkleRoot()

    CBlock()
    {
        SetNull();
    }

    CBlock(const CBlockHeader &header)
    {
        SetNull();
        *(static_cast<CBlockHeader*>(this)) = header;
    }

    SERIALIZE_METHODS(CBlock, obj)
    {
        READWRITE(AsBase<CBlockHeader>(obj), obj.vtx);
    }

    void SetNull()
    {
        CBlockHeader::SetNull();
        vtx.clear();
        fChecked = false;
        m_checked_witness_commitment = false;
        m_checked_merkle_root = false;
    }

    CBlockHeader GetBlockHeader() const
    {
        CBlockHeader block;
        block.nVersion       = nVersion;
        block.hashPrevBlock  = hashPrevBlock;
        block.hashMerkleRoot = hashMerkleRoot;
        block.nTime          = nTime;
        block.nBits          = nBits;
        block.nNonce         = nNonce;
        return block;
    }

    std::string ToString() const;
};

/** Describes a place in the block chain to another node such that if the
 * other node doesn't have the same branch, it can find a recent common trunk.
 * The further back it is, the further before the fork it may be.
 */
struct CBlockLocator
{
    /** Historically CBlockLocator's version field has been written to network
     * streams as the negotiated protocol version and to disk streams as the
     * client version, but the value has never been used.
     *
     * Hard-code to the highest protocol version ever written to a network stream.
     * SerParams can be used if the field requires any meaning in the future,
     **/
    static constexpr int DUMMY_VERSION = 70016;

    std::vector<uint256> vHave;

    CBlockLocator() = default;

    explicit CBlockLocator(std::vector<uint256>&& have) : vHave(std::move(have)) {}

    SERIALIZE_METHODS(CBlockLocator, obj)
    {
        int nVersion = DUMMY_VERSION;
        READWRITE(nVersion);
        READWRITE(obj.vHave);
    }

    void SetNull()
    {
        vHave.clear();
    }

    bool IsNull() const
    {
        return vHave.empty();
    }
};

#endif // BITCOIN_PRIMITIVES_BLOCK_H

Line	Count	Source (jump to first uncovered line)
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	14.1k	{
34	14.1k	SetNull();
35	14.1k	}
36
37	0	SERIALIZE_METHODS(CBlockHeader, obj) { READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce); } Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI10DataStreamKS_15ActionSerializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI12ParamsStreamIR12VectorWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI12SizeComputerKS_15ActionSerializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI12VectorWriterKS_15ActionSerializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI12ParamsStreamIR8AutoFile20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI12ParamsStreamIR8AutoFile20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI12BufferedFileS_17ActionUnserializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI12ParamsStreamIR12BufferedFile20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI8AutoFileS_17ActionUnserializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN12CBlockHeader16SerializationOpsI10HashWriterKS_15ActionSerializeEEvRT0_RT_T1_
38
39		void SetNull()
40	28.2k	{
41	28.2k	nVersion = 0;
42	28.2k	hashPrevBlock.SetNull();
43	28.2k	hashMerkleRoot.SetNull();
44	28.2k	nTime = 0;
45	28.2k	nBits = 0;
46	28.2k	nNonce = 0;
47	28.2k	}
48
49		bool IsNull() const
50	0	{
51	0	return (nBits == 0);
52	0	}
53
54		uint256 GetHash() const;
55
56		NodeSeconds Time() const
57	0	{
58	0	return NodeSeconds{std::chrono::seconds{nTime}};
59	0	}
60
61		int64_t GetBlockTime() const
62	0	{
63	0	return (int64_t)nTime;
64	0	}
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	14.1k	{
81	14.1k	SetNull();
82	14.1k	}
83
84		CBlock(const CBlockHeader &header)
85	0	{
86	0	SetNull();
87	0	(static_cast<CBlockHeader>(this)) = header;
88	0	}
89
90		SERIALIZE_METHODS(CBlock, obj)
91	0	{
92	0	READWRITE(AsBase<CBlockHeader>(obj), obj.vtx);
93	0	} Unexecuted instantiation: _ZN6CBlock16SerializationOpsI12ParamsStreamIR12SizeComputer20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN6CBlock16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN6CBlock16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN6CBlock16SerializationOpsI12ParamsStreamIR12VectorWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN6CBlock16SerializationOpsI12ParamsStreamIR8AutoFile20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN6CBlock16SerializationOpsI12ParamsStreamIR8AutoFile20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN6CBlock16SerializationOpsI12ParamsStreamIR12BufferedFile20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_
94
95		void SetNull()
96	14.1k	{
97	14.1k	CBlockHeader::SetNull();
98	14.1k	vtx.clear();
99	14.1k	fChecked = false;
100	14.1k	m_checked_witness_commitment = false;
101	14.1k	m_checked_merkle_root = false;
102	14.1k	}
103
104		CBlockHeader GetBlockHeader() const
105	0	{
106	0	CBlockHeader block;
107	0	block.nVersion = nVersion;
108	0	block.hashPrevBlock = hashPrevBlock;
109	0	block.hashMerkleRoot = hashMerkleRoot;
110	0	block.nTime = nTime;
111	0	block.nBits = nBits;
112	0	block.nNonce = nNonce;
113	0	return block;
114	0	}
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	0	CBlockLocator() = default;
137
138	0	explicit CBlockLocator(std::vector<uint256>&& have) : vHave(std::move(have)) {}
139
140		SERIALIZE_METHODS(CBlockLocator, obj)
141	0	{
142	0	int nVersion = DUMMY_VERSION;
143	0	READWRITE(nVersion);
144	0	READWRITE(obj.vHave);
145	0	} Unexecuted instantiation: _ZN13CBlockLocator16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN13CBlockLocator16SerializationOpsI10DataStreamKS_15ActionSerializeEEvRT0_RT_T1_ Unexecuted instantiation: _ZN13CBlockLocator16SerializationOpsI12VectorWriterKS_15ActionSerializeEEvRT0_RT_T1_
146
147		void SetNull()
148	0	{
149	0	vHave.clear();
150	0	}
151
152		bool IsNull() const
153	0	{
154	0	return vHave.empty();
155	0	}
156		};
157
158		#endif // BITCOIN_PRIMITIVES_BLOCK_H

Coverage Report

Created: 2024-10-29 12:15