tx5.vout.resize(1);

tx5.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;

tx5.vout[0].nValue = 11 * COIN;

pool.addUnchecked(entry.Fee(10000LL).FromTx(tx5));

BOOST_CHECK_EQUAL(pool.size(), 5U);

tx8.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;

tx8.vout[0].nValue = 10 * COIN;

setAncestors.insert(pool.mapTx.find(tx7.GetHash()));

// Now tx8 should be sorted low, but tx6/tx both high

sortedOrder.insert(sortedOrder.begin(), tx8.GetHash().ToString());

tx9.vout.resize(1);

tx9.vout[0].scriptPubKey = CScript() << OP_11 << OP_EQUAL;

tx9.vout[0].nValue = 1 * COIN;

// tx9 should be sorted low

BOOST_CHECK_EQUAL(pool.size(), 9U);

tx10.vout[0].nValue = 10 * COIN;

setAncestorsCalculated.clear();

BOOST_CHECK(setAncestorsCalculated == setAncestors);

pool.addUnchecked(entry.FromTx(tx10), setAncestors);

tx.vout[0].nValue = 5000000000LL - 1000;

// This tx has a low fee: 1000 satoshis

uint256 hashParentTx = tx.GetHash(); // save this txid for later use

// This tx has a medium fee: 10000 satoshis

tx.vin[0].prevout.hash = txFirst[1]->GetHash();

tx.vout[0].nValue = 5000000000LL - 10000;

uint256 hashMediumFeeTx = tx.GetHash();

// This tx has a high fee, but depends on the first transaction

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

tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 50k satoshi fee

uint256 hashHighFeeTx = tx.GetHash();

std::unique_ptr<CBlockTemplate> pblocktemplate = AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey);

BOOST_REQUIRE_EQUAL(pblocktemplate->block.vtx.size(), 4U);

hash = tx.GetHash();

bool spendsCoinbase = i == 0; // only first tx spends coinbase

// If we don't set the # of sig ops in the CTxMemPoolEntry, template creation fails

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

}

hash = tx.GetHash();

bool spendsCoinbase = i == 0; // only first tx spends coinbase

// If we do set the # of sig ops in the CTxMemPoolEntry, template creation passes

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

}

BOOST_CHECK(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey));

tx.vout[0].nValue -= LOWFEE;

hash = tx.GetHash();

bool spendsCoinbase = i == 0; // only first tx spends coinbase

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

}

BOOST_CHECK(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey));

// orphan in tx_mempool, template creation fails

hash = tx.GetHash();

BOOST_CHECK_EXCEPTION(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));

}

tx.vin[0].prevout.hash = txFirst[1]->GetHash();

tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;

hash = tx.GetHash();

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

tx.vin.resize(2);

tx.vin[1].scriptSig = CScript() << OP_1;

tx.vin[1].prevout.hash = txFirst[0]->GetHash();

tx.vin[1].prevout.n = 0;

tx.vout[0].nValue = tx.vout[0].nValue + BLOCKSUBSIDY - HIGHERFEE; // First txn output + fresh coinbase - new txn fee

hash = tx.GetHash();

BOOST_CHECK(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey));

}

tx.vout[0].nValue = 0;

hash = tx.GetHash();

// give it a fee so it'll get mined

// Should throw bad-cb-multiple

BOOST_CHECK_EXCEPTION(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-cb-multiple"));

}

tx.vout[0].nValue = BLOCKSUBSIDY - HIGHFEE;

tx.vout[0].scriptPubKey = CScript() << OP_1;

hash = tx.GetHash();

tx.vout[0].scriptPubKey = CScript() << OP_2;

hash = tx.GetHash();

BOOST_CHECK_EXCEPTION(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));

}

CScript script = CScript() << OP_0;

tx.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(script));

hash = tx.GetHash();

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

tx.vin[0].scriptSig = CScript() << std::vector<unsigned char>(script.begin(), script.end());

tx.vout[0].nValue -= LOWFEE;

hash = tx.GetHash();

// Should throw block-validation-failed

BOOST_CHECK_EXCEPTION(AssemblerForTest(tx_mempool).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("block-validation-failed"));

tx.vout[0].scriptPubKey = CScript() << OP_1;

tx.nLockTime = 0;

hash = tx.GetHash();

BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes

BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail

tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | (((m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()+1-m_node.chainman->ActiveChain()[1]->GetMedianTimePast()) >> CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) + 1); // txFirst[1] is the 3rd block

prevheights[0] = baseheight + 2;

hash = tx.GetHash();

BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes

BOOST_CHECK(!TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks fail

prevheights[0] = baseheight + 3;

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

hash = tx.GetHash();

BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails

BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass

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

prevheights.resize(1);

prevheights[0] = baseheight + 4;

hash = tx.GetHash();

BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails

BOOST_CHECK(TestSequenceLocks(CTransaction{tx}, tx_mempool)); // Sequence locks pass

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

tx.vout.resize(1);

tx.vout[0].nValue = 5000000000LL; // 0 fee

uint256 hashFreePrioritisedTx = tx.GetHash();

tx_mempool.PrioritiseTransaction(hashFreePrioritisedTx, 5 * COIN);

tx.vin[0].prevout.hash = txFirst[1]->GetHash();

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

tx.vout[0].nValue = 5000000000LL - 1000;

// This tx has a low fee: 1000 satoshis

uint256 hashParentTx = tx.GetHash(); // save this txid for later use

// This tx has a medium fee: 10000 satoshis

tx.vin[0].prevout.hash = txFirst[2]->GetHash();

tx.vout[0].nValue = 5000000000LL - 10000;

uint256 hashMediumFeeTx = tx.GetHash();

tx_mempool.PrioritiseTransaction(hashMediumFeeTx, -5 * COIN);

// This tx also has a low fee, but is prioritised

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

tx.vout[0].nValue = 5000000000LL - 1000 - 1000; // 1000 satoshi fee

uint256 hashPrioritsedChild = tx.GetHash();

tx_mempool.PrioritiseTransaction(hashPrioritsedChild, 2 * COIN);

// Test that transaction selection properly updates ancestor fee calculations as prioritised

for (int k = 0; k < 4; k++) { // add 4 fee txs

tx.vin[0].prevout.n = 10000*blocknum+100*j+k; // make transaction unique

uint256 hash = tx.GetHash();

txHashes[j].push_back(hash);

}

}

for (int k = 0; k < 4; k++) { // add 4 fee txs

tx.vin[0].prevout.n = 10000*blocknum+100*j+k;

uint256 hash = tx.GetHash();

txHashes[j].push_back(hash);

}

}

for (int k = 0; k < 4; k++) { // add 4 fee txs

tx.vin[0].prevout.n = 10000*blocknum+100*j+k;

uint256 hash = tx.GetHash();

CTransactionRef ptx = mpool.get(hash);

if (ptx)

block.push_back(ptx);

CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CTransactionRef& tx) const

{

}

#define BITCOIN_TEST_UTIL_TXMEMPOOL_H

#include <txmempool.h>

namespace node {

struct NodeContext;

}

CTxMemPool::Options MemPoolOptionsForTest(const node::NodeContext& node);

// Default values

CAmount nFee{0};

unsigned int nHeight{1};

bool spendsCoinbase{false};

unsigned int sigOpCost{4};

CTxMemPoolEntry FromTx(const CTransactionRef& tx) const;

// Change the default value

};

#endif // BITCOIN_TEST_UTIL_TXMEMPOOL_H