{

AssertLockHeld(cs_main);

assert(active_chain_tip); // TODO: Make active_chain_tip a reference

// 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 active_chain_tip.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 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() if LOCKTIME_MEDIAN_TIME_PAST is set.

const int64_t nBlockTime = (flags & LOCKTIME_MEDIAN_TIME_PAST)

? active_chain_tip->GetMedianTimePast()

: GetAdjustedTime();

return IsFinalTx(tx, nBlockHeight, nBlockTime);

{

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 (!active_chain.Contains(lp->maxInputBlock)) {

return false;

}

}

// LockPoints still valid

return true;

const CCoinsView& coins_view,

const CTransaction& tx,

int flags,

LockPoints* lp,

bool useExistingLockPoints)

{

assert(tip != nullptr);

CBlockIndex index;

index.pprev = tip;

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

std::pair<int, int64_t> lockPair;

if (useExistingLockPoints) {

assert(lp);

lockPair.first = lp->height;

lockPair.second = lp->time;

}

else {

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 (!coins_view.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);

{

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() < pindexBestHeader->nHeight - 1)

return false;

return true;

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, *m_mempool, *it, true /* bypass_limits */).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.

m_mempool->UpdateTransactionsFromBlock(vHashUpdate);

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

m_mempool->removeForReorg(*this, STANDARD_LOCKTIME_VERIFY_FLAGS);

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

LimitMempoolSize(

*m_mempool,

this->CoinsTip(),

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

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

{

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

const int64_t m_accept_time;

const bool m_bypass_limits;

/*

std::vector<COutPoint>& m_coins_to_uncache;

const bool m_test_accept;

/** Whether we allow transactions to replace mempool transactions by BIP125 rules. If false,

const bool m_allow_bip125_replacement{true};

};

// Single transaction acceptance

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

/**

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

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

std::list<CTransactionRef> m_replaced_transactions;

bool m_replacement_transaction;

CAmount m_base_fees;

CAmount m_modified_fees;

CAmount m_conflicting_fees;

size_t m_conflicting_size;

const CTransactionRef& m_ptx;

const uint256& m_hash;

TxValidationState m_state;

};

// 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(const ATMPArgs& args, Workspace& ws, PrecomputedTransactionData& txdata) 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, PrecomputedTransactionData &txdata) 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);

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

{

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;

}

CTxMemPool& m_pool;

CCoinsViewCache m_view;

CCoinsViewMemPool m_viewmempool;

CCoinsView m_dummy;

CChainState& m_active_chainstate;

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

{

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 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::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(m_active_chainstate.m_chain.Tip(), tx, STANDARD_LOCKTIME_VERIFY_FLAGS))

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

if (m_pool.exists(GenTxid(true, tx.GetWitnessHash()))) {

// Exact transaction already exists in the mempool.

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

} else if (m_pool.exists(GenTxid(false, tx.GetHash()))) {

// Transaction with the same non-witness data but different witness (same txid, different

// wtxid) already exists in the mempool.

return state.Invalid(TxValidationResult::TX_CONFLICT, "txn-same-nonwitness-data-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 (!args.m_allow_bip125_replacement) {

// Transaction conflicts with a mempool tx, but we're not allowing replacements.

return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "bip125-replacement-disallowed");

}

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.

//

// Transactions that don't explicitly signal replaceability are

// *not* replaceable with the current logic, even if one of their

// unconfirmed ancestors signals replaceability. This diverges

// from BIP125's inherited signaling description (see CVE-2021-31876).

// Applications relying on first-seen mempool behavior should

// check all unconfirmed ancestors; otherwise an opt-in ancestor

// might be replaced, causing removal of this descendant.

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

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

if (!CheckSequenceLocks(m_active_chainstate.m_chain.Tip(), m_view, tx, STANDARD_LOCKTIME_VERIFY_FLAGS, &lp))

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

if (!Consensus::CheckTxInputs(tx, state, m_view, m_active_chainstate.m_blockman.GetSpendHeight(m_view), ws.m_base_fees)) {

return false; // state filled in by CheckTxInputs

}

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

const bool taproot_active = DeploymentActiveAfter(m_active_chainstate.m_chain.Tip(), args.m_chainparams.GetConsensus(), Consensus::DEPLOYMENT_TAPROOT);

if (fRequireStandard && !AreInputsStandard(tx, m_view, taproot_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 = ws.m_base_fees;

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, ws.m_base_fees, nAcceptTime, m_active_chainstate.m_chain.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;

{

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

{

const CTransaction& tx = *ws.m_ptx;

const uint256& hash = ws.m_hash;

TxValidationState& state = ws.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(m_active_chainstate.m_chain.Tip(), chainparams.GetConsensus());

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

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;

{

const CTransaction& tx = *ws.m_ptx;

const uint256& hash = ws.m_hash;

TxValidationState& state = ws.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);

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

}

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