5 #include <boost/test/unit_test.hpp>
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);
130 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)
132 if (height <= 0 || blocks.size() >= max_size)
return;
137 const std::shared_ptr<const CBlock> pblock = gen_invalid ? BadBlock(root) : GoodBlock(root);
138 blocks.push_back(pblock);
140 BuildChain(pblock->GetHash(), height - 1, invalid_rate, branch_rate, max_size, blocks);
144 blocks.push_back(GoodBlock(root));
145 BuildChain(blocks.back()->GetHash(), height - 1, invalid_rate, branch_rate, max_size, blocks);
152 std::vector<std::shared_ptr<const CBlock>> blocks;
153 while (blocks.size() < 50) {
155 BuildChain(
Params().GenesisBlock().GetHash(), 100, 15, 10, 500, blocks);
169 auto sub = std::make_shared<TestSubscriber>(initial_tip->
GetBlockHash());
175 std::vector<std::thread> threads;
176 for (
int i = 0; i < 10; i++) {
177 threads.emplace_back([&]() {
180 for (
int i = 0; i < 1000; i++) {
181 auto block = blocks[insecure.
randrange(blocks.size() - 1)];
186 for (
const auto& block : blocks) {
187 if (block->vtx.size() == 1) {
188 bool processed = Assert(m_node.chainman)->ProcessNewBlock(block, true, true, &ignored);
195 for (
auto&
t : threads) {
226 auto ProcessBlock = [&](std::shared_ptr<const CBlock> block) ->
bool {
231 BOOST_REQUIRE(ProcessBlock(std::make_shared<CBlock>(
Params().GenesisBlock())));
232 auto last_mined = GoodBlock(
Params().GenesisBlock().GetHash());
233 BOOST_REQUIRE(ProcessBlock(last_mined));
236 for (
int test_runs = 3; test_runs > 0; --test_runs) {
240 const uint256 split_hash{last_mined->hashPrevBlock};
244 std::vector<CTransactionRef> txs;
245 for (
int num_txs = 22; num_txs > 0; --num_txs) {
249 mtx.
vout.push_back(last_mined->vtx[0]->vout[1]);
250 mtx.
vout[0].nValue -= 1000;
253 last_mined = GoodBlock(last_mined->GetHash());
254 BOOST_REQUIRE(ProcessBlock(last_mined));
259 last_mined = GoodBlock(last_mined->GetHash());
260 BOOST_REQUIRE(ProcessBlock(last_mined));
264 const uint256 tip_init{last_mined->GetHash()};
266 std::vector<std::shared_ptr<const CBlock>> reorg;
267 last_mined = GoodBlock(split_hash);
268 reorg.push_back(last_mined);
270 last_mined = GoodBlock(last_mined->GetHash());
271 reorg.push_back(last_mined);
277 for (
const auto& tx : txs) {
291 std::thread rpc_thread{[&]() {
315 for (
const auto& b : reorg) {
332 CBlock pblock = ptemplate->block;
344 CTxOut min_plus_one = witness;
351 txCoinbase.
vout.resize(4);
352 txCoinbase.
vout[0] = witness;
353 txCoinbase.
vout[1] = witness;
354 txCoinbase.
vout[2] = min_plus_one;
355 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 input of a transaction.
An output of a transaction.
Implement this to subscribe to events generated in validation.
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()
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
static uint64_t InsecureRandRange(uint64_t range)
A mutable version of CTransaction.
std::vector< CTxOut > vout
Validation result for a single transaction mempool acceptance.
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.
TestSubscriber(uint256 tip)
void UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) override
Notifies listeners when the block chain tip advances.
void BlockConnected(const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex) override
Notifies listeners of a block being connected.
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 const std::vector< uint8_t > WITNESS_STACK_ELEM_OP_TRUE
static const CScript P2WSH_OP_TRUE
BOOST_AUTO_TEST_CASE(processnewblock_signals_ordering)
void UnregisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Unregister subscriber.
void SyncWithValidationInterfaceQueue()
This is a synonym for the following, which asserts certain locks are not held: std::promise<void> pro...
void RegisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Register subscriber.