mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-02-05 10:17:30 -05:00
ed6cddd98e
In order to prevent memory DoS, we must ensure that we don't accept a new header into memory until we've performed anti-DoS checks, such as verifying that the header is part of a sufficiently high work chain. This commit adds a new argument to AcceptBlockHeader() so that we can ensure that all call-sites which might cause a new header to be accepted into memory have to grapple with the question of whether the header is safe to accept, or needs further validation. This patch also fixes two places where low-difficulty-headers could have been processed without such validation (processing an unrequested block from the network, and processing a compact block). Credit to Niklas Gögge for noticing this issue, and thanks to Sjors Provoost for test code.
615 lines
31 KiB
C++
615 lines
31 KiB
C++
// Copyright (c) 2011-2021 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include <chainparams.h>
|
|
#include <coins.h>
|
|
#include <consensus/consensus.h>
|
|
#include <consensus/merkle.h>
|
|
#include <consensus/tx_verify.h>
|
|
#include <node/miner.h>
|
|
#include <policy/policy.h>
|
|
#include <script/standard.h>
|
|
#include <timedata.h>
|
|
#include <txmempool.h>
|
|
#include <uint256.h>
|
|
#include <util/strencodings.h>
|
|
#include <util/system.h>
|
|
#include <util/time.h>
|
|
#include <validation.h>
|
|
#include <versionbits.h>
|
|
|
|
#include <test/util/setup_common.h>
|
|
|
|
#include <memory>
|
|
|
|
#include <boost/test/unit_test.hpp>
|
|
|
|
using node::BlockAssembler;
|
|
using node::CBlockTemplate;
|
|
|
|
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);
|
|
void TestBasicMining(const CChainParams& chainparams, const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight) EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_node.mempool->cs);
|
|
void TestPrioritisedMining(const CChainParams& chainparams, const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst) EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_node.mempool->cs);
|
|
bool TestSequenceLocks(const CTransaction& tx) EXCLUSIVE_LOCKS_REQUIRED(::cs_main, m_node.mempool->cs)
|
|
{
|
|
CCoinsViewMemPool view_mempool(&m_node.chainman->ActiveChainstate().CoinsTip(), *m_node.mempool);
|
|
return CheckSequenceLocksAtTip(m_node.chainman->ActiveChain().Tip(), view_mempool, tx);
|
|
}
|
|
BlockAssembler AssemblerForTest(const CChainParams& params);
|
|
};
|
|
} // namespace miner_tests
|
|
|
|
BOOST_FIXTURE_TEST_SUITE(miner_tests, MinerTestingSetup)
|
|
|
|
static CFeeRate blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE);
|
|
|
|
BlockAssembler MinerTestingSetup::AssemblerForTest(const CChainParams& params)
|
|
{
|
|
BlockAssembler::Options options;
|
|
|
|
options.nBlockMaxWeight = MAX_BLOCK_WEIGHT;
|
|
options.blockMinFeeRate = blockMinFeeRate;
|
|
return BlockAssembler{m_node.chainman->ActiveChainstate(), m_node.mempool.get(), options};
|
|
}
|
|
|
|
constexpr static struct {
|
|
unsigned char extranonce;
|
|
unsigned int nonce;
|
|
} BLOCKINFO[]{{8, 582909131}, {0, 971462344}, {2, 1169481553}, {6, 66147495}, {7, 427785981}, {8, 80538907},
|
|
{8, 207348013}, {2, 1951240923}, {4, 215054351}, {1, 491520534}, {8, 1282281282}, {4, 639565734},
|
|
{3, 248274685}, {8, 1160085976}, {6, 396349768}, {5, 393780549}, {5, 1096899528}, {4, 965381630},
|
|
{0, 728758712}, {5, 318638310}, {3, 164591898}, {2, 274234550}, {2, 254411237}, {7, 561761812},
|
|
{2, 268342573}, {0, 402816691}, {1, 221006382}, {6, 538872455}, {7, 393315655}, {4, 814555937},
|
|
{7, 504879194}, {6, 467769648}, {3, 925972193}, {2, 200581872}, {3, 168915404}, {8, 430446262},
|
|
{5, 773507406}, {3, 1195366164}, {0, 433361157}, {3, 297051771}, {0, 558856551}, {2, 501614039},
|
|
{3, 528488272}, {2, 473587734}, {8, 230125274}, {2, 494084400}, {4, 357314010}, {8, 60361686},
|
|
{7, 640624687}, {3, 480441695}, {8, 1424447925}, {4, 752745419}, {1, 288532283}, {6, 669170574},
|
|
{5, 1900907591}, {3, 555326037}, {3, 1121014051}, {0, 545835650}, {8, 189196651}, {5, 252371575},
|
|
{0, 199163095}, {6, 558895874}, {6, 1656839784}, {6, 815175452}, {6, 718677851}, {5, 544000334},
|
|
{0, 340113484}, {6, 850744437}, {4, 496721063}, {8, 524715182}, {6, 574361898}, {6, 1642305743},
|
|
{6, 355110149}, {5, 1647379658}, {8, 1103005356}, {7, 556460625}, {3, 1139533992}, {5, 304736030},
|
|
{2, 361539446}, {2, 143720360}, {6, 201939025}, {7, 423141476}, {4, 574633709}, {3, 1412254823},
|
|
{4, 873254135}, {0, 341817335}, {6, 53501687}, {3, 179755410}, {5, 172209688}, {8, 516810279},
|
|
{4, 1228391489}, {8, 325372589}, {6, 550367589}, {0, 876291812}, {7, 412454120}, {7, 717202854},
|
|
{2, 222677843}, {6, 251778867}, {7, 842004420}, {7, 194762829}, {4, 96668841}, {1, 925485796},
|
|
{0, 792342903}, {6, 678455063}, {6, 773251385}, {5, 186617471}, {6, 883189502}, {7, 396077336},
|
|
{8, 254702874}, {0, 455592851}};
|
|
|
|
static CBlockIndex CreateBlockIndex(int nHeight, CBlockIndex* active_chain_tip) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
|
|
{
|
|
CBlockIndex index;
|
|
index.nHeight = nHeight;
|
|
index.pprev = active_chain_tip;
|
|
return index;
|
|
}
|
|
|
|
// Test suite for ancestor feerate transaction selection.
|
|
// Implemented as an additional function, rather than a separate test case,
|
|
// to allow reusing the blockchain created in CreateNewBlock_validity.
|
|
void MinerTestingSetup::TestPackageSelection(const CChainParams& chainparams, const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst)
|
|
{
|
|
// Test the ancestor feerate transaction selection.
|
|
TestMemPoolEntryHelper entry;
|
|
|
|
// Test that a medium fee transaction will be selected after a higher fee
|
|
// rate package with a low fee rate parent.
|
|
CMutableTransaction tx;
|
|
tx.vin.resize(1);
|
|
tx.vin[0].scriptSig = CScript() << OP_1;
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vin[0].prevout.n = 0;
|
|
tx.vout.resize(1);
|
|
tx.vout[0].nValue = 5000000000LL - 1000;
|
|
// This tx has a low fee: 1000 satoshis
|
|
uint256 hashParentTx = tx.GetHash(); // save this txid for later use
|
|
m_node.mempool->addUnchecked(entry.Fee(1000).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
|
|
// 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();
|
|
m_node.mempool->addUnchecked(entry.Fee(10000).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
|
|
// 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();
|
|
m_node.mempool->addUnchecked(entry.Fee(50000).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
|
|
|
|
std::unique_ptr<CBlockTemplate> pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
|
|
BOOST_REQUIRE_EQUAL(pblocktemplate->block.vtx.size(), 4U);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[1]->GetHash() == hashParentTx);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[2]->GetHash() == hashHighFeeTx);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[3]->GetHash() == hashMediumFeeTx);
|
|
|
|
// Test that a package below the block min tx fee doesn't get included
|
|
tx.vin[0].prevout.hash = hashHighFeeTx;
|
|
tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 0 fee
|
|
uint256 hashFreeTx = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(0).FromTx(tx));
|
|
size_t freeTxSize = ::GetSerializeSize(tx, PROTOCOL_VERSION);
|
|
|
|
// Calculate a fee on child transaction that will put the package just
|
|
// below the block min tx fee (assuming 1 child tx of the same size).
|
|
CAmount feeToUse = blockMinFeeRate.GetFee(2*freeTxSize) - 1;
|
|
|
|
tx.vin[0].prevout.hash = hashFreeTx;
|
|
tx.vout[0].nValue = 5000000000LL - 1000 - 50000 - feeToUse;
|
|
uint256 hashLowFeeTx = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(feeToUse).FromTx(tx));
|
|
pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
|
|
// Verify that the free tx and the low fee tx didn't get selected
|
|
for (size_t i=0; i<pblocktemplate->block.vtx.size(); ++i) {
|
|
BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashFreeTx);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashLowFeeTx);
|
|
}
|
|
|
|
// Test that packages above the min relay fee do get included, even if one
|
|
// of the transactions is below the min relay fee
|
|
// Remove the low fee transaction and replace with a higher fee transaction
|
|
m_node.mempool->removeRecursive(CTransaction(tx), MemPoolRemovalReason::REPLACED);
|
|
tx.vout[0].nValue -= 2; // Now we should be just over the min relay fee
|
|
hashLowFeeTx = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(feeToUse+2).FromTx(tx));
|
|
pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
|
|
BOOST_REQUIRE_EQUAL(pblocktemplate->block.vtx.size(), 6U);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[4]->GetHash() == hashFreeTx);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[5]->GetHash() == hashLowFeeTx);
|
|
|
|
// Test that transaction selection properly updates ancestor fee
|
|
// calculations as ancestor transactions get included in a block.
|
|
// Add a 0-fee transaction that has 2 outputs.
|
|
tx.vin[0].prevout.hash = txFirst[2]->GetHash();
|
|
tx.vout.resize(2);
|
|
tx.vout[0].nValue = 5000000000LL - 100000000;
|
|
tx.vout[1].nValue = 100000000; // 1BTC output
|
|
uint256 hashFreeTx2 = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(0).SpendsCoinbase(true).FromTx(tx));
|
|
|
|
// This tx can't be mined by itself
|
|
tx.vin[0].prevout.hash = hashFreeTx2;
|
|
tx.vout.resize(1);
|
|
feeToUse = blockMinFeeRate.GetFee(freeTxSize);
|
|
tx.vout[0].nValue = 5000000000LL - 100000000 - feeToUse;
|
|
uint256 hashLowFeeTx2 = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(feeToUse).SpendsCoinbase(false).FromTx(tx));
|
|
pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
|
|
|
|
// Verify that this tx isn't selected.
|
|
for (size_t i=0; i<pblocktemplate->block.vtx.size(); ++i) {
|
|
BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashFreeTx2);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashLowFeeTx2);
|
|
}
|
|
|
|
// This tx will be mineable, and should cause hashLowFeeTx2 to be selected
|
|
// as well.
|
|
tx.vin[0].prevout.n = 1;
|
|
tx.vout[0].nValue = 100000000 - 10000; // 10k satoshi fee
|
|
m_node.mempool->addUnchecked(entry.Fee(10000).FromTx(tx));
|
|
pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
|
|
BOOST_REQUIRE_EQUAL(pblocktemplate->block.vtx.size(), 9U);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[8]->GetHash() == hashLowFeeTx2);
|
|
}
|
|
|
|
void MinerTestingSetup::TestBasicMining(const CChainParams& chainparams, const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst, int baseheight)
|
|
{
|
|
uint256 hash;
|
|
CMutableTransaction tx;
|
|
TestMemPoolEntryHelper entry;
|
|
entry.nFee = 11;
|
|
entry.nHeight = 11;
|
|
|
|
// Just to make sure we can still make simple blocks
|
|
auto pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
|
|
BOOST_CHECK(pblocktemplate);
|
|
|
|
const CAmount BLOCKSUBSIDY = 50*COIN;
|
|
const CAmount LOWFEE = CENT;
|
|
const CAmount HIGHFEE = COIN;
|
|
const CAmount HIGHERFEE = 4*COIN;
|
|
|
|
// block sigops > limit: 1000 CHECKMULTISIG + 1
|
|
tx.vin.resize(1);
|
|
// NOTE: OP_NOP is used to force 20 SigOps for the CHECKMULTISIG
|
|
tx.vin[0].scriptSig = CScript() << OP_0 << OP_0 << OP_0 << OP_NOP << OP_CHECKMULTISIG << OP_1;
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vin[0].prevout.n = 0;
|
|
tx.vout.resize(1);
|
|
tx.vout[0].nValue = BLOCKSUBSIDY;
|
|
for (unsigned int i = 0; i < 1001; ++i)
|
|
{
|
|
tx.vout[0].nValue -= LOWFEE;
|
|
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
|
|
m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
|
|
tx.vin[0].prevout.hash = hash;
|
|
}
|
|
|
|
BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-blk-sigops"));
|
|
m_node.mempool->clear();
|
|
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vout[0].nValue = BLOCKSUBSIDY;
|
|
for (unsigned int i = 0; i < 1001; ++i)
|
|
{
|
|
tx.vout[0].nValue -= LOWFEE;
|
|
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
|
|
m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(spendsCoinbase).SigOpsCost(80).FromTx(tx));
|
|
tx.vin[0].prevout.hash = hash;
|
|
}
|
|
BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
|
|
m_node.mempool->clear();
|
|
|
|
// block size > limit
|
|
tx.vin[0].scriptSig = CScript();
|
|
// 18 * (520char + DROP) + OP_1 = 9433 bytes
|
|
std::vector<unsigned char> vchData(520);
|
|
for (unsigned int i = 0; i < 18; ++i)
|
|
tx.vin[0].scriptSig << vchData << OP_DROP;
|
|
tx.vin[0].scriptSig << OP_1;
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vout[0].nValue = BLOCKSUBSIDY;
|
|
for (unsigned int i = 0; i < 128; ++i)
|
|
{
|
|
tx.vout[0].nValue -= LOWFEE;
|
|
hash = tx.GetHash();
|
|
bool spendsCoinbase = i == 0; // only first tx spends coinbase
|
|
m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
|
|
tx.vin[0].prevout.hash = hash;
|
|
}
|
|
BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
|
|
m_node.mempool->clear();
|
|
|
|
// orphan in *m_node.mempool, template creation fails
|
|
hash = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).FromTx(tx));
|
|
BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
|
|
m_node.mempool->clear();
|
|
|
|
// child with higher feerate than parent
|
|
tx.vin[0].scriptSig = CScript() << OP_1;
|
|
tx.vin[0].prevout.hash = txFirst[1]->GetHash();
|
|
tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
|
|
hash = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
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();
|
|
m_node.mempool->addUnchecked(entry.Fee(HIGHERFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
|
|
m_node.mempool->clear();
|
|
|
|
// coinbase in *m_node.mempool, template creation fails
|
|
tx.vin.resize(1);
|
|
tx.vin[0].prevout.SetNull();
|
|
tx.vin[0].scriptSig = CScript() << OP_0 << OP_1;
|
|
tx.vout[0].nValue = 0;
|
|
hash = tx.GetHash();
|
|
// give it a fee so it'll get mined
|
|
m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
|
|
// Should throw bad-cb-multiple
|
|
BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-cb-multiple"));
|
|
m_node.mempool->clear();
|
|
|
|
// double spend txn pair in *m_node.mempool, template creation fails
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vin[0].scriptSig = CScript() << OP_1;
|
|
tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
|
|
tx.vout[0].scriptPubKey = CScript() << OP_1;
|
|
hash = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
tx.vout[0].scriptPubKey = CScript() << OP_2;
|
|
hash = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("bad-txns-inputs-missingorspent"));
|
|
m_node.mempool->clear();
|
|
|
|
// subsidy changing
|
|
int nHeight = m_node.chainman->ActiveChain().Height();
|
|
// Create an actual 209999-long block chain (without valid blocks).
|
|
while (m_node.chainman->ActiveChain().Tip()->nHeight < 209999) {
|
|
CBlockIndex* prev = m_node.chainman->ActiveChain().Tip();
|
|
CBlockIndex* next = new CBlockIndex();
|
|
next->phashBlock = new uint256(InsecureRand256());
|
|
m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(next->GetBlockHash());
|
|
next->pprev = prev;
|
|
next->nHeight = prev->nHeight + 1;
|
|
next->BuildSkip();
|
|
m_node.chainman->ActiveChain().SetTip(*next);
|
|
}
|
|
BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
|
|
// Extend to a 210000-long block chain.
|
|
while (m_node.chainman->ActiveChain().Tip()->nHeight < 210000) {
|
|
CBlockIndex* prev = m_node.chainman->ActiveChain().Tip();
|
|
CBlockIndex* next = new CBlockIndex();
|
|
next->phashBlock = new uint256(InsecureRand256());
|
|
m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(next->GetBlockHash());
|
|
next->pprev = prev;
|
|
next->nHeight = prev->nHeight + 1;
|
|
next->BuildSkip();
|
|
m_node.chainman->ActiveChain().SetTip(*next);
|
|
}
|
|
BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
|
|
|
|
// invalid p2sh txn in *m_node.mempool, template creation fails
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vin[0].prevout.n = 0;
|
|
tx.vin[0].scriptSig = CScript() << OP_1;
|
|
tx.vout[0].nValue = BLOCKSUBSIDY-LOWFEE;
|
|
CScript script = CScript() << OP_0;
|
|
tx.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(script));
|
|
hash = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
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();
|
|
m_node.mempool->addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
|
|
// Should throw block-validation-failed
|
|
BOOST_CHECK_EXCEPTION(AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error, HasReason("block-validation-failed"));
|
|
m_node.mempool->clear();
|
|
|
|
// Delete the dummy blocks again.
|
|
while (m_node.chainman->ActiveChain().Tip()->nHeight > nHeight) {
|
|
CBlockIndex* del = m_node.chainman->ActiveChain().Tip();
|
|
m_node.chainman->ActiveChain().SetTip(*Assert(del->pprev));
|
|
m_node.chainman->ActiveChainstate().CoinsTip().SetBestBlock(del->pprev->GetBlockHash());
|
|
delete del->phashBlock;
|
|
delete del;
|
|
}
|
|
|
|
// non-final txs in mempool
|
|
SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
|
|
const int flags{LOCKTIME_VERIFY_SEQUENCE};
|
|
// height map
|
|
std::vector<int> prevheights;
|
|
|
|
// relative height locked
|
|
tx.nVersion = 2;
|
|
tx.vin.resize(1);
|
|
prevheights.resize(1);
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash(); // only 1 transaction
|
|
tx.vin[0].prevout.n = 0;
|
|
tx.vin[0].scriptSig = CScript() << OP_1;
|
|
tx.vin[0].nSequence = m_node.chainman->ActiveChain().Tip()->nHeight + 1; // txFirst[0] is the 2nd block
|
|
prevheights[0] = baseheight + 1;
|
|
tx.vout.resize(1);
|
|
tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
|
|
tx.vout[0].scriptPubKey = CScript() << OP_1;
|
|
tx.nLockTime = 0;
|
|
hash = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
|
|
BOOST_CHECK(!TestSequenceLocks(CTransaction{tx})); // Sequence locks fail
|
|
|
|
{
|
|
CBlockIndex* active_chain_tip = m_node.chainman->ActiveChain().Tip();
|
|
BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, CreateBlockIndex(active_chain_tip->nHeight + 2, active_chain_tip))); // Sequence locks pass on 2nd block
|
|
}
|
|
|
|
// relative time locked
|
|
tx.vin[0].prevout.hash = txFirst[1]->GetHash();
|
|
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();
|
|
m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));
|
|
BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
|
|
BOOST_CHECK(!TestSequenceLocks(CTransaction{tx})); // Sequence locks fail
|
|
|
|
const int SEQUENCE_LOCK_TIME = 512; // Sequence locks pass 512 seconds later
|
|
for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i)
|
|
m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i)->nTime += SEQUENCE_LOCK_TIME; // Trick the MedianTimePast
|
|
{
|
|
CBlockIndex* active_chain_tip = m_node.chainman->ActiveChain().Tip();
|
|
BOOST_CHECK(SequenceLocks(CTransaction(tx), flags, prevheights, CreateBlockIndex(active_chain_tip->nHeight + 1, active_chain_tip)));
|
|
}
|
|
|
|
for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i) {
|
|
CBlockIndex* ancestor{Assert(m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i))};
|
|
ancestor->nTime -= SEQUENCE_LOCK_TIME; // undo tricked MTP
|
|
}
|
|
|
|
// absolute height locked
|
|
tx.vin[0].prevout.hash = txFirst[2]->GetHash();
|
|
tx.vin[0].nSequence = CTxIn::MAX_SEQUENCE_NONFINAL;
|
|
prevheights[0] = baseheight + 3;
|
|
tx.nLockTime = m_node.chainman->ActiveChain().Tip()->nHeight + 1;
|
|
hash = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));
|
|
BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
|
|
BOOST_CHECK(TestSequenceLocks(CTransaction{tx})); // 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
|
|
|
|
// absolute time locked
|
|
tx.vin[0].prevout.hash = txFirst[3]->GetHash();
|
|
tx.nLockTime = m_node.chainman->ActiveChain().Tip()->GetMedianTimePast();
|
|
prevheights.resize(1);
|
|
prevheights[0] = baseheight + 4;
|
|
hash = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Time(GetTime()).FromTx(tx));
|
|
BOOST_CHECK(!CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime fails
|
|
BOOST_CHECK(TestSequenceLocks(CTransaction{tx})); // 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
|
|
|
|
// 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;
|
|
BOOST_CHECK(CheckFinalTxAtTip(*Assert(m_node.chainman->ActiveChain().Tip()), CTransaction{tx})); // Locktime passes
|
|
BOOST_CHECK(TestSequenceLocks(CTransaction{tx})); // Sequence locks pass
|
|
tx.vin[0].nSequence = 1;
|
|
BOOST_CHECK(!TestSequenceLocks(CTransaction{tx})); // Sequence locks fail
|
|
tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;
|
|
BOOST_CHECK(TestSequenceLocks(CTransaction{tx})); // Sequence locks pass
|
|
tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;
|
|
BOOST_CHECK(!TestSequenceLocks(CTransaction{tx})); // Sequence locks fail
|
|
|
|
BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
|
|
|
|
// None of the of the absolute height/time locked tx should have made
|
|
// it into the template because we still check IsFinalTx in CreateNewBlock,
|
|
// but relative locked txs will if inconsistently added to mempool.
|
|
// For now these will still generate a valid template until BIP68 soft fork
|
|
BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 3U);
|
|
// However if we advance height by 1 and time by SEQUENCE_LOCK_TIME, all of them should be mined
|
|
for (int i = 0; i < CBlockIndex::nMedianTimeSpan; ++i) {
|
|
CBlockIndex* ancestor{Assert(m_node.chainman->ActiveChain().Tip()->GetAncestor(m_node.chainman->ActiveChain().Tip()->nHeight - i))};
|
|
ancestor->nTime += SEQUENCE_LOCK_TIME; // Trick the MedianTimePast
|
|
}
|
|
m_node.chainman->ActiveChain().Tip()->nHeight++;
|
|
SetMockTime(m_node.chainman->ActiveChain().Tip()->GetMedianTimePast() + 1);
|
|
|
|
BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
|
|
BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 5U);
|
|
}
|
|
|
|
void MinerTestingSetup::TestPrioritisedMining(const CChainParams& chainparams, const CScript& scriptPubKey, const std::vector<CTransactionRef>& txFirst)
|
|
{
|
|
TestMemPoolEntryHelper entry;
|
|
|
|
// Test that a tx below min fee but prioritised is included
|
|
CMutableTransaction tx;
|
|
tx.vin.resize(1);
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vin[0].prevout.n = 0;
|
|
tx.vin[0].scriptSig = CScript() << OP_1;
|
|
tx.vout.resize(1);
|
|
tx.vout[0].nValue = 5000000000LL; // 0 fee
|
|
uint256 hashFreePrioritisedTx = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(0).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
m_node.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
|
|
m_node.mempool->addUnchecked(entry.Fee(1000).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
|
|
// 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();
|
|
m_node.mempool->addUnchecked(entry.Fee(10000).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
m_node.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();
|
|
m_node.mempool->addUnchecked(entry.Fee(1000).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
|
|
m_node.mempool->PrioritiseTransaction(hashPrioritsedChild, 2 * COIN);
|
|
|
|
// Test that transaction selection properly updates ancestor fee calculations as prioritised
|
|
// parents get included in a block. Create a transaction with two prioritised ancestors, each
|
|
// included by itself: FreeParent <- FreeChild <- FreeGrandchild.
|
|
// When FreeParent is added, a modified entry will be created for FreeChild + FreeGrandchild
|
|
// FreeParent's prioritisation should not be included in that entry.
|
|
// When FreeChild is included, FreeChild's prioritisation should also not be included.
|
|
tx.vin[0].prevout.hash = txFirst[3]->GetHash();
|
|
tx.vout[0].nValue = 5000000000LL; // 0 fee
|
|
uint256 hashFreeParent = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(0).SpendsCoinbase(true).FromTx(tx));
|
|
m_node.mempool->PrioritiseTransaction(hashFreeParent, 10 * COIN);
|
|
|
|
tx.vin[0].prevout.hash = hashFreeParent;
|
|
tx.vout[0].nValue = 5000000000LL; // 0 fee
|
|
uint256 hashFreeChild = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(0).SpendsCoinbase(false).FromTx(tx));
|
|
m_node.mempool->PrioritiseTransaction(hashFreeChild, 1 * COIN);
|
|
|
|
tx.vin[0].prevout.hash = hashFreeChild;
|
|
tx.vout[0].nValue = 5000000000LL; // 0 fee
|
|
uint256 hashFreeGrandchild = tx.GetHash();
|
|
m_node.mempool->addUnchecked(entry.Fee(0).SpendsCoinbase(false).FromTx(tx));
|
|
|
|
auto pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
|
|
BOOST_REQUIRE_EQUAL(pblocktemplate->block.vtx.size(), 6U);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[1]->GetHash() == hashFreeParent);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[2]->GetHash() == hashFreePrioritisedTx);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[3]->GetHash() == hashParentTx);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[4]->GetHash() == hashPrioritsedChild);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[5]->GetHash() == hashFreeChild);
|
|
for (size_t i=0; i<pblocktemplate->block.vtx.size(); ++i) {
|
|
// The FreeParent and FreeChild's prioritisations should not impact the child.
|
|
BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashFreeGrandchild);
|
|
// De-prioritised transaction should not be included.
|
|
BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashMediumFeeTx);
|
|
}
|
|
}
|
|
|
|
// NOTE: These tests rely on CreateNewBlock doing its own self-validation!
|
|
BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
|
|
{
|
|
// Note that by default, these tests run with size accounting enabled.
|
|
const auto chainParams = CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
|
|
const CChainParams& chainparams = *chainParams;
|
|
CScript scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
|
|
std::unique_ptr<CBlockTemplate> pblocktemplate;
|
|
|
|
fCheckpointsEnabled = false;
|
|
|
|
// Simple block creation, nothing special yet:
|
|
BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
|
|
|
|
// We can't make transactions until we have inputs
|
|
// Therefore, load 110 blocks :)
|
|
static_assert(std::size(BLOCKINFO) == 110, "Should have 110 blocks to import");
|
|
int baseheight = 0;
|
|
std::vector<CTransactionRef> txFirst;
|
|
for (const auto& bi : BLOCKINFO) {
|
|
CBlock *pblock = &pblocktemplate->block; // pointer for convenience
|
|
{
|
|
LOCK(cs_main);
|
|
pblock->nVersion = VERSIONBITS_TOP_BITS;
|
|
pblock->nTime = m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()+1;
|
|
CMutableTransaction txCoinbase(*pblock->vtx[0]);
|
|
txCoinbase.nVersion = 1;
|
|
txCoinbase.vin[0].scriptSig = CScript{} << (m_node.chainman->ActiveChain().Height() + 1) << bi.extranonce;
|
|
txCoinbase.vout.resize(1); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this)
|
|
txCoinbase.vout[0].scriptPubKey = CScript();
|
|
pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
|
|
if (txFirst.size() == 0)
|
|
baseheight = m_node.chainman->ActiveChain().Height();
|
|
if (txFirst.size() < 4)
|
|
txFirst.push_back(pblock->vtx[0]);
|
|
pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
|
|
pblock->nNonce = bi.nonce;
|
|
}
|
|
std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(*pblock);
|
|
BOOST_CHECK(Assert(m_node.chainman)->ProcessNewBlock(shared_pblock, true, true, nullptr));
|
|
pblock->hashPrevBlock = pblock->GetHash();
|
|
}
|
|
|
|
LOCK(cs_main);
|
|
LOCK(m_node.mempool->cs);
|
|
|
|
TestBasicMining(chainparams, scriptPubKey, txFirst, baseheight);
|
|
|
|
m_node.chainman->ActiveChain().Tip()->nHeight--;
|
|
SetMockTime(0);
|
|
m_node.mempool->clear();
|
|
|
|
TestPackageSelection(chainparams, scriptPubKey, txFirst);
|
|
|
|
m_node.chainman->ActiveChain().Tip()->nHeight--;
|
|
SetMockTime(0);
|
|
m_node.mempool->clear();
|
|
|
|
TestPrioritisedMining(chainparams, scriptPubKey, txFirst);
|
|
|
|
fCheckpointsEnabled = true;
|
|
}
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|