Block.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 <array>
#include <unordered_map>
#include <libdevcore/Common.h>
#include <libdevcore/RLP.h>
#include <libdevcore/TrieDB.h>
#include <libdevcore/OverlayDB.h>
#include <libethcore/Exceptions.h>
#include <libethcore/BlockHeader.h>
#include <libethcore/ChainOperationParams.h>
#include "Account.h"
#include "Transaction.h"
#include "TransactionReceipt.h"
#include "GasPricer.h"
#include "State.h"

namespace dev
{

namespace test { class ImportTest; class StateLoader; }

namespace eth
{

class SealEngineFace;
class BlockChain;
class State;
class TransactionQueue;
struct VerifiedBlockRef;
class LastBlockHashesFace;

struct PopulationStatistics
{
    double verify;
    double enact;
};

DEV_SIMPLE_EXCEPTION(ChainOperationWithUnknownBlockChain);
DEV_SIMPLE_EXCEPTION(InvalidOperationOnSealedBlock);

class Block
{
    friend class ExtVM;
    friend class dev::test::ImportTest;
    friend class dev::test::StateLoader;
    friend class Executive;
    friend class BlockChain;

public:
    // TODO: pass in ChainOperationParams rather than u256

    Block(u256 const& _accountStartNonce): m_state(_accountStartNonce, OverlayDB(), BaseState::Empty), m_precommit(_accountStartNonce) {}

    Block(BlockChain const& _bc, OverlayDB const& _db, BaseState _bs = BaseState::PreExisting, Address const& _author = Address());

    Block(BlockChain const& _bc, OverlayDB const& _db, h256 const& _root, Address const& _author = Address());

    enum NullType { Null };
    Block(NullType): m_state(0, OverlayDB(), BaseState::Empty), m_precommit(0) {}

    explicit Block(BlockChain const& _bc): Block(Null) { noteChain(_bc); }

    Block(Block const& _s);

    Block& operator=(Block const& _s);

    Address author() const { return m_author; }

    void setAuthor(Address const& _id) { m_author = _id; resetCurrent(); }

    void noteChain(BlockChain const& _bc);

    // Account-getters. All operate on the final state.

    u256 balance(Address const& _address) const { return m_state.balance(_address); }

    u256 transactionsFrom(Address const& _address) const { return m_state.getNonce(_address); }

    bool addressInUse(Address const& _address) const { return m_state.addressInUse(_address); }

    bool addressHasCode(Address const& _address) const { return m_state.addressHasCode(_address); }

    h256 storageRoot(Address const& _contract) const { return m_state.storageRoot(_contract); }

    u256 storage(Address const& _contract, u256 const& _memory) const { return m_state.storage(_contract, _memory); }

    std::map<h256, std::pair<u256, u256>> storage(Address const& _contract) const { return m_state.storage(_contract); }

    bytes const& code(Address const& _contract) const { return m_state.code(_contract); }

    h256 codeHash(Address const& _contract) const { return m_state.codeHash(_contract); }

    // General information from state

    State const& state() const { return m_state; }

    OverlayDB const& db() const { return m_state.db(); }

    h256 rootHash() const { return m_state.rootHash(); }

    std::unordered_map<Address, u256> addresses() const { return m_state.addresses(); }

    // For altering accounts behind-the-scenes

    State& mutableState() { return m_state; }

    // Information concerning ongoing transactions

    u256 gasLimitRemaining() const { return m_currentBlock.gasLimit() - gasUsed(); }

    Transactions const& pending() const { return m_transactions; }

    h256Hash const& pendingHashes() const { return m_transactionSet; }

    TransactionReceipt const& receipt(unsigned _i) const { return m_receipts.at(_i); }

    LogEntries const& log(unsigned _i) const { return receipt(_i).log(); }

    LogBloom logBloom() const;

    LogBloom const& logBloom(unsigned _i) const { return receipt(_i).bloom(); }

    h256 stateRootBeforeTx(unsigned _i) const;

    // State-change operations

    PopulationStatistics populateFromChain(BlockChain const& _bc, h256 const& _hash, ImportRequirements::value _ir = ImportRequirements::None);

    ExecutionResult execute(LastBlockHashesFace const& _lh, Transaction const& _t, Permanence _p = Permanence::Committed, OnOpFunc const& _onOp = OnOpFunc());

    std::pair<TransactionReceipts, bool> sync(BlockChain const& _bc, TransactionQueue& _tq, GasPricer const& _gp, unsigned _msTimeout = 100);

    bool sync(BlockChain const& _bc);

    bool sync(BlockChain const& _bc, h256 const& _blockHash, BlockHeader const& _bi = BlockHeader());

    u256 enactOn(VerifiedBlockRef const& _block, BlockChain const& _bc);

    void cleanup();

    void resetCurrent(int64_t _timestamp = utcTime());

    // Sealing

    void commitToSeal(BlockChain const& _bc, bytes const& _extraData = {});


    bool sealBlock(bytes const& _header) { return sealBlock(&_header); }
    bool sealBlock(bytesConstRef _header);

    bool isSealed() const { return !m_currentBytes.empty(); }

    bytes const& blockData() const { return m_currentBytes; }

    BlockHeader const& info() const { return m_currentBlock; }

private:
    SealEngineFace* sealEngine() const;

    void uncommitToSeal();

    u256 enact(VerifiedBlockRef const& _block, BlockChain const& _bc);

    void applyRewards(std::vector<BlockHeader> const& _uncleBlockHeaders, u256 const& _blockReward);

    u256 gasUsed() const { return m_receipts.size() ? m_receipts.back().cumulativeGasUsed() : 0; }

    void performIrregularModifications();

    void updateBlockhashContract();

    State m_state;                              
    Transactions m_transactions;                
    TransactionReceipts m_receipts;             
    h256Hash m_transactionSet;                  
    State m_precommit;                          

    BlockHeader m_previousBlock;                
    BlockHeader m_currentBlock;                 
    bytes m_currentBytes;                       
    bool m_committedToSeal = false;             

    bytes m_currentTxs;                         
    bytes m_currentUncles;                      

    Address m_author;                           

    SealEngineFace* m_sealEngine = nullptr;     

    Logger m_logger{createLogger(VerbosityDebug, "block")};
    Logger m_loggerDetailed{createLogger(VerbosityTrace, "block")};
};


}

}