State.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 "GasPricer.h"
#include "SecureTrieDB.h"
#include "Transaction.h"
#include "TransactionReceipt.h"
#include <libdevcore/Common.h>
#include <libdevcore/OverlayDB.h>
#include <libdevcore/RLP.h>
#include <libethcore/BlockHeader.h>
#include <libethcore/Exceptions.h>
#include <libethereum/CodeSizeCache.h>
#include <libevm/ExtVMFace.h>
#include <array>
#include <unordered_map>

namespace dev
{

namespace test { class ImportTest; class StateLoader; }

namespace eth
{

// Import-specific errinfos
using errinfo_uncleIndex = boost::error_info<struct tag_uncleIndex, unsigned>;
using errinfo_currentNumber = boost::error_info<struct tag_currentNumber, u256>;
using errinfo_uncleNumber = boost::error_info<struct tag_uncleNumber, u256>;
using errinfo_unclesExcluded = boost::error_info<struct tag_unclesExcluded, h256Hash>;
using errinfo_block = boost::error_info<struct tag_block, bytes>;
using errinfo_now = boost::error_info<struct tag_now, unsigned>;

using errinfo_transactionIndex = boost::error_info<struct tag_transactionIndex, unsigned>;

using errinfo_vmtrace = boost::error_info<struct tag_vmtrace, std::string>;
using errinfo_receipts = boost::error_info<struct tag_receipts, std::vector<bytes>>;
using errinfo_transaction = boost::error_info<struct tag_transaction, bytes>;
using errinfo_phase = boost::error_info<struct tag_phase, unsigned>;
using errinfo_required_LogBloom = boost::error_info<struct tag_required_LogBloom, LogBloom>;
using errinfo_got_LogBloom = boost::error_info<struct tag_get_LogBloom, LogBloom>;
using LogBloomRequirementError = boost::tuple<errinfo_required_LogBloom, errinfo_got_LogBloom>;

class BlockChain;
class State;
class TransactionQueue;
struct VerifiedBlockRef;

enum class BaseState
{
    PreExisting,
    Empty
};

enum class Permanence
{
    Reverted,
    Committed,
    Uncommitted  
};

DEV_SIMPLE_EXCEPTION(InvalidAccountStartNonceInState);
DEV_SIMPLE_EXCEPTION(IncorrectAccountStartNonceInState);

class SealEngineFace;
class Executive;

struct Change
{
    enum Kind: int
    {
        Balance,

        Storage,

        StorageRoot,

        Nonce,

        Create,

        Code,

        Touch
    };

    Kind kind;        
    Address address;  
    u256 value;       
    u256 key;         
    bytes oldCode;    

    Change(Kind _kind, Address const& _addr, u256 const& _value = 0):
            kind(_kind), address(_addr), value(_value)
    {
        assert(_kind != Code); // For this the special constructor needs to be used.
    }

    Change(Address const& _addr, u256 const& _key, u256 const& _value):
            kind(Storage), address(_addr), value(_value), key(_key)
    {}

    Change(Address const& _addr, u256 const& _value):
            kind(Nonce), address(_addr), value(_value)
    {}

    Change(Address const& _addr, bytes const& _oldCode):
            kind(Code), address(_addr), oldCode(_oldCode)
    {}
};

using ChangeLog = std::vector<Change>;

class State
{
    friend class ExtVM;
    friend class dev::test::ImportTest;
    friend class dev::test::StateLoader;
    friend class BlockChain;

public:
    enum class CommitBehaviour
    {
        KeepEmptyAccounts,
        RemoveEmptyAccounts
    };

    using AddressMap = std::map<h256, Address>;

    explicit State(u256 const& _accountStartNonce): State(_accountStartNonce, OverlayDB(), BaseState::Empty) {}

    explicit State(u256 const& _accountStartNonce, OverlayDB const& _db, BaseState _bs = BaseState::PreExisting);

    enum NullType { Null };
    State(NullType): State(Invalid256, OverlayDB(), BaseState::Empty) {}

    State(State const& _s);

    State& operator=(State const& _s);

    static OverlayDB openDB(boost::filesystem::path const& _path, h256 const& _genesisHash, WithExisting _we = WithExisting::Trust);
    OverlayDB const& db() const { return m_db; }
    OverlayDB& db() { return m_db; }

    void populateFrom(AccountMap const& _map);

    std::unordered_map<Address, u256> addresses() const;

    std::pair<AddressMap, h256> addresses(h256 const& _begin, size_t _maxResults) const;

    std::pair<ExecutionResult, TransactionReceipt> execute(EnvInfo const& _envInfo, SealEngineFace const& _sealEngine, Transaction const& _t, Permanence _p = Permanence::Committed, OnOpFunc const& _onOp = OnOpFunc());

    void executeBlockTransactions(Block const& _block, unsigned _txCount, LastBlockHashesFace const& _lastHashes, SealEngineFace const& _sealEngine);

    bool addressInUse(Address const& _address) const;

    bool accountNonemptyAndExisting(Address const& _address) const;

    bool addressHasCode(Address const& _address) const;

    u256 balance(Address const& _id) const;

    void addBalance(Address const& _id, u256 const& _amount);

    void subBalance(Address const& _addr, u256 const& _value);

    void setBalance(Address const& _addr, u256 const& _value);

    void transferBalance(Address const& _from, Address const& _to, u256 const& _value) { subBalance(_from, _value); addBalance(_to, _value); }

    h256 storageRoot(Address const& _contract) const;

    u256 storage(Address const& _contract, u256 const& _memory) const;

    void setStorage(Address const& _contract, u256 const& _location, u256 const& _value);

    u256 originalStorageValue(Address const& _contract, u256 const& _key) const;

    void clearStorage(Address const& _contract);

    void createContract(Address const& _address);

    void setCode(Address const& _address, bytes&& _code);

    void kill(Address _a);

    std::map<h256, std::pair<u256, u256>> storage(Address const& _contract) const;

    bytes const& code(Address const& _addr) const;

    h256 codeHash(Address const& _contract) const;

    size_t codeSize(Address const& _contract) const;

    void incNonce(Address const& _id);

    void setNonce(Address const& _addr, u256 const& _newNonce);

    u256 getNonce(Address const& _addr) const;

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

    void commit(CommitBehaviour _commitBehaviour);

    void setRoot(h256 const& _root);

    u256 const& accountStartNonce() const { return m_accountStartNonce; }
    u256 const& requireAccountStartNonce() const;
    void noteAccountStartNonce(u256 const& _actual);

    size_t savepoint() const;

    void rollback(size_t _savepoint);

    ChangeLog const& changeLog() const { return m_changeLog; }

private:
    void removeEmptyAccounts();

    Account const* account(Address const& _addr) const;

    Account* account(Address const& _addr);

    void clearCacheIfTooLarge() const;

    void createAccount(Address const& _address, Account const&& _account);

    bool executeTransaction(Executive& _e, Transaction const& _t, OnOpFunc const& _onOp);

    OverlayDB m_db;
    SecureTrieDB<Address, OverlayDB> m_state;
    mutable std::unordered_map<Address, Account> m_cache;
    mutable std::vector<Address> m_unchangedCacheEntries;
    mutable std::set<Address> m_nonExistingAccountsCache;
    AddressHash m_touched;

    u256 m_accountStartNonce;

    friend std::ostream& operator<<(std::ostream& _out, State const& _s);
    ChangeLog m_changeLog;
};

std::ostream& operator<<(std::ostream& _out, State const& _s);

State& createIntermediateState(State& o_s, Block const& _block, unsigned _txIndex, BlockChain const& _bc);

template <class DB>
AddressHash commit(AccountMap const& _cache, SecureTrieDB<Address, DB>& _state);

}
}