mirror of
https://github.com/ElementsProject/elements.git
synced 2026-08-19 13:27:35 +02:00
Merge ecab855838 into merged_master (Bitcoin PR bitcoin/bitcoin#28195)
This commit is contained in:
Byron Hambly
commit
bef3aeb383
15 changed files with 252 additions and 265 deletions
210
src/txdb.cpp
210
src/txdb.cpp
|
|
@ -5,58 +5,31 @@
|
|||
|
||||
#include <txdb.h>
|
||||
|
||||
#include <chain.h>
|
||||
#include <coins.h>
|
||||
#include <dbwrapper.h>
|
||||
#include <logging.h>
|
||||
#include <pow.h>
|
||||
#include <primitives/transaction.h>
|
||||
#include <random.h>
|
||||
#include <serialize.h>
|
||||
#include <uint256.h>
|
||||
#include <util/signalinterrupt.h>
|
||||
#include <util/translation.h>
|
||||
#include <util/vector.h>
|
||||
|
||||
#include <stdint.h>
|
||||
#include <cassert>
|
||||
#include <cstdlib>
|
||||
#include <iterator>
|
||||
#include <utility>
|
||||
|
||||
// ELEMENTS
|
||||
#include <block_proof.h> // CheckProof
|
||||
#include <chainparams.h> // Params()
|
||||
|
||||
static constexpr uint8_t DB_COIN{'C'};
|
||||
static constexpr uint8_t DB_BLOCK_FILES{'f'};
|
||||
static constexpr uint8_t DB_BLOCK_INDEX{'b'};
|
||||
|
||||
static constexpr uint8_t DB_BEST_BLOCK{'B'};
|
||||
static constexpr uint8_t DB_HEAD_BLOCKS{'H'};
|
||||
static constexpr uint8_t DB_FLAG{'F'};
|
||||
static constexpr uint8_t DB_REINDEX_FLAG{'R'};
|
||||
static constexpr uint8_t DB_LAST_BLOCK{'l'};
|
||||
|
||||
// ELEMENTS:
|
||||
static constexpr uint8_t DB_PEGIN_FLAG{'w'};
|
||||
// static constexpr uint8_t DB_INVALID_BLOCK_Q{'q'}; // No longer used, but avoid reuse.
|
||||
static constexpr uint8_t DB_PAK{'p'};
|
||||
|
||||
// Keys used in previous version that might still be found in the DB:
|
||||
static constexpr uint8_t DB_COINS{'c'};
|
||||
static constexpr uint8_t DB_TXINDEX_BLOCK{'T'};
|
||||
// uint8_t DB_TXINDEX{'t'}
|
||||
|
||||
util::Result<void> CheckLegacyTxindex(CBlockTreeDB& block_tree_db)
|
||||
{
|
||||
CBlockLocator ignored{};
|
||||
if (block_tree_db.Read(DB_TXINDEX_BLOCK, ignored)) {
|
||||
return util::Error{_("The -txindex upgrade started by a previous version cannot be completed. Restart with the previous version or run a full -reindex.")};
|
||||
}
|
||||
bool txindex_legacy_flag{false};
|
||||
block_tree_db.ReadFlag("txindex", txindex_legacy_flag);
|
||||
if (txindex_legacy_flag) {
|
||||
// Disable legacy txindex and warn once about occupied disk space
|
||||
if (!block_tree_db.WriteFlag("txindex", false)) {
|
||||
return util::Error{Untranslated("Failed to write block index db flag 'txindex'='0'")};
|
||||
}
|
||||
return util::Error{_("The block index db contains a legacy 'txindex'. To clear the occupied disk space, run a full -reindex, otherwise ignore this error. This error message will not be displayed again.")};
|
||||
}
|
||||
return {};
|
||||
}
|
||||
// ELEMENTS
|
||||
static constexpr uint8_t DB_PEGIN_FLAG{'w'};
|
||||
|
||||
bool CCoinsViewDB::NeedsUpgrade()
|
||||
{
|
||||
|
|
@ -205,25 +178,6 @@ size_t CCoinsViewDB::EstimateSize() const
|
|||
return m_db->EstimateSize(DB_COIN, uint8_t(DB_COIN + 1));
|
||||
}
|
||||
|
||||
bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) {
|
||||
return Read(std::make_pair(DB_BLOCK_FILES, nFile), info);
|
||||
}
|
||||
|
||||
bool CBlockTreeDB::WriteReindexing(bool fReindexing) {
|
||||
if (fReindexing)
|
||||
return Write(DB_REINDEX_FLAG, uint8_t{'1'});
|
||||
else
|
||||
return Erase(DB_REINDEX_FLAG);
|
||||
}
|
||||
|
||||
void CBlockTreeDB::ReadReindexing(bool &fReindexing) {
|
||||
fReindexing = Exists(DB_REINDEX_FLAG);
|
||||
}
|
||||
|
||||
bool CBlockTreeDB::ReadLastBlockFile(int &nFile) {
|
||||
return Read(DB_LAST_BLOCK, nFile);
|
||||
}
|
||||
|
||||
/** Specialization of CCoinsViewCursor to iterate over a CCoinsViewDB */
|
||||
class CCoinsViewDBCursor: public CCoinsViewCursor
|
||||
{
|
||||
|
|
@ -296,147 +250,3 @@ void CCoinsViewDBCursor::Next()
|
|||
keyTmp.first = entry.key;
|
||||
}
|
||||
}
|
||||
|
||||
bool CBlockTreeDB::WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*> >& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo) {
|
||||
CDBBatch batch(*this);
|
||||
for (std::vector<std::pair<int, const CBlockFileInfo*> >::const_iterator it=fileInfo.begin(); it != fileInfo.end(); it++) {
|
||||
batch.Write(std::make_pair(DB_BLOCK_FILES, it->first), *it->second);
|
||||
}
|
||||
batch.Write(DB_LAST_BLOCK, nLastFile);
|
||||
for (std::vector<const CBlockIndex*>::const_iterator it=blockinfo.begin(); it != blockinfo.end(); it++) {
|
||||
batch.Write(std::make_pair(DB_BLOCK_INDEX, (*it)->GetBlockHash()), CDiskBlockIndex(*it));
|
||||
}
|
||||
return WriteBatch(batch, true);
|
||||
}
|
||||
|
||||
bool CBlockTreeDB::WriteFlag(const std::string &name, bool fValue) {
|
||||
return Write(std::make_pair(DB_FLAG, name), fValue ? uint8_t{'1'} : uint8_t{'0'});
|
||||
}
|
||||
|
||||
bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) {
|
||||
uint8_t ch;
|
||||
if (!Read(std::make_pair(DB_FLAG, name), ch))
|
||||
return false;
|
||||
fValue = ch == uint8_t{'1'};
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CBlockTreeDB::ReadPAKList(std::vector<std::vector<unsigned char> >& offline_list, std::vector<std::vector<unsigned char> >& online_list, bool& reject)
|
||||
{
|
||||
return Read(std::make_pair(DB_PAK, uint256S("1")), offline_list) && Read(std::make_pair(DB_PAK, uint256S("2")), online_list) && Read(std::make_pair(DB_PAK, uint256S("3")), reject);
|
||||
}
|
||||
|
||||
bool CBlockTreeDB::WritePAKList(const std::vector<std::vector<unsigned char> >& offline_list, const std::vector<std::vector<unsigned char> >& online_list, bool reject)
|
||||
{
|
||||
return Write(std::make_pair(DB_PAK, uint256S("1")), offline_list) && Write(std::make_pair(DB_PAK, uint256S("2")), online_list) && Write(std::make_pair(DB_PAK, uint256S("3")), reject);
|
||||
}
|
||||
|
||||
const CBlockIndex *CBlockTreeDB::RegenerateFullIndex(const CBlockIndex *pindexTrimmed, CBlockIndex *pindexNew) const
|
||||
{
|
||||
LOCK(cs_main);
|
||||
|
||||
if(!pindexTrimmed->trimmed()) {
|
||||
return pindexTrimmed;
|
||||
}
|
||||
CBlockHeader tmp;
|
||||
bool BlockRead = false;
|
||||
{
|
||||
// In unpruned nodes, same data could be read from blocks using ReadBlockFromDisk, but that turned out to
|
||||
// be about 6x slower than reading from the index
|
||||
std::pair<uint8_t, uint256> key(DB_BLOCK_INDEX, pindexTrimmed->GetBlockHash());
|
||||
CDiskBlockIndex diskindex;
|
||||
BlockRead = this->Read(key, diskindex);
|
||||
tmp = diskindex.GetBlockHeader();
|
||||
}
|
||||
assert(BlockRead);
|
||||
// Clone the needed data from the original trimmed block
|
||||
pindexNew->pprev = pindexTrimmed->pprev;
|
||||
pindexNew->phashBlock = pindexTrimmed->phashBlock;
|
||||
// Construct block index object
|
||||
pindexNew->nHeight = pindexTrimmed->nHeight;
|
||||
pindexNew->nFile = pindexTrimmed->nFile;
|
||||
pindexNew->nDataPos = pindexTrimmed->nDataPos;
|
||||
pindexNew->nUndoPos = pindexTrimmed->nUndoPos;
|
||||
pindexNew->nVersion = pindexTrimmed->nVersion;
|
||||
pindexNew->hashMerkleRoot = pindexTrimmed->hashMerkleRoot;
|
||||
pindexNew->nTime = pindexTrimmed->nTime;
|
||||
pindexNew->nBits = pindexTrimmed->nBits;
|
||||
pindexNew->nNonce = pindexTrimmed->nNonce;
|
||||
pindexNew->nStatus = pindexTrimmed->nStatus;
|
||||
pindexNew->nTx = pindexTrimmed->nTx;
|
||||
|
||||
pindexNew->proof = tmp.proof;
|
||||
pindexNew->m_dynafed_params = tmp.m_dynafed_params;
|
||||
pindexNew->m_signblock_witness = tmp.m_signblock_witness;
|
||||
|
||||
if (pindexTrimmed->nHeight && pindexTrimmed->nHeight % 1000 == 0) {
|
||||
assert(CheckProof(pindexNew->GetBlockHeader(), Params().GetConsensus()));
|
||||
}
|
||||
return pindexNew;
|
||||
}
|
||||
|
||||
bool CBlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams, std::function<CBlockIndex*(const uint256&)> insertBlockIndex, const util::SignalInterrupt& interrupt, int trimBelowHeight)
|
||||
{
|
||||
AssertLockHeld(::cs_main);
|
||||
std::unique_ptr<CDBIterator> pcursor(NewIterator());
|
||||
pcursor->Seek(std::make_pair(DB_BLOCK_INDEX, uint256()));
|
||||
|
||||
int n_untrimmed = 0;
|
||||
int n_total = 0;
|
||||
|
||||
// Load m_block_index
|
||||
while (pcursor->Valid()) {
|
||||
if (interrupt) return false;
|
||||
std::pair<uint8_t, uint256> key;
|
||||
if (pcursor->GetKey(key) && key.first == DB_BLOCK_INDEX) {
|
||||
CDiskBlockIndex diskindex;
|
||||
if (pcursor->GetValue(diskindex)) {
|
||||
// Construct block index object
|
||||
CBlockIndex* pindexNew = insertBlockIndex(diskindex.ConstructBlockHash());
|
||||
pindexNew->pprev = insertBlockIndex(diskindex.hashPrev);
|
||||
pindexNew->nHeight = diskindex.nHeight;
|
||||
pindexNew->nFile = diskindex.nFile;
|
||||
pindexNew->nDataPos = diskindex.nDataPos;
|
||||
pindexNew->nUndoPos = diskindex.nUndoPos;
|
||||
pindexNew->nVersion = diskindex.nVersion;
|
||||
pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
|
||||
pindexNew->nTime = diskindex.nTime;
|
||||
pindexNew->nBits = diskindex.nBits;
|
||||
pindexNew->nNonce = diskindex.nNonce;
|
||||
pindexNew->nStatus = diskindex.nStatus;
|
||||
pindexNew->nTx = diskindex.nTx;
|
||||
|
||||
pindexNew->proof = diskindex.proof;
|
||||
pindexNew->m_dynafed_params = diskindex.m_dynafed_params;
|
||||
pindexNew->m_signblock_witness = diskindex.m_signblock_witness;
|
||||
|
||||
assert(!(g_signed_blocks && diskindex.m_dynafed_params.value().IsNull() && diskindex.proof.value().IsNull()));
|
||||
|
||||
pindexNew->set_stored();
|
||||
n_total++;
|
||||
|
||||
const uint256 block_hash = pindexNew->GetBlockHash();
|
||||
// Only validate one of every 1000 block header for sanity check
|
||||
if (pindexNew->nHeight % 1000 == 0 &&
|
||||
block_hash != consensusParams.hashGenesisBlock &&
|
||||
!CheckProof(pindexNew->GetBlockHeader(), consensusParams)) {
|
||||
return error("%s: CheckProof: %s, %s", __func__, block_hash.ToString(), pindexNew->ToString());
|
||||
}
|
||||
if (diskindex.nHeight >= trimBelowHeight) {
|
||||
n_untrimmed++;
|
||||
} else {
|
||||
pindexNew->trim();
|
||||
}
|
||||
|
||||
pcursor->Next();
|
||||
} else {
|
||||
return error("%s: failed to read value", __func__);
|
||||
}
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
LogPrintf("LoadBlockIndexGuts: loaded %d total / %d untrimmed (fully in-memory) headers\n", n_total, n_untrimmed);
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue