#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 <policy/fees.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 <timedata.h>

#include <tinyformat.h>

#include <txdb.h>

#include <txmempool.h>

#include <ui_interface.h>

#include <uint256.h>

#include <undo.h>

#include <util/moneystr.h>

#include <util/rbf.h>

#include <util/strencodings.h>

#include <util/system.h>

#include <util/translation.h>

#include <util/validation.h>

#include <validationinterface.h>

#include <warnings.h>

#include <string>

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

#include <boost/thread.hpp>

#if defined(NDEBUG)

# error "Bitcoin cannot be compiled without assertions."

#endif

#define MICRO 0.000001

#define MILLI 0.001

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;

}

namespace {

BlockManager g_blockman;

} // anon namespace

std::unique_ptr<CChainState> g_chainstate;

CChainState& ChainstateActive() {

assert(g_chainstate);

return *g_chainstate;

}

CChain& ChainActive() {

assert(g_chainstate);

return g_chainstate->m_chain;

}

RecursiveMutex cs_main;

CBlockIndex *pindexBestHeader = nullptr;

Mutex g_best_block_mutex;

std::condition_variable g_best_block_cv;

uint256 g_best_block;

int nScriptCheckThreads = 0;

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;

size_t nCoinCacheUsage = 5000 * 300;

uint64_t nPruneTarget = 0;

int64_t nMaxTipAge = DEFAULT_MAX_TIP_AGE;

uint256 hashAssumeValid;

arith_uint256 nMinimumChainWork;

CFeeRate minRelayTxFee = CFeeRate(DEFAULT_MIN_RELAY_TX_FEE);

CBlockPolicyEstimator feeEstimator;

CTxMemPool mempool(&feeEstimator);

CScript COINBASE_FLAGS;

namespace {

CBlockIndex* pindexBestInvalid = nullptr;

CCriticalSection cs_LastBlockFile;

std::vector<CBlockFileInfo> vinfoBlockFile;

int nLastBlockFile = 0;

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

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_blockman.m_block_index.find(hash);

return it == g_blockman.m_block_index.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;

static void FindFilesToPruneManual(std::set<int>& setFilesToPrune, int nManualPruneHeight);

static void FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPruneAfterHeight);

bool CheckInputs(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)

}

bool TestLockPointValidity(const LockPoints* lp)

}

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

}

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)

}

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

{

AssertLockHeld(cs_main);

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 */, 0 /* nAbsurdFee */)) {

// 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)});

}

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

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

}

namespace {

class MemPoolAccept

};

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

}

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

}

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

}

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