p2pool v1.9

Support mini pool.  Cleanup

.github/workflows/c-cpp.yml

@@ -106,8 +106,9 @@ jobs:
     strategy:
       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\\Enterprise\\Msbuild\\Current\\Bin\\amd64\\"}
+          - {vs: Visual Studio 16 2019, os: 2019, msbuild: "C:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Enterprise\\MSBuild\\Current\\Bin\\amd64\\", rx: "ON"}
+          - {vs: Visual Studio 17 2022, os: 2022, msbuild: "C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\Msbuild\\Current\\Bin\\amd64\\", rx: "ON"}
+          - {vs: Visual Studio 17 2022, os: 2022, msbuild: "C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\Msbuild\\Current\\Bin\\amd64\\", rx: "OFF"}
 
     steps:
     - name: Checkout repository
@@ -122,7 +123,7 @@ jobs:
       run: |
         mkdir build
         cd build
-        cmake .. -G "${{ matrix.config.vs }}"
+        cmake .. -G "${{ matrix.config.vs }}" -DWITH_RANDOMX=${{ matrix.config.rx }}
         & "${{ matrix.config.msbuild }}msbuild" /m /p:Configuration=Release p2pool.vcxproj
 
     - name: Build tests
@@ -141,7 +142,7 @@ jobs:
     - name: Archive binary
       uses: actions/upload-artifact@v2
       with:
-        name: p2pool-msbuild-${{ matrix.config.os }}.exe
+        name: p2pool-msbuild-${{ matrix.config.os }}-randomx-${{ matrix.config.rx }}.exe
         path: build/Release/p2pool.exe
 
   build-macos:
@@ -159,13 +160,29 @@ jobs:
         submodules: recursive
 
     - name: Install dependencies
-      run: HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake libuv zmq libpgm
+      run: HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake
+
+    - name: Build libuv
+      run: |
+        cd external/src/libuv
+        mkdir build
+        cd build
+        cmake ..
+        make -j3
+
+    - name: Build libzmq
+      run: |
+        cd external/src/libzmq
+        mkdir build
+        cd build
+        cmake .. -DWITH_TLS=OFF -DWITH_LIBSODIUM=OFF
+        make -j3
 
     - name: Build p2pool
       run: |
         mkdir build
         cd build
-        cmake ..
+        cmake .. -DSTATIC_BINARY=ON
         make -j3
 
     - name: Build tests
@@ -173,7 +190,7 @@ jobs:
         cd tests
         mkdir build
         cd build
-        cmake ..
+        cmake .. -DSTATIC_LIBS=ON
         make -j3
 
     - name: Run tests

.github/workflows/cppcheck.yml

@@ -45,7 +45,7 @@ jobs:
       run: |
         mkdir build
         cd build
-        cmake .. -G "Visual Studio 16 2019"
+        cmake .. -G "Visual Studio 17 2022"
 
     - name: Run cppcheck
       run: |

.gitmodules

@@ -10,9 +10,6 @@
 [submodule "external/src/cppzmq"]
 	path = external/src/cppzmq
 	url = https://github.com/SChernykh/cppzmq
-[submodule "external/src/libsodium"]
-	path = external/src/libsodium
-	url = https://github.com/SChernykh/libsodium
 [submodule "external/src/libuv"]
 	path = external/src/libuv
 	url = https://github.com/SChernykh/libuv

CMakeLists.txt

@@ -1,7 +1,8 @@
 cmake_minimum_required(VERSION 2.8.12)
 project(p2pool)
 
-option(STATIC_LINUX_BINARY "Build static Linux binary" OFF)
+option(STATIC_BINARY "Build static binary" OFF)
+option(WITH_RANDOMX "Include the RandomX library in the build. If this is turned off, p2pool will rely on monerod for verifying RandomX hashes" ON)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake")
 
@@ -9,8 +10,11 @@ if (${CMAKE_VERSION} VERSION_GREATER "3.5.2")
 	set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT p2pool)
 endif()
 
-add_subdirectory(external/src/RandomX)
-set(LIBS randomx)
+if (WITH_RANDOMX)
+	add_definitions(-DWITH_RANDOMX)
+	add_subdirectory(external/src/RandomX)
+	set(LIBS randomx)
+endif()
 
 include(cmake/flags.cmake)
 
@@ -27,7 +31,6 @@ set(HEADERS
 	src/keccak.h
 	src/log.h
 	src/mempool.h
-	src/miner.h
 	src/p2p_server.h
 	src/p2pool.h
 	src/p2pool_api.h
@@ -61,7 +64,6 @@ set(SOURCES
 	src/main.cpp
 	src/memory_leak_debug.cpp
 	src/mempool.cpp
-	src/miner.cpp
 	src/p2p_server.cpp
 	src/p2pool.cpp
 	src/p2pool_api.cpp
@@ -75,6 +77,11 @@ set(SOURCES
 	src/zmq_reader.cpp
 )
 
+if (WITH_RANDOMX)
+	set(HEADERS ${HEADERS} src/miner.h)
+	set(SOURCES ${SOURCES} src/miner.cpp)
+endif()
+
 include_directories(src)
 include_directories(external/src)
 include_directories(external/src/cryptonote)
@@ -82,7 +89,9 @@ include_directories(external/src/libuv/include)
 include_directories(external/src/cppzmq)
 include_directories(external/src/libzmq/include)
 include_directories(external/src/llhttp)
-include_directories(external/src/RandomX/src)
+if (WITH_RANDOMX)
+	include_directories(external/src/RandomX/src)
+endif()
 include_directories(external/src/rapidjson/include)
 include_directories(external/src/robin-hood-hashing/src/include)
 
@@ -124,15 +133,21 @@ add_definitions(/DZMQ_STATIC)
 
 add_executable(${CMAKE_PROJECT_NAME} ${HEADERS} ${SOURCES})
 
-if (STATIC_LINUX_BINARY)
+if (STATIC_BINARY)
 	add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_STRIP} ${CMAKE_PROJECT_NAME})
 
+	if (WITH_RANDOMX)
+		set(STATIC_LIBS randomx)
+	endif()
+
+	if (NOT APPLE)
+		set(STATIC_LIBS ${STATIC_LIBS} pthread dl)
+	endif()
+
 	target_link_libraries(${CMAKE_PROJECT_NAME}
-		"${CMAKE_SOURCE_DIR}/external/src/libsodium/src/libsodium/.libs/libsodium.a"
 		"${CMAKE_SOURCE_DIR}/external/src/libzmq/build/lib/libzmq.a"
 		"${CMAKE_SOURCE_DIR}/external/src/libuv/build/libuv_a.a"
-		randomx
-		pthread
+		${STATIC_LIBS}
 	)
 else()
 	target_link_libraries(${CMAKE_PROJECT_NAME} debug ${ZMQ_LIBRARY_DEBUG} debug ${UV_LIBRARY_DEBUG} optimized ${ZMQ_LIBRARY} optimized ${UV_LIBRARY} ${LIBS})

README.md

@@ -2,9 +2,9 @@
 
 Decentralized pool for Monero mining.
 
-Pool status and monitoring pages can be found at https://p2pool.io/ and https://p2pool.observer/
+Pool status and monitoring pages can be found at https://p2pool.io/, https://p2pool.io/mini/ and https://p2pool.observer/
 
-### Build status
+### Build Status
 
 ![C/C++ CI](https://github.com/SChernykh/p2pool/actions/workflows/c-cpp.yml/badge.svg)  
 ![CodeQL](https://github.com/SChernykh/p2pool/actions/workflows/codeql-analysis.yml/badge.svg)  
@@ -14,6 +14,17 @@ Pool status and monitoring pages can be found at https://p2pool.io/ and https://
   <img alt="Coverity Scan Build Status"
        src="https://scan.coverity.com/projects/23659/badge.svg"/>
 </a>
+# Contents
+- [Pool mining vs Solo mining vs P2Pool mining](#pool-mining-vs-solo-mining-vs-p2pool-mining)
+- [Features](#features)
+- [How PPLNS works in P2Pool](#how-pplns-works-in-p2pool)
+- [Default P2Pool parameters](#default-p2pool-parameters)
+- [How to mine on P2Pool](#how-to-mine-on-p2pool)
+  - [General Considerations](#general-considerations)
+  - [GNU/Linux](#gnulinux)
+  - [Windows](#windows)
+- [Build instructions](#build-instructions)
+- [Donations](#donations)
 
 ## Pool mining vs Solo mining vs P2Pool mining
 
@@ -54,72 +65,113 @@ First you need to find a pool share. This share will stay in PPLNS window for 21
 
 ## How to mine on P2Pool
 
-This guide assumes that you run everything on the same machine. If it's not the case, change `127.0.0.1` to appropriate IP addresses for your setup. It's highly recommended to create a new mainnet wallet for mining because **wallet addresses are public on p2pool**.
+### General Considerations
 
-**Wallet software compatible with p2pool payouts**
-- Official Monero CLI and GUI v0.17.2.3 and newer
-- Monerujo v2.1.0 "Vertant" and newer
-- Cake Wallet v4.2.7 and newer
-- Feather Wallet v1.0.0 and newer
-- MyMonero
+- In order to mine on P2Pool, a synced Monero node using monerod v0.17.3.0 or newer is required. If you do not currently have one configured, you can find instructions to do so [here](https://sethforprivacy.com/guides/run-a-monero-node-advanced/).
+- It is highly recommended that you create a separate restricted user account for mining. P2Pool is still relatively new and may still have serious bugs/vulnerabilities. 
+- You have to use a primary wallet address for mining. Subaddresses and integrated addresses are not supported, just like with monerod solo mining.
+- Starting from P2Pool v1.7, you can add the `--mini` parameter to your P2Pool command to connect to the **p2pool-mini** sidechain. Note that it will also change the default p2p port from 37889 to 37888.
+- Check that ports 18080 (Monero p2p port) and 37889/37888 (P2Pool/P2Pool mini p2p port) are open 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.
+- You can connect multiple miners to the same P2Pool node. The more the better!
+- The below steps assume that you run everything on the same machine. If it's not the case, change `127.0.0.1` to appropriate IP addresses for your setup. 
+- It is highly recommended to create a new mainnet wallet for P2Pool mining because **wallet addresses are public on P2Pool**.
 
-**General Considerations**
-
-- Create a separate restricted user account for mining. p2pool is relatively new and may still have serious bugs/vulnerabilities!
-- You have to use the primary wallet address for mining. Subaddresses and integrated addresses are not supported, just like with monerod solo mining.
-- Check that ports 18080 (Monero p2p port) and 37889 (p2pool p2p port) are open 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.
-- You can connect multiple miners to the same p2pool node. The more the better!
-- Starting from p2pool v1.7, you can add `--mini` to p2pool command line to connect to the **p2pool-mini** sidechain. Note that it will also change the default p2p port from 37889 to 37888.
-
-Step-by-step guide:
+**Wallet software compatible with P2Pool payouts**
+- [Official Monero CLI and GUI v0.17.2.3 and newer](https://www.getmonero.org/downloads/)
+- [Monerujo v2.1.0 "Vertant" and newer](https://www.monerujo.io/)
+- [Cake Wallet v4.2.7 and newer](https://cakewallet.com/)
+- [Monero.com by Cake Wallet](https://monero.com/)
+- [Feather Wallet v1.0.0 and newer](https://featherwallet.org/)
+- [MyMonero](https://mymonero.com/)
 
 ### GNU/Linux
 
-- Download binaries from https://github.com/SChernykh/p2pool/releases/latest
-- Alternatively, grab the latest source code for p2pool and build it
-- Prepare enough huge pages (each of monerod/p2pool/xmrig needs them): `sudo sysctl vm.nr_hugepages=3072`
-- Get xmrig (linux-static-x64) binary from https://github.com/xmrig/xmrig/releases/latest
-- Check that ports 18080 (Monero p2p port) and 37889 (p2pool p2p port) are open in your firewall to ensure better connectivity
-- Use the `monerod` binary v0.17.3.0 or newer
-- Run `./monerod --zmq-pub tcp://127.0.0.1:18083 --disable-dns-checkpoints --enable-dns-blocklist` **don't forget --zmq-pub parameter in the command line**
-- Run `./p2pool --host 127.0.0.1 --wallet YOUR_WALLET_ADDRESS`
-- p2pool has verbose logging by default, you can reduce it by using "loglevel N" command where N is between 0 and 6. Default loglevel is 3.
-- You can use `logrotate` with a config like this to control logfile growth:
-    ```
-    <path-to-logfile>
-    {
-	    rotate 7
-	    daily
-	    missingok
-	    delaycompress
-	    nocreate
-    }
-    ```
-- Wait until initial p2pool sync is finished, it shouldn't take more than 5-10 minutes, once completed xmrig should be able to connect to the stratum server on port 3333.
-- Run `./xmrig -o 127.0.0.1:3333`. Note that you don't need to specify wallet address for xmrig. **Wallet address set in xmrig config will be ignored!**
-- To set custom fixed difficulty for your miner (for example, 10000), run `./xmrig -u x+10000 -o 127.0.0.1:3333`
-- xmrig should connect and start mining
-- Also check p2pool.log for any warnings and errors: `grep -E 'WARNING|ERROR' p2pool.log`
+1. Download the latest P2Pool binaries [here](https://github.com/SChernykh/p2pool/releases/latest).
+   -  Alternatively, grab the latest source code for P2Pool and [build it](#build-instructions).
+2. Download the latest XMRig (linux-static-x64) binary [here](https://github.com/xmrig/xmrig/releases/latest).
+3. Prepare enough huge pages (required for each instance of monerod/P2Pool/XMRig): 
+```
+sudo sysctl vm.nr_hugepages=3072
+```
+4. Check that ports 18080 (Monero p2p port) and 37889/37888 (P2Pool/P2Pool mini p2p port) are open in your local firewall to ensure better connectivity. 
+5. Start `monerod` with the following command/options: 
+```
+./monerod --zmq-pub tcp://127.0.0.1:18083 --disable-dns-checkpoints --enable-dns-blocklist
+``` 
+**Note:** The `--zmq-pub` option is required for P2Pool to work properly.
+
+6. Start P2Pool with the following command/options:
+```
+./p2pool --host 127.0.0.1 --wallet YOUR_WALLET_ADDRESS
+```
+7. Wait until the initial P2Pool sync is finished (shouldn't take more than 5-10 minutes).
+8. Start XMRig with the following command/options:
+ ```
+ ./xmrig -o 127.0.0.1:3333
+ ```
+   - Note that you don't need to specify your wallet address for XMRig. **Wallet addresses set in XMRig config will be ignored!** 
+   - To set a custom fixed difficulty for your miner (for example, 10000), instead start XMRig with the following options: 
+   ```
+   ./xmrig -u x+10000 -o 127.0.0.1:3333
+   ```
+9. XMRig should connect and start mining!
+
+**Additional Information:** 
+- For a more in-depth beginner friendly walk-through with the option of using Docker, please see SethForPrivacy's guide at: https://sethforprivacy.com/guides/run-a-p2pool-node/
+- You can check the p2pool.log for any warnings or errors using the following command: 
+```
+grep -E 'WARNING|ERROR' p2pool.log
+```
+- P2Pool has verbose logging by default, you can reduce it by using "loglevel N" command where N is between 0 and 6. Default loglevel is 3.
+  - You can use `logrotate` with a config like this to control logfile growth:
+ ```
+<path-to-logfile>
+{
+rotate 7
+daily
+missingok
+delaycompress
+nocreate
+}
+ ```
 
 ### Windows 
 
-*NOTE: Windows SmartScreen may block incoming connections by files that are "Downloaded from the Internet". You can allow 'p2pool.exe' and 'monerod.exe' by double-clicking them, clicking "More Info", then click "Run Anyway" and then closing them immediately so you can run them from the command line. Advanced users can use the PowerShell cmdlet `Unblock-File` to remove this flag.*
+**Note:** *Windows SmartScreen may block incoming connections by files that are "Downloaded from the Internet". You can allow 'p2pool.exe' and 'monerod.exe' by double-clicking them, clicking "More Info", then click "Run Anyway" and then closing them immediately so you can run them from the command line. Advanced users can use the PowerShell cmdlet `Unblock-File` to remove this flag.*
 
-- Download p2pool binaries from https://github.com/SChernykh/p2pool/releases/latest
-- Download xmrig binary from https://github.com/xmrig/xmrig/releases/latest *(xmrig-6.15.2-gcc-win64.zip is the current version)*
-- Expand the p2pool binaries into an appropriate location (`%USERPROFILE%/bin` or `C:/bin/` are good options)
-- Expand xmrig binary into appropriate location (same folder as p2pool is fine)
-- Prepare huge pages (each of monerod/p2pool/xmrig needs them): 
-  - On Windows 10 or above, run xmrig at least once as Administrator (right-click Run As Administrator)
-  - On earlier versions of Windows, you'll need to run it as admin at least once per login.
-- Open a command prompt and navigate to the folder where you extracted p2pool.
-- *When running these commands, Windows Firewall may prompt to allow connections, click "Allow"*
-- Run `.\Monero\monerod.exe --zmq-pub tcp://127.0.0.1:18083 --disable-dns-checkpoints --enable-dns-blocklist` *NOTE: don't forget --zmq-pub parameter in the command line*
-- Run `.\p2pool.exe --host 127.0.0.1 --wallet YOUR_WALLET_ADDRESS`
-- Wait until initial p2pool sync is finished, it shouldn't take more than 5-10 minutes, once completed xmrig should be able to connect to the stratum server on port 3333.
-- Run `.\xmrig.exe -o 127.0.0.1:3333`. Note that you don't need to specify wallet address for xmrig. **Wallet address set in xmrig config will be ignored!**
-- To set custom fixed difficulty for your miner (for example, 10000), run `xmrig.exe -u x+10000 -o 127.0.0.1:3333`
-- Windows Quickstart: Create a batch (.bat) file with the following contents and place it in your p2pool directory along with xmrig.exe.
+1. Download the latest P2Pool binaries [here](https://github.com/SChernykh/p2pool/releases/latest).
+    - Alternatively, grab the latest source code for P2Pool and [build it](#build-instructions).
+2. Download the latest XMRig binary [here](https://github.com/xmrig/xmrig/releases/latest).
+3. Expand the P2Pool binaries into an appropriate location (`%USERPROFILE%/bin` or `C:/bin/` are good options)
+4. Expand XMRig binary into an appropriate location (the same folder as P2Pool is fine). 
+5. Prepare huge pages to work properly (each instance of monerod/P2Pool/XMRig needs them): 
+   - On Windows 10 or above, run XMRig at least once as Administrator (right-click Run As Administrator)
+   - On earlier versions of Windows, you'll need to run XMRig as Administrator at least once per login.
+6. Open a command prompt and navigate to the folder where you extracted P2Pool.
+
+**Note:** *When running the below commands, Windows Firewall may prompt to allow connections, click "Allow" if prompted.*
+
+7. Start `monerod` with the following command/options: 
+```
+.\Monero\monerod.exe --zmq-pub tcp://127.0.0.1:18083 --disable-dns-checkpoints --enable-dns-blocklist
+```
+**Note:** The `--zmq-pub` option is required for P2Pool to work properly.
+8. Start P2Pool with the following command/options:
+```
+.\p2pool.exe --host 127.0.0.1 --wallet YOUR_WALLET_ADDRESS
+```
+9. Wait until the initial P2Pool sync is finished (shouldn't take more than 5-10 minutes).
+10. Start XMRig with the following command/options:
+```
+.\xmrig.exe -o 127.0.0.1:3333
+```
+   - Note that you don't need to specify your wallet address for XMRig. **Wallet addresses set in XMRig config will be ignored!** 
+   - To set a custom fixed difficulty for your miner (for example, 10000), instead start XMRig with the following options: 
+     ```
+     xmrig.exe -u x+10000 -o 127.0.0.1:3333
+     ```
+11. XMRig should connect and start mining!
+12. *(Optional but highly recommended)* You can create a Quickstart by creating a batch (.bat) file with the following contents and placing it in your P2Pool directory along with `xmrig.exe`.
 ```
 @ECHO OFF
 start cmd /k %~dp0\Monero\monerod.exe --zmq-pub tcp://127.0.0.1:18083 --disable-dns-checkpoints --enable-dns-blocklist
@@ -132,10 +184,11 @@ PAUSE
 ```
 
 ## Build instructions
+Please see the relevant instructions for your platform:
 
 ### Ubuntu 20.04
 
-p2pool binary:
+Run the following commands to install the necessary prerequisites, clone this repo, and build P2Pool locally on Ubuntu 20.04:  
 ```
 sudo apt update && sudo apt install git build-essential cmake libuv1-dev libzmq3-dev libsodium-dev libpgm-dev libnorm-dev libgss-dev
 git clone --recursive https://github.com/SChernykh/p2pool
@@ -151,7 +204,7 @@ Make the package: [p2pool-git](https://aur.archlinux.org/packages/p2pool-git/)
 
 ### [Nix/NixOS](https://nixos.org)
 
-This is a flake only project. So you have to use [nixUnstable with nix flakes](https://nixos.wiki/wiki/Flakes) to build or install p2pool. 
+This is a flake only project. So you have to use [nixUnstable with nix flakes](https://nixos.wiki/wiki/Flakes) to build or install P2Pool. 
 The commands below use the new flake specific reference-format, so be sure to also set `ca-references` in `--experimental-features`.
 
 Because this project has submodules which are not fixed in _nixUnstable_ yet you have to use the `nix/master` branch:
@@ -169,21 +222,9 @@ Run the binary with arguments:
 nix run git+https://github.com/SChernykh/p2pool?ref=master -- --help
 ```
 
-### macOS
-
-p2pool binary:
-```
-brew update && brew install git cmake libuv zmq libpgm
-git clone --recursive https://github.com/SChernykh/p2pool
-cd p2pool
-mkdir build && cd build
-cmake ..
-make -j$(sysctl -n hw.logicalcpu)
-```
-
 ### Windows
 
-p2pool binary (Visual Studio Community 2019 build):
+P2Pool binary (Visual Studio Community 2019 build):
 *NOTE: You need to have the "Desktop Development with C++" module installed.*
 ```
 git clone --recursive https://github.com/SChernykh/p2pool
@@ -196,6 +237,17 @@ then open generated build\p2pool.sln in Visual Studio and build it there
 
 Alternatively, you can select "Clone a repository" within the GUI, then select "Build" from the menu. 
 
+### macOS
+
+Run the following commands to install the necessary prerequisites, clone this repo, and build P2Pool locally on your Mac:  
+```
+brew update && brew install git cmake libuv zmq libpgm
+git clone --recursive https://github.com/SChernykh/p2pool
+cd p2pool
+mkdir build && cd build
+cmake ..
+make -j$(sysctl -n hw.logicalcpu)
+```
 
 ## Donations
 

cmake/flags.cmake

@@ -18,7 +18,7 @@ if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
 	if (WIN32)
 		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")
 	else()
-		if (STATIC_LINUX_BINARY)
+		if (STATIC_BINARY)
 			set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")
 		else()
 			set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-libstdc++")

config.json

@@ -5,7 +5,7 @@
 // Fixed difficulty for miners that connect to your node must be set in their config.json
 //
 {
-	"name": "mainnet test 2",
+	"name": "default",
 	"password": "",
 	"block_time": 10,
 	"min_diff": 100000,

docker-compose/.env

@@ -5,14 +5,14 @@ WALLET_ADDRESS="44MnN1f3Eto8DZYUWuE5XZNUtE3vcRzt2j6PzqWpPau34e6Cf4fAxt6X2MBmrm6F
 ##
 # p2pool settings
 #
+# Use p2pool-mini (uncomment to enable)
+#P2POOL_MINI="--mini"
+#
 # 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
 
 
 ##
@@ -24,8 +24,8 @@ MONERO_GIT_TAG=latest
 # 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
+# Other monerod commandline options
+MONERO_EXTRA_OPTIONS=""
 
 
 ##
@@ -34,5 +34,9 @@ MONERO_VOLUME=monero
 # 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"
+# set process priority (0 idle, 2 normal to 5 highest)
+MINING_CPU_PRIORITY="--cpu-priority=2"
+#
+# Other XMRIG commandline options
+# See: https://xmrig.com/docs/miner/command-line-options
+XMRIG_EXTRA_OPTIONS=""

docker-compose/README.md

@@ -31,15 +31,18 @@ docker-compose up
 ```
 
 #### Optional
-* 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
+* Open ports 18080 (Monero p2p port) and 37889 (P2Pool p2p port) or 37888 (P2Pool-mini 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)
+* Small miners can mine on p2pool-mini by editing the .env file
 
 
 #### Other usefull commands
 * You can **run everythng in the background** by adding the "-d" argument to the "docker-compose up" command: ```docker-compose up -d```
 * You can **stop everything** with CTRL-C or ```docker-compose down```
 * 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```
+* You can pause mining with: ```docker-compose pause xmrig``` and resume mining with: ```docker-compose unpause xmrig```
+* You can disable mining with: ```docker-compose stop xmrig``` and re-enable mining with: ```docker-compose start xmrig```
 
 
 #### Uninstall

docker-compose/docker-compose.yml

@@ -7,9 +7,9 @@ networks:
 
 volumes:
   p2pool: 
-    name: ${P2POOL_VOLUME}
+    name: p2pool
   monero:
-    name: ${MONERO_VOLUME}
+    name: monero
 
 services:
   monero:
@@ -17,7 +17,7 @@ services:
     build:
       context: monero
       args:
-        - MONERO_GIT_TAG=$MONERO_GIT_TAG
+        - MONERO_GIT_TAG=${MONERO_GIT_TAG}
     container_name: p2pool-monero
     networks:
       - p2pool
@@ -39,6 +39,7 @@ services:
       --rpc-bind-port=18081
       --confirm-external-bind
       ${PRUNE_NODE}
+      ${MONERO_EXTRA_OPTIONS}
 
   p2pool:
     image: p2pool:latest
@@ -48,6 +49,7 @@ services:
       - p2pool
     ports:
       - ${P2POOL_STRATUM_PORT}:3333/tcp
+      - 37888:37888/tcp
       - 37889:37889/tcp
     volumes:
       - p2pool:/home/p2pool/.p2pool:rw
@@ -60,6 +62,7 @@ services:
       --host monero
       --wallet ${WALLET_ADDRESS}
       --loglevel ${P2POOL_LOGLEVEL}
+      ${P2POOL_MINI}
 
   xmrig:
     image: xmrig:latest
@@ -77,7 +80,7 @@ services:
     restart: unless-stopped
     command: >-
       ${FIXED_MINING_DIFFICULTY}
-      ${NUM_MINING_CPU}
+      ${MINING_CPU_PRIORITY}
+      ${XMRIG_EXTRA_OPTIONS}
       --randomx-1gb-pages
       -o p2pool:3333
-

src/block_cache.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -154,6 +154,7 @@ struct BlockCache::Impl : public nocopy_nomove
 BlockCache::BlockCache()
 	: m_impl(new Impl())
 	, m_flushRunning(0)
+	, m_storeIndex(0)
 {
 }
 
@@ -171,7 +172,7 @@ void BlockCache::store(const PoolBlock& block)
 		return;
 	}
 
-	uint8_t* data = m_impl->m_data + (static_cast<size_t>(block.m_sidechainHeight % NUM_BLOCKS) * BLOCK_SIZE);
+	uint8_t* data = m_impl->m_data + (static_cast<size_t>((m_storeIndex++) % NUM_BLOCKS) * BLOCK_SIZE);
 
 	*reinterpret_cast<uint32_t*>(data) = static_cast<uint32_t>(n1 + n2);
 	memcpy(data + sizeof(uint32_t), block.m_mainChainData.data(), n1);

src/block_cache.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -37,6 +37,7 @@ private:
 	struct Impl;
 	Impl* m_impl;
 	std::atomic<uint32_t> m_flushRunning;
+	std::atomic<uint32_t> m_storeIndex;
 };
 
 } // namespace p2pool

src/block_template.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  * Portions Copyright (c) 2012-2013 The Cryptonote developers
  * Portions Copyright (c) 2014-2021 The Monero Project
  * Portions Copyright (c) 2021 XMRig <https://github.com/xmrig>
@@ -190,12 +190,17 @@ void BlockTemplate::update(const MinerData& data, const Mempool& mempool, Wallet
 
 	++m_templateId;
 
+	// When block template generation fails for any reason
+	auto use_old_template = [this]() {
+		const uint32_t id = m_templateId - 1;
+		LOGWARN(4, "using old block template with ID = " << id);
+		*this = *m_oldTemplates[id % array_size(&BlockTemplate::m_oldTemplates)];
+	};
+
 	m_height = data.height;
 	m_difficulty = data.difficulty;
 	m_seedHash = data.seed_hash;
 
-	const time_t cur_time = time(nullptr);
-
 	// Only choose transactions that were received 10 or more seconds ago
 	size_t total_mempool_transactions;
 	{
@@ -205,6 +210,8 @@ void BlockTemplate::update(const MinerData& data, const Mempool& mempool, Wallet
 
 		total_mempool_transactions = mempool.m_transactions.size();
 
+		const uint64_t cur_time = seconds_since_epoch();
+
 		for (auto& it : mempool.m_transactions) {
 			if (cur_time >= it.second.time_received + 10) {
 				m_mempoolTxs.emplace_back(it.second);
@@ -252,7 +259,7 @@ void BlockTemplate::update(const MinerData& data, const Mempool& mempool, Wallet
 	m_poolBlockTemplate->m_minorVersion = HARDFORK_SUPPORTED_VERSION;
 
 	// Timestamp
-	m_timestamp = cur_time;
+	m_timestamp = time(nullptr);
 	if (m_timestamp <= data.median_timestamp) {
 		LOGWARN(2, "timestamp adjusted from " << m_timestamp << " to " << data.median_timestamp + 1 << ". Fix your system time!");
 		m_timestamp = data.median_timestamp + 1;
@@ -275,21 +282,26 @@ void BlockTemplate::update(const MinerData& data, const Mempool& mempool, Wallet
 
 	m_pool->side_chain().fill_sidechain_data(*m_poolBlockTemplate, miner_wallet, m_txkeySec, m_shares);
 	if (!SideChain::split_reward(max_reward, m_shares, m_rewards)) {
+		use_old_template();
 		return;
 	}
 
-	const uint64_t max_reward_amounts_weight = std::accumulate(m_rewards.begin(), m_rewards.end(), 0ULL,
-		[](uint64_t a, uint64_t b)
-		{
-			writeVarint(b, [&a](uint8_t) { ++a; });
-			return a;
-		});
+	auto get_reward_amounts_weight = [this]() {
+		return std::accumulate(m_rewards.begin(), m_rewards.end(), 0ULL,
+			[](uint64_t a, uint64_t b)
+			{
+				writeVarint(b, [&a](uint8_t) { ++a; });
+				return a;
+			});
+	};
+	uint64_t max_reward_amounts_weight = get_reward_amounts_weight();
 
-	if (!create_miner_tx(data, m_shares, max_reward_amounts_weight, true)) {
+	if (create_miner_tx(data, m_shares, max_reward_amounts_weight, true) < 0) {
+		use_old_template();
 		return;
 	}
 
-	const uint64_t miner_tx_weight = m_minerTx.size();
+	uint64_t miner_tx_weight = m_minerTx.size();
 
 	// Select transactions from the mempool
 	uint64_t final_reward, final_fees, final_weight;
@@ -427,17 +439,64 @@ void BlockTemplate::update(const MinerData& data, const Mempool& mempool, Wallet
 	}
 
 	if (!SideChain::split_reward(final_reward, m_shares, m_rewards)) {
+		use_old_template();
 		return;
 	}
 
 	m_finalReward = final_reward;
 
-	if (!create_miner_tx(data, m_shares, max_reward_amounts_weight, false)) {
-		return;
+	const int create_miner_tx_result = create_miner_tx(data, m_shares, max_reward_amounts_weight, false);
+	if (create_miner_tx_result < 0) {
+		if (create_miner_tx_result == -3) {
+			// Too many extra bytes were added, refine max_reward_amounts_weight and miner_tx_weight
+			LOGINFO(4, "Readjusting miner_tx to reduce extra nonce size");
+
+			// The difference between max possible reward and the actual reward can't reduce the size of output amount varints by more than 1 byte each
+			// So block weight will be >= current weight - number of outputs
+			const uint64_t w = (final_weight > m_rewards.size()) ? (final_weight - m_rewards.size()) : 0;
+
+			// Block reward will be <= r due to how block size penalty works
+			const uint64_t r = get_block_reward(base_reward, data.median_weight, final_fees, w);
+
+			if (!SideChain::split_reward(r, m_shares, m_rewards)) {
+				use_old_template();
+				return;
+			}
+
+			max_reward_amounts_weight = get_reward_amounts_weight();
+
+			if (create_miner_tx(data, m_shares, max_reward_amounts_weight, true) < 0) {
+				use_old_template();
+				return;
+			}
+
+			final_weight -= miner_tx_weight;
+			final_weight += m_minerTx.size();
+			miner_tx_weight = m_minerTx.size();
+
+			final_reward = get_block_reward(base_reward, data.median_weight, final_fees, final_weight);
+
+			if (!SideChain::split_reward(final_reward, m_shares, m_rewards)) {
+				use_old_template();
+				return;
+			}
+
+			if (create_miner_tx(data, m_shares, max_reward_amounts_weight, false) < 0) {
+				use_old_template();
+				return;
+			}
+
+			LOGINFO(4, "New extra nonce size = " << m_poolBlockTemplate->m_extraNonceSize);
+		}
+		else {
+			use_old_template();
+			return;
+		}
 	}
 
 	if (m_minerTx.size() != miner_tx_weight) {
 		LOGERR(1, "miner tx size changed after adjusting reward");
+		use_old_template();
 		return;
 	}
 
@@ -600,7 +659,7 @@ void BlockTemplate::fill_optimal_knapsack(const MinerData& data, uint64_t base_r
 }
 #endif
 
-bool BlockTemplate::create_miner_tx(const MinerData& data, const std::vector<MinerShare>& shares, uint64_t max_reward_amounts_weight, bool dry_run)
+int BlockTemplate::create_miner_tx(const MinerData& data, const std::vector<MinerShare>& shares, uint64_t max_reward_amounts_weight, bool dry_run)
 {
 	// Miner transaction (coinbase)
 	m_minerTx.clear();
@@ -655,12 +714,12 @@ bool BlockTemplate::create_miner_tx(const MinerData& data, const std::vector<Min
 	if (dry_run) {
 		if (reward_amounts_weight != max_reward_amounts_weight) {
 			LOGERR(1, "create_miner_tx: incorrect miner rewards during the dry run (" << reward_amounts_weight << " != " <<  max_reward_amounts_weight << ")");
-			return false;
+			return -1;
 		}
 	}
 	else if (reward_amounts_weight > max_reward_amounts_weight) {
 		LOGERR(1, "create_miner_tx: incorrect miner rewards during the real run (" << reward_amounts_weight << " > " << max_reward_amounts_weight << ")");
-		return false;
+		return -2;
 	}
 
 	m_poolBlockTemplate->m_txkeyPub = m_txkeyPub;
@@ -676,6 +735,10 @@ bool BlockTemplate::create_miner_tx(const MinerData& data, const std::vector<Min
 
 	const uint64_t corrected_extra_nonce_size = EXTRA_NONCE_SIZE + max_reward_amounts_weight - reward_amounts_weight;
 	if (corrected_extra_nonce_size > EXTRA_NONCE_SIZE) {
+		if (corrected_extra_nonce_size > EXTRA_NONCE_MAX_SIZE) {
+			LOGWARN(4, "create_miner_tx: corrected_extra_nonce_size (" << corrected_extra_nonce_size << ") is too large");
+			return -3;
+		}
 		LOGINFO(4, "increased EXTRA_NONCE from " << EXTRA_NONCE_SIZE << " to " << corrected_extra_nonce_size << " bytes to maintain miner tx weight");
 	}
 	writeVarint(corrected_extra_nonce_size, m_minerTxExtra);
@@ -701,7 +764,7 @@ bool BlockTemplate::create_miner_tx(const MinerData& data, const std::vector<Min
 	// Not a part of transaction hash data
 	m_minerTx.push_back(0);
 
-	return true;
+	return 1;
 }
 
 hash BlockTemplate::calc_sidechain_hash() const

src/block_template.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -50,7 +50,7 @@ public:
 	void update_tx_keys();
 
 	FORCEINLINE uint64_t height() const { return m_height; }
-	FORCEINLINE time_t timestamp() const { return m_timestamp; }
+	FORCEINLINE uint64_t timestamp() const { return m_timestamp; }
 	FORCEINLINE difficulty_type difficulty() const { return m_difficulty; }
 
 	void submit_sidechain_block(uint32_t template_id, uint32_t nonce, uint32_t extra_nonce);
@@ -61,7 +61,7 @@ private:
 	p2pool* m_pool;
 
 private:
-	bool create_miner_tx(const MinerData& data, const std::vector<MinerShare>& shares, uint64_t max_reward_amounts_weight, bool dry_run);
+	int create_miner_tx(const MinerData& data, const std::vector<MinerShare>& shares, uint64_t max_reward_amounts_weight, bool dry_run);
 	hash calc_sidechain_hash() const;
 	hash calc_miner_tx_hash(uint32_t extra_nonce) const;
 	void calc_merkle_tree_main_branch();

src/common.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -54,6 +54,7 @@
 #include <atomic>
 #include <chrono>
 #include <iostream>
+#include <random>
 
 #include <signal.h>
 
@@ -84,6 +85,7 @@ constexpr uint8_t HARDFORK_SUPPORTED_VERSION = 14;
 constexpr uint8_t MINER_REWARD_UNLOCK_TIME = 60;
 constexpr uint8_t NONCE_SIZE = 4;
 constexpr uint8_t EXTRA_NONCE_SIZE = 4;
+constexpr uint8_t EXTRA_NONCE_MAX_SIZE = EXTRA_NONCE_SIZE + 10;
 constexpr uint8_t TX_VERSION = 2;
 constexpr uint8_t TXIN_GEN = 0xFF;
 constexpr uint8_t TXOUT_TO_KEY = 2;
@@ -113,6 +115,8 @@ FORCEINLINE uint64_t udiv128(uint64_t hi, uint64_t lo, uint64_t divisor, uint64_
 }
 #endif
 
+template<typename T> FORCEINLINE T round_up(T a, size_t granularity) { return static_cast<T>(((a + (granularity - static_cast<size_t>(1))) / granularity) * granularity); }
+
 struct hash
 {
 	alignas(8) uint8_t h[HASH_SIZE];
@@ -232,7 +236,7 @@ struct TxMempoolData
 	uint64_t blob_size;
 	uint64_t weight;
 	uint64_t fee;
-	time_t time_received;
+	uint64_t time_received;
 };
 
 struct MinerData
@@ -258,7 +262,7 @@ struct MinerData
 	uint64_t median_timestamp;
 	std::vector<TxMempoolData> tx_backlog;
 
-	std::chrono::system_clock::time_point time_received;
+	std::chrono::high_resolution_clock::time_point time_received;
 };
 
 struct ChainMain

src/console_commands.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  * Copyright (c) 2021 hyc <https://github.com/hyc>
  *
  * This program is free software: you can redistribute it and/or modify
@@ -21,7 +21,9 @@
 #include "p2pool.h"
 #include "stratum_server.h"
 #include "p2p_server.h"
+#ifdef WITH_RANDOMX
 #include "miner.h"
+#endif
 #include "side_chain.h"
 #include <iostream>
 
@@ -70,7 +72,11 @@ typedef struct cmd {
 	cmdfunc *func;
 } cmd;
 
-static cmdfunc do_help, do_status, do_loglevel, do_addpeers, do_droppeers, do_showpeers, do_outpeers, do_inpeers, do_start_mining, do_stop_mining, do_exit;
+static cmdfunc do_help, do_status, do_loglevel, do_addpeers, do_droppeers, do_showpeers, do_showbans, do_outpeers, do_inpeers, do_exit;
+
+#ifdef WITH_RANDOMX
+static cmdfunc do_start_mining, do_stop_mining;
+#endif
 
 static cmd cmds[] = {
 	{ STRCONST("help"), "", "display list of commands", do_help },
@@ -79,10 +85,13 @@ static cmd cmds[] = {
 	{ STRCONST("addpeers"), "<peeraddr>", "add peer", do_addpeers },
 	{ STRCONST("droppeers"), "", "disconnect all peers", do_droppeers },
 	{ STRCONST("peers"), "", "show all peers", do_showpeers },
+	{ STRCONST("bans"), "", "show all banned IPs", do_showbans },
 	{ STRCONST("outpeers"), "", "set maximum number of outgoing connections", do_outpeers },
 	{ STRCONST("inpeers"), "", "set maximum number of incoming connections", do_inpeers },
+#ifdef WITH_RANDOMX
 	{ STRCONST("start_mining"), "<threads>", "start mining", do_start_mining },
 	{ STRCONST("stop_mining"), "", "stop mining", do_stop_mining },
+#endif
 	{ STRCONST("exit"), "", "terminate p2pool", do_exit },
 	{ STRCNULL, NULL, NULL, NULL }
 };
@@ -105,9 +114,11 @@ static int do_status(p2pool *m_pool, const char * /* args */)
 	if (m_pool->p2p_server()) {
 		m_pool->p2p_server()->print_status();
 	}
+#ifdef WITH_RANDOMX
 	if (m_pool->miner()) {
 		m_pool->miner()->print_status();
 	}
+#endif
 	bkg_jobs_tracker.print_status();
 	return 0;
 }
@@ -145,6 +156,17 @@ static int do_showpeers(p2pool* m_pool, const char* /* args */)
 	return 0;
 }
 
+static int do_showbans(p2pool* m_pool, const char* /* args */)
+{
+	if (m_pool->stratum_server()) {
+		m_pool->stratum_server()->print_bans();
+	}
+	if (m_pool->p2p_server()) {
+		m_pool->p2p_server()->print_bans();
+	}
+	return 0;
+}
+
 static int do_outpeers(p2pool* m_pool, const char* args)
 {
 	if (m_pool->p2p_server()) {
@@ -163,6 +185,7 @@ static int do_inpeers(p2pool* m_pool, const char* args)
 	return 0;
 }
 
+#ifdef WITH_RANDOMX
 static int do_start_mining(p2pool* m_pool, const char* args)
 {
 	uint32_t threads = strtoul(args, nullptr, 10);
@@ -176,6 +199,7 @@ static int do_stop_mining(p2pool* m_pool, const char* /*args*/)
 	m_pool->stop_mining();
 	return 0;
 }
+#endif
 
 static int do_exit(p2pool *m_pool, const char * /* args */)
 {

src/console_commands.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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

src/crypto.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -19,7 +19,6 @@
 #include "crypto.h"
 #include "keccak.h"
 #include "uv_util.h"
-#include <random>
 
 extern "C" {
 #include "crypto-ops.h"
@@ -32,7 +31,7 @@ namespace {
 class RandomBytes
 {
 public:
-	RandomBytes() : rng(s), dist(0, 255)
+	RandomBytes() : rng(RandomDeviceSeed::instance), dist(0, 255)
 	{
 		uv_mutex_init_checked(&m);
 
@@ -57,22 +56,6 @@ public:
 private:
 	uv_mutex_t m;
 
-	// Fills the whole initial MT19937-64 state with non-deterministic random numbers
-	struct SeedSequence
-	{
-		using result_type = std::random_device::result_type;
-
-		template<typename T>
-		static void generate(T begin, T end)
-		{
-			std::random_device rd;
-			for (T i = begin; i != end; ++i) {
-				*i = rd();
-			}
-		}
-	};
-
-	SeedSequence s;
 	std::mt19937_64 rng;
 	std::uniform_int_distribution<> dist;
 };

src/crypto.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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

src/json_parsers.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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

src/json_rpc_request.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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,13 +55,25 @@ JSONRPCRequest::JSONRPCRequest(const char* address, int port, const char* req, C
 	m_connect.data = this;
 	m_write.data = this;
 
-	const size_t len = strlen(req);
+	const char* uri = "/json_rpc";
+
+	size_t len = req ? strlen(req) : 0;
+	if (!len) {
+		LOGERR(1, "Empty JSONRPCRequest, fix the code!");
+		m_valid = false;
+		return;
+	}
+
+	if (req[0] == '/') {
+		uri = req;
+		len = 0;
+	}
 
 	m_request.reserve(std::max<size_t>(len + 128, log::Stream::BUF_SIZE + 1));
 	m_request.resize(log::Stream::BUF_SIZE + 1);
 
 	log::Stream s(m_request.data());
-	s << "POST /json_rpc HTTP/1.1\nContent-Type: application/json\nContent-Length: " << len << "\n\n";
+	s << "POST " << uri << " HTTP/1.1\nContent-Type: application/json\nContent-Length: " << len << "\n\n";
 
 	m_request.resize(s.m_pos);
 	m_request.insert(m_request.end(), req, req + len);

src/json_rpc_request.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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

src/keccak.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -48,17 +48,21 @@ NOINLINE void keccakf(uint64_t* st)
 		bc[3] = st[3] ^ st[8] ^ st[13] ^ st[18] ^ st[23];
 		bc[4] = st[4] ^ st[9] ^ st[14] ^ st[19] ^ st[24];
 
-		for (int i = 0; i < 5; ++i) {
-			uint64_t t = bc[(i + 4) % 5] ^ ROTL64(bc[(i + 1) % 5], 1);
-			st[i +  0 ] ^= t;
-			st[i +  5] ^= t;
-			st[i + 10] ^= t;
-			st[i + 15] ^= t;
-			st[i + 20] ^= t;
+#define X(i) { \
+			const uint64_t t = bc[(i + 4) % 5] ^ ROTL64(bc[(i + 1) % 5], 1); \
+			st[i +  0 ] ^= t; \
+			st[i +  5] ^= t; \
+			st[i + 10] ^= t; \
+			st[i + 15] ^= t; \
+			st[i + 20] ^= t; \
 		}
 
+		X(0); X(1); X(2); X(3); X(4);
+
+#undef X
+
 		// Rho Pi
-		uint64_t t = st[1];
+		const uint64_t t = st[1];
 		st[ 1] = ROTL64(st[ 6], 44);
 		st[ 6] = ROTL64(st[ 9], 20);
 		st[ 9] = ROTL64(st[22], 61);

src/keccak.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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

src/log.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -91,9 +91,13 @@ public:
 		}
 	}
 
-	FORCEINLINE ~Worker()
+	~Worker()
 	{
-		stop();
+		try {
+			stop();
+		}
+		catch (...) {
+		}
 	}
 
 	FORCEINLINE void stop()
@@ -320,6 +324,29 @@ NOINLINE void Stream::writeCurrentTime()
 	m_numberWidth = 1;
 }
 
+NOINLINE void put_rawip(const raw_ip& value, Stream* wrapper)
+{
+	const char* addr_str;
+	char addr_str_buf[64];
+
+	static constexpr uint8_t ipv4_prefix[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255 };
+	const bool is_v6 = (memcmp(value.data, ipv4_prefix, 12) != 0);
+
+	if (is_v6) {
+		addr_str = inet_ntop(AF_INET6, value.data, addr_str_buf, sizeof(addr_str_buf));
+	}
+	else {
+		addr_str = inet_ntop(AF_INET, value.data + 12, addr_str_buf, sizeof(addr_str_buf));
+	}
+
+	if (addr_str) {
+		*wrapper << addr_str;
+	}
+	else {
+		*wrapper << "N/A";
+	}
+}
+
 } // namespace log
 
 } // namespace p2pool

src/log.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -384,6 +384,13 @@ template<> struct log::Stream::Entry<NetworkType>
 	}
 };
 
+void put_rawip(const raw_ip& value, Stream* wrapper);
+
+template<> struct log::Stream::Entry<raw_ip>
+{
+	static FORCEINLINE void put(const raw_ip& value, Stream* wrapper) { put_rawip(value, wrapper); }
+};
+
 namespace {
 	template<log::Severity severity> void apply_severity(log::Stream&);
 

src/main.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -21,7 +21,7 @@
 #include "stratum_server.h"
 #include "p2p_server.h"
 
-static void usage()
+void p2pool_usage()
 {
 	printf("P2Pool %s\n"
 		"\nUsage:\n\n" \
@@ -68,13 +68,13 @@ void memory_tracking_stop();
 int main(int argc, char* argv[])
 {
 	if (argc == 1) {
-		usage();
+		p2pool_usage();
 		return 0;
 	}
 
 	for (int i = 1; i < argc; ++i) {
 		if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "/help") || !strcmp(argv[i], "-h") || !strcmp(argv[i], "/h")) {
-			usage();
+			p2pool_usage();
 			return 0;
 		}
 	}

src/memory_leak_debug.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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

src/mempool.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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,7 +44,7 @@ void Mempool::add(const TxMempoolData& tx)
 
 void Mempool::swap(std::vector<TxMempoolData>& transactions)
 {
-	const time_t cur_time = time(nullptr);
+	const uint64_t cur_time = seconds_since_epoch();
 
 	WriteLock lock(m_lock);
 

src/mempool.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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

src/miner.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -41,6 +41,7 @@ Miner::Miner(p2pool* pool, uint32_t threads)
 	, m_nonceTimestamp(m_startTimestamp)
 	, m_extraNonce(0xF19E3779U)
 	, m_totalHashes(0)
+	, m_sharesFound(0)
 	, m_job{}
 	, m_jobIndex(0)
 {

src/miner.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -51,10 +51,10 @@ private:
 	std::vector<WorkerData*> m_minerThreads;
 	volatile bool m_stopped;
 
-	std::chrono::time_point<std::chrono::high_resolution_clock> m_startTimestamp;
+	std::chrono::high_resolution_clock::time_point m_startTimestamp;
 
 	std::atomic<uint32_t> m_nonce;
-	std::chrono::time_point<std::chrono::high_resolution_clock> m_nonceTimestamp;
+	std::chrono::high_resolution_clock::time_point m_nonceTimestamp;
 	const uint32_t m_extraNonce;
 
 	uint64_t m_totalHashes;

src/p2p_server.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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,6 +23,9 @@
 #include "side_chain.h"
 #include "pool_block.h"
 #include "block_cache.h"
+#include "json_rpc_request.h"
+#include "json_parsers.h"
+#include <rapidjson/document.h>
 #include <fstream>
 #include <numeric>
 
@@ -44,14 +47,19 @@ P2PServer::P2PServer(p2pool* pool)
 	, m_cache(pool->params().m_blockCache ? new BlockCache() : nullptr)
 	, m_cacheLoaded(false)
 	, m_initialPeerList(pool->params().m_p2pPeerList)
-	, m_rd{}
-	, m_rng(m_rd())
+	, m_cachedBlocks(nullptr)
+	, m_rng(RandomDeviceSeed::instance)
 	, m_block(new PoolBlock())
 	, m_timer{}
 	, m_timerCounter(0)
-	, m_peerId(m_rng())
+	, m_timerInterval(2)
 	, m_peerListLastSaved(0)
 {
+	// Diffuse the initial state in case it has low quality
+	m_rng.discard(10000);
+
+	m_peerId = m_rng();
+
 	set_max_outgoing_peers(pool->params().m_maxOutgoingPeers);
 	set_max_incoming_peers(pool->params().m_maxIncomingPeers);
 
@@ -83,7 +91,7 @@ P2PServer::P2PServer(p2pool* pool)
 	}
 
 	m_timer.data = this;
-	err = uv_timer_start(&m_timer, on_timer, 1000, 2000);
+	err = uv_timer_start(&m_timer, on_timer, 1000, m_timerInterval * 1000);
 	if (err) {
 		LOGERR(1, "failed to start timer, error " << uv_err_name(err));
 		panic();
@@ -121,18 +129,34 @@ void P2PServer::add_cached_block(const PoolBlock& block)
 		return;
 	}
 
-	PoolBlock* new_block = new PoolBlock(block);
-	m_cachedBlocks.insert({ new_block->m_sidechainId, new_block });
+	if (!m_cachedBlocks) {
+		m_cachedBlocks = new unordered_map<hash, PoolBlock*>();
+	}
+
+	if (m_cachedBlocks->find(block.m_sidechainId) == m_cachedBlocks->end()) {
+		PoolBlock* new_block = new PoolBlock(block);
+		m_cachedBlocks->insert({ new_block->m_sidechainId, new_block });
+	}
 }
 
 void P2PServer::clear_cached_blocks()
 {
+	if (!m_cachedBlocks) {
+		return;
+	}
+
 	WriteLock lock(m_cachedBlocksLock);
 
-	for (auto it : m_cachedBlocks) {
+	if (!m_cachedBlocks) {
+		return;
+	}
+
+	for (auto it : *m_cachedBlocks) {
 		delete it.second;
 	}
-	m_cachedBlocks.clear();
+
+	delete m_cachedBlocks;
+	m_cachedBlocks = nullptr;
 }
 
 void P2PServer::store_in_cache(const PoolBlock& block)
@@ -170,8 +194,10 @@ void P2PServer::on_connect_failed(bool is_v6, const raw_ip& ip, int port)
 
 void P2PServer::update_peer_connections()
 {
-	const time_t cur_time = time(nullptr);
-	const time_t last_updated = m_pool->side_chain().last_updated();
+	const uint64_t cur_time = seconds_since_epoch();
+	const uint64_t last_updated = m_pool->side_chain().last_updated();
+
+	bool has_good_peers = false;
 
 	std::vector<raw_ip> connected_clients;
 	{
@@ -194,7 +220,7 @@ void P2PServer::update_peer_connections()
 				// - It's been at least 10 seconds since the last block request (peer is not syncing)
 				// - Peer should have sent a broadcast by now
 				if (last_updated && (cur_time >= std::max(last_updated, client->m_lastBlockrequestTimestamp) + 10) && (last_updated >= client->m_lastBroadcastTimestamp + 300)) {
-					const time_t dt = last_updated - client->m_lastBroadcastTimestamp;
+					const uint64_t dt = last_updated - client->m_lastBroadcastTimestamp;
 					LOGWARN(5, "peer " << static_cast<char*>(client->m_addrString) << " is not broadcasting blocks (last update " << dt << " seconds ago)");
 					client->ban(DEFAULT_BAN_TIME);
 					remove_peer_from_list(client);
@@ -205,6 +231,9 @@ void P2PServer::update_peer_connections()
 
 			if (!disconnected) {
 				connected_clients.emplace_back(client->m_addr);
+				if (client->m_handshakeComplete && !client->m_handshakeInvalid && (client->m_listenPort >= 0)) {
+					has_good_peers = true;
+				}
 			}
 		}
 	}
@@ -228,8 +257,20 @@ void P2PServer::update_peer_connections()
 		peer_list = m_peerList;
 	}
 
+	uint32_t N = m_maxOutgoingPeers;
+
+	// Special case: when we can't find p2pool peers, scan through monerod peers (try 25 peers at a time)
+	if (!has_good_peers && !m_peerListMonero.empty()) {
+		LOGINFO(3, "Scanning monerod peers, " << m_peerListMonero.size() << " left");
+		for (uint32_t i = 0; (i < 25) && !m_peerListMonero.empty(); ++i) {
+			peer_list.push_back(m_peerListMonero.back());
+			m_peerListMonero.pop_back();
+		}
+		N = static_cast<uint32_t>(peer_list.size());
+	}
+
 	// Try to have at least N outgoing connections (N defaults to 10, can be set via --out-peers command line parameter)
-	for (uint32_t i = m_numConnections - m_numIncomingConnections; (i < m_maxOutgoingPeers) && !peer_list.empty();) {
+	for (uint32_t i = m_numConnections - m_numIncomingConnections; (i < N) && !peer_list.empty();) {
 		const uint64_t k = get_random64() % peer_list.size();
 		const Peer& peer = peer_list[k];
 
@@ -251,14 +292,17 @@ void P2PServer::update_peer_connections()
 		peer_list.pop_back();
 	}
 
-	if ((m_numConnections == 0) && ((m_timerCounter % 30) == 0)) {
+	if (!has_good_peers && ((m_timerCounter % 30) == 0)) {
 		LOGERR(1, "no connections to other p2pool nodes, check your monerod/p2pool/network/firewall setup!!!");
+		if (m_peerListMonero.empty()) {
+			load_monerod_peer_list();
+		}
 	}
 }
 
 void P2PServer::update_peer_list()
 {
-	const time_t cur_time = time(nullptr);
+	const uint64_t cur_time = seconds_since_epoch();
 	{
 		MutexLock lock(m_clientsListLock);
 
@@ -267,9 +311,9 @@ void P2PServer::update_peer_list()
 				continue;
 			}
 
-			if (cur_time >= client->m_nextPeerListRequest) {
+			if (cur_time >= client->m_nextOutgoingPeerListRequest) {
 				// Send peer list requests at random intervals (60-120 seconds)
-				client->m_nextPeerListRequest = cur_time + 60 + (get_random64() % 61);
+				client->m_nextOutgoingPeerListRequest = cur_time + (60 + (get_random64() % 61));
 
 				const bool result = send(client,
 					[](void* buf)
@@ -280,7 +324,7 @@ void P2PServer::update_peer_list()
 					});
 
 				if (result) {
-					client->m_lastPeerListRequestTime = std::chrono::system_clock::now();
+					client->m_lastPeerListRequestTime = std::chrono::high_resolution_clock::now();
 					++client->m_peerListPendingRequests;
 				}
 			}
@@ -290,7 +334,7 @@ void P2PServer::update_peer_list()
 
 void P2PServer::save_peer_list_async()
 {
-	const time_t cur_time = time(nullptr);
+	const uint64_t cur_time = seconds_since_epoch();
 	if (cur_time < m_peerListLastSaved + 300) {
 		return;
 	}
@@ -363,12 +407,13 @@ void P2PServer::save_peer_list()
 	f.close();
 
 	LOGINFO(5, "peer list saved (" << peer_list.size() << " peers)");
-	m_peerListLastSaved = time(nullptr);
+	m_peerListLastSaved = seconds_since_epoch();
 }
 
 void P2PServer::load_peer_list()
 {
 	std::string saved_list;
+	const size_t old_size = m_peerList.size();
 
 	// Load peers from seed nodes if we're on the default or mini sidechain
 	auto load_from_seed_nodes = [&saved_list](const char** nodes, int p2p_port) {
@@ -486,19 +531,114 @@ void P2PServer::load_peer_list()
 
 			p.m_port = port;
 			p.m_numFailedConnections = 0;
-			p.m_lastSeen = time(nullptr);
+			p.m_lastSeen = seconds_since_epoch();
 
 			if (!already_added && !is_banned(p.m_addr)) {
 				m_peerList.push_back(p);
 			}
 		});
 
-	LOGINFO(4, "peer list loaded (" << m_peerList.size() << " peers)");
+	LOGINFO(4, "peer list loaded (" << (m_peerList.size() - old_size) << " peers)");
+}
+
+void P2PServer::load_monerod_peer_list()
+{
+	const Params& params = m_pool->params();
+
+	JSONRPCRequest::call(params.m_host.c_str(), params.m_rpcPort, "/get_peer_list",
+		[this](const char* data, size_t size)
+		{
+			constexpr char err_str[] = "/get_peer_list RPC request returned invalid JSON ";
+
+			using namespace rapidjson;
+
+			Document doc;
+			if (doc.Parse(data, size).HasParseError()) {
+				LOGWARN(4, err_str << "(parse error)");
+				return;
+			}
+
+			if (!doc.IsObject()) {
+				LOGWARN(4, err_str << "(not an object)");
+				return;
+			}
+
+			if (!doc.HasMember("white_list")) {
+				LOGWARN(4, err_str << "('white_list' not found)");
+				return;
+			}
+
+			const auto& white_list = doc["white_list"];
+
+			if (!white_list.IsArray()) {
+				LOGWARN(4, err_str << "('white_list' is not an array)");
+				return;
+			}
+
+			const int port = m_pool->side_chain().is_mini() ? DEFAULT_P2P_PORT_MINI : DEFAULT_P2P_PORT;
+
+			const SizeType n = white_list.Size();
+
+			m_peerListMonero.clear();
+			m_peerListMonero.reserve(n);
+
+			for (SizeType i = 0; i < n; ++i) {
+				auto& v = white_list[i];
+				const char* ip;
+				uint64_t last_seen;
+				if (!parseValue(v, "host", ip) || !parseValue(v, "last_seen", last_seen)) {
+					continue;
+				}
+
+				Peer p;
+				p.m_lastSeen = last_seen;
+
+				if (strchr(ip, ':')) {
+					sockaddr_in6 addr6;
+					const int err = uv_ip6_addr(ip, port, &addr6);
+					if (err) {
+						continue;
+					}
+					p.m_isV6 = true;
+					memcpy(p.m_addr.data, &addr6.sin6_addr, sizeof(in6_addr));
+				}
+				else {
+					sockaddr_in addr4;
+					const int err = uv_ip4_addr(ip, port, &addr4);
+					if (err) {
+						continue;
+					}
+					p.m_isV6 = false;
+					p.m_addr = {};
+					p.m_addr.data[10] = 0xFF;
+					p.m_addr.data[11] = 0xFF;
+					memcpy(p.m_addr.data + 12, &addr4.sin_addr, sizeof(in_addr));
+				}
+
+				p.m_port = port;
+				p.m_numFailedConnections = 0;
+
+				if (!is_banned(p.m_addr)) {
+					m_peerListMonero.push_back(p);
+				}
+			}
+
+			// Put recently active peers first in the list
+			std::sort(m_peerListMonero.begin(), m_peerListMonero.end(), [](const Peer& a, const Peer& b) { return a.m_lastSeen > b.m_lastSeen; });
+
+			LOGINFO(4, "monerod peer list loaded (" << m_peerListMonero.size() << " peers)");
+		},
+		[](const char* data, size_t size)
+		{
+			if (size > 0) {
+				LOGWARN(4, "/get_peer_list RPC request failed: error " << log::const_buf(data, size));
+			}
+		}, &m_loop);
 }
 
 void P2PServer::update_peer_in_list(bool is_v6, const raw_ip& ip, int port)
 {
-	const time_t cur_time = time(nullptr);
+	const uint64_t cur_time = seconds_since_epoch();
 
 	MutexLock lock(m_peerListLock);
 
@@ -682,7 +822,7 @@ void P2PServer::on_broadcast()
 				}
 
 				return p - p0;
-				});
+			});
 		}
 	}
 }
@@ -695,7 +835,7 @@ uint64_t P2PServer::get_random64()
 
 void P2PServer::print_status()
 {
-	const int64_t uptime = time(nullptr) - m_pool->start_time();
+	const int64_t uptime = seconds_since_epoch() - m_pool->start_time();
 
 	const int64_t s = uptime % 60;
 	const int64_t m = (uptime / 60) % 60;
@@ -811,12 +951,14 @@ void P2PServer::download_missing_blocks()
 		return;
 	}
 
+	ReadLock lock2(m_cachedBlocksLock);
+
 	// Try to download each block from a random client
 	for (const hash& id : missing_blocks) {
 		P2PClient* client = clients[get_random64() % clients.size()];
 
 		{
-			MutexLock lock2(m_missingBlockRequestsLock);
+			MutexLock lock3(m_missingBlockRequestsLock);
 
 			const uint64_t truncated_block_id = *reinterpret_cast<const uint64_t*>(id.h);
 			if (!m_missingBlockRequests.insert({ client->m_peerId, truncated_block_id }).second) {
@@ -826,7 +968,16 @@ void P2PServer::download_missing_blocks()
 			}
 		}
 
-		send(client,
+		if (m_cachedBlocks) {
+			auto it = m_cachedBlocks->find(id);
+			if (it != m_cachedBlocks->end()) {
+				LOGINFO(5, "using cached block for id = " << id);
+				client->handle_incoming_block_async(it->second);
+				continue;
+			}
+		}
+
+		const bool result = send(client,
 			[&id](void* buf)
 			{
 				uint8_t* p0 = reinterpret_cast<uint8_t*>(buf);
@@ -840,6 +991,10 @@ void P2PServer::download_missing_blocks()
 
 				return p - p0;
 			});
+
+		if (result) {
+			++client->m_blockPendingRequests;
+		}
 	}
 }
 
@@ -849,8 +1004,8 @@ void P2PServer::check_zmq()
 		return;
 	}
 
-	const time_t cur_time = time(nullptr);
-	const time_t last_active = m_pool->zmq_last_active();
+	const uint64_t cur_time = seconds_since_epoch();
+	const uint64_t last_active = m_pool->zmq_last_active();
 
 	if (cur_time >= last_active + 300) {
 		const uint64_t dt = static_cast<uint64_t>(cur_time - last_active);
@@ -866,10 +1021,13 @@ P2PServer::P2PClient::P2PClient()
 	, m_handshakeComplete(false)
 	, m_handshakeInvalid(false)
 	, m_listenPort(-1)
-	, m_nextPeerListRequest(0)
+	, m_fastPeerListRequestCount(0)
+	, m_prevIncomingPeerListRequest(0)
+	, m_nextOutgoingPeerListRequest(0)
 	, m_lastPeerListRequestTime{}
 	, m_peerListPendingRequests(0)
 	, m_pingTime(0)
+	, m_blockPendingRequests(0)
 	, m_lastAlive(0)
 	, m_lastBroadcastTimestamp(0)
 	, m_lastBlockrequestTimestamp(0)
@@ -892,10 +1050,13 @@ void P2PServer::P2PClient::reset()
 	m_handshakeComplete = false;
 	m_handshakeInvalid = false;
 	m_listenPort = -1;
-	m_nextPeerListRequest = 0;
+	m_fastPeerListRequestCount = 0;
+	m_prevIncomingPeerListRequest = 0;
+	m_nextOutgoingPeerListRequest = 0;
 	m_lastPeerListRequestTime = {};
 	m_peerListPendingRequests = 0;
 	m_pingTime = 0;
+	m_blockPendingRequests = 0;
 	m_lastAlive = 0;
 	m_lastBroadcastTimestamp = 0;
 	m_lastBlockrequestTimestamp = 0;
@@ -928,7 +1089,7 @@ bool P2PServer::P2PClient::on_connect()
 		}
 	}
 
-	m_lastAlive = time(nullptr);
+	m_lastAlive = seconds_since_epoch();
 	return send_handshake_challenge();
 }
 
@@ -952,6 +1113,8 @@ bool P2PServer::P2PClient::on_read(char* data, uint32_t size)
 	uint8_t* buf = buf_begin;
 	uint32_t bytes_left = m_numRead;
 
+	uint32_t num_block_requests = 0;
+
 	uint32_t bytes_read;
 	do {
 		MessageId id = static_cast<MessageId>(buf[0]);
@@ -1009,6 +1172,13 @@ bool P2PServer::P2PClient::on_read(char* data, uint32_t size)
 			break;
 
 		case MessageId::LISTEN_PORT:
+			if (m_listenPort >= 0) {
+				LOGWARN(4, "peer " << static_cast<char*>(m_addrString) << " sent an unexpected LISTEN_PORT");
+				ban(DEFAULT_BAN_TIME);
+				server->remove_peer_from_list(this);
+				return false;
+			}
+
 			LOGINFO(5, "peer " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " sent LISTEN_PORT");
 
 			if (bytes_left >= 1 + sizeof(int32_t)) {
@@ -1022,6 +1192,14 @@ bool P2PServer::P2PClient::on_read(char* data, uint32_t size)
 			break;
 
 		case MessageId::BLOCK_REQUEST:
+			++num_block_requests;
+			if (num_block_requests > 100) {
+				LOGWARN(4, "peer " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " sent too many BLOCK_REQUEST messages at once");
+				ban(DEFAULT_BAN_TIME);
+				server->remove_peer_from_list(this);
+				return false;
+			}
+
 			LOGINFO(5, "peer " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " sent BLOCK_REQUEST");
 
 			if (bytes_left >= 1 + HASH_SIZE) {
@@ -1035,12 +1213,21 @@ bool P2PServer::P2PClient::on_read(char* data, uint32_t size)
 			break;
 
 		case MessageId::BLOCK_RESPONSE:
+			if (m_blockPendingRequests <= 0) {
+				LOGWARN(4, "peer " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " sent an unexpected BLOCK_RESPONSE");
+				ban(DEFAULT_BAN_TIME);
+				server->remove_peer_from_list(this);
+				return false;
+			}
+
 			LOGINFO(5, "peer " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " sent BLOCK_RESPONSE");
 
 			if (bytes_left >= 1 + sizeof(uint32_t)) {
 				const uint32_t block_size = *reinterpret_cast<uint32_t*>(buf + 1);
 				if (bytes_left >= 1 + sizeof(uint32_t) + block_size) {
 					bytes_read = 1 + sizeof(uint32_t) + block_size;
+
+					--m_blockPendingRequests;
 					if (!on_block_response(buf + 1 + sizeof(uint32_t), block_size)) {
 						ban(DEFAULT_BAN_TIME);
 						server->remove_peer_from_list(this);
@@ -1102,7 +1289,7 @@ bool P2PServer::P2PClient::on_read(char* data, uint32_t size)
 					bytes_read = 2u + num_peers * 19u;
 
 					using namespace std::chrono;
-					m_pingTime = duration_cast<milliseconds>(system_clock::now() - m_lastPeerListRequestTime).count();
+					m_pingTime = duration_cast<milliseconds>(high_resolution_clock::now() - m_lastPeerListRequestTime).count();
 
 					--m_peerListPendingRequests;
 					if (!on_peer_list_response(buf + 1)) {
@@ -1118,7 +1305,7 @@ bool P2PServer::P2PClient::on_read(char* data, uint32_t size)
 		if (bytes_read) {
 			buf += bytes_read;
 			bytes_left -= bytes_read;
-			m_lastAlive = time(nullptr);
+			m_lastAlive = seconds_since_epoch();
 		}
 	} while (bytes_read && bytes_left);
 
@@ -1452,7 +1639,8 @@ void P2PServer::P2PClient::on_after_handshake(uint8_t* &p)
 	memcpy(p, empty.h, HASH_SIZE);
 	p += HASH_SIZE;
 
-	m_lastBroadcastTimestamp = time(nullptr);
+	++m_blockPendingRequests;
+	m_lastBroadcastTimestamp = seconds_since_epoch();
 }
 
 bool P2PServer::P2PClient::on_listen_port(const uint8_t* buf)
@@ -1473,7 +1661,7 @@ bool P2PServer::P2PClient::on_listen_port(const uint8_t* buf)
 
 bool P2PServer::P2PClient::on_block_request(const uint8_t* buf)
 {
-	m_lastBlockrequestTimestamp = time(nullptr);
+	m_lastBlockrequestTimestamp = seconds_since_epoch();
 
 	hash id;
 	memcpy(id.h, buf, HASH_SIZE);
@@ -1553,7 +1741,7 @@ bool P2PServer::P2PClient::on_block_broadcast(const uint8_t* buf, uint32_t size)
 		if (peer_height < our_height) {
 			if (our_height - peer_height < 5) {
 				using namespace std::chrono;
-				const int64_t elapsed_ms = duration_cast<milliseconds>(system_clock::now() - miner_data.time_received).count();
+				const int64_t elapsed_ms = duration_cast<milliseconds>(high_resolution_clock::now() - miner_data.time_received).count();
 				if (our_height - peer_height > 1) {
 					LOGWARN(5, "peer " << static_cast<char*>(m_addrString) << " broadcasted a stale block (" << elapsed_ms << " ms late, mainchain height " << peer_height << ", expected >= " << our_height << "), ignoring it");
 					return true;
@@ -1579,7 +1767,7 @@ bool P2PServer::P2PClient::on_block_broadcast(const uint8_t* buf, uint32_t size)
 
 	server->m_block->m_wantBroadcast = true;
 
-	m_lastBroadcastTimestamp = time(nullptr);
+	m_lastBroadcastTimestamp = seconds_since_epoch();
 
 	return handle_incoming_block_async(server->m_block);
 }
@@ -1587,6 +1775,18 @@ bool P2PServer::P2PClient::on_block_broadcast(const uint8_t* buf, uint32_t size)
 bool P2PServer::P2PClient::on_peer_list_request(const uint8_t*)
 {
 	P2PServer* server = static_cast<P2PServer*>(m_owner);
+	const uint64_t cur_time = seconds_since_epoch();
+
+	// Allow peer list requests no more than once every 30 seconds
+	if (cur_time - m_prevIncomingPeerListRequest < 30) {
+		++m_fastPeerListRequestCount;
+		if (m_fastPeerListRequestCount >= 3) {
+			LOGWARN(4, "peer " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " is sending PEER_LIST_REQUEST too often");
+			return false;
+		}
+	}
+
+	m_prevIncomingPeerListRequest = cur_time;
 
 	Peer peers[PEER_LIST_RESPONSE_MAX_PEERS];
 	uint32_t num_selected_peers = 0;
@@ -1649,7 +1849,7 @@ bool P2PServer::P2PClient::on_peer_list_request(const uint8_t*)
 bool P2PServer::P2PClient::on_peer_list_response(const uint8_t* buf) const
 {
 	P2PServer* server = static_cast<P2PServer*>(m_owner);
-	const time_t cur_time = time(nullptr);
+	const uint64_t cur_time = seconds_since_epoch();
 
 	MutexLock lock(server->m_peerListLock);
 
@@ -1772,11 +1972,13 @@ void P2PServer::P2PClient::post_handle_incoming_block(const uint32_t reset_count
 	ReadLock lock(server->m_cachedBlocksLock);
 
 	for (const hash& id : missing_blocks) {
-		auto it = server->m_cachedBlocks.find(id);
-		if (it != server->m_cachedBlocks.end()) {
-			LOGINFO(5, "using cached block for id = " << id);
-			handle_incoming_block_async(it->second);
-			continue;
+		if (server->m_cachedBlocks) {
+			auto it = server->m_cachedBlocks->find(id);
+			if (it != server->m_cachedBlocks->end()) {
+				LOGINFO(5, "using cached block for id = " << id);
+				handle_incoming_block_async(it->second);
+				continue;
+			}
 		}
 
 		const bool result = m_owner->send(this,
@@ -1797,6 +1999,8 @@ void P2PServer::P2PClient::post_handle_incoming_block(const uint32_t reset_count
 		if (!result) {
 			return;
 		}
+
+		++m_blockPendingRequests;
 	}
 }
 

src/p2p_server.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -18,7 +18,6 @@
 #pragma once
 
 #include "tcp_server.h"
-#include <random>
 
 namespace p2pool {
 
@@ -110,14 +109,18 @@ public:
 		bool m_handshakeInvalid;
 		int m_listenPort;
 
-		time_t m_nextPeerListRequest;
-		std::chrono::system_clock::time_point m_lastPeerListRequestTime;
+		uint32_t m_fastPeerListRequestCount;
+		uint64_t m_prevIncomingPeerListRequest;
+		uint64_t m_nextOutgoingPeerListRequest;
+		std::chrono::high_resolution_clock::time_point m_lastPeerListRequestTime;
 		int m_peerListPendingRequests;
 		int64_t m_pingTime;
 
-		time_t m_lastAlive;
-		time_t m_lastBroadcastTimestamp;
-		time_t m_lastBlockrequestTimestamp;
+		int m_blockPendingRequests;
+
+		uint64_t m_lastAlive;
+		uint64_t m_lastBroadcastTimestamp;
+		uint64_t m_lastBlockrequestTimestamp;
 
 		hash m_broadcastedHashes[8];
 		std::atomic<uint32_t> m_broadcastedHashesIndex{ 0 };
@@ -146,7 +149,7 @@ private:
 	uint32_t m_maxIncomingPeers;
 
 	uv_rwlock_t m_cachedBlocksLock;
-	unordered_map<hash, PoolBlock*> m_cachedBlocks;
+	unordered_map<hash, PoolBlock*>* m_cachedBlocks;
 
 private:
 	static void on_timer(uv_timer_t* timer) { reinterpret_cast<P2PServer*>(timer->data)->on_timer(); }
@@ -160,19 +163,20 @@ private:
 	void save_peer_list_async();
 	void save_peer_list();
 	void load_peer_list();
+	void load_monerod_peer_list();
 	void update_peer_in_list(bool is_v6, const raw_ip& ip, int port);
 	void remove_peer_from_list(P2PClient* client);
 	void remove_peer_from_list(const raw_ip& ip);
 
 	uv_mutex_t m_rngLock;
-	std::random_device m_rd;
 	std::mt19937_64 m_rng;
 
 	uv_mutex_t m_blockLock;
 	PoolBlock* m_block;
 
 	uv_timer_t m_timer;
-	uint32_t m_timerCounter;
+	uint64_t m_timerCounter;
+	uint64_t m_timerInterval;
 
 	uint64_t m_peerId;
 
@@ -184,11 +188,12 @@ private:
 		raw_ip m_addr;
 		int m_port;
 		uint32_t m_numFailedConnections;
-		time_t m_lastSeen;
+		uint64_t m_lastSeen;
 	};
 
 	std::vector<Peer> m_peerList;
-	time_t m_peerListLastSaved;
+	std::vector<Peer> m_peerListMonero;
+	uint64_t m_peerListLastSaved;
 
 	struct Broadcast
 	{

src/p2pool.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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 +27,9 @@
 #include "side_chain.h"
 #include "stratum_server.h"
 #include "p2p_server.h"
+#ifdef WITH_RANDOMX
 #include "miner.h"
+#endif
 #include "params.h"
 #include "console_commands.h"
 #include "crypto.h"
@@ -52,7 +54,7 @@ p2pool::p2pool(int argc, char* argv[])
 	, m_updateSeed(true)
 	, m_submitBlockData{}
 	, m_zmqLastActive(0)
-	, m_startTime(time(nullptr))
+	, m_startTime(seconds_since_epoch())
 {
 	LOGINFO(1, log::LightCyan() << VERSION);
 
@@ -111,6 +113,11 @@ 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);
 
+	if (m_params->m_localStats && !m_api) {
+		LOGERR(1, "--local-api and --stratum-api command line parameters can't be used without --data-api");
+		panic();
+	}
+
 	m_sideChain = new SideChain(this, type, m_params->m_mini ? "mini" : nullptr);
 
 	if (m_params->m_p2pAddresses.empty()) {
@@ -123,12 +130,16 @@ p2pool::p2pool(int argc, char* argv[])
 		m_params->m_p2pAddresses = buf;
 	}
 
+#ifdef WITH_RANDOMX
 	if (m_params->m_disableRandomX) {
 		m_hasher = new RandomX_Hasher_RPC(this);
 	}
 	else {
 		m_hasher = new RandomX_Hasher(this);
 	}
+#else
+	m_hasher = new RandomX_Hasher_RPC(this);
+#endif
 
 	m_blockTemplate = new BlockTemplate(this);
 	m_mempool = new Mempool();
@@ -195,7 +206,7 @@ void p2pool::handle_tx(TxMempoolData& tx)
 	m_blockTemplate->update(m_minerData, *m_mempool, &m_params->m_wallet);
 #endif
 
-	m_zmqLastActive = time(nullptr);
+	m_zmqLastActive = seconds_since_epoch();
 }
 
 void p2pool::handle_miner_data(MinerData& data)
@@ -227,7 +238,7 @@ void p2pool::handle_miner_data(MinerData& data)
 	}
 
 	data.tx_backlog.clear();
-	data.time_received = std::chrono::system_clock::now();
+	data.time_received = std::chrono::high_resolution_clock::now();
 	m_minerData = data;
 	m_updateSeed = true;
 	update_median_timestamp();
@@ -252,7 +263,7 @@ void p2pool::handle_miner_data(MinerData& data)
 		update_block_template();
 	}
 
-	m_zmqLastActive = time(nullptr);
+	m_zmqLastActive = seconds_since_epoch();
 
 	if (m_serversStarted.load()) {
 		std::vector<uint64_t> missing_heights;
@@ -356,7 +367,7 @@ void p2pool::handle_chain_main(ChainMain& data, const char* extra)
 
 	api_update_network_stats();
 
-	m_zmqLastActive = time(nullptr);
+	m_zmqLastActive = seconds_since_epoch();
 }
 
 void p2pool::submit_block_async(uint32_t template_id, uint32_t nonce, uint32_t extra_nonce)
@@ -597,9 +608,11 @@ void p2pool::download_block_headers(uint64_t current_height)
 					m_ZMQReader = new ZMQReader(m_params->m_host.c_str(), m_params->m_zmqPort, this);
 					m_stratumServer = new StratumServer(this);
 					m_p2pServer = new P2PServer(this);
+#ifdef WITH_RANDOMX
 					if (m_params->m_minerThreads) {
 						start_mining(m_params->m_minerThreads);
 					}
+#endif
 					api_update_network_stats();
 				}
 			}
@@ -666,9 +679,11 @@ void p2pool::update_median_timestamp()
 
 void p2pool::stratum_on_block()
 {
+#ifdef WITH_RANDOMX
 	if (m_miner) {
 		m_miner->on_block(*m_blockTemplate);
 	}
+#endif
 	if (m_stratumServer) {
 		m_stratumServer->on_block(*m_blockTemplate);
 	}
@@ -1114,7 +1129,7 @@ void p2pool::api_update_stats_mod()
 	m_api->set(p2pool_api::Category::GLOBAL, "stats_mod",
 		[&mainnet_tip, last_block_found_time, &last_block_found_buf, last_block_found_height, miners, hashrate, round_hashes, stratum_port](log::Stream& s)
 		{
-			s << "{\"config\":{\"ports\":[{\"port\":" << stratum_port << ",\"tls\":false}],\"fee\":0,\"minPaymentThreshold\":400000000},\"network\":{\"height\":"
+			s << "{\"config\":{\"ports\":[{\"port\":" << stratum_port << ",\"tls\":false}],\"fee\":0,\"minPaymentThreshold\":300000000},\"network\":{\"height\":"
 				<< mainnet_tip.height << "},\"pool\":{\"stats\":{\"lastBlockFound\":\""
 				<< last_block_found_time << "000\"},\"blocks\":[\""
 				<< static_cast<char*>(last_block_found_buf) << static_cast<char*>(last_block_found_buf) + HASH_SIZE * 2 - 4 << ':'
@@ -1214,6 +1229,7 @@ bool p2pool::get_difficulty_at_height(uint64_t height, difficulty_type& diff)
 	return true;
 }
 
+#ifdef WITH_RANDOMX
 void p2pool::start_mining(uint32_t threads)
 {
 	stop_mining();
@@ -1228,6 +1244,7 @@ void p2pool::stop_mining()
 		delete miner;
 	}
 }
+#endif
 
 static void on_signal(uv_signal_t* handle, int signum)
 {
@@ -1337,7 +1354,9 @@ int p2pool::run()
 
 	bkg_jobs_tracker.wait();
 
+#ifdef WITH_RANDOMX
 	delete m_miner;
+#endif
 	delete m_stratumServer;
 	delete m_p2pServer;
 

src/p2pool.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -59,7 +59,9 @@ public:
 
 	StratumServer* stratum_server() const { return m_stratumServer; }
 	P2PServer* p2p_server() const { return m_p2pServer; }
+#ifdef WITH_RANDOMX
 	Miner* miner() const { return m_miner; }
+#endif
 
 	virtual void handle_tx(TxMempoolData& tx) override;
 	virtual void handle_miner_data(MinerData& data) override;
@@ -80,11 +82,13 @@ public:
 
 	bool get_difficulty_at_height(uint64_t height, difficulty_type& diff);
 
+#ifdef WITH_RANDOMX
 	void start_mining(uint32_t threads);
 	void stop_mining();
+#endif
 
-	time_t zmq_last_active() const { return m_zmqLastActive; }
-	time_t start_time() const { return m_startTime; }
+	uint64_t zmq_last_active() const { return m_zmqLastActive; }
+	uint64_t start_time() const { return m_startTime; }
 
 private:
 	p2pool(const p2pool&) = delete;
@@ -160,7 +164,9 @@ private:
 	std::atomic<uint32_t> m_serversStarted{ 0 };
 	StratumServer* m_stratumServer = nullptr;
 	P2PServer* m_p2pServer = nullptr;
+#ifdef WITH_RANDOMX
 	Miner* m_miner = nullptr;
+#endif
 
 	ConsoleCommands* m_consoleCommands;
 
@@ -179,8 +185,8 @@ private:
 	uv_async_t m_blockTemplateAsync;
 	uv_async_t m_stopAsync;
 
-	time_t m_zmqLastActive;
-	time_t m_startTime;
+	uint64_t m_zmqLastActive;
+	uint64_t m_startTime;
 
 	ZMQReader* m_ZMQReader = nullptr;
 };

src/p2pool_api.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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

src/p2pool_api.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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

src/params.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -20,86 +20,115 @@
 #include "stratum_server.h"
 #include "p2p_server.h"
 
+void p2pool_usage();
+
 namespace p2pool {
 
 Params::Params(int argc, char* argv[])
 {
 	for (int i = 1; i < argc; ++i) {
+		bool ok = false;
+
 		if ((strcmp(argv[i], "--host") == 0) && (i + 1 < argc)) {
 			m_host = argv[++i];
+			ok = true;
 		}
 
 		if ((strcmp(argv[i], "--rpc-port") == 0) && (i + 1 < argc)) {
 			m_rpcPort = strtoul(argv[++i], nullptr, 10);
+			ok = true;
 		}
 
 		if ((strcmp(argv[i], "--zmq-port") == 0) && (i + 1 < argc)) {
 			m_zmqPort = strtoul(argv[++i], nullptr, 10);
+			ok = true;
 		}
 
 		if (strcmp(argv[i], "--light-mode") == 0) {
 			m_lightMode = true;
+			ok = true;
 		}
 
 		if ((strcmp(argv[i], "--wallet") == 0) && (i + 1 < argc)) {
 			m_wallet.decode(argv[++i]);
+			ok = true;
 		}
 
 		if ((strcmp(argv[i], "--stratum") == 0) && (i + 1 < argc)) {
 			m_stratumAddresses = argv[++i];
+			ok = true;
 		}
 
 		if ((strcmp(argv[i], "--p2p") == 0) && (i + 1 < argc)) {
 			m_p2pAddresses = argv[++i];
+			ok = true;
 		}
 
 		if ((strcmp(argv[i], "--addpeers") == 0) && (i + 1 < argc)) {
 			m_p2pPeerList = argv[++i];
+			ok = true;
 		}
 
 		if ((strcmp(argv[i], "--loglevel") == 0) && (i + 1 < argc)) {
 			const int level = std::min(std::max<int>(strtol(argv[++i], nullptr, 10), 0), log::MAX_GLOBAL_LOG_LEVEL);
 			log::GLOBAL_LOG_LEVEL = level;
+			ok = true;
 		}
 
 		if ((strcmp(argv[i], "--config") == 0) && (i + 1 < argc)) {
 			m_config = argv[++i];
+			ok = true;
 		}
 
 		if ((strcmp(argv[i], "--data-api") == 0) && (i + 1 < argc)) {
 			m_apiPath = argv[++i];
+			ok = true;
 		}
 
 		if ((strcmp(argv[i], "--local-api") == 0) || (strcmp(argv[i], "--stratum-api") == 0)) {
 			m_localStats = true;
+			ok = true;
 		}
 
 		if (strcmp(argv[i], "--no-cache") == 0) {
 			m_blockCache = false;
+			ok = true;
 		}
 
 		if (strcmp(argv[i], "--no-color") == 0) {
 			log::CONSOLE_COLORS = false;
+			ok = true;
 		}
 
 		if (strcmp(argv[i], "--no-randomx") == 0) {
 			m_disableRandomX = true;
+			ok = true;
 		}
 
 		if ((strcmp(argv[i], "--out-peers") == 0) && (i + 1 < argc)) {
 			m_maxOutgoingPeers = std::min(std::max(strtoul(argv[++i], nullptr, 10), 10UL), 1000UL);
+			ok = true;
 		}
 
 		if ((strcmp(argv[i], "--in-peers") == 0) && (i + 1 < argc)) {
 			m_maxIncomingPeers = std::min(std::max(strtoul(argv[++i], nullptr, 10), 10UL), 1000UL);
+			ok = true;
 		}
 
 		if ((strcmp(argv[i], "--start-mining") == 0) && (i + 1 < argc)) {
 			m_minerThreads = std::min(std::max(strtoul(argv[++i], nullptr, 10), 1UL), 64UL);
+			ok = true;
 		}
 
 		if (strcmp(argv[i], "--mini") == 0) {
 			m_mini = true;
+			ok = true;
+		}
+
+		if (!ok) {
+			fprintf(stderr, "Unknown command line parameter %s\n\n", argv[i]);
+			p2pool_usage();
+			panic();
 		}
 	}
 

src/params.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -39,7 +39,11 @@ struct Params
 	std::string m_apiPath;
 	bool m_localStats = false;
 	bool m_blockCache = true;
+#ifdef WITH_RANDOMX
 	bool m_disableRandomX = false;
+#else
+	bool m_disableRandomX = true;
+#endif
 	uint32_t m_maxOutgoingPeers = 10;
 	uint32_t m_maxIncomingPeers = 1000;
 	uint32_t m_minerThreads = 0;

src/pool_block.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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 +53,7 @@ PoolBlock::PoolBlock()
 	, m_invalid(false)
 	, m_broadcasted(false)
 	, m_wantBroadcast(false)
-	, m_localTimestamp(time(nullptr))
+	, m_localTimestamp(seconds_since_epoch())
 {
 	uv_mutex_init_checked(&m_lock);
 
@@ -115,7 +115,7 @@ PoolBlock& PoolBlock::operator=(const PoolBlock& b)
 	m_broadcasted = b.m_broadcasted;
 	m_wantBroadcast = b.m_wantBroadcast;
 
-	m_localTimestamp = time(nullptr);
+	m_localTimestamp = seconds_since_epoch();
 
 	if (lock_result == 0) {
 		uv_mutex_unlock(&b.m_lock);

src/pool_block.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -130,7 +130,7 @@ struct PoolBlock
 	bool m_broadcasted;
 	bool m_wantBroadcast;
 
-	time_t m_localTimestamp;
+	uint64_t m_localTimestamp;
 
 	void serialize_mainchain_data(uint32_t nonce, uint32_t extra_nonce, const hash& sidechain_hash);
 	void serialize_sidechain_data();

src/pool_block_parser.inl

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -187,7 +187,7 @@ int PoolBlock::deserialize(const uint8_t* data, size_t size, SideChain& sidechai
 		READ_VARINT(m_extraNonceSize);
 
 		// Sanity check
-		if ((m_extraNonceSize < EXTRA_NONCE_SIZE) || (m_extraNonceSize > EXTRA_NONCE_SIZE + 10)) return __LINE__;
+		if ((m_extraNonceSize < EXTRA_NONCE_SIZE) || (m_extraNonceSize > EXTRA_NONCE_MAX_SIZE)) return __LINE__;
 
 		const int extra_nonce_offset = static_cast<int>((data - data_begin) + outputs_blob_size_diff);
 		READ_BUF(&m_extraNonce, EXTRA_NONCE_SIZE);
@@ -350,7 +350,7 @@ int PoolBlock::deserialize(const uint8_t* data, size_t size, SideChain& sidechai
 	m_broadcasted = false;
 	m_wantBroadcast = false;
 
-	m_localTimestamp = time(nullptr);
+	m_localTimestamp = seconds_since_epoch();
 
 	return 0;
 }

src/pow_hash.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -19,9 +19,11 @@
 #include "pow_hash.h"
 #include "p2pool.h"
 #include "params.h"
+#ifdef WITH_RANDOMX
 #include "randomx.h"
 #include "configuration.h"
 #include "virtual_machine.hpp"
+#endif
 #include "json_rpc_request.h"
 #include "json_parsers.h"
 #include <rapidjson/document.h>
@@ -31,6 +33,7 @@ static constexpr char log_category_prefix[] = "RandomX_Hasher ";
 
 namespace p2pool {
 
+#ifdef WITH_RANDOMX
 RandomX_Hasher::RandomX_Hasher(p2pool* pool)
 	: m_pool(pool)
 	, m_cache{}
@@ -38,6 +41,7 @@ RandomX_Hasher::RandomX_Hasher(p2pool* pool)
 	, m_seed{}
 	, m_index(0)
 	, m_seedCounter(0)
+	, m_oldSeedCounter(0)
 {
 	uint64_t memory_allocated = 0;
 
@@ -220,6 +224,11 @@ void RandomX_Hasher::set_seed(const hash& seed)
 			numThreads /= 2;
 		}
 
+		// wait for set_old_seed() before initializing dataset
+		while (m_oldSeedCounter.load() == 0) {
+			std::this_thread::yield();
+		}
+
 		LOGINFO(1, log::LightCyan() << "running " << numThreads << " threads to update dataset");
 
 		ReadLock lock2(m_cacheLock);
@@ -271,7 +280,7 @@ void RandomX_Hasher::set_old_seed(const hash& seed)
 {
 	// set_seed() must go first, wait for it
 	while (m_seedCounter.load() == 0) {
-		std::this_thread::sleep_for(std::chrono::milliseconds(1));
+		std::this_thread::yield();
 	}
 
 	LOGINFO(1, "old seed " << log::LightBlue() << seed);
@@ -279,6 +288,8 @@ void RandomX_Hasher::set_old_seed(const hash& seed)
 	{
 		WriteLock lock(m_cacheLock);
 
+		m_oldSeedCounter.fetch_add(1);
+
 		const uint32_t old_index = m_index ^ 1;
 		m_seed[old_index] = seed;
 
@@ -357,6 +368,7 @@ bool RandomX_Hasher::calculate(const void* data, size_t size, uint64_t /*height*
 
 	return false;
 }
+#endif
 
 RandomX_Hasher_RPC::RandomX_Hasher_RPC(p2pool* pool)
 	: m_pool(pool)

src/pow_hash.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -43,6 +43,7 @@ public:
 	virtual bool calculate(const void* data, size_t size, uint64_t height, const hash& seed, hash& result) = 0;
 };
 
+#ifdef WITH_RANDOMX
 class RandomX_Hasher : public RandomX_Hasher_Base
 {
 public:
@@ -89,7 +90,9 @@ private:
 	uint32_t m_index;
 
 	std::atomic<uint32_t> m_seedCounter;
+	std::atomic<uint32_t> m_oldSeedCounter;
 };
+#endif
 
 class RandomX_Hasher_RPC : public RandomX_Hasher_Base
 {

src/side_chain.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -21,12 +21,15 @@
 #include "pool_block.h"
 #include "wallet.h"
 #include "block_template.h"
+#ifdef WITH_RANDOMX
 #include "randomx.h"
 #include "dataset.hpp"
 #include "configuration.h"
 #include "intrin_portable.h"
+#endif
 #include "keccak.h"
 #include "p2p_server.h"
+#include "stratum_server.h"
 #include "params.h"
 #include "json_parsers.h"
 #include <rapidjson/document.h>
@@ -107,6 +110,7 @@ SideChain::SideChain(p2pool* pool, NetworkType type, const char* pool_name)
 		m_consensusId.assign(mini_consensus_id, mini_consensus_id + HASH_SIZE);
 	}
 	else {
+#ifdef WITH_RANDOMX
 		const randomx_flags flags = randomx_get_flags();
 		randomx_cache* cache = randomx_alloc_cache(flags | RANDOMX_FLAG_LARGE_PAGES);
 		if (!cache) {
@@ -141,6 +145,10 @@ SideChain::SideChain(p2pool* pool, NetworkType type, const char* pool_name)
 		keccak(reinterpret_cast<uint8_t*>(scratchpad), static_cast<int>(scratchpad_size * sizeof(rx_vec_i128)), id.h, HASH_SIZE);
 		randomx_release_cache(cache);
 		m_consensusId.assign(id.h, id.h + HASH_SIZE);
+#else
+		LOGERR(1, "Can't calculate consensus ID without RandomX library");
+		panic();
+#endif
 	}
 
 	s.m_pos = 0;
@@ -148,7 +156,8 @@ SideChain::SideChain(p2pool* pool, NetworkType type, const char* pool_name)
 
 	// Hide most consensus ID bytes, we only want it on screen to show that we're on the right sidechain
 	memset(buf + 8, '*', HASH_SIZE * 2 - 16);
-	LOGINFO(1, "consensus ID = " << log::LightCyan() << static_cast<char*>(buf));
+	m_consensusIdDisplayStr.assign(buf);
+	LOGINFO(1, "consensus ID = " << log::LightCyan() << m_consensusIdDisplayStr.c_str());
 }
 
 SideChain::~SideChain()
@@ -505,11 +514,6 @@ void SideChain::add_block(const PoolBlock& block)
 		", verified = " << (block.m_verified ? 1 : 0)
 	);
 
-	// Save it for faster syncing on the next p2pool start
-	if (p2pServer()) {
-		p2pServer()->store_in_cache(block);
-	}
-
 	PoolBlock* new_block = new PoolBlock(block);
 
 	MutexLock lock(m_sidechainLock);
@@ -532,6 +536,11 @@ void SideChain::add_block(const PoolBlock& block)
 	if (new_block->m_verified) {
 		if (!new_block->m_invalid) {
 			update_chain_tip(new_block);
+
+			// Save it for faster syncing on the next p2pool start
+			if (P2PServer* server = p2pServer()) {
+				server->store_in_cache(*new_block);
+			}
 		}
 	}
 	else {
@@ -737,31 +746,39 @@ void SideChain::print_status()
 	const uint64_t hashrate_est = total_reward ? udiv128(product[1], product[0], total_reward, &rem) : 0;
 	const double block_share = total_reward ? ((static_cast<double>(your_reward) * 100.0) / static_cast<double>(total_reward)) : 0.0;
 
-	uint32_t our_blocks_in_window_total = std::accumulate(our_blocks_in_window.begin(), our_blocks_in_window.end(), decltype(our_blocks_in_window)::value_type(0));
-	uint32_t our_uncles_in_window_total = std::accumulate(our_uncles_in_window.begin(), our_uncles_in_window.end(), decltype(our_uncles_in_window)::value_type(0));
+	const uint32_t our_blocks_in_window_total = std::accumulate(our_blocks_in_window.begin(), our_blocks_in_window.end(), 0U);
+	const uint32_t our_uncles_in_window_total = std::accumulate(our_uncles_in_window.begin(), our_uncles_in_window.end(), 0U);
 
 	std::string our_blocks_in_window_chart;
-	our_blocks_in_window_chart.reserve(our_blocks_in_window.size());
-	for(const auto& p : our_blocks_in_window){
-		our_blocks_in_window_chart += (p > 0 ? (p > 9 ? "+" : std::to_string(p)) : ".");
+	if (our_blocks_in_window_total) {
+		our_blocks_in_window_chart.reserve(our_blocks_in_window.size() + 32);
+		our_blocks_in_window_chart = "\nYour shares position      = [";
+		for (uint32_t p : our_blocks_in_window) {
+			our_blocks_in_window_chart += (p ? ((p > 9) ? '+' : static_cast<char>('0' + p)) : '.');
+		}
+		our_blocks_in_window_chart += ']';
 	}
 
 	std::string our_uncles_in_window_chart;
-	our_uncles_in_window_chart.reserve(our_uncles_in_window.size());
-	for(const auto& p : our_uncles_in_window){
-		our_uncles_in_window_chart += (p > 0 ? (p > 9 ? "+" : std::to_string(p)) : ".");
+	if (our_uncles_in_window_total) {
+		our_uncles_in_window_chart.reserve(our_uncles_in_window.size() + 32);
+		our_uncles_in_window_chart = "\nYour uncles position      = [";
+		for (uint32_t p : our_uncles_in_window) {
+			our_uncles_in_window_chart += (p ? ((p > 9) ? '+' : static_cast<char>('0' + p)) : '.');
+		}
+		our_uncles_in_window_chart += ']';
 	}
 
 	LOGINFO(0, "status" <<
 		"\nMain chain height         = " << m_pool->block_template().height() <<
 		"\nMain chain hashrate       = " << log::Hashrate(network_hashrate) <<
+		"\nSide chain ID             = " << (is_default() ? "default" : (is_mini() ? "mini" : m_consensusIdDisplayStr.c_str())) <<
 		"\nSide chain height         = " << tip_height + 1 <<
 		"\nSide chain hashrate       = " << log::Hashrate(pool_hashrate) <<
 		(hashrate_est ? "\nYour hashrate (pool-side) = " : "") << (hashrate_est ? log::Hashrate(hashrate_est) : log::Hashrate()) <<
 		"\nPPLNS window              = " << total_blocks_in_window << " blocks (+" << total_uncles_in_window << " uncles, " << total_orphans << " orphans)" <<
-		"\nYour shares               = " << our_blocks_in_window_total << " blocks (+" << our_uncles_in_window_total << " uncles, " << our_orphans << " orphans)" <<
-		(our_blocks_in_window_total > 0 ? "\nYour shares position      = " : "") << (our_blocks_in_window_total > 0 ? "[" + our_blocks_in_window_chart + "]" : "") <<
-		(our_uncles_in_window_total > 0 ? "\nYour uncles position      = " : "") << (our_uncles_in_window_total > 0 ? "[" + our_uncles_in_window_chart + "]" : "") <<
+		"\nYour shares               = " << our_blocks_in_window_total << " blocks (+" << our_uncles_in_window_total << " uncles, " << our_orphans << " orphans)"
+										 << our_blocks_in_window_chart << our_uncles_in_window_chart <<
 		"\nBlock reward share        = " << block_share << "% (" << log::XMRAmount(your_reward) << ')'
 	);
 }
@@ -773,7 +790,7 @@ difficulty_type SideChain::total_hashes() const
 
 uint64_t SideChain::miner_count()
 {
-	const time_t cur_time = time(nullptr);
+	const uint64_t cur_time = seconds_since_epoch();
 
 	MutexLock lock(m_sidechainLock);
 
@@ -790,7 +807,7 @@ uint64_t SideChain::miner_count()
 	return m_seenWallets.size();
 }
 
-time_t SideChain::last_updated() const
+uint64_t SideChain::last_updated() const
 {
 	return m_chainTip ? m_chainTip->m_localTimestamp : 0;
 }
@@ -985,7 +1002,8 @@ void SideChain::verify_loop(PoolBlock* block)
 
 			// This block is now verified
 
-			if (is_longer_chain(highest_block, block)) {
+			bool is_alternative;
+			if (is_longer_chain(highest_block, block, is_alternative)) {
 				highest_block = block;
 			}
 			else if (highest_block && (highest_block->m_sidechainHeight > block->m_sidechainHeight)) {
@@ -995,17 +1013,19 @@ void SideChain::verify_loop(PoolBlock* block)
 					", height " << block->m_sidechainHeight);
 			}
 
+			P2PServer* server = p2pServer();
+
 			// If it came through a broadcast, send it to our peers
 			if (block->m_wantBroadcast && !block->m_broadcasted) {
 				block->m_broadcasted = true;
-				if (p2pServer() && (block->m_depth < UNCLE_BLOCK_DEPTH)) {
-					p2pServer()->broadcast(*block);
+				if (server && (block->m_depth < UNCLE_BLOCK_DEPTH)) {
+					server->broadcast(*block);
 				}
 			}
 
 			// Save it for faster syncing on the next p2pool start
-			if (p2pServer()) {
-				p2pServer()->store_in_cache(*block);
+			if (server) {
+				server->store_in_cache(*block);
 			}
 
 			// Try to verify blocks on top of this one
@@ -1330,7 +1350,8 @@ void SideChain::update_chain_tip(PoolBlock* block)
 		return;
 	}
 
-	if (is_longer_chain(m_chainTip, block)) {
+	bool is_alternative;
+	if (is_longer_chain(m_chainTip, block, is_alternative)) {
 		difficulty_type diff;
 		if (get_difficulty(block, m_difficultyData, diff)) {
 			m_chainTip = block;
@@ -1343,6 +1364,12 @@ void SideChain::update_chain_tip(PoolBlock* block)
 			block->m_wantBroadcast = true;
 			if (m_pool) {
 				m_pool->update_block_template_async();
+
+				// Reset stratum share counters when switching to an alternative chain to avoid confusion
+				StratumServer* s = m_pool->stratum_server();
+				if (s && is_alternative) {
+					s->reset_share_counters();
+				}
 			}
 			prune_old_blocks();
 		}
@@ -1405,8 +1432,10 @@ PoolBlock* SideChain::get_parent(const PoolBlock* block)
 	return nullptr;
 }
 
-bool SideChain::is_longer_chain(const PoolBlock* block, const PoolBlock* candidate)
+bool SideChain::is_longer_chain(const PoolBlock* block, const PoolBlock* candidate, bool& is_alternative)
 {
+	is_alternative = false;
+
 	if (!candidate || !candidate->m_verified || candidate->m_invalid) {
 		return false;
 	}
@@ -1449,6 +1478,8 @@ bool SideChain::is_longer_chain(const PoolBlock* block, const PoolBlock* candida
 	}
 
 	// They're on totally different chains. Compare total difficulties over the last m_chainWindowSize blocks
+	is_alternative = true;
+
 	difficulty_type block_total_diff;
 	difficulty_type candidate_total_diff;
 
@@ -1564,7 +1595,8 @@ void SideChain::prune_old_blocks()
 	const uint64_t prune_distance = m_chainWindowSize * 2 + 120 / m_targetBlockTime;
 
 	// Remove old blocks from alternative unconnected chains after long enough time
-	const time_t prune_time = time(nullptr) - m_chainWindowSize * 4 * m_targetBlockTime;
+	const uint64_t cur_time = seconds_since_epoch();
+	const uint64_t prune_delay = m_chainWindowSize * 4 * m_targetBlockTime;
 
 	if (m_chainTip->m_sidechainHeight < prune_distance) {
 		return;
@@ -1579,9 +1611,9 @@ void SideChain::prune_old_blocks()
 		std::vector<PoolBlock*>& v = it->second;
 
 		v.erase(std::remove_if(v.begin(), v.end(),
-			[this, prune_distance, prune_time, &num_blocks_pruned, height](PoolBlock* block)
+			[this, prune_distance, cur_time, prune_delay, &num_blocks_pruned, height](PoolBlock* block)
 			{
-				if ((block->m_depth >= prune_distance) || (block->m_localTimestamp <= prune_time)) {
+				if ((block->m_depth >= prune_distance) || (cur_time >= block->m_localTimestamp + prune_delay)) {
 					auto it2 = m_blocksById.find(block->m_sidechainId);
 					if (it2 != m_blocksById.end()) {
 						m_blocksById.erase(it2);

src/side_chain.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -69,7 +69,7 @@ public:
 	difficulty_type total_hashes() const;
 	uint64_t block_time() const { return m_targetBlockTime; }
 	uint64_t miner_count();
-	time_t last_updated() const;
+	uint64_t last_updated() const;
 	bool is_default() const;
 	bool is_mini() const;
 
@@ -91,7 +91,7 @@ private:
 	PoolBlock* get_parent(const PoolBlock* block);
 
 	// Checks if "candidate" has longer (higher difficulty) chain than "block"
-	bool is_longer_chain(const PoolBlock* block, const PoolBlock* candidate);
+	bool is_longer_chain(const PoolBlock* block, const PoolBlock* candidate, bool& is_alternative);
 	void update_depths(PoolBlock* block);
 	void prune_old_blocks();
 
@@ -102,7 +102,7 @@ private:
 	PoolBlock* m_chainTip;
 	std::map<uint64_t, std::vector<PoolBlock*>> m_blocksByHeight;
 	unordered_map<hash, PoolBlock*> m_blocksById;
-	unordered_map<hash, time_t> m_seenWallets;
+	unordered_map<hash, uint64_t> m_seenWallets;
 	std::vector<MinerShare> m_tmpShares;
 	std::vector<uint64_t> m_tmpRewards;
 
@@ -119,6 +119,7 @@ private:
 	uint64_t m_unclePenalty;
 
 	std::vector<uint8_t> m_consensusId;
+	std::string m_consensusIdDisplayStr;
 
 	difficulty_type m_curDifficulty;
 

src/stratum_server.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -39,8 +39,7 @@ StratumServer::StratumServer(p2pool* pool)
 	: TCPServer(StratumClient::allocate)
 	, m_pool(pool)
 	, m_extraNonce(0)
-	, m_rd{}
-	, m_rng(m_rd())
+	, m_rng(RandomDeviceSeed::instance)
 	, m_cumulativeHashes(0)
 	, m_cumulativeHashesAtLastShare(0)
 	, m_hashrateDataHead(0)
@@ -51,7 +50,10 @@ StratumServer::StratumServer(p2pool* pool)
 	, m_totalFoundShares(0)
 	, m_apiLastUpdateTime(0)
 {
-	m_hashrateData[0] = { time(nullptr), 0 };
+	// Diffuse the initial state in case it has low quality
+	m_rng.discard(10000);
+
+	m_hashrateData[0] = { seconds_since_epoch(), 0 };
 
 	uv_mutex_init_checked(&m_blobsQueueLock);
 	uv_mutex_init_checked(&m_rngLock);
@@ -435,10 +437,17 @@ uint64_t StratumServer::get_random64()
 
 void StratumServer::print_status()
 {
-	update_hashrate_data(0, time(nullptr));
+	update_hashrate_data(0, seconds_since_epoch());
 	print_stratum_status();
 }
 
+void StratumServer::reset_share_counters()
+{
+	m_cumulativeHashesAtLastShare = 0;
+	m_cumulativeFoundSharesDiff = 0.0;
+	m_totalFoundShares = 0;
+}
+
 void StratumServer::print_stratum_status() const
 {
 	uint64_t hashes_15m, hashes_1h, hashes_24h, total_hashes;
@@ -473,8 +482,9 @@ void StratumServer::print_stratum_status() const
 	const uint64_t hashrate_24h = (dt_24h > 0) ? (hashes_24h / dt_24h) : 0;
 
 	double average_effort = 0.0;
-	if (m_cumulativeFoundSharesDiff > 0.0) {
-		average_effort = static_cast<double>(m_cumulativeHashesAtLastShare) * 100.0 / m_cumulativeFoundSharesDiff;
+	const double diff = m_cumulativeFoundSharesDiff;
+	if (diff > 0.0) {
+		average_effort = static_cast<double>(m_cumulativeHashesAtLastShare) * 100.0 / diff;
 	}
 
 	LOGINFO(0, "status" <<
@@ -517,7 +527,7 @@ void StratumServer::on_blobs_ready()
 	size_t numClientsProcessed = 0;
 	uint32_t extra_nonce = 0;
 
-	const time_t cur_time = time(nullptr);
+	const uint64_t cur_time = seconds_since_epoch();
 	{
 		MutexLock lock2(m_clientsListLock);
 
@@ -595,7 +605,7 @@ void StratumServer::on_blobs_ready()
 	LOGINFO(3, "sent new job to " << extra_nonce << '/' << numClientsProcessed << " clients");
 }
 
-void StratumServer::update_hashrate_data(uint64_t hashes, time_t timestamp)
+void StratumServer::update_hashrate_data(uint64_t hashes, uint64_t timestamp)
 {
 	constexpr size_t N = array_size(&StratumServer::m_hashrateData);
 
@@ -697,7 +707,7 @@ void StratumServer::on_share_found(uv_work_t* req)
 	const uint64_t value = *reinterpret_cast<uint64_t*>(share->m_resultHash.h + HASH_SIZE - sizeof(uint64_t));
 
 	if (LIKELY(value < target)) {
-		const time_t timestamp = time(nullptr);
+		const uint64_t timestamp = seconds_since_epoch();
 		server->update_hashrate_data(hashes, timestamp);
 		server->api_update_local_stats(timestamp);
 		share->m_result = SubmittedShare::Result::OK;
@@ -793,7 +803,7 @@ void StratumServer::StratumClient::reset()
 
 bool StratumServer::StratumClient::on_connect()
 {
-	m_connectedTime = time(nullptr);
+	m_connectedTime = seconds_since_epoch();
 	return true;
 }
 
@@ -983,7 +993,7 @@ bool StratumServer::StratumClient::process_submit(rapidjson::Document& doc, uint
 	return static_cast<StratumServer*>(m_owner)->on_submit(this, id, job_id.GetString(), nonce.GetString(), result.GetString());
 }
 
-void StratumServer::api_update_local_stats(time_t timestamp)
+void StratumServer::api_update_local_stats(uint64_t timestamp)
 {
 	if (!m_pool->api() || !m_pool->params().m_localStats) {
 		return;
@@ -1028,8 +1038,9 @@ void StratumServer::api_update_local_stats(time_t timestamp)
 	const uint64_t hashrate_24h = (dt_24h > 0) ? (hashes_24h / dt_24h) : 0;
 
 	double average_effort = 0.0;
-	if (m_cumulativeFoundSharesDiff > 0.0) {
-		average_effort = static_cast<double>(m_cumulativeHashesAtLastShare) * 100.0 / m_cumulativeFoundSharesDiff;
+	const double diff = m_cumulativeFoundSharesDiff;
+	if (diff > 0.0) {
+		average_effort = static_cast<double>(m_cumulativeHashesAtLastShare) * 100.0 / diff;
 	}
 
 	int shares_found = m_totalFoundShares;

src/stratum_server.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -19,7 +19,6 @@
 
 #include "tcp_server.h"
 #include <rapidjson/document.h>
-#include <random>
 
 namespace p2pool {
 
@@ -53,7 +52,7 @@ public:
 		bool process_submit(rapidjson::Document& doc, uint32_t id);
 
 		uint32_t m_rpcId;
-		time_t m_connectedTime;
+		uint64_t m_connectedTime;
 
 		uv_mutex_t m_jobsLock;
 
@@ -75,6 +74,8 @@ public:
 
 	void print_status() override;
 
+	void reset_share_counters();
+
 private:
 	void print_stratum_status() const;
 
@@ -107,7 +108,6 @@ private:
 	std::atomic<uint32_t> m_extraNonce;
 
 	uv_mutex_t m_rngLock;
-	std::random_device m_rd;
 	std::mt19937_64 m_rng;
 
 	struct SubmittedShare
@@ -140,7 +140,7 @@ private:
 
 	struct HashrateData
 	{
-		time_t m_timestamp;
+		uint64_t m_timestamp;
 		uint64_t m_cumulativeHashes;
 	};
 
@@ -157,10 +157,10 @@ private:
 	double m_cumulativeFoundSharesDiff;
 	uint32_t m_totalFoundShares;
 
-	time_t m_apiLastUpdateTime;
+	uint64_t m_apiLastUpdateTime;
 
-	void update_hashrate_data(uint64_t hashes, time_t timestamp);
-	void api_update_local_stats(time_t timestamp);
+	void update_hashrate_data(uint64_t hashes, uint64_t timestamp);
+	void api_update_local_stats(uint64_t timestamp);
 };
 
 } // namespace p2pool

src/tcp_server.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -48,6 +48,7 @@ public:
 	virtual void on_connect_failed(bool is_v6, const raw_ip& ip, int port);
 
 	void ban(const raw_ip& ip, uint64_t seconds);
+	virtual void print_bans();
 
 	struct Client
 	{
@@ -95,9 +96,9 @@ public:
 
 	struct WriteBuf
 	{
-		Client* m_client;
-		uv_write_t m_write;
-		char m_data[WRITE_BUF_SIZE];
+		Client* m_client = nullptr;
+		uv_write_t m_write = {};
+		std::vector<uint8_t> m_data;
 	};
 
 	uv_mutex_t m_writeBuffersLock;
@@ -160,7 +161,7 @@ protected:
 	uint32_t m_numIncomingConnections;
 
 	uv_mutex_t m_bansLock;
-	unordered_map<raw_ip, time_t> m_bans;
+	unordered_map<raw_ip, std::chrono::steady_clock::time_point> m_bans;
 
 	bool is_banned(const raw_ip& ip);
 

src/tcp_server.inl

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -322,11 +322,13 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::on_connect_failed(bool, const raw
 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
 bool TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::is_banned(const raw_ip& ip)
 {
+	const auto cur_time = std::chrono::steady_clock::now();
+
 	MutexLock lock(m_bansLock);
 
 	auto it = m_bans.find(ip);
 	if (it != m_bans.end()) {
-		const bool banned = (time(nullptr) < it->second);
+		const bool banned = (cur_time < it->second);
 		if (!banned) {
 			m_bans.erase(it);
 		}
@@ -435,14 +437,14 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::shutdown_tcp()
 
 	using namespace std::chrono;
 
-	const system_clock::time_point start_time = system_clock::now();
+	const auto start_time = steady_clock::now();
 	int64_t counter = 0;
 	uv_async_t asy;
 
 	constexpr uint32_t timeout_seconds = 30;
 
 	while (!m_loopStopped) {
-		const int64_t elapsed_time = duration_cast<milliseconds>(system_clock::now() - start_time).count();
+		const int64_t elapsed_time = duration_cast<milliseconds>(steady_clock::now() - start_time).count();
 
 		if (elapsed_time >= (counter + 1) * 1000) {
 			++counter;
@@ -493,8 +495,34 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::print_status()
 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
 void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::ban(const raw_ip& ip, uint64_t seconds)
 {
+	const auto ban_time = std::chrono::steady_clock::now() + std::chrono::seconds(seconds);
+
 	MutexLock lock(m_bansLock);
-	m_bans[ip] = time(nullptr) + seconds;
+	m_bans[ip] = ban_time;
+}
+
+template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
+void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::print_bans()
+{
+	using namespace std::chrono;
+	const auto cur_time = steady_clock::now();
+
+	std::vector<std::pair<raw_ip, std::chrono::steady_clock::time_point>> bans;
+	{
+		MutexLock lock(m_bansLock);
+
+		bans.reserve(m_bans.size());
+		for (const auto& b : m_bans) {
+			bans.emplace_back(std::make_pair(b.first, b.second));
+		}
+	}
+
+	for (const auto& b : bans) {
+		if (cur_time < b.second) {
+			const uint64_t t = duration_cast<seconds>(b.second - cur_time).count();
+			LOGINFO(0, b.first << " is banned (" << t << " seconds left)");
+		}
+	}
 }
 
 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
@@ -520,10 +548,12 @@ bool TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::send_internal(Client* client, Sen
 		buf = new WriteBuf();
 	}
 
-	const size_t bytes_written = callback(buf->m_data);
+	// callback_buf is used in only 1 thread, so it's safe
+	static uint8_t callback_buf[WRITE_BUF_SIZE];
+	const size_t bytes_written = callback(callback_buf);
 
-	if (bytes_written > sizeof(buf->m_data)) {
-		LOGERR(0, "send callback wrote " << bytes_written << " bytes, expected no more than " << sizeof(buf->m_data) << " bytes");
+	if (bytes_written > WRITE_BUF_SIZE) {
+		LOGERR(0, "send callback wrote " << bytes_written << " bytes, expected no more than " << WRITE_BUF_SIZE << " bytes");
 		panic();
 	}
 
@@ -538,9 +568,11 @@ bool TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::send_internal(Client* client, Sen
 
 	buf->m_client = client;
 	buf->m_write.data = buf;
+	buf->m_data.reserve(round_up(bytes_written, 64));
+	buf->m_data.assign(callback_buf, callback_buf + bytes_written);
 
 	uv_buf_t bufs[1];
-	bufs[0].base = buf->m_data;
+	bufs[0].base = reinterpret_cast<char*>(buf->m_data.data());
 	bufs[0].len = static_cast<int>(bytes_written);
 
 	const int err = uv_write(&buf->m_write, reinterpret_cast<uv_stream_t*>(&client->m_socket), bufs, 1, Client::on_write);

src/util.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -32,7 +32,7 @@ namespace p2pool {
 #define STR2(X) STR(X)
 #define STR(X) #X
 
-const char* VERSION = "v1.7 (built"
+const char* VERSION = "v1.9 (built"
 #if defined(__clang__)
 	" with clang/" __clang_version__
 #elif defined(__GNUC__)
@@ -382,4 +382,6 @@ bool resolve_host(std::string& host, bool& is_v6)
 	return true;
 }
 
+RandomDeviceSeed RandomDeviceSeed::instance;
+
 } // namespace p2pool

src/util.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -145,6 +145,30 @@ using unordered_map = robin_hood::detail::Table<false, 80, Key, T, robin_hood::h
 template <typename Key>
 using unordered_set = robin_hood::detail::Table<false, 80, Key, void, robin_hood::hash<Key>, std::equal_to<Key>>;
 
+// Fills the whole initial MT19937-64 state with non-deterministic random numbers
+struct RandomDeviceSeed
+{
+	using result_type = std::random_device::result_type;
+	static_assert(sizeof(result_type) >= 4, "result_type must have at least 32 bits");
+
+	template<typename T>
+	static void generate(T begin, T end)
+	{
+		std::random_device rd;
+		for (T i = begin; i != end; ++i) {
+			*i = rd();
+		}
+	}
+
+	static RandomDeviceSeed instance;
+};
+
+FORCEINLINE uint64_t seconds_since_epoch()
+{
+	using namespace std::chrono;
+	return duration_cast<seconds>(steady_clock::now().time_since_epoch()).count();
+}
+
 } // namespace p2pool
 
 namespace robin_hood {

src/uv_util.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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

src/wallet.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  * Portions Copyright (c) 2012-2013 The Cryptonote developers
  * Portions Copyright (c) 2014-2021 The Monero Project
  * Portions Copyright (c) 2021 XMRig <https://github.com/xmrig>
@@ -79,7 +79,7 @@ static_assert(rev_alphabet.num_symbols == 58, "Check alphabet");
 
 namespace p2pool {
 
-Wallet::Wallet(const char* address)
+Wallet::Wallet(const char* address) : m_prefix(0), m_checksum(0), m_type(NetworkType::Invalid)
 {
 	decode(address);
 }

src/wallet.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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

src/zmq_reader.cpp

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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
@@ -19,7 +19,6 @@
 #include "zmq_reader.h"
 #include "json_parsers.h"
 #include <rapidjson/document.h>
-#include <random>
 
 static constexpr char log_category_prefix[] = "ZMQReader ";
 
@@ -160,10 +159,10 @@ bool ZMQReader::connect(const char* address)
 	m_subscriber.connect(address);
 
 	using namespace std::chrono;
-	system_clock::time_point start_time = system_clock::now();
+	steady_clock::time_point start_time = steady_clock::now();
 
 	while (!monitor.connected && monitor.check_event(-1)) {
-		const system_clock::time_point cur_time = system_clock::now();
+		const steady_clock::time_point cur_time = steady_clock::now();
 		const int64_t elapsed_time = duration_cast<milliseconds>(cur_time - start_time).count();
 		if (elapsed_time >= 3000) {
 			LOGERR(1, "failed to connect to " << address);
@@ -208,7 +207,7 @@ void ZMQReader::parse(char* data, size_t size)
 			return;
 		}
 
-		m_tx.time_received = time(nullptr);
+		m_tx.time_received = seconds_since_epoch();
 
 		for (SizeType i = 0, n = doc.Size(); i < n; ++i) {
 			const auto& v = doc[i];

src/zmq_reader.h

@@ -1,6 +1,6 @@
 /*
  * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
- * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2021-2022 SChernykh <https://github.com/SChernykh>
  *
  * 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

tests/CMakeLists.txt

@@ -1,6 +1,8 @@
 cmake_minimum_required(VERSION 2.8.12)
 project(p2pool_tests)
 
+option(STATIC_LIBS "Use locally built libuv and libzmq static libs" OFF)
+
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_CXX_STANDARD 14)
@@ -17,6 +19,7 @@ set(LIBS gtest)
 
 add_subdirectory(../external/src/RandomX RandomX)
 set(LIBS ${LIBS} randomx)
+add_definitions(-DWITH_RANDOMX)
 
 if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
 	set(WARNING_FLAGS "")
@@ -119,17 +122,28 @@ elseif (NOT APPLE)
 	set(LIBS ${LIBS} pthread gss dl)
 endif()
 
-if (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
-	find_library(ZMQ_LIBRARY_DEBUG NAMES libzmq-v142-mt-sgd-4_3_5 PATHS "../external/lib/libzmq/Debug")
-	find_library(ZMQ_LIBRARY NAMES libzmq-v142-mt-s-4_3_5 PATHS "../external/lib/libzmq/Release")
-	find_library(UV_LIBRARY_DEBUG NAMES uv_a PATHS "../external/lib/libuv/Debug")
-	find_library(UV_LIBRARY NAMES uv_a PATHS "../external/lib/libuv/Release")
-elseif (CMAKE_CXX_COMPILER_ID MATCHES GNU OR CMAKE_CXX_COMPILER_ID MATCHES Clang)
-	find_library(ZMQ_LIBRARY_DEBUG NAMES zmq libzmq.a)
-	find_library(ZMQ_LIBRARY NAMES zmq libzmq.a)
-	find_library(UV_LIBRARY_DEBUG NAMES uv libuv.a)
-	find_library(UV_LIBRARY NAMES uv libuv.a)
-	find_library(SODIUM_LIBRARY sodium)
+if (STATIC_LIBS)
+	set(ZMQ_LIBRARY "${CMAKE_SOURCE_DIR}/../external/src/libzmq/build/lib/libzmq.a")
+	set(ZMQ_LIBRARY_DEBUG "${CMAKE_SOURCE_DIR}/../external/src/libzmq/build/lib/libzmq.a")
+	set(UV_LIBRARY_DEBUG "${CMAKE_SOURCE_DIR}/../external/src/libuv/build/libuv_a.a")
+	set(UV_LIBRARY "${CMAKE_SOURCE_DIR}/../external/src/libuv/build/libuv_a.a")
+else()
+	if (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+		find_library(ZMQ_LIBRARY_DEBUG NAMES libzmq-v142-mt-sgd-4_3_5 PATHS "../external/lib/libzmq/Debug")
+		find_library(ZMQ_LIBRARY NAMES libzmq-v142-mt-s-4_3_5 PATHS "../external/lib/libzmq/Release")
+		find_library(UV_LIBRARY_DEBUG NAMES uv_a PATHS "../external/lib/libuv/Debug")
+		find_library(UV_LIBRARY NAMES uv_a PATHS "../external/lib/libuv/Release")
+	elseif (CMAKE_CXX_COMPILER_ID MATCHES GNU OR CMAKE_CXX_COMPILER_ID MATCHES Clang)
+		find_library(ZMQ_LIBRARY_DEBUG NAMES zmq libzmq.a)
+		find_library(ZMQ_LIBRARY NAMES zmq libzmq.a)
+		find_library(UV_LIBRARY_DEBUG NAMES uv libuv.a)
+		find_library(UV_LIBRARY NAMES uv libuv.a)
+		find_library(SODIUM_LIBRARY sodium)
+	endif()
+
+	if (SODIUM_LIBRARY)
+		set(LIBS ${LIBS} ${SODIUM_LIBRARY})
+	endif()
 endif()
 
 find_library(PGM_LIBRARY pgm)
@@ -143,10 +157,6 @@ if (NORM_LIBRARY)
 	set(LIBS ${LIBS} ${NORM_LIBRARY})
 endif()
 
-if (SODIUM_LIBRARY)
-	set(LIBS ${LIBS} ${SODIUM_LIBRARY})
-endif()
-
 add_definitions(/DZMQ_STATIC /DP2POOL_LOG_DISABLE)
 
 add_executable(${CMAKE_PROJECT_NAME} ${HEADERS} ${SOURCES})

tests/src/difficulty_type_tests.cpp

@@ -254,7 +254,7 @@ TEST(difficulty_type, check_pow)
 
 			// Max hash value that passes this difficulty
 			memcpy(h.h, data, HASH_SIZE);
-			EXPECT_EQ(diff.check_pow(h), true);
+			ASSERT_EQ(diff.check_pow(h), true);
 
 			// Add 1 to data (256-bit number)
 			for (int j = 0; j <= 3; ++j) {
@@ -267,7 +267,7 @@ TEST(difficulty_type, check_pow)
 
 			// Min hash value that fails this difficulty
 			memcpy(h.h, data, HASH_SIZE);
-			EXPECT_EQ(diff.check_pow(h), false);
+			ASSERT_EQ(diff.check_pow(h), false);
 		}
 
 		const uint64_t target = diff.target();
@@ -276,14 +276,14 @@ TEST(difficulty_type, check_pow)
 		for (int j = 0; j < 10000; ++j) {
 			const uint64_t data[4] = { r(), r(), r(), r() % target };
 			memcpy(h.h, data, HASH_SIZE);
-			EXPECT_EQ(diff.check_pow(h), true);
+			ASSERT_EQ(diff.check_pow(h), true);
 		}
 
 		// Random values that fail
 		for (int j = 0; j < 10000; ++j) {
 			const uint64_t data[4] = { r(), r(), r(), target + (r() % (std::numeric_limits<uint64_t>::max() - target + 1)) };
 			memcpy(h.h, data, HASH_SIZE);
-			EXPECT_EQ(diff.check_pow(h), false);
+			ASSERT_EQ(diff.check_pow(h), false);
 		}
 	}
 }

tests/src/main.cpp

@@ -17,6 +17,8 @@
 
 #include "gtest/gtest.h"
 
+void p2pool_usage() {}
+
 int main(int argc, char** argv)
 {
 	testing::InitGoogleTest(&argc, argv);