1// Copyright (c) 2011-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 <node/blockstorage.h>
6
7#include <arith_uint256.h>
8#include <chain.h>
9#include <consensus/params.h>
10#include <crypto/hex_base.h>
11#include <dbwrapper.h>
12#include <flatfile.h>
13#include <hash.h>
14#include <kernel/blockmanager_opts.h>
15#include <kernel/chainparams.h>
16#include <kernel/messagestartchars.h>
17#include <kernel/notifications_interface.h>
18#include <kernel/types.h>
19#include <pow.h>
20#include <primitives/block.h>
21#include <primitives/transaction.h>
22#include <random.h>
23#include <serialize.h>
24#include <signet.h>
25#include <streams.h>
26#include <sync.h>
27#include <tinyformat.h>
28#include <uint256.h>
29#include <undo.h>
30#include <util/check.h>
31#include <util/expected.h>
32#include <util/fs.h>
33#include <util/log.h>
34#include <util/obfuscation.h>
35#include <util/overflow.h>
36#include <util/result.h>
37#include <util/signalinterrupt.h>
38#include <util/strencodings.h>
39#include <util/syserror.h>
40#include <util/time.h>
41#include <util/translation.h>
42#include <validation.h>
43
44#include <cerrno>
45#include <compare>
46#include <cstddef>
47#include <cstdio>
48#include <exception>
49#include <map>
50#include <optional>
51#include <ostream>
52#include <span>
53#include <stdexcept>
54#include <system_error>
55#include <unordered_map>
56
57namespace kernel {
58static constexpr uint8_t DB_BLOCK_FILES{'f'};
59static constexpr uint8_t DB_BLOCK_INDEX{'b'};
60static constexpr uint8_t DB_FLAG{'F'};
61static constexpr uint8_t DB_REINDEX_FLAG{'R'};
62static constexpr uint8_t DB_LAST_BLOCK{'l'};
63// Keys used in previous version that might still be found in the DB:
64// BlockTreeDB::DB_TXINDEX_BLOCK{'T'};
65// BlockTreeDB::DB_TXINDEX{'t'}
66// BlockTreeDB::ReadFlag("txindex")
67
68bool BlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo& info)
69{
70    return Read(std::make_pair(DB_BLOCK_FILES, nFile), info);
71}
72
73void BlockTreeDB::WriteReindexing(bool fReindexing)
74{
75    if (fReindexing) {
76        Write(DB_REINDEX_FLAG, uint8_t{'1'});
77    } else {
78        Erase(DB_REINDEX_FLAG);
79    }
80}
81
82void BlockTreeDB::ReadReindexing(bool& fReindexing)
83{
84    fReindexing = Exists(DB_REINDEX_FLAG);
85}
86
87bool BlockTreeDB::ReadLastBlockFile(int& nFile)
88{
89    return Read(DB_LAST_BLOCK, nFile);
90}
91
92void BlockTreeDB::WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*>>& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo)
93{
94    CDBBatch batch(*this);
95    for (const auto& [file, info] : fileInfo) {
96        batch.Write(std::make_pair(DB_BLOCK_FILES, file), *info);
97    }
98    batch.Write(DB_LAST_BLOCK, nLastFile);
99    for (const CBlockIndex* bi : blockinfo) {
100        batch.Write(std::make_pair(DB_BLOCK_INDEX, bi->GetBlockHash()), CDiskBlockIndex{bi});
101    }
102    WriteBatch(batch, true);
103}
104
105void BlockTreeDB::WriteFlag(const std::string& name, bool fValue)
106{
107    Write(std::make_pair(DB_FLAG, name), fValue ? uint8_t{'1'} : uint8_t{'0'});
108}
109
110bool BlockTreeDB::ReadFlag(const std::string& name, bool& fValue)
111{
112    uint8_t ch;
113    if (!Read(std::make_pair(DB_FLAG, name), ch)) {
114        return false;
115    }
116    fValue = ch == uint8_t{'1'};
117    return true;
118}
119
120bool BlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams, std::function<CBlockIndex*(const uint256&)> insertBlockIndex, const util::SignalInterrupt& interrupt)
121{
122    AssertLockHeld(::cs_main);
123    std::unique_ptr<CDBIterator> pcursor(NewIterator());
124    pcursor->Seek(std::make_pair(DB_BLOCK_INDEX, uint256()));
125
126    // Load m_block_index
127    while (pcursor->Valid()) {
128        if (interrupt) return false;
129        std::pair<uint8_t, uint256> key;
130        if (pcursor->GetKey(key) && key.first == DB_BLOCK_INDEX) {
131            CDiskBlockIndex diskindex;
132            if (pcursor->GetValue(diskindex)) {
133                // Construct block index object
134                CBlockIndex* pindexNew = insertBlockIndex(diskindex.ConstructBlockHash());
135                pindexNew->pprev          = insertBlockIndex(diskindex.hashPrev);
136                pindexNew->nHeight        = diskindex.nHeight;
137                pindexNew->nFile          = diskindex.nFile;
138                pindexNew->nDataPos       = diskindex.nDataPos;
139                pindexNew->nUndoPos       = diskindex.nUndoPos;
140                pindexNew->nVersion       = diskindex.nVersion;
141                pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
142                pindexNew->nTime          = diskindex.nTime;
143                pindexNew->nBits          = diskindex.nBits;
144                pindexNew->nNonce         = diskindex.nNonce;
145                pindexNew->nStatus        = diskindex.nStatus;
146                pindexNew->nTx            = diskindex.nTx;
147
148                if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, consensusParams)) {
149                    LogError("%s: CheckProofOfWork failed: %s\n", __func__, pindexNew->ToString());
150                    return false;
151                }
152
153                pcursor->Next();
154            } else {
155                LogError("%s: failed to read value\n", __func__);
156                return false;
157            }
158        } else {
159            break;
160        }
161    }
162
163    return true;
164}
165
166std::string CBlockFileInfo::ToString() const
167{
168    return strprintf("CBlockFileInfo(blocks=%u, size=%u, heights=%u...%u, time=%s...%s)", nBlocks, nSize, nHeightFirst, nHeightLast, FormatISO8601Date(nTimeFirst), FormatISO8601Date(nTimeLast));
169}
170} // namespace kernel
171
172namespace node {
173
174bool CBlockIndexWorkComparator::operator()(const CBlockIndex* pa, const CBlockIndex* pb) const
175{
176    // First sort by most total work, ...
177    if (pa->nChainWork > pb->nChainWork) return false;
178    if (pa->nChainWork < pb->nChainWork) return true;
179
180    // ... then by earliest activatable time, ...
181    if (pa->nSequenceId < pb->nSequenceId) return false;
182    if (pa->nSequenceId > pb->nSequenceId) return true;
183
184    // Use pointer address as tie breaker (should only happen with blocks
185    // loaded from disk, as those share the same id: 0 for blocks on the
186    // best chain, 1 for all others).
187    if (pa < pb) return false;
188    if (pa > pb) return true;
189
190    // Identical blocks.
191    return false;
192}
193
194bool CBlockIndexHeightOnlyComparator::operator()(const CBlockIndex* pa, const CBlockIndex* pb) const
195{
196    return pa->nHeight < pb->nHeight;
197}
198
199std::vector<CBlockIndex*> BlockManager::GetAllBlockIndices()
200{
201    AssertLockHeld(cs_main);
202    std::vector<CBlockIndex*> rv;
203    rv.reserve(m_block_index.size());
204    for (auto& [_, block_index] : m_block_index) {
205        rv.push_back(&block_index);
206    }
207    return rv;
208}
209
210CBlockIndex* BlockManager::LookupBlockIndex(const uint256& hash)
211{
212    AssertLockHeld(cs_main);
213    BlockMap::iterator it = m_block_index.find(hash);
214    return it == m_block_index.end() ? nullptr : &it->second;
215}
216
217const CBlockIndex* BlockManager::LookupBlockIndex(const uint256& hash) const
218{
219    AssertLockHeld(cs_main);
220    BlockMap::const_iterator it = m_block_index.find(hash);
221    return it == m_block_index.end() ? nullptr : &it->second;
222}
223
224CBlockIndex* BlockManager::AddToBlockIndex(const CBlockHeader& block, CBlockIndex*& best_header)
225{
226    AssertLockHeld(cs_main);
227
228    auto [mi, inserted] = m_block_index.try_emplace(block.GetHash(), block);
229    if (!inserted) {
230        return &mi->second;
231    }
232    CBlockIndex* pindexNew = &(*mi).second;
233
234    // We assign the sequence id to blocks only when the full data is available,
235    // to avoid miners withholding blocks but broadcasting headers, to get a
236    // competitive advantage.
237    pindexNew->nSequenceId = SEQ_ID_INIT_FROM_DISK;
238
239    pindexNew->phashBlock = &((*mi).first);
240    BlockMap::iterator miPrev = m_block_index.find(block.hashPrevBlock);
241    if (miPrev != m_block_index.end()) {
242        pindexNew->pprev = &(*miPrev).second;
243        pindexNew->nHeight = pindexNew->pprev->nHeight + 1;
244        pindexNew->BuildSkip();
245    }
246    pindexNew->nTimeMax = (pindexNew->pprev ? std::max(pindexNew->pprev->nTimeMax, pindexNew->nTime) : pindexNew->nTime);
247    pindexNew->nChainWork = (pindexNew->pprev ? pindexNew->pprev->nChainWork : 0) + GetBlockProof(*pindexNew);
248    pindexNew->RaiseValidity(BLOCK_VALID_TREE);
249    if (best_header == nullptr || best_header->nChainWork < pindexNew->nChainWork) {
250        best_header = pindexNew;