Draft merge

2026-02-02 02:03:03 -05:00 · 2019-06-18 11:17:00 -07:00
parent 4d65433904 50ace41766
commit cbcfab0144
217 changed files with 13224 additions and 4105 deletions
--- a/src/net/JobResult.h
+++ b/src/net/JobResult.h
@@ -31,7 +31,8 @@
 #include <stdint.h>


-#include "common/net/Job.h"
+#include "base/tools/String.h"
+#include "base/net/stratum/Job.h"


 namespace xmrig {
@@ -40,20 +41,20 @@ namespace xmrig {
 class JobResult
 {
 public:
-    inline JobResult() : poolId(0), diff(0), nonce(0) {}
-    inline JobResult(int poolId, const Id &jobId, const Id &clientId, uint32_t nonce, const uint8_t *result, uint32_t diff, const Algorithm &algorithm) :
+    inline JobResult() : poolId(0), nonce(0), diff(0) {}
+    inline JobResult(int poolId, const String &jobId, const String &clientId, uint32_t nonce, const uint8_t *result, uint64_t diff, const Algorithm &algorithm) :
        algorithm(algorithm),
+        poolId(poolId),
        clientId(clientId),
        jobId(jobId),
-        poolId(poolId),
-        diff(diff),
-        nonce(nonce)
+        nonce(nonce),
+        diff(diff)
    {
        memcpy(this->result, result, sizeof(this->result));
    }


-    inline JobResult(const Job &job) : poolId(0), diff(0), nonce(0)
+    inline JobResult(const Job &job) : poolId(0), nonce(0), diff(0)
    {
        jobId     = job.id();
        clientId  = job.clientId();
@@ -71,11 +72,11 @@ public:


    Algorithm algorithm;
-    Id clientId;
-    Id jobId;
    int poolId;
-    uint32_t diff;
+    String clientId;
+    String jobId;
    uint32_t nonce;
+    uint64_t diff;
    uint8_t result[32];
 };

--- a/src/net/Network.cpp
+++ b/src/net/Network.cpp
@@ -6,6 +6,7 @@
 * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
 * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
 * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2019      Howard Chu  <https://github.com/hyc>
 * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
 *
 *   This program is free software: you can redistribute it and/or modify
@@ -32,38 +33,56 @@


 #include "api/Api.h"
-#include "common/log/Log.h"
-#include "common/net/Client.h"
-#include "common/net/SubmitResult.h"
-#include "core/Config.h"
+#include "base/io/log/Log.h"
+#include "base/net/stratum/Client.h"
+#include "base/net/stratum/SubmitResult.h"
+#include "base/tools/Chrono.h"
+#include "base/tools/Timer.h"
+#include "core/config/Config.h"
 #include "core/Controller.h"
 #include "net/Network.h"
 #include "net/strategies/DonateStrategy.h"
+#include "rapidjson/document.h"
 #include "workers/Workers.h"


+#ifdef XMRIG_FEATURE_API
+#   include "api/Api.h"
+#   include "api/interfaces/IApiRequest.h"
+#endif
+
+
 xmrig::Network::Network(Controller *controller) :
-    m_donate(nullptr)
+    m_controller(controller),
+    m_donate(nullptr),
+    m_timer(nullptr)
 {
    Workers::setListener(this);
    controller->addListener(this);

+#   ifdef XMRIG_FEATURE_API
+    controller->api()->addListener(this);
+#   endif
+
    const Pools &pools = controller->config()->pools();
    m_strategy = pools.createStrategy(this);

-    if (controller->config()->donateLevel() > 0) {
-        m_donate = new DonateStrategy(controller->config()->donateLevel(), pools.data().front().user(), controller->config()->algorithm().algo(), this);
+    if (pools.donateLevel() > 0) {
+        m_donate = new DonateStrategy(controller, this);
    }

-    m_timer.data = this;
-    uv_timer_init(uv_default_loop(), &m_timer);
-
-    uv_timer_start(&m_timer, Network::onTick, kTickInterval, kTickInterval);
+    m_timer = new Timer(this, kTickInterval, kTickInterval);
 }


 xmrig::Network::~Network()
 {
+    delete m_timer;
+
+    if (m_donate) {
+        delete m_donate;
+    }
+
    delete m_strategy;
 }

@@ -74,33 +93,22 @@ void xmrig::Network::connect()
 }


-void xmrig::Network::stop()
-{
-    if (m_donate) {
-        m_donate->stop();
-    }
-
-    m_strategy->stop();
-}
-
-
-void xmrig::Network::onActive(IStrategy *strategy, Client *client)
+void xmrig::Network::onActive(IStrategy *strategy, IClient *client)
 {
    if (m_donate && m_donate == strategy) {
        LOG_NOTICE("dev donate started");
        return;
    }

-    m_state.setPool(client->host(), client->port(), client->ip());
+    m_state.onActive(client);

    const char *tlsVersion = client->tlsVersion();
-    LOG_INFO(isColors() ? WHITE_BOLD("use pool ") CYAN_BOLD("%s:%d ") GREEN_BOLD("%s") " \x1B[1;30m%s "
-                        : "use pool %s:%d %s %s",
-             client->host(), client->port(), tlsVersion ? tlsVersion : "", client->ip());
+    LOG_INFO(WHITE_BOLD("use %s ") CYAN_BOLD("%s:%d ") GREEN_BOLD("%s") " " BLACK_BOLD("%s"),
+             client->mode(), client->pool().host().data(), client->pool().port(), tlsVersion ? tlsVersion : "", client->ip().data());

    const char *fingerprint = client->tlsFingerprint();
    if (fingerprint != nullptr) {
-        LOG_INFO("%sfingerprint (SHA-256): \"%s\"", isColors() ? "\x1B[1;30m" : "", fingerprint);
+        LOG_INFO(BLACK_BOLD("fingerprint (SHA-256): \"%s\""), fingerprint);
    }
 }

@@ -121,7 +129,7 @@ void xmrig::Network::onConfigChanged(Config *config, Config *previousConfig)
 }


-void xmrig::Network::onJob(IStrategy *strategy, Client *client, const Job &job)
+void xmrig::Network::onJob(IStrategy *strategy, IClient *client, const Job &job)
 {
    if (m_donate && m_donate->isActive() && m_donate != strategy) {
        return;
@@ -157,40 +165,43 @@ void xmrig::Network::onPause(IStrategy *strategy)
 }


-void xmrig::Network::onResultAccepted(IStrategy *, Client *, const SubmitResult &result, const char *error)
+void xmrig::Network::onRequest(IApiRequest &request)
+{
+#   ifdef XMRIG_FEATURE_API
+    if (request.method() == IApiRequest::METHOD_GET && (request.url() == "/1/summary" || request.url() == "/api.json")) {
+        request.accept();
+
+        getResults(request.reply(), request.doc());
+        getConnection(request.reply(), request.doc());
+    }
+#   endif
+}
+
+
+void xmrig::Network::onResultAccepted(IStrategy *, IClient *, const SubmitResult &result, const char *error)
 {
    m_state.add(result, error);

    if (error) {
-        LOG_INFO(isColors() ? "\x1B[1;31mrejected\x1B[0m (%" PRId64 "/%" PRId64 ") diff \x1B[1;37m%u\x1B[0m \x1B[31m\"%s\"\x1B[0m \x1B[1;30m(%" PRIu64 " ms)"
-                            : "rejected (%" PRId64 "/%" PRId64 ") diff %u \"%s\" (%" PRIu64 " ms)",
+        LOG_INFO(RED_BOLD("rejected") " (%" PRId64 "/%" PRId64 ") diff " WHITE_BOLD("%" PRIu64) " " RED("\"%s\"") " " BLACK_BOLD("(%" PRIu64 " ms)"),
                 m_state.accepted, m_state.rejected, result.diff, error, result.elapsed);
    }
    else {
-        LOG_INFO(isColors() ? "\x1B[1;32maccepted\x1B[0m (%" PRId64 "/%" PRId64 ") diff \x1B[1;37m%u\x1B[0m \x1B[1;30m(%" PRIu64 " ms)"
-                            : "accepted (%" PRId64 "/%" PRId64 ") diff %u (%" PRIu64 " ms)",
+        LOG_INFO(GREEN_BOLD("accepted") " (%" PRId64 "/%" PRId64 ") diff " WHITE_BOLD("%" PRIu64) " " BLACK_BOLD("(%" PRIu64 " ms)"),
                 m_state.accepted, m_state.rejected, result.diff, result.elapsed);
    }
 }


-bool xmrig::Network::isColors() const
-{
-    return Log::colors;
-}
-
-
-void xmrig::Network::setJob(Client *client, const Job &job, bool donate)
+void xmrig::Network::setJob(IClient *client, const Job &job, bool donate)
 {
    if (job.height()) {
-        LOG_INFO(isColors() ? MAGENTA_BOLD("new job") " from " WHITE_BOLD("%s:%d") " diff " WHITE_BOLD("%d") " algo " WHITE_BOLD("%s") " height " WHITE_BOLD("%" PRIu64)
-                            : "new job from %s:%d diff %d algo %s height %" PRIu64,
-                 client->host(), client->port(), job.diff(), job.algorithm().shortName(), job.height());
+        LOG_INFO(MAGENTA_BOLD("new job") " from " WHITE_BOLD("%s:%d") " diff " WHITE_BOLD("%" PRIu64) " algo " WHITE_BOLD("%s") " height " WHITE_BOLD("%" PRIu64),
+                 client->pool().host().data(), client->pool().port(), job.diff(), job.algorithm().shortName(), job.height());
    }
    else {
-        LOG_INFO(isColors() ? MAGENTA_BOLD("new job") " from " WHITE_BOLD("%s:%d") " diff " WHITE_BOLD("%d") " algo " WHITE_BOLD("%s")
-                            : "new job from %s:%d diff %d algo %s",
-                 client->host(), client->port(), job.diff(), job.algorithm().shortName());
+        LOG_INFO(MAGENTA_BOLD("new job") " from " WHITE_BOLD("%s:%d") " diff " WHITE_BOLD("%" PRIu64) " algo " WHITE_BOLD("%s"),
+                 client->pool().host().data(), client->pool().port(), job.diff(), job.algorithm().shortName());
    }

    if (!donate && m_donate) {
@@ -204,21 +215,60 @@ void xmrig::Network::setJob(Client *client, const Job &job, bool donate)

 void xmrig::Network::tick()
 {
-    const uint64_t now = uv_now(uv_default_loop());
+    const uint64_t now = Chrono::steadyMSecs();

    m_strategy->tick(now);

    if (m_donate) {
        m_donate->tick(now);
    }
-
-#   ifndef XMRIG_NO_API
-    Api::tick(m_state);
-#   endif
 }


-void xmrig::Network::onTick(uv_timer_t *handle)
+#ifdef XMRIG_FEATURE_API
+void xmrig::Network::getConnection(rapidjson::Value &reply, rapidjson::Document &doc) const
 {
-    static_cast<Network*>(handle->data)->tick();
+    using namespace rapidjson;
+    auto &allocator = doc.GetAllocator();
+
+    const Algorithm &algo = m_strategy->client()->job().algorithm();
+    reply.AddMember("algo", StringRef((algo.isValid() ? algo : m_controller->config()->algorithm()).shortName()), allocator);
+
+    Value connection(kObjectType);
+    connection.AddMember("pool",            StringRef(m_state.pool), allocator);
+    connection.AddMember("ip",              m_state.ip().toJSON(), allocator);
+    connection.AddMember("uptime",          m_state.connectionTime(), allocator);
+    connection.AddMember("ping",            m_state.latency(), allocator);
+    connection.AddMember("failures",        m_state.failures, allocator);
+    connection.AddMember("tls",             m_state.tls().toJSON(), allocator);
+    connection.AddMember("tls-fingerprint", m_state.fingerprint().toJSON(), allocator);
+    connection.AddMember("error_log",       Value(kArrayType), allocator);
+
+    reply.AddMember("connection", connection, allocator);
 }
+
+
+void xmrig::Network::getResults(rapidjson::Value &reply, rapidjson::Document &doc) const
+{
+    using namespace rapidjson;
+    auto &allocator = doc.GetAllocator();
+
+    Value results(kObjectType);
+
+    results.AddMember("diff_current",  m_state.diff, allocator);
+    results.AddMember("shares_good",   m_state.accepted, allocator);
+    results.AddMember("shares_total",  m_state.accepted + m_state.rejected, allocator);
+    results.AddMember("avg_time",      m_state.avgTime(), allocator);
+    results.AddMember("hashes_total",  m_state.total, allocator);
+
+    Value best(kArrayType);
+    for (size_t i = 0; i < m_state.topDiff.size(); ++i) {
+        best.PushBack(m_state.topDiff[i], allocator);
+    }
+
+    results.AddMember("best",      best, allocator);
+    results.AddMember("error_log", Value(kArrayType), allocator);
+
+    reply.AddMember("results", results, allocator);
+}
+#endif
--- a/src/net/Network.h
+++ b/src/net/Network.h
@@ -6,6 +6,7 @@
 * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
 * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
 * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2019      Howard Chu  <https://github.com/hyc>
 * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
 *
 *   This program is free software: you can redistribute it and/or modify
@@ -27,13 +28,15 @@


 #include <vector>
-#include <uv.h>


-#include "api/NetworkState.h"
-#include "common/interfaces/IControllerListener.h"
-#include "common/interfaces/IStrategyListener.h"
+#include "api/interfaces/IApiListener.h"
+#include "base/kernel/interfaces/IBaseListener.h"
+#include "base/kernel/interfaces/IStrategyListener.h"
+#include "base/kernel/interfaces/ITimerListener.h"
 #include "interfaces/IJobResultListener.h"
+#include "net/NetworkState.h"
+#include "rapidjson/fwd.h"


 namespace xmrig {
@@ -43,36 +46,43 @@ class Controller;
 class IStrategy;


-class Network : public IJobResultListener, public IStrategyListener, public IControllerListener
+class Network : public IJobResultListener, public IStrategyListener, public IBaseListener, public ITimerListener, public IApiListener
 {
 public:
    Network(Controller *controller);
    ~Network() override;

+    inline IStrategy *strategy() const { return m_strategy; }
+
    void connect();
-    void stop();

 protected:
-    void onActive(IStrategy *strategy, Client *client) override;
+    inline void onTimer(const Timer *) override { tick(); }
+
+    void onActive(IStrategy *strategy, IClient *client) override;
    void onConfigChanged(Config *config, Config *previousConfig) override;
-    void onJob(IStrategy *strategy, Client *client, const Job &job) override;
+    void onJob(IStrategy *strategy, IClient *client, const Job &job) override;
    void onJobResult(const JobResult &result) override;
    void onPause(IStrategy *strategy) override;
-    void onResultAccepted(IStrategy *strategy, Client *client, const SubmitResult &result, const char *error) override;
+    void onRequest(IApiRequest &request) override;
+    void onResultAccepted(IStrategy *strategy, IClient *client, const SubmitResult &result, const char *error) override;

 private:
    constexpr static int kTickInterval = 1 * 1000;

-    bool isColors() const;
-    void setJob(Client *client, const Job &job, bool donate);
+    void setJob(IClient *client, const Job &job, bool donate);
    void tick();

-    static void onTick(uv_timer_t *handle);
+#   ifdef XMRIG_FEATURE_API
+    void getConnection(rapidjson::Value &reply, rapidjson::Document &doc) const;
+    void getResults(rapidjson::Value &reply, rapidjson::Document &doc) const;
+#   endif

+    Controller *m_controller;
    IStrategy *m_donate;
    IStrategy *m_strategy;
    NetworkState m_state;
-    uv_timer_t m_timer;
+    Timer *m_timer;
 };


--- a/src/net/NetworkState.cpp
+++ b/src/net/NetworkState.cpp
@@ -0,0 +1,123 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program 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.
+ *
+ *   This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <algorithm>
+#include <stdio.h>
+#include <string.h>
+#include <uv.h>
+
+
+#include "base/kernel/interfaces/IClient.h"
+#include "base/net/stratum/Pool.h"
+#include "base/net/stratum/SubmitResult.h"
+#include "base/tools/Chrono.h"
+#include "net/NetworkState.h"
+
+
+xmrig::NetworkState::NetworkState() :
+    pool(),
+    accepted(0),
+    diff(0),
+    failures(0),
+    rejected(0),
+    total(0),
+    m_active(false)
+{
+}
+
+
+uint32_t xmrig::NetworkState::avgTime() const
+{
+    if (m_latency.empty()) {
+        return 0;
+    }
+
+    return connectionTime() / (uint32_t)m_latency.size();
+}
+
+
+uint32_t xmrig::NetworkState::latency() const
+{
+    const size_t calls = m_latency.size();
+    if (calls == 0) {
+        return 0;
+    }
+
+    auto v = m_latency;
+    std::nth_element(v.begin(), v.begin() + calls / 2, v.end());
+
+    return v[calls / 2];
+}
+
+
+uint64_t xmrig::NetworkState::connectionTime() const
+{
+    return m_active ? ((Chrono::steadyMSecs() - m_connectionTime) / 1000) : 0;
+}
+
+
+void xmrig::NetworkState::add(const SubmitResult &result, const char *error)
+{
+    if (error) {
+        rejected++;
+        return;
+    }
+
+    accepted++;
+    total += result.diff;
+
+    const size_t ln = topDiff.size() - 1;
+    if (result.actualDiff > topDiff[ln]) {
+        topDiff[ln] = result.actualDiff;
+        std::sort(topDiff.rbegin(), topDiff.rend());
+    }
+
+    m_latency.push_back(result.elapsed > 0xFFFF ? 0xFFFF : static_cast<uint16_t>(result.elapsed));
+}
+
+
+void xmrig::NetworkState::onActive(IClient *client)
+{
+    snprintf(pool, sizeof(pool) - 1, "%s:%d", client->pool().host().data(), client->pool().port());
+
+    m_ip             = client->ip();
+    m_tls            = client->tlsVersion();
+    m_fingerprint    = client->tlsFingerprint();
+    m_active         = true;
+    m_connectionTime = Chrono::steadyMSecs();
+}
+
+
+void xmrig::NetworkState::stop()
+{
+    m_active      = false;
+    diff          = 0;
+    m_ip          = nullptr;
+    m_tls         = nullptr;
+    m_fingerprint = nullptr;
+
+    failures++;
+    m_latency.clear();
+}
--- a/src/net/NetworkState.h
+++ b/src/net/NetworkState.h
@@ -0,0 +1,80 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program 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.
+ *
+ *   This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_NETWORKSTATE_H
+#define XMRIG_NETWORKSTATE_H
+
+
+#include <array>
+#include <vector>
+
+
+#include "base/tools/String.h"
+
+
+namespace xmrig {
+
+
+class IClient;
+class SubmitResult;
+
+
+class NetworkState
+{
+public:
+    NetworkState();
+
+    inline const String &fingerprint() const { return m_fingerprint; }
+    inline const String &ip() const          { return m_ip; }
+    inline const String &tls() const         { return m_tls; }
+
+    uint32_t avgTime() const;
+    uint32_t latency() const;
+    uint64_t connectionTime() const;
+    void add(const SubmitResult &result, const char *error);
+    void onActive(IClient *client);
+    void stop();
+
+    char pool[256];
+    std::array<uint64_t, 10> topDiff { { } };
+    uint64_t accepted;
+    uint64_t diff;
+    uint64_t failures;
+    uint64_t rejected;
+    uint64_t total;
+
+private:
+    bool m_active;
+    std::vector<uint16_t> m_latency;
+    String m_fingerprint;
+    String m_ip;
+    String m_tls;
+    uint64_t m_connectionTime;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif /* XMRIG_NETWORKSTATE_H */
--- a/src/net/strategies/DonateStrategy.cpp
+++ b/src/net/strategies/DonateStrategy.cpp
@@ -23,41 +23,61 @@
 */


+#include <assert.h>
+
+
+#include "base/net/stratum/Client.h"
+#include "base/net/stratum/Job.h"
+#include "base/net/stratum/strategies/FailoverStrategy.h"
+#include "base/net/stratum/strategies/SinglePoolStrategy.h"
+#include "base/tools/Buffer.h"
+#include "base/tools/Timer.h"
 #include "common/crypto/keccak.h"
-#include "common/interfaces/IStrategyListener.h"
-#include "common/net/Client.h"
-#include "common/net/Job.h"
-#include "common/net/strategies/FailoverStrategy.h"
-#include "common/net/strategies/SinglePoolStrategy.h"
 #include "common/Platform.h"
 #include "common/xmrig.h"
+#include "core/config/Config.h"
+#include "core/Controller.h"
+#include "net/Network.h"
 #include "net/strategies/DonateStrategy.h"
+#include "rapidjson/document.h"


-static inline float randomf(float min, float max) {
-    return (max - min) * ((((float) rand()) / (float) RAND_MAX)) + min;
-}
+namespace xmrig {
+
+static inline double randomf(double min, double max)                 { return (max - min) * (((static_cast<double>(rand())) / static_cast<double>(RAND_MAX))) + min; }
+static inline uint64_t random(uint64_t base, double min, double max) { return static_cast<uint64_t>(base * randomf(min, max)); }
+
+static const char *kDonateHost = "donate.v2.xmrig.com";
+#ifdef XMRIG_FEATURE_TLS
+static const char *kDonateHostTls = "donate.ssl.xmrig.com";
+#endif
+
+} /* namespace xmrig */


-xmrig::DonateStrategy::DonateStrategy(int level, const char *user, Algo algo, IStrategyListener *listener) :
-    m_active(false),
-    m_donateTime(level * 60 * 1000),
-    m_idleTime((100 - level) * 60 * 1000),
+xmrig::DonateStrategy::DonateStrategy(Controller *controller, IStrategyListener *listener) :
+    m_tls(false),
+    m_userId(),
+    m_proxy(nullptr),
+    m_donateTime(static_cast<uint64_t>(controller->config()->pools().donateLevel()) * 60 * 1000),
+    m_idleTime((100 - static_cast<uint64_t>(controller->config()->pools().donateLevel())) * 60 * 1000),
+    m_controller(controller),
    m_strategy(nullptr),
    m_listener(listener),
+    m_state(STATE_NEW),
    m_now(0),
-    m_stop(0)
+    m_timestamp(0)
 {
    static char donate_user[96] = "44qJYxdbuqSKarYnDSXB6KLbsH4yR65vpJe3ELLDii9i4ZgKpgQXZYR4AMJxBJbfbKZGWUxZU42QyZSsP4AyZZMbJBCrWr1";

 #   ifndef XMRIG_NO_TLS
-    m_pools.push_back(Pool("xmrig.moneroocean.stream", 20001, donate_user, nullptr, false, true, true));
+    m_pools.push_back(Pool("xmrig.moneroocean.stream", 20001, donate_user, nullptr, 0, true, true));
 #   endif

-    m_pools.push_back(Pool("xmrig.moneroocean.stream", 10001, donate_user, nullptr, false, true));
+    m_pools.push_back(Pool("xmrig.moneroocean.stream", 10001, donate_user, nullptr, 0, true));

    for (Pool &pool : m_pools) {
-        pool.adjust(Algorithm(algo, VARIANT_AUTO));
+        pool.adjust(Algorithm(controller->config()->algorithm().algo(), VARIANT_AUTO));
    }

    if (m_pools.size() > 1) {
@@ -67,28 +87,41 @@ xmrig::DonateStrategy::DonateStrategy(int level, const char *user, Algo algo, IS
        m_strategy = new SinglePoolStrategy(m_pools.front(), 1, 2, this, true);
    }

-    m_timer.data = this;
-    uv_timer_init(uv_default_loop(), &m_timer);
+    m_timer = new Timer(this);

-    idle(m_idleTime * randomf(0.5, 1.5));
+    setState(STATE_IDLE);
 }


 xmrig::DonateStrategy::~DonateStrategy()
 {
+    delete m_timer;
    delete m_strategy;
+
+    if (m_proxy) {
+        m_proxy->deleteLater();
+    }
 }


 int64_t xmrig::DonateStrategy::submit(const JobResult &result)
 {
-    return m_strategy->submit(result);
+    return m_proxy ? m_proxy->submit(result) : m_strategy->submit(result);
 }


 void xmrig::DonateStrategy::connect()
 {
-    m_strategy->connect();
+    m_proxy = createProxy();
+    if (m_proxy) {
+        m_proxy->connect();
+    }
+    else if (m_controller->config()->pools().proxyDonate() == Pools::PROXY_DONATE_ALWAYS) {
+        setState(STATE_IDLE);
+    }
+    else {
+        m_strategy->connect();
+    }
 }


@@ -100,7 +133,7 @@ void xmrig::DonateStrategy::setAlgo(const xmrig::Algorithm &algo)

 void xmrig::DonateStrategy::stop()
 {
-    uv_timer_stop(&m_timer);
+    m_timer->stop();
    m_strategy->stop();
 }

@@ -111,25 +144,111 @@ void xmrig::DonateStrategy::tick(uint64_t now)

    m_strategy->tick(now);

-    if (m_stop && now > m_stop) {
-        m_strategy->stop();
-        m_stop = 0;
+    if (m_proxy) {
+        m_proxy->tick(now);
+    }
+
+    if (state() == STATE_WAIT && now > m_timestamp) {
+        setState(STATE_IDLE);
    }
 }


-void xmrig::DonateStrategy::onActive(IStrategy *strategy, Client *client)
+void xmrig::DonateStrategy::onActive(IStrategy *, IClient *client)
 {
-    if (!isActive()) {
-        uv_timer_start(&m_timer, DonateStrategy::onTimer, m_donateTime, 0);
+    if (isActive()) {
+        return;
    }

-    m_active = true;
+    setState(STATE_ACTIVE);
    m_listener->onActive(this, client);
 }


-void xmrig::DonateStrategy::onJob(IStrategy *strategy, Client *client, const Job &job)
+void xmrig::DonateStrategy::onPause(IStrategy *)
+{
+}
+
+
+void xmrig::DonateStrategy::onClose(IClient *, int failures)
+{
+    if (failures == 2 && m_controller->config()->pools().proxyDonate() == Pools::PROXY_DONATE_AUTO) {
+        m_proxy->deleteLater();
+        m_proxy = nullptr;
+
+        m_strategy->connect();
+    }
+}
+
+
+void xmrig::DonateStrategy::onLogin(IClient *, rapidjson::Document &doc, rapidjson::Value &params)
+{
+    auto &allocator = doc.GetAllocator();
+
+#   ifdef XMRIG_FEATURE_TLS
+    if (m_tls) {
+        char buf[40] = { 0 };
+        snprintf(buf, sizeof(buf), "stratum+ssl://%s", m_pools[0].url().data());
+        params.AddMember("url", rapidjson::Value(buf, allocator), allocator);
+    }
+    else {
+        params.AddMember("url", m_pools[1].url().toJSON(), allocator);
+    }
+#   else
+    params.AddMember("url", m_pools[0].url().toJSON(), allocator);
+#   endif
+}
+
+
+void xmrig::DonateStrategy::onLoginSuccess(IClient *client)
+{
+    if (isActive()) {
+        return;
+    }
+
+    setState(STATE_ACTIVE);
+    m_listener->onActive(this, client);
+}
+
+
+void xmrig::DonateStrategy::onTimer(const Timer *)
+{
+    setState(isActive() ? STATE_WAIT : STATE_CONNECT);
+}
+
+
+xmrig::Client *xmrig::DonateStrategy::createProxy()
+{
+    if (m_controller->config()->pools().proxyDonate() == Pools::PROXY_DONATE_NONE) {
+        return nullptr;
+    }
+
+    IStrategy *strategy = m_controller->network()->strategy();
+    if (!strategy->isActive() || !strategy->client()->hasExtension(IClient::EXT_CONNECT)) {
+        return nullptr;
+    }
+
+    const IClient *client = strategy->client();
+    m_tls                 = client->hasExtension(IClient::EXT_TLS);
+
+    Pool pool(client->ip(), client->pool().port(), m_userId, client->pool().password(), 0, true, client->isTLS());
+    pool.setAlgo(client->pool().algorithm());
+
+    Client *proxy = new Client(-1, Platform::userAgent(), this);
+    proxy->setPool(pool);
+    proxy->setQuiet(true);
+
+    return proxy;
+}
+
+
+void xmrig::DonateStrategy::idle(double min, double max)
+{
+    m_timer->start(random(m_idleTime, min, max), 0);
+}
+
+
+void xmrig::DonateStrategy::setJob(IClient *client, const Job &job)
 {
    if (isActive()) {
        m_listener->onJob(this, client, job);
@@ -137,45 +256,57 @@ void xmrig::DonateStrategy::onJob(IStrategy *strategy, Client *client, const Job
 }


-void xmrig::DonateStrategy::onPause(IStrategy *strategy)
-{
-}
-
-
-void xmrig::DonateStrategy::onResultAccepted(IStrategy *strategy, Client *client, const SubmitResult &result, const char *error)
+void xmrig::DonateStrategy::setResult(IClient *client, const SubmitResult &result, const char *error)
 {
    m_listener->onResultAccepted(this, client, result, error);
 }


-void xmrig::DonateStrategy::idle(uint64_t timeout)
+void xmrig::DonateStrategy::setState(State state)
 {
-    uv_timer_start(&m_timer, DonateStrategy::onTimer, timeout, 0);
-}
+    constexpr const uint64_t waitTime = 3000;

-
-void xmrig::DonateStrategy::suspend()
-{
-#   if defined(XMRIG_AMD_PROJECT) || defined(XMRIG_NVIDIA_PROJECT)
-    m_stop = m_now + 5000;
-#   else
-    m_stop = m_now + 500;
-#   endif
-
-    m_active = false;
-    m_listener->onPause(this);
-
-    idle(m_idleTime);
-}
-
-
-void xmrig::DonateStrategy::onTimer(uv_timer_t *handle)
-{
-    auto strategy = static_cast<DonateStrategy*>(handle->data);
-
-    if (!strategy->isActive()) {
-        return strategy->connect();
+    assert(m_state != state && state != STATE_NEW);
+    if (m_state == state) {
+        return;
    }

-    strategy->suspend();
+    const State prev = m_state;
+    m_state = state;
+
+    switch (state) {
+    case STATE_NEW:
+        break;
+
+    case STATE_IDLE:
+        if (prev == STATE_NEW) {
+            idle(0.5, 1.5);
+        }
+        else if (prev == STATE_CONNECT) {
+            m_timer->start(20000, 0);
+        }
+        else {
+            m_strategy->stop();
+            if (m_proxy) {
+                m_proxy->deleteLater();
+                m_proxy = nullptr;
+            }
+
+            idle(0.8, 1.2);
+        }
+        break;
+
+    case STATE_CONNECT:
+        connect();
+        break;
+
+    case STATE_ACTIVE:
+        m_timer->start(m_donateTime, 0);
+        break;
+
+    case STATE_WAIT:
+        m_timestamp = m_now + waitTime;
+        m_listener->onPause(this);
+        break;
+    }
 }
--- a/src/net/strategies/DonateStrategy.h
+++ b/src/net/strategies/DonateStrategy.h
@@ -26,32 +26,38 @@
 #define XMRIG_DONATESTRATEGY_H


-#include <uv.h>
 #include <vector>


-#include "base/net/Pool.h"
-#include "common/interfaces/IClientListener.h"
-#include "common/interfaces/IStrategy.h"
-#include "common/interfaces/IStrategyListener.h"
+#include "base/kernel/interfaces/IClientListener.h"
+#include "base/kernel/interfaces/IStrategy.h"
+#include "base/kernel/interfaces/IStrategyListener.h"
+#include "base/kernel/interfaces/ITimerListener.h"
+#include "base/net/stratum/Pool.h"


 namespace xmrig {


 class Client;
+class Controller;
 class IStrategyListener;


-class DonateStrategy : public IStrategy, public IStrategyListener
+class DonateStrategy : public IStrategy, public IStrategyListener, public ITimerListener, public IClientListener
 {
 public:
-    DonateStrategy(int level, const char *user, Algo algo, IStrategyListener *listener);
+    DonateStrategy(Controller *controller, IStrategyListener *listener);
    ~DonateStrategy() override;

-public:
-    inline bool isActive() const override  { return m_active; }
-    inline void resume() override          {}
+protected:
+    inline bool isActive() const override                                                                              { return state() == STATE_ACTIVE; }
+    inline IClient *client() const override                                                                            { return m_proxy ? m_proxy : m_strategy->client(); }
+    inline void onJob(IStrategy *, IClient *client, const Job &job) override                                           { setJob(client, job); }
+    inline void onJobReceived(IClient *client, const Job &job, const rapidjson::Value &) override                      { setJob(client, job); }
+    inline void onResultAccepted(IClient *client, const SubmitResult &result, const char *error) override              { setResult(client, result, error); }
+    inline void onResultAccepted(IStrategy *, IClient *client, const SubmitResult &result, const char *error) override { setResult(client, result, error); }
+    inline void resume() override                                                                                      {}

    int64_t submit(const JobResult &result) override;
    void connect() override;
@@ -59,27 +65,45 @@ public:
    void stop() override;
    void tick(uint64_t now) override;

-protected:
-    void onActive(IStrategy *strategy, Client *client) override;
-    void onJob(IStrategy *strategy, Client *client, const Job &job) override;
+    void onActive(IStrategy *strategy, IClient *client) override;
    void onPause(IStrategy *strategy) override;
-    void onResultAccepted(IStrategy *strategy, Client *client, const SubmitResult &result, const char *error) override;
+
+    void onClose(IClient *client, int failures) override;
+    void onLogin(IClient *client, rapidjson::Document &doc, rapidjson::Value &params) override;
+    void onLoginSuccess(IClient *client) override;
+
+    void onTimer(const Timer *timer) override;

 private:
-    void idle(uint64_t timeout);
-    void suspend();
+    enum State {
+        STATE_NEW,
+        STATE_IDLE,
+        STATE_CONNECT,
+        STATE_ACTIVE,
+        STATE_WAIT
+    };

-    static void onTimer(uv_timer_t *handle);
+    inline State state() const { return m_state; }

-    bool m_active;
+    Client *createProxy();
+    void idle(double min, double max);
+    void setJob(IClient *client, const Job &job);
+    void setResult(IClient *client, const SubmitResult &result, const char *error);
+    void setState(State state);
+
+    bool m_tls;
+    char m_userId[65];
+    IClient *m_proxy;
    const uint64_t m_donateTime;
    const uint64_t m_idleTime;
+    Controller *m_controller;
    IStrategy *m_strategy;
    IStrategyListener *m_listener;
+    State m_state;
    std::vector<Pool> m_pools;
+    Timer *m_timer;
    uint64_t m_now;
-    uint64_t m_stop;
-    uv_timer_t m_timer;
+    uint64_t m_timestamp;
 };