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")};
};

}
}