7#include <chainparams.h>
18#include <boost/test/unit_test.hpp>
25BOOST_AUTO_TEST_SUITE(blockfilter_index_tests)
28 CBlock CreateBlock(
const CBlockIndex* prev,
const std::vector<CMutableTransaction>& txns,
const CScript& scriptPubKey);
29 bool BuildChain(
const CBlockIndex* pindex,
const CScript& coinbase_script_pub_key,
size_t length, std::vector<std::shared_ptr<CBlock>>& chain);
37 BOOST_ERROR(
"ComputeFilter failed on block " << block_index->
nHeight);
43 std::vector<BlockFilter> filters;
44 std::vector<uint256> filter_hashes;
61 filter_hashes.clear();
62 last_header = filter_header;
67 const std::vector<CMutableTransaction>& txns,
70 BlockAssembler::Options options;
71 options.coinbase_output_script = scriptPubKey;
73 CBlock& block = pblocktemplate->block;
84 tx_coinbase.nLockTime =
static_cast<uint32_t
>(prev->
nHeight);
96 const CScript& coinbase_script_pub_key,
98 std::vector<std::shared_ptr<CBlock>>& chain)
100 std::vector<CMutableTransaction> no_txns;
102 chain.resize(length);
103 for (
auto& block : chain) {
104 block = std::make_shared<CBlock>(
CreateBlock(pindex, no_txns, coinbase_script_pub_key));
119 BOOST_REQUIRE(filter_index.
Init());
129 std::vector<BlockFilter> filters;
130 std::vector<uint256> filter_hashes;
133 block_index !=
nullptr;
144 BOOST_CHECK(!filter_index.BlockUntilSyncedToCurrentChain());
153 block_index !=
nullptr;
169 std::vector<std::shared_ptr<CBlock>> chainA, chainB;
170 BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key_A, 10, chainA));
171 BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key_B, 10, chainB));
174 uint256 chainA_last_header = last_header;
175 for (
size_t i = 0; i < 2; i++) {
176 const auto& block = chainA[i];
179 for (
size_t i = 0; i < 2; i++) {
180 const auto& block = chainA[i];
184 block_index =
m_node.
chainman->m_blockman.LookupBlockIndex(block->GetHash());
187 BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
192 uint256 chainB_last_header = last_header;
193 for (
size_t i = 0; i < 3; i++) {
194 const auto& block = chainB[i];
197 for (
size_t i = 0; i < 3; i++) {
198 const auto& block = chainB[i];
202 block_index =
m_node.
chainman->m_blockman.LookupBlockIndex(block->GetHash());
205 BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
210 chainA_last_header = last_header;
211 for (
size_t i = 0; i < 2; i++) {
212 const auto& block = chainA[i];
216 block_index =
m_node.
chainman->m_blockman.LookupBlockIndex(block->GetHash());
219 BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
224 for (
size_t i = 2; i < 4; i++) {
225 const auto& block = chainA[i];
230 chainA_last_header = last_header;
231 chainB_last_header = last_header;
232 for (
size_t i = 0; i < 3; i++) {
237 block_index =
m_node.
chainman->m_blockman.LookupBlockIndex(chainA[i]->GetHash());
239 BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
244 block_index =
m_node.
chainman->m_blockman.LookupBlockIndex(chainB[i]->GetHash());
246 BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
251 std::vector<BlockFilter> filters;
252 std::vector<uint256> filter_hashes;
266 filter_hashes.clear();
312 std::unique_ptr<BaseIndex::DB>
m_db;
317 explicit IndexReorgCrash(std::unique_ptr<interfaces::Chain> chain, std::shared_future<void> blocker,
323 m_db = std::make_unique<BaseIndex::DB>(path /
"db", 0,
true,
false);
348 std::promise<void> promise;
349 std::shared_future<void> blocker(promise.get_future());
353 BOOST_REQUIRE(index.
Init());
356 auto func_wait_until = [&](
int height, std::chrono::milliseconds timeout) {
357 auto deadline = std::chrono::steady_clock::now() + timeout;
359 if (std::chrono::steady_clock::now() > deadline) {
363 std::this_thread::sleep_for(100ms);
368 func_wait_until(blocking_height - 1, 5
s);
371 std::vector<std::shared_ptr<CBlock>> fork;
375 for (
const auto& block : fork) {
376 BOOST_REQUIRE(
m_node.
chainman->ProcessNewBlock(block,
true,
true,
nullptr));
382 func_wait_until(blocking_height + 2, 5
s);
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
static bool CheckFilterLookups(BlockFilterIndex &filter_index, const CBlockIndex *block_index, uint256 &last_header, const BlockManager &blockman)
BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, BuildChainTestingSetup)
bool DestroyBlockFilterIndex(BlockFilterType filter_type)
Destroy the block filter index with the given type.
void DestroyAllBlockFilterIndexes()
Destroy all open block filter indexes.
BlockFilterIndex * GetBlockFilterIndex(BlockFilterType filter_type)
Get a block filter index by type.
void ForEachBlockFilterIndex(std::function< void(BlockFilterIndex &)> fn)
Iterate over all running block filter indexes, invoking fn on each.
bool InitBlockFilterIndex(std::function< std::unique_ptr< interfaces::Chain >()> make_chain, BlockFilterType filter_type, size_t n_cache_size, bool f_memory, bool f_wipe)
Initialize a block filter index for the given type if one does not already exist.
#define Assert(val)
Identity function.
fs::path GetDataDirNet() const
Get data directory path with appended network identifier.
The database stores a block locator of the chain the database is synced to so that the index can effi...
Base class for indices of blockchain data.
void Stop()
Stops the instance from staying in sync with blockchain updates.
bool Init()
Initializes the sync state and registers the instance to the validation interface so that it stays in...
bool BlockUntilSyncedToCurrentChain() const LOCKS_EXCLUDED(void Interrupt()
Blocks the current thread until the index is caught up to the current state of the block chain.
IndexSummary GetSummary() const
Get a summary of the index and its state.
void Sync()
Sync the index with the block index starting from the current best block.
bool StartBackgroundSync()
Starts the initial sync process on a background thread.
Complete block filter struct as defined in BIP 157.
uint256 ComputeHeader(const uint256 &prev_header) const
Compute the filter header given the previous one.
uint256 GetHash() const
Compute the filter hash.
BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of bloc...
bool LookupFilterRange(int start_height, const CBlockIndex *stop_index, std::vector< BlockFilter > &filters_out) const
Get a range of filters between two heights on a chain.
BlockFilterType GetFilterType() const
bool LookupFilter(const CBlockIndex *block_index, BlockFilter &filter_out) const
Get a single filter by block.
bool LookupFilterHashRange(int start_height, const CBlockIndex *stop_index, std::vector< uint256 > &hashes_out) const
Get a range of filter hashes between two heights on a chain.
bool LookupFilterHeader(const CBlockIndex *block_index, uint256 &header_out) EXCLUSIVE_LOCKS_REQUIRED(!m_cs_headers_cache)
Get a single filter header by block.
std::vector< CTransactionRef > vtx
The block chain is a tree shaped structure starting with the genesis block at the root,...
uint256 GetBlockHash() const
int nHeight
height of the entry in the chain. The genesis block has height 0
An encapsulated private key.
CPubKey GetPubKey() const
Compute the public key from a private key.
Serialized script, used inside transaction inputs and outputs.
bool CustomAppend(const interfaces::BlockInfo &block) override
Write update index entries for a newly connected block.
std::unique_ptr< BaseIndex::DB > m_db
BaseIndex::DB & GetDB() const override
IndexReorgCrash(std::unique_ptr< interfaces::Chain > chain, std::shared_future< void > blocker, int blocking_height)
bool AllowPrune() const override
std::shared_future< void > m_blocker
Generate a new block, without valid proof-of-work.
Maintains a tree of blocks (stored in m_block_index) which is consulted to determine where the most-w...
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
BOOST_AUTO_TEST_SUITE_END()
static bool create_directories(const std::filesystem::path &p)
Create directory (and if necessary its parents), unless the leaf directory already exists or is a sym...
CKey GenerateRandomKey(bool compressed) noexcept
std::unique_ptr< Chain > MakeChain(node::NodeContext &node)
Return implementation of Chain interface.
#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)
static bool GetPubKey(const SigningProvider &provider, const SignatureData &sigdata, const CKeyID &address, CPubKey &pubkey)
bool BuildChain(const CBlockIndex *pindex, const CScript &coinbase_script_pub_key, size_t length, std::vector< std::shared_ptr< CBlock > > &chain)
CBlock CreateBlock(const CBlockIndex *prev, const std::vector< CMutableTransaction > &txns, const CScript &scriptPubKey)
A mutable version of CTransaction.
Testing fixture that pre-creates a 100-block REGTEST-mode block chain.
Block data sent with blockConnected, blockDisconnected notifications.
std::unique_ptr< CTxMemPool > mempool
std::unique_ptr< ChainstateManager > chainman
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
bool ComputeFilter(BlockFilterType filter_type, const CBlockIndex &block_index, BlockFilter &filter, const BlockManager &blockman)
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.