// Copyright (c) 2009-2010 Satoshi Nakamoto

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

// Copyright (c) 2014-2025 The Dash 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/amount.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 <kernel/coinstats.h>

#include <logging.h>

#include <logging/timer.h>

#include <node/blockstorage.h>

#include <node/interface_ui.h>

#include <node/utxo_snapshot.h>

#include <policy/policy.h>

#include <policy/settings.h>

#include <pow.h>

#include <primitives/block.h>

#include <primitives/transaction.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 <uint256.h>

#include <undo.h>

#include <util/check.h>

#include <util/hasher.h>

#include <util/strencodings.h>

#include <util/trace.h>

#include <util/translation.h>

#include <util/system.h>

#include <validationinterface.h>

#include <warnings.h>

#include <chainlock/chainlock.h>

#include <evo/chainhelper.h>

#include <evo/deterministicmns.h>

#include <evo/evodb.h>

#include <evo/specialtx.h>

#include <evo/specialtxman.h>

#include <masternode/payments.h>

#include <stats/client.h>

#include <util/std23.h>

#include <algorithm>

#include <cassert>

#include <deque>

#include <numeric>

#include <optional>

#include <ranges>

#include <string>

using kernel::CCoinsStats;

using kernel::CoinStatsHashType;

using kernel::ComputeUTXOStats;

using node::BlockManager;

using node::BlockMap;

using node::CBlockIndexHeightOnlyComparator;

using node::CBlockIndexWorkComparator;

using node::DEFAULT_ADDRESSINDEX;

using node::DEFAULT_SPENTINDEX;

using node::DEFAULT_TIMESTAMPINDEX;

using node::fAddressIndex;

using node::fImporting;

using node::fPruneMode;

using node::fReindex;

using node::fSpentIndex;

using node::fTimestampIndex;

using node::ReadBlockFromDisk;

using node::SnapshotMetadata;

using node::UndoReadFromDisk;

using node::UnlinkPrunedFiles;

#define MICRO 0.000001

#define MILLI 0.001

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

static const unsigned int MAX_DISCONNECTED_TX_POOL_SIZE = 20000;

/** 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",

};

/** The number of blocks to keep below the deepest prune lock.

* There is nothing special about this number. It is higher than what we

* expect to see in regular mainnet reorgs, but not so high that it would

* noticeably interfere with the pruning mechanism.

* */

static constexpr int PRUNE_LOCK_BUFFER{10};

/**

* 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;

GlobalMutex g_best_block_mutex;

std::condition_variable g_best_block_cv;

uint256 g_best_block;

bool g_parallel_script_checks{false};

bool fRequireStandard = true;

bool fCheckBlockIndex = false;

bool fCheckpointsEnabled = DEFAULT_CHECKPOINTS_ENABLED;

int64_t nMaxTipAge = DEFAULT_MAX_TIP_AGE;

uint256 hashAssumeValid;

arith_uint256 nMinimumChainWork;

// Forward declaration to break dependency over node/transaction.h

namespace node

{

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

} // namespace node

using node::GetTransaction;

const CBlockIndex* CChainState::FindForkInGlobalIndex(const CBlockLocator& locator) const

{

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) {

const CBlockIndex* pindex{m_blockman.LookupBlockIndex(hash)};

if (pindex) {

if (m_chain.Contains(pindex)) {

return pindex;

}

}

}

return m_chain.Genesis();

}

bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,

const CCoinsViewCache& inputs, unsigned int flags, bool cacheSigStore,

bool cacheFullScriptStore, PrecomputedTransactionData& txdata,

std::vector<CScriptCheck>* pvChecks = nullptr)

EXCLUSIVE_LOCKS_REQUIRED(cs_main);

bool CheckFinalTxAtTip(const CBlockIndex& active_chain_tip, const CTransaction& tx)

{

AssertLockHeld(cs_main);

// CheckFinalTxAtTip() uses active_chain_tip.Height()+1 to evaluate

// nLockTime because when IsFinalTx() is called within

// 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 active_chain_tip.Height().

const int nBlockHeight = active_chain_tip.nHeight + 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().

const int64_t nBlockTime{active_chain_tip.GetMedianTimePast()};

return IsFinalTx(tx, nBlockHeight, nBlockTime);

}

namespace {

/**

* A helper which calculates heights of inputs of a given transaction.

*

* @param[in] tip The current chain tip. If an input belongs to a mempool

* transaction, we assume it will be confirmed in the next block.

* @param[in] coins Any CCoinsView that provides access to the relevant coins.

* @param[in] tx The transaction being evaluated.

*

* @returns A vector of input heights or nullopt, in case of an error.

*/

std::optional<std::vector<int>> CalculatePrevHeights(

const CBlockIndex& tip,

const CCoinsView& coins,

const CTransaction& tx)

{

std::vector<int> prev_heights;

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

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

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

Coin coin;

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

LogPrintf("ERROR: %s: Missing input %d in transaction \'%s\'\n", __func__, i, tx.GetHash().GetHex());

return std::nullopt;

}

if (coin.nHeight == MEMPOOL_HEIGHT) {

// Assume all mempool transaction confirm in the next block.

prev_heights[i] = tip.nHeight + 1;

} else {

prev_heights[i] = coin.nHeight;

}

}

return prev_heights;

}

} // namespace

std::optional<LockPoints> CalculateLockPointsAtTip(

CBlockIndex* tip,

const CCoinsView& coins_view,

const CTransaction& tx)

{

assert(tip);

auto prev_heights{CalculatePrevHeights(*tip, coins_view, tx)};

if (!prev_heights.has_value()) return std::nullopt;

CBlockIndex next_tip;

next_tip.pprev = tip;

// 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 active_chainstate.m_chain.Height()

next_tip.nHeight = tip->nHeight + 1;

const auto [min_height, min_time] = CalculateSequenceLocks(tx, STANDARD_LOCKTIME_VERIFY_FLAGS, prev_heights.value(), next_tip);

// 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

// min_height and min_time from CalculateSequenceLocks against tip+1.

int max_input_height{0};

for (const int height : prev_heights.value()) {

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

if (height != next_tip.nHeight) {

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

}

}

// tip->GetAncestor(max_input_height) should never return a nullptr

// because max_input_height is always less than the tip height.

// It would, however, be a bad bug to continue execution, since a

// LockPoints object with the maxInputBlock member set to nullptr

// signifies no relative lock time.

return LockPoints{min_height, min_time, Assert(tip->GetAncestor(max_input_height))};

}

bool CheckSequenceLocksAtTip(CBlockIndex* tip,

const LockPoints& lock_points)

{

assert(tip != nullptr);

CBlockIndex index;

index.pprev = tip;

// CheckSequenceLocksAtTip() uses active_chainstate.m_chain.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 active_chainstate.m_chain.Height()

index.nHeight = tip->nHeight + 1;

return EvaluateSequenceLocks(index, {lock_points.height, lock_points.time});

}

bool GetUTXOCoin(CChainState& active_chainstate, const COutPoint& outpoint, Coin& coin)

{

LOCK(cs_main);

if (!active_chainstate.CoinsTip().GetCoin(outpoint, coin))

return false;

if (coin.IsSpent())

return false;

return true;

}

int GetUTXOHeight(CChainState& active_chainstate, const COutPoint& outpoint)

{

// -1 means UTXO is yet unknown or already spent

Coin coin;

return GetUTXOCoin(active_chainstate, outpoint, coin) ? coin.nHeight : -1;

}

int GetUTXOConfirmations(CChainState& active_chainstate, const COutPoint& outpoint)

{

// -1 means UTXO is yet unknown or already spent

LOCK(cs_main);

int nPrevoutHeight = GetUTXOHeight(active_chainstate, outpoint);

return (nPrevoutHeight > -1 && active_chainstate.m_chain.Tip()) ? active_chainstate.m_chain.Height() - nPrevoutHeight + 1 : -1;

}

static bool ContextualCheckTransaction(const CTransaction& tx, TxValidationState& state, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev)

{

bool fDIP0001Active_context = DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_DIP0001);

bool fDIP0003Active_context = DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_DIP0003);

if (fDIP0003Active_context) {

// check version 3 transaction types

if (tx.IsSpecialTxVersion()) {

if (tx.nType != TRANSACTION_NORMAL &&

tx.nType != TRANSACTION_PROVIDER_REGISTER &&

tx.nType != TRANSACTION_PROVIDER_UPDATE_SERVICE &&

tx.nType != TRANSACTION_PROVIDER_UPDATE_REGISTRAR &&

tx.nType != TRANSACTION_PROVIDER_UPDATE_REVOKE &&

tx.nType != TRANSACTION_COINBASE &&

tx.nType != TRANSACTION_QUORUM_COMMITMENT &&

tx.nType != TRANSACTION_MNHF_SIGNAL &&

tx.nType != TRANSACTION_ASSET_LOCK &&

tx.nType != TRANSACTION_ASSET_UNLOCK) {

return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-type");

}

if (tx.IsCoinBase() && tx.nType != TRANSACTION_COINBASE)

return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-cb-type");

} else if (tx.nType != TRANSACTION_NORMAL) {

return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-type");

}

}

// Size limits

if (fDIP0001Active_context && ::GetSerializeSize(tx, PROTOCOL_VERSION) > MAX_STANDARD_TX_SIZE)

return state.Invalid(TxValidationResult::TX_CONSENSUS, "bad-txns-oversize");

return true;

}

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

static unsigned int GetBlockScriptFlags(const CBlockIndex* pindex, const ChainstateManager& chainman);

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

EXCLUSIVE_LOCKS_REQUIRED(::cs_main, pool.cs)

{

AssertLockHeld(::cs_main);

AssertLockHeld(pool.cs);

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)

coins_cache.Uncache(removed);

}

static bool IsCurrentForFeeEstimation(CChainState& active_chainstate) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

{

AssertLockHeld(cs_main);

if (active_chainstate.IsInitialBlockDownload())

return false;

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

return false;

if (active_chainstate.m_chain.Height() < active_chainstate.m_chainman.m_best_header->nHeight - 1) {

return false;

}

return true;

}

void CChainState::MaybeUpdateMempoolForReorg(

DisconnectedBlockTransactions& disconnectpool,

bool fAddToMempool)

{

if (!m_mempool) return;

AssertLockHeld(cs_main);

AssertLockHeld(m_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

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

AcceptToMemoryPool(*this, *it, GetTime(),

/*bypass_limits=*/true, /*test_accept=*/false).m_result_type !=

MempoolAcceptResult::ResultType::VALID) {

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

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

m_mempool->removeRecursive(**it, MemPoolRemovalReason::REORG);

} else if (m_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.

const uint64_t ancestor_count_limit = gArgs.GetIntArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT);

const uint64_t ancestor_size_limit = gArgs.GetIntArg("-limitancestorsize", DEFAULT_ANCESTOR_SIZE_LIMIT) * 1000;

m_mempool->UpdateTransactionsFromBlock(vHashUpdate, ancestor_size_limit, ancestor_count_limit);

// Predicate to use for filtering transactions in removeForReorg.

// Checks whether the transaction is still final and, if it spends a coinbase output, mature.

// Also updates valid entries' cached LockPoints if needed.

// If false, the tx is still valid and its lockpoints are updated.

// If true, the tx would be invalid in the next block; remove this entry and all of its descendants.

const auto filter_final_and_mature = [this](CTxMemPool::txiter it)

EXCLUSIVE_LOCKS_REQUIRED(m_mempool->cs, ::cs_main) {

AssertLockHeld(m_mempool->cs);

AssertLockHeld(::cs_main);

const CTransaction& tx = it->GetTx();

// The transaction must be final.

if (!CheckFinalTxAtTip(*Assert(m_chain.Tip()), tx)) return true;

const LockPoints& lp = it->GetLockPoints();

// CheckSequenceLocksAtTip checks if the transaction will be final in the next block to be

// created on top of the new chain.

if (TestLockPointValidity(m_chain, lp)) {

if (!CheckSequenceLocksAtTip(m_chain.Tip(), lp)) {

return true;

}

} else {

const CCoinsViewMemPool view_mempool{&CoinsTip(), *m_mempool};

const std::optional<LockPoints> new_lock_points{CalculateLockPointsAtTip(m_chain.Tip(), view_mempool, tx)};

if (new_lock_points.has_value() && CheckSequenceLocksAtTip(m_chain.Tip(), *new_lock_points)) {

// Now update the mempool entry lockpoints as well.

m_mempool->mapTx.modify(it, [&new_lock_points](CTxMemPoolEntry& e) { e.UpdateLockPoints(*new_lock_points); });

} else {

return true;

}

}

// If the transaction spends any coinbase outputs, it must be mature.

if (it->GetSpendsCoinbase()) {

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

auto it2 = m_mempool->mapTx.find(txin.prevout.hash);

if (it2 != m_mempool->mapTx.end())

continue;

const Coin& coin{CoinsTip().AccessCoin(txin.prevout)};

assert(!coin.IsSpent());

const auto mempool_spend_height{m_chain.Tip()->nHeight + 1};

if (coin.IsCoinBase() && mempool_spend_height - coin.nHeight < COINBASE_MATURITY) {

return true;

}

}

}

// Transaction is still valid and cached LockPoints are updated.

return false;

};

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

m_mempool->removeForReorg(m_chain, filter_final_and_mature);

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

LimitMempoolSize(

*m_mempool,

this->CoinsTip(),

gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000,

std::chrono::hours{gArgs.GetIntArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY)});

}

/**

* Checks to avoid mempool polluting consensus critical paths since cached

* signature and script validity results will be reused if we validate this

* transaction again during block validation.

* */

static bool CheckInputsFromMempoolAndCache(const CTransaction& tx, TxValidationState& state,

const CCoinsViewCache& view, const CTxMemPool& pool,

unsigned int flags, PrecomputedTransactionData& txdata, CCoinsViewCache& coins_tip)

EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs)

{

AssertLockHeld(cs_main);

AssertLockHeld(pool.cs);

assert(!tx.IsCoinBase());

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

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

// This coin was checked in PreChecks and MemPoolAccept

// has been holding cs_main since then.

Assume(!coin.IsSpent());

if (coin.IsSpent()) return false;

// If the Coin is available, there are 2 possibilities:

// it is available in our current ChainstateActive UTXO set,

// or it's a UTXO provided by a transaction in our mempool.

// Ensure the scriptPubKeys in Coins from CoinsView are correct.

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& coinFromUTXOSet = coins_tip.AccessCoin(txin.prevout);

assert(!coinFromUTXOSet.IsSpent());

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

}

}

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

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

}

namespace {

class MemPoolAccept

{

public:

explicit MemPoolAccept(CTxMemPool& mempool, CChainState& active_chainstate) :

m_pool(mempool),

m_view(&m_dummy),

m_viewmempool(&active_chainstate.CoinsTip(), m_pool),

m_active_chainstate(active_chainstate),

m_chain_helper(active_chainstate.ChainHelper()),

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

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

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

m_limit_descendant_size(gArgs.GetIntArg("-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;

const int64_t m_accept_time;

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;

/** When true, the mempool will not be trimmed when individual transactions are submitted in

* Finalize(). Instead, limits should be enforced at the end to ensure the package is not

* partially submitted.

*/

const bool m_package_submission;

/** When true, use package feerates instead of individual transaction feerates for fee-based

* policies such as mempool min fee and min relay fee.

*/

const bool m_package_feerates;

/** Parameters for single transaction mempool validation. */

static ATMPArgs SingleAccept(const CChainParams& chainparams, int64_t accept_time,

bool bypass_limits, std::vector<COutPoint>& coins_to_uncache,

bool test_accept) {

return ATMPArgs{/* m_chainparams */ chainparams,

/* m_accept_time */ accept_time,

/* m_bypass_limits */ bypass_limits,

/* m_coins_to_uncache */ coins_to_uncache,

/* m_test_accept */ test_accept,

/* m_package_submission */ false,

/* m_package_feerates */ false,

};

}

/** Parameters for test package mempool validation through testmempoolaccept. */

static ATMPArgs PackageTestAccept(const CChainParams& chainparams, int64_t accept_time,

std::vector<COutPoint>& coins_to_uncache) {

return ATMPArgs{/* m_chainparams */ chainparams,

/* m_accept_time */ accept_time,

/* m_bypass_limits */ false,

/* m_coins_to_uncache */ coins_to_uncache,

/* m_test_accept */ true,

/* m_package_submission */ false, // not submitting to mempool

/* m_package_feerates */ false,

};

}

/** Parameters for child-with-unconfirmed-parents package validation. */

static ATMPArgs PackageChildWithParents(const CChainParams& chainparams, int64_t accept_time,

std::vector<COutPoint>& coins_to_uncache) {

return ATMPArgs{/* m_chainparams */ chainparams,

/* m_accept_time */ accept_time,

/* m_bypass_limits */ false,

/* m_coins_to_uncache */ coins_to_uncache,

/* m_test_accept */ false,

/* m_package_submission */ true,

/* m_package_feerates */ true,

};

}

/** Parameters for a single transaction within a package. */

static ATMPArgs SingleInPackageAccept(const ATMPArgs& package_args) {

return ATMPArgs{/* m_chainparams */ package_args.m_chainparams,

/* m_accept_time */ package_args.m_accept_time,

/* m_bypass_limits */ false,

/* m_coins_to_uncache */ package_args.m_coins_to_uncache,

/* m_test_accept */ package_args.m_test_accept,

/* m_package_submission */ false,

/* m_package_feerates */ false, // only 1 transaction

};

}

private:

// Private ctor to avoid exposing details to clients and allowing the possibility of

// mixing up the order of the arguments. Use static functions above instead.

ATMPArgs(const CChainParams& chainparams,

int64_t accept_time,

bool bypass_limits,

std::vector<COutPoint>& coins_to_uncache,

bool test_accept,

bool package_submission,

bool package_feerates)

: m_chainparams{chainparams},

m_accept_time{accept_time},

m_bypass_limits{bypass_limits},

m_coins_to_uncache{coins_to_uncache},

m_test_accept{test_accept},

m_package_submission{package_submission},

m_package_feerates{package_feerates}

{

}

};

// Single transaction acceptance

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

/**

* Multiple transaction acceptance. Transactions may or may not be interdependent, but must not

* conflict with each other, and the transactions cannot already be in the mempool. Parents must

* come before children if any dependencies exist.

*/

PackageMempoolAcceptResult AcceptMultipleTransactions(const std::vector<CTransactionRef>& txns, ATMPArgs& args) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

/**

* Package (more specific than just multiple transactions) acceptance. Package must be a child

* with all of its unconfirmed parents, and topologically sorted.

*/

PackageMempoolAcceptResult AcceptPackage(const Package& package, 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()) {}

/** All mempool ancestors of this transaction. */

CTxMemPool::setEntries m_ancestors;

/** Mempool entry constructed for this transaction. Constructed in PreChecks() but not

* inserted into the mempool until Finalize(). */

std::unique_ptr<CTxMemPoolEntry> m_entry;

/** Size of the transaction as used by the mempool, calculated using serialized size

* of the transaction and sigops. */

int64_t m_vsize;

/** Fees paid by this transaction: total input amounts subtracted by total output amounts. */

CAmount m_base_fees;

/** Base fees + any fee delta set by the user with prioritisetransaction. */

CAmount m_modified_fees;

const CTransactionRef& m_ptx;

/** Txid. */

const uint256& m_hash;

TxValidationState m_state;

/** A temporary cache containing serialized transaction data for signature verification.

* Reused across PolicyScriptChecks and ConsensusScriptChecks. */

PrecomputedTransactionData m_precomputed_txdata;

};

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

// Enforce package mempool ancestor/descendant limits (distinct from individual

// ancestor/descendant limits done in PreChecks).

bool PackageMempoolChecks(const std::vector<CTransactionRef>& txns,

PackageValidationState& package_state) 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(const ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);

// 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(const ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);

// 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(const ATMPArgs& args, Workspace& ws) EXCLUSIVE_LOCKS_REQUIRED(cs_main, m_pool.cs);

// Submit all transactions to the mempool and call ConsensusScriptChecks to add to the script

// cache - should only be called after successful validation of all transactions in the package.

// The package may end up partially-submitted after size limiting; returns true if all

// transactions are successfully added to the mempool, false otherwise.

bool SubmitPackage(const ATMPArgs& args, std::vector<Workspace>& workspaces, PackageValidationState& package_state,

std::map<const uint256, const MempoolAcceptResult>& results)

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) EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_pool.cs)

{

AssertLockHeld(::cs_main);

AssertLockHeld(m_pool.cs);

CAmount mempoolRejectFee = m_pool.GetMinFee(gArgs.GetIntArg("-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;

CChainState& m_active_chainstate;

CChainstateHelper& m_chain_helper;

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

{

AssertLockHeld(cs_main);

AssertLockHeld(m_pool.cs);

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

const CChainParams& chainparams = args.m_chainparams;

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

TxValidationState& state = ws.m_state;

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

if (!CheckTransaction(tx, state)) {

return false; // state filled in by CheckTransaction

}

if (!ContextualCheckTransaction(tx, state, chainparams.GetConsensus(), m_active_chainstate.m_chain.Tip()))

return error("%s: ContextualCheckTransaction: %s, %s", __func__, hash.ToString(), state.ToString());

if (tx.IsSpecialTxVersion() && tx.nType == TRANSACTION_QUORUM_COMMITMENT) {

// quorum commitment is not allowed outside of blocks

return state.Invalid(TxValidationResult::TX_CONSENSUS, "qc-not-allowed");

}

// 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 empty scriptSig input and 1 P2SH output has size of 83 bytes.

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

// 64-byte transactions.

if (::GetSerializeSize(tx, PROTOCOL_VERSION) < MIN_STANDARD_TX_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 (!CheckFinalTxAtTip(*Assert(m_active_chainstate.m_chain.Tip()), tx)) {

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

}

// is it already in the memory pool?

if (m_pool.exists(hash)) {

::g_stats_client->inc("transactions.duplicate", 1.0f);

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

}

if (auto conflictLockOpt = m_chain_helper.ConflictingISLockIfAny(tx); conflictLockOpt.has_value()) {

auto& [_, conflict_txid] = conflictLockOpt.value();

uint256 hashBlock;

if (auto txConflict = GetTransaction(nullptr, &m_pool, conflict_txid, chainparams.GetConsensus(), hashBlock); txConflict) {

GetMainSignals().NotifyInstantSendDoubleSpendAttempt(ptx, txConflict);

}

LogPrintf("ERROR: AcceptToMemoryPool : Transaction %s conflicts with locked TX %s\n", hash.ToString(), conflict_txid.ToString());

return state.Invalid(TxValidationResult::TX_CONFLICT_LOCK, "tx-txlock-conflict");

}

if (m_chain_helper.IsInstantSendWaitingForTx(hash)) {

m_pool.removeConflicts(tx);

m_pool.removeProTxConflicts(tx);

} else {

// Check for conflicts with in-memory transactions

for (const CTxIn &txin : tx.vin)

{

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

if (ptxConflicting)

{

// Transaction conflicts with mempool and RBF doesn't exist in Dash

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

}

}

}

m_view.SetBackend(m_viewmempool);

const CCoinsViewCache& coins_cache = m_active_chainstate.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");

}

}

// This is const, but calls into the back end CoinsViews. The CCoinsViewDB at the bottom of the

// hierarchy brings the best block into scope. See CCoinsViewDB::GetBestBlock().

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

assert(m_active_chainstate.m_blockman.LookupBlockIndex(m_view.GetBestBlock()) == m_active_chainstate.m_chain.Tip());

// 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.

// Pass in m_view which has all of the relevant inputs cached. Note that, since m_view's

// backend was removed, it no longer pulls coins from the mempool.

const std::optional<LockPoints> lock_points{CalculateLockPointsAtTip(m_active_chainstate.m_chain.Tip(), m_view, tx)};

if (!lock_points.has_value() || !CheckSequenceLocksAtTip(m_active_chainstate.m_chain.Tip(), *lock_points)) {

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

}

// The mempool holds txs for the next block, so pass height+1 to CheckTxInputs

if (!Consensus::CheckTxInputs(tx, state, m_view, m_active_chainstate.m_chain.Height() + 1, ws.m_base_fees)) {

return false; // state filled in by CheckTxInputs

}

if (fRequireStandard && !AreInputsStandard(tx, m_view)) {

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

}

unsigned int nSigOps = GetTransactionSigOpCount(tx, m_view, STANDARD_SCRIPT_VERIFY_FLAGS);

// ws.m_modified_fees includes any fee deltas from PrioritiseTransaction

ws.m_modified_fees = ws.m_base_fees;

m_pool.ApplyDelta(hash, ws.m_modified_fees);

// 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, ws.m_base_fees, nAcceptTime, m_active_chainstate.m_chain.Height(),

fSpendsCoinbase, nSigOps, lock_points.value()));

ws.m_vsize = entry->GetTxSize();

if (nSigOps > MAX_STANDARD_TX_SIGOPS)

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

strprintf("%d", nSigOps));

// No individual transactions are allowed below minRelayTxFee and mempool min fee except from

// disconnected blocks and transactions in a package. Package transactions will be checked using

// package feerate later.

// Checking of fee for MNHF_SIGNAL should be skipped: mnhf does not have

// inputs, outputs, or fee

if (!tx.IsSpecialTxVersion() || tx.nType != TRANSACTION_MNHF_SIGNAL) {

if (!bypass_limits && !args.m_package_feerates && !CheckFeeRate(ws.m_vsize, ws.m_modified_fees, state)) return false;

}

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

std::string errString;

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

ws.m_ancestors.clear();

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

std::string dummy_err_string;

// 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 (ws.m_vsize > EXTRA_DESCENDANT_TX_SIZE_LIMIT ||

!m_pool.CalculateMemPoolAncestors(*entry, ws.m_ancestors, 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);

}

}

// check special TXs after all the other checks. If we'd do this before the other checks, we might end up

// DoS scoring a node for non-critical errors, e.g. duplicate keys because a TX is received that was already

// mined

// NOTE: we use UTXO here and do NOT allow mempool txes as masternode collaterals

if (!m_chain_helper.special_tx->CheckSpecialTx(tx, m_active_chainstate.m_chain.Tip(), m_active_chainstate.CoinsTip(), true, state))

return false;

if (m_pool.existsProviderTxConflict(tx)) {

return state.Invalid(TxValidationResult::TX_CONFLICT, "protx-dup");

}

return true;

}

bool MemPoolAccept::PackageMempoolChecks(const std::vector<CTransactionRef>& txns,

PackageValidationState& package_state)

{

AssertLockHeld(cs_main);

AssertLockHeld(m_pool.cs);

// CheckPackageLimits expects the package transactions to not already be in the mempool.

assert(std::all_of(txns.cbegin(), txns.cend(), [this](const auto& tx)

{ return !m_pool.exists(tx->GetHash());}));

std::string err_string;

if (!m_pool.CheckPackageLimits(txns, m_limit_ancestors, m_limit_ancestor_size, m_limit_descendants,

m_limit_descendant_size, err_string)) {

// This is a package-wide error, separate from an individual transaction error.

return package_state.Invalid(PackageValidationResult::PCKG_POLICY, "package-mempool-limits", err_string);

}

return true;

}

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

{

AssertLockHeld(cs_main);

AssertLockHeld(m_pool.cs);

const CTransaction& tx = *ws.m_ptx;

TxValidationState& state = ws.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, ws.m_precomputed_txdata)) {

return false; // state filled in by CheckInputScripts

}

return true;

}

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

{