Updating UTXO statistics and reversing them on reorganization

251    stats.total_prevout_spent_amount = entry.total_prevout_spent_amount;
252    stats.total_new_outputs_ex_coinbase_amount = entry.total_new_outputs_ex_coinbase_amount;
253    stats.total_coinbase_amount = entry.total_coinbase_amount;
254    stats.total_unspendables_genesis_block = entry.total_unspendables_genesis_block;
255    stats.total_unspendables_bip30 = entry.total_unspendables_bip30;
256    stats.total_unspendables_scripts = entry.total_unspendables_scripts;
257    stats.total_unspendables_unclaimed_rewards = entry.total_unspendables_unclaimed_rewards;
258
259    return stats;
260}
261
262bool CoinStatsIndex::CustomInit(const std::optional<interfaces::BlockRef>& block)
263{
264    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        if (m_db->Exists(DB_MUHASH)) {
269            LogError("Cannot read current %s state; index may be corrupted",
270                      GetName());
271            return false;
272        }
273    }
274
275    if (block) {
276        DBVal entry;
277        if (!index_util::LookUpOne(*m_db, *block, entry)) {
278            LogError("Cannot read current %s state; index may be corrupted",
279                      GetName());
280            return false;
281        }
282
283        uint256 out;
284        m_muhash.Finalize(out);
285        if (entry.muhash != out) {
286            LogError("Cannot read current %s state; index may be corrupted",
287                      GetName());
288            return false;
289        }
290
291        m_transaction_output_count = entry.transaction_output_count;
292        m_bogo_size = entry.bogo_size;
293        m_total_amount = entry.total_amount;
294        m_total_subsidy = entry.total_subsidy;
295        m_total_prevout_spent_amount = entry.total_prevout_spent_amount;
296        m_total_new_outputs_ex_coinbase_amount = entry.total_new_outputs_ex_coinbase_amount;
297        m_total_coinbase_amount = entry.total_coinbase_amount;
298        m_total_unspendables_genesis_block = entry.total_unspendables_genesis_block;
299        m_total_unspendables_bip30 = entry.total_unspendables_bip30;
300        m_total_unspendables_scripts = entry.total_unspendables_scripts;
301        m_total_unspendables_unclaimed_rewards = entry.total_unspendables_unclaimed_rewards;
302        m_current_block_hash = block->hash;
303    }
304
305    return true;
306}
307
308bool 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    batch.Write(DB_MUHASH, m_muhash);
313    return true;
314}
315
316interfaces::Chain::NotifyOptions CoinStatsIndex::CustomOptions()
317{
318    interfaces::Chain::NotifyOptions options;
319    options.connect_undo_data = true;
320    options.disconnect_data = true;
321    options.disconnect_undo_data = true;
322    return options;
323}
324
325// Revert a single block as part of a reorg
326bool CoinStatsIndex::RevertBlock(const interfaces::BlockInfo& block)
327{
328    std::pair<uint256, DBVal> read_out;
329
330    // Ignore genesis block
331    if (block.height > 0) {
332        if (!m_db->Read(index_util::DBHeightKey(block.height - 1), read_out)) {
333            return false;
334        }
335
336        uint256 expected_block_hash{*block.prev_hash};
337        if (read_out.first != expected_block_hash) {
338            LogWarning("previous block header belongs to unexpected block %s; expected %s",
339                      read_out.first.ToString(), expected_block_hash.ToString());
340
341            if (!m_db->Read(index_util::DBHashKey(expected_block_hash), read_out)) {
342                LogError("previous block header not found; expected %s",
343                          expected_block_hash.ToString());
344                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    assert(block.data);
352    assert(block.undo_data);
353    for (size_t i = 0; i < block.data->vtx.size(); ++i) {
354        const auto& tx{block.data->vtx.at(i)};
355        const bool is_coinbase{tx->IsCoinBase()};
356
357        if (is_coinbase && IsBIP30Unspendable(block.hash, block.height)) {
358            continue;
359        }
360
361        for (uint32_t j = 0; j < tx->vout.size(); ++j) {
362            const CTxOut& out{tx->vout[j]};
363            const COutPoint outpoint{tx->GetHash(), j};
364            const Coin coin{out, block.height, is_coinbase};
365
366            if (!coin.out.scriptPubKey.IsUnspendable()) {
367                RemoveCoinHash(m_muhash, outpoint, coin);
368            }
369        }
370
371        // The coinbase tx has no undo data since no former output is spent
372        if (!is_coinbase) {
373            const auto& tx_undo{block.undo_data->vtxundo.at(i - 1)};
374
375            for (size_t j = 0; j < tx_undo.vprevout.size(); ++j) {
376                const Coin& coin{tx_undo.vprevout[j]};
377                const COutPoint outpoint{tx->vin[j].prevout.hash, tx->vin[j].prevout.n};
378                ApplyCoinHash(m_muhash, outpoint, coin);
379            }
380        }
381    }
382
383    // Check that the rolled back muhash is consistent with the DB read out
384    uint256 out;
385    m_muhash.Finalize(out);
386    Assert(read_out.second.muhash == out);
387
388    // Apply the other values from the DB to the member variables
389    m_transaction_output_count = read_out.second.transaction_output_count;
390    m_total_amount = read_out.second.total_amount;
391    m_bogo_size = read_out.second.bogo_size;
392    m_total_subsidy = read_out.second.total_subsidy;
393    m_total_prevout_spent_amount = read_out.second.total_prevout_spent_amount;
394    m_total_new_outputs_ex_coinbase_amount = read_out.second.total_new_outputs_ex_coinbase_amount;
395    m_total_coinbase_amount = read_out.second.total_coinbase_amount;
396    m_total_unspendables_genesis_block = read_out.second.total_unspendables_genesis_block;
397    m_total_unspendables_bip30 = read_out.second.total_unspendables_bip30;
398    m_total_unspendables_scripts = read_out.second.total_unspendables_scripts;
399    m_total_unspendables_unclaimed_rewards = read_out.second.total_unspendables_unclaimed_rewards;
400    m_current_block_hash = *block.prev_hash;
401
402    return true;
403}
404