7 #include <chainparams.h>
19 #include <boost/test/unit_test.hpp>
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;
72 CBlock& block = pblocktemplate->block;
94 const CScript& coinbase_script_pub_key,
96 std::vector<std::shared_ptr<CBlock>>& chain)
98 std::vector<CMutableTransaction> no_txns;
100 chain.resize(length);
101 for (
auto& block : chain) {
102 block = std::make_shared<CBlock>(
CreateBlock(pindex, no_txns, coinbase_script_pub_key));
117 BOOST_REQUIRE(filter_index.
Init());
127 std::vector<BlockFilter> filters;
128 std::vector<uint256> filter_hashes;
131 block_index !=
nullptr;
142 BOOST_CHECK(!filter_index.BlockUntilSyncedToCurrentChain());
154 block_index !=
nullptr;
170 std::vector<std::shared_ptr<CBlock>> chainA, chainB;
171 BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key_A, 10, chainA));
172 BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key_B, 10, chainB));
175 uint256 chainA_last_header = last_header;
176 for (
size_t i = 0; i < 2; i++) {
177 const auto& block = chainA[i];
180 for (
size_t i = 0; i < 2; i++) {
181 const auto& block = chainA[i];
185 block_index =
m_node.
chainman->m_blockman.LookupBlockIndex(block->GetHash());
188 BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
193 uint256 chainB_last_header = last_header;
194 for (
size_t i = 0; i < 3; i++) {
195 const auto& block = chainB[i];
198 for (
size_t i = 0; i < 3; i++) {
199 const auto& block = chainB[i];
203 block_index =
m_node.
chainman->m_blockman.LookupBlockIndex(block->GetHash());
206 BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
211 chainA_last_header = last_header;
212 for (
size_t i = 0; i < 2; i++) {
213 const auto& block = chainA[i];
217 block_index =
m_node.
chainman->m_blockman.LookupBlockIndex(block->GetHash());
220 BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
225 for (
size_t i = 2; i < 4; i++) {
226 const auto& block = chainA[i];
231 chainA_last_header = last_header;
232 chainB_last_header = last_header;
233 for (
size_t i = 0; i < 3; i++) {
238 block_index =
m_node.
chainman->m_blockman.LookupBlockIndex(chainA[i]->GetHash());
240 BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
245 block_index =
m_node.
chainman->m_blockman.LookupBlockIndex(chainB[i]->GetHash());
247 BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
252 std::vector<BlockFilter> filters;
253 std::vector<uint256> filter_hashes;
267 filter_hashes.clear();
269 filter_index.Interrupt();
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.
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 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.
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...
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
BOOST_AUTO_TEST_SUITE(cuckoocache_tests)
Test Suite for CuckooCache.
BOOST_AUTO_TEST_SUITE_END()
void IndexWaitSynced(const BaseIndex &index, const util::SignalInterrupt &interrupt)
Block until the index is synced to the current chain.
CKey GenerateRandomKey(bool compressed) noexcept
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
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)
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.
std::unique_ptr< CTxMemPool > mempool
std::unique_ptr< ChainstateManager > chainman
util::SignalInterrupt * shutdown
Interrupt object used to track whether node shutdown was requested.
bool ComputeFilter(BlockFilterType filter_type, const CBlockIndex &block_index, BlockFilter &filter, const BlockManager &blockman)