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
37using kernel::ApplyCoinHash;
38using kernel::CCoinsStats;
39using kernel::GetBogoSize;
40using kernel::RemoveCoinHash;
41
42static constexpr uint8_t DB_MUHASH{'M'};
43
44namespace {
45
46struct 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    SERIALIZE_METHODS(DBVal, obj)
61    {
62        uint256 prevout_spent, new_outputs, coinbase;
63        SER_WRITE(obj, prevout_spent = ArithToUint256(obj.total_prevout_spent_amount));
64        SER_WRITE(obj, new_outputs = ArithToUint256(obj.total_new_outputs_ex_coinbase_amount));
65        SER_WRITE(obj, coinbase = ArithToUint256(obj.total_coinbase_amount));
66
67        READWRITE(obj.muhash);
68        READWRITE(obj.transaction_output_count);
69        READWRITE(obj.bogo_size);
70        READWRITE(obj.total_amount);
71        READWRITE(obj.total_subsidy);
72        READWRITE(prevout_spent);
73        READWRITE(new_outputs);
74        READWRITE(coinbase);
75        READWRITE(obj.total_unspendables_genesis_block);
76        READWRITE(obj.total_unspendables_bip30);
77        READWRITE(obj.total_unspendables_scripts);
78        READWRITE(obj.total_unspendables_unclaimed_rewards);
79
80        SER_READ(obj, obj.total_prevout_spent_amount = UintToArith256(prevout_spent));
81        SER_READ(obj, obj.total_new_outputs_ex_coinbase_amount = UintToArith256(new_outputs));
82        SER_READ(obj, obj.total_coinbase_amount = UintToArith256(coinbase));
83    }
84};
85}; // namespace
86
87std::unique_ptr<CoinStatsIndex> g_coin_stats_index;
88
89CoinStatsIndex::CoinStatsIndex(std::unique_ptr<interfaces::Chain> chain, size_t n_cache_size, bool f_memory, bool f_wipe)
90    : BaseIndex(std::move(chain), "coinstatsindex", "coinstatsidx")
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    auto old_path = gArgs.GetDataDirNet() / "indexes" / "coinstats";
97    if (fs::exists(old_path)) {
98        // TODO: Change this to deleting the old index with v31.
99        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    fs::path path{gArgs.GetDataDirNet() / "indexes" / "coinstatsindex"};
103    fs::create_directories(path);
104
105    m_db = std::make_unique<CoinStatsIndex::DB>(path / "db", n_cache_size, f_memory, f_wipe);
106}
107
108bool CoinStatsIndex::CustomAppend(const interfaces::BlockInfo& block)
109{
110    const CAmount block_subsidy{GetBlockSubsidy(block.height, Params().GetConsensus())};
111    m_total_subsidy += block_subsidy;
112
113    // Ignore genesis block
114    if (block.height > 0) {
115        uint256 expected_block_hash{*Assert(block.prev_hash)};
116        if (m_current_block_hash != expected_block_hash) {
117            LogError("previous block header belongs to unexpected block %s; expected %s",
118                      m_current_block_hash.ToString(), expected_block_hash.ToString());
119            return false;
120        }
121
122        // Add the new utxos created from the block
123        assert(block.data);
124        for (size_t i = 0; i < block.data->vtx.size(); ++i) {
125            const auto& tx{block.data->vtx.at(i)};
126            const bool is_coinbase{tx->IsCoinBase()};
127
128            // Skip duplicate txid coinbase transactions (BIP30).
129            if (is_coinbase && IsBIP30Unspendable(block.hash, block.height)) {
130                m_total_unspendables_bip30 += block_subsidy;
131                continue;
132            }
133
134            for (uint32_t j = 0; j < tx->vout.size(); ++j) {
135                const CTxOut& out{tx->vout[j]};
136                const Coin coin{out, block.height, is_coinbase};
137                const COutPoint outpoint{tx->GetHash(), j};
138
139                // Skip unspendable coins
140                if (coin.out.scriptPubKey.IsUnspendable()) {
141                    m_total_unspendables_scripts += coin.out.nValue;
142                    continue;
143                }
144
145                ApplyCoinHash(m_muhash, outpoint, coin);
146
147                if (is_coinbase) {
148                    m_total_coinbase_amount += coin.out.nValue;
149                } else {
150                    m_total_new_outputs_ex_coinbase_amount += coin.out.nValue;
151                }
152
153                ++m_transaction_output_count;
154                m_total_amount += coin.out.nValue;
155                m_bogo_size += GetBogoSize(coin.out.scriptPubKey);
156            }
157
158            // The coinbase tx has no undo data since no former output is spent
159            if (!is_coinbase) {
160                const auto& tx_undo{Assert(block.undo_data)->vtxundo.at(i - 1)};
161
162                for (size_t j = 0; j < tx_undo.vprevout.size(); ++j) {
163                    const Coin& coin{tx_undo.vprevout[j]};
164                    const COutPoint outpoint{tx->vin[j].prevout.hash, tx->vin[j].prevout.n};
165
166                    RemoveCoinHash(m_muhash, outpoint, coin);
167
168                    m_total_prevout_spent_amount += coin.out.nValue;
169
170                    --m_transaction_output_count;
171                    m_total_amount -= coin.out.nValue;
172                    m_bogo_size -= GetBogoSize(coin.out.scriptPubKey);
173                }
174            }
175        }
176    } else {
177        // genesis block
178        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    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    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    assert(unclaimed_rewards <= arith_uint256(std::numeric_limits<CAmount>::max()));
188    m_total_unspendables_unclaimed_rewards += static_cast<CAmount>(unclaimed_rewards.GetLow64());
189
190    std::pair<uint256, DBVal> value;
191    value.first = block.hash;
192    value.second.transaction_output_count = m_transaction_output_count;
193    value.second.bogo_size = m_bogo_size;
194    value.second.total_amount = m_total_amount;
195    value.second.total_subsidy = m_total_subsidy;
196    value.second.total_prevout_spent_amount = m_total_prevout_spent_amount;
197    value.second.total_new_outputs_ex_coinbase_amount = m_total_new_outputs_ex_coinbase_amount;
198    value.second.total_coinbase_amount = m_total_coinbase_amount;
199    value.second.total_unspendables_genesis_block = m_total_unspendables_genesis_block;
200    value.second.total_unspendables_bip30 = m_total_unspendables_bip30;
201    value.second.total_unspendables_scripts = m_total_unspendables_scripts;
202    value.second.total_unspendables_unclaimed_rewards = m_total_unspendables_unclaimed_rewards;
203
204    uint256 out;
205    m_muhash.Finalize(out);
206    value.second.muhash = out;
207
208    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    m_db->Write(index_util::DBHeightKey(block.height), value);
213    return true;
214}
215
216bool CoinStatsIndex::CustomRemove(const interfaces::BlockInfo& block)
217{
218    CDBBatch batch(*m_db);
219    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    if (!index_util::CopyHeightIndexToHashIndex<DBVal>(*db_it, batch, m_name, block.height)) {
224        return false;
225    }
226
227    m_db->WriteBatch(batch);
228
229    if (!RevertBlock(block)) {
230        return false; // failure cause logged internally
231    }
232
233    return true;
234}
235
236std::optional<CCoinsStats> CoinStatsIndex::LookUpStats(const CBlockIndex& block_index) const
237{
238    CCoinsStats stats{block_index.nHeight, block_index.GetBlockHash()};
239    stats.index_used = true;
240
241    DBVal entry;
242    if (!index_util::LookUpOne(*m_db, {block_index.GetBlockHash(), block_index.nHeight}, entry)) {
243        return std::nullopt;
244    }
245
246    stats.hashSerialized = entry.muhash;
247    stats.nTransactionOutputs = entry.transaction_output_count;
248    stats.nBogoSize = entry.bogo_size;
249    stats.total_amount = entry.total_amount;
250    stats.total_subsidy = entry.total_subsidy;