BlockChain.h

Go to the documentation of this file.

/*
    This file is part of cpp-ethereum.
 
    cpp-ethereum is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    cpp-ethereum is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
 
#include "Account.h"
#include "BlockDetails.h"
#include "BlockQueue.h"
#include "ChainParams.h"
#include "LastBlockHashesFace.h"
#include "State.h"
#include "Transaction.h"
#include "VerifiedBlock.h"
#include <libdevcore/db.h>
#include <libdevcore/Exceptions.h>
#include <libdevcore/Log.h>
#include <libdevcore/Guards.h>
#include <libethcore/BlockHeader.h>
#include <libethcore/Common.h>
#include <libethcore/SealEngine.h>
#include <chrono>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <boost/filesystem/path.hpp>
 
namespace std
{
template <> struct hash<pair<dev::h256, unsigned>>
{
    size_t operator()(pair<dev::h256, unsigned> const& _x) const { return hash<dev::h256>()(_x.first) ^ hash<unsigned>()(_x.second); }
};
}
 
namespace dev
{
 
class OverlayDB;
 
namespace eth
{
 
static const h256s NullH256s;
 
class State;
class Block;
class ImportPerformanceLogger;
 
DEV_SIMPLE_EXCEPTION(AlreadyHaveBlock);
DEV_SIMPLE_EXCEPTION(FutureTime);
DEV_SIMPLE_EXCEPTION(TransientError);
DEV_SIMPLE_EXCEPTION(FailedToWriteChainStart);
DEV_SIMPLE_EXCEPTION(UnknownBlockNumber);
 
// TODO: Move all this Genesis stuff into Genesis.h/.cpp
std::unordered_map<Address, Account> const& genesisState();
 
db::Slice toSlice(h256 const& _h, unsigned _sub = 0);
db::Slice toSlice(uint64_t _n, unsigned _sub = 0);
 
using BlocksHash = std::unordered_map<h256, bytes>;
using TransactionHashes = h256s;
using UncleHashes = h256s;
 
enum {
    ExtraDetails = 0,
    ExtraBlockHash,
    ExtraTransactionAddress,
    ExtraLogBlooms,
    ExtraReceipts,
    ExtraBlocksBlooms
};
 
using ProgressCallback = std::function<void(unsigned, unsigned)>;
 
class VersionChecker
{
public:
    VersionChecker(boost::filesystem::path const& _dbPath, h256 const& _genesisHash);
};
 
class BlockChain
{
public:
    BlockChain(ChainParams const& _p, boost::filesystem::path const& _path, WithExisting _we = WithExisting::Trust, ProgressCallback const& _pc = ProgressCallback());
    ~BlockChain();
 
    void reopen(WithExisting _we = WithExisting::Trust, ProgressCallback const& _pc = ProgressCallback()) { reopen(m_params, _we, _pc); }
    void reopen(ChainParams const& _p, WithExisting _we = WithExisting::Trust, ProgressCallback const& _pc = ProgressCallback());
 
    void process();
 
    std::tuple<ImportRoute, bool, unsigned> sync(BlockQueue& _bq, OverlayDB const& _stateDB, unsigned _max);
 
    std::pair<ImportResult, ImportRoute> attemptImport(bytes const& _block, OverlayDB const& _stateDB, bool _mutBeNew = true) noexcept;
 
    ImportRoute import(bytes const& _block, OverlayDB const& _stateDB, bool _mustBeNew = true);
    ImportRoute import(VerifiedBlockRef const& _block, OverlayDB const& _db, bool _mustBeNew = true);
 
    void insert(bytes const& _block, bytesConstRef _receipts, bool _mustBeNew = true);
    void insert(VerifiedBlockRef _block, bytesConstRef _receipts, bool _mustBeNew = true);
    ImportRoute insertWithoutParent(bytes const& _block, bytesConstRef _receipts, u256 const& _totalDifficulty);
 
    bool isKnown(h256 const& _hash, bool _isCurrent = true) const;
 
    BlockHeader info(h256 const& _hash) const { return BlockHeader(headerData(_hash), HeaderData); }
    BlockHeader info() const { return info(currentHash()); }
 
    bytes block(h256 const& _hash) const;
    bytes block() const { return block(currentHash()); }
 
    bytes headerData(h256 const& _hash) const;
    bytes headerData() const { return headerData(currentHash()); }
 
    BlockDetails details(h256 const& _hash) const { return queryExtras<BlockDetails, ExtraDetails>(_hash, m_details, x_details, NullBlockDetails); }
    BlockDetails details() const { return details(currentHash()); }
 
    BlockLogBlooms logBlooms(h256 const& _hash) const { return queryExtras<BlockLogBlooms, ExtraLogBlooms>(_hash, m_logBlooms, x_logBlooms, NullBlockLogBlooms); }
    BlockLogBlooms logBlooms() const { return logBlooms(currentHash()); }
 
    BlockReceipts receipts(h256 const& _hash) const { return queryExtras<BlockReceipts, ExtraReceipts>(_hash, m_receipts, x_receipts, NullBlockReceipts); }
    BlockReceipts receipts() const { return receipts(currentHash()); }
 
    TransactionReceipt transactionReceipt(h256 const& _blockHash, unsigned _i) const { return receipts(_blockHash).receipts[_i]; }
 
    TransactionReceipt transactionReceipt(h256 const& _transactionHash) const { TransactionAddress ta = queryExtras<TransactionAddress, ExtraTransactionAddress>(_transactionHash, m_transactionAddresses, x_transactionAddresses, NullTransactionAddress); if (!ta) return bytesConstRef(); return transactionReceipt(ta.blockHash, ta.index); }
 
    TransactionHashes transactionHashes(h256 const& _hash) const { auto b = block(_hash); RLP rlp(b); h256s ret; for (auto t: rlp[1]) ret.push_back(sha3(t.data())); return ret; }
    TransactionHashes transactionHashes() const { return transactionHashes(currentHash()); }
 
    UncleHashes uncleHashes(h256 const& _hash) const { auto b = block(_hash); RLP rlp(b); h256s ret; for (auto t: rlp[2]) ret.push_back(sha3(t.data())); return ret; }
    UncleHashes uncleHashes() const { return uncleHashes(currentHash()); }
    
    h256 numberHash(unsigned _i) const { if (!_i) return genesisHash(); return queryExtras<BlockHash, uint64_t, ExtraBlockHash>(_i, m_blockHashes, x_blockHashes, NullBlockHash).value; }
 
    LastBlockHashesFace const& lastBlockHashes() const { return *m_lastBlockHashes;  }
 
    BlocksBlooms blocksBlooms(unsigned _level, unsigned _index) const { return blocksBlooms(chunkId(_level, _index)); }
    BlocksBlooms blocksBlooms(h256 const& _chunkId) const { return queryExtras<BlocksBlooms, ExtraBlocksBlooms>(_chunkId, m_blocksBlooms, x_blocksBlooms, NullBlocksBlooms); }
    LogBloom blockBloom(unsigned _number) const { return blocksBlooms(chunkId(0, _number / c_bloomIndexSize)).blooms[_number % c_bloomIndexSize]; }
    std::vector<unsigned> withBlockBloom(LogBloom const& _b, unsigned _earliest, unsigned _latest) const;
    std::vector<unsigned> withBlockBloom(LogBloom const& _b, unsigned _earliest, unsigned _latest, unsigned _topLevel, unsigned _index) const;
 
    bool isKnownTransaction(h256 const& _transactionHash) const { TransactionAddress ta = queryExtras<TransactionAddress, ExtraTransactionAddress>(_transactionHash, m_transactionAddresses, x_transactionAddresses, NullTransactionAddress); return !!ta; }
 
    bytes transaction(h256 const& _transactionHash) const { TransactionAddress ta = queryExtras<TransactionAddress, ExtraTransactionAddress>(_transactionHash, m_transactionAddresses, x_transactionAddresses, NullTransactionAddress); if (!ta) return bytes(); return transaction(ta.blockHash, ta.index); }
    std::pair<h256, unsigned> transactionLocation(h256 const& _transactionHash) const { TransactionAddress ta = queryExtras<TransactionAddress, ExtraTransactionAddress>(_transactionHash, m_transactionAddresses, x_transactionAddresses, NullTransactionAddress); if (!ta) return std::pair<h256, unsigned>(h256(), 0); return std::make_pair(ta.blockHash, ta.index); }
 
    bytes transaction(h256 const& _blockHash, unsigned _i) const { bytes b = block(_blockHash); return RLP(b)[1][_i].data().toBytes(); }
    bytes transaction(unsigned _i) const { return transaction(currentHash(), _i); }
 
    std::vector<bytes> transactions(h256 const& _blockHash) const { bytes b = block(_blockHash); std::vector<bytes> ret; for (auto const& i: RLP(b)[1]) ret.push_back(i.data().toBytes()); return ret; }
    std::vector<bytes> transactions() const { return transactions(currentHash()); }
 
    unsigned number(h256 const& _hash) const { return details(_hash).number; }
    unsigned number() const { ReadGuard l(x_lastBlockHash); return m_lastBlockNumber; }
 
    h256 currentHash() const { ReadGuard l(x_lastBlockHash); return m_lastBlockHash; }
 
    h256 genesisHash() const { return m_genesisHash; }
 
    h256Hash allKinFrom(h256 const& _parent, unsigned _generations) const;
 
    void rebuild(boost::filesystem::path const& _path, ProgressCallback const& _progress = std::function<void(unsigned, unsigned)>());
 
    void rewind(unsigned _newHead);
 
    void rescue(OverlayDB const& _db);
 
    std::tuple<h256s, h256, unsigned> treeRoute(h256 const& _from, h256 const& _to, bool _common = true, bool _pre = true, bool _post = true) const;
 
    struct Statistics
    {
        unsigned memBlocks = 0;
        unsigned memDetails = 0;
        unsigned memLogBlooms = 0;
        unsigned memReceipts = 0;
        unsigned memTransactionAddresses = 0;
        unsigned memBlockHashes = 0;
        unsigned memTotal() const { return memBlocks + memDetails + memLogBlooms + memReceipts + memTransactionAddresses + memBlockHashes; }
    };
 
    Statistics usage(bool _freshen = false) const { if (_freshen) updateStats(); return m_lastStats; }
 
    void garbageCollect(bool _force = false);
 
    void setOnBad(std::function<void(Exception&)> _t) { m_onBad = _t; }
 
    void setOnBlockImport(std::function<void(BlockHeader const&)> _t) { m_onBlockImport = _t; }
 
    Block genesisBlock(OverlayDB const& _db) const;
 
    VerifiedBlockRef verifyBlock(bytesConstRef _block, std::function<void(Exception&)> const& _onBad, ImportRequirements::value _ir = ImportRequirements::OutOfOrderChecks) const;
 
    std::string dumpDatabase() const;
 
    ChainParams const& chainParams() const { return m_params; }
 
    SealEngineFace* sealEngine() const { return m_sealEngine.get(); }
 
    BlockHeader const& genesis() const;
 
    unsigned chainStartBlockNumber() const;
    void setChainStartBlockNumber(unsigned _number);
 
private:
    static h256 chunkId(unsigned _level, unsigned _index) { return h256(_index * 0xff + _level); }
 
    void init(ChainParams const& _p);
    unsigned open(boost::filesystem::path const& _path, WithExisting _we);
    void open(boost::filesystem::path const& _path, WithExisting _we, ProgressCallback const& _pc);
    void close();
 
    ImportRoute insertBlockAndExtras(VerifiedBlockRef const& _block, bytesConstRef _receipts, u256 const& _totalDifficulty, ImportPerformanceLogger& _performanceLogger);
    void checkBlockIsNew(VerifiedBlockRef const& _block) const;
    void checkBlockTimestamp(BlockHeader const& _header) const;
 
    template <class T, class K, unsigned N>
    T queryExtras(K const& _h, std::unordered_map<K, T>& _m, boost::shared_mutex& _x, T const& _n,
        db::DatabaseFace* _extrasDB = nullptr) const
    {
        {
            ReadGuard l(_x);
            auto it = _m.find(_h);
            if (it != _m.end())
                return it->second;
        }
 
        std::string const s = (_extrasDB ? _extrasDB : m_extrasDB.get())->lookup(toSlice(_h, N));
        if (s.empty())
            return _n;
 
        noteUsed(_h, N);
 
        WriteGuard l(_x);
        auto ret = _m.insert(std::make_pair(_h, T(RLP(s))));
        return ret.first->second;
    }
 
    template <class T, unsigned N>
    T queryExtras(h256 const& _h, std::unordered_map<h256, T>& _m, boost::shared_mutex& _x,
        T const& _n, db::DatabaseFace* _extrasDB = nullptr) const
    {
        return queryExtras<T, h256, N>(_h, _m, _x, _n, _extrasDB);
    }
 
    void checkConsistency();
 
    void clearCachesDuringChainReversion(unsigned _firstInvalid);
    void clearBlockBlooms(unsigned _begin, unsigned _end);
 
    mutable SharedMutex x_blocks;
    mutable BlocksHash m_blocks;
    mutable SharedMutex x_details;
    mutable BlockDetailsHash m_details;
    mutable SharedMutex x_logBlooms;
    mutable BlockLogBloomsHash m_logBlooms;
    mutable SharedMutex x_receipts;
    mutable BlockReceiptsHash m_receipts;
    mutable SharedMutex x_transactionAddresses;
    mutable TransactionAddressHash m_transactionAddresses;
    mutable SharedMutex x_blockHashes;
    mutable BlockHashHash m_blockHashes;
    mutable SharedMutex x_blocksBlooms;
    mutable BlocksBloomsHash m_blocksBlooms;
 
    using CacheID = std::pair<h256, unsigned>;
    mutable Mutex x_cacheUsage;
    mutable std::deque<std::unordered_set<CacheID>> m_cacheUsage;
    mutable std::unordered_set<CacheID> m_inUse;
    void noteUsed(h256 const& _h, unsigned _extra = (unsigned)-1) const;
    void noteUsed(uint64_t const& _h, unsigned _extra = (unsigned)-1) const { (void)_h; (void)_extra; } // don't note non-hash types
    std::chrono::system_clock::time_point m_lastCollection;
 
    void noteCanonChanged() const { m_lastBlockHashes->clear(); }
    std::unique_ptr<LastBlockHashesFace> m_lastBlockHashes;
 
    void updateStats() const;
    mutable Statistics m_lastStats;
 
    std::unique_ptr<db::DatabaseFace> m_blocksDB;
    std::unique_ptr<db::DatabaseFace> m_extrasDB;
 
    mutable boost::shared_mutex x_lastBlockHash; // should protect both m_lastBlockHash and m_lastBlockNumber
    h256 m_lastBlockHash;
    unsigned m_lastBlockNumber = 0;
 
    ChainParams m_params;
    std::shared_ptr<SealEngineFace> m_sealEngine;   // consider shared_ptr.
    mutable SharedMutex x_genesis;
    mutable BlockHeader m_genesis;  // mutable because they're effectively memos.
    mutable bytes m_genesisHeaderBytes; // mutable because they're effectively memos.
    mutable h256 m_genesisHash;     // mutable because they're effectively memos.
 
    std::function<void(Exception&)> m_onBad;                                    
    std::function<void(BlockHeader const&)> m_onBlockImport;                                        
 
    boost::filesystem::path m_dbPath;
 
    mutable Logger m_logger{createLogger(VerbosityDebug, "chain")};
    mutable Logger m_loggerDetail{createLogger(VerbosityTrace, "chain")};
    mutable Logger m_loggerError{createLogger(VerbosityError, "chain")};
 
    friend std::ostream& operator<<(std::ostream& _out, BlockChain const& _bc);
};
 
std::ostream& operator<<(std::ostream& _out, BlockChain const& _bc);
 
}
}