src/primitives/block.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2013 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
  13 /** Nodes collect new transactions into a block, hash them into a hash tree,
  14  * and scan through nonce values to make the block's hash satisfy proof-of-work
  15  * requirements.  When they solve the proof-of-work, they broadcast the block
  16  * to everyone and the block is added to the block chain.  The first transaction
  17  * in the block is a special one that creates a new coin owned by the creator
  18  * of the block.
  19  */
  20 class CBlockHeader
  21 {
  22 public:
  23     // header
  24     static const int32_t CURRENT_VERSION=4;
  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     ADD_SERIALIZE_METHODS;
  38
  39     template <typename Stream, typename Operation>
  40     inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
  41         READWRITE(this->nVersion);
  42         nVersion = this->nVersion;
  43         READWRITE(hashPrevBlock);
  44         READWRITE(hashMerkleRoot);
  45         READWRITE(nTime);
  46         READWRITE(nBits);
  47         READWRITE(nNonce);
  48     }
  49
  50     void SetNull()
  51     {
  52         nVersion = CBlockHeader::CURRENT_VERSION;
  53         hashPrevBlock.SetNull();
  54         hashMerkleRoot.SetNull();
  55         nTime = 0;
  56         nBits = 0;
  57         nNonce = 0;
  58     }
  59
  60     bool IsNull() const
  61     {
  62         return (nBits == 0);
  63     }
  64
  65     uint256 GetHash() const;
  66
  67     int64_t GetBlockTime() const
  68     {
  69         return (int64_t)nTime;
  70     }
  71 };
  72
  73
  74 class CBlock : public CBlockHeader
  75 {
  76 public:
  77     // network and disk
  78     std::vector<CTransaction> vtx;
  79
  80     // memory only
  81     mutable bool fChecked;
  82
  83     CBlock()
  84     {
  85         SetNull();
  86     }
  87
  88     CBlock(const CBlockHeader &header)
  89     {
  90         SetNull();
  91         *((CBlockHeader*)this) = header;
  92     }
  93
  94     ADD_SERIALIZE_METHODS;
  95
  96     template <typename Stream, typename Operation>
  97     inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
  98         READWRITE(*(CBlockHeader*)this);
  99         READWRITE(vtx);
 100     }
 101
 102     void SetNull()
 103     {
 104         CBlockHeader::SetNull();
 105         vtx.clear();
 106         fChecked = false;
 107     }
 108
 109     CBlockHeader GetBlockHeader() const
 110     {
 111         CBlockHeader block;
 112         block.nVersion       = nVersion;
 113         block.hashPrevBlock  = hashPrevBlock;
 114         block.hashMerkleRoot = hashMerkleRoot;
 115         block.nTime          = nTime;
 116         block.nBits          = nBits;
 117         block.nNonce         = nNonce;
 118         return block;
 119     }
 120
 121     std::string ToString() const;
 122 };
 123
 124
 125 /** Describes a place in the block chain to another node such that if the
 126  * other node doesn't have the same branch, it can find a recent common trunk.
 127  * The further back it is, the further before the fork it may be.
 128  */
 129 struct CBlockLocator
 130 {
 131     std::vector<uint256> vHave;
 132
 133     CBlockLocator() {}
 134
 135     CBlockLocator(const std::vector<uint256>& vHaveIn)
 136     {
 137         vHave = vHaveIn;
 138     }
 139
 140     ADD_SERIALIZE_METHODS;
 141
 142     template <typename Stream, typename Operation>
 143     inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
 144         if (!(nType & SER_GETHASH))
 145             READWRITE(nVersion);
 146         READWRITE(vHave);
 147     }
 148
 149     void SetNull()
 150     {
 151         vHave.clear();
 152     }
 153
 154     bool IsNull() const
 155     {
 156         return vHave.empty();
 157     }
 158 };
 159
 160 #endif // BITCOIN_PRIMITIVES_BLOCK_H