5 #include <boost/test/unit_test.hpp>
7 #include <chainparams.h>
29 std::shared_ptr<CBlock>
FinalizeBlock(std::shared_ptr<CBlock> pblock);
30 void BuildChain(
const uint256& root,
int height,
const unsigned int invalid_rate,
const unsigned int branch_rate,
const unsigned int max_size, std::vector<std::shared_ptr<const CBlock>>& blocks);
51 m_expected_tip = block->GetHash();
59 m_expected_tip = block->hashPrevBlock;
63 std::shared_ptr<CBlock> MinerTestingSetup::Block(
const uint256& prev_hash)
69 auto pblock = std::make_shared<CBlock>(ptemplate->block);
70 pblock->hashPrevBlock = prev_hash;
71 pblock->nTime = ++time;
77 txCoinbase.
vout.resize(2);
79 txCoinbase.
vout[1].nValue = txCoinbase.
vout[0].nValue;
80 txCoinbase.
vout[0].nValue = 0;
81 txCoinbase.
vin[0].scriptWitness.SetNull();
89 std::shared_ptr<CBlock> MinerTestingSetup::FinalizeBlock(std::shared_ptr<CBlock> pblock)
109 std::shared_ptr<const CBlock> MinerTestingSetup::GoodBlock(
const uint256& prev_hash)
111 return FinalizeBlock(Block(prev_hash));
115 std::shared_ptr<const CBlock> MinerTestingSetup::BadBlock(
const uint256& prev_hash)
117 auto pblock = Block(prev_hash);
121 coinbase_spend.
vout.push_back(pblock->vtx[0]->vout[0]);
124 pblock->vtx.push_back(tx);
126 auto ret = FinalizeBlock(pblock);
131 void MinerTestingSetup::BuildChain(
const uint256& root,
int height,
const unsigned int invalid_rate,
const unsigned int branch_rate,
const unsigned int max_size, std::vector<std::shared_ptr<const CBlock>>& blocks)
133 if (height <= 0 || blocks.size() >= max_size)
return;
138 const std::shared_ptr<const CBlock> pblock = gen_invalid ? BadBlock(root) : GoodBlock(root);
139 blocks.push_back(pblock);
141 BuildChain(pblock->GetHash(), height - 1, invalid_rate, branch_rate, max_size, blocks);
145 blocks.push_back(GoodBlock(root));
146 BuildChain(blocks.back()->GetHash(), height - 1, invalid_rate, branch_rate, max_size, blocks);
153 std::vector<std::shared_ptr<const CBlock>> blocks;
154 while (blocks.size() < 50) {
156 BuildChain(
Params().GenesisBlock().GetHash(), 100, 15, 10, 500, blocks);
170 auto sub = std::make_shared<TestSubscriber>(initial_tip->
GetBlockHash());
176 std::vector<std::thread> threads;
178 for (
int i = 0; i < 10; i++) {
179 threads.emplace_back([&]() {
182 for (
int i = 0; i < 1000; i++) {
183 auto block = blocks[insecure.
randrange(blocks.size() - 1)];
188 for (
const auto& block : blocks) {
189 if (block->vtx.size() == 1) {
190 bool processed = Assert(m_node.chainman)->ProcessNewBlock(block, true, true, &ignored);
197 for (
auto&
t : threads) {
228 auto ProcessBlock = [&](std::shared_ptr<const CBlock> block) ->
bool {
233 BOOST_REQUIRE(ProcessBlock(std::make_shared<CBlock>(
Params().GenesisBlock())));
234 auto last_mined = GoodBlock(
Params().GenesisBlock().GetHash());
235 BOOST_REQUIRE(ProcessBlock(last_mined));
238 for (
int test_runs = 3; test_runs > 0; --test_runs) {
242 const uint256 split_hash{last_mined->hashPrevBlock};
246 std::vector<CTransactionRef> txs;
247 for (
int num_txs = 22; num_txs > 0; --num_txs) {
251 mtx.
vout.push_back(last_mined->vtx[0]->vout[1]);
252 mtx.
vout[0].nValue -= 1000;
255 last_mined = GoodBlock(last_mined->GetHash());
256 BOOST_REQUIRE(ProcessBlock(last_mined));
261 last_mined = GoodBlock(last_mined->GetHash());
262 BOOST_REQUIRE(ProcessBlock(last_mined));
266 const uint256 tip_init{last_mined->GetHash()};
268 std::vector<std::shared_ptr<const CBlock>> reorg;
269 last_mined = GoodBlock(split_hash);
270 reorg.push_back(last_mined);
272 last_mined = GoodBlock(last_mined->GetHash());
273 reorg.push_back(last_mined);
279 for (
const auto& tx : txs) {
292 std::thread rpc_thread{[&]() {
316 for (
const auto& b : reorg) {
333 CBlock pblock = ptemplate->block;
345 CTxOut min_plus_one = witness;
352 txCoinbase.
vout.resize(4);
353 txCoinbase.
vout[0] = witness;
354 txCoinbase.
vout[1] = witness;
355 txCoinbase.
vout[2] = min_plus_one;
356 txCoinbase.
vout[3] = invalid;
const CChainParams & Params()
Return the currently selected parameters.
#define Assert(val)
Identity function.
std::vector< CTransactionRef > vtx
The block chain is a tree shaped structure starting with the genesis block at the root,...
CBlockIndex * pprev
pointer to the index of the predecessor of this block
uint256 GetBlockHash() const
const CBlock & GenesisBlock() const
An outpoint - a combination of a transaction hash and an index n into its vout.
Serialized script, used inside transaction inputs and outputs.
An output of a transaction.
Implement this to subscribe to events generated in validation and mempool.
uint64_t randrange(uint64_t range) noexcept
Generate a random integer in the range [0..range).
Generate a new block, without valid proof-of-work.
void resize(size_type new_size)
static constexpr size_t MINIMUM_WITNESS_COMMITMENT
Minimum size of a witness commitment structure.
int GetWitnessCommitmentIndex(const CBlock &block)
Compute at which vout of the block's coinbase transaction the witness commitment occurs,...
static const int COINBASE_MATURITY
Coinbase transaction outputs can only be spent after this number of new blocks (network rule)
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
BOOST_AUTO_TEST_SUITE_END()
ChainstateRole
This enum describes the various roles a specific Chainstate instance can take.
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
#define BOOST_CHECK_EQUAL(v1, v2)
#define BOOST_CHECK(expr)
bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params ¶ms)
Check whether a block hash satisfies the proof-of-work requirement specified by nBits.
static CTransactionRef MakeTransactionRef(Tx &&txIn)
std::shared_ptr< const CTransaction > CTransactionRef
A mutable version of CTransaction.
std::vector< CTxOut > vout
Validation result for a transaction evaluated by MemPoolAccept (single or package).
const ResultType m_result_type
Result type.
Identical to TestingSetup, but chain set to regtest.
void BlockDisconnected(const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex) override
Notifies listeners of a block being disconnected Provides the block that was disconnected.
TestSubscriber(uint256 tip)
void BlockConnected(ChainstateRole role, const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex) override
Notifies listeners of a block being connected.
void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override
Notifies listeners when the block chain tip advances.
std::unique_ptr< ValidationSignals > validation_signals
Issues calls about blocks and transactions.
std::unique_ptr< CTxMemPool > mempool
std::unique_ptr< ChainstateManager > chainman
void BuildChain(const uint256 &root, int height, const unsigned int invalid_rate, const unsigned int branch_rate, const unsigned int max_size, std::vector< std::shared_ptr< const CBlock >> &blocks)
std::shared_ptr< const CBlock > BadBlock(const uint256 &prev_hash)
std::shared_ptr< CBlock > Block(const uint256 &prev_hash)
std::shared_ptr< const CBlock > GoodBlock(const uint256 &prev_hash)
std::shared_ptr< CBlock > FinalizeBlock(std::shared_ptr< CBlock > pblock)
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
static uint64_t InsecureRandRange(uint64_t range)
static const std::vector< uint8_t > WITNESS_STACK_ELEM_OP_TRUE
static const CScript P2WSH_OP_TRUE
BOOST_AUTO_TEST_CASE(processnewblock_signals_ordering)