30 const Coin EMPTY_COIN{};
41 static const auto testing_setup = MakeNoLogFileContext<const TestingSetup>();
42 g_setup = testing_setup.get();
60 Coin coin = random_coin;
61 bool expected_code_path =
false;
62 const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
64 coins_view_cache.AddCoin(random_out_point, std::move(coin), possible_overwrite);
65 expected_code_path = true;
66 }
catch (
const std::logic_error& e) {
67 if (e.what() == std::string{
"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
68 assert(!possible_overwrite);
69 expected_code_path = true;
72 assert(expected_code_path);
75 (void)coins_view_cache.Flush();
78 (void)coins_view_cache.Sync();
81 coins_view_cache.SetBestBlock(
ConsumeUInt256(fuzzed_data_provider));
85 (void)coins_view_cache.SpendCoin(random_out_point, fuzzed_data_provider.ConsumeBool() ? &move_to :
nullptr);
88 coins_view_cache.Uncache(random_out_point);
91 if (fuzzed_data_provider.ConsumeBool()) {
94 coins_view_cache.SetBackend(backend_coins_view);
97 const std::optional<COutPoint> opt_out_point = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
101 random_out_point = *opt_out_point;
104 const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
108 random_coin = *opt_coin;
111 const std::optional<CMutableTransaction> opt_mutable_transaction = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider);
112 if (!opt_mutable_transaction) {
115 random_mutable_transaction = *opt_mutable_transaction;
121 coins_cache_entry.
flags = fuzzed_data_provider.ConsumeIntegral<
unsigned char>();
122 if (fuzzed_data_provider.ConsumeBool()) {
123 coins_cache_entry.
coin = random_coin;
125 const std::optional<Coin> opt_coin = ConsumeDeserializable<Coin>(fuzzed_data_provider);
129 coins_cache_entry.
coin = *opt_coin;
131 coins_map.emplace(random_out_point, std::move(coins_cache_entry));
133 bool expected_code_path =
false;
135 coins_view_cache.BatchWrite(coins_map, fuzzed_data_provider.ConsumeBool() ?
ConsumeUInt256(fuzzed_data_provider) : coins_view_cache.GetBestBlock());
136 expected_code_path =
true;
137 }
catch (
const std::logic_error& e) {
138 if (e.what() == std::string{
"FRESH flag misapplied to coin that exists in parent cache"}) {
139 expected_code_path =
true;
142 assert(expected_code_path);
147 const Coin& coin_using_access_coin = coins_view_cache.AccessCoin(random_out_point);
148 const bool exists_using_access_coin = !(coin_using_access_coin == EMPTY_COIN);
149 const bool exists_using_have_coin = coins_view_cache.HaveCoin(random_out_point);
150 const bool exists_using_have_coin_in_cache = coins_view_cache.HaveCoinInCache(random_out_point);
151 Coin coin_using_get_coin;
152 const bool exists_using_get_coin = coins_view_cache.GetCoin(random_out_point, coin_using_get_coin);
153 if (exists_using_get_coin) {
154 assert(coin_using_get_coin == coin_using_access_coin);
156 assert((exists_using_access_coin && exists_using_have_coin_in_cache && exists_using_have_coin && exists_using_get_coin) ||
157 (!exists_using_access_coin && !exists_using_have_coin_in_cache && !exists_using_have_coin && !exists_using_get_coin));
158 const bool exists_using_have_coin_in_backend = backend_coins_view.
HaveCoin(random_out_point);
159 if (exists_using_have_coin_in_backend) {
160 assert(exists_using_have_coin);
162 Coin coin_using_backend_get_coin;
163 if (backend_coins_view.
GetCoin(random_out_point, coin_using_backend_get_coin)) {
164 assert(exists_using_have_coin_in_backend);
165 assert(coin_using_get_coin == coin_using_backend_get_coin);
167 assert(!exists_using_have_coin_in_backend);
172 bool expected_code_path =
false;
174 (void)coins_view_cache.Cursor();
175 }
catch (
const std::logic_error&) {
176 expected_code_path =
true;
178 assert(expected_code_path);
179 (void)coins_view_cache.DynamicMemoryUsage();
180 (void)coins_view_cache.EstimateSize();
181 (void)coins_view_cache.GetBestBlock();
182 (void)coins_view_cache.GetCacheSize();
183 (void)coins_view_cache.GetHeadBlocks();
184 (void)coins_view_cache.HaveInputs(
CTransaction{random_mutable_transaction});
188 std::unique_ptr<CCoinsViewCursor> coins_view_cursor = backend_coins_view.Cursor();
189 assert(!coins_view_cursor);
190 (void)backend_coins_view.EstimateSize();
191 (void)backend_coins_view.GetBestBlock();
192 (void)backend_coins_view.GetHeadBlocks();
195 if (fuzzed_data_provider.ConsumeBool()) {
197 fuzzed_data_provider,
199 const CTransaction transaction{random_mutable_transaction};
200 bool is_spent =
false;
201 for (
const CTxOut& tx_out : transaction.vout) {
202 if (Coin{tx_out, 0, transaction.IsCoinBase()}.IsSpent()) {
211 bool expected_code_path =
false;
212 const int height{int(fuzzed_data_provider.ConsumeIntegral<uint32_t>() >> 1)};
213 const bool possible_overwrite = fuzzed_data_provider.ConsumeBool();
215 AddCoins(coins_view_cache, transaction, height, possible_overwrite);
216 expected_code_path =
true;
217 }
catch (
const std::logic_error& e) {
218 if (e.what() == std::string{
"Attempted to overwrite an unspent coin (when possible_overwrite is false)"}) {
219 assert(!possible_overwrite);
220 expected_code_path =
true;
223 assert(expected_code_path);
231 const CTransaction transaction{random_mutable_transaction};
242 if (
Consensus::CheckTxInputs(transaction, state, coins_view_cache, fuzzed_data_provider.ConsumeIntegralInRange<
int>(0, std::numeric_limits<int>::max()), tx_fee_out)) {
247 const CTransaction transaction{random_mutable_transaction};
256 const CTransaction transaction{random_mutable_transaction};
262 const auto flags{fuzzed_data_provider.ConsumeIntegral<uint32_t>()};
bool MoneyRange(const CAmount &nValue)
int64_t CAmount
Amount in satoshis (Can be negative)
catch(const std::exception &e)
CCoinsView that adds a memory cache for transactions to another CCoinsView.
Abstract view on the open txout dataset.
virtual bool GetCoin(const COutPoint &outpoint, Coin &coin) const
Retrieve the Coin (unspent transaction output) for a given outpoint.
virtual bool HaveCoin(const COutPoint &outpoint) const
Just check whether a given outpoint is unspent.
An outpoint - a combination of a transaction hash and an index n into its vout.
The basic transaction that is broadcasted on the network and contained in blocks.
An output of a transaction.
CTxOut out
unspent transaction output
bool IsSpent() const
Either this coin never existed (see e.g.
uint32_t nHeight
at which height this containing transaction was included in the active block chain
unsigned int fCoinBase
whether containing transaction was a coinbase
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.
std::unordered_map< COutPoint, CCoinsCacheEntry, SaltedOutpointHasher > CCoinsMap
void initialize_coins_view()
FUZZ_TARGET_INIT(coins_view, initialize_coins_view)
#define LIMITED_WHILE(condition, limit)
Can be used to limit a theoretically unbounded loop.
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...
bool operator==(const CNetAddr &a, const CNetAddr &b)
bool AreInputsStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs)
Check transaction inputs to mitigate two potential denial-of-service attacks:
bool IsWitnessStandard(const CTransaction &tx, const CCoinsViewCache &mapInputs)
Check if the transaction is over standard P2WSH resources limit: 3600bytes witnessScript size,...
A Coin in one level of the coins database caching hierarchy.
A mutable version of CTransaction.
Testing setup that configures a complete environment.
bool ContainsSpentInput(const CTransaction &tx, const CCoinsViewCache &inputs) noexcept
uint256 ConsumeUInt256(FuzzedDataProvider &fuzzed_data_provider) noexcept
size_t CallOneOf(FuzzedDataProvider &fuzzed_data_provider, Callables... callables)
bool CheckTransaction(const CTransaction &tx, TxValidationState &state)
int64_t GetTransactionSigOpCost(const CTransaction &tx, const CCoinsViewCache &inputs, uint32_t flags)
Compute total signature operation cost of a transaction.
unsigned int GetP2SHSigOpCount(const CTransaction &tx, const CCoinsViewCache &inputs)
Count ECDSA signature operations in pay-to-script-hash inputs.