namespace miner_tests {

struct MinerTestingSetup : public TestingSetup {

void TestPackageSelection(const CChainParams& chainparams, const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_node.mempool->cs);

{

CCoinsViewMemPool view_mempool(&m_node.chainman->ActiveChainstate().CoinsTip(), *m_node.mempool);

}

BlockAssembler AssemblerForTest(const CChainParams& params);

};

// non-final txs in mempool

SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()+1);

// height map

std::vector<int> prevheights;

tx.nLockTime = 0;

hash = tx.GetHash();

m_node.mempool->addUnchecked(entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));

{

CBlockIndex* active_chain_tip = m_node.chainman->ActiveChain().Tip();

prevheights[0] = baseheight + 2;

hash = tx.GetHash();

m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));

for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)

m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i)->nTime += 512; //Trick the MedianTimePast

tx.nLockTime = m_node.chainman->ActiveChain().Tip()->nHeight + 1;

hash = tx.GetHash();

m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));

BOOST_CHECK(IsFinalTx(CTransaction(tx), m_node.chainman->ActiveChain().Tip()->nHeight + 2, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast())); // Locktime passes on 2nd block

// absolute time locked

prevheights[0] = baseheight + 4;

hash = tx.GetHash();

m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));

BOOST_CHECK(IsFinalTx(CTransaction(tx), m_node.chainman->ActiveChain().Tip()->nHeight + 2, m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1)); // Locktime passes 1 second later

// mempool-dependent transactions (not added)

tx.vin[0].prevout.hash = hash;

prevheights[0] = m_node.chainman->ActiveChain().Tip()->nHeight + 1;

tx.nLockTime = 0;

tx.vin[0].nSequence = 0;

tx.vin[0].nSequence = 1;

tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;

tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;

BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));

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

EXCLUSIVE_LOCKS_REQUIRED(cs_main);

{

AssertLockHeld(cs_main);

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

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

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

return IsFinalTx(tx, nBlockHeight, nBlockTime);

}

const CCoinsView& coins_view,

const CTransaction& tx,

LockPoints* lp,

bool useExistingLockPoints)

{

assert(tip != nullptr);

CBlockIndex index;

index.pprev = tip;

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

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

// evaluated is what is used.

prevheights[txinIndex] = coin.nHeight;

}

}

if (lp) {

lp->height = lockPair.first;

lp->time = lockPair.second;

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

int maxInputHeight = 0;

for (const int height : prevheights) {

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

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

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.

LockPoints lp = it->GetLockPoints();

const bool validLP{TestLockPointValidity(m_chain, lp)};

CCoinsViewMemPool view_mempool(&CoinsTip(), *m_mempool);

// created on top of the new chain. We use useExistingLockPoints=false so that, instead of

// using the information in lp (which might now refer to a block that no longer exists in

// the chain), it will update lp to contain LockPoints relevant to the new chain.

return true;

} else if (!validLP) {

// Now update the mempool entry lockpoints as well.

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

}

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

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

if (m_pool.exists(GenTxid::Wtxid(tx.GetWitnessHash()))) {

// Exact transaction already exists in the mempool.

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

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

const Package& txns, bool test_accept)

EXCLUSIVE_LOCKS_REQUIRED(cs_main);

const CCoinsView& coins_view,

const CTransaction& tx,

LockPoints* lp = nullptr,

bool useExistingLockPoints = false);