704b76358d
The Equihash check caused block index loading to take around 38x longer. However, we don't need to check it directly, as the only paths to writing a block header to disk already go through a proof-of-work check (e.g. receiving a block over the network). By forcing the block header inside the CBlockIndex to be re-serialized, we retain the benefits of the consistency check without the overhead at startup. Co-authored-by: Brad Miller <brad@z.cash>
336 lines
12 KiB
C++
336 lines
12 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2014 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include "txdb.h"
|
|
|
|
#include "chainparams.h"
|
|
#include "hash.h"
|
|
#include "main.h"
|
|
#include "pow.h"
|
|
#include "uint256.h"
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <boost/thread.hpp>
|
|
|
|
using namespace std;
|
|
|
|
static const char DB_ANCHOR = 'A';
|
|
static const char DB_NULLIFIER = 's';
|
|
static const char DB_COINS = 'c';
|
|
static const char DB_BLOCK_FILES = 'f';
|
|
static const char DB_TXINDEX = 't';
|
|
static const char DB_BLOCK_INDEX = 'b';
|
|
|
|
static const char DB_BEST_BLOCK = 'B';
|
|
static const char DB_BEST_ANCHOR = 'a';
|
|
static const char DB_FLAG = 'F';
|
|
static const char DB_REINDEX_FLAG = 'R';
|
|
static const char DB_LAST_BLOCK = 'l';
|
|
|
|
|
|
void static BatchWriteAnchor(CLevelDBBatch &batch,
|
|
const uint256 &croot,
|
|
const ZCIncrementalMerkleTree &tree,
|
|
const bool &entered)
|
|
{
|
|
if (!entered)
|
|
batch.Erase(make_pair(DB_ANCHOR, croot));
|
|
else {
|
|
batch.Write(make_pair(DB_ANCHOR, croot), tree);
|
|
}
|
|
}
|
|
|
|
void static BatchWriteNullifier(CLevelDBBatch &batch, const uint256 &nf, const bool &entered) {
|
|
if (!entered)
|
|
batch.Erase(make_pair(DB_NULLIFIER, nf));
|
|
else
|
|
batch.Write(make_pair(DB_NULLIFIER, nf), true);
|
|
}
|
|
|
|
void static BatchWriteCoins(CLevelDBBatch &batch, const uint256 &hash, const CCoins &coins) {
|
|
if (coins.IsPruned())
|
|
batch.Erase(make_pair(DB_COINS, hash));
|
|
else
|
|
batch.Write(make_pair(DB_COINS, hash), coins);
|
|
}
|
|
|
|
void static BatchWriteHashBestChain(CLevelDBBatch &batch, const uint256 &hash) {
|
|
batch.Write(DB_BEST_BLOCK, hash);
|
|
}
|
|
|
|
void static BatchWriteHashBestAnchor(CLevelDBBatch &batch, const uint256 &hash) {
|
|
batch.Write(DB_BEST_ANCHOR, hash);
|
|
}
|
|
|
|
CCoinsViewDB::CCoinsViewDB(std::string dbName, size_t nCacheSize, bool fMemory, bool fWipe) : db(GetDataDir() / dbName, nCacheSize, fMemory, fWipe) {
|
|
}
|
|
|
|
CCoinsViewDB::CCoinsViewDB(size_t nCacheSize, bool fMemory, bool fWipe) : db(GetDataDir() / "chainstate", nCacheSize, fMemory, fWipe) {
|
|
}
|
|
|
|
|
|
bool CCoinsViewDB::GetAnchorAt(const uint256 &rt, ZCIncrementalMerkleTree &tree) const {
|
|
if (rt == ZCIncrementalMerkleTree::empty_root()) {
|
|
ZCIncrementalMerkleTree new_tree;
|
|
tree = new_tree;
|
|
return true;
|
|
}
|
|
|
|
bool read = db.Read(make_pair(DB_ANCHOR, rt), tree);
|
|
|
|
return read;
|
|
}
|
|
|
|
bool CCoinsViewDB::GetNullifier(const uint256 &nf) const {
|
|
bool spent = false;
|
|
bool read = db.Read(make_pair(DB_NULLIFIER, nf), spent);
|
|
|
|
return read;
|
|
}
|
|
|
|
bool CCoinsViewDB::GetCoins(const uint256 &txid, CCoins &coins) const {
|
|
return db.Read(make_pair(DB_COINS, txid), coins);
|
|
}
|
|
|
|
bool CCoinsViewDB::HaveCoins(const uint256 &txid) const {
|
|
return db.Exists(make_pair(DB_COINS, txid));
|
|
}
|
|
|
|
uint256 CCoinsViewDB::GetBestBlock() const {
|
|
uint256 hashBestChain;
|
|
if (!db.Read(DB_BEST_BLOCK, hashBestChain))
|
|
return uint256();
|
|
return hashBestChain;
|
|
}
|
|
|
|
uint256 CCoinsViewDB::GetBestAnchor() const {
|
|
uint256 hashBestAnchor;
|
|
if (!db.Read(DB_BEST_ANCHOR, hashBestAnchor))
|
|
return ZCIncrementalMerkleTree::empty_root();
|
|
return hashBestAnchor;
|
|
}
|
|
|
|
bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins,
|
|
const uint256 &hashBlock,
|
|
const uint256 &hashAnchor,
|
|
CAnchorsMap &mapAnchors,
|
|
CNullifiersMap &mapNullifiers) {
|
|
CLevelDBBatch batch;
|
|
size_t count = 0;
|
|
size_t changed = 0;
|
|
for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
|
|
if (it->second.flags & CCoinsCacheEntry::DIRTY) {
|
|
BatchWriteCoins(batch, it->first, it->second.coins);
|
|
changed++;
|
|
}
|
|
count++;
|
|
CCoinsMap::iterator itOld = it++;
|
|
mapCoins.erase(itOld);
|
|
}
|
|
|
|
for (CAnchorsMap::iterator it = mapAnchors.begin(); it != mapAnchors.end();) {
|
|
if (it->second.flags & CAnchorsCacheEntry::DIRTY) {
|
|
BatchWriteAnchor(batch, it->first, it->second.tree, it->second.entered);
|
|
// TODO: changed++?
|
|
}
|
|
CAnchorsMap::iterator itOld = it++;
|
|
mapAnchors.erase(itOld);
|
|
}
|
|
|
|
for (CNullifiersMap::iterator it = mapNullifiers.begin(); it != mapNullifiers.end();) {
|
|
if (it->second.flags & CNullifiersCacheEntry::DIRTY) {
|
|
BatchWriteNullifier(batch, it->first, it->second.entered);
|
|
// TODO: changed++?
|
|
}
|
|
CNullifiersMap::iterator itOld = it++;
|
|
mapNullifiers.erase(itOld);
|
|
}
|
|
|
|
if (!hashBlock.IsNull())
|
|
BatchWriteHashBestChain(batch, hashBlock);
|
|
if (!hashAnchor.IsNull())
|
|
BatchWriteHashBestAnchor(batch, hashAnchor);
|
|
|
|
LogPrint("coindb", "Committing %u changed transactions (out of %u) to coin database...\n", (unsigned int)changed, (unsigned int)count);
|
|
return db.WriteBatch(batch);
|
|
}
|
|
|
|
CBlockTreeDB::CBlockTreeDB(size_t nCacheSize, bool fMemory, bool fWipe) : CLevelDBWrapper(GetDataDir() / "blocks" / "index", nCacheSize, fMemory, fWipe) {
|
|
}
|
|
|
|
bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) {
|
|
return Read(make_pair(DB_BLOCK_FILES, nFile), info);
|
|
}
|
|
|
|
bool CBlockTreeDB::WriteReindexing(bool fReindexing) {
|
|
if (fReindexing)
|
|
return Write(DB_REINDEX_FLAG, '1');
|
|
else
|
|
return Erase(DB_REINDEX_FLAG);
|
|
}
|
|
|
|
bool CBlockTreeDB::ReadReindexing(bool &fReindexing) {
|
|
fReindexing = Exists(DB_REINDEX_FLAG);
|
|
return true;
|
|
}
|
|
|
|
bool CBlockTreeDB::ReadLastBlockFile(int &nFile) {
|
|
return Read(DB_LAST_BLOCK, nFile);
|
|
}
|
|
|
|
bool CCoinsViewDB::GetStats(CCoinsStats &stats) const {
|
|
/* It seems that there are no "const iterators" for LevelDB. Since we
|
|
only need read operations on it, use a const-cast to get around
|
|
that restriction. */
|
|
boost::scoped_ptr<leveldb::Iterator> pcursor(const_cast<CLevelDBWrapper*>(&db)->NewIterator());
|
|
pcursor->SeekToFirst();
|
|
|
|
CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
|
|
stats.hashBlock = GetBestBlock();
|
|
ss << stats.hashBlock;
|
|
CAmount nTotalAmount = 0;
|
|
while (pcursor->Valid()) {
|
|
boost::this_thread::interruption_point();
|
|
try {
|
|
leveldb::Slice slKey = pcursor->key();
|
|
CDataStream ssKey(slKey.data(), slKey.data()+slKey.size(), SER_DISK, CLIENT_VERSION);
|
|
char chType;
|
|
ssKey >> chType;
|
|
if (chType == DB_COINS) {
|
|
leveldb::Slice slValue = pcursor->value();
|
|
CDataStream ssValue(slValue.data(), slValue.data()+slValue.size(), SER_DISK, CLIENT_VERSION);
|
|
CCoins coins;
|
|
ssValue >> coins;
|
|
uint256 txhash;
|
|
ssKey >> txhash;
|
|
ss << txhash;
|
|
ss << VARINT(coins.nVersion);
|
|
ss << (coins.fCoinBase ? 'c' : 'n');
|
|
ss << VARINT(coins.nHeight);
|
|
stats.nTransactions++;
|
|
for (unsigned int i=0; i<coins.vout.size(); i++) {
|
|
const CTxOut &out = coins.vout[i];
|
|
if (!out.IsNull()) {
|
|
stats.nTransactionOutputs++;
|
|
ss << VARINT(i+1);
|
|
ss << out;
|
|
nTotalAmount += out.nValue;
|
|
}
|
|
}
|
|
stats.nSerializedSize += 32 + slValue.size();
|
|
ss << VARINT(0);
|
|
}
|
|
pcursor->Next();
|
|
} catch (const std::exception& e) {
|
|
return error("%s: Deserialize or I/O error - %s", __func__, e.what());
|
|
}
|
|
}
|
|
{
|
|
LOCK(cs_main);
|
|
stats.nHeight = mapBlockIndex.find(stats.hashBlock)->second->nHeight;
|
|
}
|
|
stats.hashSerialized = ss.GetHash();
|
|
stats.nTotalAmount = nTotalAmount;
|
|
return true;
|
|
}
|
|
|
|
bool CBlockTreeDB::WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*> >& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo) {
|
|
CLevelDBBatch batch;
|
|
for (std::vector<std::pair<int, const CBlockFileInfo*> >::const_iterator it=fileInfo.begin(); it != fileInfo.end(); it++) {
|
|
batch.Write(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(make_pair(DB_BLOCK_INDEX, (*it)->GetBlockHash()), CDiskBlockIndex(*it));
|
|
}
|
|
return WriteBatch(batch, true);
|
|
}
|
|
|
|
bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) {
|
|
return Read(make_pair(DB_TXINDEX, txid), pos);
|
|
}
|
|
|
|
bool CBlockTreeDB::WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos> >&vect) {
|
|
CLevelDBBatch batch;
|
|
for (std::vector<std::pair<uint256,CDiskTxPos> >::const_iterator it=vect.begin(); it!=vect.end(); it++)
|
|
batch.Write(make_pair(DB_TXINDEX, it->first), it->second);
|
|
return WriteBatch(batch);
|
|
}
|
|
|
|
bool CBlockTreeDB::WriteFlag(const std::string &name, bool fValue) {
|
|
return Write(std::make_pair(DB_FLAG, name), fValue ? '1' : '0');
|
|
}
|
|
|
|
bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) {
|
|
char ch;
|
|
if (!Read(std::make_pair(DB_FLAG, name), ch))
|
|
return false;
|
|
fValue = ch == '1';
|
|
return true;
|
|
}
|
|
|
|
bool CBlockTreeDB::LoadBlockIndexGuts()
|
|
{
|
|
boost::scoped_ptr<leveldb::Iterator> pcursor(NewIterator());
|
|
|
|
CDataStream ssKeySet(SER_DISK, CLIENT_VERSION);
|
|
ssKeySet << make_pair(DB_BLOCK_INDEX, uint256());
|
|
pcursor->Seek(ssKeySet.str());
|
|
|
|
// Load mapBlockIndex
|
|
while (pcursor->Valid()) {
|
|
boost::this_thread::interruption_point();
|
|
try {
|
|
leveldb::Slice slKey = pcursor->key();
|
|
CDataStream ssKey(slKey.data(), slKey.data()+slKey.size(), SER_DISK, CLIENT_VERSION);
|
|
char chType;
|
|
ssKey >> chType;
|
|
if (chType == DB_BLOCK_INDEX) {
|
|
leveldb::Slice slValue = pcursor->value();
|
|
CDataStream ssValue(slValue.data(), slValue.data()+slValue.size(), SER_DISK, CLIENT_VERSION);
|
|
CDiskBlockIndex diskindex;
|
|
ssValue >> diskindex;
|
|
|
|
// Construct block index object
|
|
CBlockIndex* pindexNew = InsertBlockIndex(diskindex.GetBlockHash());
|
|
pindexNew->pprev = InsertBlockIndex(diskindex.hashPrev);
|
|
pindexNew->nHeight = diskindex.nHeight;
|
|
pindexNew->nFile = diskindex.nFile;
|
|
pindexNew->nDataPos = diskindex.nDataPos;
|
|
pindexNew->nUndoPos = diskindex.nUndoPos;
|
|
pindexNew->hashAnchor = diskindex.hashAnchor;
|
|
pindexNew->nVersion = diskindex.nVersion;
|
|
pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
|
|
pindexNew->hashReserved = diskindex.hashReserved;
|
|
pindexNew->nTime = diskindex.nTime;
|
|
pindexNew->nBits = diskindex.nBits;
|
|
pindexNew->nNonce = diskindex.nNonce;
|
|
pindexNew->nSolution = diskindex.nSolution;
|
|
pindexNew->nStatus = diskindex.nStatus;
|
|
pindexNew->nCachedBranchId = diskindex.nCachedBranchId;
|
|
pindexNew->nTx = diskindex.nTx;
|
|
pindexNew->nSproutValue = diskindex.nSproutValue;
|
|
|
|
// Consistency checks
|
|
auto header = pindexNew->GetBlockHeader();
|
|
if (header.GetHash() != pindexNew->GetBlockHash())
|
|
return error("LoadBlockIndex(): block header inconsistency detected: on-disk = %s, in-memory = %s",
|
|
diskindex.ToString(), pindexNew->ToString());
|
|
if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, Params().GetConsensus()))
|
|
return error("LoadBlockIndex(): CheckProofOfWork failed: %s", pindexNew->ToString());
|
|
|
|
pcursor->Next();
|
|
} else {
|
|
break; // if shutdown requested or finished loading block index
|
|
}
|
|
} catch (const std::exception& e) {
|
|
return error("%s: Deserialize or I/O error - %s", __func__, e.what());
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|