BitCoin

Calculate the number of blocks per four year cycle:
6 blocks per hour (every 10 minutes)
* 24 hours per day
* 365 days per year
* 4 years per cycle
= 210,240
round to 210,000
Sum all the block reward sizes, as they "halve":
50 + 25 + 12.5 + 6.25 + 3.125 + … = 100
Multiply the two:
210,000 * 100 = 21 million.

// Copyright (c) 2009-2010 Satoshi Nakamoto

// Copyright (c) 2009-2020 The Bitcoin Core developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <validation.h>

#include <arith_uint256.h>

#include <chain.h>

#include <chainparams.h>

#include <checkqueue.h>

#include <consensus/consensus.h>

#include <consensus/merkle.h>

#include <consensus/tx_check.h>

#include <consensus/tx_verify.h>

#include <consensus/validation.h>

#include <cuckoocache.h>

#include <flatfile.h>

#include <hash.h>

#include <index/txindex.h>

#include <logging.h>

#include <logging/timer.h>

#include <node/ui_interface.h>

#include <optional.h>

#include <policy/policy.h>

#include <policy/settings.h>

#include <pow.h>

#include <primitives/block.h>

#include <primitives/transaction.h>

#include <random.h>

#include <reverse_iterator.h>

#include <script/script.h>

#include <script/sigcache.h>

#include <shutdown.h>

#include <signet.h>

#include <timedata.h>

#include <tinyformat.h>

#include <txdb.h>

#include <txmempool.h>

#include <uint256.h>

#include <undo.h>

#include <util/check.h> // For NDEBUG compile time check

#include <util/moneystr.h>

#include <util/rbf.h>

#include <util/strencodings.h>

#include <util/system.h>

#include <util/translation.h>

#include <validationinterface.h>

#include <warnings.h>

#include <string>

#include <boost/algorithm/string/replace.hpp>

#define MICRO 0.000001

#define MILLI 0.001

/**

* An extra transaction can be added to a package, as long as it only has one

* ancestor and is no larger than this. Not really any reason to make this

* configurable as it doesn't materially change DoS parameters.

*/

static const unsigned int EXTRA_DESCENDANT_TX_SIZE_LIMIT = 10000;

/** Maximum kilobytes for transactions to store for processing during reorg */

static const unsigned int MAX_DISCONNECTED_TX_POOL_SIZE = 20000;

/** The pre-allocation chunk size for blk?????.dat files (since 0.8) */

static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB

/** The pre-allocation chunk size for rev?????.dat files (since 0.8) */

static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB

/** Time to wait between writing blocks/block index to disk. */

static constexpr std::chrono::hours DATABASE_WRITE_INTERVAL{1};

/** Time to wait between flushing chainstate to disk. */

static constexpr std::chrono::hours DATABASE_FLUSH_INTERVAL{24};

/** Maximum age of our tip for us to be considered current for fee estimation */

static constexpr std::chrono::hours MAX_FEE_ESTIMATION_TIP_AGE{3};

const std::vector<std::string> CHECKLEVEL_DOC {

"level 0 reads the blocks from disk",

"level 1 verifies block validity",

"level 2 verifies undo data",

"level 3 checks disconnection of tip blocks",

"level 4 tries to reconnect the blocks",

"each level includes the checks of the previous levels",

};

bool CBlockIndexWorkComparator::operator()(const CBlockIndex *pa, const CBlockIndex *pb) const {

// First sort by most total work, ...

if (pa->nChainWork > pb->nChainWork) return false;

if (pa->nChainWork < pb->nChainWork) return true;

// ... then by earliest time received, ...

if (pa->nSequenceId < pb->nSequenceId) return false;

if (pa->nSequenceId > pb->nSequenceId) return true;

// Use pointer address as tie breaker (should only happen with blocks

// loaded from disk, as those all have id 0).

if (pa < pb) return false;

if (pa > pb) return true;

// Identical blocks.

return false;

}

ChainstateManager g_chainman;

CChainState& ChainstateActive()

{

LOCK(::cs_main);

assert(g_chainman.m_active_chainstate);

return *g_chainman.m_active_chainstate;

}

CChain& ChainActive()

{

LOCK(::cs_main);

return ::ChainstateActive().m_chain;

}

/**

* Mutex to guard access to validation specific variables, such as reading

* or changing the chainstate.

*

* This may also need to be locked when updating the transaction pool, e.g. on

* AcceptToMemoryPool. See CTxMemPool::cs comment for details.

*

* The transaction pool has a separate lock to allow reading from it and the

* chainstate at the same time.

*/

RecursiveMutex cs_main;

CBlockIndex *pindexBestHeader = nullptr;

Mutex g_best_block_mutex;

std::condition_variable g_best_block_cv;

uint256 g_best_block;

bool g_parallel_script_checks{false};

std::atomic_bool fImporting(false);

std::atomic_bool fReindex(false);

bool fHavePruned = false;

bool fPruneMode = false;

bool fRequireStandard = true;

bool fCheckBlockIndex = false;

bool fCheckpointsEnabled = DEFAULT_CHECKPOINTS_ENABLED;

uint64_t nPruneTarget = 0;

int64_t nMaxTipAge = DEFAULT_MAX_TIP_AGE;

uint256 hashAssumeValid;

arith_uint256 nMinimumChainWork;

CFeeRate minRelayTxFee = CFeeRate(DEFAULT_MIN_RELAY_TX_FEE);

// Internal stuff

namespace {

CBlockIndex* pindexBestInvalid = nullptr;

RecursiveMutex cs_LastBlockFile;

std::vector<CBlockFileInfo> vinfoBlockFile;

int nLastBlockFile = 0;

/** Global flag to indicate we should check to see if there are

* block/undo files that should be deleted. Set on startup

* or if we allocate more file space when we're in prune mode

*/

bool fCheckForPruning = false;

/** Dirty block index entries. */

std::set<CBlockIndex*> setDirtyBlockIndex;

/** Dirty block file entries. */

std::set<int> setDirtyFileInfo;

} // anon namespace

CBlockIndex* LookupBlockIndex(const uint256& hash)

{

AssertLockHeld(cs_main);

BlockMap::const_iterator it = g_chainman.BlockIndex().find(hash);

return it == g_chainman.BlockIndex().end() ? nullptr : it->second;

}

CBlockIndex* FindForkInGlobalIndex(const CChain& chain, const CBlockLocator& locator)

{

AssertLockHeld(cs_main);

// Find the latest block common to locator and chain - we expect that

// locator.vHave is sorted descending by height.

for (const uint256& hash : locator.vHave) {

CBlockIndex* pindex = LookupBlockIndex(hash);

if (pindex) {

if (chain.Contains(pindex))

return pindex;

if (pindex->GetAncestor(chain.Height()) == chain.Tip()) {

return chain.Tip();

}

}

}

return chain.Genesis();

}

std::unique_ptr<CBlockTreeDB> pblocktree;

bool CheckInputScripts(const CTransaction& tx, TxValidationState &state, const CCoinsViewCache &inputs, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData& txdata, std::vector<CScriptCheck> *pvChecks = nullptr);

static FILE* OpenUndoFile(const FlatFilePos &pos, bool fReadOnly = false);

static FlatFileSeq BlockFileSeq();

static FlatFileSeq UndoFileSeq();

bool CheckFinalTx(const CTransaction &tx, int flags)

{

AssertLockHeld(cs_main);

// By convention a negative value for flags indicates that the

// current network-enforced consensus rules should be used. In

// a future soft-fork scenario that would mean checking which

// rules would be enforced for the next block and setting the

// appropriate flags. At the present time no soft-forks are

// scheduled, so no flags are set.

flags = std::max(flags, 0);

// CheckFinalTx() uses ::ChainActive().Height()+1 to evaluate

// nLockTime because when IsFinalTx() is called within

// CBlock::AcceptBlock(), the height of the block *being*

// evaluated is what is used. Thus if we want to know if a

// transaction can be part of the *next* block, we need to call

// IsFinalTx() with one more than ::ChainActive().Height().

const int nBlockHeight = ::ChainActive().Height() + 1;

// BIP113 requires that time-locked transactions have nLockTime set to

// less than the median time of the previous block they're contained in.

// When the next block is created its previous block will be the current

// chain tip, so we use that to calculate the median time passed to

// IsFinalTx() if LOCKTIME_MEDIAN_TIME_PAST is set.

const int64_t nBlockTime = (flags & LOCKTIME_MEDIAN_TIME_PAST)

? ::ChainActive().Tip()->GetMedianTimePast()

: GetAdjustedTime();

return IsFinalTx(tx, nBlockHeight, nBlockTime);

}

bool TestLockPointValidity(const LockPoints* lp)

{

AssertLockHeld(cs_main);

assert(lp);

// If there are relative lock times then the maxInputBlock will be set

// If there are no relative lock times, the LockPoints don't depend on the chain

if (lp->maxInputBlock) {

// Check whether ::ChainActive() is an extension of the block at which the LockPoints

// calculation was valid. If not LockPoints are no longer valid

if (!::ChainActive().Contains(lp->maxInputBlock)) {

return false;

}

}

// LockPoints still valid

return true;

}

bool CheckSequenceLocks(const CTxMemPool& pool, const CTransaction& tx, int flags, LockPoints* lp, bool useExistingLockPoints)

{

AssertLockHeld(cs_main);

AssertLockHeld(pool.cs);

CBlockIndex* tip = ::ChainActive().Tip();

assert(tip != nullptr);

CBlockIndex index;

index.pprev = tip;

// CheckSequenceLocks() uses ::ChainActive().Height()+1 to evaluate

// height based locks because when SequenceLocks() is called within

// ConnectBlock(), the height of the block *being*

// evaluated is what is used.

// Thus if we want to know if a transaction can be part of the

// *next* block, we need to use one more than ::ChainActive().Height()

index.nHeight = tip->nHeight + 1;

std::pair<int, int64_t> lockPair;

if (useExistingLockPoints) {

assert(lp);

lockPair.first = lp->height;

lockPair.second = lp->time;

}

else {

// CoinsTip() contains the UTXO set for ::ChainActive().Tip()

CCoinsViewMemPool viewMemPool(&::ChainstateActive().CoinsTip(), pool);

std::vector<int> prevheights;

prevheights.resize(tx.vin.size());

for (size_t txinIndex = 0; txinIndex < tx.vin.size(); txinIndex++) {

const CTxIn& txin = tx.vin[txinIndex];

Coin coin;

if (!viewMemPool.GetCoin(txin.prevout, coin)) {

return error("%s: Missing input", __func__);

}

if (coin.nHeight == MEMPOOL_HEIGHT) {

// Assume all mempool transaction confirm in the next block

prevheights[txinIndex] = tip->nHeight + 1;

} else {

prevheights[txinIndex] = coin.nHeight;

}

}

lockPair = CalculateSequenceLocks(tx, flags, prevheights, index);

if (lp) {

lp->height = lockPair.first;

lp->time = lockPair.second;

// Also store the hash of the block with the highest height of

// all the blocks which have sequence locked prevouts.

// This hash needs to still be on the chain

// for these LockPoint calculations to be valid

// Note: It is impossible to correctly calculate a maxInputBlock

// if any of the sequence locked inputs depend on unconfirmed txs,

// except in the special case where the relative lock time/height

// is 0, which is equivalent to no sequence lock. Since we assume

// input height of tip+1 for mempool txs and test the resulting

// lockPair from CalculateSequenceLocks against tip+1. We know

// EvaluateSequenceLocks will fail if there was a non-zero sequence

// lock on a mempool input, so we can use the return value of

// CheckSequenceLocks to indicate the LockPoints validity

int maxInputHeight = 0;

for (const int height : prevheights) {

// Can ignore mempool inputs since we'll fail if they had non-zero locks

if (height != tip->nHeight+1) {

maxInputHeight = std::max(maxInputHeight, height);

}

}

lp->maxInputBlock = tip->GetAncestor(maxInputHeight);

}

}

return EvaluateSequenceLocks(index, lockPair);

}

// Returns the script flags which should be checked for a given block

static unsigned int GetBlockScriptFlags(const CBlockIndex* pindex, const Consensus::Params& chainparams);

static void LimitMempoolSize(CTxMemPool& pool, size_t limit, std::chrono::seconds age)

EXCLUSIVE_LOCKS_REQUIRED(pool.cs, ::cs_main)

{

int expired = pool.Expire(GetTime<std::chrono::seconds>() - age);

if (expired != 0) {

LogPrint(BCLog::MEMPOOL, "Expired %i transactions from the memory pool\n", expired);

}

std::vector<COutPoint> vNoSpendsRemaining;

pool.TrimToSize(limit, &vNoSpendsRemaining);

for (const COutPoint& removed : vNoSpendsRemaining)

::ChainstateActive().CoinsTip().Uncache(removed);

}

static bool IsCurrentForFeeEstimation() EXCLUSIVE_LOCKS_REQUIRED(cs_main)

{

AssertLockHeld(cs_main);

if (::ChainstateActive().IsInitialBlockDownload())

return false;

if (::ChainActive().Tip()->GetBlockTime() < count_seconds(GetTime<std::chrono::seconds>() - MAX_FEE_ESTIMATION_TIP_AGE))

return false;

if (::ChainActive().Height() < pindexBestHeader->nHeight - 1)

return false;

return true;

}

/* Make mempool consistent after a reorg, by re-adding or recursively erasing

* disconnected block transactions from the mempool, and also removing any

* other transactions from the mempool that are no longer valid given the new

* tip/height.

*

* Note: we assume that disconnectpool only contains transactions that are NOT

* confirmed in the current chain nor already in the mempool (otherwise,

* in-mempool descendants of such transactions would be removed).

*

* Passing fAddToMempool=false will skip trying to add the transactions back,

* and instead just erase from the mempool as needed.

*/

static void UpdateMempoolForReorg(CTxMemPool& mempool, DisconnectedBlockTransactions& disconnectpool, bool fAddToMempool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, mempool.cs)

{

AssertLockHeld(cs_main);

AssertLockHeld(mempool.cs);

std::vector<uint256> vHashUpdate;

// disconnectpool's insertion_order index sorts the entries from

// oldest to newest, but the oldest entry will be the last tx from the

// latest mined block that was disconnected.

// Iterate disconnectpool in reverse, so that we add transactions

// back to the mempool starting with the earliest transaction that had

// been previously seen in a block.

auto it = disconnectpool.queuedTx.get<insertion_order>().rbegin();

while (it != disconnectpool.queuedTx.get<insertion_order>().rend()) {

// ignore validation errors in resurrected transactions

TxValidationState stateDummy;

if (!fAddToMempool || (*it)->IsCoinBase() ||

!AcceptToMemoryPool(mempool, stateDummy, *it,

nullptr /* plTxnReplaced */, true /* bypass_limits */)) {

// If the transaction doesn't make it in to the mempool, remove any

// transactions that depend on it (which would now be orphans).

mempool.removeRecursive(**it, MemPoolRemovalReason::REORG);

} else if (mempool.exists((*it)->GetHash())) {

vHashUpdate.push_back((*it)->GetHash());

}

++it;

}

disconnectpool.queuedTx.clear();

// AcceptToMemoryPool/addUnchecked all assume that new mempool entries have

// no in-mempool children, which is generally not true when adding

// previously-confirmed transactions back to the mempool.

// UpdateTransactionsFromBlock finds descendants of any transactions in

// the disconnectpool that were added back and cleans up the mempool state.

mempool.UpdateTransactionsFromBlock(vHashUpdate);

// We also need to remove any now-immature transactions

mempool.removeForReorg(&::ChainstateActive().CoinsTip(), ::ChainActive().Tip()->nHeight + 1, STANDARD_LOCKTIME_VERIFY_FLAGS);

// Re-limit mempool size, in case we added any transactions

LimitMempoolSize(mempool, gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000, std::chrono::hours{gArgs.GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY)});

}

// Used to avoid mempool polluting consensus critical paths if CCoinsViewMempool

// were somehow broken and returning the wrong scriptPubKeys

static bool CheckInputsFromMempoolAndCache(const CTransaction& tx, TxValidationState& state, const CCoinsViewCache& view, const CTxMemPool& pool,

unsigned int flags, PrecomputedTransactionData& txdata) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {

AssertLockHeld(cs_main);

// pool.cs should be locked already, but go ahead and re-take the lock here

// to enforce that mempool doesn't change between when we check the view

// and when we actually call through to CheckInputScripts

LOCK(pool.cs);

assert(!tx.IsCoinBase());

for (const CTxIn& txin : tx.vin) {

const Coin& coin = view.AccessCoin(txin.prevout);

// AcceptToMemoryPoolWorker has already checked that the coins are

// available, so this shouldn't fail. If the inputs are not available

// here then return false.

if (coin.IsSpent()) return false;

// Check equivalence for available inputs.

const CTransactionRef& txFrom = pool.get(txin.prevout.hash);

if (txFrom) {

assert(txFrom->GetHash() == txin.prevout.hash);

assert(txFrom->vout.size() > txin.prevout.n);

assert(txFrom->vout[txin.prevout.n] == coin.out);

} else {

const Coin& coinFromDisk = ::ChainstateActive().CoinsTip().AccessCoin(txin.prevout);

assert(!coinFromDisk.IsSpent());

assert(coinFromDisk.out == coin.out);

}

}

// Call CheckInputScripts() to cache signature and script validity against current tip consensus rules.

return CheckInputScripts(tx, state, view, flags, /* cacheSigStore = */ true, /* cacheFullSciptStore = */ true, txdata);

}

namespace {

class MemPoolAccept

{

public:

explicit MemPoolAccept(CTxMemPool& mempool) : m_pool(mempool), m_view(&m_dummy), m_viewmempool(&::ChainstateActive().CoinsTip(), m_pool),

m_limit_ancestors(gArgs.GetArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT)),

m_limit_ancestor_size(gArgs.GetArg("-limitancestorsize", DEFAULT_ANCESTOR_SIZE_LIMIT)*1000),

m_limit_descendants(gArgs.GetArg("-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT)),

m_limit_descendant_size(gArgs.GetArg("-limitdescendantsize", DEFAULT_DESCENDANT_SIZE_LIMIT)*1000) {}

// We put the arguments we're handed into a struct, so we can pass them

// around easier.

struct ATMPArgs {

const CChainParams& m_chainparams;

TxValidationState &m_state;

const int64_t m_accept_time;

std::list<CTransactionRef>* m_replaced_transactions;

const bool m_bypass_limits;

/*

* Return any outpoints which were not previously present in the coins

* cache, but were added as a result of validating the tx for mempool

* acceptance. This allows the caller to optionally remove the cache

* additions if the associated transaction ends up being rejected by

* the mempool.

*/

std::vector<COutPoint>& m_coins_to_uncache;

const bool m_test_accept;

CAmount* m_fee_out;

};

// Single transaction acceptance

bool AcceptSingleTransaction(const CTransactionRef& ptx, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

private:

// All the intermediate state that gets passed between the various levels

// of checking a given transaction.

struct Workspace {

explicit Workspace(const CTransactionRef& ptx) : m_ptx(ptx), m_hash(ptx->GetHash()) {}

std::set<uint256> m_conflicts;

CTxMemPool::setEntries m_all_conflicting;

CTxMemPool::setEntries m_ancestors;

std::unique_ptr<CTxMemPoolEntry> m_entry;

bool m_replacement_transaction;

CAmount m_modified_fees;

CAmount m_conflicting_fees;

size_t m_conflicting_size;

const CTransactionRef& m_ptx;

const uint256& m_hash;

};

// Run the policy checks on a given transaction, excluding any script checks.

// Looks up inputs, calculates feerate, considers replacement, evaluates

// package limits, etc. As this function can be invoked for "free" by a peer,

// only tests that are fast should be done here (to avoid CPU DoS).

bool PreChecks(ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);

// Run the script checks using our policy flags. As this can be slow, we should

// only invoke this on transactions that have otherwise passed policy checks.

bool PolicyScriptChecks(ATMPArgs& args, const Workspace& ws, PrecomputedTransactionData& txdata) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

// Re-run the script checks, using consensus flags, and try to cache the

// result in the scriptcache. This should be done after

// PolicyScriptChecks(). This requires that all inputs either be in our

// utxo set or in the mempool.

bool ConsensusScriptChecks(ATMPArgs& args, const Workspace& ws, PrecomputedTransactionData &txdata) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

// Try to add the transaction to the mempool, removing any conflicts first.

// Returns true if the transaction is in the mempool after any size

// limiting is performed, false otherwise.

bool Finalize(ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);

// Compare a package's feerate against minimum allowed.

bool CheckFeeRate(size_t package_size, CAmount package_fee, TxValidationState& state)

{

CAmount mempoolRejectFee = m_pool.GetMinFee(gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000).GetFee(package_size);

if (mempoolRejectFee > 0 && package_fee < mempoolRejectFee) {

return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "mempool min fee not met", strprintf("%d < %d", package_fee, mempoolRejectFee));

}

if (package_fee < ::minRelayTxFee.GetFee(package_size)) {

return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "min relay fee not met", strprintf("%d < %d", package_fee, ::minRelayTxFee.GetFee(package_size)));

}

return true;

}

private:

CTxMemPool& m_pool;

CCoinsViewCache m_view;

CCoinsViewMemPool m_viewmempool;

CCoinsView m_dummy;

// The package limits in effect at the time of invocation.

const size_t m_limit_ancestors;

const size_t m_limit_ancestor_size;

// These may be modified while evaluating a transaction (eg to account for

// in-mempool conflicts; see below).

size_t m_limit_descendants;

size_t m_limit_descendant_size;

};

bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)

{

const CTransactionRef& ptx = ws.m_ptx;

const CTransaction& tx = *ws.m_ptx;

const uint256& hash = ws.m_hash;

// Copy/alias what we need out of args

TxValidationState &state = args.m_state;

const int64_t nAcceptTime = args.m_accept_time;

const bool bypass_limits = args.m_bypass_limits;

std::vector<COutPoint>& coins_to_uncache = args.m_coins_to_uncache;

// Alias what we need out of ws

std::set<uint256>& setConflicts = ws.m_conflicts;

CTxMemPool::setEntries& allConflicting = ws.m_all_conflicting;

CTxMemPool::setEntries& setAncestors = ws.m_ancestors;

std::unique_ptr<CTxMemPoolEntry>& entry = ws.m_entry;

bool& fReplacementTransaction = ws.m_replacement_transaction;

CAmount& nModifiedFees = ws.m_modified_fees;

CAmount& nConflictingFees = ws.m_conflicting_fees;

size_t& nConflictingSize = ws.m_conflicting_size;

if (!CheckTransaction(tx, state)) {

return false; // state filled in by CheckTransaction

}

// Coinbase is only valid in a block, not as a loose transaction

if (tx.IsCoinBase())

return state.Invalid(TxValidationResult::TX_CONSENSUS, "coinbase");

// Rather not work on nonstandard transactions (unless -testnet/-regtest)

std::string reason;

if (fRequireStandard && !IsStandardTx(tx, reason))

return state.Invalid(TxValidationResult::TX_NOT_STANDARD, reason);

// Do not work on transactions that are too small.

// A transaction with 1 segwit input and 1 P2WPHK output has non-witness size of 82 bytes.

// Transactions smaller than this are not relayed to mitigate CVE-2017-12842 by not relaying

// 64-byte transactions.

if (::GetSerializeSize(tx, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS) < MIN_STANDARD_TX_NONWITNESS_SIZE)

return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "tx-size-small");

// Only accept nLockTime-using transactions that can be mined in the next

// block; we don't want our mempool filled up with transactions that can't

// be mined yet.

if (!CheckFinalTx(tx, STANDARD_LOCKTIME_VERIFY_FLAGS))

return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "non-final");

// is it already in the memory pool?

if (m_pool.exists(hash)) {

return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-in-mempool");

}

// Check for conflicts with in-memory transactions

for (const CTxIn &txin : tx.vin)

{

const CTransaction* ptxConflicting = m_pool.GetConflictTx(txin.prevout);

if (ptxConflicting) {

if (!setConflicts.count(ptxConflicting->GetHash()))

{

// Allow opt-out of transaction replacement by setting

// nSequence > MAX_BIP125_RBF_SEQUENCE (SEQUENCE_FINAL-2) on all inputs.

//

// SEQUENCE_FINAL-1 is picked to still allow use of nLockTime by

// non-replaceable transactions. All inputs rather than just one

// is for the sake of multi-party protocols, where we don't

// want a single party to be able to disable replacement.

//

// The opt-out ignores descendants as anyone relying on

// first-seen mempool behavior should be checking all

// unconfirmed ancestors anyway; doing otherwise is hopelessly

// insecure.

bool fReplacementOptOut = true;

for (const CTxIn &_txin : ptxConflicting->vin)

{

if (_txin.nSequence <= MAX_BIP125_RBF_SEQUENCE)

{

fReplacementOptOut = false;

break;

}

}

if (fReplacementOptOut) {

return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "txn-mempool-conflict");

}

setConflicts.insert(ptxConflicting->GetHash());

}

}

}

LockPoints lp;

m_view.SetBackend(m_viewmempool);

const CCoinsViewCache& coins_cache = ::ChainstateActive().CoinsTip();

// do all inputs exist?

for (const CTxIn& txin : tx.vin) {

if (!coins_cache.HaveCoinInCache(txin.prevout)) {

coins_to_uncache.push_back(txin.prevout);

}

// Note: this call may add txin.prevout to the coins cache

// (coins_cache.cacheCoins) by way of FetchCoin(). It should be removed

// later (via coins_to_uncache) if this tx turns out to be invalid.

if (!m_view.HaveCoin(txin.prevout)) {

// Are inputs missing because we already have the tx?

for (size_t out = 0; out < tx.vout.size(); out++) {

// Optimistically just do efficient check of cache for outputs

if (coins_cache.HaveCoinInCache(COutPoint(hash, out))) {

return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-already-known");

}

}

// Otherwise assume this might be an orphan tx for which we just haven't seen parents yet

return state.Invalid(TxValidationResult::TX_MISSING_INPUTS, "bad-txns-inputs-missingorspent");

}

}

// Bring the best block into scope

m_view.GetBestBlock();

// we have all inputs cached now, so switch back to dummy (to protect

// against bugs where we pull more inputs from disk that miss being added

// to coins_to_uncache)

m_view.SetBackend(m_dummy);

// Only accept BIP68 sequence locked transactions that can be mined in the next

// block; we don't want our mempool filled up with transactions that can't

// be mined yet.

// Must keep pool.cs for this unless we change CheckSequenceLocks to take a

// CoinsViewCache instead of create its own

if (!CheckSequenceLocks(m_pool, tx, STANDARD_LOCKTIME_VERIFY_FLAGS, &lp))

return state.Invalid(TxValidationResult::TX_PREMATURE_SPEND, "non-BIP68-final");

CAmount nFees = 0;

if (!Consensus::CheckTxInputs(tx, state, m_view, GetSpendHeight(m_view), nFees)) {

return false; // state filled in by CheckTxInputs

}

// If fee_out is passed, return the fee to the caller

if (args.m_fee_out) {

*args.m_fee_out = nFees;

}

// Check for non-standard pay-to-script-hash in inputs

const auto& params = args.m_chainparams.GetConsensus();

auto taproot_state = VersionBitsState(::ChainActive().Tip(), params, Consensus::DEPLOYMENT_TAPROOT, versionbitscache);

if (fRequireStandard && !AreInputsStandard(tx, m_view, taproot_state == ThresholdState::ACTIVE)) {

return state.Invalid(TxValidationResult::TX_INPUTS_NOT_STANDARD, "bad-txns-nonstandard-inputs");

}

// Check for non-standard witnesses.

if (tx.HasWitness() && fRequireStandard && !IsWitnessStandard(tx, m_view))

return state.Invalid(TxValidationResult::TX_WITNESS_MUTATED, "bad-witness-nonstandard");

int64_t nSigOpsCost = GetTransactionSigOpCost(tx, m_view, STANDARD_SCRIPT_VERIFY_FLAGS);

// nModifiedFees includes any fee deltas from PrioritiseTransaction

nModifiedFees = nFees;

m_pool.ApplyDelta(hash, nModifiedFees);

// Keep track of transactions that spend a coinbase, which we re-scan

// during reorgs to ensure COINBASE_MATURITY is still met.

bool fSpendsCoinbase = false;

for (const CTxIn &txin : tx.vin) {

const Coin &coin = m_view.AccessCoin(txin.prevout);

if (coin.IsCoinBase()) {

fSpendsCoinbase = true;

break;

}

}

entry.reset(new CTxMemPoolEntry(ptx, nFees, nAcceptTime, ::ChainActive().Height(),

fSpendsCoinbase, nSigOpsCost, lp));

unsigned int nSize = entry->GetTxSize();

if (nSigOpsCost > MAX_STANDARD_TX_SIGOPS_COST)

return state.Invalid(TxValidationResult::TX_NOT_STANDARD, "bad-txns-too-many-sigops",

strprintf("%d", nSigOpsCost));

// No transactions are allowed below minRelayTxFee except from disconnected

// blocks

if (!bypass_limits && !CheckFeeRate(nSize, nModifiedFees, state)) return false;

const CTxMemPool::setEntries setIterConflicting = m_pool.GetIterSet(setConflicts);

// Calculate in-mempool ancestors, up to a limit.

if (setConflicts.size() == 1) {

// In general, when we receive an RBF transaction with mempool conflicts, we want to know whether we

// would meet the chain limits after the conflicts have been removed. However, there isn't a practical

// way to do this short of calculating the ancestor and descendant sets with an overlay cache of

// changed mempool entries. Due to both implementation and runtime complexity concerns, this isn't

// very realistic, thus we only ensure a limited set of transactions are RBF'able despite mempool

// conflicts here. Importantly, we need to ensure that some transactions which were accepted using

// the below carve-out are able to be RBF'ed, without impacting the security the carve-out provides

// for off-chain contract systems (see link in the comment below).

//

// Specifically, the subset of RBF transactions which we allow despite chain limits are those which

// conflict directly with exactly one other transaction (but may evict children of said transaction),

// and which are not adding any new mempool dependencies. Note that the "no new mempool dependencies"

// check is accomplished later, so we don't bother doing anything about it here, but if BIP 125 is

// amended, we may need to move that check to here instead of removing it wholesale.

//

// Such transactions are clearly not merging any existing packages, so we are only concerned with

// ensuring that (a) no package is growing past the package size (not count) limits and (b) we are

// not allowing something to effectively use the (below) carve-out spot when it shouldn't be allowed

// to.

//

// To check these we first check if we meet the RBF criteria, above, and increment the descendant

// limits by the direct conflict and its descendants (as these are recalculated in

// CalculateMempoolAncestors by assuming the new transaction being added is a new descendant, with no

// removals, of each parent's existing dependent set). The ancestor count limits are unmodified (as

// the ancestor limits should be the same for both our new transaction and any conflicts).

// We don't bother incrementing m_limit_descendants by the full removal count as that limit never comes

// into force here (as we're only adding a single transaction).

assert(setIterConflicting.size() == 1);

CTxMemPool::txiter conflict = *setIterConflicting.begin();

m_limit_descendants += 1;

m_limit_descendant_size += conflict->GetSizeWithDescendants();

}

std::string errString;

if (!m_pool.CalculateMemPoolAncestors(*entry, setAncestors, m_limit_ancestors, m_limit_ancestor_size, m_limit_descendants, m_limit_descendant_size, errString)) {

setAncestors.clear();

// If CalculateMemPoolAncestors fails second time, we want the original error string.

std::string dummy_err_string;

// Contracting/payment channels CPFP carve-out:

// If the new transaction is relatively small (up to 40k weight)

// and has at most one ancestor (ie ancestor limit of 2, including

// the new transaction), allow it if its parent has exactly the

// descendant limit descendants.

//

// This allows protocols which rely on distrusting counterparties

// being able to broadcast descendants of an unconfirmed transaction

// to be secure by simply only having two immediately-spendable

// outputs - one for each counterparty. For more info on the uses for

// this, see https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2018-November/016518.html

if (nSize > EXTRA_DESCENDANT_TX_SIZE_LIMIT ||

!m_pool.CalculateMemPoolAncestors(*entry, setAncestors, 2, m_limit_ancestor_size, m_limit_descendants + 1, m_limit_descendant_size + EXTRA_DESCENDANT_TX_SIZE_LIMIT, dummy_err_string)) {

return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", errString);

}

}

// A transaction that spends outputs that would be replaced by it is invalid. Now

// that we have the set of all ancestors we can detect this

// pathological case by making sure setConflicts and setAncestors don't

// intersect.

for (CTxMemPool::txiter ancestorIt : setAncestors)

{

const uint256 &hashAncestor = ancestorIt->GetTx().GetHash();

if (setConflicts.count(hashAncestor))

{

return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-spends-conflicting-tx",

strprintf("%s spends conflicting transaction %s",

hash.ToString(),

hashAncestor.ToString()));

}

}

// Check if it's economically rational to mine this transaction rather

// than the ones it replaces.

nConflictingFees = 0;

nConflictingSize = 0;

uint64_t nConflictingCount = 0;

// If we don't hold the lock allConflicting might be incomplete; the

// subsequent RemoveStaged() and addUnchecked() calls don't guarantee

// mempool consistency for us.

fReplacementTransaction = setConflicts.size();

if (fReplacementTransaction)

{

CFeeRate newFeeRate(nModifiedFees, nSize);

std::set<uint256> setConflictsParents;

const int maxDescendantsToVisit = 100;

for (const auto& mi : setIterConflicting) {

// Don't allow the replacement to reduce the feerate of the

// mempool.

//

// We usually don't want to accept replacements with lower

// feerates than what they replaced as that would lower the

// feerate of the next block. Requiring that the feerate always

// be increased is also an easy-to-reason about way to prevent

// DoS attacks via replacements.

//

// We only consider the feerates of transactions being directly

// replaced, not their indirect descendants. While that does

// mean high feerate children are ignored when deciding whether

// or not to replace, we do require the replacement to pay more

// overall fees too, mitigating most cases.

CFeeRate oldFeeRate(mi->GetModifiedFee(), mi->GetTxSize());

if (newFeeRate <= oldFeeRate)

{

return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "insufficient fee",

strprintf("rejecting replacement %s; new feerate %s <= old feerate %s",

hash.ToString(),

newFeeRate.ToString(),

oldFeeRate.ToString()));

}

for (const CTxIn &txin : mi->GetTx().vin)

{

setConflictsParents.insert(txin.prevout.hash);

}

nConflictingCount += mi->GetCountWithDescendants();

}

// This potentially overestimates the number of actual descendants

// but we just want to be conservative to avoid doing too much

// work.

if (nConflictingCount <= maxDescendantsToVisit) {

// If not too many to replace, then calculate the set of

// transactions that would have to be evicted

for (CTxMemPool::txiter it : setIterConflicting) {

m_pool.CalculateDescendants(it, allConflicting);

}

for (CTxMemPool::txiter it : allConflicting) {

nConflictingFees += it->GetModifiedFee();

nConflictingSize += it->GetTxSize();

}

} else {

return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too many potential replacements",

strprintf("rejecting replacement %s; too many potential replacements (%d > %d)\n",

hash.ToString(),

nConflictingCount,

maxDescendantsToVisit));

}

for (unsigned int j = 0; j < tx.vin.size(); j++)

{

// We don't want to accept replacements that require low

// feerate junk to be mined first. Ideally we'd keep track of

// the ancestor feerates and make the decision based on that,

// but for now requiring all new inputs to be confirmed works.

//

// Note that if you relax this to make RBF a little more useful,

// this may break the CalculateMempoolAncestors RBF relaxation,

// above. See the comment above the first CalculateMempoolAncestors

// call for more info.

if (!setConflictsParents.count(tx.vin[j].prevout.hash))

{

// Rather than check the UTXO set - potentially expensive -

// it's cheaper to just check if the new input refers to a

// tx that's in the mempool.

if (m_pool.exists(tx.vin[j].prevout.hash)) {

return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "replacement-adds-unconfirmed",

strprintf("replacement %s adds unconfirmed input, idx %d",

hash.ToString(), j));

}

}

}

// The replacement must pay greater fees than the transactions it

// replaces - if we did the bandwidth used by those conflicting

// transactions would not be paid for.

if (nModifiedFees < nConflictingFees)

{

return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "insufficient fee",

strprintf("rejecting replacement %s, less fees than conflicting txs; %s < %s",

hash.ToString(), FormatMoney(nModifiedFees), FormatMoney(nConflictingFees)));

}

// Finally in addition to paying more fees than the conflicts the

// new transaction must pay for its own bandwidth.

CAmount nDeltaFees = nModifiedFees - nConflictingFees;

if (nDeltaFees < ::incrementalRelayFee.GetFee(nSize))

{

return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "insufficient fee",

strprintf("rejecting replacement %s, not enough additional fees to relay; %s < %s",

hash.ToString(),

FormatMoney(nDeltaFees),

FormatMoney(::incrementalRelayFee.GetFee(nSize))));

}

}

return true;

}

bool MemPoolAccept::PolicyScriptChecks(ATMPArgs& args, const Workspace& ws, PrecomputedTransactionData& txdata)

{

const CTransaction& tx = *ws.m_ptx;

TxValidationState &state = args.m_state;

constexpr unsigned int scriptVerifyFlags = STANDARD_SCRIPT_VERIFY_FLAGS;

// Check input scripts and signatures.

// This is done last to help prevent CPU exhaustion denial-of-service attacks.

if (!CheckInputScripts(tx, state, m_view, scriptVerifyFlags, true, false, txdata)) {

// SCRIPT_VERIFY_CLEANSTACK requires SCRIPT_VERIFY_WITNESS, so we

// need to turn both off, and compare against just turning off CLEANSTACK

// to see if the failure is specifically due to witness validation.

TxValidationState state_dummy; // Want reported failures to be from first CheckInputScripts

if (!tx.HasWitness() && CheckInputScripts(tx, state_dummy, m_view, scriptVerifyFlags & ~(SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_CLEANSTACK), true, false, txdata) &&

!CheckInputScripts(tx, state_dummy, m_view, scriptVerifyFlags & ~SCRIPT_VERIFY_CLEANSTACK, true, false, txdata)) {

// Only the witness is missing, so the transaction itself may be fine.

state.Invalid(TxValidationResult::TX_WITNESS_STRIPPED,

state.GetRejectReason(), state.GetDebugMessage());

}

return false; // state filled in by CheckInputScripts

}

return true;

}

bool MemPoolAccept::ConsensusScriptChecks(ATMPArgs& args, const Workspace& ws, PrecomputedTransactionData& txdata)

{

const CTransaction& tx = *ws.m_ptx;

const uint256& hash = ws.m_hash;

TxValidationState &state = args.m_state;

const CChainParams& chainparams = args.m_chainparams;

// Check again against the current block tip's script verification

// flags to cache our script execution flags. This is, of course,

// useless if the next block has different script flags from the

// previous one, but because the cache tracks script flags for us it

// will auto-invalidate and we'll just have a few blocks of extra

// misses on soft-fork activation.

//

// This is also useful in case of bugs in the standard flags that cause

// transactions to pass as valid when they're actually invalid. For

// instance the STRICTENC flag was incorrectly allowing certain

// CHECKSIG NOT scripts to pass, even though they were invalid.

//

// There is a similar check in CreateNewBlock() to prevent creating

// invalid blocks (using TestBlockValidity), however allowing such

// transactions into the mempool can be exploited as a DoS attack.

unsigned int currentBlockScriptVerifyFlags = GetBlockScriptFlags(::ChainActive().Tip(), chainparams.GetConsensus());

if (!CheckInputsFromMempoolAndCache(tx, state, m_view, m_pool, currentBlockScriptVerifyFlags, txdata)) {

return error("%s: BUG! PLEASE REPORT THIS! CheckInputScripts failed against latest-block but not STANDARD flags %s, %s",

__func__, hash.ToString(), state.ToString());

}

return true;

}

bool MemPoolAccept::Finalize(ATMPArgs& args, Workspace& ws)

{

const CTransaction& tx = *ws.m_ptx;

const uint256& hash = ws.m_hash;

TxValidationState &state = args.m_state;

const bool bypass_limits = args.m_bypass_limits;

CTxMemPool::setEntries& allConflicting = ws.m_all_conflicting;

CTxMemPool::setEntries& setAncestors = ws.m_ancestors;

const CAmount& nModifiedFees = ws.m_modified_fees;

const CAmount& nConflictingFees = ws.m_conflicting_fees;

const size_t& nConflictingSize = ws.m_conflicting_size;

const bool fReplacementTransaction = ws.m_replacement_transaction;

std::unique_ptr<CTxMemPoolEntry>& entry = ws.m_entry;

// Remove conflicting transactions from the mempool

for (CTxMemPool::txiter it : allConflicting)

{

LogPrint(BCLog::MEMPOOL, "replacing tx %s with %s for %s additional fees, %d delta bytes\n",

it->GetTx().GetHash().ToString(),

hash.ToString(),

FormatMoney(nModifiedFees - nConflictingFees),

(int)entry->GetTxSize() - (int)nConflictingSize);

if (args.m_replaced_transactions)

args.m_replaced_transactions->push_back(it->GetSharedTx());

}

m_pool.RemoveStaged(allConflicting, false, MemPoolRemovalReason::REPLACED);

// This transaction should only count for fee estimation if:

// - it isn't a BIP 125 replacement transaction (may not be widely supported)

// - it's not being re-added during a reorg which bypasses typical mempool fee limits

// - the node is not behind

// - the transaction is not dependent on any other transactions in the mempool

bool validForFeeEstimation = !fReplacementTransaction && !bypass_limits && IsCurrentForFeeEstimation() && m_pool.HasNoInputsOf(tx);

// Store transaction in memory

m_pool.addUnchecked(*entry, setAncestors, validForFeeEstimation);

// trim mempool and check if tx was trimmed

if (!bypass_limits) {

LimitMempoolSize(m_pool, gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000, std::chrono::hours{gArgs.GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY)});

if (!m_pool.exists(hash))

return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "mempool full");

}

return true;

}

bool MemPoolAccept::AcceptSingleTransaction(const CTransactionRef& ptx, ATMPArgs& args)

{

AssertLockHeld(cs_main);

LOCK(m_pool.cs); // mempool "read lock" (held through GetMainSignals().TransactionAddedToMempool())

Workspace workspace(ptx);

if (!PreChecks(args, workspace)) return false;

// Only compute the precomputed transaction data if we need to verify

// scripts (ie, other policy checks pass). We perform the inexpensive

// checks first and avoid hashing and signature verification unless those

// checks pass, to mitigate CPU exhaustion denial-of-service attacks.

PrecomputedTransactionData txdata;

if (!PolicyScriptChecks(args, workspace, txdata)) return false;

if (!ConsensusScriptChecks(args, workspace, txdata)) return false;

// Tx was accepted, but not added

if (args.m_test_accept) return true;

if (!Finalize(args, workspace)) return false;

GetMainSignals().TransactionAddedToMempool(ptx, m_pool.GetAndIncrementSequence());

return true;

}

} // anon namespace

/** (try to) add transaction to memory pool with a specified acceptance time **/

static bool AcceptToMemoryPoolWithTime(const CChainParams& chainparams, CTxMemPool& pool, TxValidationState &state, const CTransactionRef &tx,

int64_t nAcceptTime, std::list<CTransactionRef>* plTxnReplaced,

bool bypass_limits, bool test_accept, CAmount* fee_out=nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

{

std::vector<COutPoint> coins_to_uncache;

MemPoolAccept::ATMPArgs args { chainparams, state, nAcceptTime, plTxnReplaced, bypass_limits, coins_to_uncache, test_accept, fee_out };

bool res = MemPoolAccept(pool).AcceptSingleTransaction(tx, args);

if (!res) {

// Remove coins that were not present in the coins cache before calling ATMPW;

// this is to prevent memory DoS in case we receive a large number of

// invalid transactions that attempt to overrun the in-memory coins cache

// (`CCoinsViewCache::cacheCoins`).

for (const COutPoint& hashTx : coins_to_uncache)

::ChainstateActive().CoinsTip().Uncache(hashTx);

}

// After we've (potentially) uncached entries, ensure our coins cache is still within its size limits

BlockValidationState state_dummy;

::ChainstateActive().FlushStateToDisk(chainparams, state_dummy, FlushStateMode::PERIODIC);

return res;

}

bool AcceptToMemoryPool(CTxMemPool& pool, TxValidationState &state, const CTransactionRef &tx,

std::list<CTransactionRef>* plTxnReplaced,

bool bypass_limits, bool test_accept, CAmount* fee_out)

{

const CChainParams& chainparams = Params();

return AcceptToMemoryPoolWithTime(chainparams, pool, state, tx, GetTime(), plTxnReplaced, bypass_limits, test_accept, fee_out);

}

CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool, const uint256& hash, const Consensus::Params& consensusParams, uint256& hashBlock)

{

LOCK(cs_main);

if (block_index) {

CBlock block;

if (ReadBlockFromDisk(block, block_index, consensusParams)) {

for (const auto& tx : block.vtx) {

if (tx->GetHash() == hash) {

hashBlock = block_index->GetBlockHash();

return tx;

}

}

}

return nullptr;

}

if (mempool) {

CTransactionRef ptx = mempool->get(hash);

if (ptx) return ptx;

}

if (g_txindex) {

CTransactionRef tx;

if (g_txindex->FindTx(hash, hashBlock, tx)) return tx;

}

return nullptr;

}

//////////////////////////////////////////////////////////////////////////////

//

// CBlock and CBlockIndex

//

static bool WriteBlockToDisk(const CBlock& block, FlatFilePos& pos, const CMessageHeader::MessageStartChars& messageStart)

{

// Open history file to append

CAutoFile fileout(OpenBlockFile(pos), SER_DISK, CLIENT_VERSION);

if (fileout.IsNull())

return error("WriteBlockToDisk: OpenBlockFile failed");

// Write index header

unsigned int nSize = GetSerializeSize(block, fileout.GetVersion());

fileout << messageStart << nSize;

// Write block

long fileOutPos = ftell(fileout.Get());

if (fileOutPos < 0)

return error("WriteBlockToDisk: ftell failed");

pos.nPos = (unsigned int)fileOutPos;

fileout << block;

return true;

}

bool ReadBlockFromDisk(CBlock& block, const FlatFilePos& pos, const Consensus::Params& consensusParams)

{

block.SetNull();

// Open history file to read

CAutoFile filein(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION);

if (filein.IsNull())

return error("ReadBlockFromDisk: OpenBlockFile failed for %s", pos.ToString());

// Read block

try {

filein >> block;

}

catch (const std::exception& e) {

return error("%s: Deserialize or I/O error - %s at %s", __func__, e.what(), pos.ToString());

}

// Check the header

if (!CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))

return error("ReadBlockFromDisk: Errors in block header at %s", pos.ToString());

// Signet only: check block solution

if (consensusParams.signet_blocks && !CheckSignetBlockSolution(block, consensusParams)) {

return error("ReadBlockFromDisk: Errors in block solution at %s", pos.ToString());

}

return true;

}

bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const Consensus::Params& consensusParams)

{

FlatFilePos blockPos;

{

LOCK(cs_main);

blockPos = pindex->GetBlockPos();

}

if (!ReadBlockFromDisk(block, blockPos, consensusParams))

return false;

if (block.GetHash() != pindex->GetBlockHash())

return error("ReadBlockFromDisk(CBlock&, CBlockIndex*): GetHash() doesn't match index for %s at %s",

pindex->ToString(), pindex->GetBlockPos().ToString());

return true;

}

bool ReadRawBlockFromDisk(std::vector<uint8_t>& block, const FlatFilePos& pos, const CMessageHeader::MessageStartChars& message_start)

{

FlatFilePos hpos = pos;

hpos.nPos -= 8; // Seek back 8 bytes for meta header

CAutoFile filein(OpenBlockFile(hpos, true), SER_DISK, CLIENT_VERSION);

if (filein.IsNull()) {

return error("%s: OpenBlockFile failed for %s", __func__, pos.ToString());

}

try {

CMessageHeader::MessageStartChars blk_start;

unsigned int blk_size;

filein >> blk_start >> blk_size;

if (memcmp(blk_start, message_start, CMessageHeader::MESSAGE_START_SIZE)) {

return error("%s: Block magic mismatch for %s: %s versus expected %s", __func__, pos.ToString(),

HexStr(blk_start),

HexStr(message_start));

}

if (blk_size > MAX_SIZE) {

return error("%s: Block data is larger than maximum deserialization size for %s: %s versus %s", __func__, pos.ToString(),

blk_size, MAX_SIZE);

}

block.resize(blk_size); // Zeroing of memory is intentional here

filein.read((char*)block.data(), blk_size);

} catch(const std::exception& e) {

return error("%s: Read from block file failed: %s for %s", __func__, e.what(), pos.ToString());

}

return true;

}

bool ReadRawBlockFromDisk(std::vector<uint8_t>& block, const CBlockIndex* pindex, const CMessageHeader::MessageStartChars& message_start)

{

FlatFilePos block_pos;

{

LOCK(cs_main);

block_pos = pindex->GetBlockPos();

}

return ReadRawBlockFromDisk(block, block_pos, message_start);

}

CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams)

{

int halvings = nHeight / consensusParams.nSubsidyHalvingInterval;

// Force block reward to zero when right shift is undefined.

if (halvings >= 64)

return 0;

CAmount nSubsidy = 50 * COIN;

// Subsidy is cut in half every 210,000 blocks which will occur approximately every 4 years.

nSubsidy >>= halvings;

return nSubsidy;

}

CoinsViews::CoinsViews(

std::string ldb_name,

size_t cache_size_bytes,

bool in_memory,

bool should_wipe) : m_dbview(

GetDataDir() / ldb_name, cache_size_bytes, in_memory, should_wipe),

m_catcherview(&m_dbview) {}

void CoinsViews::InitCache()

{

m_cacheview = MakeUnique<CCoinsViewCache>(&m_catcherview);

}

CChainState::CChainState(CTxMemPool& mempool, BlockManager& blockman, uint256 from_snapshot_blockhash)

: m_blockman(blockman),

m_mempool(mempool),

m_from_snapshot_blockhash(from_snapshot_blockhash) {}

void CChainState::InitCoinsDB(

size_t cache_size_bytes,

bool in_memory,

bool should_wipe,

std::string leveldb_name)

{

if (!m_from_snapshot_blockhash.IsNull()) {

leveldb_name += "_" + m_from_snapshot_blockhash.ToString();

}

m_coins_views = MakeUnique<CoinsViews>(

leveldb_name, cache_size_bytes, in_memory, should_wipe);

}

void CChainState::InitCoinsCache(size_t cache_size_bytes)

{

assert(m_coins_views != nullptr);

m_coinstip_cache_size_bytes = cache_size_bytes;

m_coins_views->InitCache();

}

// Note that though this is marked const, we may end up modifying `m_cached_finished_ibd`, which

// is a performance-related implementation detail. This function must be marked

// `const` so that `CValidationInterface` clients (which are given a `const CChainState*`)

// can call it.

//

bool CChainState::IsInitialBlockDownload() const

{

// Optimization: pre-test latch before taking the lock.

if (m_cached_finished_ibd.load(std::memory_order_relaxed))

return false;

LOCK(cs_main);

if (m_cached_finished_ibd.load(std::memory_order_relaxed))

return false;

if (fImporting || fReindex)

return true;

if (m_chain.Tip() == nullptr)

return true;

if (m_chain.Tip()->nChainWork < nMinimumChainWork)

return true;

if (m_chain.Tip()->GetBlockTime() < (GetTime() - nMaxTipAge))

return true;

LogPrintf("Leaving InitialBlockDownload (latching to false)\n");

m_cached_finished_ibd.store(true, std::memory_order_relaxed);

return false;

}

static void AlertNotify(const std::string& strMessage)

{

uiInterface.NotifyAlertChanged();

#if HAVE_SYSTEM

std::string strCmd = gArgs.GetArg("-alertnotify", "");

if (strCmd.empty()) return;

// Alert text should be plain ascii coming from a trusted source, but to

// be safe we first strip anything not in safeChars, then add single quotes around

// the whole string before passing it to the shell:

std::string singleQuote("'");

std::string safeStatus = SanitizeString(strMessage);

safeStatus = singleQuote+safeStatus+singleQuote;

boost::replace_all(strCmd, "%s", safeStatus);

std::thread t(runCommand, strCmd);

t.detach(); // thread runs free

#endif

}

static void CheckForkWarningConditions() EXCLUSIVE_LOCKS_REQUIRED(cs_main)

{

AssertLockHeld(cs_main);

// Before we get past initial download, we cannot reliably alert about forks

// (we assume we don't get stuck on a fork before finishing our initial sync)

if (::ChainstateActive().IsInitialBlockDownload()) {

return;

}

if (pindexBestInvalid && pindexBestInvalid->nChainWork > ::ChainActive().Tip()->nChainWork + (GetBlockProof(*::ChainActive().Tip()) * 6)) {

LogPrintf("%s: Warning: Found invalid chain at least ~6 blocks longer than our best chain.\nChain state database corruption likely.\n", __func__);

SetfLargeWorkInvalidChainFound(true);

} else {

SetfLargeWorkInvalidChainFound(false);

}

}

// Called both upon regular invalid block discovery *and* InvalidateBlock

void static InvalidChainFound(CBlockIndex* pindexNew) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

{

if (!pindexBestInvalid || pindexNew->nChainWork > pindexBestInvalid->nChainWork)

pindexBestInvalid = pindexNew;

if (pindexBestHeader != nullptr && pindexBestHeader->GetAncestor(pindexNew->nHeight) == pindexNew) {

pindexBestHeader = ::ChainActive().Tip();

}

LogPrintf("%s: invalid block=%s height=%d log2_work=%f date=%s\n", __func__,

pindexNew->GetBlockHash().ToString(), pindexNew->nHeight,

log(pindexNew->nChainWork.getdouble())/log(2.0), FormatISO8601DateTime(pindexNew->GetBlockTime()));

CBlockIndex *tip = ::ChainActive().Tip();

assert (tip);

LogPrintf("%s: current best=%s height=%d log2_work=%f date=%s\n", __func__,

tip->GetBlockHash().ToString(), ::ChainActive().Height(), log(tip->nChainWork.getdouble())/log(2.0),

FormatISO8601DateTime(tip->GetBlockTime()));

CheckForkWarningConditions();

}

// Same as InvalidChainFound, above, except not called directly from InvalidateBlock,

// which does its own setBlockIndexCandidates manageent.

void CChainState::InvalidBlockFound(CBlockIndex *pindex, const BlockValidationState &state) {

if (state.GetResult() != BlockValidationResult::BLOCK_MUTATED) {

pindex->nStatus |= BLOCK_FAILED_VALID;

m_blockman.m_failed_blocks.insert(pindex);

setDirtyBlockIndex.insert(pindex);

setBlockIndexCandidates.erase(pindex);

InvalidChainFound(pindex);

}

}

void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo &txundo, int nHeight)

{

// mark inputs spent

if (!tx.IsCoinBase()) {

txundo.vprevout.reserve(tx.vin.size());

for (const CTxIn &txin : tx.vin) {

txundo.vprevout.emplace_back();

bool is_spent = inputs.SpendCoin(txin.prevout, &txundo.vprevout.back());

assert(is_spent);

}

}

// add outputs

AddCoins(inputs, tx, nHeight);

}

void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, int nHeight)

{

CTxUndo txundo;

UpdateCoins(tx, inputs, txundo, nHeight);

}

bool CScriptCheck::operator()() {

const CScript &scriptSig = ptxTo->vin[nIn].scriptSig;

const CScriptWitness *witness = &ptxTo->vin[nIn].scriptWitness;

return VerifyScript(scriptSig, m_tx_out.scriptPubKey, witness, nFlags, CachingTransactionSignatureChecker(ptxTo, nIn, m_tx_out.nValue, cacheStore, *txdata), &error);

}

int GetSpendHeight(const CCoinsViewCache& inputs)

{

LOCK(cs_main);

CBlockIndex* pindexPrev = LookupBlockIndex(inputs.GetBestBlock());

return pindexPrev->nHeight + 1;

}

static CuckooCache::cache<uint256, SignatureCacheHasher> g_scriptExecutionCache;

static CSHA256 g_scriptExecutionCacheHasher;

void InitScriptExecutionCache() {

// Setup the salted hasher

uint256 nonce = GetRandHash();

// We want the nonce to be 64 bytes long to force the hasher to process

// this chunk, which makes later hash computations more efficient. We

// just write our 32-byte entropy twice to fill the 64 bytes.

g_scriptExecutionCacheHasher.Write(nonce.begin(), 32);

g_scriptExecutionCacheHasher.Write(nonce.begin(), 32);

// nMaxCacheSize is unsigned. If -maxsigcachesize is set to zero,

// setup_bytes creates the minimum possible cache (2 elements).

size_t nMaxCacheSize = std::min(std::max((int64_t)0, gArgs.GetArg("-maxsigcachesize", DEFAULT_MAX_SIG_CACHE_SIZE) / 2), MAX_MAX_SIG_CACHE_SIZE) * ((size_t) 1 << 20);

size_t nElems = g_scriptExecutionCache.setup_bytes(nMaxCacheSize);

LogPrintf("Using %zu MiB out of %zu/2 requested for script execution cache, able to store %zu elements\n",

(nElems*sizeof(uint256)) >>20, (nMaxCacheSize*2)>>20, nElems);

}

/**

* Check whether all of this transaction's input scripts succeed.

*

* This involves ECDSA signature checks so can be computationally intensive. This function should

* only be called after the cheap sanity checks in CheckTxInputs passed.

*

* If pvChecks is not nullptr, script checks are pushed onto it instead of being performed inline. Any

* script checks which are not necessary (eg due to script execution cache hits) are, obviously,

* not pushed onto pvChecks/run.

*

* Setting cacheSigStore/cacheFullScriptStore to false will remove elements from the corresponding cache

* which are matched. This is useful for checking blocks where we will likely never need the cache

* entry again.

*

* Note that we may set state.reason to NOT_STANDARD for extra soft-fork flags in flags, block-checking

* callers should probably reset it to CONSENSUS in such cases.

*

* Non-static (and re-declared) in src/test/txvalidationcache_tests.cpp

*/

bool CheckInputScripts(const CTransaction& tx, TxValidationState &state, const CCoinsViewCache &inputs, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData& txdata, std::vector<CScriptCheck> *pvChecks) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

{

if (tx.IsCoinBase()) return true;

if (pvChecks) {

pvChecks->reserve(tx.vin.size());

}

// First check if script executions have been cached with the same

// flags. Note that this assumes that the inputs provided are

// correct (ie that the transaction hash which is in tx's prevouts

// properly commits to the scriptPubKey in the inputs view of that

// transaction).

uint256 hashCacheEntry;

CSHA256 hasher = g_scriptExecutionCacheHasher;

hasher.Write(tx.GetWitnessHash().begin(), 32).Write((unsigned char*)&flags, sizeof(flags)).Finalize(hashCacheEntry.begin());

AssertLockHeld(cs_main); //TODO: Remove this requirement by making CuckooCache not require external locks

if (g_scriptExecutionCache.contains(hashCacheEntry, !cacheFullScriptStore)) {

return true;

}

if (!txdata.m_spent_outputs_ready) {

std::vector<CTxOut> spent_outputs;

spent_outputs.reserve(tx.vin.size());

for (const auto& txin : tx.vin) {

const COutPoint& prevout = txin.prevout;

const Coin& coin = inputs.AccessCoin(prevout);

assert(!coin.IsSpent());

spent_outputs.emplace_back(coin.out);

}

txdata.Init(tx, std::move(spent_outputs));

}

assert(txdata.m_spent_outputs.size() == tx.vin.size());

for (unsigned int i = 0; i < tx.vin.size(); i++) {

// We very carefully only pass in things to CScriptCheck which

// are clearly committed to by tx' witness hash. This provides

// a sanity check that our caching is not introducing consensus

// failures through additional data in, eg, the coins being

// spent being checked as a part of CScriptCheck.

// Verify signature

CScriptCheck check(txdata.m_spent_outputs[i], tx, i, flags, cacheSigStore, &txdata);

if (pvChecks) {

pvChecks->push_back(CScriptCheck());

check.swap(pvChecks->back());

} else if (!check()) {

if (flags & STANDARD_NOT_MANDATORY_VERIFY_FLAGS) {

// Check whether the failure was caused by a

// non-mandatory script verification check, such as

// non-standard DER encodings or non-null dummy

// arguments; if so, ensure we return NOT_STANDARD

// instead of CONSENSUS to avoid downstream users

// splitting the network between upgraded and

// non-upgraded nodes by banning CONSENSUS-failing

// data providers.

CScriptCheck check2(txdata.m_spent_outputs[i], tx, i,

flags & ~STANDARD_NOT_MANDATORY_VERIFY_FLAGS, cacheSigStore, &txdata);

if (check2())

return state.Invalid(TxValidationResult::TX_NOT_STANDARD, strprintf("non-mandatory-script-verify-flag (%s)", ScriptErrorString(check.GetScriptError())));

}

// MANDATORY flag failures correspond to

// TxValidationResult::TX_CONSENSUS. Because CONSENSUS

// failures are the most serious case of validation

// failures, we may need to consider using

// RECENT_CONSENSUS_CHANGE for any script failure that

// could be due to non-upgraded nodes which we may want to

// support, to avoid splitting the network (but this

// depends on the details of how net_processing handles

// such errors).

return state.Invalid(TxValidationResult::TX_CONSENSUS, strprintf("mandatory-script-verify-flag-failed (%s)", ScriptErrorString(check.GetScriptError())));

}

}

if (cacheFullScriptStore && !pvChecks) {

// We executed all of the provided scripts, and were told to

// cache the result. Do so now.

g_scriptExecutionCache.insert(hashCacheEntry);

}

return true;

}

static bool UndoWriteToDisk(const CBlockUndo& blockundo, FlatFilePos& pos, const uint256& hashBlock, const CMessageHeader::MessageStartChars& messageStart)

{

// Open history file to append

CAutoFile fileout(OpenUndoFile(pos), SER_DISK, CLIENT_VERSION);

if (fileout.IsNull())

return error("%s: OpenUndoFile failed", __func__);

// Write index header

unsigned int nSize = GetSerializeSize(blockundo, fileout.GetVersion());

fileout << messageStart << nSize;

// Write undo data

long fileOutPos = ftell(fileout.Get());

if (fileOutPos < 0)

return error("%s: ftell failed", __func__);

pos.nPos = (unsigned int)fileOutPos;

fileout << blockundo;

// calculate & write checksum

CHashWriter hasher(SER_GETHASH, PROTOCOL_VERSION);

hasher << hashBlock;

hasher << blockundo;

fileout << hasher.GetHash();

return true;

}

bool UndoReadFromDisk(CBlockUndo& blockundo, const CBlockIndex* pindex)

{

FlatFilePos pos = pindex->GetUndoPos();

if (pos.IsNull()) {

return error("%s: no undo data available", __func__);

}

// Open history file to read

CAutoFile filein(OpenUndoFile(pos, true), SER_DISK, CLIENT_VERSION);

if (filein.IsNull())

return error("%s: OpenUndoFile failed", __func__);

// Read block

uint256 hashChecksum;

CHashVerifier<CAutoFile> verifier(&filein); // We need a CHashVerifier as reserializing may lose data

try {

verifier << pindex->pprev->GetBlockHash();

verifier >> blockundo;

filein >> hashChecksum;

}

catch (const std::exception& e) {

return error("%s: Deserialize or I/O error - %s", __func__, e.what());

}

// Verify checksum

if (hashChecksum != verifier.GetHash())

return error("%s: Checksum mismatch", __func__);

return true;

}

/** Abort with a message */

static bool AbortNode(const std::string& strMessage, bilingual_str user_message = bilingual_str())

{

SetMiscWarning(Untranslated(strMessage));

LogPrintf("*** %s\n", strMessage);

if (user_message.empty()) {

user_message = _("A fatal internal error occurred, see debug.log for details");

}

AbortError(user_message);

StartShutdown();

return false;

}

static bool AbortNode(BlockValidationState& state, const std::string& strMessage, const bilingual_str& userMessage = bilingual_str())

{

AbortNode(strMessage, userMessage);

return state.Error(strMessage);

}

/**

* Restore the UTXO in a Coin at a given COutPoint

* @param undo The Coin to be restored.

* @param view The coins view to which to apply the changes.

* @param out The out point that corresponds to the tx input.

* @return A DisconnectResult as an int

*/

int ApplyTxInUndo(Coin&& undo, CCoinsViewCache& view, const COutPoint& out)

{

bool fClean = true;

if (view.HaveCoin(out)) fClean = false; // overwriting transaction output

if (undo.nHeight == 0) {

// Missing undo metadata (height and coinbase). Older versions included this

// information only in undo records for the last spend of a transactions'

// outputs. This implies that it must be present for some other output of the same tx.

const Coin& alternate = AccessByTxid(view, out.hash);

if (!alternate.IsSpent()) {

undo.nHeight = alternate.nHeight;

undo.fCoinBase = alternate.fCoinBase;

} else {

return DISCONNECT_FAILED; // adding output for transaction without known metadata

}

}

// If the coin already exists as an unspent coin in the cache, then the

// possible_overwrite parameter to AddCoin must be set to true. We have

// already checked whether an unspent coin exists above using HaveCoin, so

// we don't need to guess. When fClean is false, an unspent coin already

// existed and it is an overwrite.

view.AddCoin(out, std::move(undo), !fClean);

return fClean ? DISCONNECT_OK : DISCONNECT_UNCLEAN;

}

/** Undo the effects of this block (with given index) on the UTXO set represented by coins.

* When FAILED is returned, view is left in an indeterminate state. */

DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view)

{

bool fClean = true;

CBlockUndo blockUndo;

if (!UndoReadFromDisk(blockUndo, pindex)) {

error("DisconnectBlock(): failure reading undo data");

return DISCONNECT_FAILED;

}

if (blockUndo.vtxundo.size() + 1 != block.vtx.size()) {

error("DisconnectBlock(): block and undo data inconsistent");

return DISCONNECT_FAILED;

}

// undo transactions in reverse order

for (int i = block.vtx.size() - 1; i >= 0; i--) {

const CTransaction &tx = *(block.vtx[i]);

uint256 hash = tx.GetHash();

bool is_coinbase = tx.IsCoinBase();

// Check that all outputs are available and match the outputs in the block itself

// exactly.

for (size_t o = 0; o < tx.vout.size(); o++) {

if (!tx.vout[o].scriptPubKey.IsUnspendable()) {

COutPoint out(hash, o);

Coin coin;

bool is_spent = view.SpendCoin(out, &coin);

if (!is_spent || tx.vout[o] != coin.out || pindex->nHeight != coin.nHeight || is_coinbase != coin.fCoinBase) {

fClean = false; // transaction output mismatch

}

}

}

// restore inputs

if (i > 0) { // not coinbases

CTxUndo &txundo = blockUndo.vtxundo[i-1];

if (txundo.vprevout.size() != tx.vin.size()) {

error("DisconnectBlock(): transaction and undo data inconsistent");

return DISCONNECT_FAILED;

}

for (unsigned int j = tx.vin.size(); j-- > 0;) {

const COutPoint &out = tx.vin[j].prevout;

int res = ApplyTxInUndo(std::move(txundo.vprevout[j]), view, out);

if (res == DISCONNECT_FAILED) return DISCONNECT_FAILED;

fClean = fClean && res != DISCONNECT_UNCLEAN;

}

// At this point, all of txundo.vprevout should have been moved out.

}

}

// move best block pointer to prevout block

view.SetBestBlock(pindex->pprev->GetBlockHash());

return fClean ? DISCONNECT_OK : DISCONNECT_UNCLEAN;

}

static void FlushUndoFile(int block_file, bool finalize = false)

{

FlatFilePos undo_pos_old(block_file, vinfoBlockFile[block_file].nUndoSize);

if (!UndoFileSeq().Flush(undo_pos_old, finalize)) {

AbortNode("Flushing undo file to disk failed. This is likely the result of an I/O error.");

}

}

static void FlushBlockFile(bool fFinalize = false, bool finalize_undo = false)

{

LOCK(cs_LastBlockFile);

FlatFilePos block_pos_old(nLastBlockFile, vinfoBlockFile[nLastBlockFile].nSize);

if (!BlockFileSeq().Flush(block_pos_old, fFinalize)) {

AbortNode("Flushing block file to disk failed. This is likely the result of an I/O error.");

}

// we do not always flush the undo file, as the chain tip may be lagging behind the incoming blocks,

// e.g. during IBD or a sync after a node going offline

if (!fFinalize || finalize_undo) FlushUndoFile(nLastBlockFile, finalize_undo);

}

static bool FindUndoPos(BlockValidationState &state, int nFile, FlatFilePos &pos, unsigned int nAddSize);

static bool WriteUndoDataForBlock(const CBlockUndo& blockundo, BlockValidationState& state, CBlockIndex* pindex, const CChainParams& chainparams)

{

// Write undo information to disk

if (pindex->GetUndoPos().IsNull()) {

FlatFilePos _pos;

if (!FindUndoPos(state, pindex->nFile, _pos, ::GetSerializeSize(blockundo, CLIENT_VERSION) + 40))

return error("ConnectBlock(): FindUndoPos failed");

if (!UndoWriteToDisk(blockundo, _pos, pindex->pprev->GetBlockHash(), chainparams.MessageStart()))

return AbortNode(state, "Failed to write undo data");

// rev files are written in block height order, whereas blk files are written as blocks come in (often out of order)

// we want to flush the rev (undo) file once we've written the last block, which is indicated by the last height

// in the block file info as below; note that this does not catch the case where the undo writes are keeping up

// with the block writes (usually when a synced up node is getting newly mined blocks) -- this case is caught in

// the FindBlockPos function

if (_pos.nFile < nLastBlockFile && static_cast<uint32_t>(pindex->nHeight) == vinfoBlockFile[_pos.nFile].nHeightLast) {

FlushUndoFile(_pos.nFile, true);

}

// update nUndoPos in block index

pindex->nUndoPos = _pos.nPos;

pindex->nStatus |= BLOCK_HAVE_UNDO;

setDirtyBlockIndex.insert(pindex);

}

return true;

}

static CCheckQueue<CScriptCheck> scriptcheckqueue(128);

void ThreadScriptCheck(int worker_num) {

util::ThreadRename(strprintf("scriptch.%i", worker_num));

scriptcheckqueue.Thread();

}

VersionBitsCache versionbitscache GUARDED_BY(cs_main);

int32_t ComputeBlockVersion(const CBlockIndex* pindexPrev, const Consensus::Params& params)

{

LOCK(cs_main);

int32_t nVersion = VERSIONBITS_TOP_BITS;

for (int i = 0; i < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; i++) {

ThresholdState state = VersionBitsState(pindexPrev, params, static_cast<Consensus::DeploymentPos>(i), versionbitscache);

if (state == ThresholdState::LOCKED_IN || state == ThresholdState::STARTED) {

nVersion |= VersionBitsMask(params, static_cast<Consensus::DeploymentPos>(i));

}

}

return nVersion;

}

/**

* Threshold condition checker that triggers when unknown versionbits are seen on the network.

*/

class WarningBitsConditionChecker : public AbstractThresholdConditionChecker

{

private:

int bit;

public:

explicit WarningBitsConditionChecker(int bitIn) : bit(bitIn) {}

int64_t BeginTime(const Consensus::Params& params) const override { return 0; }

int64_t EndTime(const Consensus::Params& params) const override { return std::numeric_limits<int64_t>::max(); }

int Period(const Consensus::Params& params) const override { return params.nMinerConfirmationWindow; }

int Threshold(const Consensus::Params& params) const override { return params.nRuleChangeActivationThreshold; }

bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const override

{

return pindex->nHeight >= params.MinBIP9WarningHeight &&

((pindex->nVersion & VERSIONBITS_TOP_MASK) == VERSIONBITS_TOP_BITS) &&

((pindex->nVersion >> bit) & 1) != 0 &&

((ComputeBlockVersion(pindex->pprev, params) >> bit) & 1) == 0;

}

};

static ThresholdConditionCache warningcache[VERSIONBITS_NUM_BITS] GUARDED_BY(cs_main);

// 0.13.0 was shipped with a segwit deployment defined for testnet, but not for

// mainnet. We no longer need to support disabling the segwit deployment

// except for testing purposes, due to limitations of the functional test

// environment. See test/functional/p2p-segwit.py.

static bool IsScriptWitnessEnabled(const Consensus::Params& params)

{

return params.SegwitHeight != std::numeric_limits<int>::max();

}

static unsigned int GetBlockScriptFlags(const CBlockIndex* pindex, const Consensus::Params& consensusparams) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {

AssertLockHeld(cs_main);

unsigned int flags = SCRIPT_VERIFY_NONE;

// BIP16 didn't become active until Apr 1 2012 (on mainnet, and

// retroactively applied to testnet)

// However, only one historical block violated the P2SH rules (on both

// mainnet and testnet), so for simplicity, always leave P2SH

// on except for the one violating block.

if (consensusparams.BIP16Exception.IsNull() || // no bip16 exception on this chain

pindex->phashBlock == nullptr || // this is a new candidate block, eg from TestBlockValidity()

*pindex->phashBlock != consensusparams.BIP16Exception) // this block isn't the historical exception

{

flags |= SCRIPT_VERIFY_P2SH;

}

// Enforce WITNESS rules whenever P2SH is in effect (and the segwit

// deployment is defined).

if (flags & SCRIPT_VERIFY_P2SH && IsScriptWitnessEnabled(consensusparams)) {

flags |= SCRIPT_VERIFY_WITNESS;

}

// Start enforcing the DERSIG (BIP66) rule

if (pindex->nHeight >= consensusparams.BIP66Height) {

flags |= SCRIPT_VERIFY_DERSIG;

}

// Start enforcing CHECKLOCKTIMEVERIFY (BIP65) rule

if (pindex->nHeight >= consensusparams.BIP65Height) {

flags |= SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY;

}

// Start enforcing BIP112 (CHECKSEQUENCEVERIFY)

if (pindex->nHeight >= consensusparams.CSVHeight) {

flags |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY;

}

// Start enforcing Taproot using versionbits logic.

if (VersionBitsState(pindex->pprev, consensusparams, Consensus::DEPLOYMENT_TAPROOT, versionbitscache) == ThresholdState::ACTIVE) {

flags |= SCRIPT_VERIFY_TAPROOT;

}

// Start enforcing BIP147 NULLDUMMY (activated simultaneously with segwit)

if (IsWitnessEnabled(pindex->pprev, consensusparams)) {

flags |= SCRIPT_VERIFY_NULLDUMMY;

}

return flags;

}