Account.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 <libdevcore/Common.h>
#include <libdevcore/SHA3.h>
#include <libdevcore/TrieCommon.h>
#include <libethcore/Common.h>
 
#include <boost/filesystem/path.hpp>
 
namespace dev
{
class OverlayDB;
 
namespace eth
{
 
class Account
{
public:
    enum Changedness
    {
        Changed,
        Unchanged
    };
 
    Account() {}
 
    Account(u256 _nonce, u256 _balance, Changedness _c = Changed): m_isAlive(true), m_isUnchanged(_c == Unchanged), m_nonce(_nonce), m_balance(_balance) {}
 
    Account(u256 _nonce, u256 _balance, h256 _contractRoot, h256 _codeHash, Changedness _c): m_isAlive(true), m_isUnchanged(_c == Unchanged), m_nonce(_nonce), m_balance(_balance), m_storageRoot(_contractRoot), m_codeHash(_codeHash) { assert(_contractRoot); }
 
 
    void kill()
    {
        m_isAlive = false;
        m_storageOverlay.clear();
        m_storageOriginal.clear();
        m_codeHash = EmptySHA3;
        m_storageRoot = EmptyTrie;
        m_balance = 0;
        m_nonce = 0;
        changed();
    }
 
    bool isAlive() const { return m_isAlive; }
 
    bool isDirty() const { return !m_isUnchanged; }
 
    void untouch() { m_isUnchanged = true; }
 
    bool isEmpty() const { return nonce() == 0 && balance() == 0 && codeHash() == EmptySHA3; }
 
    u256 const& balance() const { return m_balance; }
 
    void addBalance(u256 _value) { m_balance += _value; changed(); }
 
    u256 nonce() const { return m_nonce; }
 
    void incNonce() { ++m_nonce; changed(); }
 
    void setNonce(u256 const& _nonce) { m_nonce = _nonce; changed(); }
 
    h256 baseRoot() const { assert(m_storageRoot); return m_storageRoot; }
 
    u256 storageValue(u256 const& _key, OverlayDB const& _db) const
    {
        auto mit = m_storageOverlay.find(_key);
        if (mit != m_storageOverlay.end())
            return mit->second;
 
        return originalStorageValue(_key, _db);
    }
 
    u256 originalStorageValue(u256 const& _key, OverlayDB const& _db) const;
 
    std::unordered_map<u256, u256> const& storageOverlay() const { return m_storageOverlay; }
 
    void setStorage(u256 _p, u256 _v) { m_storageOverlay[_p] = _v; changed(); }
 
    void clearStorage()
    {
        m_storageOverlay.clear();
        m_storageOriginal.clear();
        m_storageRoot = EmptyTrie;
        changed();
    }
 
    void setStorageRoot(h256 const& _root)
    {
        m_storageOverlay.clear();
        m_storageOriginal.clear();
        m_storageRoot = _root;
        changed();
    }
 
    h256 codeHash() const { return m_codeHash; }
 
    bool hasNewCode() const { return m_hasNewCode; }
 
    void setCode(bytes&& _code);
 
    void noteCode(bytesConstRef _code) { assert(sha3(_code) == m_codeHash); m_codeCache = _code.toBytes(); }
 
    bytes const& code() const { return m_codeCache; }
 
private:
    void changed() { m_isUnchanged = false; }
 
    bool m_isAlive = false;
 
    bool m_isUnchanged = false;
 
    bool m_hasNewCode = false;
 
    u256 m_nonce;
 
    u256 m_balance = 0;
 
    h256 m_storageRoot = EmptyTrie;
 
    h256 m_codeHash = EmptySHA3;
 
    mutable std::unordered_map<u256, u256> m_storageOverlay;
 
    mutable std::unordered_map<u256, u256> m_storageOriginal;
 
    bytes m_codeCache;
 
    static const h256 c_contractConceptionCodeHash;
};
 
class AccountMask
{
public:
    AccountMask(bool _all = false):
        m_hasBalance(_all),
        m_hasNonce(_all),
        m_hasCode(_all),
        m_hasStorage(_all)
    {}
 
    AccountMask(
        bool _hasBalance,
        bool _hasNonce,
        bool _hasCode,
        bool _hasStorage,
        bool _shouldNotExist = false
    ):
        m_hasBalance(_hasBalance),
        m_hasNonce(_hasNonce),
        m_hasCode(_hasCode),
        m_hasStorage(_hasStorage),
        m_shouldNotExist(_shouldNotExist)
    {}
 
    bool allSet() const { return m_hasBalance && m_hasNonce && m_hasCode && m_hasStorage; }
    bool hasBalance() const { return m_hasBalance; }
    bool hasNonce() const { return m_hasNonce; }
    bool hasCode() const { return m_hasCode; }
    bool hasStorage() const { return m_hasStorage; }
    bool shouldExist() const { return !m_shouldNotExist; }
 
private:
    bool m_hasBalance;
    bool m_hasNonce;
    bool m_hasCode;
    bool m_hasStorage;
    bool m_shouldNotExist = false;
};
 
using AccountMap = std::unordered_map<Address, Account>;
using AccountMaskMap = std::unordered_map<Address, AccountMask>;
 
class PrecompiledContract;
using PrecompiledContractMap = std::unordered_map<Address, PrecompiledContract>;
 
AccountMap jsonToAccountMap(std::string const& _json, u256 const& _defaultNonce = 0,
    AccountMaskMap* o_mask = nullptr, PrecompiledContractMap* o_precompiled = nullptr,
    const boost::filesystem::path& _configPath = {});
}
}