Bitcoin Core 29.99.0
P2P Digital Currency
coins_view.cpp
Go to the documentation of this file.
1// Copyright (c) 2020-present 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 <consensus/amount.h>
10#include <policy/policy.h>
12#include <script/interpreter.h>
14#include <test/fuzz/fuzz.h>
15#include <test/fuzz/util.h>
17#include <txdb.h>
18#include <util/hasher.h>
19
20#include <cassert>
21#include <cstdint>
22#include <limits>
23#include <memory>
24#include <optional>
25#include <stdexcept>
26#include <string>
27#include <utility>
28#include <vector>
29
30namespace {
31const Coin EMPTY_COIN{};
32
33bool operator==(const Coin& a, const Coin& b)
34{
35 if (a.IsSpent() && b.IsSpent()) return true;
36 return a.fCoinBase == b.fCoinBase && a.nHeight == b.nHeight && a.out == b.out;
37}
38} // namespace
39
41{
42 static const auto testing_setup = MakeNoLogFileContext<>();
43}
44
45void TestCoinsView(FuzzedDataProvider& fuzzed_data_provider, CCoinsView& backend_coins_view, bool is_db)
46{
47 bool good_data{true};
48
49 CCoinsViewCache coins_view_cache{&backend_coins_view, /*deterministic=*/true};
50 if (is_db) coins_view_cache.SetBestBlock(uint256::ONE);
51 COutPoint random_out_point;
52 Coin random_coin;
53 CMutableTransaction random_mutable_transaction;
54 LIMITED_WHILE(good_data && fuzzed_data_provider.ConsumeBool(), 10'000)
55 {
57 fuzzed_data_provider,
58 [&] {
59 if (random_coin.IsSpent()) {
60 return;
61 }
62 Coin coin = random_coin;
63 bool expected_code_path = false;
64 const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
65 try {
66 coins_view_cache.AddCoin(random_out_point, std::move(coin), possible_overwrite);
67 expected_code_path = true;
68 } catch (const std::logic_error& e) {
69 if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
70 assert(!possible_overwrite);
71 expected_code_path = true;
72 // AddCoin() decreases cachedCoinsUsage by the memory usage of the old coin at the beginning and
73 // increases it by the value of the new coin at the end. If it throws in the process, the value
74 // of cachedCoinsUsage would have been incorrectly decreased, leading to an underflow later on.
75 // To avoid this, use Flush() to reset the value of cachedCoinsUsage in sync with the cacheCoins
76 // mapping.
77 (void)coins_view_cache.Flush();
78 }
79 }
80 assert(expected_code_path);
81 },
82 [&] {
83 (void)coins_view_cache.Flush();
84 },
85 [&] {
86 (void)coins_view_cache.Sync();
87 },
88 [&] {
89 uint256 best_block{ConsumeUInt256(fuzzed_data_provider)};
90 // Set best block hash to non-null to satisfy the assertion in CCoinsViewDB::BatchWrite().
91 if (is_db && best_block.IsNull()) best_block = uint256::ONE;
92 coins_view_cache.SetBestBlock(best_block);
93 },
94 [&] {
95 Coin move_to;
96 (void)coins_view_cache.SpendCoin(random_out_point, fuzzed_data_provider.ConsumeBool() ? &move_to : nullptr);
97 },
98 [&] {
99 coins_view_cache.Uncache(random_out_point);
100 },
101 [&] {
102 if (fuzzed_data_provider.ConsumeBool()) {
103 backend_coins_view = CCoinsView{};
104 }
105 coins_view_cache.SetBackend(backend_coins_view);
106 },
107 [&] {
108 const std::optional<COutPoint> opt_out_point = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
109 if (!opt_out_point) {
110 good_data = false;
111 return;
112 }
113 random_out_point = *opt_out_point;
114 },
115 [&] {
116 const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
117 if (!opt_coin) {
118 good_data = false;
119 return;
120 }
121 random_coin = *opt_coin;
122 },
123 [&] {
124 const std::optional<CMutableTransaction> opt_mutable_transaction = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider, TX_WITH_WITNESS);
125 if (!opt_mutable_transaction) {
126 good_data = false;
127 return;
128 }
129 random_mutable_transaction = *opt_mutable_transaction;
130 },
131 [&] {
132 CoinsCachePair sentinel{};
133 sentinel.second.SelfRef(sentinel);
134 size_t usage{0};
136 CCoinsMap coins_map{0, SaltedOutpointHasher{/*deterministic=*/true}, CCoinsMap::key_equal{}, &resource};
137 LIMITED_WHILE(good_data && fuzzed_data_provider.ConsumeBool(), 10'000)
138 {
139 CCoinsCacheEntry coins_cache_entry;
140 const auto dirty{fuzzed_data_provider.ConsumeBool()};
141 const auto fresh{fuzzed_data_provider.ConsumeBool()};
142 if (fuzzed_data_provider.ConsumeBool()) {
143 coins_cache_entry.coin = random_coin;
144 } else {
145 const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
146 if (!opt_coin) {
147 good_data = false;
148 return;
149 }
150 coins_cache_entry.coin = *opt_coin;
151 }
152 auto it{coins_map.emplace(random_out_point, std::move(coins_cache_entry)).first};
153 if (dirty) CCoinsCacheEntry::SetDirty(*it, sentinel);
154 if (fresh) CCoinsCacheEntry::SetFresh(*it, sentinel);
155 usage += it->second.coin.DynamicMemoryUsage();
156 }
157 bool expected_code_path = false;
158 try {
159 auto cursor{CoinsViewCacheCursor(usage, sentinel, coins_map, /*will_erase=*/true)};
160 uint256 best_block{coins_view_cache.GetBestBlock()};
161 if (fuzzed_data_provider.ConsumeBool()) best_block = ConsumeUInt256(fuzzed_data_provider);
162 // Set best block hash to non-null to satisfy the assertion in CCoinsViewDB::BatchWrite().
163 if (is_db && best_block.IsNull()) best_block = uint256::ONE;
164 coins_view_cache.BatchWrite(cursor, best_block);
165 expected_code_path = true;
166 } catch (const std::logic_error& e) {
167 if (e.what() == std::string{"FRESH flag misapplied to coin that exists in parent cache"}) {
168 expected_code_path = true;
169 }
170 }
171 assert(expected_code_path);
172 });
173 }
174
175 {
176 const Coin& coin_using_access_coin = coins_view_cache.AccessCoin(random_out_point);
177 const bool exists_using_access_coin = !(coin_using_access_coin == EMPTY_COIN);
178 const bool exists_using_have_coin = coins_view_cache.HaveCoin(random_out_point);
179 const bool exists_using_have_coin_in_cache = coins_view_cache.HaveCoinInCache(random_out_point);
180 if (auto coin{coins_view_cache.GetCoin(random_out_point)}) {
181 assert(*coin == coin_using_access_coin);
182 assert(exists_using_access_coin && exists_using_have_coin_in_cache && exists_using_have_coin);
183 } else {
184 assert(!exists_using_access_coin && !exists_using_have_coin_in_cache && !exists_using_have_coin);
185 }
186 // If HaveCoin on the backend is true, it must also be on the cache if the coin wasn't spent.
187 const bool exists_using_have_coin_in_backend = backend_coins_view.HaveCoin(random_out_point);
188 if (!coin_using_access_coin.IsSpent() && exists_using_have_coin_in_backend) {
189 assert(exists_using_have_coin);
190 }
191 if (auto coin{backend_coins_view.GetCoin(random_out_point)}) {
192 assert(exists_using_have_coin_in_backend);
193 // Note we can't assert that `coin_using_get_coin == *coin` because the coin in
194 // the cache may have been modified but not yet flushed.
195 } else {
196 assert(!exists_using_have_coin_in_backend);
197 }
198 }
199
200 {
201 bool expected_code_path = false;
202 try {
203 (void)coins_view_cache.Cursor();
204 } catch (const std::logic_error&) {
205 expected_code_path = true;
206 }
207 assert(expected_code_path);
208 (void)coins_view_cache.DynamicMemoryUsage();
209 (void)coins_view_cache.EstimateSize();
210 (void)coins_view_cache.GetBestBlock();
211 (void)coins_view_cache.GetCacheSize();
212 (void)coins_view_cache.GetHeadBlocks();
213 (void)coins_view_cache.HaveInputs(CTransaction{random_mutable_transaction});
214 }
215
216 {
217 std::unique_ptr<CCoinsViewCursor> coins_view_cursor = backend_coins_view.Cursor();
218 assert(is_db == !!coins_view_cursor);
219 (void)backend_coins_view.EstimateSize();
220 (void)backend_coins_view.GetBestBlock();
221 (void)backend_coins_view.GetHeadBlocks();
222 }
223
224 if (fuzzed_data_provider.ConsumeBool()) {
225 CallOneOf(
226 fuzzed_data_provider,
227 [&] {
228 const CTransaction transaction{random_mutable_transaction};
229 bool is_spent = false;
230 for (const CTxOut& tx_out : transaction.vout) {
231 if (Coin{tx_out, 0, transaction.IsCoinBase()}.IsSpent()) {
232 is_spent = true;
233 }
234 }
235 if (is_spent) {
236 // Avoid:
237 // coins.cpp:69: void CCoinsViewCache::AddCoin(const COutPoint &, Coin &&, bool): Assertion `!coin.IsSpent()' failed.
238 return;
239 }
240 bool expected_code_path = false;
241 const int height{int(fuzzed_data_provider.ConsumeIntegral<uint32_t>() >> 1)};
242 const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
243 try {
244 AddCoins(coins_view_cache, transaction, height, possible_overwrite);
245 expected_code_path = true;
246 } catch (const std::logic_error& e) {
247 if (e.what() == std::string{"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
248 assert(!possible_overwrite);
249 expected_code_path = true;
250 }
251 }
252 assert(expected_code_path);
253 },
254 [&] {
255 (void)AreInputsStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
256 },
257 [&] {
258 TxValidationState state;
259 CAmount tx_fee_out;
260 const CTransaction transaction{random_mutable_transaction};
261 if (ContainsSpentInput(transaction, coins_view_cache)) {
262 // Avoid:
263 // consensus/tx_verify.cpp:171: bool Consensus::CheckTxInputs(const CTransaction &, TxValidationState &, const CCoinsViewCache &, int, CAmount &): Assertion `!coin.IsSpent()' failed.
264 return;
265 }
266 TxValidationState dummy;
267 if (!CheckTransaction(transaction, dummy)) {
268 // It is not allowed to call CheckTxInputs if CheckTransaction failed
269 return;
270 }
271 if (Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<int>(0, std::numeric_limits<int>::max()), tx_fee_out)) {
272 assert(MoneyRange(tx_fee_out));
273 }
274 },
275 [&] {
276 const CTransaction transaction{random_mutable_transaction};
277 if (ContainsSpentInput(transaction, coins_view_cache)) {
278 // Avoid:
279 // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
280 return;
281 }
282 (void)GetP2SHSigOpCount(transaction, coins_view_cache);
283 },
284 [&] {
285 const CTransaction transaction{random_mutable_transaction};
286 if (ContainsSpentInput(transaction, coins_view_cache)) {
287 // Avoid:
288 // consensus/tx_verify.cpp:130: unsigned int GetP2SHSigOpCount(const CTransaction &, const CCoinsViewCache &): Assertion `!coin.IsSpent()' failed.
289 return;
290 }
291 const auto flags{fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
292 if (!transaction.vin.empty() && (flags & SCRIPT_VERIFY_WITNESS) != 0 && (flags & SCRIPT_VERIFY_P2SH) == 0) {
293 // Avoid:
294 // script/interpreter.cpp:1705: size_t CountWitnessSigOps(const CScript &, const CScript &, const CScriptWitness *, unsigned int): Assertion `(flags & SCRIPT_VERIFY_P2SH) != 0' failed.
295 return;
296 }
297 (void)GetTransactionSigOpCost(transaction, coins_view_cache, flags);
298 },
299 [&] {
300 (void)IsWitnessStandard(CTransaction{random_mutable_transaction}, coins_view_cache);
301 });
302 }
303}
304
306{
307 FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
308 CCoinsView backend_coins_view;
309 TestCoinsView(fuzzed_data_provider, backend_coins_view, /*is_db=*/false);
310}
311
313{
314 FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
315 auto db_params = DBParams{
316 .path = "",
317 .cache_bytes = 1_MiB,
318 .memory_only = true,
319 };
320 CCoinsViewDB coins_db{std::move(db_params), CoinsViewOptions{}};
321 TestCoinsView(fuzzed_data_provider, coins_db, /*is_db=*/true);
322}
bool MoneyRange(const CAmount &nValue)
Definition: amount.h:27
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
catch(const std::exception &e)
int flags
Definition: bitcoin-tx.cpp:529
CCoinsView that adds a memory cache for transactions to another CCoinsView.
Definition: coins.h:363
CCoinsView backed by the coin database (chainstate/)
Definition: txdb.h:38
Abstract view on the open txout dataset.
Definition: coins.h:310
virtual std::optional< Coin > GetCoin(const COutPoint &outpoint) const
Retrieve the Coin (unspent transaction output) for a given outpoint.
Definition: coins.cpp:16
virtual bool HaveCoin(const COutPoint &outpoint) const
Just check whether a given outpoint is unspent.
Definition: coins.cpp:22
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:29
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:296
An output of a transaction.
Definition: transaction.h:150
A UTXO entry.
Definition: coins.h:33
CTxOut out
unspent transaction output
Definition: coins.h:36
bool IsSpent() const
Either this coin never existed (see e.g.
Definition: coins.h:81
uint32_t nHeight
at which height this containing transaction was included in the active block chain
Definition: coins.h:42
unsigned int fCoinBase
whether containing transaction was a coinbase
Definition: coins.h:39
256-bit opaque blob.
Definition: uint256.h:196
static const uint256 ONE
Definition: uint256.h:205
void AddCoins(CCoinsViewCache &cache, const CTransaction &tx, int nHeight, bool check_for_overwrite)
Utility function to add all of a transaction's outputs to a cache.
Definition: coins.cpp:119
std::pair< const COutPoint, CCoinsCacheEntry > CoinsCachePair
Definition: coins.h:91
std::unordered_map< COutPoint, CCoinsCacheEntry, SaltedOutpointHasher, std::equal_to< COutPoint >, PoolAllocator< CoinsCachePair, sizeof(CoinsCachePair)+sizeof(void *) *4 > > CCoinsMap
PoolAllocator's MAX_BLOCK_SIZE_BYTES parameter here uses sizeof the data, and adds the size of 4 poin...
Definition: coins.h:229
CCoinsMap::allocator_type::ResourceType CCoinsMapMemoryResource
Definition: coins.h:231
void TestCoinsView(FuzzedDataProvider &fuzzed_data_provider, CCoinsView &backend_coins_view, bool is_db)
Definition: coins_view.cpp:45
FUZZ_TARGET(coins_view,.init=initialize_coins_view)
Definition: coins_view.cpp:305
void initialize_coins_view()
Definition: coins_view.cpp:40
#define LIMITED_WHILE(condition, limit)
Can be used to limit a theoretically unbounded loop.
Definition: fuzz.h:22
@ SCRIPT_VERIFY_P2SH
Definition: interpreter.h:49
@ SCRIPT_VERIFY_WITNESS
Definition: interpreter.h:108
bool CheckTxInputs(const CTransaction &tx, TxValidationState &state, const CCoinsViewCache &inputs, int nSpendHeight, CAmount &txfee)
Check whether all inputs of this transaction are valid (no double spends and amounts) This does not m...
Definition: tx_verify.cpp:164
bool operator==(const CNetAddr &a, const CNetAddr &b)
Definition: netaddress.cpp:607
bool AreInputsStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs)
Check transaction inputs.
Definition: policy.cpp:182
bool IsWitnessStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs)
Check if the transaction is over standard P2WSH resources limit: 3600bytes witnessScript size,...
Definition: policy.cpp:216
static constexpr TransactionSerParams TX_WITH_WITNESS
Definition: transaction.h:195
A Coin in one level of the coins database caching hierarchy.
Definition: coins.h:109
Coin coin
Definition: coins.h:147
static void SetFresh(CoinsCachePair &pair, CoinsCachePair &sentinel) noexcept
Definition: coins.h:178
static void SetDirty(CoinsCachePair &pair, CoinsCachePair &sentinel) noexcept
Definition: coins.h:177
A mutable version of CTransaction.
Definition: transaction.h:378
Cursor for iterating over the linked list of flagged entries in CCoinsViewCache.
Definition: coins.h:266
User-controlled performance and debug options.
Definition: txdb.h:28
Application-specific storage settings.
Definition: dbwrapper.h:34
fs::path path
Location in the filesystem where leveldb data will be stored.
Definition: dbwrapper.h:36
bool ContainsSpentInput(const CTransaction &tx, const CCoinsViewCache &inputs) noexcept
Definition: util.cpp:240
uint256 ConsumeUInt256(FuzzedDataProvider &fuzzed_data_provider) noexcept
Definition: util.h:171
size_t CallOneOf(FuzzedDataProvider &fuzzed_data_provider, Callables... callables)
Definition: util.h:35
bool CheckTransaction(const CTransaction &tx, TxValidationState &state)
Definition: tx_check.cpp:11
int64_t GetTransactionSigOpCost(const CTransaction &tx, const CCoinsViewCache &inputs, uint32_t flags)
Compute total signature operation cost of a transaction.
Definition: tx_verify.cpp:143
unsigned int GetP2SHSigOpCount(const CTransaction &tx, const CCoinsViewCache &inputs)
Count ECDSA signature operations in pay-to-script-hash inputs.
Definition: tx_verify.cpp:126
assert(!tx.IsCoinBase())