Branch data Line data Source code
1 : : // Copyright (c) 2023 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 <coins.h>
6 : : #include <crypto/sha256.h>
7 : : #include <primitives/transaction.h>
8 : : #include <test/fuzz/fuzz.h>
9 : : #include <test/fuzz/FuzzedDataProvider.h>
10 : : #include <test/fuzz/util.h>
11 : :
12 : : #include <assert.h>
13 : : #include <optional>
14 : : #include <memory>
15 : : #include <stdint.h>
16 : : #include <vector>
17 : :
18 : : namespace {
19 : :
20 : : /** Number of distinct COutPoint values used in this test. */
21 : : constexpr uint32_t NUM_OUTPOINTS = 256;
22 : : /** Number of distinct Coin values used in this test (ignoring nHeight). */
23 : : constexpr uint32_t NUM_COINS = 256;
24 : : /** Maximum number CCoinsViewCache objects used in this test. */
25 [ + - ]: 173 : constexpr uint32_t MAX_CACHES = 4;
26 : : /** Data type large enough to hold NUM_COINS-1. */
27 : : using coinidx_type = uint8_t;
28 : :
29 : 1 : struct PrecomputedData
30 : : {
31 : : //! Randomly generated COutPoint values.
32 : : COutPoint outpoints[NUM_OUTPOINTS];
33 : :
34 : : //! Randomly generated Coin values.
35 : : Coin coins[NUM_COINS];
36 : :
37 [ + - + + ]: 256 : PrecomputedData()
38 : : {
39 : : static const uint8_t PREFIX_O[1] = {'o'}; /** Hash prefix for outpoint hashes. */
40 : : static const uint8_t PREFIX_S[1] = {'s'}; /** Hash prefix for coins scriptPubKeys. */
41 : : static const uint8_t PREFIX_M[1] = {'m'}; /** Hash prefix for coins nValue/fCoinBase. */
42 : :
43 [ + + ]: 257 : for (uint32_t i = 0; i < NUM_OUTPOINTS; ++i) {
44 : 256 : uint32_t idx = (i * 1200U) >> 12; /* Map 3 or 4 entries to same txid. */
45 : 256 : const uint8_t ser[4] = {uint8_t(idx), uint8_t(idx >> 8), uint8_t(idx >> 16), uint8_t(idx >> 24)};
46 [ + - + - : 256 : CSHA256().Write(PREFIX_O, 1).Write(ser, sizeof(ser)).Finalize(outpoints[i].hash.begin());
+ - + - +
- ]
47 : 256 : outpoints[i].n = i;
48 : 256 : }
49 : :
50 [ + + ]: 257 : for (uint32_t i = 0; i < NUM_COINS; ++i) {
51 : 256 : const uint8_t ser[4] = {uint8_t(i), uint8_t(i >> 8), uint8_t(i >> 16), uint8_t(i >> 24)};
52 [ + - ]: 256 : uint256 hash;
53 [ + - + - : 256 : CSHA256().Write(PREFIX_S, 1).Write(ser, sizeof(ser)).Finalize(hash.begin());
+ - + - +
- ]
54 : : /* Convert hash to scriptPubkeys (of different lengths, so SanityCheck's cached memory
55 : : * usage check has a chance to detect mismatches). */
56 [ + + + + : 256 : switch (i % 5U) {
+ - ]
57 : : case 0: /* P2PKH */
58 [ + - ]: 52 : coins[i].out.scriptPubKey.resize(25);
59 [ + - ]: 52 : coins[i].out.scriptPubKey[0] = OP_DUP;
60 [ + - ]: 52 : coins[i].out.scriptPubKey[1] = OP_HASH160;
61 [ + - ]: 52 : coins[i].out.scriptPubKey[2] = 20;
62 [ + - + - : 52 : std::copy(hash.begin(), hash.begin() + 20, coins[i].out.scriptPubKey.begin() + 3);
+ - + - +
- ]
63 [ + - ]: 52 : coins[i].out.scriptPubKey[23] = OP_EQUALVERIFY;
64 [ + - ]: 52 : coins[i].out.scriptPubKey[24] = OP_CHECKSIG;
65 : 52 : break;
66 : : case 1: /* P2SH */
67 [ + - ]: 51 : coins[i].out.scriptPubKey.resize(23);
68 [ + - ]: 51 : coins[i].out.scriptPubKey[0] = OP_HASH160;
69 [ + - ]: 51 : coins[i].out.scriptPubKey[1] = 20;
70 [ + - + - : 51 : std::copy(hash.begin(), hash.begin() + 20, coins[i].out.scriptPubKey.begin() + 2);
+ - + - +
- ]
71 [ + - ]: 51 : coins[i].out.scriptPubKey[12] = OP_EQUAL;
72 : 51 : break;
73 : : case 2: /* P2WPKH */
74 [ + - ]: 51 : coins[i].out.scriptPubKey.resize(22);
75 [ + - ]: 51 : coins[i].out.scriptPubKey[0] = OP_0;
76 [ + - ]: 51 : coins[i].out.scriptPubKey[1] = 20;
77 [ + - + - : 51 : std::copy(hash.begin(), hash.begin() + 20, coins[i].out.scriptPubKey.begin() + 2);
+ - + - +
- ]
78 : 51 : break;
79 : : case 3: /* P2WSH */
80 [ + - ]: 51 : coins[i].out.scriptPubKey.resize(34);
81 [ + - ]: 51 : coins[i].out.scriptPubKey[0] = OP_0;
82 [ + - ]: 51 : coins[i].out.scriptPubKey[1] = 32;
83 [ + - + - : 51 : std::copy(hash.begin(), hash.begin() + 32, coins[i].out.scriptPubKey.begin() + 2);
+ - + - +
- ]
84 : 51 : break;
85 : : case 4: /* P2TR */
86 [ + - ]: 51 : coins[i].out.scriptPubKey.resize(34);
87 [ + - ]: 51 : coins[i].out.scriptPubKey[0] = OP_1;
88 [ + - ]: 51 : coins[i].out.scriptPubKey[1] = 32;
89 [ + - + - : 51 : std::copy(hash.begin(), hash.begin() + 32, coins[i].out.scriptPubKey.begin() + 2);
+ - + - +
- ]
90 : 51 : break;
91 : : }
92 : : /* Hash again to construct nValue and fCoinBase. */
93 [ + - + - : 256 : CSHA256().Write(PREFIX_M, 1).Write(ser, sizeof(ser)).Finalize(hash.begin());
+ - + - +
- ]
94 [ + - ]: 256 : coins[i].out.nValue = CAmount(hash.GetUint64(0) % MAX_MONEY);
95 [ + - ]: 256 : coins[i].fCoinBase = (hash.GetUint64(1) & 7) == 0;
96 : 256 : coins[i].nHeight = 0; /* Real nHeight used in simulation is set dynamically. */
97 : 256 : }
98 : 1 : }
99 : : };
100 : :
101 : : enum class EntryType : uint8_t
102 : : {
103 : : /* This entry in the cache does not exist (so we'd have to look in the parent cache). */
104 : : NONE,
105 : :
106 : : /* This entry in the cache corresponds to an unspent coin. */
107 : : UNSPENT,
108 : :
109 : : /* This entry in the cache corresponds to a spent coin. */
110 : : SPENT,
111 : : };
112 : :
113 : : struct CacheEntry
114 : : {
115 : : /* Type of entry. */
116 : : EntryType entrytype;
117 : :
118 : : /* Index in the coins array this entry corresponds to (only if entrytype == UNSPENT). */
119 : : coinidx_type coinidx;
120 : :
121 : : /* nHeight value for this entry (so the coins[coinidx].nHeight value is ignored; only if entrytype == UNSPENT). */
122 : : uint32_t height;
123 : : };
124 : :
125 : : struct CacheLevel
126 : : {
127 : : CacheEntry entry[NUM_OUTPOINTS];
128 : :
129 : 19876 : void Wipe() {
130 [ + + ]: 5108132 : for (uint32_t i = 0; i < NUM_OUTPOINTS; ++i) {
131 : 5088256 : entry[i].entrytype = EntryType::NONE;
132 : 5088256 : }
133 : 19876 : }
134 : : };
135 : :
136 : : /** Class for the base of the hierarchy (roughly simulating a memory-backed CCoinsViewDB).
137 : : *
138 : : * The initial state consists of the empty UTXO set, though coins whose output index
139 : : * is 3 (mod 5) always have GetCoin() succeed (but returning an IsSpent() coin unless a UTXO
140 : : * exists). Coins whose output index is 4 (mod 5) have GetCoin() always succeed after being spent.
141 : : * This exercises code paths with spent, non-DIRTY cache entries.
142 : : */
143 : : class CoinsViewBottom final : public CCoinsView
144 : : {
145 : : std::map<COutPoint, Coin> m_data;
146 : :
147 : : public:
148 : 324031 : bool GetCoin(const COutPoint& outpoint, Coin& coin) const final
149 : : {
150 : 324031 : auto it = m_data.find(outpoint);
151 [ + + ]: 324031 : if (it == m_data.end()) {
152 [ + + ]: 298491 : if ((outpoint.n % 5) == 3) {
153 : 56537 : coin.Clear();
154 : 56537 : return true;
155 : : }
156 : 241954 : return false;
157 : : } else {
158 : 25540 : coin = it->second;
159 : 25540 : return true;
160 : : }
161 : 324031 : }
162 : :
163 : 0 : bool HaveCoin(const COutPoint& outpoint) const final
164 : : {
165 : 0 : return m_data.count(outpoint);
166 : : }
167 : :
168 : 0 : uint256 GetBestBlock() const final { return {}; }
169 : 0 : std::vector<uint256> GetHeadBlocks() const final { return {}; }
170 : 0 : std::unique_ptr<CCoinsViewCursor> Cursor() const final { return {}; }
171 : 0 : size_t EstimateSize() const final { return m_data.size(); }
172 : :
173 : 47710 : bool BatchWrite(CCoinsMap& data, const uint256&, bool erase) final
174 : : {
175 [ + + + + ]: 110828 : for (auto it = data.begin(); it != data.end(); it = erase ? data.erase(it) : std::next(it)) {
176 [ + + ]: 63118 : if (it->second.flags & CCoinsCacheEntry::DIRTY) {
177 [ + + + + ]: 33746 : if (it->second.coin.IsSpent() && (it->first.n % 5) != 4) {
178 : 6864 : m_data.erase(it->first);
179 [ + + ]: 33746 : } else if (erase) {
180 : 10291 : m_data[it->first] = std::move(it->second.coin);
181 : 10291 : } else {
182 : 16591 : m_data[it->first] = it->second.coin;
183 : : }
184 : 33746 : } else {
185 : : /* For non-dirty entries being written, compare them with what we have. */
186 : 29372 : auto it2 = m_data.find(it->first);
187 [ + + ]: 29372 : if (it->second.coin.IsSpent()) {
188 [ + + + - ]: 3083 : assert(it2 == m_data.end() || it2->second.IsSpent());
189 : 3083 : } else {
190 [ + - ]: 26289 : assert(it2 != m_data.end());
191 [ - + ]: 26289 : assert(it->second.coin.out == it2->second.out);
192 [ - + ]: 26289 : assert(it->second.coin.fCoinBase == it2->second.fCoinBase);
193 [ - + ]: 26289 : assert(it->second.coin.nHeight == it2->second.nHeight);
194 : : }
195 : : }
196 : 63118 : }
197 : 47710 : return true;
198 : : }
199 : : };
200 : :
201 : : } // namespace
202 : :
203 [ - + ]: 764 : FUZZ_TARGET(coinscache_sim)
204 : : {
205 : : /** Precomputed COutPoint and CCoins values. */
206 [ + + - + : 418 : static const PrecomputedData data;
+ - ]
207 : :
208 : : /** Dummy coinsview instance (base of the hierarchy). */
209 : 418 : CoinsViewBottom bottom;
210 : : /** Real CCoinsViewCache objects. */
211 : 418 : std::vector<std::unique_ptr<CCoinsViewCache>> caches;
212 : : /** Simulated cache data (sim_caches[0] matches bottom, sim_caches[i+1] matches caches[i]). */
213 : : CacheLevel sim_caches[MAX_CACHES + 1];
214 : : /** Current height in the simulation. */
215 : 418 : uint32_t current_height = 1U;
216 : :
217 : : // Initialize bottom simulated cache.
218 [ + - ]: 418 : sim_caches[0].Wipe();
219 : :
220 : : /** Helper lookup function in the simulated cache stack. */
221 : 388276 : auto lookup = [&](uint32_t outpointidx, int sim_idx = -1) -> std::optional<std::pair<coinidx_type, uint32_t>> {
222 [ + + ]: 387858 : uint32_t cache_idx = sim_idx == -1 ? caches.size() : sim_idx;
223 : 831075 : while (true) {
224 : 831075 : const auto& entry = sim_caches[cache_idx].entry[outpointidx];
225 [ + + ]: 831075 : if (entry.entrytype == EntryType::UNSPENT) {
226 : 72696 : return {{entry.coinidx, entry.height}};
227 [ + + ]: 758379 : } else if (entry.entrytype == EntryType::SPENT) {
228 : 33328 : return std::nullopt;
229 : : };
230 [ + + ]: 725051 : if (cache_idx == 0) break;
231 : 443217 : --cache_idx;
232 : : }
233 : 281834 : return std::nullopt;
234 : 387858 : };
235 : :
236 : : /** Flush changes in top cache to the one below. */
237 : 79561 : auto flush = [&]() {
238 [ + - ]: 79143 : assert(caches.size() >= 1);
239 : 79143 : auto& cache = sim_caches[caches.size()];
240 : 79143 : auto& prev_cache = sim_caches[caches.size() - 1];
241 [ + + ]: 20339751 : for (uint32_t outpointidx = 0; outpointidx < NUM_OUTPOINTS; ++outpointidx) {
242 [ + + ]: 20260608 : if (cache.entry[outpointidx].entrytype != EntryType::NONE) {
243 : 109114 : prev_cache.entry[outpointidx] = cache.entry[outpointidx];
244 : 109114 : cache.entry[outpointidx].entrytype = EntryType::NONE;
245 : 109114 : }
246 : 20260608 : }
247 : 79143 : };
248 : :
249 : : // Main simulation loop: read commands from the fuzzer input, and apply them
250 : : // to both the real cache stack and the simulation.
251 [ + - ]: 418 : FuzzedDataProvider provider(buffer.data(), buffer.size());
252 [ + - + + : 324808 : LIMITED_WHILE(provider.remaining_bytes(), 10000) {
+ + ]
253 : : // Every operation (except "Change height") moves current height forward,
254 : : // so it functions as a kind of epoch, making ~all UTXOs unique.
255 : 324390 : ++current_height;
256 : : // Make sure there is always at least one CCoinsViewCache.
257 [ + + ]: 324390 : if (caches.empty()) {
258 [ + - + - : 12267 : caches.emplace_back(new CCoinsViewCache(&bottom, /*deterministic=*/true));
+ - ]
259 [ + - ]: 12267 : sim_caches[caches.size()].Wipe();
260 : 12267 : }
261 : :
262 : : // Execute command.
263 [ + - ]: 324390 : CallOneOf(
264 : : provider,
265 : :
266 : 352359 : [&]() { // GetCoin
267 : 27969 : uint32_t outpointidx = provider.ConsumeIntegralInRange<uint32_t>(0, NUM_OUTPOINTS - 1);
268 : : // Look up in simulation data.
269 : 27969 : auto sim = lookup(outpointidx);
270 : : // Look up in real caches.
271 : 27969 : Coin realcoin;
272 [ + - ]: 27969 : auto real = caches.back()->GetCoin(data.outpoints[outpointidx], realcoin);
273 : : // Compare results.
274 [ + + ]: 27969 : if (!sim.has_value()) {
275 [ - + # # : 19442 : assert(!real || realcoin.IsSpent());
+ - ]
276 : 19442 : } else {
277 [ + - + - : 8527 : assert(real && !realcoin.IsSpent());
+ - ]
278 : 8527 : const auto& simcoin = data.coins[sim->first];
279 [ + - + - ]: 8527 : assert(realcoin.out == simcoin.out);
280 [ + - ]: 8527 : assert(realcoin.fCoinBase == simcoin.fCoinBase);
281 [ - + ]: 8527 : assert(realcoin.nHeight == sim->second);
282 : : }
283 : 27969 : },
284 : :
285 : 337484 : [&]() { // HaveCoin
286 : 13094 : uint32_t outpointidx = provider.ConsumeIntegralInRange<uint32_t>(0, NUM_OUTPOINTS - 1);
287 : : // Look up in simulation data.
288 : 13094 : auto sim = lookup(outpointidx);
289 : : // Look up in real caches.
290 : 13094 : auto real = caches.back()->HaveCoin(data.outpoints[outpointidx]);
291 : : // Compare results.
292 [ + - ]: 13094 : assert(sim.has_value() == real);
293 : 13094 : },
294 : :
295 : 331260 : [&]() { // HaveCoinInCache
296 : 6870 : uint32_t outpointidx = provider.ConsumeIntegralInRange<uint32_t>(0, NUM_OUTPOINTS - 1);
297 : : // Invoke on real cache (there is no equivalent in simulation, so nothing to compare result with).
298 : 6870 : (void)caches.back()->HaveCoinInCache(data.outpoints[outpointidx]);
299 : 6870 : },
300 : :
301 : 334549 : [&]() { // AccessCoin
302 : 10159 : uint32_t outpointidx = provider.ConsumeIntegralInRange<uint32_t>(0, NUM_OUTPOINTS - 1);
303 : : // Look up in simulation data.
304 : 10159 : auto sim = lookup(outpointidx);
305 : : // Look up in real caches.
306 : 10159 : const auto& realcoin = caches.back()->AccessCoin(data.outpoints[outpointidx]);
307 : : // Compare results.
308 [ + + ]: 10159 : if (!sim.has_value()) {
309 [ + - ]: 5852 : assert(realcoin.IsSpent());
310 : 5852 : } else {
311 [ + - ]: 4307 : assert(!realcoin.IsSpent());
312 : 4307 : const auto& simcoin = data.coins[sim->first];
313 [ + - ]: 4307 : assert(simcoin.out == realcoin.out);
314 [ + - ]: 4307 : assert(simcoin.fCoinBase == realcoin.fCoinBase);
315 [ - + ]: 4307 : assert(realcoin.nHeight == sim->second);
316 : : }
317 : 10159 : },
318 : :
319 : 359438 : [&]() { // AddCoin (only possible_overwrite if necessary)
320 : 35048 : uint32_t outpointidx = provider.ConsumeIntegralInRange<uint32_t>(0, NUM_OUTPOINTS - 1);
321 : 35048 : uint32_t coinidx = provider.ConsumeIntegralInRange<uint32_t>(0, NUM_COINS - 1);
322 : : // Look up in simulation data (to know whether we must set possible_overwrite or not).
323 : 35048 : auto sim = lookup(outpointidx);
324 : : // Invoke on real caches.
325 : 35048 : Coin coin = data.coins[coinidx];
326 : 35048 : coin.nHeight = current_height;
327 [ + - ]: 35048 : caches.back()->AddCoin(data.outpoints[outpointidx], std::move(coin), sim.has_value());
328 : : // Apply to simulation data.
329 : 35048 : auto& entry = sim_caches[caches.size()].entry[outpointidx];
330 : 35048 : entry.entrytype = EntryType::UNSPENT;
331 : 35048 : entry.coinidx = coinidx;
332 : 35048 : entry.height = current_height;
333 : 35048 : },
334 : :
335 : 349222 : [&]() { // AddCoin (always possible_overwrite)
336 : 24832 : uint32_t outpointidx = provider.ConsumeIntegralInRange<uint32_t>(0, NUM_OUTPOINTS - 1);
337 : 24832 : uint32_t coinidx = provider.ConsumeIntegralInRange<uint32_t>(0, NUM_COINS - 1);
338 : : // Invoke on real caches.
339 : 24832 : Coin coin = data.coins[coinidx];
340 : 24832 : coin.nHeight = current_height;
341 [ + - ]: 24832 : caches.back()->AddCoin(data.outpoints[outpointidx], std::move(coin), true);
342 : : // Apply to simulation data.
343 : 24832 : auto& entry = sim_caches[caches.size()].entry[outpointidx];
344 : 24832 : entry.entrytype = EntryType::UNSPENT;
345 : 24832 : entry.coinidx = coinidx;
346 : 24832 : entry.height = current_height;
347 : 24832 : },
348 : :
349 : 348244 : [&]() { // SpendCoin (moveto = nullptr)
350 : 23854 : uint32_t outpointidx = provider.ConsumeIntegralInRange<uint32_t>(0, NUM_OUTPOINTS - 1);
351 : : // Invoke on real caches.
352 : 23854 : caches.back()->SpendCoin(data.outpoints[outpointidx], nullptr);
353 : : // Apply to simulation data.
354 : 23854 : sim_caches[caches.size()].entry[outpointidx].entrytype = EntryType::SPENT;
355 : 23854 : },
356 : :
357 : 346426 : [&]() { // SpendCoin (with moveto)
358 : 22036 : uint32_t outpointidx = provider.ConsumeIntegralInRange<uint32_t>(0, NUM_OUTPOINTS - 1);
359 : : // Look up in simulation data (to compare the returned *moveto with).
360 : 22036 : auto sim = lookup(outpointidx);
361 : : // Invoke on real caches.
362 : 22036 : Coin realcoin;
363 [ + - ]: 22036 : caches.back()->SpendCoin(data.outpoints[outpointidx], &realcoin);
364 : : // Apply to simulation data.
365 : 22036 : sim_caches[caches.size()].entry[outpointidx].entrytype = EntryType::SPENT;
366 : : // Compare *moveto with the value expected based on simulation data.
367 [ + + ]: 22036 : if (!sim.has_value()) {
368 [ + - + - ]: 12761 : assert(realcoin.IsSpent());
369 : 12761 : } else {
370 [ + - + - ]: 9275 : assert(!realcoin.IsSpent());
371 : 9275 : const auto& simcoin = data.coins[sim->first];
372 [ + - + - ]: 9275 : assert(simcoin.out == realcoin.out);
373 [ + - ]: 9275 : assert(simcoin.fCoinBase == realcoin.fCoinBase);
374 [ - + ]: 9275 : assert(realcoin.nHeight == sim->second);
375 : : }
376 : 22036 : },
377 : :
378 : 334638 : [&]() { // Uncache
379 : 10248 : uint32_t outpointidx = provider.ConsumeIntegralInRange<uint32_t>(0, NUM_OUTPOINTS - 1);
380 : : // Apply to real caches (there is no equivalent in our simulation).
381 : 10248 : caches.back()->Uncache(data.outpoints[outpointidx]);
382 : 10248 : },
383 : :
384 : 336935 : [&]() { // Add a cache level (if not already at the max).
385 [ + + ]: 12545 : if (caches.size() != MAX_CACHES) {
386 : : // Apply to real caches.
387 [ + - ]: 7191 : caches.emplace_back(new CCoinsViewCache(&*caches.back(), /*deterministic=*/true));
388 : : // Apply to simulation data.
389 : 7191 : sim_caches[caches.size()].Wipe();
390 : 7191 : }
391 : 12545 : },
392 : :
393 : 343174 : [&]() { // Remove a cache level.
394 : : // Apply to real caches (this reduces caches.size(), implicitly doing the same on the simulation data).
395 : 18784 : caches.back()->SanityCheck();
396 : 18784 : caches.pop_back();
397 : 18784 : },
398 : :
399 : 360760 : [&]() { // Flush.
400 : : // Apply to simulation data.
401 : 36370 : flush();
402 : : // Apply to real caches.
403 : 36370 : caches.back()->Flush();
404 : 36370 : },
405 : :
406 : 351664 : [&]() { // Sync.
407 : : // Apply to simulation data (note that in our simulation, syncing and flushing is the same thing).
408 : 27274 : flush();
409 : : // Apply to real caches.
410 : 27274 : caches.back()->Sync();
411 : 27274 : },
412 : :
413 : 339889 : [&]() { // Flush + ReallocateCache.
414 : : // Apply to simulation data.
415 : 15499 : flush();
416 : : // Apply to real caches.
417 : 15499 : caches.back()->Flush();
418 : 15499 : caches.back()->ReallocateCache();
419 : 15499 : },
420 : :
421 : 335870 : [&]() { // GetCacheSize
422 : 11480 : (void)caches.back()->GetCacheSize();
423 : 11480 : },
424 : :
425 : 336719 : [&]() { // DynamicMemoryUsage
426 : 12329 : (void)caches.back()->DynamicMemoryUsage();
427 : 12329 : },
428 : :
429 : 340389 : [&]() { // Change height
430 : 15999 : current_height = provider.ConsumeIntegralInRange<uint32_t>(1, current_height - 1);
431 : 15999 : }
432 : : );
433 : 324390 : }
434 : :
435 : : // Sanity check all the remaining caches
436 [ + + ]: 1092 : for (const auto& cache : caches) {
437 [ + - ]: 674 : cache->SanityCheck();
438 : : }
439 : :
440 : : // Full comparison between caches and simulation data, from bottom to top,
441 : : // as AccessCoin on a higher cache may affect caches below it.
442 [ + + ]: 1092 : for (unsigned sim_idx = 1; sim_idx <= caches.size(); ++sim_idx) {
443 [ + - ]: 674 : auto& cache = *caches[sim_idx - 1];
444 : 674 : size_t cache_size = 0;
445 : :
446 [ + + ]: 173218 : for (uint32_t outpointidx = 0; outpointidx < NUM_OUTPOINTS; ++outpointidx) {
447 [ + - ]: 172544 : cache_size += cache.HaveCoinInCache(data.outpoints[outpointidx]);
448 [ + - ]: 172544 : const auto& real = cache.AccessCoin(data.outpoints[outpointidx]);
449 [ + - ]: 172544 : auto sim = lookup(outpointidx, sim_idx);
450 [ + + ]: 172544 : if (!sim.has_value()) {
451 [ + - - + ]: 155296 : assert(real.IsSpent());
452 : 155296 : } else {
453 [ + - - + ]: 17248 : assert(!real.IsSpent());
454 [ + - + - : 17248 : assert(real.out == data.coins[sim->first].out);
- + ]
455 [ + - + - ]: 17248 : assert(real.fCoinBase == data.coins[sim->first].fCoinBase);
456 [ + - - + ]: 17248 : assert(real.nHeight == sim->second);
457 : : }
458 : 172544 : }
459 : :
460 : : // HaveCoinInCache ignores spent coins, so GetCacheSize() may exceed it. */
461 [ + - + - ]: 674 : assert(cache.GetCacheSize() >= cache_size);
462 : 674 : }
463 : :
464 : : // Compare the bottom coinsview (not a CCoinsViewCache) with sim_cache[0].
465 [ + + ]: 107426 : for (uint32_t outpointidx = 0; outpointidx < NUM_OUTPOINTS; ++outpointidx) {
466 [ + - ]: 107008 : Coin realcoin;
467 [ + - ]: 107008 : bool real = bottom.GetCoin(data.outpoints[outpointidx], realcoin);
468 [ + - ]: 107008 : auto sim = lookup(outpointidx, 0);
469 [ + + ]: 107008 : if (!sim.has_value()) {
470 [ + + + - : 100580 : assert(!real || realcoin.IsSpent());
+ - ]
471 : 100580 : } else {
472 [ + - + - : 6428 : assert(real && !realcoin.IsSpent());
+ - ]
473 [ + - + - : 6428 : assert(realcoin.out == data.coins[sim->first].out);
- + ]
474 [ + - + - ]: 6428 : assert(realcoin.fCoinBase == data.coins[sim->first].fCoinBase);
475 [ + - - + ]: 6428 : assert(realcoin.nHeight == sim->second);
476 : : }
477 : 107008 : }
478 : 418 : }
|
