EthashClient.cpp

/*
    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/>.
*/
/** @file EthashClient.cpp
 * @author Gav Wood <i@gavwood.com>
 * @date 2015
 */

#include "EthashClient.h"
#include "Ethash.h"
#include <boost/filesystem/path.hpp>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace p2p;
namespace fs = boost::filesystem;

EthashClient& dev::eth::asEthashClient(Interface& _c)
{
    if (dynamic_cast<Ethash*>(_c.sealEngine()))
        return dynamic_cast<EthashClient&>(_c);
    throw InvalidSealEngine();
}

EthashClient* dev::eth::asEthashClient(Interface* _c)
{
    if (dynamic_cast<Ethash*>(_c->sealEngine()))
        return &dynamic_cast<EthashClient&>(*_c);
    throw InvalidSealEngine();
}

DEV_SIMPLE_EXCEPTION(ChainParamsNotEthash);

EthashClient::EthashClient(ChainParams const& _params, int _networkID, p2p::Host* _host,
    std::shared_ptr<GasPricer> _gpForAdoption, fs::path const& _dbPath,
    fs::path const& _snapshotPath, WithExisting _forceAction,
    TransactionQueue::Limits const& _limits)
  : Client(
        _params, _networkID, _host, _gpForAdoption, _dbPath, _snapshotPath, _forceAction, _limits)
{
    // will throw if we're not an Ethash seal engine.
    asEthashClient(*this);
}

EthashClient::~EthashClient()
{
    terminate();
}

Ethash* EthashClient::ethash() const
{
    return dynamic_cast<Ethash*>(Client::sealEngine());
}

bool EthashClient::isMining() const
{
    return ethash()->farm().isMining();
}

WorkingProgress EthashClient::miningProgress() const
{
    if (isMining())
        return ethash()->farm().miningProgress();
    return WorkingProgress();
}

u256 EthashClient::hashrate() const
{
    u256 r = externalHashrate();
    if (isMining())
        r += miningProgress().rate();
    return r;
}

std::tuple<h256, h256, h256> EthashClient::getEthashWork()
{
    // lock the work so a later submission isn't invalidated by processing a transaction elsewhere.
    // this will be reset as soon as a new block arrives, allowing more transactions to be processed.
    bool oldShould = shouldServeWork();
    m_lastGetWork = chrono::system_clock::now();

    if (!sealEngine()->shouldSeal(this))
        return std::tuple<h256, h256, h256>();

    // if this request has made us bother to serve work, prep it now.
    if (!oldShould && shouldServeWork())
        onPostStateChanged();
    else
        // otherwise, set this to true so that it gets prepped next time.
        m_remoteWorking = true;
    ethash()->manuallySetWork(m_sealingInfo);
    return std::tuple<h256, h256, h256>(m_sealingInfo.hash(WithoutSeal), Ethash::seedHash(m_sealingInfo), Ethash::boundary(m_sealingInfo));
}

bool EthashClient::submitEthashWork(h256 const& _mixHash, h64 const& _nonce)
{
    ethash()->manuallySubmitWork(_mixHash, _nonce);
    return true;
}

void EthashClient::setShouldPrecomputeDAG(bool _precompute)
{
    bytes trueBytes {1};
    bytes falseBytes {0};
    sealEngine()->setOption("precomputeDAG", _precompute ? trueBytes: falseBytes);
}

void EthashClient::submitExternalHashrate(u256 const& _rate, h256 const& _id)
{
    WriteGuard writeGuard(x_externalRates);
    m_externalRates[_id] = make_pair(_rate, chrono::steady_clock::now());
}

u256 EthashClient::externalHashrate() const
{
    u256 ret = 0;
    WriteGuard writeGuard(x_externalRates);
    for (auto i = m_externalRates.begin(); i != m_externalRates.end();)
        if (chrono::steady_clock::now() - i->second.second > chrono::seconds(5))
            i = m_externalRates.erase(i);
        else
            ret += i++->second.first;
    return ret;
}