Branch data Line data Source code
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 <index/coinstatsindex.h>
6 : :
7 : : #include <arith_uint256.h>
8 : : #include <chain.h>
9 : : #include <chainparams.h>
10 : : #include <coins.h>
11 : : #include <common/args.h>
12 : : #include <consensus/amount.h>
13 : : #include <crypto/muhash.h>
14 : : #include <dbwrapper.h>
15 : : #include <index/base.h>
16 : : #include <index/db_key.h>
17 : : #include <interfaces/chain.h>
18 : : #include <interfaces/types.h>
19 : : #include <kernel/coinstats.h>
20 : : #include <primitives/block.h>
21 : : #include <primitives/transaction.h>
22 : : #include <script/script.h>
23 : : #include <serialize.h>
24 : : #include <uint256.h>
25 : : #include <undo.h>
26 : : #include <util/check.h>
27 : : #include <util/fs.h>
28 : : #include <util/log.h>
29 : : #include <validation.h>
30 : :
31 : : #include <compare>
32 : : #include <limits>
33 : : #include <string>
34 : : #include <utility>
35 : : #include <vector>
36 : :
37 : : using kernel::ApplyCoinHash;
38 : : using kernel::CCoinsStats;
39 : : using kernel::GetBogoSize;
40 : : using kernel::RemoveCoinHash;
41 : :
42 : : static constexpr uint8_t DB_MUHASH{'M'};
43 : :
44 : : namespace {
45 : :
46 : : struct DBVal {
47 : : uint256 muhash{uint256::ZERO};
48 : : uint64_t transaction_output_count{0};
49 : : uint64_t bogo_size{0};
50 : : CAmount total_amount{0};
51 : : CAmount total_subsidy{0};
52 : : arith_uint256 total_prevout_spent_amount{0};
53 : : arith_uint256 total_new_outputs_ex_coinbase_amount{0};
54 : : arith_uint256 total_coinbase_amount{0};
55 : : CAmount total_unspendables_genesis_block{0};
56 : : CAmount total_unspendables_bip30{0};
57 : : CAmount total_unspendables_scripts{0};
58 : : CAmount total_unspendables_unclaimed_rewards{0};
59 : :
60 : 24626 : SERIALIZE_METHODS(DBVal, obj)
61 : : {
62 : 12313 : uint256 prevout_spent, new_outputs, coinbase;
63 : 12313 : SER_WRITE(obj, prevout_spent = ArithToUint256(obj.total_prevout_spent_amount));
64 : 12313 : SER_WRITE(obj, new_outputs = ArithToUint256(obj.total_new_outputs_ex_coinbase_amount));
65 : 12313 : SER_WRITE(obj, coinbase = ArithToUint256(obj.total_coinbase_amount));
66 : :
67 : 12313 : READWRITE(obj.muhash);
68 : 12313 : READWRITE(obj.transaction_output_count);
69 : 12313 : READWRITE(obj.bogo_size);
70 : 12313 : READWRITE(obj.total_amount);
71 : 12313 : READWRITE(obj.total_subsidy);
72 : 12313 : READWRITE(prevout_spent);
73 : 12313 : READWRITE(new_outputs);
74 : 12313 : READWRITE(coinbase);
75 : 12313 : READWRITE(obj.total_unspendables_genesis_block);
76 : 12313 : READWRITE(obj.total_unspendables_bip30);
77 : 12313 : READWRITE(obj.total_unspendables_scripts);
78 : 12313 : READWRITE(obj.total_unspendables_unclaimed_rewards);
79 : :
80 : 12313 : SER_READ(obj, obj.total_prevout_spent_amount = UintToArith256(prevout_spent));
81 : 12313 : SER_READ(obj, obj.total_new_outputs_ex_coinbase_amount = UintToArith256(new_outputs));
82 : 12313 : SER_READ(obj, obj.total_coinbase_amount = UintToArith256(coinbase));
83 : 12313 : }
84 : : };
85 : : }; // namespace
86 : :
87 : : std::unique_ptr<CoinStatsIndex> g_coin_stats_index;
88 : :
89 : 51 : CoinStatsIndex::CoinStatsIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory, bool f_wipe)
90 [ + - ]: 51 : : BaseIndex(std::move(chain), "coinstatsindex")
91 : : {
92 : : // An earlier version of the index used "indexes/coinstats" but it contained
93 : : // a bug and is superseded by a fixed version at "indexes/coinstatsindex".
94 : : // The original index is kept around until the next release in case users
95 : : // decide to downgrade their node.
96 [ + - + - ]: 204 : auto old_path = gArgs.GetDataDirNet() / "indexes" / "coinstats";
97 [ + - + + ]: 51 : if (fs::exists(old_path)) {
98 : : // TODO: Change this to deleting the old index with v31.
99 [ - + + - ]: 3 : LogWarning("Old version of coinstatsindex found at %s. This folder can be safely deleted unless you " \
100 : : "plan to downgrade your node to version 29 or lower.", fs::PathToString(old_path));
101 : : }
102 [ + - + - ]: 204 : fs::path path{gArgs.GetDataDirNet() / "indexes" / "coinstatsindex"};
103 [ + - ]: 51 : fs::create_directories(path);
104 : :
105 [ + - + - : 204 : m_db = std::make_unique<CoinStatsIndex::DB>(path / "db", n_cache_size, f_memory, f_wipe);
+ + ]
106 : 103 : }
107 : :
108 : 11721 : bool CoinStatsIndex::CustomAppend(const interfaces::BlockInfo& block)
109 : : {
110 : 11721 : const CAmount block_subsidy{GetBlockSubsidy(block.height, Params().GetConsensus())};
111 : 11721 : m_total_subsidy += block_subsidy;
112 : :
113 : : // Ignore genesis block
114 [ + + ]: 11721 : if (block.height > 0) {
115 [ - + ]: 11703 : uint256 expected_block_hash{*Assert(block.prev_hash)};
116 [ - + ]: 11703 : if (m_current_block_hash != expected_block_hash) {
117 [ # # # # ]: 0 : LogError("previous block header belongs to unexpected block %s; expected %s",
118 : : m_current_block_hash.ToString(), expected_block_hash.ToString());
119 : 0 : return false;
120 : : }
121 : :
122 : : // Add the new utxos created from the block
123 [ - + ]: 11703 : assert(block.data);
124 [ - + + + ]: 23653 : for (size_t i = 0; i < block.data->vtx.size(); ++i) {
125 : 11950 : const auto& tx{block.data->vtx.at(i)};
126 [ + + ]: 11950 : const bool is_coinbase{tx->IsCoinBase()};
127 : :
128 : : // Skip duplicate txid coinbase transactions (BIP30).
129 [ + + - + ]: 11950 : if (is_coinbase && IsBIP30Unspendable(block.hash, block.height)) {
130 : 0 : m_total_unspendables_bip30 += block_subsidy;
131 : 0 : continue;
132 : : }
133 : :
134 [ - + + + ]: 35606 : for (uint32_t j = 0; j < tx->vout.size(); ++j) {
135 : 23656 : const CTxOut& out{tx->vout[j]};
136 : 23656 : const Coin coin{out, block.height, is_coinbase};
137 [ + + ]: 23656 : const COutPoint outpoint{tx->GetHash(), j};
138 : :
139 : : // Skip unspendable coins
140 [ + + ]: 23656 : if (coin.out.scriptPubKey.IsUnspendable()) {
141 : 11703 : m_total_unspendables_scripts += coin.out.nValue;
142 : 11703 : continue;
143 : : }
144 : :
145 [ + - ]: 11953 : ApplyCoinHash(m_muhash, outpoint, coin);
146 : :
147 [ + + ]: 11953 : if (is_coinbase) {
148 : 11706 : m_total_coinbase_amount += coin.out.nValue;
149 : : } else {
150 : 247 : m_total_new_outputs_ex_coinbase_amount += coin.out.nValue;
151 : : }
152 : :
153 : 11953 : ++m_transaction_output_count;
154 : 11953 : m_total_amount += coin.out.nValue;
155 [ + - ]: 11953 : m_bogo_size += GetBogoSize(coin.out.scriptPubKey);
156 : 23656 : }
157 : :
158 : : // The coinbase tx has no undo data since no former output is spent
159 [ + + ]: 11950 : if (!is_coinbase) {
160 [ - + ]: 247 : const auto& tx_undo{Assert(block.undo_data)->vtxundo.at(i - 1)};
161 : :
162 [ - + + + ]: 494 : for (size_t j = 0; j < tx_undo.vprevout.size(); ++j) {
163 : 247 : const Coin& coin{tx_undo.vprevout[j]};
164 : 247 : const COutPoint outpoint{tx->vin[j].prevout.hash, tx->vin[j].prevout.n};
165 : :
166 : 247 : RemoveCoinHash(m_muhash, outpoint, coin);
167 : :
168 : 247 : m_total_prevout_spent_amount += coin.out.nValue;
169 : :
170 : 247 : --m_transaction_output_count;
171 : 247 : m_total_amount -= coin.out.nValue;
172 : 247 : m_bogo_size -= GetBogoSize(coin.out.scriptPubKey);
173 : : }
174 : : }
175 : : }
176 : : } else {
177 : : // genesis block
178 : 18 : m_total_unspendables_genesis_block += block_subsidy;
179 : : }
180 : :
181 : : // If spent prevouts + block subsidy are still a higher amount than
182 : : // new outputs + coinbase + current unspendable amount this means
183 : : // the miner did not claim the full block reward. Unclaimed block
184 : : // rewards are also unspendable.
185 : 11721 : const CAmount temp_total_unspendable_amount{m_total_unspendables_genesis_block + m_total_unspendables_bip30 + m_total_unspendables_scripts + m_total_unspendables_unclaimed_rewards};
186 : 35163 : const arith_uint256 unclaimed_rewards{(m_total_prevout_spent_amount + m_total_subsidy) - (m_total_new_outputs_ex_coinbase_amount + m_total_coinbase_amount + temp_total_unspendable_amount)};
187 [ - + ]: 11721 : assert(unclaimed_rewards <= arith_uint256(std::numeric_limits<CAmount>::max()));
188 : 11721 : m_total_unspendables_unclaimed_rewards += static_cast<CAmount>(unclaimed_rewards.GetLow64());
189 : :
190 : 11721 : std::pair<uint256, DBVal> value;
191 : 11721 : value.first = block.hash;
192 : 11721 : value.second.transaction_output_count = m_transaction_output_count;
193 : 11721 : value.second.bogo_size = m_bogo_size;
194 : 11721 : value.second.total_amount = m_total_amount;
195 : 11721 : value.second.total_subsidy = m_total_subsidy;
196 : 11721 : value.second.total_prevout_spent_amount = m_total_prevout_spent_amount;
197 : 11721 : value.second.total_new_outputs_ex_coinbase_amount = m_total_new_outputs_ex_coinbase_amount;
198 : 11721 : value.second.total_coinbase_amount = m_total_coinbase_amount;
199 : 11721 : value.second.total_unspendables_genesis_block = m_total_unspendables_genesis_block;
200 : 11721 : value.second.total_unspendables_bip30 = m_total_unspendables_bip30;
201 : 11721 : value.second.total_unspendables_scripts = m_total_unspendables_scripts;
202 : 11721 : value.second.total_unspendables_unclaimed_rewards = m_total_unspendables_unclaimed_rewards;
203 : :
204 : 11721 : uint256 out;
205 : 11721 : m_muhash.Finalize(out);
206 : 11721 : value.second.muhash = out;
207 : :
208 : 11721 : m_current_block_hash = block.hash;
209 : :
210 : : // Intentionally do not update DB_MUHASH here so it stays in sync with
211 : : // DB_BEST_BLOCK, and the index is not corrupted if there is an unclean shutdown.
212 : 11721 : m_db->Write(index_util::DBHeightKey(block.height), value);
213 : 11721 : return true;
214 : : }
215 : :
216 : 163 : bool CoinStatsIndex::CustomRemove(const interfaces::BlockInfo& block)
217 : : {
218 : 163 : CDBBatch batch(*m_db);
219 [ + - + - ]: 163 : std::unique_ptr<CDBIterator> db_it(m_db->NewIterator());
220 : :
221 : : // During a reorg, copy the block's hash digest from the height index to the hash index,
222 : : // ensuring it's still accessible after the height index entry is overwritten.
223 [ + - + - ]: 163 : if (!index_util::CopyHeightIndexToHashIndex<DBVal>(*db_it, batch, m_name, block.height)) {
224 : : return false;
225 : : }
226 : :
227 [ + - ]: 163 : m_db->WriteBatch(batch);
228 : :
229 [ + - - + ]: 163 : if (!RevertBlock(block)) {
230 : 0 : return false; // failure cause logged internally
231 : : }
232 : :
233 : : return true;
234 : 163 : }
235 : :
236 : 68 : std::optional<CCoinsStats> CoinStatsIndex::LookUpStats(const CBlockIndex& block_index) const
237 : : {
238 : 68 : CCoinsStats stats{block_index.nHeight, block_index.GetBlockHash()};
239 : 68 : stats.index_used = true;
240 : :
241 : 68 : DBVal entry;
242 [ + + ]: 68 : if (!index_util::LookUpOne(*m_db, {block_index.GetBlockHash(), block_index.nHeight}, entry)) {
243 : 1 : return std::nullopt;
244 : : }
245 : :
246 : 67 : stats.hashSerialized = entry.muhash;
247 : 67 : stats.nTransactionOutputs = entry.transaction_output_count;
248 : 67 : stats.nBogoSize = entry.bogo_size;
249 : 67 : stats.total_amount = entry.total_amount;
250 : 67 : stats.total_subsidy = entry.total_subsidy;
251 : 67 : stats.total_prevout_spent_amount = entry.total_prevout_spent_amount;
252 : 67 : stats.total_new_outputs_ex_coinbase_amount = entry.total_new_outputs_ex_coinbase_amount;
253 : 67 : stats.total_coinbase_amount = entry.total_coinbase_amount;
254 : 67 : stats.total_unspendables_genesis_block = entry.total_unspendables_genesis_block;
255 : 67 : stats.total_unspendables_bip30 = entry.total_unspendables_bip30;
256 : 67 : stats.total_unspendables_scripts = entry.total_unspendables_scripts;
257 : 67 : stats.total_unspendables_unclaimed_rewards = entry.total_unspendables_unclaimed_rewards;
258 : :
259 : 67 : return stats;
260 : : }
261 : :
262 : 53 : bool CoinStatsIndex::CustomInit(const std::optional<interfaces::BlockRef>& block)
263 : : {
264 [ + + ]: 53 : if (!m_db->Read(DB_MUHASH, m_muhash)) {
265 : : // Check that the cause of the read failure is that the key does not
266 : : // exist. Any other errors indicate database corruption or a disk
267 : : // failure, and starting the index would cause further corruption.
268 [ - + ]: 19 : if (m_db->Exists(DB_MUHASH)) {
269 : 0 : LogError("Cannot read current %s state; index may be corrupted",
270 : : GetName());
271 : 0 : return false;
272 : : }
273 : : }
274 : :
275 [ + + ]: 53 : if (block) {
276 : 34 : DBVal entry;
277 [ - + ]: 34 : if (!index_util::LookUpOne(*m_db, *block, entry)) {
278 : 0 : LogError("Cannot read current %s state; index may be corrupted",
279 : : GetName());
280 : 0 : return false;
281 : : }
282 : :
283 : 34 : uint256 out;
284 : 34 : m_muhash.Finalize(out);
285 [ - + ]: 34 : if (entry.muhash != out) {
286 : 0 : LogError("Cannot read current %s state; index may be corrupted",
287 : : GetName());
288 : 0 : return false;
289 : : }
290 : :
291 : 34 : m_transaction_output_count = entry.transaction_output_count;
292 : 34 : m_bogo_size = entry.bogo_size;
293 : 34 : m_total_amount = entry.total_amount;
294 : 34 : m_total_subsidy = entry.total_subsidy;
295 : 34 : m_total_prevout_spent_amount = entry.total_prevout_spent_amount;
296 : 34 : m_total_new_outputs_ex_coinbase_amount = entry.total_new_outputs_ex_coinbase_amount;
297 : 34 : m_total_coinbase_amount = entry.total_coinbase_amount;
298 : 34 : m_total_unspendables_genesis_block = entry.total_unspendables_genesis_block;
299 : 34 : m_total_unspendables_bip30 = entry.total_unspendables_bip30;
300 : 34 : m_total_unspendables_scripts = entry.total_unspendables_scripts;
301 : 34 : m_total_unspendables_unclaimed_rewards = entry.total_unspendables_unclaimed_rewards;
302 : 34 : m_current_block_hash = block->hash;
303 : : }
304 : :
305 : : return true;
306 : : }
307 : :
308 : 123 : bool CoinStatsIndex::CustomCommit(CDBBatch& batch)
309 : : {
310 : : // DB_MUHASH should always be committed in a batch together with DB_BEST_BLOCK
311 : : // to prevent an inconsistent state of the DB.
312 : 123 : batch.Write(DB_MUHASH, m_muhash);
313 : 123 : return true;
314 : : }
315 : :
316 : 12075 : interfaces::Chain::NotifyOptions CoinStatsIndex::CustomOptions()
317 : : {
318 : 12075 : interfaces::Chain::NotifyOptions options;
319 : 12075 : options.connect_undo_data = true;
320 : 12075 : options.disconnect_data = true;
321 : 12075 : options.disconnect_undo_data = true;
322 : 12075 : return options;
323 : : }
324 : :
325 : : // Revert a single block as part of a reorg
326 : 163 : bool CoinStatsIndex::RevertBlock(const interfaces::BlockInfo& block)
327 : : {
328 : 163 : std::pair<uint256, DBVal> read_out;
329 : :
330 : : // Ignore genesis block
331 [ + - ]: 163 : if (block.height > 0) {
332 [ + - ]: 163 : if (!m_db->Read(index_util::DBHeightKey(block.height - 1), read_out)) {
333 : : return false;
334 : : }
335 : :
336 : 163 : uint256 expected_block_hash{*block.prev_hash};
337 [ - + ]: 163 : if (read_out.first != expected_block_hash) {
338 [ # # # # ]: 0 : LogWarning("previous block header belongs to unexpected block %s; expected %s",
339 : : read_out.first.ToString(), expected_block_hash.ToString());
340 : :
341 [ # # ]: 0 : if (!m_db->Read(index_util::DBHashKey(expected_block_hash), read_out)) {
342 [ # # ]: 0 : LogError("previous block header not found; expected %s",
343 : : expected_block_hash.ToString());
344 : 0 : return false;
345 : : }
346 : : }
347 : : }
348 : :
349 : : // Roll back muhash by removing the new UTXOs that were created by the
350 : : // block and reapplying the old UTXOs that were spent by the block
351 [ - + ]: 163 : assert(block.data);
352 [ - + ]: 163 : assert(block.undo_data);
353 [ - + + + ]: 330 : for (size_t i = 0; i < block.data->vtx.size(); ++i) {
354 : 167 : const auto& tx{block.data->vtx.at(i)};
355 [ + + ]: 167 : const bool is_coinbase{tx->IsCoinBase()};
356 : :
357 [ + + - + ]: 167 : if (is_coinbase && IsBIP30Unspendable(block.hash, block.height)) {
358 : 0 : continue;
359 : : }
360 : :
361 [ - + + + ]: 498 : for (uint32_t j = 0; j < tx->vout.size(); ++j) {
362 : 331 : const CTxOut& out{tx->vout[j]};
363 : 331 : const COutPoint outpoint{tx->GetHash(), j};
364 : 331 : const Coin coin{out, block.height, is_coinbase};
365 : :
366 [ + + ]: 331 : if (!coin.out.scriptPubKey.IsUnspendable()) {
367 [ + - ]: 168 : RemoveCoinHash(m_muhash, outpoint, coin);
368 : : }
369 : 331 : }
370 : :
371 : : // The coinbase tx has no undo data since no former output is spent
372 [ + + ]: 167 : if (!is_coinbase) {
373 : 4 : const auto& tx_undo{block.undo_data->vtxundo.at(i - 1)};
374 : :
375 [ - + + + ]: 8 : for (size_t j = 0; j < tx_undo.vprevout.size(); ++j) {
376 : 4 : const Coin& coin{tx_undo.vprevout[j]};
377 : 4 : const COutPoint outpoint{tx->vin[j].prevout.hash, tx->vin[j].prevout.n};
378 : 4 : ApplyCoinHash(m_muhash, outpoint, coin);
379 : : }
380 : : }
381 : : }
382 : :
383 : : // Check that the rolled back muhash is consistent with the DB read out
384 : 163 : uint256 out;
385 : 163 : m_muhash.Finalize(out);
386 [ - + ]: 163 : Assert(read_out.second.muhash == out);
387 : :
388 : : // Apply the other values from the DB to the member variables
389 : 163 : m_transaction_output_count = read_out.second.transaction_output_count;
390 : 163 : m_total_amount = read_out.second.total_amount;
391 : 163 : m_bogo_size = read_out.second.bogo_size;
392 : 163 : m_total_subsidy = read_out.second.total_subsidy;
393 : 163 : m_total_prevout_spent_amount = read_out.second.total_prevout_spent_amount;
394 : 163 : m_total_new_outputs_ex_coinbase_amount = read_out.second.total_new_outputs_ex_coinbase_amount;
395 : 163 : m_total_coinbase_amount = read_out.second.total_coinbase_amount;
396 : 163 : m_total_unspendables_genesis_block = read_out.second.total_unspendables_genesis_block;
397 : 163 : m_total_unspendables_bip30 = read_out.second.total_unspendables_bip30;
398 : 163 : m_total_unspendables_scripts = read_out.second.total_unspendables_scripts;
399 : 163 : m_total_unspendables_unclaimed_rewards = read_out.second.total_unspendables_unclaimed_rewards;
400 : 163 : m_current_block_hash = *block.prev_hash;
401 : :
402 : 163 : return true;
403 : : }
|
