Branch data Line data Source code
1 : : // Copyright (c) 2017-2022 The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <addresstype.h>
6 : : #include <blockfilter.h>
7 : : #include <chainparams.h>
8 : : #include <consensus/merkle.h>
9 : : #include <consensus/validation.h>
10 : : #include <index/blockfilterindex.h>
11 : : #include <interfaces/chain.h>
12 : : #include <node/miner.h>
13 : : #include <pow.h>
14 : : #include <test/util/blockfilter.h>
15 : : #include <test/util/index.h>
16 : : #include <test/util/setup_common.h>
17 : 0 : #include <validation.h>
18 : 0 :
19 : : #include <boost/test/unit_test.hpp>
20 : :
21 : : using node::BlockAssembler;
22 : : using node::BlockManager;
23 : : using node::CBlockTemplate;
24 : :
25 : 0 : BOOST_AUTO_TEST_SUITE(blockfilter_index_tests)
26 : :
27 : 0 : struct BuildChainTestingSetup : public TestChain100Setup {
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);
30 : : };
31 : :
32 : 0 : static bool CheckFilterLookups(BlockFilterIndex& filter_index, const CBlockIndex* block_index,
33 : : uint256& last_header, const BlockManager& blockman)
34 : : {
35 : 0 : BlockFilter expected_filter;
36 : 0 : if (!ComputeFilter(filter_index.GetFilterType(), *block_index, expected_filter, blockman)) {
37 : 0 : BOOST_ERROR("ComputeFilter failed on block " << block_index->nHeight);
38 : 0 : return false;
39 : : }
40 : :
41 : 0 : BlockFilter filter;
42 : 0 : uint256 filter_header;
43 : 0 : std::vector<BlockFilter> filters;
44 : 0 : std::vector<uint256> filter_hashes;
45 : :
46 : 0 : BOOST_CHECK(filter_index.LookupFilter(block_index, filter));
47 : 0 : BOOST_CHECK(filter_index.LookupFilterHeader(block_index, filter_header));
48 : 0 : BOOST_CHECK(filter_index.LookupFilterRange(block_index->nHeight, block_index, filters));
49 : 0 : BOOST_CHECK(filter_index.LookupFilterHashRange(block_index->nHeight, block_index,
50 : : filter_hashes));
51 : :
52 : 0 : BOOST_CHECK_EQUAL(filters.size(), 1U);
53 : 0 : BOOST_CHECK_EQUAL(filter_hashes.size(), 1U);
54 : :
55 : 0 : BOOST_CHECK_EQUAL(filter.GetHash(), expected_filter.GetHash());
56 : 0 : BOOST_CHECK_EQUAL(filter_header, expected_filter.ComputeHeader(last_header));
57 : 0 : BOOST_CHECK_EQUAL(filters[0].GetHash(), expected_filter.GetHash());
58 : 0 : BOOST_CHECK_EQUAL(filter_hashes[0], expected_filter.GetHash());
59 : :
60 : 0 : filters.clear();
61 : 0 : filter_hashes.clear();
62 : 0 : last_header = filter_header;
63 : 0 : return true;
64 : 0 : }
65 : :
66 : 0 : CBlock BuildChainTestingSetup::CreateBlock(const CBlockIndex* prev,
67 : : const std::vector<CMutableTransaction>& txns,
68 : : const CScript& scriptPubKey)
69 : : {
70 : 0 : std::unique_ptr<CBlockTemplate> pblocktemplate = BlockAssembler{m_node.chainman->ActiveChainstate(), m_node.mempool.get()}.CreateNewBlock(scriptPubKey);
71 : 0 : CBlock& block = pblocktemplate->block;
72 : 0 : block.hashPrevBlock = prev->GetBlockHash();
73 : 0 : block.nTime = prev->nTime + 1;
74 : 0 :
75 : : // Replace mempool-selected txns with just coinbase plus passed-in txns:
76 : 0 : block.vtx.resize(1);
77 : 0 : for (const CMutableTransaction& tx : txns) {
78 : 0 : block.vtx.push_back(MakeTransactionRef(tx));
79 : : }
80 : : {
81 : 0 : CMutableTransaction tx_coinbase{*block.vtx.at(0)};
82 : 0 : tx_coinbase.vin.at(0).scriptSig = CScript{} << prev->nHeight + 1;
83 : 0 : block.vtx.at(0) = MakeTransactionRef(std::move(tx_coinbase));
84 : 0 : block.hashMerkleRoot = BlockMerkleRoot(block);
85 : 0 : }
86 : :
87 : 0 : while (!CheckProofOfWork(block.GetHash(), block.nBits, m_node.chainman->GetConsensus())) ++block.nNonce;
88 : :
89 : 0 : return block;
90 : 0 : }
91 : :
92 : 0 : bool BuildChainTestingSetup::BuildChain(const CBlockIndex* pindex,
93 : : const CScript& coinbase_script_pub_key,
94 : : size_t length,
95 : : std::vector<std::shared_ptr<CBlock>>& chain)
96 : : {
97 : 0 : std::vector<CMutableTransaction> no_txns;
98 : :
99 : 0 : chain.resize(length);
100 : 0 : for (auto& block : chain) {
101 : 0 : block = std::make_shared<CBlock>(CreateBlock(pindex, no_txns, coinbase_script_pub_key));
102 : 0 : CBlockHeader header = block->GetBlockHeader();
103 : :
104 : 0 : BlockValidationState state;
105 : 0 : if (!Assert(m_node.chainman)->ProcessNewBlockHeaders({header}, true, state, &pindex)) {
106 : 0 : return false;
107 : : }
108 : 0 : }
109 : :
110 : 0 : return true;
111 : 0 : }
112 : :
113 : 0 : BOOST_FIXTURE_TEST_CASE(blockfilter_index_initial_sync, BuildChainTestingSetup)
114 : : {
115 : 0 : BlockFilterIndex filter_index(interfaces::MakeChain(m_node), BlockFilterType::BASIC, 1 << 20, true);
116 : 0 : BOOST_REQUIRE(filter_index.Init());
117 : :
118 : 0 : uint256 last_header;
119 : :
120 : : // Filter should not be found in the index before it is started.
121 : : {
122 : 0 : LOCK(cs_main);
123 : :
124 : 0 : BlockFilter filter;
125 : 0 : uint256 filter_header;
126 : 0 : std::vector<BlockFilter> filters;
127 : 0 : std::vector<uint256> filter_hashes;
128 : :
129 : 0 : for (const CBlockIndex* block_index = m_node.chainman->ActiveChain().Genesis();
130 : 0 : block_index != nullptr;
131 : 0 : block_index = m_node.chainman->ActiveChain().Next(block_index)) {
132 : 0 : BOOST_CHECK(!filter_index.LookupFilter(block_index, filter));
133 : 0 : BOOST_CHECK(!filter_index.LookupFilterHeader(block_index, filter_header));
134 : 0 : BOOST_CHECK(!filter_index.LookupFilterRange(block_index->nHeight, block_index, filters));
135 : 0 : BOOST_CHECK(!filter_index.LookupFilterHashRange(block_index->nHeight, block_index,
136 : : filter_hashes));
137 : 0 : }
138 : 0 : }
139 : :
140 : : // BlockUntilSyncedToCurrentChain should return false before index is started.
141 : 0 : BOOST_CHECK(!filter_index.BlockUntilSyncedToCurrentChain());
142 : :
143 : 0 : BOOST_REQUIRE(filter_index.StartBackgroundSync());
144 : :
145 : : // Allow filter index to catch up with the block index.
146 : 0 : IndexWaitSynced(filter_index);
147 : :
148 : : // Check that filter index has all blocks that were in the chain before it started.
149 : : {
150 : 0 : LOCK(cs_main);
151 : : const CBlockIndex* block_index;
152 : 0 : for (block_index = m_node.chainman->ActiveChain().Genesis();
153 : 0 : block_index != nullptr;
154 : 0 : block_index = m_node.chainman->ActiveChain().Next(block_index)) {
155 : 0 : CheckFilterLookups(filter_index, block_index, last_header, m_node.chainman->m_blockman);
156 : 0 : }
157 : 0 : }
158 : :
159 : : // Create two forks.
160 : : const CBlockIndex* tip;
161 : : {
162 : 0 : LOCK(cs_main);
163 : 0 : tip = m_node.chainman->ActiveChain().Tip();
164 : 0 : }
165 : 0 : CKey coinbase_key_A, coinbase_key_B;
166 : 0 : coinbase_key_A.MakeNewKey(true);
167 : 0 : coinbase_key_B.MakeNewKey(true);
168 : 0 : CScript coinbase_script_pub_key_A = GetScriptForDestination(PKHash(coinbase_key_A.GetPubKey()));
169 : 0 : CScript coinbase_script_pub_key_B = GetScriptForDestination(PKHash(coinbase_key_B.GetPubKey()));
170 : 0 : std::vector<std::shared_ptr<CBlock>> chainA, chainB;
171 : 0 : BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key_A, 10, chainA));
172 : 0 : BOOST_REQUIRE(BuildChain(tip, coinbase_script_pub_key_B, 10, chainB));
173 : :
174 : : // Check that new blocks on chain A get indexed.
175 : 0 : uint256 chainA_last_header = last_header;
176 : 0 : for (size_t i = 0; i < 2; i++) {
177 : 0 : const auto& block = chainA[i];
178 : 0 : BOOST_REQUIRE(Assert(m_node.chainman)->ProcessNewBlock(block, true, true, nullptr));
179 : 0 : }
180 : 0 : for (size_t i = 0; i < 2; i++) {
181 : 0 : const auto& block = chainA[i];
182 : : const CBlockIndex* block_index;
183 : : {
184 : 0 : LOCK(cs_main);
185 : 0 : block_index = m_node.chainman->m_blockman.LookupBlockIndex(block->GetHash());
186 : 0 : }
187 : :
188 : 0 : BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
189 : 0 : CheckFilterLookups(filter_index, block_index, chainA_last_header, m_node.chainman->m_blockman);
190 : 0 : }
191 : :
192 : : // Reorg to chain B.
193 : 0 : uint256 chainB_last_header = last_header;
194 : 0 : for (size_t i = 0; i < 3; i++) {
195 : 0 : const auto& block = chainB[i];
196 : 0 : BOOST_REQUIRE(Assert(m_node.chainman)->ProcessNewBlock(block, true, true, nullptr));
197 : 0 : }
198 : 0 : for (size_t i = 0; i < 3; i++) {
199 : 0 : const auto& block = chainB[i];
200 : : const CBlockIndex* block_index;
201 : : {
202 : 0 : LOCK(cs_main);
203 : 0 : block_index = m_node.chainman->m_blockman.LookupBlockIndex(block->GetHash());
204 : 0 : }
205 : :
206 : 0 : BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
207 : 0 : CheckFilterLookups(filter_index, block_index, chainB_last_header, m_node.chainman->m_blockman);
208 : 0 : }
209 : :
210 : : // Check that filters for stale blocks on A can be retrieved.
211 : 0 : chainA_last_header = last_header;
212 : 0 : for (size_t i = 0; i < 2; i++) {
213 : 0 : const auto& block = chainA[i];
214 : : const CBlockIndex* block_index;
215 : : {
216 : 0 : LOCK(cs_main);
217 : 0 : block_index = m_node.chainman->m_blockman.LookupBlockIndex(block->GetHash());
218 : 0 : }
219 : :
220 : 0 : BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
221 : 0 : CheckFilterLookups(filter_index, block_index, chainA_last_header, m_node.chainman->m_blockman);
222 : 0 : }
223 : :
224 : : // Reorg back to chain A.
225 : 0 : for (size_t i = 2; i < 4; i++) {
226 : 0 : const auto& block = chainA[i];
227 : 0 : BOOST_REQUIRE(Assert(m_node.chainman)->ProcessNewBlock(block, true, true, nullptr));
228 : 0 : }
229 : :
230 : : // Check that chain A and B blocks can be retrieved.
231 : 0 : chainA_last_header = last_header;
232 : 0 : chainB_last_header = last_header;
233 : 0 : for (size_t i = 0; i < 3; i++) {
234 : : const CBlockIndex* block_index;
235 : :
236 : : {
237 : 0 : LOCK(cs_main);
238 : 0 : block_index = m_node.chainman->m_blockman.LookupBlockIndex(chainA[i]->GetHash());
239 : 0 : }
240 : 0 : BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
241 : 0 : CheckFilterLookups(filter_index, block_index, chainA_last_header, m_node.chainman->m_blockman);
242 : :
243 : : {
244 : 0 : LOCK(cs_main);
245 : 0 : block_index = m_node.chainman->m_blockman.LookupBlockIndex(chainB[i]->GetHash());
246 : 0 : }
247 : 0 : BOOST_CHECK(filter_index.BlockUntilSyncedToCurrentChain());
248 : 0 : CheckFilterLookups(filter_index, block_index, chainB_last_header, m_node.chainman->m_blockman);
249 : 0 : }
250 : :
251 : : // Test lookups for a range of filters/hashes.
252 : 0 : std::vector<BlockFilter> filters;
253 : 0 : std::vector<uint256> filter_hashes;
254 : :
255 : : {
256 : 0 : LOCK(cs_main);
257 : 0 : tip = m_node.chainman->ActiveChain().Tip();
258 : 0 : }
259 : 0 : BOOST_CHECK(filter_index.LookupFilterRange(0, tip, filters));
260 : 0 : BOOST_CHECK(filter_index.LookupFilterHashRange(0, tip, filter_hashes));
261 : :
262 : 0 : assert(tip->nHeight >= 0);
263 : 0 : BOOST_CHECK_EQUAL(filters.size(), tip->nHeight + 1U);
264 : 0 : BOOST_CHECK_EQUAL(filter_hashes.size(), tip->nHeight + 1U);
265 : :
266 : 0 : filters.clear();
267 : 0 : filter_hashes.clear();
268 : :
269 : 0 : filter_index.Interrupt();
270 : 0 : filter_index.Stop();
271 : 0 : }
272 : :
273 : 0 : BOOST_FIXTURE_TEST_CASE(blockfilter_index_init_destroy, BasicTestingSetup)
274 : : {
275 : : BlockFilterIndex* filter_index;
276 : :
277 : 0 : filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
278 : 0 : BOOST_CHECK(filter_index == nullptr);
279 : :
280 : 0 : BOOST_CHECK(InitBlockFilterIndex([&]{ return interfaces::MakeChain(m_node); }, BlockFilterType::BASIC, 1 << 20, true, false));
281 : :
282 : 0 : filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
283 : 0 : BOOST_CHECK(filter_index != nullptr);
284 : 0 : BOOST_CHECK(filter_index->GetFilterType() == BlockFilterType::BASIC);
285 : :
286 : : // Initialize returns false if index already exists.
287 : 0 : BOOST_CHECK(!InitBlockFilterIndex([&]{ return interfaces::MakeChain(m_node); }, BlockFilterType::BASIC, 1 << 20, true, false));
288 : :
289 : 0 : int iter_count = 0;
290 : 0 : ForEachBlockFilterIndex([&iter_count](BlockFilterIndex& _index) { iter_count++; });
291 : 0 : BOOST_CHECK_EQUAL(iter_count, 1);
292 : :
293 : 0 : BOOST_CHECK(DestroyBlockFilterIndex(BlockFilterType::BASIC));
294 : :
295 : : // Destroy returns false because index was already destroyed.
296 : 0 : BOOST_CHECK(!DestroyBlockFilterIndex(BlockFilterType::BASIC));
297 : :
298 : 0 : filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
299 : 0 : BOOST_CHECK(filter_index == nullptr);
300 : :
301 : : // Reinitialize index.
302 : 0 : BOOST_CHECK(InitBlockFilterIndex([&]{ return interfaces::MakeChain(m_node); }, BlockFilterType::BASIC, 1 << 20, true, false));
303 : :
304 : 0 : DestroyAllBlockFilterIndexes();
305 : :
306 : 0 : filter_index = GetBlockFilterIndex(BlockFilterType::BASIC);
307 : 0 : BOOST_CHECK(filter_index == nullptr);
308 : 0 : }
309 : :
310 : 0 : BOOST_AUTO_TEST_SUITE_END()
|
