block.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2013 The Bitcoin developers
// Copyright (c) 2015-2021 The PIVX Core developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef PIVX_PRIMITIVES_BLOCK_H
#define PIVX_PRIMITIVES_BLOCK_H
 
#include "primitives/transaction.h"
#include "keystore.h"
#include "serialize.h"
#include "uint256.h"
 
class CBlockHeader
{
public:
    // header
    static const int32_t CURRENT_VERSION=11;    // since v5.2.99
    int32_t nVersion;
    uint256 hashPrevBlock;
    uint256 hashMerkleRoot;
    uint32_t nTime;
    uint32_t nBits;
    uint32_t nNonce;
    uint256 nAccumulatorCheckpoint;             // only for version 4, 5 and 6.
    uint256 hashFinalSaplingRoot;               // only for version 8+
 
    CBlockHeader()
    {
        SetNull();
    }
 
    SERIALIZE_METHODS(CBlockHeader, obj) {
        READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce);
 
        //zerocoin active, header changes to include accumulator checksum
        if(obj.nVersion > 3 && obj.nVersion < 7)
            READWRITE(obj.nAccumulatorCheckpoint);
 
        // Sapling active
        if (obj.nVersion >= 8)
            READWRITE(obj.hashFinalSaplingRoot);
    }
 
    void SetNull()
    {
        nVersion = CBlockHeader::CURRENT_VERSION;
        hashPrevBlock.SetNull();
        hashMerkleRoot.SetNull();
        nTime = 0;
        nBits = 0;
        nNonce = 0;
        nAccumulatorCheckpoint.SetNull();
        hashFinalSaplingRoot.SetNull();
    }
 
    bool IsNull() const
    {
        return (nBits == 0);
    }
 
    uint256 GetHash() const;
 
    int64_t GetBlockTime() const
    {
        return (int64_t)nTime;
    }
};
 
 
class CBlock : public CBlockHeader
{
public:
    // network and disk
    std::vector<CTransactionRef> vtx;
 
    // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
    std::vector<unsigned char> vchBlockSig;
 
    // memory only
    mutable bool fChecked{false};
 
    CBlock()
    {
        SetNull();
    }
 
    CBlock(const CBlockHeader &header)
    {
        SetNull();
        *(static_cast<CBlockHeader*>(this)) = header;
    }
 
    SERIALIZE_METHODS(CBlock, obj)
    {
        READWRITEAS(CBlockHeader, obj);
        READWRITE(obj.vtx);
        if(obj.vtx.size() > 1 && obj.vtx[1]->IsCoinStake())
            READWRITE(obj.vchBlockSig);
    }
 
    void SetNull()
    {
        CBlockHeader::SetNull();
        vtx.clear();
        fChecked = false;
        vchBlockSig.clear();
    }
 
    CBlockHeader GetBlockHeader() const
    {
        CBlockHeader block;
        block.nVersion       = nVersion;
        block.hashPrevBlock  = hashPrevBlock;
        block.hashMerkleRoot = hashMerkleRoot;
        block.nTime          = nTime;
        block.nBits          = nBits;
        block.nNonce         = nNonce;
        if(nVersion > 3 && nVersion < 7)
            block.nAccumulatorCheckpoint = nAccumulatorCheckpoint;
        if (nVersion >= 8)
            block.hashFinalSaplingRoot   = hashFinalSaplingRoot;
        return block;
    }
 
    bool IsProofOfStake() const
    {
        return (vtx.size() > 1 && vtx[1]->IsCoinStake());
    }
 
    bool IsProofOfWork() const
    {
        return !IsProofOfStake();
    }
 
    std::string ToString() const;
    void print() const;
};
 
 
struct CBlockLocator
{
    std::vector<uint256> vHave;
 
    CBlockLocator() {}
 
    explicit CBlockLocator(const std::vector<uint256>& vHaveIn)
    {
        vHave = vHaveIn;
    }
 
    SERIALIZE_METHODS(CBlockLocator, obj)
    {
        int nVersion = s.GetVersion();
        if (!(s.GetType() & SER_GETHASH))
            READWRITE(nVersion);
        READWRITE(obj.vHave);
    }
 
    void SetNull()
    {
        vHave.clear();
    }
 
    bool IsNull() const
    {
        return vHave.empty();
    }
};
 
#endif // PIVX_PRIMITIVES_BLOCK_H