Updated version mismatch error message

Use macos-10.15 instead of "latest".

.github/workflows/c-cpp.yml

@@ -9,15 +9,20 @@ on:
 jobs:
   build-ubuntu:
 
-    runs-on: ${{ matrix.os }}
+    runs-on: ${{ matrix.config.os }}
 
     strategy:
       matrix:
-        os: [ubuntu-latest, ubuntu-18.04]
+        config:
+          - {os: ubuntu-latest, c: gcc-11, cpp: g++-11}
+          - {os: ubuntu-18.04, c: gcc, cpp: g++}
 
     steps:
     - name: Install dependencies
-      run: sudo apt update && sudo apt install git build-essential cmake libuv1-dev libzmq3-dev libsodium-dev libpgm-dev libnorm-dev libgss-dev
+      run: |
+        sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+        sudo apt update
+        sudo apt install -y git build-essential cmake libuv1-dev libzmq3-dev libsodium-dev libpgm-dev libnorm-dev libgss-dev ${{ matrix.config.c }} ${{ matrix.config.cpp }}
 
     - name: Checkout repository
       uses: actions/checkout@v2
@@ -28,7 +33,7 @@ jobs:
       run: |
         mkdir build
         cd build
-        cmake ..
+        cmake .. -DCMAKE_C_COMPILER=${{ matrix.config.c }} -DCMAKE_CXX_COMPILER=${{ matrix.config.cpp }}
         make -j2
 
     - name: Build tests
@@ -36,7 +41,7 @@ jobs:
         cd tests
         mkdir build
         cd build
-        cmake ..
+        cmake .. -DCMAKE_C_COMPILER=${{ matrix.config.c }} -DCMAKE_CXX_COMPILER=${{ matrix.config.cpp }}
         make -j2
 
     - name: Run tests
@@ -45,7 +50,7 @@ jobs:
     - name: Archive binary
       uses: actions/upload-artifact@v2
       with:
-        name: p2pool-${{ matrix.os }}
+        name: p2pool-${{ matrix.config.os }}
         path: build/p2pool
 
   build-windows-msys2:
@@ -102,7 +107,7 @@ jobs:
       matrix:
         config:
           - {vs: Visual Studio 16 2019, os: 2019, msbuild: "C:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Enterprise\\MSBuild\\Current\\Bin\\amd64\\"}
-          - {vs: Visual Studio 17 2022, os: 2022, msbuild: "C:\\Program Files\\Microsoft Visual Studio\\2022\\Preview\\Msbuild\\Current\\Bin\\amd64\\"}
+          - {vs: Visual Studio 17 2022, os: 2022, msbuild: "C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\Msbuild\\Current\\Bin\\amd64\\"}
 
     steps:
     - name: Checkout repository
@@ -145,7 +150,7 @@ jobs:
 
     strategy:
       matrix:
-        os: [macos-latest, macos-11]
+        os: [macos-10.15, macos-11]
 
     steps:
     - name: Checkout repository

Dockerfile

@@ -0,0 +1,50 @@
+FROM ubuntu:latest
+
+RUN set -e && \
+    apt-get update -q -y --no-install-recommends && \
+    DEBIAN_FRONTEND="noninteractive" apt-get install -q -y --no-install-recommends \
+        git \
+        build-essential \
+        ca-certificates \
+        cmake \
+        libuv1-dev \
+        libzmq3-dev \
+        libsodium-dev \
+        libpgm-dev \
+        libnorm-dev \
+        libgss-dev
+
+ADD . /usr/src/p2pool
+WORKDIR /usr/src/p2pool
+RUN git submodule update --init --recursive && \
+    mkdir build && \
+    cd build && \
+    cmake .. && \
+    make -j$(nproc)
+
+# ---
+
+FROM ubuntu:latest
+COPY --from=0 /usr/src/p2pool/build/p2pool /
+
+RUN set -e && \
+    apt-get update -q -y --no-install-recommends && \
+    DEBIAN_FRONTEND="noninteractive" apt-get install -q -y --no-install-recommends \
+    libzmq5 \
+    libuv1 \
+      && \
+    apt-get clean
+
+RUN groupadd -r p2pool -g 1000 && \
+    useradd -u 1000 -r -g p2pool -s /sbin/nologin -c "p2pool user" p2pool
+RUN mkdir -p /home/p2pool/.p2pool && \
+    chown p2pool.p2pool /home/p2pool /home/p2pool/.p2pool
+USER p2pool
+
+EXPOSE 3333
+EXPOSE 37889
+
+VOLUME /home/p2pool/.p2pool
+
+WORKDIR /home/p2pool/.p2pool
+ENTRYPOINT ["/p2pool"]

docker-compose/.env

@@ -0,0 +1,38 @@
+##
+# Monero Wallet Address for mining rewards (replace this with your own address)
+WALLET_ADDRESS="44MnN1f3Eto8DZYUWuE5XZNUtE3vcRzt2j6PzqWpPau34e6Cf4fAxt6X2MBmrm6F9YMEiMNjN6W4Shn4pLcfNAja621jwyg"
+
+##
+# p2pool settings
+#
+# Which port to listen for miner connections
+P2POOL_STRATUM_PORT=3333
+#
+# How much logging - (Less) 0 - 6 (More)
+P2POOL_LOGLEVEL=2
+#
+# The name of docker volume to hold p2pool data (created automatically if it doesnt exist)
+P2POOL_VOLUME=p2pool
+
+
+##
+# Monero Node Settings
+#
+# Version of Monero to build
+MONERO_GIT_TAG=release-v0.17
+#
+# Limit the size of the blockchain on disk (comment to disable)
+PRUNE_NODE="--prune-blockchain"
+#
+# The name of docker volume to hold p2pool data (created automatically if it doesnt exist)
+MONERO_VOLUME=monero
+
+
+##
+# Xmrig Miner Settings
+#
+# Submit shares at a lower fixed difficulty to show mining progress (comment to disable, edit to customize)
+FIXED_MINING_DIFFICULTY="-u x+500000"
+#
+# Limit the number of CPU cores to use for mining (uncomment to enable, edit to customize)
+#NUM_MINING_CPU="-t 4"

docker-compose/README.md

@@ -0,0 +1,38 @@
+# Monero P2Pool Docker Compose
+
+Run your own <b>Monero Node + P2Pool + XMRig</b> in Docker  
+
+## Instructions
+
+#### Install docker and docker-compose
+[Install Docker](https://docs.docker.com/engine/install/)  
+[Install Docker Compose](https://docs.docker.com/compose/install/)
+
+#### Clone the P2Pool project
+```
+git clone --recursive https://github.com/SChernykh/p2pool
+```
+
+#### Configure your Monero address for mining rewards
+```
+cd p2pool/docker-compose
+vi .env
+```
+<b>WALLET_ADDRESS</b> is the only setting that needs to be updated in that file
+
+#### Build the docker containers
+```
+docker-compose build
+```
+
+#### Run the node, pool, and CPU miner
+```
+docker-compose up
+```
+
+#### Optional
+* You can run everythng in the background by adding the "-d" argument to the "docker-compose up" command: ```docker-compose up -d```
+* You can see logs when running in the background for with the "docker logs" command:  ```docker logs -f p2pool-xmrig``` or ```docker logs -f p2pool-p2pool``` or ```docker logs -f p2pool-monero```
+* Open ports 18080 (Monero p2p port) and 37889 (P2Pool p2p port) in your firewall to ensure better connectivity. If you're mining from a computer behind NAT (like a router) you could consider forwarding the ports to your local machine
+* An XMRig CPU miner is included by default, but you can connect additional miners to this same p2pool node using port 3333
+* Configure your kernel for maximum mining performance: [XMRig RandomX Optimization Guide](https://xmrig.com/docs/miner/randomx-optimization-guide)

docker-compose/docker-compose.yml

@@ -0,0 +1,84 @@
+version: '3.4'
+
+networks:
+  p2pool:
+    driver: bridge
+
+volumes:
+  p2pool: 
+    name: ${P2POOL_VOLUME}
+  monero:
+    name: ${MONERO_VOLUME}
+
+services:
+  monero:
+    image: monero:latest
+    build:
+      context: monero
+      args:
+        - MONERO_GIT_TAG=$MONERO_GIT_TAG
+    container_name: p2pool-monero
+    networks:
+      - p2pool
+    ports:
+      - 18080:18080/tcp
+    volumes:
+      - monero:/home/monero/.bitmonero:rw
+      - /dev/null:/home/monero/.bitmonero/bitmonero.log:rw
+      - /dev/hugepages:/dev/hugepages:rw
+    restart: unless-stopped
+    command: >-
+      --zmq-pub tcp://0.0.0.0:18083
+      --disable-dns-checkpoints
+      --enable-dns-blocklist
+      --non-interactive
+      --p2p-bind-ip=0.0.0.0
+      --p2p-bind-port=18080
+      --rpc-bind-ip=0.0.0.0
+      --rpc-bind-port=18081
+      --confirm-external-bind
+      ${PRUNE_NODE}
+
+  p2pool:
+    image: p2pool:latest
+    build: ../
+    container_name: p2pool-p2pool
+    networks:
+      - p2pool
+    ports:
+      - ${P2POOL_STRATUM_PORT}:3333/tcp
+      - 37889:37889/tcp
+    volumes:
+      - p2pool:/home/p2pool/.p2pool:rw
+      - /dev/null:/home/p2pool/.p2pool/p2pool.log:rw
+      - /dev/hugepages:/dev/hugepages:rw
+    depends_on:
+      - monero
+    restart: unless-stopped
+    command: >-
+      --host monero
+      --wallet ${WALLET_ADDRESS}
+      --loglevel ${P2POOL_LOGLEVEL}
+
+  xmrig:
+    image: xmrig:latest
+    build: xmrig
+    container_name: p2pool-xmrig
+    networks:
+      - p2pool
+    privileged: true
+    cap_add:
+      - ALL
+    volumes:
+      - /dev:/dev:ro
+      - /lib/modules:/lib/modules:ro
+      - /dev/hugepages:/dev/hugepages:rw
+    depends_on:
+      - p2pool
+    restart: unless-stopped
+    command: >-
+      ${FIXED_MINING_DIFFICULTY}
+      ${NUM_MINING_CPU}
+      --randomx-1gb-pages
+      -o p2pool:3333
+

docker-compose/monero/Dockerfile

@@ -0,0 +1,79 @@
+FROM ubuntu:latest
+ARG MONERO_GIT_TAG="master"
+
+RUN set -e && \
+    apt-get update -q -y --no-install-recommends && \
+    DEBIAN_FRONTEND="noninteractive" apt-get install -q -y --no-install-recommends \
+        git \
+        ca-certificates \
+        build-essential \
+        pkg-config \
+        cmake \
+        libuv1-dev \
+        libzmq3-dev \
+        libsodium-dev \
+        libpgm-dev \
+        libnorm-dev \
+        libgss-dev \
+        libssl-dev \
+        libzmq3-dev \
+        libunbound-dev \
+        libsodium-dev \
+        libunwind8-dev \
+        liblzma-dev \
+        libreadline6-dev \
+        libldns-dev \
+        libexpat1-dev \
+        libpgm-dev \
+        qttools5-dev-tools \
+        libhidapi-dev \
+        libusb-1.0-0-dev \
+        libprotobuf-dev \
+        protobuf-compiler \
+        libudev-dev \
+        libboost-chrono-dev \
+        libboost-date-time-dev \
+        libboost-filesystem-dev \
+        libboost-locale-dev \
+        libboost-program-options-dev \
+        libboost-regex-dev \
+        libboost-serialization-dev \
+        libboost-system-dev \
+        libboost-thread-dev \
+        ccache \
+        doxygen \
+        graphviz
+
+WORKDIR /usr/src
+RUN git clone --recursive https://github.com/monero-project/monero && \
+    cd monero && \
+    git checkout $MONERO_GIT_TAG && \
+    git submodule sync && git submodule update --init --force --recursive && \
+    make release-static -j$(nproc)
+
+# ---
+
+FROM ubuntu:latest
+ARG MONERO_GIT_TAG="master"
+
+COPY --from=0 /usr/src/monero/build/Linux/$MONERO_GIT_TAG/release/bin/* /
+
+RUN set -e && \
+    apt-get update -q -y --no-install-recommends && \
+    DEBIAN_FRONTEND="noninteractive" apt-get install -q -y --no-install-recommends \
+    libgssapi-krb5-2 \
+      && \
+    apt-get clean
+
+RUN groupadd -r monero -g 1000 && \
+    useradd -u 1000 -r -g monero -s /sbin/nologin -c "monero node user" monero
+RUN mkdir -p /home/monero/.bitmonero && \
+    chown monero.monero /home/monero /home/monero/.bitmonero
+USER monero
+
+EXPOSE 18080 18081 18083
+
+VOLUME /home/monero/.bitmonero
+
+WORKDIR /home/monero
+ENTRYPOINT ["/monerod"]

docker-compose/xmrig/Dockerfile

@@ -0,0 +1,37 @@
+FROM ubuntu:latest
+
+RUN set -e && \
+    apt-get update -q -y --no-install-recommends && \
+    DEBIAN_FRONTEND="noninteractive" apt-get install -q -y --no-install-recommends \
+        git \
+        build-essential \
+        ca-certificates \
+        cmake \
+        libuv1-dev \
+        libssl-dev \
+        libhwloc-dev
+
+WORKDIR /usr/src
+RUN git clone https://github.com/xmrig/xmrig.git && \
+    mkdir xmrig/build && \
+    cd xmrig/build && \
+    cmake .. && \
+    make -j$(nproc)
+
+# ---
+
+FROM ubuntu:latest
+
+COPY --from=0 /usr/src/xmrig/build/xmrig /
+
+RUN set -e && \
+    apt-get update -q -y --no-install-recommends && \
+    DEBIAN_FRONTEND="noninteractive" apt-get install -q -y --no-install-recommends \
+    libssl1.1 \
+    libcrypto++6 \
+    libhwloc15 \
+      && \
+    apt-get clean
+
+WORKDIR /
+ENTRYPOINT ["/xmrig"]

src/block_template.cpp

@@ -1018,7 +1018,7 @@ void BlockTemplate::submit_sidechain_block(uint32_t template_id, uint32_t nonce,
 			}
 
 			hash pow_hash;
-			if (!check.get_pow_hash(m_pool->hasher(), m_seedHash, pow_hash)) {
+			if (!check.get_pow_hash(m_pool->hasher(), check.m_txinGenHeight, m_seedHash, pow_hash)) {
 				LOGERR(1, "PoW check failed for the sidechain block. Fix it! ");
 			}
 			else if (!check.m_difficulty.check_pow(pow_hash)) {

src/json_rpc_request.cpp

@@ -25,7 +25,7 @@ static constexpr char log_category_prefix[] = "JSONRPCRequest ";
 
 namespace p2pool {
 
-JSONRPCRequest::JSONRPCRequest(const char* address, int port, const char* req, CallbackBase* cb, CallbackBase* close_cb)
+JSONRPCRequest::JSONRPCRequest(const char* address, int port, const char* req, CallbackBase* cb, CallbackBase* close_cb, uv_loop_t* loop)
 	: m_socket{}
 	, m_connect{}
 	, m_write{}
@@ -38,7 +38,7 @@ JSONRPCRequest::JSONRPCRequest(const char* address, int port, const char* req, C
 {
 	m_readBuf[0] = '\0';
 
-	uv_tcp_init(uv_default_loop_checked(), &m_socket);
+	uv_tcp_init(loop ? loop : uv_default_loop_checked(), &m_socket);
 	uv_tcp_nodelay(&m_socket, 1);
 
 	sockaddr_storage addr;

src/json_rpc_request.h

@@ -26,20 +26,21 @@ public:
 	static FORCEINLINE void call(const char* address, int port, const char* req, T&& cb)
 	{
 		// It will be deleted in one of the tcp callbacks eventually
-		JSONRPCRequest* r = new JSONRPCRequest(address, port, req, new Callback<T>(std::move(cb)), nullptr);
+		JSONRPCRequest* r = new JSONRPCRequest(address, port, req, new Callback<T>(std::move(cb)), nullptr, nullptr);
 		if (!r->m_valid) {
 			delete r;
 		}
 	}
 
 	template<typename T, typename U>
-	static FORCEINLINE void call(const char* address, int port, const char* req, T&& cb, U&& close_cb)
+	static FORCEINLINE void call(const char* address, int port, const char* req, T&& cb, U&& close_cb, uv_loop_t* loop = nullptr)
 	{
 		// It will be deleted in one of the tcp callbacks eventually
-		JSONRPCRequest* r = new JSONRPCRequest(address, port, req, new Callback<T>(std::move(cb)), new Callback<U>(std::move(close_cb)));
+		CallbackBase* close_callback = new Callback<U>(std::move(close_cb));
+		JSONRPCRequest* r = new JSONRPCRequest(address, port, req, new Callback<T>(std::move(cb)), close_callback, loop);
 		if (!r->m_valid) {
 			constexpr char err[] = "internal error";
-			close_cb(err, sizeof(err) - 1);
+			(*close_callback)(err, sizeof(err) - 1);
 			delete r;
 		}
 	}
@@ -62,7 +63,7 @@ private:
 		T m_cb;
 	};
 
-	JSONRPCRequest(const char* address, int port, const char* req, CallbackBase* cb, CallbackBase* close_cb);
+	JSONRPCRequest(const char* address, int port, const char* req, CallbackBase* cb, CallbackBase* close_cb, uv_loop_t* loop);
 	~JSONRPCRequest();
 
 	static void on_connect(uv_connect_t* req, int status);

src/main.cpp

@@ -39,6 +39,7 @@ static void usage()
 		"--stratum-api        Enable /local/ path in api path for Stratum Server statistics\n"
 		"--no-cache           Disable p2pool.cache\n"
 		"--no-color           Disable colors in console output\n"
+		"--no-randomx         Disable internal RandomX hasher: p2pool will use RPC calls to monerod to check PoW hashes\n"
 		"--help               Show this help message\n\n"
 		"Example command line:\n\n"
 		"%s --host 127.0.0.1 --rpc-port 18081 --zmq-port 18083 --wallet YOUR_WALLET_ADDRESS --stratum 0.0.0.0:%d --p2p 0.0.0.0:%d\n\n",

src/p2pool.cpp

@@ -110,7 +110,14 @@ p2pool::p2pool(int argc, char* argv[])
 	m_api = m_params->m_apiPath.empty() ? nullptr : new p2pool_api(m_params->m_apiPath, m_params->m_localStats);
 
 	m_sideChain = new SideChain(this, type);
-	m_hasher = new RandomX_Hasher(this);
+
+	if (m_params->m_disableRandomX) {
+		m_hasher = new RandomX_Hasher_RPC(this);
+	}
+	else {
+		m_hasher = new RandomX_Hasher(this);
+	}
+
 	m_blockTemplate = new BlockTemplate(this);
 	m_mempool = new Mempool();
 	m_consoleCommands = new ConsoleCommands(this);
@@ -131,9 +138,9 @@ p2pool::~p2pool()
 	delete m_consoleCommands;
 }
 
-bool p2pool::calculate_hash(const void* data, size_t size, const hash& seed, hash& result)
+bool p2pool::calculate_hash(const void* data, size_t size, uint64_t height, const hash& seed, hash& result)
 {
-	return m_hasher->calculate(data, size, seed, result);
+	return m_hasher->calculate(data, size, height, seed, result);
 }
 
 uint64_t p2pool::get_seed_height(uint64_t height)
@@ -811,10 +818,14 @@ void p2pool::parse_get_version_rpc(const char* data, size_t size)
 		return;
 	}
 
-	if (version < 0x30008) {
+	const uint64_t required = m_params->m_disableRandomX ? 0x30009 : 0x30008;
+
+	if (version < required) {
 		const uint64_t version_hi = version >> 16;
 		const uint64_t version_lo = version & 65535;
-		LOGERR(1, "monerod RPC v" << version_hi << '.' << version_lo << " is incompatible, update to RPC >= v3.8");
+		const uint64_t required_version_hi = required >> 16;
+		const uint64_t required_version_lo = required & 65535;
+		LOGERR(1, "monerod RPC v" << version_hi << '.' << version_lo << " is incompatible, update to RPC >= v" << required_version_hi << '.' << required_version_lo << " (Monero v0.17.3.0 or newer)");
 		panic();
 	}
 

src/p2pool.h

@@ -23,7 +23,7 @@
 namespace p2pool {
 
 struct Params;
-class RandomX_Hasher;
+class RandomX_Hasher_Base;
 class BlockTemplate;
 class Mempool;
 class SideChain;
@@ -51,8 +51,8 @@ public:
 
 	p2pool_api* api() const { return m_api; }
 
-	RandomX_Hasher* hasher() const { return m_hasher; }
-	bool calculate_hash(const void* data, size_t size, const hash& seed, hash& result);
+	RandomX_Hasher_Base* hasher() const { return m_hasher; }
+	bool calculate_hash(const void* data, size_t size, uint64_t height, const hash& seed, hash& result);
 	static uint64_t get_seed_height(uint64_t height);
 	bool get_seed(uint64_t height, hash& seed) const;
 
@@ -97,7 +97,7 @@ private:
 
 	p2pool_api* m_api;
 	SideChain* m_sideChain;
-	RandomX_Hasher* m_hasher;
+	RandomX_Hasher_Base* m_hasher;
 	BlockTemplate* m_blockTemplate;
 	MinerData m_minerData;
 	bool m_updateSeed;

src/params.cpp

@@ -81,6 +81,10 @@ Params::Params(int argc, char* argv[])
 		if (strcmp(argv[i], "--no-color") == 0) {
 			log::CONSOLE_COLORS = false;
 		}
+
+		if (strcmp(argv[i], "--no-randomx") == 0) {
+			m_disableRandomX = true;
+		}
 	}
 
 	if (m_stratumAddresses.empty()) {

src/params.h

@@ -39,6 +39,7 @@ struct Params
 	std::string m_apiPath;
 	bool m_localStats = false;
 	bool m_blockCache = true;
+	bool m_disableRandomX = false;
 };
 
 } // namespace p2pool

src/pool_block.cpp

@@ -225,7 +225,7 @@ void PoolBlock::serialize_sidechain_data()
 	writeVarint(m_cumulativeDifficulty.hi, m_sideChainData);
 }
 
-bool PoolBlock::get_pow_hash(RandomX_Hasher* hasher, const hash& seed_hash, hash& pow_hash)
+bool PoolBlock::get_pow_hash(RandomX_Hasher_Base* hasher, uint64_t height, const hash& seed_hash, hash& pow_hash)
 {
 	alignas(8) uint8_t hashes[HASH_SIZE * 3];
 
@@ -295,7 +295,7 @@ bool PoolBlock::get_pow_hash(RandomX_Hasher* hasher, const hash& seed_hash, hash
 
 	writeVarint(count, [&blob, &blob_size](uint8_t b) { blob[blob_size++] = b; });
 
-	return hasher->calculate(blob, blob_size, seed_hash, pow_hash);
+	return hasher->calculate(blob, blob_size, height, seed_hash, pow_hash);
 }
 
 } // namespace p2pool

src/pool_block.h

@@ -28,7 +28,7 @@
 
 namespace p2pool {
 
-class RandomX_Hasher;
+class RandomX_Hasher_Base;
 class SideChain;
 
 /*
@@ -136,7 +136,7 @@ struct PoolBlock
 	void serialize_sidechain_data();
 
 	int deserialize(const uint8_t* data, size_t size, SideChain& sidechain);
-	bool get_pow_hash(RandomX_Hasher* hasher, const hash& seed_hash, hash& pow_hash);
+	bool get_pow_hash(RandomX_Hasher_Base* hasher, uint64_t height, const hash& seed_hash, hash& pow_hash);
 };
 
 } // namespace p2pool

src/pow_hash.cpp

@@ -22,6 +22,9 @@
 #include "randomx.h"
 #include "configuration.h"
 #include "virtual_machine.hpp"
+#include "json_rpc_request.h"
+#include "json_parsers.h"
+#include <rapidjson/document.h>
 #include <thread>
 
 static constexpr char log_category_prefix[] = "RandomX_Hasher ";
@@ -302,7 +305,7 @@ void RandomX_Hasher::set_old_seed(const hash& seed)
 	LOGINFO(1, log::LightCyan() << "old cache updated");
 }
 
-bool RandomX_Hasher::calculate(const void* data, size_t size, const hash& seed, hash& result)
+bool RandomX_Hasher::calculate(const void* data, size_t size, uint64_t /*height*/, const hash& seed, hash& result)
 {
 	// First try to use the dataset if it's ready
 	if (uv_rwlock_tryrdlock(&m_datasetLock) == 0) {
@@ -348,4 +351,113 @@ bool RandomX_Hasher::calculate(const void* data, size_t size, const hash& seed,
 	return false;
 }
 
+RandomX_Hasher_RPC::RandomX_Hasher_RPC(p2pool* pool)
+	: m_pool(pool)
+	, m_loopStopped(false)
+	, m_loopThread{}
+{
+	int err = uv_loop_init(&m_loop);
+	if (err) {
+		LOGERR(1, "failed to create event loop, error " << uv_err_name(err));
+		panic();
+	}
+
+	uv_async_init(&m_loop, &m_shutdownAsync, on_shutdown);
+	uv_async_init(&m_loop, &m_kickTheLoopAsync, nullptr);
+	m_shutdownAsync.data = this;
+
+	uv_mutex_init_checked(&m_requestMutex);
+	uv_mutex_init_checked(&m_condMutex);
+
+	err = uv_cond_init(&m_cond);
+	if (err) {
+		LOGERR(1, "failed to create cond, error " << uv_err_name(err));
+		panic();
+	}
+
+	err = uv_thread_create(&m_loopThread, loop, this);
+	if (err) {
+		LOGERR(1, "failed to start event loop thread, error " << uv_err_name(err));
+		panic();
+	}
+}
+
+RandomX_Hasher_RPC::~RandomX_Hasher_RPC()
+{
+	uv_async_send(&m_shutdownAsync);
+
+	using namespace std::chrono;
+	while (!m_loopStopped) {
+		std::this_thread::sleep_for(milliseconds(1));
+	}
+
+	uv_mutex_destroy(&m_requestMutex);
+	uv_mutex_destroy(&m_condMutex);
+	uv_cond_destroy(&m_cond);
+
+	LOGINFO(1, "stopped");
+}
+
+void RandomX_Hasher_RPC::loop(void* data)
+{
+	LOGINFO(1, "event loop started");
+	RandomX_Hasher_RPC* hasher = static_cast<RandomX_Hasher_RPC*>(data);
+	uv_run(&hasher->m_loop, UV_RUN_DEFAULT);
+	uv_loop_close(&hasher->m_loop);
+	LOGINFO(1, "event loop stopped");
+	hasher->m_loopStopped = true;
+}
+
+bool RandomX_Hasher_RPC::calculate(const void* data_ptr, size_t size, uint64_t height, const hash& /*seed*/, hash& h)
+{
+	MutexLock lock(m_requestMutex);
+
+	const uint8_t* data = reinterpret_cast<const uint8_t*>(data_ptr);
+	const uint8_t major_version = data[0];
+
+	char buf[log::Stream::BUF_SIZE + 1];
+	log::Stream s(buf);
+	s << "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"calc_pow\",\"params\":{\"major_version\":" << major_version <<
+		",\"height\":" << height <<
+		",\"block_blob\":\"" << log::hex_buf(data, size) << '"' <<
+		",\"seed_hash\":\"\"}}";
+
+	volatile int result = 0;
+	volatile bool done = false;
+
+	JSONRPCRequest::call(m_pool->params().m_host.c_str(), m_pool->params().m_rpcPort, buf,
+		[&result, &h](const char* data, size_t size)
+		{
+			rapidjson::Document doc;
+			if (doc.Parse(data, size).HasParseError() || !parseValue(doc, "result", h)) {
+				LOGWARN(3, "RPC calc_pow: invalid JSON response (parse error)");
+				result = -1;
+				return;
+			}
+			result = 1;
+		},
+		[this, &result, &done](const char* data, size_t size)
+		{
+			if (size > 0) {
+				LOGWARN(3, "RPC calc_pow: server returned error " << log::const_buf(data, size));
+				result = -1;
+			}
+
+			MutexLock lock2(m_condMutex);
+			done = true;
+			uv_cond_signal(&m_cond);
+		}, &m_loop);
+
+	uv_async_send(&m_kickTheLoopAsync);
+
+	{
+		MutexLock lock2(m_condMutex);
+		while (!done) {
+			uv_cond_wait(&m_cond, &m_condMutex);
+		}
+	}
+
+	return result > 0;
+}
+
 } // namespace p2pool

src/pow_hash.h

@@ -27,18 +27,29 @@ namespace p2pool {
 
 class p2pool;
 
-class RandomX_Hasher
+class RandomX_Hasher_Base
+{
+public:
+	virtual ~RandomX_Hasher_Base() {}
+
+	virtual void set_seed_async(const hash&) {}
+	virtual void set_old_seed(const hash&) {}
+
+	virtual bool calculate(const void* data, size_t size, uint64_t height, const hash& seed, hash& result) = 0;
+};
+
+class RandomX_Hasher : public RandomX_Hasher_Base
 {
 public:
 	explicit RandomX_Hasher(p2pool* pool);
 	~RandomX_Hasher();
 
-	void set_seed_async(const hash& seed);
+	void set_seed_async(const hash& seed) override;
 	void set_seed(const hash& seed);
 
-	void set_old_seed(const hash& seed);
+	void set_old_seed(const hash& seed) override;
 
-	bool calculate(const void* data, size_t size, const hash& seed, hash& result);
+	bool calculate(const void* data, size_t size, uint64_t height, const hash& seed, hash& result) override;
 
 private:
 
@@ -70,4 +81,36 @@ private:
 	std::atomic<uint32_t> m_setSeedCounter;
 };
 
+class RandomX_Hasher_RPC : public RandomX_Hasher_Base
+{
+public:
+	explicit RandomX_Hasher_RPC(p2pool* pool);
+	~RandomX_Hasher_RPC();
+
+	bool calculate(const void* data, size_t size, uint64_t height, const hash& seed, hash& result) override;
+
+private:
+	static void loop(void* data);
+
+	p2pool* m_pool;
+
+	uv_mutex_t m_requestMutex;
+	uv_loop_t m_loop;
+	volatile bool m_loopStopped;
+
+	uv_thread_t m_loopThread;
+	uv_mutex_t m_condMutex;
+	uv_cond_t m_cond;
+
+	uv_async_t m_shutdownAsync;
+	uv_async_t m_kickTheLoopAsync;
+
+	static void on_shutdown(uv_async_t* async)
+	{
+		RandomX_Hasher_RPC* server = reinterpret_cast<RandomX_Hasher_RPC*>(async->data);
+		uv_close(reinterpret_cast<uv_handle_t*>(&server->m_shutdownAsync), nullptr);
+		uv_close(reinterpret_cast<uv_handle_t*>(&server->m_kickTheLoopAsync), nullptr);
+	}
+};
+
 } // namespace p2pool

src/side_chain.cpp

@@ -429,7 +429,7 @@ bool SideChain::add_external_block(PoolBlock& block, std::vector<hash>& missing_
 	}
 
 	hash pow_hash;
-	if (!block.get_pow_hash(m_pool->hasher(), seed, pow_hash)) {
+	if (!block.get_pow_hash(m_pool->hasher(), block.m_txinGenHeight, seed, pow_hash)) {
 		LOGWARN(3, "add_external_block: couldn't get PoW hash for height = " << block.m_sidechainHeight << ", mainchain height " << block.m_txinGenHeight << ". Ignoring it.");
 		unsee_block(block);
 		return true;

src/stratum_server.cpp

@@ -661,7 +661,7 @@ void StratumServer::on_share_found(uv_work_t* req)
 		}
 
 		hash pow_hash;
-		if (!pool->calculate_hash(blob, blob_size, seed_hash, pow_hash)) {
+		if (!pool->calculate_hash(blob, blob_size, height, seed_hash, pow_hash)) {
 			LOGWARN(3, "client " << static_cast<char*>(client->m_addrString) << " couldn't check share PoW");
 			share->m_result = SubmittedShare::Result::COULDNT_CHECK_POW;
 			return;

src/tcp_server.h

@@ -76,7 +76,6 @@ public:
 		Client* m_next;
 
 		uv_tcp_t m_socket;
-		uv_write_t m_write;
 		uv_connect_t m_connectRequest;
 
 		bool m_isV6;

src/tcp_server.inl

@@ -564,6 +564,7 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::loop(void* data)
 	TCPServer* server = static_cast<TCPServer*>(data);
 	uv_run(&server->m_loop, UV_RUN_DEFAULT);
 	uv_loop_close(&server->m_loop);
+	LOGINFO(1, "event loop stopped");
 	server->m_loopStopped = true;
 }
 
@@ -798,7 +799,6 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::Client::reset()
 	m_prev = nullptr;
 	m_next = nullptr;
 	memset(&m_socket, 0, sizeof(m_socket));
-	memset(&m_write, 0, sizeof(m_write));
 	memset(&m_connectRequest, 0, sizeof(m_connectRequest));
 	m_isV6 = false;
 	m_isIncoming = false;

src/util.cpp

@@ -32,7 +32,7 @@ namespace p2pool {
 #define STR2(X) STR(X)
 #define STR(X) #X
 
-const char* VERSION = "v1.3.1 (built"
+const char* VERSION = "v1.4.0 (built"
 #if defined(__clang__)
 	" with clang/" __clang_version__
 #elif defined(__GNUC__)

tests/src/pool_block_tests.cpp

@@ -91,7 +91,7 @@ TEST(pool_block, deserialize)
 	hasher.set_seed(seed);
 
 	hash pow_hash;
-	ASSERT_EQ(b.get_pow_hash(&hasher, seed, pow_hash), true);
+	ASSERT_EQ(b.get_pow_hash(&hasher, 0, seed, pow_hash), true);
 
 	std::stringstream s;
 	s << pow_hash;