ExtVMFace.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 "Instruction.h"

#include <libethcore/BlockHeader.h>
#include <libethcore/ChainOperationParams.h>
#include <libethcore/Common.h>
#include <libethcore/LogEntry.h>
#include <libdevcore/Common.h>
#include <libdevcore/CommonData.h>
#include <libdevcore/SHA3.h>

#include <evmc/evmc.h>
#include <evmc/helpers.h>

#include <boost/optional.hpp>
#include <functional>
#include <set>

namespace dev
{
namespace eth
{

class owning_bytes_ref: public vector_ref<byte const>
{
public:
    owning_bytes_ref() = default;

    owning_bytes_ref(bytes&& _bytes, size_t _begin, size_t _size):
            m_bytes(std::move(_bytes))
    {
        // Set the reference *after* the buffer is moved to avoid
        // pointer invalidation.
        retarget(&m_bytes[_begin], _size);
    }

    owning_bytes_ref(owning_bytes_ref const&) = delete;
    owning_bytes_ref(owning_bytes_ref&&) = default;
    owning_bytes_ref& operator=(owning_bytes_ref const&) = delete;
    owning_bytes_ref& operator=(owning_bytes_ref&&) = default;

    bytes&& takeBytes()
    {
        reset();  // Reset reference just in case.
        return std::move(m_bytes);
    }

private:
    bytes m_bytes;
};

struct SubState
{
    std::set<Address> suicides;  
    LogEntries logs;             
    int64_t refunds = 0;         

    SubState& operator+=(SubState const& _s)
    {
        suicides += _s.suicides;
        refunds += _s.refunds;
        logs += _s.logs;
        return *this;
    }

    void clear()
    {
        suicides.clear();
        logs.clear();
        refunds = 0;
    }
};

class ExtVMFace;
class LastBlockHashesFace;
class VMFace;

using OnOpFunc = std::function<void(uint64_t /*steps*/, uint64_t /* PC */, Instruction /*instr*/, bigint /*newMemSize*/, bigint /*gasCost*/, bigint /*gas*/, VMFace const*, ExtVMFace const*)>;

struct CallParameters
{
    CallParameters() = default;
    CallParameters(
        Address _senderAddress,
        Address _codeAddress,
        Address _receiveAddress,
        u256 _valueTransfer,
        u256 _apparentValue,
        u256 _gas,
        bytesConstRef _data,
        OnOpFunc _onOpFunc
    ):    senderAddress(_senderAddress), codeAddress(_codeAddress), receiveAddress(_receiveAddress),
        valueTransfer(_valueTransfer), apparentValue(_apparentValue), gas(_gas), data(_data), onOp(_onOpFunc)  {}
    Address senderAddress;
    Address codeAddress;
    Address receiveAddress;
    u256 valueTransfer;
    u256 apparentValue;
    u256 gas;
    bytesConstRef data;
    bool staticCall = false;
    OnOpFunc onOp;
};

class EnvInfo
{
public:
    EnvInfo(BlockHeader const& _current, LastBlockHashesFace const& _lh, u256 const& _gasUsed):
        m_headerInfo(_current),
        m_lastHashes(_lh),
        m_gasUsed(_gasUsed)
    {}
    // Constructor with custom gasLimit - used in some synthetic scenarios like eth_estimateGas    RPC method
    EnvInfo(BlockHeader const& _current, LastBlockHashesFace const& _lh, u256 const& _gasUsed, u256 const& _gasLimit):
        EnvInfo(_current, _lh, _gasUsed)
    {
        m_headerInfo.setGasLimit(_gasLimit);
    }

    BlockHeader const& header() const { return m_headerInfo;  }

    int64_t number() const { return m_headerInfo.number(); }
    Address const& author() const { return m_headerInfo.author(); }
    int64_t timestamp() const { return m_headerInfo.timestamp(); }
    u256 const& difficulty() const { return m_headerInfo.difficulty(); }
    u256 const& gasLimit() const { return m_headerInfo.gasLimit(); }
    LastBlockHashesFace const& lastHashes() const { return m_lastHashes; }
    u256 const& gasUsed() const { return m_gasUsed; }

private:
    BlockHeader m_headerInfo;
    LastBlockHashesFace const& m_lastHashes;
    u256 m_gasUsed;
};

struct CallResult
{
    evmc_status_code status;
    owning_bytes_ref output;

    CallResult(evmc_status_code status, owning_bytes_ref&& output)
      : status{status}, output{std::move(output)}
    {}
};

struct CreateResult
{
    evmc_status_code status;
    owning_bytes_ref output;
    h160 address;

    CreateResult(evmc_status_code status, owning_bytes_ref&& output, h160 const& address)
        : status{status}, output{std::move(output)}, address{address}
    {}
};

class ExtVMFace: public evmc_context
{
public:
    ExtVMFace(EnvInfo const& _envInfo, Address _myAddress, Address _caller, Address _origin,
        u256 _value, u256 _gasPrice, bytesConstRef _data, bytes _code, h256 const& _codeHash,
        unsigned _depth, bool _isCreate, bool _staticCall);

    virtual ~ExtVMFace() = default;

    ExtVMFace(ExtVMFace const&) = delete;
    ExtVMFace& operator=(ExtVMFace const&) = delete;

    virtual u256 store(u256) { return 0; }

    virtual void setStore(u256, u256) {}

    virtual u256 originalStorageValue(u256 const&) { return 0; }

    virtual u256 balance(Address) { return 0; }

    virtual bytes const& codeAt(Address) { return NullBytes; }

    virtual size_t codeSizeAt(Address) { return 0; }

    virtual h256 codeHashAt(Address) { return h256{}; }

    virtual bool exists(Address) { return false; }

    virtual void suicide(Address) { sub.suicides.insert(myAddress); }

    virtual CreateResult create(u256, u256&, bytesConstRef, Instruction, u256, OnOpFunc const&) = 0;

    virtual CallResult call(CallParameters&) = 0;

    virtual void log(h256s&& _topics, bytesConstRef _data) { sub.logs.push_back(LogEntry(myAddress, std::move(_topics), _data.toBytes())); }

    virtual h256 blockHash(u256 _number) = 0;

    EnvInfo const& envInfo() const { return m_envInfo; }

    virtual EVMSchedule const& evmSchedule() const { return DefaultSchedule; }

private:
    EnvInfo const& m_envInfo;

public:
    // TODO: make private
    Address myAddress;  
    Address caller;     
    Address origin;     
    u256 value;         
    u256 gasPrice;      
    bytesConstRef data;       
    bytes code;               
    h256 codeHash;            
    u256 salt;                
    SubState sub;             
    unsigned depth = 0;       
    bool isCreate = false;    
    bool staticCall = false;  
};

inline evmc_address toEvmC(Address const& _addr)
{
    return reinterpret_cast<evmc_address const&>(_addr);
}

inline evmc_uint256be toEvmC(h256 const& _h)
{
    return reinterpret_cast<evmc_uint256be const&>(_h);
}

inline u256 fromEvmC(evmc_uint256be const& _n)
{
    return fromBigEndian<u256>(_n.bytes);
}

inline Address fromEvmC(evmc_address const& _addr)
{
    return reinterpret_cast<Address const&>(_addr);
}
}
}