Executive.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 "Transaction.h"
 
#include <libdevcore/Log.h>
#include <libethcore/Common.h>
#include <libevm/VMFace.h>
 
#include <json/json.h>
#include <functional>
 
namespace Json
{
    class Value;
}
 
namespace dev
{
 
class OverlayDB;
 
namespace eth
{
 
class State;
class Block;
class BlockChain;
class ExtVM;
class SealEngineFace;
struct Manifest;
 
class StandardTrace
{
public:
    struct DebugOptions
    {
        bool disableStorage = false;
        bool disableMemory = false;
        bool disableStack = false;
        bool fullStorage = false;
    };
 
    StandardTrace();
    void operator()(uint64_t _steps, uint64_t _PC, Instruction _inst, bigint _newMemSize,
        bigint _gasCost, bigint _gas, VMFace const* _vm, ExtVMFace const* _extVM);
 
    void setShowMnemonics() { m_showMnemonics = true; }
    void setOptions(DebugOptions _options) { m_options = _options; }
 
    Json::Value jsonValue() const { return m_trace; }
    std::string styledJson() const;
    std::string multilineTrace() const;
 
    OnOpFunc onOp()
    {
        return [=](uint64_t _steps, uint64_t _PC, Instruction _inst, bigint _newMemSize,
                   bigint _gasCost, bigint _gas, VMFace const* _vm, ExtVMFace const* _extVM) {
            (*this)(_steps, _PC, _inst, _newMemSize, _gasCost, _gas, _vm, _extVM);
        };
    }
 
private:
    bool m_showMnemonics = false;
    std::vector<Instruction> m_lastInst;
    Json::Value m_trace;
    DebugOptions m_options;
};
 
class Executive
{
public:
    Executive(State& _s, EnvInfo const& _envInfo, SealEngineFace const& _sealEngine, unsigned _level = 0): m_s(_s), m_envInfo(_envInfo), m_depth(_level), m_sealEngine(_sealEngine) {}
 
    Executive(Block& _s, BlockChain const& _bc, unsigned _level = 0);
 
    Executive(Block& _s, LastBlockHashesFace const& _lh, unsigned _level = 0);
 
    Executive(State& io_s, Block const& _block, unsigned _txIndex, BlockChain const& _bc, unsigned _level = 0);
 
    Executive(Executive const&) = delete;
    void operator=(Executive) = delete;
 
    void initialize(bytesConstRef _transaction) { initialize(Transaction(_transaction, CheckTransaction::None)); }
    void initialize(Transaction const& _transaction);
    bool finalize();
    bool execute();
    Transaction const& t() const { return m_t; }
    LogEntries const& logs() const { return m_logs; }
    u256 gasUsed() const;
 
    owning_bytes_ref takeOutput() { return std::move(m_output); }
 
    bool create(Address const& _txSender, u256 const& _endowment, u256 const& _gasPrice, u256 const& _gas, bytesConstRef _code, Address const& _originAddress);
    bool createOpcode(Address const& _sender, u256 const& _endowment, u256 const& _gasPrice, u256 const& _gas, bytesConstRef _code, Address const& _originAddress);
    bool create2Opcode(Address const& _sender, u256 const& _endowment, u256 const& _gasPrice, u256 const& _gas, bytesConstRef _code, Address const& _originAddress, u256 const& _salt);
    bool call(Address const& _receiveAddress, Address const& _txSender, u256 const& _txValue, u256 const& _gasPrice, bytesConstRef _txData, u256 const& _gas);
    bool call(CallParameters const& _cp, u256 const& _gasPrice, Address const& _origin);
    void accrueSubState(SubState& _parentContext);
 
    bool go(OnOpFunc const& _onOp = OnOpFunc());
 
    OnOpFunc simpleTrace();
 
    u256 gas() const { return m_gas; }
 
    Address newAddress() const { return m_newAddress; }
 
    TransactionException getException() const noexcept { return m_excepted; }
 
    void setResultRecipient(ExecutionResult& _res) { m_res = &_res; }
 
    void revert();
 
private:
    bool executeCreate(Address const& _txSender, u256 const& _endowment, u256 const& _gasPrice, u256 const& _gas, bytesConstRef _code, Address const& _originAddress);
 
    State& m_s;                         
    // TODO: consider changign to EnvInfo const& to avoid LastHashes copy at every CALL/CREATE
    EnvInfo m_envInfo;                  
    std::shared_ptr<ExtVM> m_ext;       
    owning_bytes_ref m_output;          
    ExecutionResult* m_res = nullptr;   
 
    unsigned m_depth = 0;               
    TransactionException m_excepted = TransactionException::None;   
    int64_t m_baseGasRequired;          
    u256 m_gas = 0;                     
 
    Transaction m_t;                    
    LogEntries m_logs;                  
 
    u256 m_gasCost;
    SealEngineFace const& m_sealEngine;
 
    bool m_isCreation = false;
    Address m_newAddress;
    size_t m_savepoint = 0;
 
    Logger m_execLogger{createLogger(VerbosityDebug, "exec")};
    Logger m_detailsLogger{createLogger(VerbosityTrace, "exec")};
    Logger m_vmTraceLogger{createLogger(VerbosityTrace, "vmtrace")};
};
 
}
}