blockindex.h

Go to the documentation of this file.

// Copyright (c) 2009-2020 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_BLOCKINDEX_H
#define BITCOIN_BLOCKINDEX_H
 
#include <arith_uint256.h>
#include <blockstatus.h>
#include <flatfile.h>
#include <kernel/cs_main.h>
#include <primitives/block.h>
#include <sync.h>
#include <uint256.h>
#include <util/time.h>
 
struct BlockHash;
 
class CBlockIndex {
public:
    const BlockHash *phashBlock{nullptr};
 
    CBlockIndex *pprev{nullptr};
 
    CBlockIndex *pskip{nullptr};
 
    int nHeight{0};
 
    int nFile GUARDED_BY(::cs_main){0};
 
    unsigned int nDataPos GUARDED_BY(::cs_main){0};
 
    unsigned int nUndoPos GUARDED_BY(::cs_main){0};
 
    arith_uint256 nChainWork{};
 
    unsigned int nTx{0};
 
    unsigned int nSize{0};
 
    unsigned int nChainTx{0};
 
private:
    uint64_t nChainSize{0};
 
public:
    BlockStatus nStatus GUARDED_BY(::cs_main){};
 
    int32_t nVersion{0};
    uint256 hashMerkleRoot{};
    uint32_t nTime{0};
    uint32_t nBits{0};
    uint32_t nNonce{0};
 
    int32_t nSequenceId{0};
 
    uint64_t nTimeReceived{0};
 
    unsigned int nTimeMax{0};
 
    explicit CBlockIndex() = default;
 
    explicit CBlockIndex(const CBlockHeader &block)
        : nVersion{block.nVersion}, hashMerkleRoot{block.hashMerkleRoot},
          nTime{block.nTime}, nBits{block.nBits}, nNonce{block.nNonce},
          nTimeReceived{0} {}
 
    FlatFilePos GetBlockPos() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        AssertLockHeld(::cs_main);
        FlatFilePos ret;
        if (nStatus.hasData()) {
            ret.nFile = nFile;
            ret.nPos = nDataPos;
        }
        return ret;
    }
 
    FlatFilePos GetUndoPos() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        AssertLockHeld(::cs_main);
        FlatFilePos ret;
        if (nStatus.hasUndo()) {
            ret.nFile = nFile;
            ret.nPos = nUndoPos;
        }
        return ret;
    }
 
    CBlockHeader GetBlockHeader() const {
        CBlockHeader block;
        block.nVersion = nVersion;
        if (pprev) {
            block.hashPrevBlock = pprev->GetBlockHash();
        }
        block.hashMerkleRoot = hashMerkleRoot;
        block.nTime = nTime;
        block.nBits = nBits;
        block.nNonce = nNonce;
        return block;
    }
 
    BlockHash GetBlockHash() const {
        assert(phashBlock != nullptr);
        return *phashBlock;
    }
 
    int64_t GetChainTxCount() const { return nChainTx; }
 
    uint64_t GetChainSize() const { return nChainSize; }
 
    bool UpdateChainStats();
 
    bool HaveTxsDownloaded() const { return GetChainTxCount() != 0; }
 
    NodeSeconds Time() const {
        return NodeSeconds{std::chrono::seconds{nTime}};
    }
 
    int64_t GetBlockTime() const { return int64_t(nTime); }
 
    int64_t GetBlockTimeMax() const { return int64_t(nTimeMax); }
 
    int64_t GetHeaderReceivedTime() const { return nTimeReceived; }
 
    int64_t GetReceivedTimeDiff() const {
        return GetHeaderReceivedTime() - GetBlockTime();
    }
 
    static constexpr int nMedianTimeSpan = 11;
 
    int64_t GetMedianTimePast() const {
        int64_t pmedian[nMedianTimeSpan];
        int64_t *pbegin = &pmedian[nMedianTimeSpan];
        int64_t *pend = &pmedian[nMedianTimeSpan];
 
        const CBlockIndex *pindex = this;
        for (int i = 0; i < nMedianTimeSpan && pindex;
             i++, pindex = pindex->pprev) {
            *(--pbegin) = pindex->GetBlockTime();
        }
 
        std::sort(pbegin, pend);
        return pbegin[(pend - pbegin) / 2];
    }
 
    std::string ToString() const;
 
    bool IsValid(enum BlockValidity nUpTo = BlockValidity::TRANSACTIONS) const
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        AssertLockHeld(::cs_main);
        return nStatus.isValid(nUpTo);
    }
 
    bool IsAssumedValid() const EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        AssertLockHeld(::cs_main);
        return nStatus.isAssumedValid();
    }
 
    bool RaiseValidity(enum BlockValidity nUpTo)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
        AssertLockHeld(::cs_main);
        // Only validity flags allowed.
        if (nStatus.isInvalid()) {
            return false;
        }
 
        if (nStatus.getValidity() >= nUpTo) {
            return false;
        }
 
        // If this block had been marked assumed-valid and we're raising
        // its validity to a certain point, there is no longer an assumption.
        if (IsAssumedValid() && nUpTo >= BlockValidity::SCRIPTS) {
            nStatus = nStatus.withClearedAssumedValidFlags();
        }
 
        nStatus = nStatus.withValidity(nUpTo);
        return true;
    }
 
    void BuildSkip();
 
    CBlockIndex *GetAncestor(int height);
    const CBlockIndex *GetAncestor(int height) const;
};
 
#endif // BITCOIN_BLOCKINDEX_H