validation.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2011-2013 The PPCoin developers
// Copyright (c) 2013-2014 The NovaCoin Developers
// Copyright (c) 2014-2018 The BlackCoin Developers
// Copyright (c) 2015-2022 The PIVX Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef PIVX_VALIDATION_H
#define PIVX_VALIDATION_H
 
#if defined(HAVE_CONFIG_H)
#include "config/pivx-config.h"
#endif
 
#include "amount.h"
#include "chain.h"
#include "coins.h"
#include "consensus/validation.h"
#include "fs.h"
#include "moneysupply.h"
#include "policy/feerate.h"
#include "script/script_error.h"
#include "sync.h"
#include "txmempool.h"
 
#include <algorithm>
#include <atomic>
#include <exception>
#include <map>
#include <memory>
#include <set>
#include <stdint.h>
#include <string>
#include <utility>
#include <vector>
 
class AccumulatorCache;
class CBlockIndex;
class CBlockTreeDB;
class CBudgetManager;
class CCoinsViewDB;
class CZerocoinDB;
class CSporkDB;
class CBloomFilter;
class CInv;
class CConnman;
class CNode;
class CScriptCheck;
 
struct PrecomputedTransactionData;
 
static const unsigned int DEFAULT_ANCESTOR_LIMIT = 25;
static const unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT = 101;
static const int DEFAULT_BANSCORE_THRESHOLD = 100;
static const bool DEFAULT_PERSIST_MEMPOOL = true;
static const unsigned int DEFAULT_DESCENDANT_LIMIT = 25;
static const unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT = 101;
static const unsigned int DEFAULT_MEMPOOL_EXPIRY = 72;
static const bool DEFAULT_TXINDEX = true;
static const bool DEFAULT_CHECKPOINTS_ENABLED = true;
static const unsigned int MAX_STANDARD_TX_SIZE = 100000;
static const unsigned int MAX_ZEROCOIN_TX_SIZE = 150000;
static const unsigned int MAX_DISCONNECTED_TX_POOL_SIZE = 20000;
static const signed int DEFAULT_CHECKBLOCKS = 6;
static const unsigned int DEFAULT_CHECKLEVEL = 3;
static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB
static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB
static const int MAX_SCRIPTCHECK_THREADS = 16;
static const int DEFAULT_SCRIPTCHECK_THREADS = 0;
static const int MAX_BLOCKS_IN_TRANSIT_PER_PEER = 16;
static const unsigned int BLOCK_STALLING_TIMEOUT = 2;
static const unsigned int MAX_HEADERS_RESULTS = 2000;
static const unsigned int BLOCK_DOWNLOAD_WINDOW = 1024;
static const unsigned int DATABASE_WRITE_INTERVAL = 60 * 60;
static const unsigned int DATABASE_FLUSH_INTERVAL = 24 * 60 * 60;
static constexpr std::chrono::hours AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL{24};
static constexpr std::chrono::seconds AVG_ADDRESS_BROADCAST_INTERVAL{30};
static const unsigned int DEFAULT_SHIELDEDTXFEE_K = 100;
 static const bool DEFAULT_PEERBLOOMFILTERS = true;
static const int64_t DEFAULT_MAX_TIP_AGE = 24 * 60 * 60;
static const int64_t MAX_FEE_ESTIMATION_TIP_AGE = 3 * 60 * 60;
 
struct BlockHasher {
    size_t operator()(const uint256& hash) const { return hash.GetCheapHash(); }
};
 
extern CScript COINBASE_FLAGS;
extern RecursiveMutex cs_main;
extern CTxMemPool mempool;
typedef std::unordered_map<uint256, CBlockIndex*, BlockHasher> BlockMap;
typedef std::unordered_multimap<uint256, CBlockIndex*, BlockHasher> PrevBlockMap;
extern BlockMap mapBlockIndex;
extern PrevBlockMap mapPrevBlockIndex;
extern uint64_t nLastBlockTx;
extern uint64_t nLastBlockSize;
 
// Best block section
extern Mutex g_best_block_mutex;
extern std::condition_variable g_best_block_cv;
extern uint256 g_best_block;
extern int64_t g_best_block_time;
 
extern std::atomic<bool> fImporting;
extern std::atomic<bool> fReindex;
extern int nScriptCheckThreads;
extern bool fTxIndex;
extern bool fRequireStandard;
extern bool fCheckBlockIndex;
extern size_t nCoinCacheUsage;
extern CFeeRate minRelayTxFee;
extern int64_t nMaxTipAge;
 
extern bool fLargeWorkForkFound;
extern bool fLargeWorkInvalidChainFound;
 
extern std::map<uint256, int64_t> mapRejectedBlocks;
 
extern CMoneySupply MoneySupply;
 
extern CBlockIndex* pindexBestHeader;
 
bool ProcessNewBlock(const std::shared_ptr<const CBlock>& pblock, const FlatFilePos* dbp);
 
FILE* OpenBlockFile(const FlatFilePos& pos, bool fReadOnly = false);
FILE* OpenUndoFile(const FlatFilePos& pos, bool fReadOnly = false);
fs::path GetBlockPosFilename(const FlatFilePos &pos);
bool LoadExternalBlockFile(FILE* fileIn, FlatFilePos* dbp = nullptr);
bool LoadGenesisBlock();
bool LoadBlockIndex(std::string& strError) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
bool LoadChainTip(const CChainParams& chainparams) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
void UnloadBlockIndex();
int ActiveProtocol();
void ThreadScriptCheck();
 
bool IsInitialBlockDownload();
bool GetTransaction(const uint256& hash, CTransactionRef& tx, uint256& hashBlock, bool fAllowSlow = false, CBlockIndex* blockIndex = nullptr);
bool GetOutput(const uint256& hash, unsigned int index, CValidationState& state, CTxOut& out);
 
double ConvertBitsToDouble(unsigned int nBits);
int64_t GetMasternodePayment(int nHeight);
 
bool ActivateBestChain(CValidationState& state, std::shared_ptr<const CBlock> pblock = std::shared_ptr<const CBlock>());
CAmount GetBlockValue(int nHeight);
 
CBlockIndex* InsertBlockIndex(const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
void FlushStateToDisk();
 
 
bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState& state, const CTransactionRef& tx, bool fLimitFree,
                        bool* pfMissingInputs, bool fOverrideMempoolLimit = false,
                        bool fRejectInsaneFee = false, bool ignoreFees = false) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
bool AcceptToMemoryPoolWithTime(CTxMemPool& pool, CValidationState &state, const CTransactionRef &tx, bool fLimitFree,
                                bool* pfMissingInputs, int64_t nAcceptTime, bool fOverrideMempoolLimit = false,
                                bool fRejectInsaneFee = false, bool ignoreFees = false) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
CAmount GetMinRelayFee(const CTransaction& tx, const CTxMemPool& pool, unsigned int nBytes);
CAmount GetMinRelayFee(unsigned int nBytes);
CAmount GetShieldedTxMinFee(const CTransaction& tx);
 
bool CheckInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& view, bool fScriptChecks, unsigned int flags, bool cacheStore, PrecomputedTransactionData& precomTxData, std::vector<CScriptCheck>* pvChecks = nullptr);
 
void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, int nHeight, bool fSkipInvalid = false);
 
bool CheckFinalTx(const CTransactionRef& tx, int flags = -1);
 
 
class CScriptCheck
{
private:
    CTxOut m_tx_out;
    const CTransaction* ptxTo;
    unsigned int nIn;
    unsigned int nFlags;
    bool cacheStore;
    ScriptError error;
    PrecomputedTransactionData *precomTxData;
 
public:
    CScriptCheck() : ptxTo(0), nIn(0), nFlags(0), cacheStore(false), error(SCRIPT_ERR_UNKNOWN_ERROR), precomTxData(nullptr) {}
    CScriptCheck(const CTxOut& outIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, bool cacheIn, PrecomputedTransactionData* cachedHashesIn) :
        m_tx_out(outIn),
        ptxTo(&txToIn),
        nIn(nInIn),
        nFlags(nFlagsIn),
        cacheStore(cacheIn),
        error(SCRIPT_ERR_UNKNOWN_ERROR),
        precomTxData(cachedHashesIn) {}
 
    bool operator()();
 
    void swap(CScriptCheck& check)
    {
        std::swap(ptxTo, check.ptxTo);
        std::swap(m_tx_out, check.m_tx_out);
        std::swap(nIn, check.nIn);
        std::swap(nFlags, check.nFlags);
        std::swap(cacheStore, check.cacheStore);
        std::swap(error, check.error);
        std::swap(precomTxData, check.precomTxData);
    }
 
    ScriptError GetScriptError() const { return error; }
};
 
 
bool WriteBlockToDisk(const CBlock& block, FlatFilePos& pos);
bool ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos);
bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex);
 
 
bool CheckBlock(const CBlock& block, CValidationState& state, bool fCheckPOW = true, bool fCheckMerkleRoot = true, bool fCheckSig = true) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
bool CheckWork(const CBlock& block, const CBlockIndex* const pindexPrev);
 
bool ContextualCheckBlockHeader(const CBlockHeader& block, CValidationState& state, CBlockIndex* pindexPrev) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
bool ContextualCheckBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindexPrev);
 
bool TestBlockValidity(CValidationState& state, const CBlock& block, CBlockIndex* pindexPrev, bool fCheckPOW = true, bool fCheckMerkleRoot = true, bool fCheckBlockSig = true) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
bool AcceptBlockHeader(const CBlock& block, CValidationState& state, CBlockIndex** ppindex = nullptr, CBlockIndex* pindexPrev = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
 
class CVerifyDB
{
public:
    CVerifyDB();
    ~CVerifyDB();
    bool VerifyDB(CCoinsView* coinsview, int nCheckLevel, int nCheckDepth);
};
 
bool ReplayBlocks(const CChainParams& params, CCoinsView* view);
 
inline CBlockIndex* LookupBlockIndex(const uint256& hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
{
    AssertLockHeld(cs_main);
    BlockMap::const_iterator it = mapBlockIndex.find(hash);
    return it == mapBlockIndex.end() ? nullptr : it->second;
}
 
CBlockIndex* FindForkInGlobalIndex(const CChain& chain, const CBlockLocator& locator) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
bool InvalidateBlock(CValidationState& state, const CChainParams& chainparams, CBlockIndex* pindex) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
bool ReconsiderBlock(CValidationState& state, CBlockIndex* pindex);
 
extern CChain chainActive;
 
extern std::unique_ptr<CCoinsViewDB> pcoinsdbview;
 
extern std::unique_ptr<CCoinsViewCache> pcoinsTip;
 
extern std::unique_ptr<CBlockTreeDB> pblocktree;
 
extern std::unique_ptr<CZerocoinDB> zerocoinDB;
 
extern std::unique_ptr<AccumulatorCache> accumulatorCache;
 
extern std::unique_ptr<CSporkDB> pSporkDB;
 
CBlockIndex* GetChainTip();
 
int GetSpendHeight(const CCoinsViewCache& inputs);
 
static const unsigned int REJECT_INTERNAL = 0x100;
static const unsigned int REJECT_HIGHFEE = 0x100;
static const unsigned int REJECT_ALREADY_KNOWN = 0x101;
static const unsigned int REJECT_CONFLICT = 0x102;
 
CBlockFileInfo* GetBlockFileInfo(size_t n);
 
bool DumpMempool(const CTxMemPool& pool);
 
bool LoadMempool(CTxMemPool& pool);
 
#endif // PIVX_VALIDATION_H