v6.14.1

Merge branch 'dev'
Update CHANGELOG.md
2025-12-07 16:05:05 -05:00 · 2021-08-15 00:42:47 +07:00 · 2021-08-15 00:42:12 +07:00 · 2021-08-15 00:37:23 +07:00 · 2021-08-14 05:48:37 +07:00 · 2021-08-14 04:58:01 +07:00
62 changed files with 7221 additions and 6829 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,16 @@
+# v6.14.1
+- [#2532](https://github.com/xmrig/xmrig/pull/2532) Refactoring: stable (persistent) algorithms IDs.
+- [#2537](https://github.com/xmrig/xmrig/pull/2537) Fixed Termux build.
+
+# v6.14.0
+- [#2484](https://github.com/xmrig/xmrig/pull/2484) Added ZeroMQ support for solo mining.
+- [#2476](https://github.com/xmrig/xmrig/issues/2476) Fixed crash in DMI memory reader.
+- [#2492](https://github.com/xmrig/xmrig/issues/2492) Added missing `--huge-pages-jit` command line option.
+- [#2512](https://github.com/xmrig/xmrig/pull/2512) Added show the number of transactions in pool job.
+
+# v6.13.1
+- [#2468](https://github.com/xmrig/xmrig/pull/2468) Fixed regression in previous version: don't send miner signature during regular mining.
+
 # v6.13.0
 - [#2445](https://github.com/xmrig/xmrig/pull/2445) Added support for solo mining with miner signatures for the upcoming Wownero fork.

--- a/src/backend/common/Threads.cpp
+++ b/src/backend/common/Threads.cpp
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -22,7 +16,6 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-
 #include "backend/common/Threads.h"
 #include "3rdparty/rapidjson/document.h"
 #include "backend/cpu/CpuThreads.h"
@@ -43,7 +36,6 @@ namespace xmrig {


 static const char *kAsterisk = "*";
-static const char *kCn2      = "cn/2";


 } // namespace xmrig
@@ -112,7 +104,7 @@ xmrig::String xmrig::Threads<T>::profileName(const Algorithm &algorithm, bool st
        return String();
    }

-    const String name = algorithm.shortName();
+    const String name = algorithm.name();
    if (has(name)) {
        return name;
    }
@@ -125,8 +117,8 @@ xmrig::String xmrig::Threads<T>::profileName(const Algorithm &algorithm, bool st
        return String();
    }

-    if (algorithm.family() == Algorithm::CN && CnAlgo<>::base(algorithm) == Algorithm::CN_2 && has(kCn2)) {
-        return kCn2;
+    if (algorithm.family() == Algorithm::CN && algorithm.base() == Algorithm::CN_2 && has(Algorithm::kCN_2)) {
+        return Algorithm::kCN_2;
    }

    if (name.contains("/")) {
@@ -155,11 +147,11 @@ void xmrig::Threads<T>::toJSON(rapidjson::Value &out, rapidjson::Document &doc)
    }

    for (const Algorithm &algo : m_disabled) {
-        out.AddMember(StringRef(algo.shortName()), false, allocator);
+        out.AddMember(StringRef(algo.name()), false, allocator);
    }

    for (const auto &kv : m_aliases) {
-        out.AddMember(StringRef(kv.first.shortName()), kv.second.toJSON(), allocator);
+        out.AddMember(StringRef(kv.first.name()), kv.second.toJSON(), allocator);
    }
 }

--- a/src/backend/common/Threads.h
+++ b/src/backend/common/Threads.h
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -22,6 +16,7 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

+
 #ifndef XMRIG_THREADS_H
 #define XMRIG_THREADS_H

@@ -45,7 +40,7 @@ public:
    inline bool has(const char *profile) const                                         { return m_profiles.count(profile) > 0; }
    inline bool isDisabled(const Algorithm &algo) const                                { return m_disabled.count(algo) > 0; }
    inline bool isEmpty() const                                                        { return m_profiles.empty(); }
-    inline bool isExist(const Algorithm &algo) const                                   { return isDisabled(algo) || m_aliases.count(algo) > 0 || has(algo.shortName()); }
+    inline bool isExist(const Algorithm &algo) const                                   { return isDisabled(algo) || m_aliases.count(algo) > 0 || has(algo.name()); }
    inline const T &get(const Algorithm &algo, bool strict = false) const              { return get(profileName(algo, strict)); }
    inline void disable(const Algorithm &algo)                                         { m_disabled.insert(algo); }
    inline void setAlias(const Algorithm &algo, const char *profile)                   { m_aliases[algo] = profile; }
--- a/src/backend/cpu/CpuBackend.cpp
+++ b/src/backend/cpu/CpuBackend.cpp
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -22,7 +16,6 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-
 #include <mutex>


@@ -297,7 +290,7 @@ const xmrig::String &xmrig::CpuBackend::type() const
 void xmrig::CpuBackend::prepare(const Job &nextJob)
 {
 #   ifdef XMRIG_ALGO_ARGON2
-    const xmrig::Algorithm::Family f = nextJob.algorithm().family();
+    const auto f = nextJob.algorithm().family();
    if ((f == Algorithm::ARGON2) || (f == Algorithm::RANDOM_X)) {
        if (argon2::Impl::select(d_ptr->controller->config()->cpu().argon2Impl())) {
            LOG_INFO("%s use " WHITE_BOLD("argon2") " implementation " CSI "1;%dm" "%s",
--- a/src/backend/cpu/CpuBackend.h
+++ b/src/backend/cpu/CpuBackend.h
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
--- a/src/backend/cpu/CpuConfig_gen.h
+++ b/src/backend/cpu/CpuConfig_gen.h
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -53,7 +47,7 @@ size_t inline generate<Algorithm::CN>(Threads<CpuThreads> &threads, uint32_t lim
 {
    size_t count = 0;

-    count += generate("cn", threads, Algorithm::CN_1, limit);
+    count += generate(Algorithm::kCN, threads, Algorithm::CN_1, limit);

    if (!threads.isExist(Algorithm::CN_0)) {
        threads.disable(Algorithm::CN_0);
@@ -70,7 +64,7 @@ size_t inline generate<Algorithm::CN_LITE>(Threads<CpuThreads> &threads, uint32_
 {
    size_t count = 0;

-    count += generate("cn-lite", threads, Algorithm::CN_LITE_1, limit);
+    count += generate(Algorithm::kCN_LITE, threads, Algorithm::CN_LITE_1, limit);

    if (!threads.isExist(Algorithm::CN_LITE_0)) {
        threads.disable(Algorithm::CN_LITE_0);
@@ -86,7 +80,7 @@ size_t inline generate<Algorithm::CN_LITE>(Threads<CpuThreads> &threads, uint32_
 template<>
 size_t inline generate<Algorithm::CN_HEAVY>(Threads<CpuThreads> &threads, uint32_t limit)
 {
-    return generate("cn-heavy", threads, Algorithm::CN_HEAVY_0, limit);
+    return generate(Algorithm::kCN_HEAVY, threads, Algorithm::CN_HEAVY_0, limit);
 }
 #endif

@@ -95,7 +89,7 @@ size_t inline generate<Algorithm::CN_HEAVY>(Threads<CpuThreads> &threads, uint32
 template<>
 size_t inline generate<Algorithm::CN_PICO>(Threads<CpuThreads> &threads, uint32_t limit)
 {
-    return generate("cn-pico", threads, Algorithm::CN_PICO_0, limit);
+    return generate(Algorithm::kCN_PICO, threads, Algorithm::CN_PICO_0, limit);
 }
 #endif

@@ -104,7 +98,7 @@ size_t inline generate<Algorithm::CN_PICO>(Threads<CpuThreads> &threads, uint32_
 template<>
 size_t inline generate<Algorithm::CN_FEMTO>(Threads<CpuThreads>& threads, uint32_t limit)
 {
-    return generate("cn/upx2", threads, Algorithm::CN_UPX2, limit);
+    return generate(Algorithm::kCN_UPX2, threads, Algorithm::CN_UPX2, limit);
 }
 #endif

@@ -120,30 +114,30 @@ size_t inline generate<Algorithm::RANDOM_X>(Threads<CpuThreads> &threads, uint32
    if (!threads.isExist(Algorithm::RX_ARQ)) {
        auto arq = cpuInfo->threads(Algorithm::RX_ARQ, limit);
        if (arq == wow) {
-            threads.setAlias(Algorithm::RX_ARQ, "rx/wow");
+            threads.setAlias(Algorithm::RX_ARQ, Algorithm::kRX_WOW);
            ++count;
        }
        else {
-            count += threads.move("rx/arq", std::move(arq));
+            count += threads.move(Algorithm::kRX_ARQ, std::move(arq));
        }
    }

    if (!threads.isExist(Algorithm::RX_KEVA)) {
        auto keva = cpuInfo->threads(Algorithm::RX_KEVA, limit);
        if (keva == wow) {
-            threads.setAlias(Algorithm::RX_KEVA, "rx/wow");
+            threads.setAlias(Algorithm::RX_KEVA, Algorithm::kRX_WOW);
            ++count;
        }
        else {
-            count += threads.move("rx/keva", std::move(keva));
+            count += threads.move(Algorithm::kRX_KEVA, std::move(keva));
        }
    }

    if (!threads.isExist(Algorithm::RX_WOW)) {
-        count += threads.move("rx/wow", std::move(wow));
+        count += threads.move(Algorithm::kRX_WOW, std::move(wow));
    }

-    count += generate("rx", threads, Algorithm::RX_0, limit);
+    count += generate(Algorithm::kRX, threads, Algorithm::RX_0, limit);

    return count;
 }
@@ -154,7 +148,7 @@ size_t inline generate<Algorithm::RANDOM_X>(Threads<CpuThreads> &threads, uint32
 template<>
 size_t inline generate<Algorithm::ARGON2>(Threads<CpuThreads> &threads, uint32_t limit)
 {
-    return generate("argon2", threads, Algorithm::AR2_CHUKWA_V2, limit);
+    return generate(Algorithm::kAR2, threads, Algorithm::AR2_CHUKWA_V2, limit);
 }
 #endif

@@ -163,7 +157,7 @@ size_t inline generate<Algorithm::ARGON2>(Threads<CpuThreads> &threads, uint32_t
 template<>
 size_t inline generate<Algorithm::ASTROBWT>(Threads<CpuThreads>& threads, uint32_t limit)
 {
-    return generate("astrobwt", threads, Algorithm::ASTROBWT_DERO, limit);
+    return generate(Algorithm::kASTROBWT, threads, Algorithm::ASTROBWT_DERO, limit);
 }
 #endif

--- a/src/backend/cpu/CpuWorker.cpp
+++ b/src/backend/cpu/CpuWorker.cpp
@@ -329,7 +329,7 @@ void xmrig::CpuWorker<N>::start()
                    else
 #                   endif
                    if (value < job.target()) {
-                        JobResults::submit(job, current_job_nonces[i], m_hash + (i * 32), miner_signature_saved);
+                        JobResults::submit(job, current_job_nonces[i], m_hash + (i * 32), job.hasMinerSignature() ? miner_signature_saved : nullptr);
                    }
                }
                m_count += N;
--- a/src/backend/cpu/platform/BasicCpuInfo.cpp
+++ b/src/backend/cpu/platform/BasicCpuInfo.cpp
@@ -309,7 +309,7 @@ xmrig::CpuThreads xmrig::BasicCpuInfo::threads(const Algorithm &algorithm, uint3
        return 1;
    }

-    Algorithm::Family f = algorithm.family();
+    const auto f = algorithm.family();

 #   ifdef XMRIG_ALGO_CN_LITE
    if (f == Algorithm::CN_LITE) {
--- a/src/backend/cpu/platform/HwlocCpuInfo.cpp
+++ b/src/backend/cpu/platform/HwlocCpuInfo.cpp
@@ -16,7 +16,6 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-
 #ifdef XMRIG_HWLOC_DEBUG
 #   include <uv.h>
 #endif
@@ -259,7 +258,7 @@ xmrig::CpuThreads xmrig::HwlocCpuInfo::threads(const Algorithm &algorithm, uint3
    }

    if (threads.isEmpty()) {
-        LOG_WARN("hwloc auto configuration for algorithm \"%s\" failed.", algorithm.shortName());
+        LOG_WARN("hwloc auto configuration for algorithm \"%s\" failed.", algorithm.name());

        return BasicCpuInfo::threads(algorithm, limit);
    }
@@ -336,7 +335,7 @@ void xmrig::HwlocCpuInfo::processTopLevelCache(hwloc_obj_t cache, const Algorith

    size_t cacheHashes = ((L3 + extra) + (scratchpad / 2)) / scratchpad;

-    Algorithm::Family family = algorithm.family();
+    const auto family = algorithm.family();
    if (intensity && ((family == Algorithm::CN_PICO) || (family == Algorithm::CN_FEMTO)) && (cacheHashes / PUs) >= 2) {
        intensity = 2;
    }
--- a/src/backend/cuda/CudaConfig_gen.h
+++ b/src/backend/cuda/CudaConfig_gen.h
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -56,8 +50,8 @@ size_t inline generate<Algorithm::CN>(Threads<CudaThreads> &threads, const std::
 {
    size_t count = 0;

-    count += generate("cn", threads, Algorithm::CN_1, devices);
-    count += generate("cn/2", threads, Algorithm::CN_2, devices);
+    count += generate(Algorithm::kCN, threads, Algorithm::CN_1, devices);
+    count += generate(Algorithm::kCN_2, threads, Algorithm::CN_2, devices);

    if (!threads.isExist(Algorithm::CN_0)) {
        threads.disable(Algorithm::CN_0);
@@ -72,7 +66,7 @@ size_t inline generate<Algorithm::CN>(Threads<CudaThreads> &threads, const std::
 template<>
 size_t inline generate<Algorithm::CN_LITE>(Threads<CudaThreads> &threads, const std::vector<CudaDevice> &devices)
 {
-    size_t count = generate("cn-lite", threads, Algorithm::CN_LITE_1, devices);
+    size_t count = generate(Algorithm::kCN_LITE, threads, Algorithm::CN_LITE_1, devices);

    if (!threads.isExist(Algorithm::CN_LITE_0)) {
        threads.disable(Algorithm::CN_LITE_0);
@@ -88,7 +82,7 @@ size_t inline generate<Algorithm::CN_LITE>(Threads<CudaThreads> &threads, const
 template<>
 size_t inline generate<Algorithm::CN_HEAVY>(Threads<CudaThreads> &threads, const std::vector<CudaDevice> &devices)
 {
-    return generate("cn-heavy", threads, Algorithm::CN_HEAVY_0, devices);
+    return generate(Algorithm::kCN_HEAVY, threads, Algorithm::CN_HEAVY_0, devices);
 }
 #endif

@@ -97,7 +91,7 @@ size_t inline generate<Algorithm::CN_HEAVY>(Threads<CudaThreads> &threads, const
 template<>
 size_t inline generate<Algorithm::CN_PICO>(Threads<CudaThreads> &threads, const std::vector<CudaDevice> &devices)
 {
-    return generate("cn-pico", threads, Algorithm::CN_PICO_0, devices);
+    return generate(Algorithm::kCN_PICO, threads, Algorithm::CN_PICO_0, devices);
 }
 #endif

@@ -106,7 +100,7 @@ size_t inline generate<Algorithm::CN_PICO>(Threads<CudaThreads> &threads, const
 template<>
 size_t inline generate<Algorithm::CN_FEMTO>(Threads<CudaThreads>& threads, const std::vector<CudaDevice>& devices)
 {
-    return generate("cn/upx2", threads, Algorithm::CN_UPX2, devices);
+    return generate(Algorithm::kCN_UPX2, threads, Algorithm::CN_UPX2, devices);
 }
 #endif

@@ -123,18 +117,18 @@ size_t inline generate<Algorithm::RANDOM_X>(Threads<CudaThreads> &threads, const
    auto kva = CudaThreads(devices, Algorithm::RX_KEVA);

    if (!threads.isExist(Algorithm::RX_WOW) && wow != rx) {
-        count += threads.move("rx/wow", std::move(wow));
+        count += threads.move(Algorithm::kRX_WOW, std::move(wow));
    }

    if (!threads.isExist(Algorithm::RX_ARQ) && arq != rx) {
-        count += threads.move("rx/arq", std::move(arq));
+        count += threads.move(Algorithm::kRX_ARQ, std::move(arq));
    }

    if (!threads.isExist(Algorithm::RX_KEVA) && kva != rx) {
-        count += threads.move("rx/keva", std::move(kva));
+        count += threads.move(Algorithm::kRX_KEVA, std::move(kva));
    }

-    count += threads.move("rx", std::move(rx));
+    count += threads.move(Algorithm::kRX, std::move(rx));

    return count;
 }
@@ -145,7 +139,7 @@ size_t inline generate<Algorithm::RANDOM_X>(Threads<CudaThreads> &threads, const
 template<>
 size_t inline generate<Algorithm::ASTROBWT>(Threads<CudaThreads> &threads, const std::vector<CudaDevice> &devices)
 {
-    return generate("astrobwt", threads, Algorithm::ASTROBWT_DERO, devices);
+    return generate(Algorithm::kASTROBWT, threads, Algorithm::ASTROBWT_DERO, devices);
 }
 #endif

@@ -154,7 +148,7 @@ size_t inline generate<Algorithm::ASTROBWT>(Threads<CudaThreads> &threads, const
 template<>
 size_t inline generate<Algorithm::KAWPOW>(Threads<CudaThreads> &threads, const std::vector<CudaDevice> &devices)
 {
-    return generate("kawpow", threads, Algorithm::KAWPOW_RVN, devices);
+    return generate(Algorithm::kKAWPOW, threads, Algorithm::KAWPOW_RVN, devices);
 }
 #endif

--- a/src/backend/cuda/wrappers/CudaLib.cpp
+++ b/src/backend/cuda/wrappers/CudaLib.cpp
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -22,7 +16,6 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

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

@@ -199,7 +192,7 @@ bool xmrig::CudaLib::deviceInfo(nvid_ctx *ctx, int32_t blocks, int32_t threads,
 {
    const Algorithm algo = RxAlgo::id(algorithm);

-    return pDeviceInfo_v2(ctx, blocks, threads, algo.isValid() ? algo.shortName() : nullptr, dataset_host);
+    return pDeviceInfo_v2(ctx, blocks, threads, algo.isValid() ? algo.name() : nullptr, dataset_host);
 }


@@ -243,7 +236,7 @@ bool xmrig::CudaLib::setJob(nvid_ctx *ctx, const void *data, size_t size, const
 {
    const Algorithm algo = RxAlgo::id(algorithm);

-    return pSetJob_v2(ctx, data, size, algo.shortName());
+    return pSetJob_v2(ctx, data, size, algo.name());
 }


--- a/src/backend/cuda/wrappers/CudaLib.h
+++ b/src/backend/cuda/wrappers/CudaLib.h
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
--- a/src/backend/opencl/OclConfig_gen.h
+++ b/src/backend/opencl/OclConfig_gen.h
@@ -1,12 +1,6 @@
 /* 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>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -55,8 +49,8 @@ size_t inline generate<Algorithm::CN>(Threads<OclThreads> &threads, const std::v
 {
    size_t count = 0;

-    count += generate("cn", threads, Algorithm::CN_1, devices);
-    count += generate("cn/2", threads, Algorithm::CN_2, devices);
+    count += generate(Algorithm::kCN, threads, Algorithm::CN_1, devices);
+    count += generate(Algorithm::kCN_2, threads, Algorithm::CN_2, devices);

    if (!threads.isExist(Algorithm::CN_0)) {
        threads.disable(Algorithm::CN_0);
@@ -71,7 +65,7 @@ size_t inline generate<Algorithm::CN>(Threads<OclThreads> &threads, const std::v
 template<>
 size_t inline generate<Algorithm::CN_LITE>(Threads<OclThreads> &threads, const std::vector<OclDevice> &devices)
 {
-    size_t count = generate("cn-lite", threads, Algorithm::CN_LITE_1, devices);
+    size_t count = generate(Algorithm::kCN_LITE, threads, Algorithm::CN_LITE_1, devices);

    if (!threads.isExist(Algorithm::CN_LITE_0)) {
        threads.disable(Algorithm::CN_LITE_0);
@@ -87,7 +81,7 @@ size_t inline generate<Algorithm::CN_LITE>(Threads<OclThreads> &threads, const s
 template<>
 size_t inline generate<Algorithm::CN_HEAVY>(Threads<OclThreads> &threads, const std::vector<OclDevice> &devices)
 {
-    return generate("cn-heavy", threads, Algorithm::CN_HEAVY_0, devices);
+    return generate(Algorithm::kCN_HEAVY, threads, Algorithm::CN_HEAVY_0, devices);
 }
 #endif

@@ -96,7 +90,7 @@ size_t inline generate<Algorithm::CN_HEAVY>(Threads<OclThreads> &threads, const
 template<>
 size_t inline generate<Algorithm::CN_PICO>(Threads<OclThreads> &threads, const std::vector<OclDevice> &devices)
 {
-    return generate("cn-pico", threads, Algorithm::CN_PICO_0, devices);
+    return generate(Algorithm::kCN_PICO, threads, Algorithm::CN_PICO_0, devices);
 }
 #endif

@@ -105,7 +99,7 @@ size_t inline generate<Algorithm::CN_PICO>(Threads<OclThreads> &threads, const s
 template<>
 size_t inline generate<Algorithm::CN_FEMTO>(Threads<OclThreads>& threads, const std::vector<OclDevice>& devices)
 {
-    return generate("cn/upx2", threads, Algorithm::CN_UPX2, devices);
+    return generate(Algorithm::kCN_UPX2, threads, Algorithm::CN_UPX2, devices);
 }
 #endif

@@ -121,14 +115,14 @@ size_t inline generate<Algorithm::RANDOM_X>(Threads<OclThreads> &threads, const
    auto arq = OclThreads(devices, Algorithm::RX_ARQ);

    if (!threads.isExist(Algorithm::RX_WOW) && wow != rx) {
-        count += threads.move("rx/wow", std::move(wow));
+        count += threads.move(Algorithm::kRX_WOW, std::move(wow));
    }

    if (!threads.isExist(Algorithm::RX_ARQ) && arq != rx) {
-        count += threads.move("rx/arq", std::move(arq));
+        count += threads.move(Algorithm::kRX_ARQ, std::move(arq));
    }

-    count += threads.move("rx", std::move(rx));
+    count += threads.move(Algorithm::kRX, std::move(rx));

    return count;
 }
@@ -139,7 +133,7 @@ size_t inline generate<Algorithm::RANDOM_X>(Threads<OclThreads> &threads, const
 template<>
 size_t inline generate<Algorithm::ASTROBWT>(Threads<OclThreads>& threads, const std::vector<OclDevice>& devices)
 {
-    return generate("astrobwt", threads, Algorithm::ASTROBWT_DERO, devices);
+    return generate(Algorithm::kASTROBWT, threads, Algorithm::ASTROBWT_DERO, devices);
 }
 #endif

@@ -148,7 +142,7 @@ size_t inline generate<Algorithm::ASTROBWT>(Threads<OclThreads>& threads, const
 template<>
 size_t inline generate<Algorithm::KAWPOW>(Threads<OclThreads>& threads, const std::vector<OclDevice>& devices)
 {
-    return generate("kawpow", threads, Algorithm::KAWPOW_RVN, devices);
+    return generate(Algorithm::kKAWPOW, threads, Algorithm::KAWPOW_RVN, devices);
 }
 #endif

--- a/src/backend/opencl/cl/cn/algorithm.cl
+++ b/src/backend/opencl/cl/cn/algorithm.cl
@@ -1,40 +1,41 @@
-#define ALGO_CN_0           0
-#define ALGO_CN_1           1
-#define ALGO_CN_2           2
-#define ALGO_CN_R           3
-#define ALGO_CN_FAST        4
-#define ALGO_CN_HALF        5
-#define ALGO_CN_XAO         6
-#define ALGO_CN_RTO         7
-#define ALGO_CN_RWZ         8
-#define ALGO_CN_ZLS         9
-#define ALGO_CN_DOUBLE      10
-#define ALGO_CN_LITE_0      11
-#define ALGO_CN_LITE_1      12
-#define ALGO_CN_HEAVY_0     13
-#define ALGO_CN_HEAVY_TUBE  14
-#define ALGO_CN_HEAVY_XHV   15
-#define ALGO_CN_PICO_0      16
-#define ALGO_CN_PICO_TLO    17
-#define ALGO_CN_CCX         18
-#define ALGO_CN_UPX2        19
-#define ALGO_RX_0           20
-#define ALGO_RX_WOW         21
-#define ALGO_RX_ARQMA       22
-#define ALGO_RX_SFX         23
-#define ALGO_RX_KEVA        24
-#define ALGO_AR2_CHUKWA     25
-#define ALGO_AR2_CHUKWA_V2  26
-#define ALGO_AR2_WRKZ       27
-#define ALGO_ASTROBWT_DERO  28
-#define ALGO_KAWPOW_RVN     29
+#define ALGO_CN_0           0x63150000
+#define ALGO_CN_1           0x63150100
+#define ALGO_CN_2           0x63150200
+#define ALGO_CN_R           0x63150272
+#define ALGO_CN_FAST        0x63150166
+#define ALGO_CN_HALF        0x63150268
+#define ALGO_CN_XAO         0x63150078
+#define ALGO_CN_RTO         0x63150172
+#define ALGO_CN_RWZ         0x63150277
+#define ALGO_CN_ZLS         0x6315027a
+#define ALGO_CN_DOUBLE      0x63150264
+#define ALGO_CN_CCX         0x63150063
+#define ALGO_CN_LITE_0      0x63140000
+#define ALGO_CN_LITE_1      0x63140100
+#define ALGO_CN_HEAVY_0     0x63160000
+#define ALGO_CN_HEAVY_TUBE  0x63160172
+#define ALGO_CN_HEAVY_XHV   0x63160068
+#define ALGO_CN_PICO_0      0x63120200
+#define ALGO_CN_PICO_TLO    0x63120274
+#define ALGO_CN_UPX2        0x63110200
+#define ALGO_RX_0           0x72151200
+#define ALGO_RX_WOW         0x72141177
+#define ALGO_RX_ARQMA       0x72121061
+#define ALGO_RX_SFX         0x72151273
+#define ALGO_RX_KEVA        0x7214116b
+#define ALGO_AR2_CHUKWA     0x61130000
+#define ALGO_AR2_CHUKWA_V2  0x61140000
+#define ALGO_AR2_WRKZ       0x61120000
+#define ALGO_ASTROBWT_DERO  0x41000000
+#define ALGO_KAWPOW_RVN     0x6b0f0000

 #define FAMILY_UNKNOWN      0
-#define FAMILY_CN           1
-#define FAMILY_CN_LITE      2
-#define FAMILY_CN_HEAVY     3
-#define FAMILY_CN_PICO      4
-#define FAMILY_RANDOM_X     5
-#define FAMILY_ARGON2       6
-#define FAMILY_ASTROBWT     7
-#define FAMILY_KAWPOW       8
+#define FAMILY_CN           0x63150000
+#define FAMILY_CN_LITE      0x63140000
+#define FAMILY_CN_HEAVY     0x63160000
+#define FAMILY_CN_PICO      0x63120000
+#define FAMILY_CN_FEMTO     0x63110000
+#define FAMILY_RANDOM_X     0x72000000
+#define FAMILY_ARGON2       0x61000000
+#define FAMILY_ASTROBWT     0x41000000
+#define FAMILY_KAWPOW       0x6b000000
--- a/src/backend/opencl/cl/cn/cryptonight_cl.h
+++ b/src/backend/opencl/cl/cn/cryptonight_cl.h
--- a/src/backend/opencl/cl/rx/randomx_cl.h
+++ b/src/backend/opencl/cl/rx/randomx_cl.h
--- a/src/backend/opencl/generators/ocl_generic_cn_generator.cpp
+++ b/src/backend/opencl/generators/ocl_generic_cn_generator.cpp
@@ -1,13 +1,8 @@
 /* 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      Lee Clagett <https://github.com/vtnerd>
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright (c) 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -23,7 +18,6 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-
 #include "backend/opencl/OclThreads.h"
 #include "backend/opencl/wrappers/OclDevice.h"
 #include "base/crypto/Algorithm.h"
@@ -36,31 +30,31 @@
 namespace xmrig {


-constexpr const size_t oneMiB = 1024u * 1024u;
+constexpr const size_t oneMiB = 1024U * 1024U;


 static inline uint32_t getMaxThreads(const OclDevice &device, const Algorithm &algorithm)
 {
    if (device.vendorId() == OCL_VENDOR_NVIDIA && (device.name().contains("P100") || device.name().contains("V100"))) {
-        return 40000u;
+        return 40000U;
    }

-    const uint32_t ratio = (algorithm.l3() <= oneMiB) ? 2u : 1u;
+    const uint32_t ratio = (algorithm.l3() <= oneMiB) ? 2U : 1U;

    if (device.vendorId() == OCL_VENDOR_INTEL) {
        return ratio * device.computeUnits() * 8;
    }

-    return ratio * 1000u;
+    return ratio * 1000U;
 }


 static inline uint32_t getPossibleIntensity(const OclDevice &device, const Algorithm &algorithm)
 {
    const uint32_t maxThreads   = getMaxThreads(device, algorithm);
-    const size_t minFreeMem     = (maxThreads == 40000u ? 512u : 128u) * oneMiB;
+    const size_t minFreeMem     = (maxThreads == 40000U ? 512U : 128U) * oneMiB;
    const size_t availableMem   = device.freeMemSize() - minFreeMem;
-    const size_t perThread      = algorithm.l3() + 224u;
+    const size_t perThread      = algorithm.l3() + 224U;
    const auto maxIntensity     = static_cast<uint32_t>(availableMem / perThread);

    return std::min<uint32_t>(maxThreads, maxIntensity);
@@ -98,7 +92,7 @@ static uint32_t getStridedIndex(const OclDevice &device, const Algorithm &algori
        return 0;
    }

-    return CnAlgo<>::base(algorithm) == Algorithm::CN_2 ? 2 : 1;
+    return algorithm.base() == Algorithm::CN_2 ? 2 : 1;
 }


--- a/src/backend/opencl/generators/ocl_vega_cn_generator.cpp
+++ b/src/backend/opencl/generators/ocl_vega_cn_generator.cpp
@@ -1,13 +1,6 @@
 /* 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      Lee Clagett <https://github.com/vtnerd>
- * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -23,7 +16,6 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-
 #include "backend/opencl/OclThreads.h"
 #include "backend/opencl/wrappers/OclDevice.h"
 #include "base/crypto/Algorithm.h"
@@ -36,7 +28,7 @@
 namespace xmrig {


-constexpr const size_t oneMiB = 1024u * 1024u;
+constexpr const size_t oneMiB = 1024U * 1024U;


 static inline bool isMatch(const OclDevice &device, const Algorithm &algorithm)
@@ -49,23 +41,23 @@ static inline bool isMatch(const OclDevice &device, const Algorithm &algorithm)

 static inline uint32_t getMaxThreads(const OclDevice &device, const Algorithm &algorithm)
 {
-    const uint32_t ratio = (algorithm.l3() <= oneMiB) ? 2u : 1u;
+    const uint32_t ratio = (algorithm.l3() <= oneMiB) ? 2U : 1U;

    if (device.type() == OclDevice::Vega_10) {
-        if (device.computeUnits() == 56 && algorithm.family() == Algorithm::CN && CnAlgo<>::base(algorithm) == Algorithm::CN_2) {
-            return 1792u;
+        if (device.computeUnits() == 56 && algorithm.family() == Algorithm::CN && algorithm.base() == Algorithm::CN_2) {
+            return 1792U;
        }
    }

-    return ratio * 2024u;
+    return ratio * 2024U;
 }


 static inline uint32_t getPossibleIntensity(const OclDevice &device, const Algorithm &algorithm)
 {
    const uint32_t maxThreads   = getMaxThreads(device, algorithm);
-    const size_t availableMem   = device.freeMemSize() - (128u * oneMiB);
-    const size_t perThread      = algorithm.l3() + 224u;
+    const size_t availableMem   = device.freeMemSize() - (128U * oneMiB);
+    const size_t perThread      = algorithm.l3() + 224U;
    const auto maxIntensity     = static_cast<uint32_t>(availableMem / perThread);

    return std::min<uint32_t>(maxThreads, maxIntensity);
@@ -88,28 +80,24 @@ static inline uint32_t getIntensity(const OclDevice &device, const Algorithm &al

 static inline uint32_t getWorksize(const Algorithm &algorithm)
 {
-    Algorithm::Family f = algorithm.family();
+    const auto f = algorithm.family();
    if (f == Algorithm::CN_PICO || f == Algorithm::CN_FEMTO) {
        return 64;
    }

-    if (CnAlgo<>::base(algorithm) == Algorithm::CN_2) {
-        return 16;
-    }
-
-    return 8;
+    return algorithm.base() == Algorithm::CN_2 ? 16 : 8;
 }


 static uint32_t getStridedIndex(const Algorithm &algorithm)
 {
-    return CnAlgo<>::base(algorithm) == Algorithm::CN_2 ? 2 : 1;
+    return algorithm.base() == Algorithm::CN_2 ? 2 : 1;
 }


 static inline uint32_t getMemChunk(const Algorithm &algorithm)
 {
-    return CnAlgo<>::base(algorithm) == Algorithm::CN_2 ? 1 : 2;
+    return algorithm.base() == Algorithm::CN_2 ? 1 : 2;
 }


--- a/src/backend/opencl/runners/OclCnRunner.cpp
+++ b/src/backend/opencl/runners/OclCnRunner.cpp
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -22,7 +16,6 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-
 #include "backend/opencl/runners/OclCnRunner.h"
 #include "backend/opencl/kernels/Cn0Kernel.h"
 #include "backend/opencl/kernels/Cn1Kernel.h"
@@ -39,12 +32,12 @@
 xmrig::OclCnRunner::OclCnRunner(size_t index, const OclLaunchData &data) : OclBaseRunner(index, data)
 {
    uint32_t stridedIndex = data.thread.stridedIndex();
-    Algorithm::Family f = m_algorithm.family();
+    const auto f = m_algorithm.family();

    if (data.device.vendorId() == OCL_VENDOR_NVIDIA) {
        stridedIndex = 0;
    }
-    else if (stridedIndex == 1 && (f == Algorithm::CN_PICO || f == Algorithm::CN_FEMTO || (f == Algorithm::CN && CnAlgo<>::base(m_algorithm) == Algorithm::CN_2))) {
+    else if (stridedIndex == 1 && (f == Algorithm::CN_PICO || f == Algorithm::CN_FEMTO || (f == Algorithm::CN && m_algorithm.base() == Algorithm::CN_2))) {
        stridedIndex = 2;
    }

@@ -52,10 +45,10 @@ xmrig::OclCnRunner::OclCnRunner(size_t index, const OclLaunchData &data) : OclBa
    m_options += " -DMASK="                 + std::to_string(CnAlgo<>::mask(m_algorithm)) + "U";
    m_options += " -DWORKSIZE="             + std::to_string(data.thread.worksize()) + "U";
    m_options += " -DSTRIDED_INDEX="        + std::to_string(stridedIndex) + "U";
-    m_options += " -DMEM_CHUNK_EXPONENT="   + std::to_string(1u << data.thread.memChunk()) + "U";
+    m_options += " -DMEM_CHUNK_EXPONENT="   + std::to_string(1U << data.thread.memChunk()) + "U";
    m_options += " -DMEMORY="               + std::to_string(m_algorithm.l3()) + "LU";
    m_options += " -DALGO="                 + std::to_string(m_algorithm.id());
-    m_options += " -DALGO_BASE="            + std::to_string(CnAlgo<>::base(m_algorithm));
+    m_options += " -DALGO_BASE="            + std::to_string(m_algorithm.base());
    m_options += " -DALGO_FAMILY="          + std::to_string(m_algorithm.family());
    m_options += " -DCN_UNROLL="            + std::to_string(data.thread.unrollFactor());
 }
@@ -96,7 +89,7 @@ void xmrig::OclCnRunner::run(uint32_t nonce, uint32_t *hashOutput)
    static const cl_uint zero = 0;

    const size_t w_size = data().thread.worksize();
-    const size_t g_thd  = ((m_intensity + w_size - 1u) / w_size) * w_size;
+    const size_t g_thd  = ((m_intensity + w_size - 1U) / w_size) * w_size;

    assert(g_thd % w_size == 0);

--- a/src/backend/opencl/runners/OclCnRunner.h
+++ b/src/backend/opencl/runners/OclCnRunner.h
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
--- a/src/base/base.cmake
+++ b/src/base/base.cmake
@@ -70,18 +70,19 @@ set(HEADERS_BASE
    src/base/net/tools/Storage.h
    src/base/tools/Arguments.h
    src/base/tools/Baton.h
+    src/base/tools/bswap_64.h
    src/base/tools/Buffer.h
    src/base/tools/Chrono.h
+    src/base/tools/cryptonote/BlobReader.h
+    src/base/tools/cryptonote/BlockTemplate.h
+    src/base/tools/cryptonote/crypto-ops.h
+    src/base/tools/cryptonote/Signatures.h
+    src/base/tools/cryptonote/umul128.h
+    src/base/tools/cryptonote/WalletAddress.h
    src/base/tools/Cvt.h
    src/base/tools/Handle.h
    src/base/tools/String.h
    src/base/tools/Timer.h
-    src/base/tools/cryptonote/BlobReader.h
-    src/base/tools/cryptonote/BlockTemplate.h
-    src/base/tools/cryptonote/Signatures.h
-    src/base/tools/cryptonote/WalletAddress.h
-    src/base/tools/cryptonote/crypto-ops.h
-    src/base/tools/cryptonote/umul128.h
   )

 set(SOURCES_BASE
--- a/src/base/crypto/Algorithm.cpp
+++ b/src/base/crypto/Algorithm.cpp
@@ -1,13 +1,7 @@
 /* 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      Lee Clagett <https://github.com/vtnerd>
- * Copyright 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -23,15 +17,15 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-
 #include "base/crypto/Algorithm.h"
 #include "3rdparty/rapidjson/document.h"
+#include "base/tools/String.h"


 #include <cassert>
 #include <cstdio>
 #include <cstdlib>
-#include <cstring>
+#include <map>


 #ifdef _MSC_VER
@@ -42,98 +36,248 @@
 namespace xmrig {


-struct AlgoName
-{
-    const char *name;
-    const char *shortName;
-    const Algorithm::Id id;
+const char *Algorithm::kINVALID         = "invalid";
+const char *Algorithm::kCN              = "cn";
+const char *Algorithm::kCN_0            = "cn/0";
+const char *Algorithm::kCN_1            = "cn/1";
+const char *Algorithm::kCN_2            = "cn/2";
+const char *Algorithm::kCN_R            = "cn/r";
+const char *Algorithm::kCN_FAST         = "cn/fast";
+const char *Algorithm::kCN_HALF         = "cn/half";
+const char *Algorithm::kCN_XAO          = "cn/xao";
+const char *Algorithm::kCN_RTO          = "cn/rto";
+const char *Algorithm::kCN_RWZ          = "cn/rwz";
+const char *Algorithm::kCN_ZLS          = "cn/zls";
+const char *Algorithm::kCN_DOUBLE       = "cn/double";
+const char *Algorithm::kCN_CCX          = "cn/ccx";
+
+#ifdef XMRIG_ALGO_CN_LITE
+const char *Algorithm::kCN_LITE         = "cn-lite";
+const char *Algorithm::kCN_LITE_0       = "cn-lite/0";
+const char *Algorithm::kCN_LITE_1       = "cn-lite/1";
+#endif
+
+#ifdef XMRIG_ALGO_CN_HEAVY
+const char *Algorithm::kCN_HEAVY        = "cn-heavy";
+const char *Algorithm::kCN_HEAVY_0      = "cn-heavy/0";
+const char *Algorithm::kCN_HEAVY_TUBE   = "cn-heavy/tube";
+const char *Algorithm::kCN_HEAVY_XHV    = "cn-heavy/xhv";
+#endif
+
+#ifdef XMRIG_ALGO_CN_PICO
+const char *Algorithm::kCN_PICO         = "cn-pico";
+const char *Algorithm::kCN_PICO_0       = "cn-pico";
+const char *Algorithm::kCN_PICO_TLO     = "cn-pico/tlo";
+#endif
+
+#ifdef XMRIG_ALGO_CN_FEMTO
+const char *Algorithm::kCN_UPX2         = "cn/upx2";
+#endif
+
+#ifdef XMRIG_ALGO_RANDOMX
+const char *Algorithm::kRX              = "rx";
+const char *Algorithm::kRX_0            = "rx/0";
+const char *Algorithm::kRX_WOW          = "rx/wow";
+const char *Algorithm::kRX_ARQ          = "rx/arq";
+const char *Algorithm::kRX_SFX          = "rx/sfx";
+const char *Algorithm::kRX_KEVA         = "rx/keva";
+#endif
+
+#ifdef XMRIG_ALGO_ARGON2
+const char *Algorithm::kAR2             = "argon2";
+const char *Algorithm::kAR2_CHUKWA      = "argon2/chukwa";
+const char *Algorithm::kAR2_CHUKWA_V2   = "argon2/chukwav2";
+const char *Algorithm::kAR2_WRKZ        = "argon2/ninja";
+#endif
+
+#ifdef XMRIG_ALGO_ASTROBWT
+const char *Algorithm::kASTROBWT        = "astrobwt";
+const char *Algorithm::kASTROBWT_DERO   = "astrobwt";
+#endif
+
+#ifdef XMRIG_ALGO_KAWPOW
+const char *Algorithm::kKAWPOW          = "kawpow";
+const char *Algorithm::kKAWPOW_RVN      = "kawpow";
+#endif
+
+
+#define ALGO_NAME(ALGO)         { Algorithm::ALGO, Algorithm::k##ALGO }
+#define ALGO_ALIAS(ALGO, NAME)  { NAME, Algorithm::ALGO }
+#define ALGO_ALIAS_AUTO(ALGO)   { Algorithm::k##ALGO, Algorithm::ALGO }
+
+
+#ifdef _MSC_VER
+#   define strcasecmp _stricmp
+#endif
+
+
+static const std::map<uint32_t, const char *> kAlgorithmNames = {
+    ALGO_NAME(CN_0),
+    ALGO_NAME(CN_1),
+    ALGO_NAME(CN_2),
+    ALGO_NAME(CN_R),
+    ALGO_NAME(CN_FAST),
+    ALGO_NAME(CN_HALF),
+    ALGO_NAME(CN_XAO),
+    ALGO_NAME(CN_RTO),
+    ALGO_NAME(CN_RWZ),
+    ALGO_NAME(CN_ZLS),
+    ALGO_NAME(CN_DOUBLE),
+    ALGO_NAME(CN_CCX),
+
+#   ifdef XMRIG_ALGO_CN_LITE
+    ALGO_NAME(CN_LITE_0),
+    ALGO_NAME(CN_LITE_1),
+#   endif
+
+#   ifdef XMRIG_ALGO_CN_HEAVY
+    ALGO_NAME(CN_HEAVY_0),
+    ALGO_NAME(CN_HEAVY_TUBE),
+    ALGO_NAME(CN_HEAVY_XHV),
+#   endif
+
+#   ifdef XMRIG_ALGO_CN_PICO
+    ALGO_NAME(CN_PICO_0),
+    ALGO_NAME(CN_PICO_TLO),
+#   endif
+
+#   ifdef XMRIG_ALGO_CN_FEMTO
+    ALGO_NAME(CN_UPX2),
+#   endif
+
+#   ifdef XMRIG_ALGO_RANDOMX
+    ALGO_NAME(RX_0),
+    ALGO_NAME(RX_WOW),
+    ALGO_NAME(RX_ARQ),
+    ALGO_NAME(RX_SFX),
+    ALGO_NAME(RX_KEVA),
+#   endif
+
+#   ifdef XMRIG_ALGO_ARGON2
+    ALGO_NAME(AR2_CHUKWA),
+    ALGO_NAME(AR2_CHUKWA_V2),
+    ALGO_NAME(AR2_WRKZ),
+#   endif
+
+#   ifdef XMRIG_ALGO_ASTROBWT
+    ALGO_NAME(ASTROBWT_DERO),
+#   endif
+
+#   ifdef XMRIG_ALGO_KAWPOW
+    ALGO_NAME(KAWPOW_RVN),
+#   endif
 };


-static AlgoName const algorithm_names[] = {
-    { "cryptonight/0",             "cn/0",             Algorithm::CN_0            },
-    { "cryptonight",               "cn",               Algorithm::CN_0            },
-    { "cryptonight/1",             "cn/1",             Algorithm::CN_1            },
-    { "cryptonight-monerov7",      nullptr,            Algorithm::CN_1            },
-    { "cryptonight_v7",            nullptr,            Algorithm::CN_1            },
-    { "cryptonight/2",             "cn/2",             Algorithm::CN_2            },
-    { "cryptonight-monerov8",      nullptr,            Algorithm::CN_2            },
-    { "cryptonight_v8",            nullptr,            Algorithm::CN_2            },
-    { "cryptonight/r",             "cn/r",             Algorithm::CN_R            },
-    { "cryptonight_r",             nullptr,            Algorithm::CN_R            },
-    { "cryptonight/fast",          "cn/fast",          Algorithm::CN_FAST         },
-    { "cryptonight/msr",           "cn/msr",           Algorithm::CN_FAST         },
-    { "cryptonight/half",          "cn/half",          Algorithm::CN_HALF         },
-    { "cryptonight/xao",           "cn/xao",           Algorithm::CN_XAO          },
-    { "cryptonight_alloy",         nullptr,            Algorithm::CN_XAO          },
-    { "cryptonight/rto",           "cn/rto",           Algorithm::CN_RTO          },
-    { "cryptonight/rwz",           "cn/rwz",           Algorithm::CN_RWZ          },
-    { "cryptonight/zls",           "cn/zls",           Algorithm::CN_ZLS          },
-    { "cryptonight/double",        "cn/double",        Algorithm::CN_DOUBLE       },
+struct aliasCompare
+{
+   inline bool operator()(const char *a, const char *b) const   { return strcasecmp(a, b) < 0; }
+};
+
+
+static const std::map<const char *, Algorithm::Id, aliasCompare> kAlgorithmAliases = {
+    ALGO_ALIAS_AUTO(CN_0),          ALGO_ALIAS(CN_0,            "cryptonight/0"),
+                                    ALGO_ALIAS(CN_0,            "cryptonight"),
+                                    ALGO_ALIAS(CN_0,            "cn"),
+    ALGO_ALIAS_AUTO(CN_1),          ALGO_ALIAS(CN_1,            "cryptonight/1"),
+                                    ALGO_ALIAS(CN_1,            "cryptonight-monerov7"),
+                                    ALGO_ALIAS(CN_1,            "cryptonight_v7"),
+    ALGO_ALIAS_AUTO(CN_2),          ALGO_ALIAS(CN_2,            "cryptonight/2"),
+                                    ALGO_ALIAS(CN_2,            "cryptonight-monerov8"),
+                                    ALGO_ALIAS(CN_2,            "cryptonight_v8"),
+    ALGO_ALIAS_AUTO(CN_FAST),       ALGO_ALIAS(CN_FAST,         "cryptonight/fast"),
+                                    ALGO_ALIAS(CN_FAST,         "cryptonight/msr"),
+                                    ALGO_ALIAS(CN_FAST,         "cn/msr"),
+    ALGO_ALIAS_AUTO(CN_R),          ALGO_ALIAS(CN_R,            "cryptonight/r"),
+                                    ALGO_ALIAS(CN_R,            "cryptonight_r"),
+    ALGO_ALIAS_AUTO(CN_XAO),        ALGO_ALIAS(CN_XAO,          "cryptonight/xao"),
+                                    ALGO_ALIAS(CN_XAO,          "cryptonight_alloy"),
+    ALGO_ALIAS_AUTO(CN_HALF),       ALGO_ALIAS(CN_HALF,         "cryptonight/half"),
+    ALGO_ALIAS_AUTO(CN_RTO),        ALGO_ALIAS(CN_RTO,          "cryptonight/rto"),
+    ALGO_ALIAS_AUTO(CN_RWZ),        ALGO_ALIAS(CN_RWZ,          "cryptonight/rwz"),
+    ALGO_ALIAS_AUTO(CN_ZLS),        ALGO_ALIAS(CN_ZLS,          "cryptonight/zls"),
+    ALGO_ALIAS_AUTO(CN_DOUBLE),     ALGO_ALIAS(CN_DOUBLE,       "cryptonight/double"),
+    ALGO_ALIAS_AUTO(CN_CCX),        ALGO_ALIAS(CN_CCX,          "cryptonight/ccx"),
+                                    ALGO_ALIAS(CN_CCX,          "cryptonight/conceal"),
+                                    ALGO_ALIAS(CN_CCX,          "cn/conceal"),
+
 #   ifdef XMRIG_ALGO_CN_LITE
-    { "cryptonight-lite/0",        "cn-lite/0",        Algorithm::CN_LITE_0       },
-    { "cryptonight-lite/1",        "cn-lite/1",        Algorithm::CN_LITE_1       },
-    { "cryptonight-lite",          "cn-lite",          Algorithm::CN_LITE_1       },
-    { "cryptonight-light",         "cn-light",         Algorithm::CN_LITE_1       },
-    { "cryptonight_lite",          nullptr,            Algorithm::CN_LITE_1       },
-    { "cryptonight-aeonv7",        nullptr,            Algorithm::CN_LITE_1       },
-    { "cryptonight_lite_v7",       nullptr,            Algorithm::CN_LITE_1       },
+    ALGO_ALIAS_AUTO(CN_LITE_0),     ALGO_ALIAS(CN_LITE_0,       "cryptonight-lite/0"),
+                                    ALGO_ALIAS(CN_LITE_0,       "cryptonight-lite"),
+                                    ALGO_ALIAS(CN_LITE_0,       "cryptonight-light"),
+                                    ALGO_ALIAS(CN_LITE_0,       "cn-lite"),
+                                    ALGO_ALIAS(CN_LITE_0,       "cn-light"),
+                                    ALGO_ALIAS(CN_LITE_0,       "cryptonight_lite"),
+    ALGO_ALIAS_AUTO(CN_LITE_1),     ALGO_ALIAS(CN_LITE_1,       "cryptonight-lite/1"),
+                                    ALGO_ALIAS(CN_LITE_1,       "cryptonight-aeonv7"),
+                                    ALGO_ALIAS(CN_LITE_1,       "cryptonight_lite_v7"),
 #   endif
+
 #   ifdef XMRIG_ALGO_CN_HEAVY
-    { "cryptonight-heavy/0",       "cn-heavy/0",       Algorithm::CN_HEAVY_0      },
-    { "cryptonight-heavy",         "cn-heavy",         Algorithm::CN_HEAVY_0      },
-    { "cryptonight_heavy",         nullptr,            Algorithm::CN_HEAVY_0      },
-    { "cryptonight-heavy/xhv",     "cn-heavy/xhv",     Algorithm::CN_HEAVY_XHV    },
-    { "cryptonight_haven",         nullptr,            Algorithm::CN_HEAVY_XHV    },
-    { "cryptonight-heavy/tube",    "cn-heavy/tube",    Algorithm::CN_HEAVY_TUBE   },
-    { "cryptonight-bittube2",      nullptr,            Algorithm::CN_HEAVY_TUBE   },
+    ALGO_ALIAS_AUTO(CN_HEAVY_0),    ALGO_ALIAS(CN_HEAVY_0,      "cryptonight-heavy/0"),
+                                    ALGO_ALIAS(CN_HEAVY_0,      "cryptonight-heavy"),
+                                    ALGO_ALIAS(CN_HEAVY_0,      "cn-heavy"),
+                                    ALGO_ALIAS(CN_HEAVY_0,      "cryptonight_heavy"),
+    ALGO_ALIAS_AUTO(CN_HEAVY_XHV),  ALGO_ALIAS(CN_HEAVY_XHV,    "cryptonight-heavy/xhv"),
+                                    ALGO_ALIAS(CN_HEAVY_XHV,    "cryptonight_haven"),
+    ALGO_ALIAS_AUTO(CN_HEAVY_TUBE), ALGO_ALIAS(CN_HEAVY_TUBE,   "cryptonight-heavy/tube"),
+                                    ALGO_ALIAS(CN_HEAVY_TUBE,   "cryptonight-bittube2"),
 #   endif
+
 #   ifdef XMRIG_ALGO_CN_PICO
-    { "cryptonight-pico",          "cn-pico",          Algorithm::CN_PICO_0       },
-    { "cryptonight-pico/trtl",     "cn-pico/trtl",     Algorithm::CN_PICO_0       },
-    { "cryptonight-turtle",        "cn-trtl",          Algorithm::CN_PICO_0       },
-    { "cryptonight-ultralite",     "cn-ultralite",     Algorithm::CN_PICO_0       },
-    { "cryptonight_turtle",        "cn_turtle",        Algorithm::CN_PICO_0       },
-    { "cryptonight-pico/tlo",      "cn-pico/tlo",      Algorithm::CN_PICO_TLO     },
-    { "cryptonight/ultra",         "cn/ultra",         Algorithm::CN_PICO_TLO     },
-    { "cryptonight-talleo",        "cn-talleo",        Algorithm::CN_PICO_TLO     },
-    { "cryptonight_talleo",        "cn_talleo",        Algorithm::CN_PICO_TLO     },
+    ALGO_ALIAS_AUTO(CN_PICO_0),     ALGO_ALIAS(CN_PICO_0,       "cryptonight-pico"),
+                                    ALGO_ALIAS(CN_PICO_0,       "cn-pico/0"),
+                                    ALGO_ALIAS(CN_PICO_0,       "cryptonight-pico/trtl"),
+                                    ALGO_ALIAS(CN_PICO_0,       "cn-pico/trtl"),
+                                    ALGO_ALIAS(CN_PICO_0,       "cryptonight-turtle"),
+                                    ALGO_ALIAS(CN_PICO_0,       "cn-trtl"),
+                                    ALGO_ALIAS(CN_PICO_0,       "cryptonight-ultralite"),
+                                    ALGO_ALIAS(CN_PICO_0,       "cn-ultralite"),
+                                    ALGO_ALIAS(CN_PICO_0,       "cryptonight_turtle"),
+                                    ALGO_ALIAS(CN_PICO_0,       "cn_turtle"),
+    ALGO_ALIAS_AUTO(CN_PICO_TLO),   ALGO_ALIAS(CN_PICO_TLO,     "cryptonight-pico/tlo"),
+                                    ALGO_ALIAS(CN_PICO_TLO,     "cryptonight/ultra"),
+                                    ALGO_ALIAS(CN_PICO_TLO,     "cn/ultra"),
+                                    ALGO_ALIAS(CN_PICO_TLO,     "cryptonight-talleo"),
+                                    ALGO_ALIAS(CN_PICO_TLO,     "cn-talleo"),
+                                    ALGO_ALIAS(CN_PICO_TLO,     "cryptonight_talleo"),
+                                    ALGO_ALIAS(CN_PICO_TLO,     "cn_talleo"),
 #   endif
-#   ifdef XMRIG_ALGO_RANDOMX
-    { "randomx/0",                 "rx/0",             Algorithm::RX_0            },
-    { "randomx/test",              "rx/test",          Algorithm::RX_0            },
-    { "RandomX",                   "rx",               Algorithm::RX_0            },
-    { "randomx/wow",               "rx/wow",           Algorithm::RX_WOW          },
-    { "RandomWOW",                 nullptr,            Algorithm::RX_WOW          },
-    { "randomx/arq",               "rx/arq",           Algorithm::RX_ARQ          },
-    { "RandomARQ",                 nullptr,            Algorithm::RX_ARQ          },
-    { "randomx/sfx",               "rx/sfx",           Algorithm::RX_SFX          },
-    { "RandomSFX",                 nullptr,            Algorithm::RX_SFX          },
-    { "randomx/keva",              "rx/keva",          Algorithm::RX_KEVA         },
-    { "RandomKEVA",                nullptr,            Algorithm::RX_KEVA         },
-#   endif
-#   ifdef XMRIG_ALGO_ARGON2
-    { "argon2/chukwa",             nullptr,            Algorithm::AR2_CHUKWA      },
-    { "chukwa",                    nullptr,            Algorithm::AR2_CHUKWA      },
-    { "argon2/chukwav2",           nullptr,            Algorithm::AR2_CHUKWA_V2   },
-    { "chukwav2",                  nullptr,            Algorithm::AR2_CHUKWA_V2   },
-    { "argon2/ninja",              nullptr,            Algorithm::AR2_WRKZ        },
-    { "argon2/wrkz",               nullptr,            Algorithm::AR2_WRKZ        },
-#   endif
-#   ifdef XMRIG_ALGO_ASTROBWT
-    { "astrobwt",                  nullptr,            Algorithm::ASTROBWT_DERO   },
-    { "astrobwt/dero",             nullptr,            Algorithm::ASTROBWT_DERO   },
-#   endif
-#   ifdef XMRIG_ALGO_KAWPOW
-    { "kawpow",                    nullptr,            Algorithm::KAWPOW_RVN      },
-    { "kawpow/rvn",                nullptr,            Algorithm::KAWPOW_RVN      },
-#   endif
-    { "cryptonight/ccx",           "cn/ccx",           Algorithm::CN_CCX          },
-    { "cryptonight/conceal",       "cn/conceal",       Algorithm::CN_CCX          },
+
 #   ifdef XMRIG_ALGO_CN_FEMTO
-    { "cryptonight/upx2",          "cn/upx2",          Algorithm::CN_UPX2         },
-    { "cn-extremelite/upx2",       nullptr,            Algorithm::CN_UPX2         },
-    { "cryptonight-upx/2",         nullptr,            Algorithm::CN_UPX2         },
+    ALGO_ALIAS_AUTO(CN_UPX2),       ALGO_ALIAS(CN_UPX2,         "cryptonight/upx2"),
+                                    ALGO_ALIAS(CN_UPX2,         "cn-extremelite/upx2"),
+                                    ALGO_ALIAS(CN_UPX2,         "cryptonight-upx/2"),
+#   endif
+
+#   ifdef XMRIG_ALGO_RANDOMX
+    ALGO_ALIAS_AUTO(RX_0),          ALGO_ALIAS(RX_0,            "randomx/0"),
+                                    ALGO_ALIAS(RX_0,            "randomx/test"),
+                                    ALGO_ALIAS(RX_0,            "rx/test"),
+                                    ALGO_ALIAS(RX_0,            "randomx"),
+                                    ALGO_ALIAS(RX_0,            "rx"),
+    ALGO_ALIAS_AUTO(RX_WOW),        ALGO_ALIAS(RX_WOW,          "randomx/wow"),
+                                    ALGO_ALIAS(RX_WOW,          "randomwow"),
+    ALGO_ALIAS_AUTO(RX_ARQ),        ALGO_ALIAS(RX_ARQ,          "randomx/arq"),
+                                    ALGO_ALIAS(RX_ARQ,          "randomarq"),
+    ALGO_ALIAS_AUTO(RX_SFX),        ALGO_ALIAS(RX_SFX,          "randomx/sfx"),
+                                    ALGO_ALIAS(RX_SFX,          "randomsfx"),
+    ALGO_ALIAS_AUTO(RX_KEVA),       ALGO_ALIAS(RX_KEVA,         "randomx/keva"),
+                                    ALGO_ALIAS(RX_KEVA,         "randomkeva"),
+#   endif
+
+#   ifdef XMRIG_ALGO_ARGON2
+    ALGO_ALIAS_AUTO(AR2_CHUKWA),    ALGO_ALIAS(AR2_CHUKWA,      "chukwa"),
+    ALGO_ALIAS_AUTO(AR2_CHUKWA_V2), ALGO_ALIAS(AR2_CHUKWA,      "chukwav2"),
+    ALGO_ALIAS_AUTO(AR2_WRKZ),      ALGO_ALIAS(AR2_WRKZ,        "argon2/wrkz"),
+#   endif
+
+#   ifdef XMRIG_ALGO_ASTROBWT
+    ALGO_ALIAS_AUTO(ASTROBWT_DERO), ALGO_ALIAS(ASTROBWT_DERO,   "astrobwt/dero"),
+#   endif
+
+#   ifdef XMRIG_ALGO_KAWPOW
+    ALGO_ALIAS_AUTO(KAWPOW_RVN),    ALGO_ALIAS(KAWPOW_RVN,      "kawpow/rvn"),
 #   endif
 };

@@ -147,11 +291,30 @@ xmrig::Algorithm::Algorithm(const rapidjson::Value &value) :
 }


+xmrig::Algorithm::Algorithm(uint32_t id) :
+    m_id(kAlgorithmNames.count(id) ? static_cast<Id>(id) : INVALID)
+{
+}
+
+
+const char *xmrig::Algorithm::name() const
+{
+    if (!isValid()) {
+        return kINVALID;
+    }
+
+    assert(kAlgorithmNames.count(m_id));
+    const auto it = kAlgorithmNames.find(m_id);
+
+    return it != kAlgorithmNames.end() ? it->second : kINVALID;
+}
+
+
 rapidjson::Value xmrig::Algorithm::toJSON() const
 {
    using namespace rapidjson;

-    return isValid() ? Value(StringRef(shortName())) : Value(kNullType);
+    return isValid() ? Value(StringRef(name())) : Value(kNullType);
 }


@@ -161,245 +324,46 @@ rapidjson::Value xmrig::Algorithm::toJSON(rapidjson::Document &) const
 }


-size_t xmrig::Algorithm::l2() const
-{
-#   ifdef XMRIG_ALGO_RANDOMX
-    switch (m_id) {
-    case RX_0:
-    case RX_SFX:
-        return 0x40000;
-
-    case RX_WOW:
-    case RX_KEVA:
-        return 0x20000;
-
-    case RX_ARQ:
-        return 0x10000;
-
-    default:
-        break;
-    }
-#   endif
-
-    return 0;
-}
-
-
-size_t xmrig::Algorithm::l3() const
-{
-    constexpr size_t oneMiB = 0x100000;
-
-    const auto f = family();
-    assert(f != UNKNOWN);
-
-    switch (f) {
-    case CN:
-        return oneMiB * 2;
-
-    case CN_LITE:
-        return oneMiB;
-
-    case CN_HEAVY:
-        return oneMiB * 4;
-
-    case CN_PICO:
-        return oneMiB / 4;
-
-    case CN_FEMTO:
-        return oneMiB / 8;
-
-    default:
-        break;
-    }
-
-#   ifdef XMRIG_ALGO_RANDOMX
-    if (f == RANDOM_X) {
-        switch (m_id) {
-        case RX_0:
-        case RX_SFX:
-            return oneMiB * 2;
-
-        case RX_WOW:
-        case RX_KEVA:
-            return oneMiB;
-
-        case RX_ARQ:
-            return oneMiB / 4;
-
-        default:
-            break;
-        }
-    }
-#   endif
-
-#   ifdef XMRIG_ALGO_ARGON2
-    if (f == ARGON2) {
-        switch (m_id) {
-        case AR2_CHUKWA:
-            return oneMiB / 2;
-
-        case AR2_CHUKWA_V2:
-            return oneMiB;
-
-        case AR2_WRKZ:
-            return oneMiB / 4;
-
-        default:
-            break;
-        }
-    }
-#   endif
-
-#   ifdef XMRIG_ALGO_ASTROBWT
-    if (f == ASTROBWT) {
-        switch (m_id) {
-        case ASTROBWT_DERO:
-            return oneMiB * 20;
-
-        default:
-            break;
-        }
-    }
-#   endif
-
-#   ifdef XMRIG_ALGO_KAWPOW
-    if (f == KAWPOW) {
-        switch (m_id) {
-        case KAWPOW_RVN:
-            return 32768;
-
-        default:
-            break;
-        }
-    }
-#   endif
-
-    return 0;
-}
-
-
-uint32_t xmrig::Algorithm::maxIntensity() const
-{
-#   ifdef XMRIG_ALGO_RANDOMX
-    if (family() == RANDOM_X) {
-        return 1;
-    }
-#   endif
-
-#   ifdef XMRIG_ALGO_ARGON2
-    if (family() == ARGON2) {
-        return 1;
-    }
-#   endif
-
-#   ifdef XMRIG_ALGO_ASTROBWT
-    if (family() == ASTROBWT) {
-        return 1;
-    }
-#   endif
-
-    return 5;
-}
-
-
-xmrig::Algorithm::Family xmrig::Algorithm::family(Id id)
-{
-    switch (id) {
-    case CN_0:
-    case CN_1:
-    case CN_2:
-    case CN_R:
-    case CN_FAST:
-    case CN_HALF:
-    case CN_XAO:
-    case CN_RTO:
-    case CN_RWZ:
-    case CN_ZLS:
-    case CN_DOUBLE:
-    case CN_CCX:
-        return CN;
-
-#   ifdef XMRIG_ALGO_CN_LITE
-    case CN_LITE_0:
-    case CN_LITE_1:
-        return CN_LITE;
-#   endif
-
-#   ifdef XMRIG_ALGO_CN_HEAVY
-    case CN_HEAVY_0:
-    case CN_HEAVY_TUBE:
-    case CN_HEAVY_XHV:
-        return CN_HEAVY;
-#   endif
-
-#   ifdef XMRIG_ALGO_CN_PICO
-    case CN_PICO_0:
-    case CN_PICO_TLO:
-        return CN_PICO;
-#   endif
-
-#   ifdef XMRIG_ALGO_CN_FEMTO
-    case CN_UPX2:
-        return CN_FEMTO;
-#   endif
-
-#   ifdef XMRIG_ALGO_RANDOMX
-    case RX_0:
-    case RX_WOW:
-    case RX_ARQ:
-    case RX_SFX:
-    case RX_KEVA:
-        return RANDOM_X;
-#   endif
-
-#   ifdef XMRIG_ALGO_ARGON2
-    case AR2_CHUKWA:
-    case AR2_CHUKWA_V2:
-    case AR2_WRKZ:
-        return ARGON2;
-#   endif
-
-#   ifdef XMRIG_ALGO_ASTROBWT
-    case ASTROBWT_DERO:
-        return ASTROBWT;
-#   endif
-
-#   ifdef XMRIG_ALGO_KAWPOW
-    case KAWPOW_RVN:
-        return KAWPOW;
-#   endif
-
-    default:
-        break;
-    }
-
-    return UNKNOWN;
-}
-
-
 xmrig::Algorithm::Id xmrig::Algorithm::parse(const char *name)
 {
    if (name == nullptr || strlen(name) < 1) {
        return INVALID;
    }

-    for (const AlgoName &item : algorithm_names) {
-        if ((strcasecmp(name, item.name) == 0) || (item.shortName != nullptr && strcasecmp(name, item.shortName) == 0)) {
-            return item.id;
-        }
-    }
+    const auto it = kAlgorithmAliases.find(name);

-    return INVALID;
+    return it != kAlgorithmAliases.end() ? it->second : INVALID;
 }


-const char *xmrig::Algorithm::name(bool shortName) const
+size_t xmrig::Algorithm::count()
 {
-    for (const AlgoName &item : algorithm_names) {
-        if (item.id == m_id) {
-            return (shortName && item.shortName) ? item.shortName : item.name;
+    return kAlgorithmNames.size();
+}
+
+
+std::vector<xmrig::Algorithm> xmrig::Algorithm::all(const std::function<bool(const Algorithm &algo)> &filter)
+{
+    static const std::vector<Id> order = {
+        CN_0, CN_1, CN_2, CN_R, CN_FAST, CN_HALF, CN_XAO, CN_RTO, CN_RWZ, CN_ZLS, CN_DOUBLE, CN_CCX,
+        CN_LITE_0, CN_LITE_1,
+        CN_HEAVY_0, CN_HEAVY_TUBE, CN_HEAVY_XHV,
+        CN_PICO_0, CN_PICO_TLO,
+        CN_UPX2,
+        RX_0, RX_WOW, RX_ARQ, RX_SFX, RX_KEVA,
+        AR2_CHUKWA, AR2_CHUKWA_V2, AR2_WRKZ,
+        ASTROBWT_DERO,
+        KAWPOW_RVN
+    };
+
+    Algorithms out;
+    out.reserve(count());
+
+    for (const Id algo : order) {
+        if (kAlgorithmNames.count(algo) && (!filter || filter(algo))) {
+            out.emplace_back(algo);
        }
    }

-    return "invalid";
+    return out;
 }
--- a/src/base/crypto/Algorithm.h
+++ b/src/base/crypto/Algorithm.h
@@ -1,13 +1,7 @@
 /* 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      Lee Clagett <https://github.com/vtnerd>
- * Copyright 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -27,6 +21,7 @@
 #define XMRIG_ALGORITHM_H


+#include <functional>
 #include <vector>


@@ -39,70 +34,156 @@ namespace xmrig {
 class Algorithm
 {
 public:
-    // Changes in following file is required if this enum changed:
+    // Changes in following file may required if this enum changed:
    //
    // src/backend/opencl/cl/cn/algorithm.cl
    //
-    enum Id : int {
-        INVALID = -1,
-        CN_0,          // "cn/0"             CryptoNight (original).
-        CN_1,          // "cn/1"             CryptoNight variant 1 also known as Monero7 and CryptoNightV7.
-        CN_2,          // "cn/2"             CryptoNight variant 2.
-        CN_R,          // "cn/r"             CryptoNightR (Monero's variant 4).
-        CN_FAST,       // "cn/fast"          CryptoNight variant 1 with half iterations.
-        CN_HALF,       // "cn/half"          CryptoNight variant 2 with half iterations (Masari/Torque).
-        CN_XAO,        // "cn/xao"           CryptoNight variant 0 (modified, Alloy only).
-        CN_RTO,        // "cn/rto"           CryptoNight variant 1 (modified, Arto only).
-        CN_RWZ,        // "cn/rwz"           CryptoNight variant 2 with 3/4 iterations and reversed shuffle operation (Graft).
-        CN_ZLS,        // "cn/zls"           CryptoNight variant 2 with 3/4 iterations (Zelerius).
-        CN_DOUBLE,     // "cn/double"        CryptoNight variant 2 with double iterations (X-CASH).
-        CN_LITE_0,     // "cn-lite/0"        CryptoNight-Lite variant 0.
-        CN_LITE_1,     // "cn-lite/1"        CryptoNight-Lite variant 1.
-        CN_HEAVY_0,    // "cn-heavy/0"       CryptoNight-Heavy (4 MB).
-        CN_HEAVY_TUBE, // "cn-heavy/tube"    CryptoNight-Heavy (modified, TUBE only).
-        CN_HEAVY_XHV,  // "cn-heavy/xhv"     CryptoNight-Heavy (modified, Haven Protocol only).
-        CN_PICO_0,     // "cn-pico"          CryptoNight-Pico
-        CN_PICO_TLO,   // "cn-pico/tlo"      CryptoNight-Pico (TLO)
-        CN_CCX,        // "cn/ccx"           Conceal (CCX)
-        CN_UPX2,       // "cn/upx2"          Uplexa (UPX2)
-        RX_0,          // "rx/0"             RandomX (reference configuration).
-        RX_WOW,        // "rx/wow"           RandomWOW (Wownero).
-        RX_ARQ,        // "rx/arq"           RandomARQ (Arqma).
-        RX_SFX,        // "rx/sfx"           RandomSFX (Safex Cash).
-        RX_KEVA,       // "rx/keva"          RandomKEVA (Keva).
-        AR2_CHUKWA,    // "argon2/chukwa"    Argon2id (Chukwa).
-        AR2_CHUKWA_V2, // "argon2/chukwav2"  Argon2id (Chukwa v2).
-        AR2_WRKZ,      // "argon2/wrkz"      Argon2id (WRKZ)
-        ASTROBWT_DERO, // "astrobwt"         AstroBWT (Dero)
-        KAWPOW_RVN,    // "kawpow/rvn"       KawPow (RVN)
-        MAX
+    // Id encoding:
+    // 1 byte: family
+    // 1 byte: L3 memory as power of 2 (if applicable).
+    // 1 byte: L2 memory for RandomX algorithms as power of 2, base variant for CryptoNight algorithms or 0x00.
+    // 1 byte: extra variant (coin) id.
+    enum Id : uint32_t {
+        INVALID         = 0,
+        CN_0            = 0x63150000,   // "cn/0"             CryptoNight (original).
+        CN_1            = 0x63150100,   // "cn/1"             CryptoNight variant 1 also known as Monero7 and CryptoNightV7.
+        CN_2            = 0x63150200,   // "cn/2"             CryptoNight variant 2.
+        CN_R            = 0x63150272,   // "cn/r"             CryptoNightR (Monero's variant 4).
+        CN_FAST         = 0x63150166,   // "cn/fast"          CryptoNight variant 1 with half iterations.
+        CN_HALF         = 0x63150268,   // "cn/half"          CryptoNight variant 2 with half iterations (Masari/Torque).
+        CN_XAO          = 0x63150078,   // "cn/xao"           CryptoNight variant 0 (modified, Alloy only).
+        CN_RTO          = 0x63150172,   // "cn/rto"           CryptoNight variant 1 (modified, Arto only).
+        CN_RWZ          = 0x63150277,   // "cn/rwz"           CryptoNight variant 2 with 3/4 iterations and reversed shuffle operation (Graft).
+        CN_ZLS          = 0x6315027a,   // "cn/zls"           CryptoNight variant 2 with 3/4 iterations (Zelerius).
+        CN_DOUBLE       = 0x63150264,   // "cn/double"        CryptoNight variant 2 with double iterations (X-CASH).
+        CN_CCX          = 0x63150063,   // "cn/ccx"           Conceal (CCX)
+        CN_LITE_0       = 0x63140000,   // "cn-lite/0"        CryptoNight-Lite variant 0.
+        CN_LITE_1       = 0x63140100,   // "cn-lite/1"        CryptoNight-Lite variant 1.
+        CN_HEAVY_0      = 0x63160000,   // "cn-heavy/0"       CryptoNight-Heavy (4 MB).
+        CN_HEAVY_TUBE   = 0x63160172,   // "cn-heavy/tube"    CryptoNight-Heavy (modified, TUBE only).
+        CN_HEAVY_XHV    = 0x63160068,   // "cn-heavy/xhv"     CryptoNight-Heavy (modified, Haven Protocol only).
+        CN_PICO_0       = 0x63120200,   // "cn-pico"          CryptoNight-Pico
+        CN_PICO_TLO     = 0x63120274,   // "cn-pico/tlo"      CryptoNight-Pico (TLO)
+        CN_UPX2         = 0x63110200,   // "cn/upx2"          Uplexa (UPX2)
+        RX_0            = 0x72151200,   // "rx/0"             RandomX (reference configuration).
+        RX_WOW          = 0x72141177,   // "rx/wow"           RandomWOW (Wownero).
+        RX_ARQ          = 0x72121061,   // "rx/arq"           RandomARQ (Arqma).
+        RX_SFX          = 0x72151273,   // "rx/sfx"           RandomSFX (Safex Cash).
+        RX_KEVA         = 0x7214116b,   // "rx/keva"          RandomKEVA (Keva).
+        AR2_CHUKWA      = 0x61130000,   // "argon2/chukwa"    Argon2id (Chukwa).
+        AR2_CHUKWA_V2   = 0x61140000,   // "argon2/chukwav2"  Argon2id (Chukwa v2).
+        AR2_WRKZ        = 0x61120000,   // "argon2/wrkz"      Argon2id (WRKZ)
+        ASTROBWT_DERO   = 0x41000000,   // "astrobwt"         AstroBWT (Dero)
+        KAWPOW_RVN      = 0x6b0f0000,   // "kawpow/rvn"       KawPow (RVN)
    };

-    enum Family : int {
-        UNKNOWN,
-        CN,
-        CN_LITE,
-        CN_HEAVY,
-        CN_PICO,
-        CN_FEMTO,
-        RANDOM_X,
-        ARGON2,
-        ASTROBWT,
-        KAWPOW
+    enum Family : uint32_t {
+        UNKNOWN         = 0,
+        CN_ANY          = 0x63000000,
+        CN              = 0x63150000,
+        CN_LITE         = 0x63140000,
+        CN_HEAVY        = 0x63160000,
+        CN_PICO         = 0x63120000,
+        CN_FEMTO        = 0x63110000,
+        RANDOM_X        = 0x72000000,
+        ARGON2          = 0x61000000,
+        ASTROBWT        = 0x41000000,
+        KAWPOW          = 0x6b000000
    };

+    static const char *kINVALID;
+    static const char *kCN;
+    static const char *kCN_0;
+    static const char *kCN_1;
+    static const char *kCN_2;
+    static const char *kCN_R;
+    static const char *kCN_FAST;
+    static const char *kCN_HALF;
+    static const char *kCN_XAO;
+    static const char *kCN_RTO;
+    static const char *kCN_RWZ;
+    static const char *kCN_ZLS;
+    static const char *kCN_DOUBLE;
+    static const char *kCN_CCX;
+
+#   ifdef XMRIG_ALGO_CN_LITE
+    static const char *kCN_LITE;
+    static const char *kCN_LITE_0;
+    static const char *kCN_LITE_1;
+#   endif
+
+#   ifdef XMRIG_ALGO_CN_HEAVY
+    static const char *kCN_HEAVY;
+    static const char *kCN_HEAVY_0;
+    static const char *kCN_HEAVY_TUBE;
+    static const char *kCN_HEAVY_XHV;
+#   endif
+
+#   ifdef XMRIG_ALGO_CN_PICO
+    static const char *kCN_PICO;
+    static const char *kCN_PICO_0;
+    static const char *kCN_PICO_TLO;
+#   endif
+
+#   ifdef XMRIG_ALGO_CN_FEMTO
+    static const char *kCN_UPX2;
+#   endif
+
+#   ifdef XMRIG_ALGO_RANDOMX
+    static const char *kRX;
+    static const char *kRX_0;
+    static const char *kRX_WOW;
+    static const char *kRX_ARQ;
+    static const char *kRX_SFX;
+    static const char *kRX_KEVA;
+#   endif
+
+#   ifdef XMRIG_ALGO_ARGON2
+    static const char *kAR2;
+    static const char *kAR2_CHUKWA;
+    static const char *kAR2_CHUKWA_V2;
+    static const char *kAR2_WRKZ;
+#   endif
+
+#   ifdef XMRIG_ALGO_ASTROBWT
+    static const char *kASTROBWT;
+    static const char *kASTROBWT_DERO;
+#   endif
+
+#   ifdef XMRIG_ALGO_KAWPOW
+    static const char *kKAWPOW;
+    static const char *kKAWPOW_RVN;
+#   endif
+
    inline Algorithm() = default;
    inline Algorithm(const char *algo) : m_id(parse(algo))  {}
    inline Algorithm(Id id) : m_id(id)                      {}
    Algorithm(const rapidjson::Value &value);
+    Algorithm(uint32_t id);

-    inline bool isCN() const                          { auto f = family(); return f == CN || f == CN_LITE || f == CN_HEAVY || f == CN_PICO || f == CN_FEMTO; }
+    static inline constexpr bool isCN(Id id)                { return (id & 0xff000000) == CN_ANY; }
+    static inline constexpr Id base(Id id)                  { return isCN(id) ? static_cast<Id>(CN_0 | (id & 0xff00)) : INVALID; }
+    static inline constexpr size_t l2(Id id)                { return family(id) == RANDOM_X ? (1U << ((id >> 8) & 0xff)) : 0U; }
+    static inline constexpr size_t l3(Id id)                { return 1U << ((id >> 16) & 0xff); }
+    static inline constexpr uint32_t family(Id id)          { return id & (isCN(id) ? 0xffff0000 : 0xff000000); }
+
+    inline bool isCN() const                                { return isCN(m_id); }
    inline bool isEqual(const Algorithm &other) const       { return m_id == other.m_id; }
-    inline bool isValid() const                       { return m_id != INVALID && family() != UNKNOWN; }
-    inline const char *name() const                   { return name(false); }
-    inline const char *shortName() const              { return name(true); }
-    inline Family family() const                      { return family(m_id); }
+    inline bool isValid() const                             { return m_id != INVALID && family() > UNKNOWN; }
+    inline Id base() const                                  { return base(m_id); }
    inline Id id() const                                    { return m_id; }
+    inline size_t l2() const                                { return l2(m_id); }
+    inline uint32_t family() const                          { return family(m_id); }
+    inline uint32_t maxIntensity() const                    { return isCN() ? 5 : 1; };
+
+    inline size_t l3() const
+    {
+#       ifdef XMRIG_ALGO_ASTROBWT
+        return m_id != ASTROBWT_DERO ? l3(m_id) : 0x100000 * 20;
+#       else
+        return l3(m_id);
+#       endif
+    }

    inline bool operator!=(Algorithm::Id id) const          { return m_id != id; }
    inline bool operator!=(const Algorithm &other) const    { return !isEqual(other); }
@@ -110,18 +191,15 @@ public:
    inline bool operator==(const Algorithm &other) const    { return isEqual(other); }
    inline operator Algorithm::Id() const                   { return m_id; }

+    const char *name() const;
    rapidjson::Value toJSON() const;
    rapidjson::Value toJSON(rapidjson::Document &doc) const;
-    size_t l2() const;
-    size_t l3() const;
-    uint32_t maxIntensity() const;

-    static Family family(Id id);
    static Id parse(const char *name);
+    static size_t count();
+    static std::vector<Algorithm> all(const std::function<bool(const Algorithm &algo)> &filter = nullptr);

 private:
-    const char *name(bool shortName) const;
-
    Id m_id = INVALID;
 };

--- a/src/base/kernel/config/BaseTransform.cpp
+++ b/src/base/kernel/config/BaseTransform.cpp
@@ -249,6 +249,7 @@ void xmrig::BaseTransform::transform(rapidjson::Document &doc, int key, const ch
    case IConfig::DonateLevelKey:   /* --donate-level */
    case IConfig::DaemonPollKey:    /* --daemon-poll-interval */
    case IConfig::DnsTtlKey:        /* --dns-ttl */
+    case IConfig::DaemonZMQPortKey: /* --daemon-zmq-port */
        return transformUint64(doc, key, static_cast<uint64_t>(strtol(arg, nullptr, 10)));

    case IConfig::BackgroundKey:  /* --background */
@@ -359,6 +360,9 @@ void xmrig::BaseTransform::transformUint64(rapidjson::Document &doc, int key, ui
 #   ifdef XMRIG_FEATURE_HTTP
    case IConfig::DaemonPollKey:  /* --daemon-poll-interval */
        return add(doc, Pools::kPools, Pool::kDaemonPollInterval, arg);
+
+    case IConfig::DaemonZMQPortKey:  /* --daemon-zmq-port */
+        return add(doc, Pools::kPools, Pool::kDaemonZMQPort, arg);
 #   endif

    default:
--- a/src/base/kernel/interfaces/IConfig.h
+++ b/src/base/kernel/interfaces/IConfig.h
@@ -85,6 +85,8 @@ public:
        DnsIPv6Key           = 1053,
        DnsTtlKey            = 1054,
        SpendSecretKey       = 1055,
+        DaemonZMQPortKey     = 1056,
+        HugePagesJitKey      = 1057,

        // xmrig common
        CPUPriorityKey       = 1021,
--- a/src/base/net/stratum/Client.cpp
+++ b/src/base/net/stratum/Client.cpp
@@ -1,13 +1,7 @@
 /* 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 2019      jtgrassie   <https://github.com/jtgrassie>
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2019      jtgrassie   <https://github.com/jtgrassie>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -225,10 +219,14 @@ int64_t xmrig::Client::submit(const JobResult &result)
    if (result.minerSignature()) {
        params.AddMember("sig", StringRef(signature), allocator);
    }
+#   else
+    if (result.sig) {
+        params.AddMember("sig", StringRef(result.sig), allocator);
+    }
 #   endif

    if (has<EXT_ALGO>() && result.algorithm.isValid()) {
-        params.AddMember("algo", StringRef(result.algorithm.shortName()), allocator);
+        params.AddMember("algo", StringRef(result.algorithm.name()), allocator);
    }

    JsonRequest::create(doc, m_sequence, "submit", params);
@@ -440,12 +438,7 @@ bool xmrig::Client::parseJob(const rapidjson::Value &params, int *code)
        return false;
    }

-#   ifndef XMRIG_PROXY_PROJECT
-    uint8_t signatureKeyBuf[32 * 2];
-    if (Cvt::fromHex(signatureKeyBuf, sizeof(signatureKeyBuf), Json::getValue(params, "sig_key"))) {
-        job.setEphemeralKeys(signatureKeyBuf, signatureKeyBuf + 32);
-    }
-#   endif
+    job.setSigKey(Json::getString(params, "sig_key"));

    m_job.setClientId(m_rpcId);

@@ -516,7 +509,7 @@ bool xmrig::Client::verifyAlgorithm(const Algorithm &algorithm, const char *algo
    m_listener->onVerifyAlgorithm(this, algorithm, &ok);

    if (!ok && !isQuiet()) {
-        LOG_ERR("%s " RED("incompatible/disabled algorithm ") RED_BOLD("\"%s\" ") RED("detected, reconnect"), tag(), algorithm.shortName());
+        LOG_ERR("%s " RED("incompatible/disabled algorithm ") RED_BOLD("\"%s\" ") RED("detected, reconnect"), tag(), algorithm.name());
    }

    return ok;
--- a/src/base/net/stratum/Client.h
+++ b/src/base/net/stratum/Client.h
@@ -1,13 +1,7 @@
 /* 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 2019      jtgrassie   <https://github.com/jtgrassie>
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2019      jtgrassie   <https://github.com/jtgrassie>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
--- a/src/base/net/stratum/DaemonClient.cpp
+++ b/src/base/net/stratum/DaemonClient.cpp
@@ -31,10 +31,14 @@
 #include "base/io/json/JsonRequest.h"
 #include "base/io/log/Log.h"
 #include "base/kernel/interfaces/IClientListener.h"
+#include "base/net/dns/Dns.h"
+#include "base/net/dns/DnsRecords.h"
 #include "base/net/http/Fetch.h"
 #include "base/net/http/HttpData.h"
 #include "base/net/http/HttpListener.h"
 #include "base/net/stratum/SubmitResult.h"
+#include "base/net/tools/NetBuffer.h"
+#include "base/tools/bswap_64.h"
 #include "base/tools/Cvt.h"
 #include "base/tools/Timer.h"
 #include "base/tools/cryptonote/Signatures.h"
@@ -48,7 +52,11 @@

 namespace xmrig {

-static const char *kBlocktemplateBlob       = "blocktemplate_blob";
+
+Storage<DaemonClient> DaemonClient::m_storage;
+
+
+static const char* kBlocktemplateBlob = "blocktemplate_blob";
 static const char *kGetHeight               = "/getheight";
 static const char *kGetInfo                 = "/getinfo";
 static const char *kHash                    = "hash";
@@ -57,6 +65,12 @@ static const char *kJsonRPC                 = "/json_rpc";

 static constexpr size_t kBlobReserveSize    = 8;

+static const char kZMQGreeting[64] = { static_cast<char>(-1), 0, 0, 0, 0, 0, 0, 0, 0, 127, 3, 0, 'N', 'U', 'L', 'L' };
+static constexpr size_t kZMQGreetingSize1 = 11;
+
+static const char kZMQHandshake[] = "\4\x19\5READY\xbSocket-Type\0\0\0\3SUB";
+static const char kZMQSubscribe[] = "\0\x18\1json-minimal-chain_main";
+
 }


@@ -65,12 +79,25 @@ xmrig::DaemonClient::DaemonClient(int id, IClientListener *listener) :
 {
    m_httpListener  = std::make_shared<HttpListener>(this);
    m_timer         = new Timer(this);
+    m_key           = m_storage.add(this);
 }


 xmrig::DaemonClient::~DaemonClient()
 {
    delete m_timer;
+    delete m_ZMQSocket;
+}
+
+
+void xmrig::DaemonClient::deleteLater()
+{
+    if (m_pool.zmq_port() >= 0) {
+        ZMQClose(true);
+    }
+    else {
+        delete this;
+    }
 }


@@ -96,7 +123,7 @@ bool xmrig::DaemonClient::isTLS() const

 int64_t xmrig::DaemonClient::submit(const JobResult &result)
 {
-    if (result.jobId != (m_blocktemplateStr.data() + m_blocktemplateStr.size() - 32)) {
+    if (result.jobId != m_currentJobId) {
        return -1;
    }

@@ -114,6 +141,10 @@ int64_t xmrig::DaemonClient::submit(const JobResult &result)
        memcpy(data + m_blocktemplate.eph_public_key_index * 2, result.sig_data + 32 * 2, 32 * 2);
    }

+    if (result.extra_nonce >= 0) {
+        Cvt::toHex(data + m_blocktemplate.tx_extra_nonce_index * 2, 8, reinterpret_cast<const uint8_t*>(&result.extra_nonce), 4);
+    }
+
 #   else

    Cvt::toHex(data + m_job.nonceOffset() * 2, 8, reinterpret_cast<const uint8_t*>(&result.nonce), 4);
@@ -155,7 +186,13 @@ void xmrig::DaemonClient::connect()
    }

    setState(ConnectingState);
+
+    if (m_pool.zmq_port() >= 0) {
+        m_dns = Dns::resolve(m_pool.host(), this);
+    }
+    else {
        getBlockTemplate();
+    }
 }


@@ -234,7 +271,7 @@ void xmrig::DaemonClient::onHttpData(const HttpData &data)
 void xmrig::DaemonClient::onTimer(const Timer *)
 {
    if (m_state == ConnectingState) {
-        getBlockTemplate();
+        connect();
    }
    else if (m_state == ConnectedState) {
        if (m_apiVersion == API_DERO) {
@@ -247,6 +284,43 @@ void xmrig::DaemonClient::onTimer(const Timer *)
 }


+void xmrig::DaemonClient::onResolved(const DnsRecords& records, int status, const char* error)
+{
+    m_dns.reset();
+
+    if (status < 0 && records.isEmpty()) {
+        if (!isQuiet()) {
+            LOG_ERR("%s " RED("DNS error: ") RED_BOLD("\"%s\""), tag(), error);
+        }
+
+        retry();
+        return;
+    }
+
+    if (m_ZMQSocket) {
+        delete m_ZMQSocket;
+    }
+
+    const auto& record = records.get();
+    m_ip = record.ip();
+
+    uv_connect_t* req = new uv_connect_t;
+    req->data = m_storage.ptr(m_key);
+
+    m_ZMQSocket = new uv_tcp_t;
+    m_ZMQSocket->data = m_storage.ptr(m_key);
+
+    uv_tcp_init(uv_default_loop(), m_ZMQSocket);
+    uv_tcp_nodelay(m_ZMQSocket, 1);
+
+#   ifndef WIN32
+    uv_tcp_keepalive(m_ZMQSocket, 1, 60);
+#   endif
+
+    uv_tcp_connect(req, m_ZMQSocket, record.addr(m_pool.zmq_port()), onZMQConnect);
+}
+
+
 bool xmrig::DaemonClient::isOutdated(uint64_t height, const char *hash) const
 {
    return m_job.height() != height || m_prevHash != hash;
@@ -277,6 +351,19 @@ bool xmrig::DaemonClient::parseJob(const rapidjson::Value &params, int *code)
        return false;
    }

+#   ifdef XMRIG_PROXY_PROJECT
+    const size_t k = m_blocktemplate.miner_tx_prefix_begin_index;
+    job.setMinerTx(
+        m_blocktemplate.raw_blob.data() + k,
+        m_blocktemplate.raw_blob.data() + m_blocktemplate.miner_tx_prefix_end_index,
+        m_blocktemplate.eph_public_key_index - k,
+        m_blocktemplate.tx_pubkey_index - k,
+        m_blocktemplate.tx_extra_nonce_index - k,
+        m_blocktemplate.tx_extra_nonce_size,
+        m_blocktemplate.miner_tx_merkle_tree_branch
+    );
+#   endif
+
    m_blockhashingblob = Json::getString(params, "blockhashing_blob");

    if (m_blocktemplate.has_miner_signature) {
@@ -308,13 +395,6 @@ bool xmrig::DaemonClient::parseJob(const rapidjson::Value &params, int *code)

 #       ifdef XMRIG_PROXY_PROJECT
        job.setSpendSecretKey(secret_spendkey);
-        job.setMinerTx(
-            m_blocktemplate.raw_blob.data() + m_blocktemplate.miner_tx_prefix_begin_index,
-            m_blocktemplate.raw_blob.data() + m_blocktemplate.miner_tx_prefix_end_index,
-            m_blocktemplate.eph_public_key_index - m_blocktemplate.miner_tx_prefix_begin_index,
-            m_blocktemplate.tx_pubkey_index - m_blocktemplate.miner_tx_prefix_begin_index,
-            m_blocktemplate.miner_tx_merkle_tree_branch
-        );
 #       else
        uint8_t secret_viewkey[32];
        derive_view_secret_key(secret_spendkey, secret_viewkey);
@@ -377,7 +457,8 @@ bool xmrig::DaemonClient::parseJob(const rapidjson::Value &params, int *code)
    job.setHeight(Json::getUint64(params, kHeight));
    job.setDiff(Json::getUint64(params, "difficulty"));

-    job.setId(blocktemplate.data() + blocktemplate.size() - 32);
+    m_currentJobId = Cvt::toHex(Cvt::randomBytes(4));
+    job.setId(m_currentJobId);

    m_job              = std::move(job);
    m_blocktemplateStr = std::move(blocktemplate);
@@ -441,7 +522,9 @@ bool xmrig::DaemonClient::parseResponse(int64_t id, const rapidjson::Value &resu
    }

    if (handleSubmitResponse(id, error_msg)) {
+        if (error_msg || (m_pool.zmq_port() < 0)) {
            getBlockTemplate();
+        }
        return true;
    }

@@ -493,6 +576,10 @@ void xmrig::DaemonClient::retry()
        setState(ConnectingState);
    }

+    if ((m_ZMQConnectionState != ZMQ_NOT_CONNECTED) && (m_ZMQConnectionState != ZMQ_DISCONNECTING)) {
+        uv_close(reinterpret_cast<uv_handle_t*>(m_ZMQSocket), onZMQClose);
+    }
+
    m_timer->stop();
    m_timer->start(m_retryPause, 0);
 }
@@ -520,9 +607,11 @@ void xmrig::DaemonClient::setState(SocketState state)
            m_failures = 0;
            m_listener->onLoginSuccess(this);

+            if (m_pool.zmq_port() < 0) {
                const uint64_t interval = std::max<uint64_t>(20, m_pool.pollInterval());
                m_timer->start(interval, interval);
            }
+        }
        break;

    case UnconnectedState:
@@ -534,3 +623,282 @@ void xmrig::DaemonClient::setState(SocketState state)
        break;
    }
 }
+
+
+void xmrig::DaemonClient::onZMQConnect(uv_connect_t* req, int status)
+{
+    DaemonClient* client = getClient(req->data);
+    delete req;
+
+    if (!client) {
+        return;
+    }
+
+    if (status < 0) {
+        LOG_ERR("%s " RED("ZMQ connect error: ") RED_BOLD("\"%s\""), client->tag(), uv_strerror(status));
+        client->retry();
+        return;
+    }
+
+    client->ZMQConnected();
+}
+
+
+void xmrig::DaemonClient::onZMQRead(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf)
+{
+    DaemonClient* client = getClient(stream->data);
+    if (client) {
+        client->ZMQRead(nread, buf);
+    }
+
+    NetBuffer::release(buf);
+}
+
+
+void xmrig::DaemonClient::onZMQClose(uv_handle_t* handle)
+{
+    DaemonClient* client = getClient(handle->data);
+    if (client) {
+#       ifdef APP_DEBUG
+        LOG_DEBUG(CYAN("tcp-zmq://%s:%u") BLACK_BOLD(" disconnected"), client->m_pool.host().data(), client->m_pool.zmq_port());
+#       endif
+        client->m_ZMQConnectionState = ZMQ_NOT_CONNECTED;
+    }
+}
+
+
+void xmrig::DaemonClient::onZMQShutdown(uv_handle_t* handle)
+{
+    DaemonClient* client = getClient(handle->data);
+    if (client) {
+#       ifdef APP_DEBUG
+        LOG_DEBUG(CYAN("tcp-zmq://%s:%u") BLACK_BOLD(" shutdown"), client->m_pool.host().data(), client->m_pool.zmq_port());
+#       endif
+        client->m_ZMQConnectionState = ZMQ_NOT_CONNECTED;
+        m_storage.remove(client->m_key);
+    }
+}
+
+
+void xmrig::DaemonClient::ZMQConnected()
+{
+#   ifdef APP_DEBUG
+    LOG_DEBUG(CYAN("tcp-zmq://%s:%u") BLACK_BOLD(" connected"), m_pool.host().data(), m_pool.zmq_port());
+#   endif
+
+    m_ZMQConnectionState = ZMQ_GREETING_1;
+    m_ZMQSendBuf.reserve(256);
+    m_ZMQRecvBuf.reserve(256);
+
+    if (ZMQWrite(kZMQGreeting, kZMQGreetingSize1)) {
+        uv_read_start(reinterpret_cast<uv_stream_t*>(m_ZMQSocket), NetBuffer::onAlloc, onZMQRead);
+    }
+}
+
+
+bool xmrig::DaemonClient::ZMQWrite(const char* data, size_t size)
+{
+    m_ZMQSendBuf.assign(data, data + size);
+
+    uv_buf_t buf;
+    buf.base = m_ZMQSendBuf.data();
+    buf.len = static_cast<uint32_t>(m_ZMQSendBuf.size());
+
+    const int rc = uv_try_write(reinterpret_cast<uv_stream_t*>(m_ZMQSocket), &buf, 1);
+
+    if (static_cast<size_t>(rc) == buf.len) {
+        return true;
+    }
+
+    LOG_ERR("%s " RED("ZMQ write failed, rc = %d"), tag(), rc);
+    ZMQClose();
+    return false;
+}
+
+
+void xmrig::DaemonClient::ZMQRead(ssize_t nread, const uv_buf_t* buf)
+{
+    if (nread <= 0) {
+        LOG_ERR("%s " RED("ZMQ read failed, nread = %" PRId64), tag(), nread);
+        ZMQClose();
+        return;
+    }
+
+    m_ZMQRecvBuf.insert(m_ZMQRecvBuf.end(), buf->base, buf->base + nread);
+
+    do {
+        switch (m_ZMQConnectionState) {
+        case ZMQ_GREETING_1:
+            if (m_ZMQRecvBuf.size() >= kZMQGreetingSize1) {
+                if ((m_ZMQRecvBuf[0] == static_cast<char>(-1)) && (m_ZMQRecvBuf[9] == 127) && (m_ZMQRecvBuf[10] == 3)) {
+                    ZMQWrite(kZMQGreeting + kZMQGreetingSize1, sizeof(kZMQGreeting) - kZMQGreetingSize1);
+                    m_ZMQConnectionState = ZMQ_GREETING_2;
+                    break;
+                }
+                else {
+                    LOG_ERR("%s " RED("ZMQ handshake failed: invalid greeting format"), tag());
+                    ZMQClose();
+                }
+            }
+            return;
+
+        case ZMQ_GREETING_2:
+            if (m_ZMQRecvBuf.size() >= sizeof(kZMQGreeting)) {
+                if (memcmp(m_ZMQRecvBuf.data() + 12, kZMQGreeting + 12, 20) == 0) {
+                    m_ZMQConnectionState = ZMQ_HANDSHAKE;
+                    m_ZMQRecvBuf.erase(m_ZMQRecvBuf.begin(), m_ZMQRecvBuf.begin() + sizeof(kZMQGreeting));
+
+                    ZMQWrite(kZMQHandshake, sizeof(kZMQHandshake) - 1);
+                    break;
+                }
+                else {
+                    LOG_ERR("%s " RED("ZMQ handshake failed: invalid greeting format 2"), tag());
+                    ZMQClose();
+                }
+            }
+            return;
+
+        case ZMQ_HANDSHAKE:
+            if (m_ZMQRecvBuf.size() >= 2) {
+                if (m_ZMQRecvBuf[0] != 4) {
+                    LOG_ERR("%s " RED("ZMQ handshake failed: invalid handshake format"), tag());
+                    ZMQClose();
+                    return;
+                }
+
+                const size_t size = static_cast<unsigned char>(m_ZMQRecvBuf[1]);
+                if (size < 18) {
+                    LOG_ERR("%s " RED("ZMQ handshake failed: invalid handshake size"), tag());
+                    ZMQClose();
+                    return;
+                }
+
+                if (m_ZMQRecvBuf.size() < size + 2) {
+                    return;
+                }
+
+                if (memcmp(m_ZMQRecvBuf.data() + 2, kZMQHandshake + 2, 18) != 0) {
+                    LOG_ERR("%s " RED("ZMQ handshake failed: invalid handshake data"), tag());
+                    ZMQClose();
+                    return;
+                }
+
+                ZMQWrite(kZMQSubscribe, sizeof(kZMQSubscribe) - 1);
+
+                m_ZMQConnectionState = ZMQ_CONNECTED;
+                m_ZMQRecvBuf.erase(m_ZMQRecvBuf.begin(), m_ZMQRecvBuf.begin() + size + 2);
+
+                getBlockTemplate();
+                break;
+            }
+            return;
+
+        case ZMQ_CONNECTED:
+            ZMQParse();
+            return;
+
+        default:
+            return;
+        }
+    } while (true);
+}
+
+
+void xmrig::DaemonClient::ZMQParse()
+{
+#   ifdef APP_DEBUG
+    std::vector<char> msg;
+#   endif
+
+    size_t msg_size = 0;
+
+    char* data = m_ZMQRecvBuf.data();
+    size_t avail = m_ZMQRecvBuf.size();
+    bool more;
+
+    do {
+        if (avail < 1) {
+            return;
+        }
+
+        more                 = (data[0] & 1) != 0;
+        const bool long_size = (data[0] & 2) != 0;
+        const bool command   = (data[0] & 4) != 0;
+
+        ++data;
+        --avail;
+
+        uint64_t size = 0;
+        if (long_size)
+        {
+            if (avail < sizeof(uint64_t)) {
+                return;
+            }
+            size = bswap_64(*((uint64_t*)data));
+            data += sizeof(uint64_t);
+            avail -= sizeof(uint64_t);
+        }
+        else
+        {
+            if (avail < sizeof(uint8_t)) {
+                return;
+            }
+            size = static_cast<uint8_t>(*data);
+            ++data;
+            --avail;
+        }
+
+        if (size > 1024U - msg_size)
+        {
+            LOG_ERR("%s " RED("ZMQ message is too large, size = %" PRIu64 " bytes"), tag(), size);
+            ZMQClose();
+            return;
+        }
+
+        if (avail < size) {
+            return;
+        }
+
+        if (!command) {
+#           ifdef APP_DEBUG
+            msg.insert(msg.end(), data, data + size);
+#           endif
+
+            msg_size += size;
+        }
+
+        data += size;
+        avail -= size;
+    } while (more);
+
+    m_ZMQRecvBuf.erase(m_ZMQRecvBuf.begin(), m_ZMQRecvBuf.begin() + (data - m_ZMQRecvBuf.data()));
+
+#   ifdef APP_DEBUG
+    LOG_DEBUG(CYAN("tcp-zmq://%s:%u") BLACK_BOLD(" read ") CYAN_BOLD("%zu") BLACK_BOLD(" bytes") " %s", m_pool.host().data(), m_pool.zmq_port(), msg.size(), msg.data());
+#   endif
+
+    getBlockTemplate();
+}
+
+
+bool xmrig::DaemonClient::ZMQClose(bool shutdown)
+{
+    if ((m_ZMQConnectionState == ZMQ_NOT_CONNECTED) || (m_ZMQConnectionState == ZMQ_DISCONNECTING)) {
+        if (shutdown) {
+            m_storage.remove(m_key);
+        }
+        return false;
+    }
+
+    m_ZMQConnectionState = ZMQ_DISCONNECTING;
+
+    if (uv_is_closing(reinterpret_cast<uv_handle_t*>(m_ZMQSocket)) == 0) {
+        uv_close(reinterpret_cast<uv_handle_t*>(m_ZMQSocket), shutdown ? onZMQShutdown : onZMQClose);
+        if (!shutdown) {
+            retry();
+        }
+        return true;
+    }
+
+    return false;
+}
--- a/src/base/net/stratum/DaemonClient.h
+++ b/src/base/net/stratum/DaemonClient.h
@@ -27,11 +27,16 @@
 #define XMRIG_DAEMONCLIENT_H


+#include <uv.h>
+
+
+#include "base/kernel/interfaces/IDnsListener.h"
 #include "base/kernel/interfaces/IHttpListener.h"
 #include "base/kernel/interfaces/ITimerListener.h"
 #include "base/net/stratum/BaseClient.h"
 #include "base/tools/Object.h"
 #include "base/tools/cryptonote/BlockTemplate.h"
+#include "base/net/tools/Storage.h"


 #include <memory>
@@ -40,7 +45,10 @@
 namespace xmrig {


-class DaemonClient : public BaseClient, public ITimerListener, public IHttpListener
+class DnsRequest;
+
+
+class DaemonClient : public BaseClient, public IDnsListener, public ITimerListener, public IHttpListener
 {
 public:
    XMRIG_DISABLE_COPY_MOVE_DEFAULT(DaemonClient)
@@ -57,6 +65,7 @@ protected:

    void onHttpData(const HttpData &data) override;
    void onTimer(const Timer *timer) override;
+    void onResolved(const DnsRecords& records, int status, const char* error) override;

    inline bool hasExtension(Extension) const noexcept override         { return false; }
    inline const char *mode() const override                            { return "daemon"; }
@@ -64,7 +73,7 @@ protected:
    inline const char *tlsVersion() const override                      { return m_tlsVersion; }
    inline int64_t send(const rapidjson::Value &, Callback) override    { return -1; }
    inline int64_t send(const rapidjson::Value &) override              { return -1; }
-    inline void deleteLater() override                                  { delete this; }
+    void deleteLater() override;
    inline void tick(uint64_t) override                                 {}

 private:
@@ -84,6 +93,7 @@ private:
    } m_apiVersion = API_MONERO;

    std::shared_ptr<IHttpListener> m_httpListener;
+    String m_currentJobId;
    String m_blocktemplateStr;
    String m_blockhashingblob;
    String m_prevHash;
@@ -94,6 +104,38 @@ private:
    String m_blocktemplateRequestHash;

    BlockTemplate m_blocktemplate;
+
+private:
+    static inline DaemonClient* getClient(void* data) { return m_storage.get(data); }
+
+    uintptr_t m_key = 0;
+    static Storage<DaemonClient> m_storage;
+
+    static void onZMQConnect(uv_connect_t* req, int status);
+    static void onZMQRead(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf);
+    static void onZMQClose(uv_handle_t* handle);
+    static void onZMQShutdown(uv_handle_t* handle);
+
+    void ZMQConnected();
+    bool ZMQWrite(const char* data, size_t size);
+    void ZMQRead(ssize_t nread, const uv_buf_t* buf);
+    void ZMQParse();
+    bool ZMQClose(bool shutdown = false);
+
+    std::shared_ptr<DnsRequest> m_dns;
+    uv_tcp_t* m_ZMQSocket = nullptr;
+
+    enum {
+        ZMQ_NOT_CONNECTED,
+        ZMQ_GREETING_1,
+        ZMQ_GREETING_2,
+        ZMQ_HANDSHAKE,
+        ZMQ_CONNECTED,
+        ZMQ_DISCONNECTING,
+    } m_ZMQConnectionState = ZMQ_NOT_CONNECTED;
+
+    std::vector<char> m_ZMQSendBuf;
+    std::vector<char> m_ZMQRecvBuf;
 };


--- a/src/base/net/stratum/EthStratumClient.cpp
+++ b/src/base/net/stratum/EthStratumClient.cpp
@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -213,7 +213,7 @@ void xmrig::EthStratumClient::parseNotification(const char *method, const rapidj

        if (!ok) {
            if (!isQuiet()) {
-                LOG_ERR("[%s] incompatible/disabled algorithm \"%s\" detected, reconnect", url(), algo.shortName());
+                LOG_ERR("[%s] incompatible/disabled algorithm \"%s\" detected, reconnect", url(), algo.name());
            }
            close();
            return;
--- a/src/base/net/stratum/EthStratumClient.h
+++ b/src/base/net/stratum/EthStratumClient.h
@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
--- a/src/base/net/stratum/Job.cpp
+++ b/src/base/net/stratum/Job.cpp
@@ -7,8 +7,8 @@
 * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
 * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
 * Copyright 2019      Howard Chu  <https://github.com/hyc>
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2021 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
@@ -144,6 +144,50 @@ void xmrig::Job::setDiff(uint64_t diff)
 }


+void xmrig::Job::setSigKey(const char *sig_key)
+{
+    constexpr const size_t size = 64;
+
+    if (!sig_key || strlen(sig_key) != size * 2) {
+        return;
+    }
+
+#   ifndef XMRIG_PROXY_PROJECT
+    const auto buf = Cvt::fromHex(sig_key, size * 2);
+    if (buf.size() == size) {
+        setEphemeralKeys(buf.data(), buf.data() + 32);
+    }
+#   else
+    m_rawSigKey = sig_key;
+#   endif
+}
+
+
+uint32_t xmrig::Job::getNumTransactions() const
+{
+    if (!(m_algorithm.isCN() || m_algorithm.family() == Algorithm::RANDOM_X)) {
+        return 0;
+    }
+
+    uint32_t num_transactions = 0;
+
+    // Monero (and some other coins) has the number of transactions encoded as varint in the end of hashing blob
+    const size_t expected_tx_offset = (m_algorithm == Algorithm::RX_WOW) ? 141 : 75;
+
+    if ((m_size > expected_tx_offset) && (m_size <= expected_tx_offset + 4)) {
+        for (size_t i = expected_tx_offset, k = 0; i < m_size; ++i, k += 7) {
+            const uint8_t b = m_blob[i];
+            num_transactions |= static_cast<uint32_t>(b & 0x7F) << k;
+            if ((b & 0x80) == 0) {
+                break;
+            }
+        }
+    }
+
+    return num_transactions;
+}
+
+
 void xmrig::Job::copy(const Job &other)
 {
    m_algorithm  = other.m_algorithm;
@@ -164,6 +208,7 @@ void xmrig::Job::copy(const Job &other)

 #   ifdef XMRIG_PROXY_PROJECT
    m_rawSeedHash = other.m_rawSeedHash;
+    m_rawSigKey   = other.m_rawSigKey;

    memcpy(m_rawBlob, other.m_rawBlob, sizeof(m_rawBlob));
    memcpy(m_rawTarget, other.m_rawTarget, sizeof(m_rawTarget));
@@ -181,6 +226,8 @@ void xmrig::Job::copy(const Job &other)
    m_minerTxPrefix = other.m_minerTxPrefix;
    m_minerTxEphPubKeyOffset = other.m_minerTxEphPubKeyOffset;
    m_minerTxPubKeyOffset = other.m_minerTxPubKeyOffset;
+    m_minerTxExtraNonceOffset = other.m_minerTxExtraNonceOffset;
+    m_minerTxExtraNonceSize = other.m_minerTxExtraNonceSize;
    m_minerTxMerkleTreeBranch = other.m_minerTxMerkleTreeBranch;
 #   else
    memcpy(m_ephPublicKey, other.m_ephPublicKey, sizeof(m_ephPublicKey));
@@ -215,6 +262,7 @@ void xmrig::Job::move(Job &&other)

 #   ifdef XMRIG_PROXY_PROJECT
    m_rawSeedHash = std::move(other.m_rawSeedHash);
+    m_rawSigKey   = std::move(other.m_rawSigKey);

    memcpy(m_rawBlob, other.m_rawBlob, sizeof(m_rawBlob));
    memcpy(m_rawTarget, other.m_rawTarget, sizeof(m_rawTarget));
@@ -229,9 +277,12 @@ void xmrig::Job::move(Job &&other)
    memcpy(m_viewSecretKey, other.m_viewSecretKey, sizeof(m_viewSecretKey));
    memcpy(m_spendPublicKey, other.m_spendPublicKey, sizeof(m_spendPublicKey));
    memcpy(m_viewPublicKey, other.m_viewPublicKey, sizeof(m_viewPublicKey));
+
    m_minerTxPrefix             = std::move(other.m_minerTxPrefix);
    m_minerTxEphPubKeyOffset    = other.m_minerTxEphPubKeyOffset;
    m_minerTxPubKeyOffset       = other.m_minerTxPubKeyOffset;
+    m_minerTxExtraNonceOffset   = other.m_minerTxExtraNonceOffset;
+    m_minerTxExtraNonceSize     = other.m_minerTxExtraNonceSize;
    m_minerTxMerkleTreeBranch   = std::move(other.m_minerTxMerkleTreeBranch);
 #   else
    memcpy(m_ephPublicKey, other.m_ephPublicKey, sizeof(m_ephPublicKey));
@@ -245,26 +296,35 @@ void xmrig::Job::move(Job &&other)
 #ifdef XMRIG_PROXY_PROJECT


-void xmrig::Job::setSpendSecretKey(uint8_t* key)
+void xmrig::Job::setSpendSecretKey(const uint8_t *key)
 {
    m_hasMinerSignature = true;
    memcpy(m_spendSecretKey, key, sizeof(m_spendSecretKey));
-    xmrig::derive_view_secret_key(m_spendSecretKey, m_viewSecretKey);
-    xmrig::secret_key_to_public_key(m_spendSecretKey, m_spendPublicKey);
-    xmrig::secret_key_to_public_key(m_viewSecretKey, m_viewPublicKey);
+
+    derive_view_secret_key(m_spendSecretKey, m_viewSecretKey);
+    secret_key_to_public_key(m_spendSecretKey, m_spendPublicKey);
+    secret_key_to_public_key(m_viewSecretKey, m_viewPublicKey);
 }


-void xmrig::Job::setMinerTx(const uint8_t* begin, const uint8_t* end, size_t minerTxEphPubKeyOffset, size_t minerTxPubKeyOffset, const Buffer& minerTxMerkleTreeBranch)
+void xmrig::Job::setMinerTx(const uint8_t *begin, const uint8_t *end, size_t minerTxEphPubKeyOffset, size_t minerTxPubKeyOffset, size_t minerTxExtraNonceOffset, size_t minerTxExtraNonceSize, const Buffer &minerTxMerkleTreeBranch)
 {
    m_minerTxPrefix.assign(begin, end);
    m_minerTxEphPubKeyOffset    = minerTxEphPubKeyOffset;
    m_minerTxPubKeyOffset       = minerTxPubKeyOffset;
+    m_minerTxExtraNonceOffset   = minerTxExtraNonceOffset;
+    m_minerTxExtraNonceSize     = minerTxExtraNonceSize;
    m_minerTxMerkleTreeBranch   = minerTxMerkleTreeBranch;
 }


-void xmrig::Job::generateHashingBlob(String& blob, String& signatureData) const
+void xmrig::Job::setExtraNonceInMinerTx(uint32_t extra_nonce)
+{
+    memcpy(m_minerTxPrefix.data() + m_minerTxExtraNonceOffset, &extra_nonce, std::min(m_minerTxExtraNonceSize, sizeof(uint32_t)));
+}
+
+
+void xmrig::Job::generateSignatureData(String &signatureData) const
 {
    uint8_t* eph_public_key = m_minerTxPrefix.data() + m_minerTxEphPubKeyOffset;
    uint8_t* txkey_pub = m_minerTxPrefix.data() + m_minerTxPubKeyOffset;
@@ -285,15 +345,23 @@ void xmrig::Job::generateHashingBlob(String& blob, String& signatureData) const
    generate_key_derivation(txkey_pub, m_viewSecretKey, derivation);
    derive_secret_key(derivation, 0, m_spendSecretKey, buf + 64);

-    signatureData = xmrig::Cvt::toHex(buf, sizeof(buf));
+    signatureData = Cvt::toHex(buf, sizeof(buf));
+}

+void xmrig::Job::generateHashingBlob(String &blob) const
+{
    uint8_t root_hash[32];
    const uint8_t* p = m_minerTxPrefix.data();
-    xmrig::BlockTemplate::CalculateRootHash(p, p + m_minerTxPrefix.size(), m_minerTxMerkleTreeBranch, root_hash);
+    BlockTemplate::CalculateRootHash(p, p + m_minerTxPrefix.size(), m_minerTxMerkleTreeBranch, root_hash);
+
+    uint64_t root_hash_offset = nonceOffset() + nonceSize();
+
+    if (m_hasMinerSignature) {
+        root_hash_offset += BlockTemplate::SIGNATURE_SIZE + 2 /* vote */;
+    }

    blob = rawBlob();
-    const uint64_t offset = nonceOffset() + nonceSize() + BlockTemplate::SIGNATURE_SIZE + 2 /* vote */;
-    xmrig::Cvt::toHex(blob.data() + offset * 2, 64, root_hash, 32);
+    Cvt::toHex(blob.data() + root_hash_offset * 2, 64, root_hash, BlockTemplate::HASH_SIZE);
 }


--- a/src/base/net/stratum/Job.h
+++ b/src/base/net/stratum/Job.h
@@ -7,8 +7,8 @@
 * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
 * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
 * Copyright 2019      Howard Chu  <https://github.com/hyc>
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2021 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
@@ -63,6 +63,7 @@ public:
    bool setSeedHash(const char *hash);
    bool setTarget(const char *target);
    void setDiff(uint64_t diff);
+    void setSigKey(const char *sig_key);

    inline bool isNicehash() const                      { return m_nicehash; }
    inline bool isValid() const                         { return (m_size > 0 && m_diff > 0) || !m_poolWallet.isEmpty(); }
@@ -102,6 +103,7 @@ public:
    inline const char *rawBlob() const                  { return m_rawBlob; }
    inline const char *rawTarget() const                { return m_rawTarget; }
    inline const String &rawSeedHash() const            { return m_rawSeedHash; }
+    inline const String &rawSigKey() const              { return m_rawSigKey; }
 #   endif

    static inline uint64_t toDiff(uint64_t target)      { return target ? (0xFFFFFFFFFFFFFFFFULL / target) : 0; }
@@ -117,13 +119,15 @@ public:
 #   endif

 #   ifdef XMRIG_PROXY_PROJECT
-    void setSpendSecretKey(uint8_t* key);
-    void setMinerTx(const uint8_t* begin, const uint8_t* end, size_t minerTxEphPubKeyOffset, size_t minerTxPubKeyOffset, const Buffer& minerTxMerkleTreeBranch);
-    void generateHashingBlob(String& blob, String& signatureData) const;
+    void setSpendSecretKey(const uint8_t* key);
+    void setMinerTx(const uint8_t* begin, const uint8_t* end, size_t minerTxEphPubKeyOffset, size_t minerTxPubKeyOffset, size_t minerTxExtraNonceOffset, size_t minerTxExtraNonceSize, const Buffer& minerTxMerkleTreeBranch);
+    void setExtraNonceInMinerTx(uint32_t extra_nonce);
+    void generateSignatureData(String& signatureData) const;
+    void generateHashingBlob(String& blob) const;
 #   else
    inline const uint8_t* ephSecretKey() const { return m_hasMinerSignature ? m_ephSecretKey : nullptr; }

-    inline void setEphemeralKeys(uint8_t* pub_key, uint8_t* sec_key)
+    inline void setEphemeralKeys(const uint8_t *pub_key, const uint8_t *sec_key)
    {
        m_hasMinerSignature = true;
        memcpy(m_ephPublicKey, pub_key, sizeof(m_ephSecretKey));
@@ -135,6 +139,8 @@ public:

    inline bool hasMinerSignature() const { return m_hasMinerSignature; }

+    uint32_t getNumTransactions() const;
+
 private:
    void copy(const Job &other);
    void move(Job &&other);
@@ -158,15 +164,18 @@ private:
    char m_rawBlob[kMaxBlobSize * 2 + 8]{};
    char m_rawTarget[24]{};
    String m_rawSeedHash;
+    String m_rawSigKey;

    // Miner signatures
-    uint8_t m_spendSecretKey[32];
-    uint8_t m_viewSecretKey[32];
-    uint8_t m_spendPublicKey[32];
-    uint8_t m_viewPublicKey[32];
+    uint8_t m_spendSecretKey[32]{};
+    uint8_t m_viewSecretKey[32]{};
+    uint8_t m_spendPublicKey[32]{};
+    uint8_t m_viewPublicKey[32]{};
    mutable Buffer m_minerTxPrefix;
    size_t m_minerTxEphPubKeyOffset = 0;
    size_t m_minerTxPubKeyOffset = 0;
+    size_t m_minerTxExtraNonceOffset = 0;
+    size_t m_minerTxExtraNonceSize = 0;
    Buffer m_minerTxMerkleTreeBranch;
 #   else
    // Miner signatures
--- a/src/base/net/stratum/NetworkState.cpp
+++ b/src/base/net/stratum/NetworkState.cpp
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -22,7 +16,6 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-
 #include "base/net/stratum/NetworkState.h"
 #include "3rdparty/rapidjson/document.h"
 #include "base/io/log/Log.h"
@@ -196,7 +189,7 @@ void xmrig::NetworkState::printConnection() const
    Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-17s") CYAN_BOLD("%s ") BLACK_BOLD("(%s) ") GREEN_BOLD("%s"),
               "pool address", m_pool, m_ip.data(), m_tls.isNull() ? "" : m_tls.data());

-    Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-17s") WHITE_BOLD("%s"), "algorithm", m_algorithm.shortName());
+    Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-17s") WHITE_BOLD("%s"), "algorithm", m_algorithm.name());
    printDiff(m_diff);
    printLatency(latency());
    Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-17s") CYAN_BOLD("%" PRIu64 "s"), "connection time", connectionTime() / 1000);
--- a/src/base/net/stratum/NetworkState.h
+++ b/src/base/net/stratum/NetworkState.h
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
--- a/src/base/net/stratum/Pool.cpp
+++ b/src/base/net/stratum/Pool.cpp
@@ -1,7 +1,7 @@
 /* XMRig
 * Copyright (c) 2019      Howard Chu  <https://github.com/hyc>
- * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -17,7 +17,6 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-
 #include <cassert>
 #include <cstring>
 #include <cstdlib>
@@ -66,6 +65,7 @@ const char *Pool::kAlgo                   = "algo";
 const char *Pool::kCoin                   = "coin";
 const char *Pool::kDaemon                 = "daemon";
 const char *Pool::kDaemonPollInterval     = "daemon-poll-interval";
+const char *Pool::kDaemonZMQPort          = "daemon-zmq-port";
 const char *Pool::kEnabled                = "enabled";
 const char *Pool::kFingerprint            = "tls-fingerprint";
 const char *Pool::kKeepalive              = "keepalive";
@@ -127,6 +127,7 @@ xmrig::Pool::Pool(const rapidjson::Value &object) :
    m_coin           = Json::getString(object, kCoin);
    m_daemon         = Json::getString(object, kSelfSelect);
    m_proxy          = Json::getValue(object, kSOCKS5);
+    m_zmqPort        = Json::getInt(object, kDaemonZMQPort, m_zmqPort);

    m_flags.set(FLAG_ENABLED,  Json::getBool(object, kEnabled, true));
    m_flags.set(FLAG_NICEHASH, Json::getBool(object, kNicehash) || m_url.host().contains(kNicehashHost));
@@ -301,6 +302,7 @@ rapidjson::Value xmrig::Pool::toJSON(rapidjson::Document &doc) const

    if (m_mode == MODE_DAEMON) {
        obj.AddMember(StringRef(kDaemonPollInterval), m_pollInterval, allocator);
+        obj.AddMember(StringRef(kDaemonZMQPort), m_zmqPort, allocator);
    }
    else {
        obj.AddMember(StringRef(kSelfSelect),     m_daemon.url().toJSON(), allocator);
@@ -319,7 +321,7 @@ std::string xmrig::Pool::printableName() const
        out += std::string(" coin ") + WHITE_BOLD_S + m_coin.name() + CLEAR;
    }
    else {
-        out += std::string(" algo ") + WHITE_BOLD_S + (m_algorithm.isValid() ? m_algorithm.shortName() : "auto") + CLEAR;
+        out += std::string(" algo ") + WHITE_BOLD_S + (m_algorithm.isValid() ? m_algorithm.name() : "auto") + CLEAR;
    }

    if (m_mode == MODE_SELF_SELECT) {
@@ -336,6 +338,9 @@ void xmrig::Pool::print() const
    LOG_NOTICE("url:       %s", url().data());
    LOG_DEBUG ("host:      %s", host().data());
    LOG_DEBUG ("port:      %d", static_cast<int>(port()));
+    if (m_zmqPort >= 0) {
+        LOG_DEBUG("zmq-port:  %d", m_zmqPort);
+    }
    LOG_DEBUG ("user:      %s", m_user.data());
    LOG_DEBUG ("pass:      %s", m_password.data());
    LOG_DEBUG ("rig-id     %s", m_rigId.data());
--- a/src/base/net/stratum/Pool.h
+++ b/src/base/net/stratum/Pool.h
@@ -1,7 +1,7 @@
 /* XMRig
 * Copyright (c) 2019      Howard Chu  <https://github.com/hyc>
- * Copyright (c) 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -72,6 +72,7 @@ public:
    static const char *kUrl;
    static const char *kUser;
    static const char* kSpendSecretKey;
+    static const char* kDaemonZMQPort;
    static const char *kNicehashHost;

    constexpr static int kKeepAliveTimeout         = 60;
@@ -107,6 +108,7 @@ public:
    inline int keepAlive() const                        { return m_keepAlive; }
    inline Mode mode() const                            { return m_mode; }
    inline uint16_t port() const                        { return m_url.port(); }
+    inline int zmq_port() const                         { return m_zmqPort; }
    inline uint64_t pollInterval() const                { return m_pollInterval; }
    inline void setAlgo(const Algorithm &algorithm)     { m_algorithm = algorithm; }
    inline void setPassword(const String &password)     { m_password = password; }
@@ -155,6 +157,7 @@ private:
    uint64_t m_pollInterval         = kDefaultPollInterval;
    Url m_daemon;
    Url m_url;
+    int m_zmqPort                   = -1;

 #   ifdef XMRIG_FEATURE_BENCHMARK
    std::shared_ptr<BenchConfig> m_benchmark;
--- a/src/base/net/stratum/benchmark/BenchClient.cpp
+++ b/src/base/net/stratum/benchmark/BenchClient.cpp
@@ -263,7 +263,7 @@ void xmrig::BenchClient::start()
               tag(),
               size < 1000000 ? size / 1000 : size / 1000000,
               size < 1000000 ? "K" : "M",
-               m_job.algorithm().shortName());
+               m_job.algorithm().name());

    m_listener->onLoginSuccess(this);
    m_listener->onJobReceived(this, m_job, rapidjson::Value());
--- a/src/base/tools/bswap_64.h
+++ b/src/base/tools/bswap_64.h
@@ -0,0 +1,37 @@
+/* XMRig
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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_BSWAP_64_H
+#define XMRIG_BSWAP_64_H
+
+#ifdef _MSC_VER
+
+#include <stdlib.h>
+#define bswap_64(x) _byteswap_uint64(x)
+
+#elif defined __GNUC__
+
+#define bswap_64(x) __builtin_bswap64(x)
+
+#else
+
+#include <byteswap.h>
+
+#endif
+
+#endif /* XMRIG_BSWAP_64_H */
--- a/src/base/tools/cryptonote/BlobReader.h
+++ b/src/base/tools/cryptonote/BlobReader.h
@@ -61,6 +61,8 @@ public:

    inline size_t index() const { return m_index; }

+    inline void skip(size_t N) { m_index += N; }
+
 private:
    inline bool getByte(uint8_t& data)
    {
--- a/src/base/tools/cryptonote/BlockTemplate.cpp
+++ b/src/base/tools/cryptonote/BlockTemplate.cpp
@@ -86,13 +86,35 @@ bool BlockTemplate::Init(const String& blockTemplate, Coin coin)
    ar(eph_public_key);
    ar(extra_size);

-    tx_pubkey_index = ar.index() + 1;
+    const uint64_t tx_extra_index = ar.index();

    ar.readItems(extra, extra_size);

-    // First thing in tx_extra must be TX_EXTRA_TAG_PUBKEY
-    if (extra[0] != 0x01)
-        return false;
+    CBlobReader ar_extra(extra.data(), extra_size);
+
+    tx_extra_nonce_size = 0;
+    tx_extra_nonce_index = 0;
+
+    while (ar_extra.index() < extra_size) {
+        uint64_t extra_tag = 0;
+        ar_extra(extra_tag);
+
+        switch (extra_tag) {
+        case 0x01: // TX_EXTRA_TAG_PUBKEY
+            tx_pubkey_index = tx_extra_index + ar_extra.index();
+            ar_extra.skip(KEY_SIZE);
+            break;
+
+        case 0x02: // TX_EXTRA_NONCE
+            ar_extra(tx_extra_nonce_size);
+            tx_extra_nonce_index = tx_extra_index + ar_extra.index();
+            ar_extra.skip(tx_extra_nonce_size);
+            break;
+
+        default:
+            return false; // TODO: handle other tags
+        }
+    }

    miner_tx_prefix_end_index = ar.index();
    // Prefix end
--- a/src/base/tools/cryptonote/BlockTemplate.h
+++ b/src/base/tools/cryptonote/BlockTemplate.h
@@ -42,6 +42,8 @@ struct BlockTemplate
    Buffer raw_blob;
    size_t eph_public_key_index;
    size_t tx_pubkey_index;
+    uint64_t tx_extra_nonce_size;
+    size_t tx_extra_nonce_index;
    size_t miner_tx_prefix_begin_index;
    size_t miner_tx_prefix_end_index;

--- a/src/core/Miner.cpp
+++ b/src/core/Miner.cpp
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -22,7 +16,6 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-
 #include <algorithm>
 #include <mutex>
 #include <thread>
@@ -116,15 +109,7 @@ public:

    inline void rebuild()
    {
-        algorithms.clear();
-
-        for (int i = 0; i < Algorithm::MAX; ++i) {
-            const Algorithm algo(static_cast<Algorithm::Id>(i));
-
-            if (algo.isValid() && isEnabled(algo)) {
-                algorithms.push_back(algo);
-            }
-        }
+        algorithms = Algorithm::all([this](const Algorithm &algo) { return isEnabled(algo); });
    }


@@ -171,7 +156,7 @@ public:
        Value algo(kArrayType);

        for (const Algorithm &a : algorithms) {
-            algo.PushBack(StringRef(a.shortName()), allocator);
+            algo.PushBack(StringRef(a.name()), allocator);
        }

        reply.AddMember("algorithms", algo, allocator);
--- a/src/core/Miner.h
+++ b/src/core/Miner.h
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
--- a/src/core/config/ConfigTransform.cpp
+++ b/src/core/config/ConfigTransform.cpp
@@ -195,6 +195,9 @@ void xmrig::ConfigTransform::transform(rapidjson::Document &doc, int key, const

    case IConfig::RandomXCacheQoSKey: /* --cache-qos */
        return set(doc, RxConfig::kField, RxConfig::kCacheQoS, true);
+
+    case IConfig::HugePagesJitKey: /* --huge-pages-jit */
+        return set(doc, CpuConfig::kField, CpuConfig::kHugePagesJit, true);
 #   endif

 #   ifdef XMRIG_FEATURE_OPENCL
--- a/src/core/config/Config_platform.h
+++ b/src/core/config/Config_platform.h
@@ -52,6 +52,7 @@ static const option options[] = {
    { "daemon-poll-interval",  1, nullptr, IConfig::DaemonPollKey         },
    { "self-select",           1, nullptr, IConfig::SelfSelectKey         },
    { "submit-to-origin",      0, nullptr, IConfig::SubmitToOriginKey     },
+    { "daemon-zmq-port",       1, nullptr, IConfig::DaemonZMQPortKey      },
 #   endif
    { "av",                    1, nullptr, IConfig::AVKey                 },
    { "background",            0, nullptr, IConfig::BackgroundKey         },
@@ -68,6 +69,8 @@ static const option options[] = {
    { "no-huge-pages",         0, nullptr, IConfig::HugePagesKey          },
    { "no-hugepages",          0, nullptr, IConfig::HugePagesKey          },
    { "hugepage-size",         1, nullptr, IConfig::HugePageSizeKey       },
+    { "huge-pages-jit",        0, nullptr, IConfig::HugePagesJitKey       },
+    { "hugepages-jit",         0, nullptr, IConfig::HugePagesJitKey       },
    { "pass",                  1, nullptr, IConfig::PasswordKey           },
    { "print-time",            1, nullptr, IConfig::PrintTimeKey          },
    { "retries",               1, nullptr, IConfig::RetriesKey            },
--- a/src/core/config/usage.h
+++ b/src/core/config/usage.h
@@ -88,6 +88,9 @@ static inline const std::string &usage()
    u += "      --no-huge-pages           disable huge pages support\n";
 #   ifdef XMRIG_OS_LINUX
    u += "      --hugepage-size=N         custom hugepage size in kB\n";
+#   endif
+#   ifdef XMRIG_ALGO_RANDOMX
+    u += "      --huge-pages-jit          enable huge pages support for RandomX JIT code\n";
 #   endif
    u += "      --asm=ASM                 ASM optimizations, possible values: auto, none, intel, ryzen, bulldozer\n";

--- a/src/crypto/astrobwt/AstroBWT.cpp
+++ b/src/crypto/astrobwt/AstroBWT.cpp
@@ -30,6 +30,7 @@
 #include "crypto/astrobwt/AstroBWT.h"
 #include "backend/cpu/Cpu.h"
 #include "base/crypto/sha3.h"
+#include "base/tools/bswap_64.h"
 #include "crypto/cn/CryptoNight.h"


@@ -54,21 +55,6 @@ __attribute__((ms_abi))
 void SHA3_256_AVX2_ASM(const void* in, size_t inBytes, void* out);
 #endif

-#ifdef _MSC_VER
-
-#include <stdlib.h>
-#define bswap_64(x) _byteswap_uint64(x)
-
-#elif defined __GNUC__
-
-#define bswap_64(x) __builtin_bswap64(x)
-
-#else
-
-#include <byteswap.h>
-
-#endif
-
 #ifdef XMRIG_ARM
 extern "C" {
 #include "salsa20_ref/ecrypt-sync.h"
--- a/src/crypto/cn/CnAlgo.h
+++ b/src/crypto/cn/CnAlgo.h
@@ -1,13 +1,6 @@
 /* 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-2019 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
- * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -44,20 +37,13 @@ class CnAlgo
 public:
    constexpr CnAlgo() {};

-    constexpr inline Algorithm::Id base() const  { static_assert(ALGO > Algorithm::INVALID && ALGO < Algorithm::RX_0, "invalid CRYPTONIGHT algorithm"); return Algorithm::CN_2; }
-    constexpr inline bool isHeavy() const        { return memory() == CN_MEMORY * 2; }
+    constexpr inline Algorithm::Id base() const  { static_assert(Algorithm::isCN(ALGO), "invalid CRYPTONIGHT algorithm"); return Algorithm::base(ALGO); }
+    constexpr inline bool isHeavy() const        { return Algorithm::family(ALGO) == Algorithm::CN_HEAVY; }
    constexpr inline bool isR() const            { return ALGO == Algorithm::CN_R; }
-    constexpr inline size_t memory() const       { static_assert(ALGO > Algorithm::INVALID && ALGO < Algorithm::RX_0, "invalid CRYPTONIGHT algorithm"); return CN_MEMORY; }
-    constexpr inline uint32_t iterations() const { static_assert(ALGO > Algorithm::INVALID && ALGO < Algorithm::RX_0, "invalid CRYPTONIGHT algorithm"); return CN_ITER; }
+    constexpr inline size_t memory() const       { static_assert(Algorithm::isCN(ALGO), "invalid CRYPTONIGHT algorithm"); return Algorithm::l3(ALGO); }
+    constexpr inline uint32_t iterations() const { static_assert(Algorithm::isCN(ALGO), "invalid CRYPTONIGHT algorithm"); return CN_ITER; }
    constexpr inline uint32_t mask() const       { return static_cast<uint32_t>(((memory() - 1) / 16) * 16); }

-    inline static size_t memory(Algorithm::Id algo)
-    {
-        Algorithm algorithm(algo);
-
-        return algorithm.isCN() ? algorithm.l3() : 0;
-    }
-
    inline static uint32_t iterations(Algorithm::Id algo)
    {
        switch (algo) {
@@ -122,77 +108,14 @@ public:
        }
 #       endif

-        return ((memory(algo) - 1) / 16) * 16;
-    }
-
-    inline static Algorithm::Id base(Algorithm::Id algo)
-    {
-        switch (algo) {
-        case Algorithm::CN_0:
-        case Algorithm::CN_XAO:
-#       ifdef XMRIG_ALGO_CN_LITE
-        case Algorithm::CN_LITE_0:
-#       endif
-#       ifdef XMRIG_ALGO_CN_HEAVY
-        case Algorithm::CN_HEAVY_0:
-        case Algorithm::CN_HEAVY_XHV:
-#       endif
-        case Algorithm::CN_CCX:
-            return Algorithm::CN_0;
-
-        case Algorithm::CN_1:
-        case Algorithm::CN_FAST:
-        case Algorithm::CN_RTO:
-#       ifdef XMRIG_ALGO_CN_LITE
-        case Algorithm::CN_LITE_1:
-#       endif
-#       ifdef XMRIG_ALGO_CN_HEAVY
-        case Algorithm::CN_HEAVY_TUBE:
-            return Algorithm::CN_1;
-#       endif
-
-        case Algorithm::CN_2:
-        case Algorithm::CN_R:
-        case Algorithm::CN_HALF:
-        case Algorithm::CN_RWZ:
-        case Algorithm::CN_ZLS:
-        case Algorithm::CN_DOUBLE:
-#       ifdef XMRIG_ALGO_CN_PICO
-        case Algorithm::CN_PICO_0:
-        case Algorithm::CN_PICO_TLO:
-#       endif
-#       ifdef XMRIG_ALGO_CN_FEMTO
-        case Algorithm::CN_UPX2:
-#       endif
-            return Algorithm::CN_2;
-
-        default:
-            break;
-        }
-
-        return Algorithm::INVALID;
+        return ((Algorithm::l3(algo) - 1) / 16) * 16;
    }

 private:
-    constexpr const static size_t   CN_MEMORY = 0x200000;
    constexpr const static uint32_t CN_ITER = 0x80000;
 };


-template<> constexpr inline Algorithm::Id CnAlgo<Algorithm::CN_0>::base() const             { return Algorithm::CN_0; }
-template<> constexpr inline Algorithm::Id CnAlgo<Algorithm::CN_XAO>::base() const           { return Algorithm::CN_0; }
-template<> constexpr inline Algorithm::Id CnAlgo<Algorithm::CN_LITE_0>::base() const        { return Algorithm::CN_0; }
-template<> constexpr inline Algorithm::Id CnAlgo<Algorithm::CN_HEAVY_0>::base() const       { return Algorithm::CN_0; }
-template<> constexpr inline Algorithm::Id CnAlgo<Algorithm::CN_HEAVY_XHV>::base() const     { return Algorithm::CN_0; }
-template<> constexpr inline Algorithm::Id CnAlgo<Algorithm::CN_CCX>::base() const           { return Algorithm::CN_0; }
-template<> constexpr inline Algorithm::Id CnAlgo<Algorithm::CN_1>::base() const             { return Algorithm::CN_1; }
-template<> constexpr inline Algorithm::Id CnAlgo<Algorithm::CN_FAST>::base() const          { return Algorithm::CN_1; }
-template<> constexpr inline Algorithm::Id CnAlgo<Algorithm::CN_RTO>::base() const           { return Algorithm::CN_1; }
-template<> constexpr inline Algorithm::Id CnAlgo<Algorithm::CN_LITE_1>::base() const        { return Algorithm::CN_1; }
-template<> constexpr inline Algorithm::Id CnAlgo<Algorithm::CN_HEAVY_TUBE>::base() const    { return Algorithm::CN_1; }
-template<> constexpr inline Algorithm::Id CnAlgo<Algorithm::CN_UPX2>::base() const          { return Algorithm::CN_2; }
-
-
 template<> constexpr inline uint32_t CnAlgo<Algorithm::CN_FAST>::iterations() const         { return CN_ITER / 2; }
 template<> constexpr inline uint32_t CnAlgo<Algorithm::CN_HALF>::iterations() const         { return CN_ITER / 2; }
 template<> constexpr inline uint32_t CnAlgo<Algorithm::CN_LITE_0>::iterations() const       { return CN_ITER / 2; }
@@ -210,16 +133,6 @@ template<> constexpr inline uint32_t CnAlgo<Algorithm::CN_CCX>::iterations() con
 template<> constexpr inline uint32_t CnAlgo<Algorithm::CN_UPX2>::iterations() const         { return CN_ITER / 32; }


-template<> constexpr inline size_t CnAlgo<Algorithm::CN_LITE_0>::memory() const             { return CN_MEMORY / 2; }
-template<> constexpr inline size_t CnAlgo<Algorithm::CN_LITE_1>::memory() const             { return CN_MEMORY / 2; }
-template<> constexpr inline size_t CnAlgo<Algorithm::CN_HEAVY_0>::memory() const            { return CN_MEMORY * 2; }
-template<> constexpr inline size_t CnAlgo<Algorithm::CN_HEAVY_TUBE>::memory() const         { return CN_MEMORY * 2; }
-template<> constexpr inline size_t CnAlgo<Algorithm::CN_HEAVY_XHV>::memory() const          { return CN_MEMORY * 2; }
-template<> constexpr inline size_t CnAlgo<Algorithm::CN_PICO_0>::memory() const             { return CN_MEMORY / 8; }
-template<> constexpr inline size_t CnAlgo<Algorithm::CN_PICO_TLO>::memory() const           { return CN_MEMORY / 8; }
-template<> constexpr inline size_t CnAlgo<Algorithm::CN_UPX2>::memory() const               { return CN_MEMORY / 16; }
-
-
 template<> constexpr inline uint32_t CnAlgo<Algorithm::CN_PICO_0>::mask() const             { return 0x1FFF0; }
 template<> constexpr inline uint32_t CnAlgo<Algorithm::CN_UPX2>::mask() const               { return 0x1FFF0; }

--- a/src/crypto/cn/CnHash.cpp
+++ b/src/crypto/cn/CnHash.cpp
@@ -1,13 +1,7 @@
 /* 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-2019 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
 * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2021 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
@@ -23,16 +17,12 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-#include <cstdio>
-
-
-#include "backend/cpu/Cpu.h"
 #include "crypto/cn/CnHash.h"
+#include "backend/cpu/Cpu.h"
+#include "base/tools/cryptonote/umul128.h"
 #include "crypto/common/VirtualMemory.h"


-#include "base/tools/cryptonote/umul128.h"
-
 #if defined(XMRIG_ARM)
 #   include "crypto/cn/CryptoNight_arm.h"
 #else
@@ -50,27 +40,30 @@
 #endif


-#define ADD_FN(algo) \
-    m_map[algo][AV_SINGLE][Assembly::NONE]      = cryptonight_single_hash<algo, false, 0>; \
-    m_map[algo][AV_SINGLE_SOFT][Assembly::NONE] = cryptonight_single_hash<algo, true,  0>; \
-    m_map[algo][AV_DOUBLE][Assembly::NONE]      = cryptonight_double_hash<algo, false>;    \
-    m_map[algo][AV_DOUBLE_SOFT][Assembly::NONE] = cryptonight_double_hash<algo, true>;     \
-    m_map[algo][AV_TRIPLE][Assembly::NONE]      = cryptonight_triple_hash<algo, false>;    \
-    m_map[algo][AV_TRIPLE_SOFT][Assembly::NONE] = cryptonight_triple_hash<algo, true>;     \
-    m_map[algo][AV_QUAD][Assembly::NONE]        = cryptonight_quad_hash<algo,   false>;    \
-    m_map[algo][AV_QUAD_SOFT][Assembly::NONE]   = cryptonight_quad_hash<algo,   true>;     \
-    m_map[algo][AV_PENTA][Assembly::NONE]       = cryptonight_penta_hash<algo,  false>;    \
-    m_map[algo][AV_PENTA_SOFT][Assembly::NONE]  = cryptonight_penta_hash<algo,  true>;
+#define ADD_FN(algo) do {                                                                            \
+        m_map[algo] = new cn_hash_fun_array{};                                                       \
+        m_map[algo]->data[AV_SINGLE][Assembly::NONE]      = cryptonight_single_hash<algo, false, 0>; \
+        m_map[algo]->data[AV_SINGLE_SOFT][Assembly::NONE] = cryptonight_single_hash<algo, true,  0>; \
+        m_map[algo]->data[AV_DOUBLE][Assembly::NONE]      = cryptonight_double_hash<algo, false>;    \
+        m_map[algo]->data[AV_DOUBLE_SOFT][Assembly::NONE] = cryptonight_double_hash<algo, true>;     \
+        m_map[algo]->data[AV_TRIPLE][Assembly::NONE]      = cryptonight_triple_hash<algo, false>;    \
+        m_map[algo]->data[AV_TRIPLE_SOFT][Assembly::NONE] = cryptonight_triple_hash<algo, true>;     \
+        m_map[algo]->data[AV_QUAD][Assembly::NONE]        = cryptonight_quad_hash<algo,   false>;    \
+        m_map[algo]->data[AV_QUAD_SOFT][Assembly::NONE]   = cryptonight_quad_hash<algo,   true>;     \
+        m_map[algo]->data[AV_PENTA][Assembly::NONE]       = cryptonight_penta_hash<algo,  false>;    \
+        m_map[algo]->data[AV_PENTA_SOFT][Assembly::NONE]  = cryptonight_penta_hash<algo,  true>;     \
+    } while (0)


 #ifdef XMRIG_FEATURE_ASM
-#   define ADD_FN_ASM(algo) \
-    m_map[algo][AV_SINGLE][Assembly::INTEL]     = cryptonight_single_hash_asm<algo, Assembly::INTEL>;     \
-    m_map[algo][AV_SINGLE][Assembly::RYZEN]     = cryptonight_single_hash_asm<algo, Assembly::RYZEN>;     \
-    m_map[algo][AV_SINGLE][Assembly::BULLDOZER] = cryptonight_single_hash_asm<algo, Assembly::BULLDOZER>; \
-    m_map[algo][AV_DOUBLE][Assembly::INTEL]     = cryptonight_double_hash_asm<algo, Assembly::INTEL>;     \
-    m_map[algo][AV_DOUBLE][Assembly::RYZEN]     = cryptonight_double_hash_asm<algo, Assembly::RYZEN>;     \
-    m_map[algo][AV_DOUBLE][Assembly::BULLDOZER] = cryptonight_double_hash_asm<algo, Assembly::BULLDOZER>;
+#   define ADD_FN_ASM(algo) do {                                                                                    \
+        m_map[algo]->data[AV_SINGLE][Assembly::INTEL]     = cryptonight_single_hash_asm<algo, Assembly::INTEL>;     \
+        m_map[algo]->data[AV_SINGLE][Assembly::RYZEN]     = cryptonight_single_hash_asm<algo, Assembly::RYZEN>;     \
+        m_map[algo]->data[AV_SINGLE][Assembly::BULLDOZER] = cryptonight_single_hash_asm<algo, Assembly::BULLDOZER>; \
+        m_map[algo]->data[AV_DOUBLE][Assembly::INTEL]     = cryptonight_double_hash_asm<algo, Assembly::INTEL>;     \
+        m_map[algo]->data[AV_DOUBLE][Assembly::RYZEN]     = cryptonight_double_hash_asm<algo, Assembly::RYZEN>;     \
+        m_map[algo]->data[AV_DOUBLE][Assembly::BULLDOZER] = cryptonight_double_hash_asm<algo, Assembly::BULLDOZER>; \
+    } while (0)


 namespace xmrig {
@@ -298,17 +291,23 @@ xmrig::CnHash::CnHash()
 #   endif

 #   ifdef XMRIG_ALGO_ARGON2
-    m_map[Algorithm::AR2_CHUKWA][AV_SINGLE][Assembly::NONE]         = argon2::single_hash<Algorithm::AR2_CHUKWA>;
-    m_map[Algorithm::AR2_CHUKWA][AV_SINGLE_SOFT][Assembly::NONE]    = argon2::single_hash<Algorithm::AR2_CHUKWA>;
-    m_map[Algorithm::AR2_CHUKWA_V2][AV_SINGLE][Assembly::NONE]      = argon2::single_hash<Algorithm::AR2_CHUKWA_V2>;
-    m_map[Algorithm::AR2_CHUKWA_V2][AV_SINGLE_SOFT][Assembly::NONE] = argon2::single_hash<Algorithm::AR2_CHUKWA_V2>;
-    m_map[Algorithm::AR2_WRKZ][AV_SINGLE][Assembly::NONE]           = argon2::single_hash<Algorithm::AR2_WRKZ>;
-    m_map[Algorithm::AR2_WRKZ][AV_SINGLE_SOFT][Assembly::NONE]      = argon2::single_hash<Algorithm::AR2_WRKZ>;
+    m_map[Algorithm::AR2_CHUKWA] = new cn_hash_fun_array{};
+    m_map[Algorithm::AR2_CHUKWA]->data[AV_SINGLE][Assembly::NONE]         = argon2::single_hash<Algorithm::AR2_CHUKWA>;
+    m_map[Algorithm::AR2_CHUKWA]->data[AV_SINGLE_SOFT][Assembly::NONE]    = argon2::single_hash<Algorithm::AR2_CHUKWA>;
+
+    m_map[Algorithm::AR2_CHUKWA_V2] = new cn_hash_fun_array{};
+    m_map[Algorithm::AR2_CHUKWA_V2]->data[AV_SINGLE][Assembly::NONE]      = argon2::single_hash<Algorithm::AR2_CHUKWA_V2>;
+    m_map[Algorithm::AR2_CHUKWA_V2]->data[AV_SINGLE_SOFT][Assembly::NONE] = argon2::single_hash<Algorithm::AR2_CHUKWA_V2>;
+
+    m_map[Algorithm::AR2_WRKZ] = new cn_hash_fun_array{};
+    m_map[Algorithm::AR2_WRKZ]->data[AV_SINGLE][Assembly::NONE]           = argon2::single_hash<Algorithm::AR2_WRKZ>;
+    m_map[Algorithm::AR2_WRKZ]->data[AV_SINGLE_SOFT][Assembly::NONE]      = argon2::single_hash<Algorithm::AR2_WRKZ>;
 #   endif

 #   ifdef XMRIG_ALGO_ASTROBWT
-    m_map[Algorithm::ASTROBWT_DERO][AV_SINGLE][Assembly::NONE]      = astrobwt::single_hash<Algorithm::ASTROBWT_DERO>;
-    m_map[Algorithm::ASTROBWT_DERO][AV_SINGLE_SOFT][Assembly::NONE] = astrobwt::single_hash<Algorithm::ASTROBWT_DERO>;
+    m_map[Algorithm::ASTROBWT_DERO] = new cn_hash_fun_array{};
+    m_map[Algorithm::ASTROBWT_DERO]->data[AV_SINGLE][Assembly::NONE]      = astrobwt::single_hash<Algorithm::ASTROBWT_DERO>;
+    m_map[Algorithm::ASTROBWT_DERO]->data[AV_SINGLE_SOFT][Assembly::NONE] = astrobwt::single_hash<Algorithm::ASTROBWT_DERO>;
 #   endif

 #   ifdef XMRIG_FEATURE_ASM
@@ -319,20 +318,30 @@ xmrig::CnHash::CnHash()

 xmrig::cn_hash_fun xmrig::CnHash::fn(const Algorithm &algorithm, AlgoVariant av, Assembly::Id assembly)
 {
+    assert(cnHash.m_map.count(algorithm));
+
    if (!algorithm.isValid()) {
        return nullptr;
    }

+    const auto it = cnHash.m_map.find(algorithm);
+    if (it == cnHash.m_map.end()) {
+        return nullptr;
+    }
+
 #   ifdef XMRIG_ALGO_CN_HEAVY
    // cn-heavy optimization for Zen3 CPUs
    if ((av == AV_SINGLE) && (assembly != Assembly::NONE) && (Cpu::info()->arch() == ICpuInfo::ARCH_ZEN3)) {
        switch (algorithm.id()) {
-        case xmrig::Algorithm::CN_HEAVY_0:
-            return cryptonight_single_hash<xmrig::Algorithm::CN_HEAVY_0, false, 3>;
-        case xmrig::Algorithm::CN_HEAVY_TUBE:
-            return cryptonight_single_hash<xmrig::Algorithm::CN_HEAVY_TUBE, false, 3>;
-        case xmrig::Algorithm::CN_HEAVY_XHV:
-            return cryptonight_single_hash<xmrig::Algorithm::CN_HEAVY_XHV, false, 3>;
+        case Algorithm::CN_HEAVY_0:
+            return cryptonight_single_hash<Algorithm::CN_HEAVY_0, false, 3>;
+
+        case Algorithm::CN_HEAVY_TUBE:
+            return cryptonight_single_hash<Algorithm::CN_HEAVY_TUBE, false, 3>;
+
+        case Algorithm::CN_HEAVY_XHV:
+            return cryptonight_single_hash<Algorithm::CN_HEAVY_XHV, false, 3>;
+
        default:
            break;
        }
@@ -340,11 +349,11 @@ xmrig::cn_hash_fun xmrig::CnHash::fn(const Algorithm &algorithm, AlgoVariant av,
 #   endif

 #   ifdef XMRIG_FEATURE_ASM
-    cn_hash_fun fun = cnHash.m_map[algorithm][av][Cpu::assembly(assembly)];
+    cn_hash_fun fun = it->second->data[av][Cpu::assembly(assembly)];
    if (fun) {
        return fun;
    }
 #   endif

-    return cnHash.m_map[algorithm][av][Assembly::NONE];
+    return it->second->data[av][Assembly::NONE];
 }
--- a/src/crypto/cn/CnHash.h
+++ b/src/crypto/cn/CnHash.h
@@ -1,13 +1,7 @@
 /* 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-2019 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
 * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2021 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
@@ -29,6 +23,7 @@

 #include <cstddef>
 #include <cstdint>
+#include <map>


 #include "crypto/cn/CnAlgo.h"
@@ -68,7 +63,11 @@ public:
    static cn_hash_fun fn(const Algorithm &algorithm, AlgoVariant av, Assembly::Id assembly);

 private:
-    cn_hash_fun m_map[Algorithm::MAX][AV_MAX][Assembly::MAX] = {};
+    struct cn_hash_fun_array {
+        cn_hash_fun data[AV_MAX][Assembly::MAX];
+    };
+
+    std::map<Algorithm, cn_hash_fun_array*> m_map;
 };


--- a/src/crypto/rx/Rx.cpp
+++ b/src/crypto/rx/Rx.cpp
@@ -17,7 +17,6 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-
 #include "crypto/rx/Rx.h"
 #include "backend/cpu/CpuConfig.h"
 #include "backend/cpu/CpuThreads.h"
@@ -88,7 +87,7 @@ void xmrig::Rx::init(IRxListener *listener)
 template<typename T>
 bool xmrig::Rx::init(const T &seed, const RxConfig &config, const CpuConfig &cpu)
 {
-    const Algorithm::Family f = seed.algorithm().family();
+    const auto f = seed.algorithm().family();
    if ((f != Algorithm::RANDOM_X)
 #       ifdef XMRIG_ALGO_CN_HEAVY
        && (f != Algorithm::CN_HEAVY)
--- a/src/crypto/rx/RxQueue.cpp
+++ b/src/crypto/rx/RxQueue.cpp
@@ -1,14 +1,8 @@
 /* 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-2019 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
- * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
- * Copyright 2018-2019 tevador     <tevador@gmail.com>
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright (c) 2018-2019 tevador     <tevador@gmail.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -24,7 +18,6 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-
 #include "crypto/rx/RxQueue.h"
 #include "backend/common/interfaces/IRxListener.h"
 #include "base/io/Async.h"
@@ -148,7 +141,7 @@ void xmrig::RxQueue::backgroundInit()
        LOG_INFO("%s" MAGENTA_BOLD("init dataset%s") " algo " WHITE_BOLD("%s (") CYAN_BOLD("%u") WHITE_BOLD(" threads)") BLACK_BOLD(" seed %s..."),
                 Tags::randomx(),
                 item.nodeset.size() > 1 ? "s" : "",
-                 item.seed.algorithm().shortName(),
+                 item.seed.algorithm().name(),
                 item.threads,
                 Cvt::toHex(item.seed.data().data(), 8).data()
                 );
--- a/src/crypto/rx/RxQueue.h
+++ b/src/crypto/rx/RxQueue.h
@@ -1,14 +1,8 @@
 /* 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-2019 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
- * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
- * Copyright 2018-2019 tevador     <tevador@gmail.com>
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright (c) 2018-2019 tevador     <tevador@gmail.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
--- a/src/donate.h
+++ b/src/donate.h
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -42,7 +36,6 @@
 *
 * If you plan on changing this setting to 0 please consider making a one off donation to my wallet:
 * XMR: 48edfHu7V9Z84YzzMa6fUueoELZ9ZRXq9VetWzYGzKt52XU5xvqgzYnDK9URnRoJMk1j8nLwEVsaSWJ4fhdUyZijBGUicoD
- * BTC: 1P7ujsXeX7GxQwHNnJsRMgAdNkFZmNVqJT
 */
 constexpr const int kDefaultDonateLevel = 1;
 constexpr const int kMinimumDonateLevel = 1;
--- a/src/hw/dmi/DmiMemory.cpp
+++ b/src/hw/dmi/DmiMemory.cpp
@@ -230,6 +230,10 @@ void xmrig::DmiMemory::setId(const char *slot, const char *bank)
    m_slot = slot;
    m_bank = bank;

+    if (!slot || !bank) {
+        return;
+    }
+
    try {
        std::cmatch cm;
        if (std::regex_match(slot, cm, std::regex("^Channel([A-Z])[-_]DIMM(\\d+)$", std::regex_constants::icase))) {
--- a/src/net/Network.cpp
+++ b/src/net/Network.cpp
@@ -1,13 +1,7 @@
 /* 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 2019      Howard Chu  <https://github.com/hyc>
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2019      Howard Chu  <https://github.com/hyc>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -137,9 +131,14 @@ void xmrig::Network::onActive(IStrategy *strategy, IClient *client)
    }
 #   endif

+    char zmq_buf[32] = {};
+    if (client->pool().zmq_port() >= 0) {
+        snprintf(zmq_buf, sizeof(zmq_buf), " (ZMQ:%d)", client->pool().zmq_port());
+    }
+
    const char *tlsVersion = client->tlsVersion();
-    LOG_INFO("%s " WHITE_BOLD("use %s ") CYAN_BOLD("%s:%d ") GREEN_BOLD("%s") " " BLACK_BOLD("%s"),
-             Tags::network(), client->mode(), pool.host().data(), pool.port(), tlsVersion ? tlsVersion : "", client->ip().data());
+    LOG_INFO("%s " WHITE_BOLD("use %s ") CYAN_BOLD("%s:%d%s ") GREEN_BOLD("%s") " " BLACK_BOLD("%s"),
+             Tags::network(), client->mode(), pool.host().data(), pool.port(), zmq_buf, tlsVersion ? tlsVersion : "", client->ip().data());

    const char *fingerprint = client->tlsFingerprint();
    if (fingerprint != nullptr) {
@@ -202,7 +201,7 @@ void xmrig::Network::onLogin(IStrategy *, IClient *client, rapidjson::Document &
    Value algo(kArrayType);

    for (const auto &a : algorithms) {
-        algo.PushBack(StringRef(a.shortName()), allocator);
+        algo.PushBack(StringRef(a.name()), allocator);
    }

    params.AddMember("algo", algo, allocator);
@@ -269,11 +268,22 @@ void xmrig::Network::setJob(IClient *client, const Job &job, bool donate)
    if (!BenchState::size())
 #   endif
    {
-        uint64_t diff       = job.diff();;
+        uint64_t diff       = job.diff();
        const char *scale   = NetworkState::scaleDiff(diff);

-        LOG_INFO("%s " MAGENTA_BOLD("new job") " from " WHITE_BOLD("%s:%d") " diff " WHITE_BOLD("%" PRIu64 "%s") " algo " WHITE_BOLD("%s") " height " WHITE_BOLD("%" PRIu64),
-                 Tags::network(), client->pool().host().data(), client->pool().port(), diff, scale, job.algorithm().shortName(), job.height());
+        char zmq_buf[32] = {};
+        if (client->pool().zmq_port() >= 0) {
+            snprintf(zmq_buf, sizeof(zmq_buf), " (ZMQ:%d)", client->pool().zmq_port());
+        }
+
+        char tx_buf[32] = {};
+        const uint32_t num_transactions = job.getNumTransactions();
+        if (num_transactions > 0) {
+            snprintf(tx_buf, sizeof(tx_buf), " (%u tx)", num_transactions);
+        }
+
+        LOG_INFO("%s " MAGENTA_BOLD("new job") " from " WHITE_BOLD("%s:%d%s") " diff " WHITE_BOLD("%" PRIu64 "%s") " algo " WHITE_BOLD("%s") " height " WHITE_BOLD("%" PRIu64) "%s",
+                 Tags::network(), client->pool().host().data(), client->pool().port(), zmq_buf, diff, scale, job.algorithm().name(), job.height(), tx_buf);
    }

    if (!donate && m_donate) {
--- a/src/net/Network.h
+++ b/src/net/Network.h
@@ -1,13 +1,7 @@
 /* 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 2019      Howard Chu  <https://github.com/hyc>
- * Copyright 2018-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2019      Howard Chu  <https://github.com/hyc>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
--- a/src/net/strategies/DonateStrategy.cpp
+++ b/src/net/strategies/DonateStrategy.cpp
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -22,7 +16,6 @@
 *   along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

-
 #include <algorithm>
 #include <cassert>
 #include <iterator>
@@ -291,7 +284,7 @@ void xmrig::DonateStrategy::setAlgorithms(rapidjson::Document &doc, rapidjson::V
    Value algo(kArrayType);

    for (const auto &a : algorithms) {
-        algo.PushBack(StringRef(a.shortName()), allocator);
+        algo.PushBack(StringRef(a.name()), allocator);
    }

    params.AddMember("algo", algo, allocator);
--- a/src/net/strategies/DonateStrategy.h
+++ b/src/net/strategies/DonateStrategy.h
@@ -1,12 +1,6 @@
 /* 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-2020 SChernykh   <https://github.com/SChernykh>
- * Copyright 2016-2020 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
--- a/src/version.h
+++ b/src/version.h
@@ -28,15 +28,15 @@
 #define APP_ID        "xmrig"
 #define APP_NAME      "XMRig"
 #define APP_DESC      "XMRig miner"
-#define APP_VERSION   "6.13.0"
+#define APP_VERSION   "6.14.1"
 #define APP_DOMAIN    "xmrig.com"
 #define APP_SITE      "www.xmrig.com"
 #define APP_COPYRIGHT "Copyright (C) 2016-2021 xmrig.com"
 #define APP_KIND      "miner"

 #define APP_VER_MAJOR  6
-#define APP_VER_MINOR  13
-#define APP_VER_PATCH  0
+#define APP_VER_MINOR  14
+#define APP_VER_PATCH  1

 #ifdef _MSC_VER
 #   if (_MSC_VER >= 1920)
--- a/src/xmrig.cpp
+++ b/src/xmrig.cpp
@@ -1,12 +1,6 @@
 /* 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>
+ * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2021 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
@@ -27,7 +21,8 @@
 #include "base/kernel/Process.h"


-int main(int argc, char **argv) {
+int main(int argc, char **argv)
+{
    using namespace xmrig;

    Process process(argc, argv);
Author	SHA1	Message	Date
XMRig	230ff87634	v6.14.1	2021-08-15 00:42:47 +07:00
XMRig	19adf2630a	Merge branch 'dev'	2021-08-15 00:42:12 +07:00
xmrig	3de4b16117	Update CHANGELOG.md	2021-08-15 00:37:23 +07:00
XMRig	602e3a7587	Fix algorithms order.	2021-08-14 05:48:37 +07:00
XMRig	4f6ffb67c1	Cleanup.	2021-08-14 04:58:01 +07:00
xmrig	a0194ddd18	Merge pull request #2537 from SChernykh/dev Fixed Termux build	2021-08-13 21:14:35 +07:00
SChernykh	30f7e876a2	Update CnHash.cpp	2021-08-13 16:03:15 +02:00
SChernykh	5958490c23	Fixed Termux build	2021-08-13 12:02:03 +02:00
XMRig	f92ad4423d	Fix Job::getNumTransactions.	2021-08-12 22:30:47 +07:00
XMRig	e0749a82c2	Fix cn-pico name.	2021-08-12 17:52:52 +07:00
xmrig	440aa003af	Merge pull request #2532 from xmrig/feature-stable-algo-id Refactoring: Stable (persistent) algorithms IDs.	2021-08-12 02:03:39 +07:00
XMRig	9580f5395f	Removed shortName.	2021-08-11 22:26:34 +07:00
XMRig	e9ae4deb91	Removed duplicate strings.	2021-08-11 22:07:43 +07:00
XMRig	aee0762424	Fix typo.	2021-08-11 16:27:36 +07:00
XMRig	e6332eff2b	Implemented stable algorithm ids.	2021-08-11 03:46:34 +07:00
XMRig	d0a632f557	Optimize CnHash storage.	2021-08-10 14:54:35 +07:00
XMRig	f4cdc527b0	#2527 Fix narrowing conversion.	2021-08-10 01:40:36 +07:00
XMRig	661dc515ab	namespace cleanup.	2021-08-09 23:51:07 +07:00
XMRig	6d9bafe068	v6.14.1-dev	2021-08-09 17:20:15 +07:00
XMRig	202c8aaee8	Merge branch 'master' into dev	2021-08-09 17:19:48 +07:00
XMRig	410084384e	v6.14.0	2021-08-09 16:09:15 +07:00
XMRig	43e98c509a	Merge branch 'dev'	2021-08-09 16:08:20 +07:00
XMRig	08d79ddcdc	v6.14.0-dev	2021-08-08 19:36:54 +07:00
xmrig	0fdf063760	Merge pull request #2512 from SChernykh/dev Show the number of transactions in pool job	2021-08-08 00:52:06 +07:00
SChernykh	929205536c	Show the number of transactions in pool job Useful to check if pool/proxy is working properly and can also be used to compare different pools.	2021-08-07 19:38:31 +02:00
XMRig	d24581c963	#2492 Add missing --huge-pages-jit command line option.	2021-07-24 12:27:48 +07:00
xmrig	2eb2e90631	Merge pull request #2484 from SChernykh/zmq ZeroMQ support for solo mining	2021-07-17 17:14:42 +07:00
SChernykh	0842e6b9d2	ZeroMQ support for solo mining Gets new blocks from daemon immediately without polling, saving ~0.5 seconds on average when daemon gets new block from the network. Also saves some CPU cycles because it doesn't need to poll daemon every second. Testing: add "daemon-zmq-port": 28083 to xmrig's pool config in config.json and run ./monerod --testnet --zmq-pub tcp://127.0.0.1:28083	2021-07-15 11:13:14 +02:00
XMRig	93805cd167	#2476 Fixed crash in DMI memory reader.	2021-07-06 23:07:31 +07:00
xmrig	755fe28bc3	Merge pull request #2472 from SChernykh/dev Updates from xmrig-proxy	2021-07-05 19:13:14 +07:00
SChernykh	59d780169f	Merge branch 'dev' of https://github.com/SChernykh/xmrig into dev	2021-07-05 13:57:16 +02:00
SChernykh	a30ede04f3	Updates from xmrig-proxy	2021-07-05 13:56:37 +02:00
XMRig	3f2dfa4279	Sync with proxy.	2021-07-05 02:31:29 +07:00
XMRig	7177b42903	v6.13.2-dev	2021-07-03 16:00:30 +07:00
XMRig	21638c2f58	Merge branch 'master' into dev	2021-07-03 16:00:05 +07:00
XMRig	02b2b87bb6	v6.13.1	2021-07-03 15:29:49 +07:00
XMRig	c8a9dba8fd	Merge branch 'dev'	2021-07-03 15:29:14 +07:00
xmrig	9a77d39a3f	Update CHANGELOG.md	2021-07-03 15:16:47 +07:00
xmrig	28a1d0fe1e	Merge pull request #2468 from SChernykh/dev Fix: don't send miner signature during regular mining	2021-07-02 00:37:04 +07:00
XMRig	0243789c04	v6.13.1-dev	2021-07-02 00:36:32 +07:00
XMRig	45dd58f808	Merge branch 'master' into dev	2021-07-02 00:35:52 +07:00
SChernykh	1b4abe1e98	Fix: don't send miner signature during regular mining	2021-07-01 19:31:55 +02:00