p2pool v2.1

Fixed a new cppcheck issue
CI: added Linux aarch64 build
2022-05-31 18:20:21 +02:00 · 2022-05-31 16:51:09 +02:00 · 2022-05-31 16:38:28 +02:00 · 2022-05-28 22:27:46 +02:00 · 2022-05-28 21:46:50 +02:00 · 2022-05-26 21:19:01 +02:00
81 changed files with 2172 additions and 868 deletions
@@ -53,6 +53,50 @@ jobs:
        name: p2pool-${{ matrix.config.os }}
        path: build/p2pool

+  build-ubuntu-aarch64:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Install dependencies
+      run: |
+        sudo apt update
+        sudo apt install -y git build-essential cmake gcc-aarch64-linux-gnu g++-aarch64-linux-gnu binutils-aarch64-linux-gnu
+
+    - name: Checkout repository
+      uses: actions/checkout@v2
+      with:
+        submodules: true
+
+    - name: Build libuv
+      run: |
+        cd external/src/libuv
+        mkdir build
+        cd build
+        cmake .. -DCMAKE_C_COMPILER=aarch64-linux-gnu-gcc -DCMAKE_CXX_COMPILER=aarch64-linux-gnu-g++
+        make -j$(nproc)
+
+    - name: Build libzmq
+      run: |
+        cd external/src/libzmq
+        mkdir build
+        cd build
+        cmake .. -DCMAKE_C_COMPILER=aarch64-linux-gnu-gcc -DCMAKE_CXX_COMPILER=aarch64-linux-gnu-g++ -DWITH_TLS=OFF -DWITH_LIBSODIUM=OFF -DWITH_LIBBSD=OFF -DBUILD_TESTS=OFF
+        make -j$(nproc)
+
+    - name: Build p2pool
+      run: |
+        mkdir build
+        cd build
+        cmake .. -DCMAKE_C_COMPILER=aarch64-linux-gnu-gcc -DCMAKE_CXX_COMPILER=aarch64-linux-gnu-g++ -DCMAKE_STRIP=/usr/bin/aarch64-linux-gnu-strip -DSTATIC_LIBS=ON -DARCH_ID=aarch64
+        make -j$(nproc)
+
+    - name: Archive binary
+      uses: actions/upload-artifact@v2
+      with:
+        name: p2pool-ubuntu-latest-aarch64
+        path: build/p2pool
+
  build-windows-msys2:

    runs-on: windows-latest
@@ -106,8 +150,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 +167,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 +186,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:
@@ -12,14 +12,22 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-    - name: Install cppcheck
-      run: sudo apt update && sudo apt install cppcheck
-
    - name: Checkout repository
      uses: actions/checkout@v2
      with:
        submodules: true

+    - name: Checkout cppcheck
+      uses: actions/checkout@v3
+      with:
+        repository: danmar/cppcheck
+        path: cppcheck-main
+
+    - name: Build cppcheck
+      run: |
+        cd cppcheck-main
+        make -j$(nproc) cppcheck
+
    - name: Run cppcheck
      run: |
        cd cppcheck
@@ -30,14 +38,22 @@ jobs:
    runs-on: windows-latest

    steps:
-    - name: Install cppcheck
-      run: choco install cppcheck
-
    - name: Checkout repository
      uses: actions/checkout@v2
      with:
        submodules: true

+    - name: Checkout cppcheck
+      uses: actions/checkout@v3
+      with:
+        repository: danmar/cppcheck
+        path: cppcheck-main
+
+    - name: Build cppcheck
+      run: |
+        cd cppcheck-main
+        & "C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\Msbuild\\Current\\Bin\\amd64\\msbuild.exe" /m /p:Configuration=Release /p:Platform=x64
+
    - name: Setup cmake
      uses: lukka/get-cmake@latest

@@ -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
@@ -2,15 +2,20 @@ cmake_minimum_required(VERSION 2.8.12)
 project(p2pool)

 option(STATIC_BINARY "Build static binary" OFF)
+option(STATIC_LIBS "Link libuv and libzmq statically" 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")

-if (${CMAKE_VERSION} VERSION_GREATER "3.5.2") 
+if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.6.0") 
 	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 +32,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 +65,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 +78,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,14 +90,18 @@ 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)

 if (WIN32)
 	set(LIBS ${LIBS} ws2_32 iphlpapi userenv psapi)
+elseif (CMAKE_SYSTEM_NAME STREQUAL FreeBSD)
+	set(LIBS ${LIBS} pthread)
 elseif (NOT APPLE)
-	set(LIBS ${LIBS} pthread gss dl)
+	set(LIBS ${LIBS} pthread dl)
 endif()

 if (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
@@ -122,13 +134,40 @@ endif()

 add_definitions(/DZMQ_STATIC)

+include(CheckSymbolExists)
+
+set(CMAKE_REQUIRED_FLAGS "${GENERAL_FLAGS}")
+check_symbol_exists(pthread_cancel pthread.h HAVE_PTHREAD_CANCEL)
+
+if (HAVE_PTHREAD_CANCEL)
+	add_definitions(/DHAVE_PTHREAD_CANCEL)
+endif()
+
+include(CheckCXXSourceCompiles)
+
+check_cxx_source_compiles("int main(){ return __builtin_clzll(1);}" HAVE_BUILTIN_CLZLL)
+check_cxx_source_compiles("#include <intrin.h>\n#pragma intrinsic(_BitScanReverse64)\nint main(){unsigned long r;_BitScanReverse64(&r,1);return r;}" HAVE_BITSCANREVERSE64)
+
+if (HAVE_BUILTIN_CLZLL)
+	add_definitions(/DHAVE_BUILTIN_CLZLL)
+endif()
+
+if (HAVE_BITSCANREVERSE64)
+	add_definitions(/DHAVE_BITSCANREVERSE64)
+endif()
+
 add_executable(${CMAKE_PROJECT_NAME} ${HEADERS} ${SOURCES})

-if (STATIC_BINARY)
+if (STATIC_BINARY OR STATIC_LIBS)
 	add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_STRIP} ${CMAKE_PROJECT_NAME})

-	set(STATIC_LIBS randomx)
-	if (NOT APPLE)
+	if (WITH_RANDOMX)
+		set(STATIC_LIBS randomx)
+	endif()
+
+	if (CMAKE_SYSTEM_NAME STREQUAL FreeBSD)
+		set(STATIC_LIBS ${STATIC_LIBS} pthread)
+	elseif (NOT APPLE)
 		set(STATIC_LIBS ${STATIC_LIBS} pthread dl)
 	endif()

@@ -2,14 +2,14 @@

 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

-![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)  
-![msvc-analysis](https://github.com/SChernykh/p2pool/actions/workflows/msvc-analysis.yml/badge.svg)  
-![cppcheck](https://github.com/SChernykh/p2pool/actions/workflows/cppcheck.yml/badge.svg)  
+![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)
+![msvc-analysis](https://github.com/SChernykh/p2pool/actions/workflows/msvc-analysis.yml/badge.svg)
+![cppcheck](https://github.com/SChernykh/p2pool/actions/workflows/cppcheck.yml/badge.svg)
 <a href="https://scan.coverity.com/projects/schernykh-p2pool">
  <img alt="Coverity Scan Build Status"
       src="https://scan.coverity.com/projects/23659/badge.svg"/>
@@ -19,6 +19,7 @@ Pool status and monitoring pages can be found at https://p2pool.io/ and https://
 - [Features](#features)
 - [How PPLNS works in P2Pool](#how-pplns-works-in-p2pool)
 - [Default P2Pool parameters](#default-p2pool-parameters)
+- [Monero version support](#monero-version-support)
 - [How to mine on P2Pool](#how-to-mine-on-p2pool)
  - [General Considerations](#general-considerations)
  - [GNU/Linux](#gnulinux)
@@ -63,12 +64,21 @@ First you need to find a pool share. This share will stay in PPLNS window for 21
 * PPLNS window: 2160 blocks (6 hours)
 * Minimum payout = Monero block reward/2160, ~0.0003 XMR

+## Monero version support
+
+Monero will undergo a network upgrade on July 16th, 2022 (block 2,668,888). In order to continue mining after that date, you must update both Monero and P2Pool software to the latest available versions as soon as they are released.
+
+|Monero protocol version|Required Monero software version|Required P2Pool version
+|-|-|-|
+|v14 (active until July 16th, 2022)|v0.17.3.0 or newer|v1.0 or newer
+|v15, v16  (active after July 16th, 2022)|v0.18.0.0 or newer|v2.0 or newer
+
 ## How to mine on P2Pool

 ### General Considerations

 - 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. 
+- It is highly recommended that you create a separate restricted user account for mining. While P2Pool has been battle-tested for a long time now, any software may have unknown 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.
@@ -188,7 +198,7 @@ Please see the relevant instructions for your platform:

 ### Ubuntu 20.04

-Run the following commands to install the necessary prerequisites, clone this repo, and build P2Pool locally on Ubuntu 20.04:  
+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
@@ -239,7 +249,7 @@ Alternatively, you can select "Clone a repository" within the GUI, then select "

 ### macOS

-Run the following commands to install the necessary prerequisites, clone this repo, and build P2Pool locally on your Mac:  
+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
@@ -249,6 +259,30 @@ cmake ..
 make -j$(sysctl -n hw.logicalcpu)
 ```

+### FreeBSD
+
+Run the following commands to install the necessary prerequisites, clone this repo, and build P2Pool locally on FreeBSD:
+```
+pkg install git cmake libuv libzmq4
+git clone --recursive https://github.com/SChernykh/p2pool
+cd p2pool
+mkdir build && cd build
+cmake ..
+make
+```
+
+### Android (Termux)
+
+Run the following commands to install the necessary prerequisites, clone this repo, and build P2Pool locally in Termux:
+```
+pkg install git build-essential cmake libuv libzmq
+git clone --recursive https://github.com/SChernykh/p2pool
+cd p2pool
+mkdir build && cd build
+cmake ..
+make -j$(nproc)
+```
+
 ## Donations

 If you'd like to support further development of Monero P2Pool, you're welcome to send any amount of XMR to the following address:
@@ -6,14 +6,15 @@ set(CMAKE_C_STANDARD 99)
 set(CMAKE_C_STANDARD_REQUIRED ON)

 if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
+	set(GENERAL_FLAGS "-pthread")
 	set(WARNING_FLAGS "-Wall -Wextra -Werror")
 	set(OPTIMIZATION_FLAGS "-Ofast -s")

-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
-	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")

-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
-	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")

 	if (WIN32)
 		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")
@@ -25,26 +26,28 @@ if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
 		endif()
 	endif()
 elseif (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+	set(GENERAL_FLAGS "")
 	set(WARNING_FLAGS "/Wall /WX /sdl")
 	set(SECURITY_FLAGS "/GS /guard:cf")
 	set(OPTIMIZATION_FLAGS "/O2 /Oi /Ob2 /Ot /DNDEBUG /GL")

-	set(CMAKE_C_FLAGS_DEBUG "${WARNING_FLAGS} ${SECURITY_FLAGS} /Od /Ob0 /Zi /MTd /fsanitize=address")
-	set(CMAKE_CXX_FLAGS_DEBUG "${WARNING_FLAGS} ${SECURITY_FLAGS} /Od /Ob0 /Zi /MTd /fsanitize=address")
+	set(CMAKE_C_FLAGS_DEBUG "${GENERAL_FLAGS} ${WARNING_FLAGS} ${SECURITY_FLAGS} /Od /Ob0 /Zi /MTd /fsanitize=address")
+	set(CMAKE_CXX_FLAGS_DEBUG "${GENERAL_FLAGS} ${WARNING_FLAGS} ${SECURITY_FLAGS} /Od /Ob0 /Zi /MTd /fsanitize=address")

-	set(CMAKE_C_FLAGS_RELEASE "${WARNING_FLAGS} ${SECURITY_FLAGS} ${OPTIMIZATION_FLAGS} /MT")
-	set(CMAKE_CXX_FLAGS_RELEASE "${WARNING_FLAGS} ${SECURITY_FLAGS} ${OPTIMIZATION_FLAGS} /MT")
+	set(CMAKE_C_FLAGS_RELEASE "${GENERAL_FLAGS} ${WARNING_FLAGS} ${SECURITY_FLAGS} ${OPTIMIZATION_FLAGS} /MT")
+	set(CMAKE_CXX_FLAGS_RELEASE "${GENERAL_FLAGS} ${WARNING_FLAGS} ${SECURITY_FLAGS} ${OPTIMIZATION_FLAGS} /MT")

-	set(CMAKE_C_FLAGS_RELWITHDEBINFO "${WARNING_FLAGS} ${SECURITY_FLAGS} /Ob1 /Ot /Zi /MT")
-	set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${WARNING_FLAGS} ${SECURITY_FLAGS} /Ob1 /Ot /Zi /MT")
+	set(CMAKE_C_FLAGS_RELWITHDEBINFO "${GENERAL_FLAGS} ${WARNING_FLAGS} ${SECURITY_FLAGS} /Ob1 /Ot /Zi /MT")
+	set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${GENERAL_FLAGS} ${WARNING_FLAGS} ${SECURITY_FLAGS} /Ob1 /Ot /Zi /MT")

 elseif (CMAKE_CXX_COMPILER_ID MATCHES Clang)
+	set(GENERAL_FLAGS "-pthread")
 	set(WARNING_FLAGS "-Wall -Wextra -Wno-undefined-internal -Werror")
 	set(OPTIMIZATION_FLAGS "-Ofast -funroll-loops -fmerge-all-constants")

-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
-	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")

-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
-	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
 endif()
@@ -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,
@@ -1,9 +1,9 @@
 ../src/
 ../external/src/
 ../external/src/cryptonote/
-../external/src/libuv/
+../external/src/libuv/include/
 ../external/src/cppzmq/
-../external/src/libzmq/
+../external/src/libzmq/include/
 ../external/src/llhttp/
 ../external/src/RandomX/src/
 ../external/src/rapidjson/include
@@ -1,5 +1,5 @@
@echo off
-"C:\Program Files\cppcheck\cppcheck.exe" --project=..\build\p2pool.vcxproj --project-configuration="Release|x64" -DZMQ_STATIC --platform=win64 --std=c++14 --enable=all --inconclusive --inline-suppr --template="{file}:{line}:{id}{inconclusive: INCONCLUSIVE} {message}" --includes-file=includes.txt --suppressions-list=suppressions.txt --output-file=errors_full.txt
+"..\cppcheck-main\bin\cppcheck.exe" --project=..\build\p2pool.vcxproj --project-configuration="Release|x64" -DSIZE_MAX=UINT64_MAX -DRAPIDJSON_ENDIAN=RAPIDJSON_LITTLEENDIAN --platform=win64 --std=c++14 --enable=all --inconclusive --inline-suppr --template="{file}:{line}:{id}{inconclusive: INCONCLUSIVE} {message}" --includes-file=includes.txt --suppressions-list=suppressions.txt --output-file=errors_full.txt
 findstr /V /C:"external\src" errors_full.txt > errors_filtered.txt
 for /f %%i in ("errors_filtered.txt") do set size=%%~zi
 if %size% gtr 0 (
@@ -1,6 +1,6 @@
 #!/bin/bash
-cppcheck ../src -DZMQ_STATIC --platform=unix64 --std=c++14 --enable=all --inconclusive --inline-suppr --template="{file}:{line}:{id}{inconclusive: INCONCLUSIVE} {message}" -I ../src/ -I ../external/src/ -I ../external/src/cryptonote/ -I ../external/src/libuv/ -I ../external/src/cppzmq/ -I ../external/src/libzmq/ -I ../external/src/llhttp/ -I ../external/src/RandomX/src/ -I ../external/src/rapidjson/include -I ../external/src/robin-hood-hashing/src/include --suppressions-list=suppressions.txt --output-file=errors_full.txt
-grep -v 'external' errors_full.txt | grep -v 'unmatchedSuppression' > errors_filtered.txt
+../cppcheck-main/cppcheck ../src -DSIZE_MAX=UINT64_MAX -DRAPIDJSON_ENDIAN=RAPIDJSON_LITTLEENDIAN --platform=unix64 --std=c++14 --enable=all --inconclusive --inline-suppr --template="{file}:{line}:{id}{inconclusive: INCONCLUSIVE} {message}" --includes-file=includes.txt --suppressions-list=suppressions.txt --output-file=errors_full.txt
+grep -v 'external' errors_full.txt > errors_filtered.txt
 if [ -s errors_filtered.txt ]; then
 	cat errors_filtered.txt
 	exit 1
@@ -1,6 +1,3 @@
 missingIncludeSystem
 unusedFunction
 useStlAlgorithm
-functionStatic
-functionConst
-unmatchedSuppression
@@ -3831,15 +3831,51 @@ int sc_isnonzero(const unsigned char *s) {
    s[27] | s[28] | s[29] | s[30] | s[31]) - 1) >> 8) + 1;
 }

-int ge_p3_is_point_at_infinity(const ge_p3 *p) {
-  // X = 0 and Y == Z
-  int n;
-  for (n = 0; n < 10; ++n)
+int ge_p3_is_point_at_infinity_vartime(const ge_p3 *p) {
+  // https://eprint.iacr.org/2008/522
+  // X == T == 0 and Y/Z == 1
+  // note: convert all pieces to canonical bytes in case rounding is required (i.e. an element is > q)
+  // note2: even though T = XY/Z is true for valid point representations (implying it isn't necessary to
+  //        test T == 0), the input to this function might NOT be valid, so we must test T == 0
+  char result_X_bytes[32];
+  fe_tobytes((unsigned char*)&result_X_bytes, p->X);
+
+  // X != 0
+  for (int i = 0; i < 32; ++i)
  {
-    if (p->X[n] | p->T[n])
-      return 0;
-    if (p->Y[n] != p->Z[n])
+    if (result_X_bytes[i])
      return 0;
  }
-  return 1;
+
+  char result_T_bytes[32];
+  fe_tobytes((unsigned char*)&result_T_bytes, p->T);
+
+  // T != 0
+  for (int i = 0; i < 32; ++i)
+  {
+    if (result_T_bytes[i])
+      return 0;
+  }
+
+  char result_Y_bytes[32];
+  char result_Z_bytes[32];
+  fe_tobytes((unsigned char*)&result_Y_bytes, p->Y);
+  fe_tobytes((unsigned char*)&result_Z_bytes, p->Z);
+
+  // Y != Z
+  for (int i = 0; i < 32; ++i)
+  {
+    if (result_Y_bytes[i] != result_Z_bytes[i])
+      return 0;
+  }
+
+  // is Y nonzero? then Y/Z == 1
+  for (int i = 0; i < 32; ++i)
+  {
+    if (result_Y_bytes[i] != 0)
+      return 1;
+  }
+
+  // Y/Z = 0/0
+  return 0;
 }
@@ -162,4 +162,4 @@ void fe_add(fe h, const fe f, const fe g);
 void fe_tobytes(unsigned char *, const fe);
 void fe_invert(fe out, const fe z);

-int ge_p3_is_point_at_infinity(const ge_p3 *p);
+int ge_p3_is_point_at_infinity_vartime(const ge_p3 *p);
@@ -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);
@@ -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
@@ -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>
@@ -115,7 +115,7 @@ BlockTemplate& BlockTemplate::operator=(const BlockTemplate& b)
 	m_extraNonceOffsetInTemplate = b.m_extraNonceOffsetInTemplate;
 	m_numTransactionHashes = b.m_numTransactionHashes;
 	m_prevId = b.m_prevId;
-	m_height = b.m_height;
+	m_height = b.m_height.load();
 	m_difficulty = b.m_difficulty;
 	m_seedHash = b.m_seedHash;
 	m_timestamp = b.m_timestamp;
@@ -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;
 	}

@@ -516,7 +575,6 @@ void BlockTemplate::update(const MinerData& data, const Mempool& mempool, Wallet
 	m_rewards.clear();
 	m_mempoolTxs.clear();
 	m_mempoolTxsOrder.clear();
-	m_shares.clear();
 }

 #if TEST_MEMPOOL_PICKING_ALGORITHM
@@ -600,7 +658,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();
@@ -630,6 +688,8 @@ bool BlockTemplate::create_miner_tx(const MinerData& data, const std::vector<Min
 	m_poolBlockTemplate->m_outputs.clear();
 	m_poolBlockTemplate->m_outputs.reserve(num_outputs);

+	const uint8_t tx_type = m_poolBlockTemplate->get_tx_type();
+
 	uint64_t reward_amounts_weight = 0;
 	for (size_t i = 0; i < num_outputs; ++i) {
 		writeVarint(m_rewards[i], [this, &reward_amounts_weight](uint8_t b)
@@ -637,30 +697,36 @@ bool BlockTemplate::create_miner_tx(const MinerData& data, const std::vector<Min
 				m_minerTx.push_back(b);
 				++reward_amounts_weight;
 			});
-		m_minerTx.push_back(TXOUT_TO_KEY);
+		m_minerTx.push_back(tx_type);
+
+		uint8_t view_tag = 0;

 		if (dry_run) {
 			m_minerTx.insert(m_minerTx.end(), HASH_SIZE, 0);
 		}
 		else {
 			hash eph_public_key;
-			if (!shares[i].m_wallet->get_eph_public_key(m_txkeySec, i, eph_public_key)) {
+			if (!shares[i].m_wallet->get_eph_public_key(m_txkeySec, i, eph_public_key, view_tag)) {
 				LOGERR(1, "get_eph_public_key failed at index " << i);
 			}
 			m_minerTx.insert(m_minerTx.end(), eph_public_key.h, eph_public_key.h + HASH_SIZE);
-			m_poolBlockTemplate->m_outputs.emplace_back(m_rewards[i], eph_public_key);
+			m_poolBlockTemplate->m_outputs.emplace_back(m_rewards[i], eph_public_key, tx_type, view_tag);
+		}
+
+		if (tx_type == TXOUT_TO_TAGGED_KEY) {
+			m_minerTx.emplace_back(view_tag);
 		}
 	}

 	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 +742,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 +771,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
@@ -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,18 +50,17 @@ public:
 	void update_tx_keys();

 	FORCEINLINE uint64_t height() const { return m_height; }
-	FORCEINLINE time_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);

-	FORCEINLINE uint64_t final_reward() const { return m_finalReward; }
+	FORCEINLINE const std::vector<MinerShare>& shares() const { return m_shares; }

 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();
@@ -83,7 +82,7 @@ private:

 	size_t m_numTransactionHashes;
 	hash m_prevId;
-	uint64_t m_height;
+	std::atomic<uint64_t> m_height;
 	difficulty_type m_difficulty;
 	hash m_seedHash;

@@ -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,22 +19,25 @@

 #ifdef _MSC_VER

-#pragma warning(disable : 4005 4061 4365 4464 4625 4626 4668 4710 4711 4804 4820 5039 5045 5220)
+#pragma warning(disable : 4005 4061 4365 4464 4625 4626 4668 4710 4711 4804 4820 5039 5045 5220 5246)
 #define FORCEINLINE __forceinline
 #define NOINLINE __declspec(noinline)
 #define LIKELY(expression) expression
+#define MSVC_PRAGMA(...) __pragma(__VA_ARGS__)

 #elif __GNUC__

 #define FORCEINLINE __attribute__((always_inline)) inline
 #define NOINLINE __attribute__((noinline))
 #define LIKELY(expression) __builtin_expect(expression, 1)
+#define MSVC_PRAGMA(...)

 #else

 #define FORCEINLINE inline
 #define NOINLINE
 #define LIKELY(expression) expression
+#define MSVC_PRAGMA(...)

 #endif

@@ -54,6 +57,7 @@
 #include <atomic>
 #include <chrono>
 #include <iostream>
+#include <random>

 #include <signal.h>

@@ -80,13 +84,16 @@
 namespace p2pool {

 constexpr size_t HASH_SIZE = 32;
-constexpr uint8_t HARDFORK_SUPPORTED_VERSION = 14;
+constexpr uint8_t HARDFORK_VIEW_TAGS_VERSION = 15;
+constexpr uint8_t HARDFORK_SUPPORTED_VERSION = 16;
 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;
+constexpr uint8_t TXOUT_TO_TAGGED_KEY = 3;
 constexpr uint8_t TX_EXTRA_TAG_PUBKEY = 1;
 constexpr uint8_t TX_EXTRA_NONCE = 2;
 constexpr uint8_t TX_EXTRA_MERGE_MINING_TAG = 3;
@@ -194,11 +201,16 @@ struct difficulty_type
 	FORCEINLINE bool operator==(const difficulty_type& other) const { return (lo == other.lo) && (hi == other.hi); }
 	FORCEINLINE bool operator!=(const difficulty_type& other) const { return (lo != other.lo) || (hi != other.hi); }

+	FORCEINLINE bool operator==(uint64_t other) const { return (lo == other) && (hi == 0); }
+	FORCEINLINE bool operator!=(uint64_t other) const { return (lo != other) || (hi != 0); }
+
 	friend std::ostream& operator<<(std::ostream& s, const difficulty_type& d);
 	friend std::istream& operator>>(std::istream& s, difficulty_type& d);

 	FORCEINLINE double to_double() const { return static_cast<double>(hi) * 18446744073709551616.0 + static_cast<double>(lo); }

+	FORCEINLINE bool empty() const { return (lo == 0) && (hi == 0); }
+
 	// Finds a 64-bit target for mining (target = 2^64 / difficulty) and rounds up the result of division
 	// Because of that, there's a very small chance that miners will find a hash that meets the target but is still wrong (hash * difficulty >= 2^256)
 	// A proper difficulty check is in check_pow()
@@ -234,7 +246,7 @@ struct TxMempoolData
 	uint64_t blob_size;
 	uint64_t weight;
 	uint64_t fee;
-	time_t time_received;
+	uint64_t time_received;
 };

 struct MinerData
@@ -260,7 +272,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
@@ -305,6 +317,14 @@ struct raw_ip
 	}

 	FORCEINLINE bool operator!=(const raw_ip& other) const { return !operator==(other); }
+
+	FORCEINLINE bool is_localhost() const
+	{
+		static constexpr raw_ip localhost_ipv4 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x01 };
+		static constexpr raw_ip localhost_ipv6 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 };
+
+		return (*this == localhost_ipv4) || (*this == localhost_ipv6);
+	}
 };

 static_assert(sizeof(raw_ip) == 16, "struct raw_ip has invalid size");
@@ -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,10 +21,16 @@
 #include "p2pool.h"
 #include "stratum_server.h"
 #include "p2p_server.h"
+#ifdef WITH_RANDOMX
 #include "miner.h"
+#endif
 #include "side_chain.h"
 #include <iostream>

+#ifdef HAVE_PTHREAD_CANCEL
+#include <pthread.h>
+#endif
+
 static constexpr char log_category_prefix[] = "ConsoleCommands ";

 namespace p2pool {
@@ -43,7 +49,7 @@ ConsoleCommands::~ConsoleCommands()

 #ifdef _WIN32
 	TerminateThread(reinterpret_cast<HANDLE>(m_worker->native_handle()), 0);
-#else
+#elif defined HAVE_PTHREAD_CANCEL
 	pthread_cancel(m_worker->native_handle());
 #endif

@@ -70,7 +76,11 @@ typedef struct cmd {
 	cmdfunc *func;
 } cmd;

-static cmdfunc do_help, do_status, do_loglevel, do_addpeers, do_droppeers, do_showpeers, do_showbans, 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_showworkers, 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,11 +89,14 @@ 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("workers"), "", "show all connected workers", do_showworkers },
 	{ 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 }
 };
@@ -106,9 +119,9 @@ static int do_status(p2pool *m_pool, const char * /* args */)
 	if (m_pool->p2p_server()) {
 		m_pool->p2p_server()->print_status();
 	}
-	if (m_pool->miner()) {
-		m_pool->miner()->print_status();
-	}
+#ifdef WITH_RANDOMX
+	m_pool->print_miner_status();
+#endif
 	bkg_jobs_tracker.print_status();
 	return 0;
 }
@@ -146,6 +159,14 @@ static int do_showpeers(p2pool* m_pool, const char* /* args */)
 	return 0;
 }

+static int do_showworkers(p2pool* m_pool, const char* /* args */)
+{
+	if (m_pool->stratum_server()) {
+		m_pool->stratum_server()->show_workers();
+	}
+	return 0;
+}
+
 static int do_showbans(p2pool* m_pool, const char* /* args */)
 {
 	if (m_pool->stratum_server()) {
@@ -175,6 +196,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);
@@ -188,6 +210,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 */)
 {
@@ -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
@@ -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;
 };
@@ -126,9 +109,9 @@ bool check_keys(const hash& pub, const hash& sec)
 	return pub == pub_check;
 }

-static FORCEINLINE void hash_to_scalar(const uint8_t* data, size_t length, uint8_t(&res)[HASH_SIZE])
+static FORCEINLINE void hash_to_scalar(const uint8_t* data, int length, uint8_t (&res)[HASH_SIZE])
 {
-	keccak(data, static_cast<int>(length), res, HASH_SIZE);
+	keccak(data, length, res, HASH_SIZE);
 	sc_reduce32(res);
 }

@@ -139,18 +122,13 @@ static FORCEINLINE void derivation_to_scalar(const hash& derivation, size_t outp
 		uint8_t output_index[(sizeof(size_t) * 8 + 6) / 7];
 	} buf;

-	uint8_t* begin = buf.derivation;
-	uint8_t* end = buf.output_index;
 	memcpy(buf.derivation, derivation.h, sizeof(buf.derivation));

-	size_t k = output_index;
-	while (k >= 0x80) {
-		*(end++) = (static_cast<uint8_t>(k) & 0x7F) | 0x80;
-		k >>= 7;
-	}
-	*(end++) = static_cast<uint8_t>(k);
+	uint8_t* p = buf.output_index;
+	writeVarint(output_index, [&p](uint8_t b) { *(p++) = b; });

-	hash_to_scalar(begin, end - begin, res);
+	const uint8_t* data = buf.derivation;
+	hash_to_scalar(data, static_cast<int>(p - data), res);
 }

 class Cache
@@ -166,17 +144,19 @@ public:
 		uv_mutex_destroy(&m);
 	}

-	bool get_derivation(const hash& key1, const hash& key2, hash& derivation)
+	bool get_derivation(const hash& key1, const hash& key2, size_t output_index, hash& derivation, uint8_t& view_tag)
 	{
-		std::array<uint8_t, HASH_SIZE * 2> index;
+		std::array<uint8_t, HASH_SIZE * 2 + sizeof(size_t)> index;
 		memcpy(index.data(), key1.h, HASH_SIZE);
 		memcpy(index.data() + HASH_SIZE, key2.h, HASH_SIZE);
+		memcpy(index.data() + HASH_SIZE * 2, &output_index, sizeof(size_t));

 		{
 			MutexLock lock(m);
 			auto it = derivations.find(index);
 			if (it != derivations.end()) {
-				derivation = it->second;
+				derivation = it->second.derivation;
+				view_tag = it->second.view_tag;
 				return true;
 			}
 		}
@@ -194,9 +174,11 @@ public:
 		ge_p1p1_to_p2(&point2, &point3);
 		ge_tobytes(reinterpret_cast<uint8_t*>(&derivation), &point2);

+		derive_view_tag(derivation, output_index, view_tag);
+
 		{
 			MutexLock lock(m);
-			derivations.emplace(index, derivation);
+			derivations.emplace(index, DerivationEntry{ derivation, view_tag } );
 		}

 		return true;
@@ -253,16 +235,23 @@ public:
 	}

 private:
+	struct DerivationEntry
+	{
+		hash derivation;
+		// cppcheck-suppress unusedStructMember
+		uint8_t view_tag;
+	};
+
 	uv_mutex_t m;
-	unordered_map<std::array<uint8_t, HASH_SIZE * 2>, hash> derivations;
+	unordered_map<std::array<uint8_t, HASH_SIZE * 2 + sizeof(size_t)>, DerivationEntry> derivations;
 	unordered_map<std::array<uint8_t, HASH_SIZE * 2 + sizeof(size_t)>, hash> public_keys;
 };

 static Cache* cache = nullptr;

-bool generate_key_derivation(const hash& key1, const hash& key2, hash& derivation)
+bool generate_key_derivation(const hash& key1, const hash& key2, size_t output_index, hash& derivation, uint8_t& view_tag)
 {
-	return cache->get_derivation(key1, key2, derivation);
+	return cache->get_derivation(key1, key2, output_index, derivation, view_tag);
 }

 bool derive_public_key(const hash& derivation, size_t output_index, const hash& base, hash& derived_key)
@@ -270,6 +259,22 @@ bool derive_public_key(const hash& derivation, size_t output_index, const hash&
 	return cache->get_public_key(derivation, output_index, base, derived_key);
 }

+void derive_view_tag(const hash& derivation, size_t output_index, uint8_t& view_tag)
+{
+	constexpr uint8_t salt[] = "view_tag";
+	constexpr size_t SALT_SIZE = sizeof(salt) - 1;
+
+	uint8_t buf[64];
+	memcpy(buf, salt, SALT_SIZE);
+	memcpy(buf + SALT_SIZE, derivation.h, HASH_SIZE);
+	uint8_t* p = buf + SALT_SIZE + HASH_SIZE;
+	writeVarint(output_index, [&p](uint8_t b) { *(p++) = b; });
+
+	hash view_tag_full;
+	keccak(buf, static_cast<int>(p - buf), view_tag_full.h, HASH_SIZE);
+	view_tag = view_tag_full.h[0];
+}
+
 void init_crypto_cache()
 {
 	if (!cache) {
@@ -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,8 +21,9 @@ namespace p2pool {

 void generate_keys(hash& pub, hash& sec);
 bool check_keys(const hash& pub, const hash& sec);
-bool generate_key_derivation(const hash& key1, const hash& key2, hash& derivation);
+bool generate_key_derivation(const hash& key1, const hash& key2, size_t output_index, hash& derivation, uint8_t& view_tag);
 bool derive_public_key(const hash& derivation, size_t output_index, const hash& base, hash& derived_key);
+void derive_view_tag(const hash& derivation, size_t output_index, uint8_t& view_tag);

 void init_crypto_cache();
 void destroy_crypto_cache();
@@ -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
@@ -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
@@ -72,7 +72,7 @@ JSONRPCRequest::JSONRPCRequest(const char* address, int port, const char* req, C
 	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());
+	log::Stream s(m_request.data(), m_request.size());
 	s << "POST " << uri << " HTTP/1.1\nContent-Type: application/json\nContent-Length: " << len << "\n\n";

 	m_request.resize(s.m_pos);
@@ -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
@@ -71,6 +71,7 @@ private:
 	static void on_alloc(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf);
 	static void on_read(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf);
 	void on_read(const char* data, size_t size);
+	// cppcheck-suppress functionConst
 	void close();
 	static void on_close(uv_handle_t* handle);

@@ -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,23 @@ 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 THETA(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; \
 		}

+		THETA(0);
+		THETA(1);
+		THETA(2);
+		THETA(3);
+		THETA(4);
+
 		// 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);
@@ -85,60 +91,25 @@ NOINLINE void keccakf(uint64_t* st)
 		st[10] = ROTL64(t, 1);

 		//  Chi
-		// unrolled loop, where only last iteration is different
-		int j = 0;
-		bc[0] = st[j + 0];
-		bc[1] = st[j + 1];
+#define CHI(j) { \
+			const uint64_t st0 = st[j    ]; \
+			const uint64_t st1 = st[j + 1]; \
+			const uint64_t st2 = st[j + 2]; \
+			const uint64_t st3 = st[j + 3]; \
+			const uint64_t st4 = st[j + 4]; \
+			st[j    ] ^= ~st1 & st2; \
+			st[j + 1] ^= ~st2 & st3; \
+			st[j + 2] ^= ~st3 & st4; \
+			st[j + 3] ^= ~st4 & st0; \
+			st[j + 4] ^= ~st0 & st1; \
+		}

-		st[j + 0] ^= (~st[j + 1]) & st[j + 2];
-		st[j + 1] ^= (~st[j + 2]) & st[j + 3];
-		st[j + 2] ^= (~st[j + 3]) & st[j + 4];
-		st[j + 3] ^= (~st[j + 4]) & bc[0];
-		st[j + 4] ^= (~bc[0]) & bc[1];
+		CHI( 0);
+		CHI( 5);
+		CHI(10);
+		CHI(15);
+		CHI(20);

-		j = 5;
-		bc[0] = st[j + 0];
-		bc[1] = st[j + 1];
-
-		st[j + 0] ^= (~st[j + 1]) & st[j + 2];
-		st[j + 1] ^= (~st[j + 2]) & st[j + 3];
-		st[j + 2] ^= (~st[j + 3]) & st[j + 4];
-		st[j + 3] ^= (~st[j + 4]) & bc[0];
-		st[j + 4] ^= (~bc[0]) & bc[1];
-
-		j = 10;
-		bc[0] = st[j + 0];
-		bc[1] = st[j + 1];
-
-		st[j + 0] ^= (~st[j + 1]) & st[j + 2];
-		st[j + 1] ^= (~st[j + 2]) & st[j + 3];
-		st[j + 2] ^= (~st[j + 3]) & st[j + 4];
-		st[j + 3] ^= (~st[j + 4]) & bc[0];
-		st[j + 4] ^= (~bc[0]) & bc[1];
-
-		j = 15;
-		bc[0] = st[j + 0];
-		bc[1] = st[j + 1];
-
-		st[j + 0] ^= (~st[j + 1]) & st[j + 2];
-		st[j + 1] ^= (~st[j + 2]) & st[j + 3];
-		st[j + 2] ^= (~st[j + 3]) & st[j + 4];
-		st[j + 3] ^= (~st[j + 4]) & bc[0];
-		st[j + 4] ^= (~bc[0]) & bc[1];
-
-		j = 20;
-		bc[0] = st[j + 0];
-		bc[1] = st[j + 1];
-		bc[2] = st[j + 2];
-		bc[3] = st[j + 3];
-		bc[4] = st[j + 4];
-
-		st[j + 0] ^= (~bc[1]) & bc[2];
-		st[j + 1] ^= (~bc[2]) & bc[3];
-		st[j + 2] ^= (~bc[3]) & bc[4];
-		st[j + 3] ^= (~bc[4]) & bc[0];
-		st[j + 4] ^= (~bc[0]) & bc[1];
-		
 		// Iota
 		st[0] ^= keccakf_rndc[round];
 	}
@@ -155,7 +126,7 @@ NOINLINE void keccak(const uint8_t* in, int inlen, uint8_t* md, int mdlen)

 	for (; inlen >= rsiz; inlen -= rsiz, in += rsiz) {
 		for (int i = 0; i < rsizw; i++) {
-			st[i] ^= ((uint64_t*)in)[i];
+			st[i] ^= read_unaligned(reinterpret_cast<const uint64_t*>(in) + i);
 		}
 		keccakf(st);
 	}
@@ -169,7 +140,7 @@ NOINLINE void keccak(const uint8_t* in, int inlen, uint8_t* md, int mdlen)
 	temp[rsiz - 1] |= 0x80;

 	for (int i = 0; i < rsizw; i++) {
-		st[i] ^= ((uint64_t*)temp)[i];
+		st[i] ^= reinterpret_cast<uint64_t*>(temp)[i];
 	}

 	keccakf(st);
@@ -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
@@ -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,6 +19,7 @@
 #include "uv_util.h"
 #include <ctime>
 #include <fstream>
+#include <thread>

 static constexpr char log_category_prefix[] = "Log ";
 static constexpr char log_file_name[] = "p2pool.log";
@@ -32,7 +33,7 @@ bool CONSOLE_COLORS = true;

 #ifndef P2POOL_LOG_DISABLE

-static volatile bool stopped = false;
+static std::atomic<bool> stopped{ false };
 static volatile bool worker_started = false;

 #ifdef _WIN32
@@ -47,7 +48,7 @@ public:
 	enum params : int
 	{
 		SLOT_SIZE = 1024,
-		BUF_SIZE = SLOT_SIZE * 16384,
+		BUF_SIZE = SLOT_SIZE * 8192,
 	};

 	FORCEINLINE Worker()
@@ -72,7 +73,9 @@ public:
 			abort();
 		}

-		do {} while (!worker_started);
+		while (!worker_started) {
+			std::this_thread::yield();
+		}

 #ifdef _WIN32
 		DWORD dwConsoleMode;
@@ -102,11 +105,10 @@ public:

 	FORCEINLINE void stop()
 	{
-		if (stopped) {
+		if (stopped.exchange(true)) {
 			return;
 		}

-		stopped = true;
 		LOGINFO(0, "stopped");
 		uv_thread_join(&m_worker);
 		uv_cond_destroy(&m_cond);
@@ -131,6 +133,7 @@ public:

 		memcpy(p + 1, buf + 1, size - 1);

+		// Ensure memory order in the writer thread
 		std::atomic_thread_fence(std::memory_order_seq_cst);

 		// Mark that everything is written into this log slot
@@ -149,18 +152,26 @@ private:

 		do {
 			uv_mutex_lock(&m_mutex);
-			uv_cond_wait(&m_cond, &m_mutex);
+			if (m_readPos == m_writePos.load()) {
+				// Nothing to do, wait for the signal
+				uv_cond_wait(&m_cond, &m_mutex);
+			}
 			uv_mutex_unlock(&m_mutex);

-			for (uint32_t writePos = m_writePos.load(); m_readPos < writePos; writePos = m_writePos.load()) {
+			for (uint32_t writePos = m_writePos.load(); m_readPos != writePos; writePos = m_writePos.load()) {
 				// We have at least one log slot pending, possibly more than one
 				// Process everything in a loop before reading m_writePos again
 				do {
 					char* p = m_buf.data() + (m_readPos % BUF_SIZE);

 					// Wait until everything is written into this log slot
-					volatile char& severity = *p;
-					while (!severity) {}
+					volatile char& severity = p[0];
+					while (!severity) {
+						std::this_thread::yield();
+					}
+
+					// Ensure memory order in the reader thread
+					std::atomic_thread_fence(std::memory_order_seq_cst);

 					uint32_t size = static_cast<uint8_t>(p[2]);
 					size = (size << 8) + static_cast<uint8_t>(p[1]);
@@ -183,15 +194,6 @@ private:
 						fwrite(p, 1, size, (severity == 1) ? stdout : stderr);
 #endif

-						// Reopen the log file if it's been moved (logrotate support)
-						if (m_logFile.is_open()) {
-							struct stat buf;
-							if (stat(log_file_name, &buf) != 0) {
-								m_logFile.close();
-								m_logFile.open(log_file_name, std::ios::app | std::ios::binary);
-							}
-						}
-
 						if (m_logFile.is_open()) {
 							if (c) {
 								strip_colors(p, size);
@@ -208,7 +210,6 @@ private:
 							}

 							m_logFile.write(p, size);
-							m_logFile.flush();
 						}
 					}

@@ -218,6 +219,18 @@ private:
 					m_readPos += SLOT_SIZE;
 				} while (m_readPos < writePos);
 			}
+
+			// Flush the log file only after all pending log lines have been written
+			if (m_logFile.is_open()) {
+				m_logFile.flush();
+
+				// Reopen the log file if it's been moved (logrotate support)
+				struct stat buf;
+				if (stat(log_file_name, &buf) != 0) {
+					m_logFile.close();
+					m_logFile.open(log_file_name, std::ios::app | std::ios::binary);
+				}
+			}
 		} while (!stopped);
 	}

@@ -263,7 +276,6 @@ static Worker worker;

 #endif // P2POOL_LOG_DISABLE

-// cppcheck-suppress uninitMemberVar
 NOINLINE Writer::Writer(Severity severity) : Stream(m_stackBuf)
 {
 	m_buf[0] = static_cast<char>(severity);
@@ -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
@@ -35,8 +35,10 @@ struct Stream
 {
 	enum params : int { BUF_SIZE = 1024 - 1 };

-	explicit FORCEINLINE Stream(char* buf) : m_pos(0), m_numberWidth(1), m_buf(buf), m_bufSize(BUF_SIZE) {}
-	FORCEINLINE Stream(char* buf, size_t size) : m_pos(0), m_numberWidth(1), m_buf(buf), m_bufSize(static_cast<int>(size) - 1) {}
+	template<size_t N>
+	explicit FORCEINLINE Stream(char (&buf)[N]) : m_pos(0), m_numberWidth(1), m_buf(buf), m_bufSize(N - 1) {}
+
+	FORCEINLINE Stream(void* buf, size_t size) : m_pos(0), m_numberWidth(1), m_buf(reinterpret_cast<char*>(buf)), m_bufSize(static_cast<int>(size) - 1) {}

 	template<typename T>
 	struct Entry
@@ -182,7 +184,10 @@ INT_ENTRY(unsigned long)
 template<typename T, int base>
 struct BasedValue
 {
-	explicit FORCEINLINE BasedValue(T value) : m_value(value) {}
+	explicit FORCEINLINE BasedValue(T value) : m_value(value)
+	{
+		static_assert(std::is_integral<T>::value, "Must be an integer type here");
+	}

 	T m_value;
 };
@@ -190,7 +195,7 @@ struct BasedValue
 template<typename T, int base>
 struct Stream::Entry<BasedValue<T, base>>
 {
-	static FORCEINLINE void put(BasedValue<T, base>&& data, Stream* wrapper)
+	static FORCEINLINE void put(BasedValue<T, base> data, Stream* wrapper)
 	{
 		wrapper->writeInt<T, base>(data.m_value);
 	}
@@ -302,6 +307,7 @@ struct Hashrate
 {
 	FORCEINLINE Hashrate() : m_data(0), m_valid(false) {}
 	explicit FORCEINLINE Hashrate(uint64_t data) : m_data(data), m_valid(true) {}
+	FORCEINLINE Hashrate(uint64_t data, bool valid) : m_data(data), m_valid(valid) {}

 	uint64_t m_data;
 	bool m_valid;
@@ -309,7 +315,7 @@ struct Hashrate

 template<> struct log::Stream::Entry<Hashrate>
 {
-	static NOINLINE void put(Hashrate&& value, Stream* wrapper)
+	static NOINLINE void put(const Hashrate& value, Stream* wrapper)
 	{
 		if (!value.m_valid) {
 			return;
@@ -354,7 +360,7 @@ struct XMRAmount

 template<> struct log::Stream::Entry<XMRAmount>
 {
-	static NOINLINE void put(XMRAmount&& value, Stream* wrapper)
+	static NOINLINE void put(XMRAmount value, Stream* wrapper)
 	{
 		constexpr uint64_t denomination = 1000000000000ULL;

@@ -372,8 +378,7 @@ template<> struct log::Stream::Entry<XMRAmount>

 template<> struct log::Stream::Entry<NetworkType>
 {
-	// cppcheck-suppress constParameter
-	static NOINLINE void put(const NetworkType& value, Stream* wrapper)
+	static NOINLINE void put(NetworkType value, Stream* wrapper)
 	{
 		switch (value) {
 		case NetworkType::Invalid:  *wrapper << "invalid";  break;
@@ -384,6 +389,68 @@ template<> struct log::Stream::Entry<NetworkType>
 	}
 };

+struct Duration
+{
+	explicit FORCEINLINE Duration(uint64_t data) : m_data(data) {}
+
+	uint64_t m_data;
+};
+
+template<> struct log::Stream::Entry<Duration>
+{
+	static NOINLINE void put(Duration value, Stream* wrapper)
+	{
+		const uint64_t uptime = value.m_data;
+
+		const int64_t s = uptime % 60;
+		const int64_t m = (uptime / 60) % 60;
+		const int64_t h = (uptime / 3600) % 24;
+		const int64_t d = uptime / 86400;
+
+		if (d > 0) {
+			*wrapper << d << "d ";
+		}
+		*wrapper << h << "h " << m << "m " << s << 's';
+	}
+};
+
+template<typename T>
+struct PadRight
+{
+	FORCEINLINE PadRight(const T& value, int len) : m_value(value), m_len(len) {}
+
+	const T& m_value;
+	int m_len;
+
+	// Declare it to make compiler happy
+	PadRight(const PadRight&);
+
+private:
+	PadRight& operator=(const PadRight&) = delete;
+	PadRight& operator=(PadRight&&) = delete;
+};
+
+template<typename T> FORCEINLINE PadRight<T> pad_right(const T& value, int len) { return PadRight<T>(value, len); }
+
+template<typename T>
+struct log::Stream::Entry<PadRight<T>>
+{
+	static NOINLINE void put(PadRight<T>&& data, Stream* wrapper)
+	{
+		char buf[log::Stream::BUF_SIZE + 1];
+		log::Stream s(buf);
+		s << data.m_value;
+
+		const int len = std::min<int>(data.m_len, log::Stream::BUF_SIZE);
+		if (s.m_pos < len) {
+			memset(buf + s.m_pos, ' ', static_cast<size_t>(len) - s.m_pos);
+			s.m_pos = len;
+		}
+
+		wrapper->writeBuf(buf, s.m_pos);
+	}
+};
+
 void put_rawip(const raw_ip& value, Stream* wrapper);

 template<> struct log::Stream::Entry<raw_ip>
@@ -402,16 +469,47 @@ namespace {
 #define CONCAT(a, b) CONCAT2(a, b)
 #define CONCAT2(a, b) a##b

+// This is to check that LOG() call doesn't modify variables in scope, making program behavior dependent on the log level:
+//
+//		int some_func(int& n) { return ++n; }
+//		...
+//		LOGINFO(1, "Some important value: " << some_func(n));
+//
+// will not compile because the dummy lambda capture uses const-qualified copies of all variables.
+//
+// The check is "free": compiler will remove it entirely in release builds.
+
+struct DummyStream
+{
+	template<typename T>
+	FORCEINLINE DummyStream& operator<<(const T&)
+	{
+		return *this;
+	}
+};
+
+#define SIDE_EFFECT_CHECK(level, ...) \
+	do { \
+		if (0) { \
+			MSVC_PRAGMA(warning(suppress:26444)) \
+			[=]() { \
+				log::DummyStream x; \
+				x << level << __VA_ARGS__; \
+			}; \
+		} \
+	} while (0)
+
 #ifdef P2POOL_LOG_DISABLE

-#define LOGINFO(level, ...)
-#define LOGWARN(level, ...)
-#define LOGERR(level, ...)
+#define LOGINFO(level, ...) SIDE_EFFECT_CHECK(level, __VA_ARGS__)
+#define LOGWARN(level, ...) SIDE_EFFECT_CHECK(level, __VA_ARGS__)
+#define LOGERR(level, ...) SIDE_EFFECT_CHECK(level, __VA_ARGS__)

 #else

 #define LOG(level, severity, ...) \
 	do { \
+		SIDE_EFFECT_CHECK(level, __VA_ARGS__); \
 		if (level <= log::GLOBAL_LOG_LEVEL) { \
 			log::Writer CONCAT(log_wrapper_, __LINE__)(severity); \
 			CONCAT(log_wrapper_, __LINE__) << log::Gray() << log_category_prefix; \
@@ -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,8 @@ void p2pool_usage()
 		"--out-peers N        Maximum number of outgoing connections for p2p server (any value between 10 and 1000)\n"
 		"--in-peers N         Maximum number of incoming connections for p2p server (any value between 10 and 1000)\n"
 		"--start-mining N     Start built-in miner using N threads (any value between 1 and 64)\n"
-		"--mini               Connect to p2pool-mini sidechain. Note that it will also change default p2p port from %d to %d.\n"
+		"--mini               Connect to p2pool-mini sidechain. Note that it will also change default p2p port from %d to %d\n"
+		"--no-autodiff        Disable automatic difficulty adjustment for miners connected to stratum\n"
 		"--help               Show this help message\n\n"
 		"Example command line:\n\n"
 		"%s --host 127.0.0.1 --rpc-port 18081 --zmq-port 18083 --wallet YOUR_WALLET_ADDRESS --stratum 0.0.0.0:%d --p2p 0.0.0.0:%d\n\n",
@@ -84,10 +85,15 @@ int main(int argc, char* argv[])
 	memory_tracking_start();

 	p2pool::init_crypto_cache();
-	{
+
+	try {
 		p2pool::p2pool pool(argc, argv);
 		result = pool.run();
 	}
+	catch (...) {
+		result = 1;
+	}
+
 	p2pool::destroy_crypto_cache();

 	memory_tracking_stop();
@@ -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
@@ -236,7 +236,9 @@ NOINLINE void operator delete(void* p, size_t) noexcept { p2pool::free_hook(p);
 NOINLINE void operator delete[](void* p, size_t) noexcept { p2pool::free_hook(p); }

 #else
+// cppcheck-suppress functionStatic
 void memory_tracking_start() {}
+// cppcheck-suppress functionStatic
 void memory_tracking_stop() {}

 namespace p2pool {
@@ -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);

@@ -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
@@ -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
@@ -24,6 +24,7 @@
 #include "randomx.h"
 #include "params.h"
 #include "p2pool_api.h"
+#include "side_chain.h"
 #include <thread>

 static constexpr char log_category_prefix[] = "Miner ";
@@ -35,14 +36,15 @@ namespace p2pool {
 Miner::Miner(p2pool* pool, uint32_t threads)
 	: m_pool(pool)
 	, m_threads(threads)
-	, m_stopped(false)
+	, m_stopped{ false }
 	, m_startTimestamp(high_resolution_clock::now())
 	, m_nonce(0)
 	, m_nonceTimestamp(m_startTimestamp)
 	, m_extraNonce(0xF19E3779U)
 	, m_totalHashes(0)
+	, m_sharesFound(0)
 	, m_job{}
-	, m_jobIndex(0)
+	, m_jobIndex{ 0 }
 {
 	on_block(m_pool->block_template());

@@ -100,8 +102,10 @@ void Miner::on_block(const BlockTemplate& block)
 	m_totalHashes += hash_count;

 	if (m_pool->api() && m_pool->params().m_localStats) {
+		const double block_reward_share_percent = m_pool->side_chain().get_reward_share(m_pool->params().m_wallet) * 100.0;
+
 		m_pool->api()->set(p2pool_api::Category::LOCAL, "miner",
-			[cur_ts, hash_count, dt, this](log::Stream& s)
+			[cur_ts, hash_count, dt, block_reward_share_percent, this](log::Stream& s)
 			{
 				const uint64_t hr = (dt > 0.0) ? static_cast<uint64_t>(hash_count / dt) : 0;
 				const double time_running = static_cast<double>(duration_cast<milliseconds>(cur_ts - m_startTimestamp).count()) / 1e3;
@@ -110,6 +114,7 @@ void Miner::on_block(const BlockTemplate& block)
 					<< ",\"total_hashes\":" << m_totalHashes
 					<< ",\"time_running\":" << time_running
 					<< ",\"shares_found\":" << m_sharesFound.load()
+					<< ",\"block_reward_share_percent\":" << block_reward_share_percent
 					<< ",\"threads\":" << m_threads
 					<< "}";
 			});
@@ -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
@@ -49,12 +49,12 @@ private:
 	};

 	std::vector<WorkerData*> m_minerThreads;
-	volatile bool m_stopped;
+	std::atomic<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;
@@ -75,7 +75,7 @@ private:
 		void set_nonce(uint32_t nonce, uint32_t extra_nonce);
 	};
 	Job m_job[2];
-	volatile uint32_t m_jobIndex;
+	std::atomic<uint32_t> m_jobIndex;

 	void run(WorkerData* data);
 };
@@ -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,8 @@ static const char* seed_nodes_mini[] = { "seeds-mini.p2pool.io", "" };
 static constexpr int DEFAULT_BACKLOG = 16;
 static constexpr uint64_t DEFAULT_BAN_TIME = 600;

+static constexpr size_t SEND_BUF_MIN_SIZE = 256;
+
 #include "tcp_server.inl"

 namespace p2pool {
@@ -47,17 +49,23 @@ 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_timerInterval(2)
-	, m_peerId(m_rng())
 	, m_peerListLastSaved(0)
 {
-	set_max_outgoing_peers(pool->params().m_maxOutgoingPeers);
-	set_max_incoming_peers(pool->params().m_maxIncomingPeers);
+	// Diffuse the initial state in case it has low quality
+	m_rng.discard(10000);
+
+	m_peerId = m_rng();
+
+	const Params& params = pool->params();
+
+	set_max_outgoing_peers(params.m_maxOutgoingPeers);
+	set_max_incoming_peers(params.m_maxIncomingPeers);

 	uv_mutex_init_checked(&m_rngLock);
 	uv_mutex_init_checked(&m_blockLock);
@@ -69,7 +77,7 @@ P2PServer::P2PServer(p2pool* pool)
 	int err = uv_async_init(&m_loop, &m_broadcastAsync, on_broadcast);
 	if (err) {
 		LOGERR(1, "uv_async_init failed, error " << uv_err_name(err));
-		return;
+		panic();
 	}
 	m_broadcastAsync.data = this;
 	m_broadcastQueue.reserve(2);
@@ -94,7 +102,7 @@ P2PServer::P2PServer(p2pool* pool)
 	}

 	load_peer_list();
-	start_listening(pool->params().m_p2pAddresses);
+	start_listening(params.m_p2pAddresses);
 }

 P2PServer::~P2PServer()
@@ -125,18 +133,35 @@ 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) {
+	// cppcheck-suppress identicalConditionAfterEarlyExit
+	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)
@@ -174,12 +199,12 @@ 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;
+	unordered_set<raw_ip> connected_clients;
 	{
 		MutexLock lock(m_clientsListLock);
 		connected_clients.reserve(m_numConnections);
@@ -195,12 +220,12 @@ void P2PServer::update_peer_connections()
 			}

 			if (client->m_handshakeComplete && client->m_lastBroadcastTimestamp) {
-				// - Side chain is at least 5 minutes newer (last_updated >= client->m_lastBroadcastTimestamp + 300)
+				// - Side chain is at least 15 minutes newer (last_updated >= client->m_lastBroadcastTimestamp + 900)
 				// - It's been at least 10 seconds since side chain updated (cur_time >= last_updated + 10)
 				// - 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;
+				if (last_updated && (cur_time >= std::max(last_updated, client->m_lastBlockrequestTimestamp) + 10) && (last_updated >= client->m_lastBroadcastTimestamp + 900)) {
+					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);
@@ -210,7 +235,7 @@ void P2PServer::update_peer_connections()
 			}

 			if (!disconnected) {
-				connected_clients.emplace_back(client->m_addr);
+				connected_clients.insert(client->m_addr);
 				if (client->m_handshakeComplete && !client->m_handshakeInvalid && (client->m_listenPort >= 0)) {
 					has_good_peers = true;
 				}
@@ -225,7 +250,7 @@ void P2PServer::update_peer_connections()
 		if ((m_timerCounter % 30) == 1) {
 			// Update last seen time for currently connected peers
 			for (Peer& p : m_peerList) {
-				if (std::find_if(connected_clients.begin(), connected_clients.end(), [&p](const raw_ip& addr) { return p.m_addr == addr; }) != connected_clients.end()) {
+				if (connected_clients.find(p.m_addr) != connected_clients.end()) {
 					p.m_lastSeen = cur_time;
 				}
 			}
@@ -254,15 +279,7 @@ void P2PServer::update_peer_connections()
 		const uint64_t k = get_random64() % peer_list.size();
 		const Peer& peer = peer_list[k];

-		bool already_connected = false;
-		for (const raw_ip& ip : connected_clients) {
-			if (ip == peer.m_addr) {
-				already_connected = true;
-				break;
-			}
-		}
-
-		if (!already_connected && connect_to_peer(peer.m_isV6, peer.m_addr, peer.m_port)) {
+		if ((connected_clients.find(peer.m_addr) == connected_clients.end()) && connect_to_peer(peer.m_isV6, peer.m_addr, peer.m_port)) {
 			++i;
 		}

@@ -274,6 +291,7 @@ void P2PServer::update_peer_connections()

 	if (!has_good_peers && ((m_timerCounter % 30) == 0)) {
 		LOGERR(1, "no connections to other p2pool nodes, check your monerod/p2pool/network/firewall setup!!!");
+		load_peer_list();
 		if (m_peerListMonero.empty()) {
 			load_monerod_peer_list();
 		}
@@ -282,6 +300,7 @@ void P2PServer::update_peer_connections()

 void P2PServer::update_peer_list()
 {
+	const uint64_t cur_time = seconds_since_epoch();
 	{
 		MutexLock lock(m_clientsListLock);

@@ -290,14 +309,19 @@ void P2PServer::update_peer_list()
 				continue;
 			}

-			if (m_timerCounter >= client->m_nextOutgoingPeerListRequest) {
+			if (cur_time >= client->m_nextOutgoingPeerListRequest) {
 				// Send peer list requests at random intervals (60-120 seconds)
-				client->m_nextOutgoingPeerListRequest = m_timerCounter + (60 + (get_random64() % 61)) / m_timerInterval;
+				client->m_nextOutgoingPeerListRequest = cur_time + (60 + (get_random64() % 61));

 				const bool result = send(client,
-					[](void* buf)
+					[](void* buf, size_t buf_size)
 					{
 						LOGINFO(5, "sending PEER_LIST_REQUEST");
+
+						if (buf_size < SEND_BUF_MIN_SIZE) {
+							return 0;
+						}
+
 						*reinterpret_cast<uint8_t*>(buf) = static_cast<uint8_t>(MessageId::PEER_LIST_REQUEST);
 						return 1;
 					});
@@ -313,7 +337,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;
 	}
@@ -386,13 +410,18 @@ 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()
 {
+	size_t old_size;
+	{
+		MutexLock lock(m_peerListLock);
+		old_size = m_peerList.size();
+	}
+
 	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) {
@@ -402,7 +431,7 @@ void P2PServer::load_peer_list()
 			addrinfo hints{};
 			hints.ai_family = AF_UNSPEC;
 			hints.ai_socktype = SOCK_STREAM;
-			hints.ai_flags = AI_V4MAPPED | AI_ADDRCONFIG;
+			hints.ai_flags = AI_ADDRCONFIG;

 			addrinfo* result;
 			const int err = getaddrinfo(nodes[i], nullptr, &hints, &result);
@@ -411,7 +440,9 @@ void P2PServer::load_peer_list()
 					const char* addr_str;
 					char addr_str_buf[64];

-					char buf[log::Stream::BUF_SIZE + 1];
+					char buf[128];
+					buf[0] = '\0';
+
 					log::Stream s(buf);

 					if (r->ai_family == AF_INET6) {
@@ -428,7 +459,7 @@ void P2PServer::load_peer_list()
 					}

 					if (s.m_pos) {
-						LOGINFO(4, "added " << static_cast<char*>(buf) << " from " << nodes[i]);
+						LOGINFO(4, "added " << static_cast<const char*>(buf) << " from " << nodes[i]);
 						if (!saved_list.empty()) {
 							saved_list += ',';
 						}
@@ -510,7 +541,7 @@ 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);
@@ -527,33 +558,35 @@ void P2PServer::load_monerod_peer_list()
 	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 ";
+#define 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)");
+				LOGWARN(4, ERR_STR "(parse error)");
 				return;
 			}

 			if (!doc.IsObject()) {
-				LOGWARN(4, err_str << "(not an object)");
+				LOGWARN(4, ERR_STR "(not an object)");
 				return;
 			}

 			if (!doc.HasMember("white_list")) {
-				LOGWARN(4, err_str << "('white_list' not found)");
+				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)");
+				LOGWARN(4, ERR_STR "('white_list' is not an array)");
 				return;
 			}

+#undef ERR_STR
+
 			const int port = m_pool->side_chain().is_mini() ? DEFAULT_P2P_PORT_MINI : DEFAULT_P2P_PORT;

 			const SizeType n = white_list.Size();
@@ -617,7 +650,7 @@ void P2PServer::load_monerod_peer_list()

 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);

@@ -663,13 +696,15 @@ void P2PServer::remove_peer_from_list(const raw_ip& ip)

 void P2PServer::broadcast(const PoolBlock& block)
 {
-	if (block.m_txinGenHeight + 2 < m_pool->miner_data().height) {
-		LOGWARN(3, "Trying to broadcast a stale block " << block.m_sidechainId << " (mainchain height " << block.m_txinGenHeight << ", current height is " << m_pool->miner_data().height << ')');
+	MinerData miner_data = m_pool->miner_data();
+
+	if (block.m_txinGenHeight + 2 < miner_data.height) {
+		LOGWARN(3, "Trying to broadcast a stale block " << block.m_sidechainId << " (mainchain height " << block.m_txinGenHeight << ", current height is " << miner_data.height << ')');
 		return;
 	}

-	if (block.m_txinGenHeight > m_pool->miner_data().height + 2) {
-		LOGWARN(3, "Trying to broadcast a block " << block.m_sidechainId << " ahead on mainchain (mainchain height " << block.m_txinGenHeight << ", current height is " << m_pool->miner_data().height << ')');
+	if (block.m_txinGenHeight > miner_data.height + 2) {
+		LOGWARN(3, "Trying to broadcast a block " << block.m_sidechainId << " ahead on mainchain (mainchain height " << block.m_txinGenHeight << ", current height is " << miner_data.height << ')');
 		return;
 	}

@@ -763,7 +798,8 @@ void P2PServer::on_broadcast()
 		}

 		for (Broadcast* data : broadcast_queue) {
-			send(client, [client, data](void* buf) {
+			send(client, [client, data](void* buf, size_t buf_size) -> size_t
+			{
 				uint8_t* p0 = reinterpret_cast<uint8_t*>(buf);
 				uint8_t* p = p0;

@@ -781,23 +817,39 @@ void P2PServer::on_broadcast()

 				if (send_pruned) {
 					LOGINFO(6, "sending BLOCK_BROADCAST (pruned) to " << log::Gray() << static_cast<char*>(client->m_addrString));
+
+					const uint32_t len = static_cast<uint32_t>(data->pruned_blob.size());
+					if (buf_size < SEND_BUF_MIN_SIZE + 1 + sizeof(uint32_t) + len) {
+						return 0;
+					}
+
 					*(p++) = static_cast<uint8_t>(MessageId::BLOCK_BROADCAST);

-					*reinterpret_cast<uint32_t*>(p) = static_cast<uint32_t>(data->pruned_blob.size());
+					memcpy(p, &len, sizeof(uint32_t));
 					p += sizeof(uint32_t);

-					memcpy(p, data->pruned_blob.data(), data->pruned_blob.size());
-					p += data->pruned_blob.size();
+					if (len) {
+						memcpy(p, data->pruned_blob.data(), len);
+						p += len;
+					}
 				}
 				else {
 					LOGINFO(5, "sending BLOCK_BROADCAST (full)   to " << log::Gray() << static_cast<char*>(client->m_addrString));
+
+					const uint32_t len = static_cast<uint32_t>(data->blob.size());
+					if (buf_size < SEND_BUF_MIN_SIZE + 1 + sizeof(uint32_t) + len) {
+						return 0;
+					}
+
 					*(p++) = static_cast<uint8_t>(MessageId::BLOCK_BROADCAST);

-					*reinterpret_cast<uint32_t*>(p) = static_cast<uint32_t>(data->blob.size());
+					memcpy(p, &len, sizeof(uint32_t));
 					p += sizeof(uint32_t);

-					memcpy(p, data->blob.data(), data->blob.size());
-					p += data->blob.size();
+					if (len) {
+						memcpy(p, data->blob.data(), len);
+						p += len;
+					}
 				}

 				return p - p0;
@@ -814,25 +866,12 @@ uint64_t P2PServer::get_random64()

 void P2PServer::print_status()
 {
-	const int64_t uptime = time(nullptr) - m_pool->start_time();
-
-	const int64_t s = uptime % 60;
-	const int64_t m = (uptime / 60) % 60;
-	const int64_t h = (uptime / 3600) % 24;
-	const int64_t d = uptime / 86400;
-
-	char buf[log::Stream::BUF_SIZE + 1];
-	log::Stream s1(buf);
-
-	if (d > 0) {
-		s1 << d << "d ";
-	}
-	s1 << h << "h " << m << "m " << s << 's';
+	MutexLock lock(m_peerListLock);

 	LOGINFO(0, "status" <<
-		"\nConnections    = " << m_numConnections << " (" << m_numIncomingConnections << " incoming)" <<
+		"\nConnections    = " << m_numConnections.load() << " (" << m_numIncomingConnections.load() << " incoming)" <<
 		"\nPeer list size = " << m_peerList.size() <<
-		"\nUptime         = " << log::const_buf(buf, s1.m_pos)
+		"\nUptime         = " << log::Duration(seconds_since_epoch() - m_pool->start_time())
 	);
 }

@@ -840,11 +879,16 @@ void P2PServer::show_peers()
 {
 	MutexLock lock(m_clientsListLock);

+	size_t n = 0;
+
 	for (P2PClient* client = static_cast<P2PClient*>(m_connectedClientsList->m_next); client != m_connectedClientsList; client = static_cast<P2PClient*>(client->m_next)) {
 		if (client->m_listenPort >= 0) {
 			LOGINFO(0, (client->m_isIncoming ? "I " : "O ") << client->m_pingTime << " ms\t" << static_cast<char*>(client->m_addrString));
+			++n;
 		}
 	}
+
+	LOGINFO(0, "Total: " << n << " peers");
 }

 void P2PServer::on_timer()
@@ -930,12 +974,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) {
@@ -945,13 +991,27 @@ void P2PServer::download_missing_blocks()
 			}
 		}

+		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)
+			[&id](void* buf, size_t buf_size) -> size_t
 			{
+				LOGINFO(5, "sending BLOCK_REQUEST for id = " << id);
+
+				if (buf_size < SEND_BUF_MIN_SIZE) {
+					return 0;
+				}
+
 				uint8_t* p0 = reinterpret_cast<uint8_t*>(buf);
 				uint8_t* p = p0;

-				LOGINFO(5, "sending BLOCK_REQUEST for id = " << id);
 				*(p++) = static_cast<uint8_t>(MessageId::BLOCK_REQUEST);

 				memcpy(p, id.h, HASH_SIZE);
@@ -972,12 +1032,13 @@ 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);
 		LOGERR(1, "no ZMQ messages received from monerod in the last " << dt << " seconds, check your monerod/p2pool/network/firewall setup!!!");
+		m_pool->restart_zmq();
 	}
 }

@@ -990,12 +1051,13 @@ P2PServer::P2PClient::P2PClient()
 	, m_handshakeInvalid(false)
 	, m_listenPort(-1)
 	, m_fastPeerListRequestCount(0)
-	, m_prevIncomingPeerListRequest{}
+	, m_prevIncomingPeerListRequest(0)
 	, m_nextOutgoingPeerListRequest(0)
 	, m_lastPeerListRequestTime{}
 	, m_peerListPendingRequests(0)
 	, m_pingTime(0)
 	, m_blockPendingRequests(0)
+	, m_chainTipBlockRequest(false)
 	, m_lastAlive(0)
 	, m_lastBroadcastTimestamp(0)
 	, m_lastBlockrequestTimestamp(0)
@@ -1019,12 +1081,13 @@ void P2PServer::P2PClient::reset()
 	m_handshakeInvalid = false;
 	m_listenPort = -1;
 	m_fastPeerListRequestCount = 0;
-	m_prevIncomingPeerListRequest = {};
+	m_prevIncomingPeerListRequest = 0;
 	m_nextOutgoingPeerListRequest = 0;
 	m_lastPeerListRequestTime = {};
 	m_peerListPendingRequests = 0;
 	m_pingTime = 0;
 	m_blockPendingRequests = 0;
+	m_chainTipBlockRequest = false;
 	m_lastAlive = 0;
 	m_lastBroadcastTimestamp = 0;
 	m_lastBlockrequestTimestamp = 0;
@@ -1057,7 +1120,7 @@ bool P2PServer::P2PClient::on_connect()
 		}
 	}

-	m_lastAlive = time(nullptr);
+	m_lastAlive = seconds_since_epoch();
 	return send_handshake_challenge();
 }

@@ -1191,7 +1254,7 @@ bool P2PServer::P2PClient::on_read(char* data, uint32_t size)
 			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);
+				const uint32_t block_size = read_unaligned(reinterpret_cast<uint32_t*>(buf + 1));
 				if (bytes_left >= 1 + sizeof(uint32_t) + block_size) {
 					bytes_read = 1 + sizeof(uint32_t) + block_size;

@@ -1209,7 +1272,7 @@ bool P2PServer::P2PClient::on_read(char* data, uint32_t size)
 			LOGINFO(6, "peer " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " sent BLOCK_BROADCAST");

 			if (bytes_left >= 1 + sizeof(uint32_t)) {
-				const uint32_t block_size = *reinterpret_cast<uint32_t*>(buf + 1);
+				const uint32_t block_size = read_unaligned(reinterpret_cast<uint32_t*>(buf + 1));
 				if (bytes_left >= 1 + sizeof(uint32_t) + block_size) {
 					bytes_read = 1 + sizeof(uint32_t) + block_size;
 					if (!on_block_broadcast(buf + 1 + sizeof(uint32_t), block_size)) {
@@ -1273,7 +1336,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);

@@ -1312,12 +1375,17 @@ bool P2PServer::P2PClient::send_handshake_challenge()
 	m_handshakeChallenge = owner->get_random64();

 	return owner->send(this,
-		[this, owner](void* buf)
+		[this, owner](void* buf, size_t buf_size) -> size_t
 		{
+			LOGINFO(5, "sending HANDSHAKE_CHALLENGE");
+
+			if (buf_size < SEND_BUF_MIN_SIZE) {
+				return 0;
+			}
+
 			uint8_t* p0 = reinterpret_cast<uint8_t*>(buf);
 			uint8_t* p = p0;

-			LOGINFO(5, "sending HANDSHAKE_CHALLENGE");
 			*(p++) = static_cast<uint8_t>(MessageId::HANDSHAKE_CHALLENGE);

 			uint64_t k = m_handshakeChallenge;
@@ -1429,12 +1497,17 @@ void P2PServer::P2PClient::send_handshake_solution(const uint8_t (&challenge)[CH
 			}

 			const bool result = work->server->send(work->client,
-				[work](void* buf)
+				[work](void* buf, size_t buf_size) -> size_t
 				{
+					LOGINFO(5, "sending HANDSHAKE_SOLUTION");
+
+					if (buf_size < SEND_BUF_MIN_SIZE) {
+						return 0;
+					}
+
 					uint8_t* p0 = reinterpret_cast<uint8_t*>(buf);
 					uint8_t* p = p0;

-					LOGINFO(5, "sending HANDSHAKE_SOLUTION");
 					*(p++) = static_cast<uint8_t>(MessageId::HANDSHAKE_SOLUTION);

 					memcpy(p, work->solution.h, HASH_SIZE);
@@ -1579,8 +1652,14 @@ bool P2PServer::P2PClient::on_handshake_solution(const uint8_t* buf)
 		}

 		return m_owner->send(this,
-			[this](void* buf)
+			[this](void* buf, size_t buf_size) -> size_t
 			{
+				LOGINFO(5, "sending LISTEN_PORT and BLOCK_REQUEST for the chain tip");
+
+				if (buf_size < SEND_BUF_MIN_SIZE) {
+					return 0;
+				}
+
 				uint8_t* p0 = reinterpret_cast<uint8_t*>(buf);
 				uint8_t* p = p0;
 				on_after_handshake(p);
@@ -1608,7 +1687,8 @@ void P2PServer::P2PClient::on_after_handshake(uint8_t* &p)
 	p += HASH_SIZE;

 	++m_blockPendingRequests;
-	m_lastBroadcastTimestamp = time(nullptr);
+	m_chainTipBlockRequest = true;
+	m_lastBroadcastTimestamp = seconds_since_epoch();
 }

 bool P2PServer::P2PClient::on_listen_port(const uint8_t* buf)
@@ -1629,7 +1709,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);
@@ -1642,19 +1722,28 @@ bool P2PServer::P2PClient::on_block_request(const uint8_t* buf)
 	}

 	return server->send(this,
-		[&blob](void* buf)
+		[&blob](void* buf, size_t buf_size) -> size_t
 		{
+			LOGINFO(5, "sending BLOCK_RESPONSE");
+
+			const uint32_t len = static_cast<uint32_t>(blob.size());
+
+			if (buf_size < SEND_BUF_MIN_SIZE + 1 + sizeof(uint32_t) + len) {
+				return 0;
+			}
+
 			uint8_t* p0 = reinterpret_cast<uint8_t*>(buf);
 			uint8_t* p = p0;

-			LOGINFO(5, "sending BLOCK_RESPONSE");
 			*(p++) = static_cast<uint8_t>(MessageId::BLOCK_RESPONSE);

-			*reinterpret_cast<uint32_t*>(p) = static_cast<uint32_t>(blob.size());
+			memcpy(p, &len, sizeof(uint32_t));
 			p += sizeof(uint32_t);

-			memcpy(p, blob.data(), blob.size());
-			p += blob.size();
+			if (len) {
+				memcpy(p, blob.data(), len);
+				p += len;
+			}

 			return p - p0;
 		});
@@ -1677,6 +1766,18 @@ bool P2PServer::P2PClient::on_block_response(const uint8_t* buf, uint32_t size)
 		return false;
 	}

+	if (m_chainTipBlockRequest) {
+		m_chainTipBlockRequest = false;
+
+		const uint64_t peer_height = server->m_block->m_txinGenHeight;
+		const uint64_t our_height = server->m_pool->miner_data().height;
+
+		if (peer_height + 2 < our_height) {
+			LOGWARN(4, "peer " << static_cast<char*>(m_addrString) << " is mining on top of a stale block (mainchain height " << peer_height << ", expected >= " << our_height << ')');
+			return false;
+		}
+	}
+
 	return handle_incoming_block_async(server->m_block);
 }

@@ -1699,7 +1800,7 @@ bool P2PServer::P2PClient::on_block_broadcast(const uint8_t* buf, uint32_t size)

 	m_broadcastedHashes[m_broadcastedHashesIndex.fetch_add(1) % array_size(&P2PClient::m_broadcastedHashes)] = server->m_block->m_sidechainId;

-	const MinerData& miner_data = server->m_pool->miner_data();
+	MinerData miner_data = server->m_pool->miner_data();

 	if (server->m_block->m_prevId != miner_data.prev_id) {
 		// This peer is mining on top of a different Monero block, investigate it
@@ -1709,7 +1810,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;
@@ -1719,7 +1820,7 @@ bool P2PServer::P2PClient::on_block_broadcast(const uint8_t* buf, uint32_t size)
 				}
 			}
 			else {
-				LOGWARN(5, "peer " << static_cast<char*>(m_addrString) << " broadcasted an unreasonably stale block (mainchain height " << peer_height << ", expected >= " << our_height << ')');
+				LOGWARN(4, "peer " << static_cast<char*>(m_addrString) << " broadcasted an unreasonably stale block (mainchain height " << peer_height << ", expected >= " << our_height << ')');
 				return false;
 			}
 		}
@@ -1735,20 +1836,18 @@ 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);
 }

 bool P2PServer::P2PClient::on_peer_list_request(const uint8_t*)
 {
-	using namespace std::chrono;
-
 	P2PServer* server = static_cast<P2PServer*>(m_owner);
-	const auto cur_time = steady_clock::now();
+	const uint64_t cur_time = seconds_since_epoch();

 	// Allow peer list requests no more than once every 30 seconds
-	if (duration_cast<seconds>(cur_time - m_prevIncomingPeerListRequest).count() < 30) {
+	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");
@@ -1791,12 +1890,17 @@ bool P2PServer::P2PClient::on_peer_list_request(const uint8_t*)
 	}

 	return server->send(this,
-		[&peers, num_selected_peers](void* buf)
+		[&peers, num_selected_peers](void* buf, size_t buf_size) -> size_t
 		{
+			LOGINFO(5, "sending PEER_LIST_RESPONSE");
+
+			if (buf_size < SEND_BUF_MIN_SIZE + 2 + num_selected_peers * 19) {
+				return 0;
+			}
+
 			uint8_t* p0 = reinterpret_cast<uint8_t*>(buf);
 			uint8_t* p = p0;

-			LOGINFO(5, "sending PEER_LIST_RESPONSE");
 			*(p++) = static_cast<uint8_t>(MessageId::PEER_LIST_RESPONSE);
 			*(p++) = static_cast<uint8_t>(num_selected_peers);

@@ -1819,7 +1923,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);

@@ -1942,20 +2046,27 @@ 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,
-			[&id](void* buf)
+			[&id](void* buf, size_t buf_size) -> size_t
 			{
+				LOGINFO(5, "sending BLOCK_REQUEST for id = " << id);
+
+				if (buf_size < SEND_BUF_MIN_SIZE + 1 + HASH_SIZE) {
+					return 0;
+				}
+
 				uint8_t* p0 = reinterpret_cast<uint8_t*>(buf);
 				uint8_t* p = p0;

-				LOGINFO(5, "sending BLOCK_REQUEST for id = " << id);
 				*(p++) = static_cast<uint8_t>(MessageId::BLOCK_REQUEST);

 				memcpy(p, id.h, HASH_SIZE);
@@ -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 {

@@ -111,17 +110,18 @@ public:
 		int m_listenPort;

 		uint32_t m_fastPeerListRequestCount;
-		std::chrono::steady_clock::time_point m_prevIncomingPeerListRequest;
+		uint64_t m_prevIncomingPeerListRequest;
 		uint64_t m_nextOutgoingPeerListRequest;
 		std::chrono::high_resolution_clock::time_point m_lastPeerListRequestTime;
 		int m_peerListPendingRequests;
 		int64_t m_pingTime;

 		int m_blockPendingRequests;
+		bool m_chainTipBlockRequest;

-		time_t m_lastAlive;
-		time_t m_lastBroadcastTimestamp;
-		time_t m_lastBlockrequestTimestamp;
+		uint64_t m_lastAlive;
+		uint64_t m_lastBroadcastTimestamp;
+		uint64_t m_lastBlockrequestTimestamp;

 		hash m_broadcastedHashes[8];
 		std::atomic<uint32_t> m_broadcastedHashesIndex{ 0 };
@@ -133,7 +133,7 @@ public:

 	void print_status() override;
 	void show_peers();
-	size_t peer_list_size() const { return m_peerList.size(); }
+	size_t peer_list_size() const { MutexLock lock(m_peerListLock); return m_peerList.size(); }

 	uint32_t max_outgoing_peers() const { return m_maxOutgoingPeers; }
 	uint32_t max_incoming_peers() const { return m_maxIncomingPeers; }
@@ -150,7 +150,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(); }
@@ -170,7 +170,6 @@ private:
 	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;
@@ -182,7 +181,7 @@ private:

 	uint64_t m_peerId;

-	uv_mutex_t m_peerListLock;
+	mutable uv_mutex_t m_peerListLock;

 	struct Peer
 	{
@@ -190,12 +189,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;
 	std::vector<Peer> m_peerListMonero;
-	time_t m_peerListLastSaved;
+	std::atomic<uint64_t> m_peerListLastSaved;

 	struct Broadcast
 	{
@@ -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,12 +27,15 @@
 #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"
 #include "p2pool_api.h"
 #include "pool_block.h"
+#include "keccak.h"
 #include <thread>
 #include <fstream>

@@ -52,27 +55,28 @@ 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);

 	if (!m_params->m_wallet.valid()) {
 		LOGERR(1, "Invalid wallet address. Try \"p2pool --help\".");
-		panic();
+		throw std::exception();
 	}

 	bool is_v6;
 	if (!resolve_host(m_params->m_host, is_v6)) {
 		LOGERR(1, "resolve_host failed for " << m_params->m_host);
-		panic();
+		throw std::exception();
 	}

 	hash pub, sec, eph_public_key;
 	generate_keys(pub, sec);

-	if (!m_params->m_wallet.get_eph_public_key(sec, 0, eph_public_key)) {
+	uint8_t view_tag;
+	if (!m_params->m_wallet.get_eph_public_key(sec, 0, eph_public_key, view_tag)) {
 		LOGERR(1, "Invalid wallet address: get_eph_public_key failed");
-		panic();
+		throw std::exception();
 	}

 	const NetworkType type = m_params->m_wallet.type();
@@ -87,33 +91,44 @@ p2pool::p2pool(int argc, char* argv[])
 	int err = uv_async_init(uv_default_loop_checked(), &m_submitBlockAsync, on_submit_block);
 	if (err) {
 		LOGERR(1, "uv_async_init failed, error " << uv_err_name(err));
-		panic();
+		throw std::exception();
 	}
 	m_submitBlockAsync.data = this;

 	err = uv_async_init(uv_default_loop_checked(), &m_blockTemplateAsync, on_update_block_template);
 	if (err) {
 		LOGERR(1, "uv_async_init failed, error " << uv_err_name(err));
-		panic();
+		throw std::exception();
 	}
 	m_blockTemplateAsync.data = this;

 	err = uv_async_init(uv_default_loop_checked(), &m_stopAsync, on_stop);
 	if (err) {
 		LOGERR(1, "uv_async_init failed, error " << uv_err_name(err));
-		panic();
+		throw std::exception();
 	}
 	m_stopAsync.data = this;

+	err = uv_async_init(uv_default_loop_checked(), &m_restartZMQAsync, on_restart_zmq);
+	if (err) {
+		LOGERR(1, "uv_async_init failed, error " << uv_err_name(err));
+		throw std::exception();
+	}
+	m_restartZMQAsync.data = this;
+
 	uv_rwlock_init_checked(&m_mainchainLock);
+	uv_rwlock_init_checked(&m_minerDataLock);
 	uv_mutex_init_checked(&m_foundBlocksLock);
+#ifdef WITH_RANDOMX
+	uv_mutex_init_checked(&m_minerLock);
+#endif
 	uv_mutex_init_checked(&m_submitBlockDataLock);

 	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();
+		throw std::exception();
 	}

 	m_sideChain = new SideChain(this, type, m_params->m_mini ? "mini" : nullptr);
@@ -128,12 +143,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();
@@ -143,7 +162,11 @@ p2pool::p2pool(int argc, char* argv[])
 p2pool::~p2pool()
 {
 	uv_rwlock_destroy(&m_mainchainLock);
+	uv_rwlock_destroy(&m_minerDataLock);
 	uv_mutex_destroy(&m_foundBlocksLock);
+#ifdef WITH_RANDOMX
+	uv_mutex_destroy(&m_minerLock);
+#endif
 	uv_mutex_destroy(&m_submitBlockDataLock);

 	delete m_api;
@@ -181,6 +204,17 @@ bool p2pool::get_seed(uint64_t height, hash& seed) const
 	return true;
 }

+#ifdef WITH_RANDOMX
+void p2pool::print_miner_status()
+{
+	MutexLock lock(m_minerLock);
+
+	if (m_miner) {
+		m_miner->print_status();
+	}
+}
+#endif
+
 void p2pool::handle_tx(TxMempoolData& tx)
 {
 	if (!tx.weight || !tx.fee) {
@@ -197,10 +231,10 @@ void p2pool::handle_tx(TxMempoolData& tx)
 		", fee = " << log::Gray() << static_cast<double>(tx.fee) / 1e6 << " um");

 #if TEST_MEMPOOL_PICKING_ALGORITHM
-	m_blockTemplate->update(m_minerData, *m_mempool, &m_params->m_wallet);
+	m_blockTemplate->update(miner_data(), *m_mempool, &m_params->m_wallet);
 #endif

-	m_zmqLastActive = time(nullptr);
+	m_zmqLastActive = seconds_since_epoch();
 }

 void p2pool::handle_miner_data(MinerData& data)
@@ -232,8 +266,11 @@ void p2pool::handle_miner_data(MinerData& data)
 	}

 	data.tx_backlog.clear();
-	data.time_received = std::chrono::system_clock::now();
-	m_minerData = data;
+	data.time_received = std::chrono::high_resolution_clock::now();
+	{
+		WriteLock lock(m_minerDataLock);
+		m_minerData = data;
+	}
 	m_updateSeed = true;
 	update_median_timestamp();

@@ -257,7 +294,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;
@@ -265,7 +302,8 @@ void p2pool::handle_miner_data(MinerData& data)
 			WriteLock lock(m_mainchainLock);

 			for (uint64_t h = data.height; h && (h + BLOCK_HEADERS_REQUIRED > data.height); --h) {
-				if (m_mainchainByHeight.find(h) == m_mainchainByHeight.end()) {
+				auto it = m_mainchainByHeight.find(h);
+				if ((it == m_mainchainByHeight.end()) || it->second.difficulty.empty()) {
 					LOGWARN(3, "Mainchain data for height " << h << " is missing, requesting it from monerod again");
 					missing_heights.push_back(h);
 				}
@@ -361,7 +399,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)
@@ -409,6 +447,7 @@ void p2pool::on_stop(uv_async_t* async)
 	uv_close(reinterpret_cast<uv_handle_t*>(&pool->m_submitBlockAsync), nullptr);
 	uv_close(reinterpret_cast<uv_handle_t*>(&pool->m_blockTemplateAsync), nullptr);
 	uv_close(reinterpret_cast<uv_handle_t*>(&pool->m_stopAsync), nullptr);
+	uv_close(reinterpret_cast<uv_handle_t*>(&pool->m_restartZMQAsync), nullptr);
 	uv_stop(uv_default_loop());
 }

@@ -543,11 +582,13 @@ void p2pool::update_block_template_async()

 void p2pool::update_block_template()
 {
+	MinerData data = miner_data();
+
 	if (m_updateSeed) {
-		m_hasher->set_seed_async(m_minerData.seed_hash);
+		m_hasher->set_seed_async(data.seed_hash);
 		m_updateSeed = false;
 	}
-	m_blockTemplate->update(m_minerData, *m_mempool, &m_params->m_wallet);
+	m_blockTemplate->update(data, *m_mempool, &m_params->m_wallet);
 	stratum_on_block();
 	api_update_pool_stats();
 }
@@ -590,33 +631,44 @@ void p2pool::download_block_headers(uint64_t current_height)
 			});
 	}

+	const uint64_t start_height = (current_height > BLOCK_HEADERS_REQUIRED) ? (current_height - BLOCK_HEADERS_REQUIRED) : 0;
+
 	s.m_pos = 0;
-	s << "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"get_block_headers_range\",\"params\":{\"start_height\":" << current_height - BLOCK_HEADERS_REQUIRED << ",\"end_height\":" << current_height - 1 << "}}\0";
+	s << "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"get_block_headers_range\",\"params\":{\"start_height\":" << start_height << ",\"end_height\":" << current_height - 1 << "}}\0";

 	JSONRPCRequest::call(m_params->m_host.c_str(), m_params->m_rpcPort, buf,
-		[this, current_height](const char* data, size_t size)
+		[this, start_height, current_height](const char* data, size_t size)
 		{
-			if (parse_block_headers_range(data, size) == BLOCK_HEADERS_REQUIRED) {
+			if (parse_block_headers_range(data, size) == current_height - start_height) {
 				update_median_timestamp();
 				if (m_serversStarted.exchange(1) == 0) {
-					m_ZMQReader = new ZMQReader(m_params->m_host.c_str(), m_params->m_zmqPort, this);
+					try {
+						m_ZMQReader = new ZMQReader(m_params->m_host.c_str(), m_params->m_zmqPort, this);
+					}
+					catch (const std::exception& e) {
+						LOGERR(1, "Couldn't start ZMQ reader: exception " << e.what());
+						panic();
+					}
+
 					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();
 				}
 			}
 			else {
-				LOGERR(1, "fatal error: couldn't download block headers for heights " << current_height - BLOCK_HEADERS_REQUIRED << " - " << current_height - 1);
+				LOGERR(1, "fatal error: couldn't download block headers for heights " << start_height << " - " << current_height - 1);
 				panic();
 			}
 		},
-		[current_height](const char* data, size_t size)
+		[start_height, current_height](const char* data, size_t size)
 		{
 			if (size > 0) {
-				LOGERR(1, "fatal error: couldn't download block headers for heights " << current_height - BLOCK_HEADERS_REQUIRED << " - " << current_height - 1 << ", error " << log::const_buf(data, size));
+				LOGERR(1, "fatal error: couldn't download block headers for heights " << start_height << " - " << current_height - 1 << ", error " << log::const_buf(data, size));
 				panic();
 			}
 		});
@@ -658,6 +710,7 @@ void p2pool::update_median_timestamp()
 	uint64_t timestamps[TIMESTAMP_WINDOW];
 	if (!get_timestamps(timestamps))
 	{
+		WriteLock lock(m_minerDataLock);
 		m_minerData.median_timestamp = 0;
 		return;
 	}
@@ -665,15 +718,25 @@ void p2pool::update_median_timestamp()
 	std::sort(timestamps, timestamps + TIMESTAMP_WINDOW);

 	// Shift it +1 block compared to Monero's code because we don't have the latest block yet when we receive new miner data
-	m_minerData.median_timestamp = (timestamps[TIMESTAMP_WINDOW / 2] + timestamps[TIMESTAMP_WINDOW / 2 + 1]) / 2;
-	LOGINFO(4, "median timestamp updated to " << log::Gray() << m_minerData.median_timestamp);
+	const uint64_t ts = (timestamps[TIMESTAMP_WINDOW / 2] + timestamps[TIMESTAMP_WINDOW / 2 + 1]) / 2;
+	LOGINFO(4, "median timestamp updated to " << log::Gray() << ts);
+
+	WriteLock lock(m_minerDataLock);
+	m_minerData.median_timestamp = ts;
 }

 void p2pool::stratum_on_block()
 {
-	if (m_miner) {
-		m_miner->on_block(*m_blockTemplate);
+#ifdef WITH_RANDOMX
+	{
+		MutexLock lock(m_minerLock);
+
+		if (m_miner) {
+			m_miner->on_block(*m_blockTemplate);
+		}
 	}
+#endif
+
 	if (m_stratumServer) {
 		m_stratumServer->on_block(*m_blockTemplate);
 	}
@@ -849,6 +912,8 @@ void p2pool::parse_get_version_rpc(const char* data, size_t size)

 void p2pool::get_miner_data()
 {
+	m_getMinerDataPending = true;
+
 	JSONRPCRequest::call(m_params->m_host.c_str(), m_params->m_rpcPort, "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"get_miner_data\"}",
 		[this](const char* data, size_t size)
 		{
@@ -861,11 +926,22 @@ void p2pool::get_miner_data()
 				std::this_thread::sleep_for(std::chrono::milliseconds(1000));
 				get_miner_data();
 			}
+			else {
+				m_getMinerDataPending = false;
+			}
 		});
 }

 void p2pool::parse_get_miner_data_rpc(const char* data, size_t size)
 {
+	hash h;
+	keccak(reinterpret_cast<const uint8_t*>(data), static_cast<int>(size), h.h, HASH_SIZE);
+	if (h == m_getMinerDataHash) {
+		LOGWARN(4, "Received a duplicate get_miner_data RPC response, ignoring it");
+		return;
+	}
+	m_getMinerDataHash = h;
+
 	rapidjson::Document doc;
 	doc.Parse<rapidjson::kParseCommentsFlag | rapidjson::kParseTrailingCommasFlag>(data, size);

@@ -1011,10 +1087,16 @@ void p2pool::api_update_network_stats()
 		return;
 	}

+	hash prev_id;
+	{
+		ReadLock lock(m_minerDataLock);
+		prev_id = m_minerData.prev_id;
+	}
+
 	ChainMain mainnet_tip;
 	{
 		ReadLock lock(m_mainchainLock);
-		mainnet_tip = m_mainchainByHash[m_minerData.prev_id];
+		mainnet_tip = m_mainchainByHash[prev_id];
 	}

 	m_api->set(p2pool_api::Category::NETWORK, "stats",
@@ -1076,10 +1158,16 @@ void p2pool::api_update_stats_mod()
 		return;
 	}

+	hash prev_id;
+	{
+		ReadLock lock(m_minerDataLock);
+		prev_id = m_minerData.prev_id;
+	}
+
 	ChainMain mainnet_tip;
 	{
 		ReadLock lock(m_mainchainLock);
-		mainnet_tip = m_mainchainByHash[m_minerData.prev_id];
+		mainnet_tip = m_mainchainByHash[prev_id];
 	}

 	time_t last_block_found_time = 0;
@@ -1090,10 +1178,11 @@ void p2pool::api_update_stats_mod()
 	{
 		MutexLock lock(m_foundBlocksLock);
 		if (!m_foundBlocks.empty()) {
-			last_block_found_time = m_foundBlocks.back().timestamp;
-			last_block_found_height = m_foundBlocks.back().height;
-			last_block_found_hash = m_foundBlocks.back().id;
-			last_block_total_hashes = m_foundBlocks.back().total_hashes;
+			const FoundBlock& b = m_foundBlocks.back();
+			last_block_found_time = b.timestamp;
+			last_block_found_height = b.height;
+			last_block_found_hash = b.id;
+			last_block_total_hashes = b.total_hashes;
 		}
 	}

@@ -1219,20 +1308,25 @@ 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();
+
+	MutexLock lock(m_minerLock);
 	m_miner = new Miner(this, threads);
 }

 void p2pool::stop_mining()
 {
-	Miner* miner = m_miner;
-	if (miner) {
+	MutexLock lock(m_minerLock);
+
+	if (m_miner) {
+		delete m_miner;
 		m_miner = nullptr;
-		delete miner;
 	}
 }
+#endif

 static void on_signal(uv_signal_t* handle, int signum)
 {
@@ -1276,6 +1370,10 @@ static bool init_uv_threadpool()

 static bool init_signals(p2pool* pool)
 {
+#ifdef SIGPIPE
+	signal(SIGPIPE, SIG_IGN);
+#endif
+
 	constexpr int signal_names[] = {
 		SIGHUP,
 		SIGINT,
@@ -1308,6 +1406,29 @@ void p2pool::stop()
 	uv_async_send(&m_stopAsync);
 }

+void p2pool::restart_zmq()
+{
+	if (!is_main_thread()) {
+		uv_async_send(&m_restartZMQAsync);
+		return;
+	}
+
+	if (!m_getMinerDataPending) {
+		get_miner_data();
+	}
+
+	delete m_ZMQReader;
+	m_ZMQReader = nullptr;
+
+	try {
+		m_ZMQReader = new ZMQReader(m_params->m_host.c_str(), m_params->m_zmqPort, this);
+		m_zmqLastActive = seconds_since_epoch();
+	}
+	catch (const std::exception& e) {
+		LOGERR(1, "Couldn't restart ZMQ reader: exception " << e.what());
+	}
+}
+
 int p2pool::run()
 {
 	if (!m_params->ok()) {
@@ -1342,7 +1463,9 @@ int p2pool::run()

 	bkg_jobs_tracker.wait();

+#ifdef WITH_RANDOMX
 	delete m_miner;
+#endif
 	delete m_stratumServer;
 	delete m_p2pServer;

@@ -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,7 +48,12 @@ public:
 	const Params& params() const { return *m_params; }
 	BlockTemplate& block_template() { return *m_blockTemplate; }
 	SideChain& side_chain() { return *m_sideChain; }
-	const MinerData& miner_data() const { return m_minerData; }
+
+	FORCEINLINE MinerData miner_data() const
+	{
+		ReadLock lock(m_minerDataLock);
+		return m_minerData;
+	}

 	p2pool_api* api() const { return m_api; }

@@ -59,7 +64,10 @@ public:

 	StratumServer* stratum_server() const { return m_stratumServer; }
 	P2PServer* p2p_server() const { return m_p2pServer; }
-	Miner* miner() const { return m_miner; }
+
+#ifdef WITH_RANDOMX
+	void print_miner_status();
+#endif

 	virtual void handle_tx(TxMempoolData& tx) override;
 	virtual void handle_miner_data(MinerData& data) override;
@@ -80,11 +88,14 @@ 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; }
+	void restart_zmq();

 private:
 	p2pool(const p2pool&) = delete;
@@ -93,6 +104,7 @@ private:
 	static void on_submit_block(uv_async_t* async) { reinterpret_cast<p2pool*>(async->data)->submit_block(); }
 	static void on_update_block_template(uv_async_t* async) { reinterpret_cast<p2pool*>(async->data)->update_block_template(); }
 	static void on_stop(uv_async_t*);
+	static void on_restart_zmq(uv_async_t* async) { reinterpret_cast<p2pool*>(async->data)->restart_zmq(); }

 	void submit_block() const;

@@ -104,7 +116,6 @@ private:
 	SideChain* m_sideChain;
 	RandomX_Hasher_Base* m_hasher;
 	BlockTemplate* m_blockTemplate;
-	MinerData m_minerData;
 	bool m_updateSeed;
 	Mempool* m_mempool;

@@ -112,6 +123,9 @@ private:
 	std::map<uint64_t, ChainMain> m_mainchainByHeight;
 	unordered_map<hash, ChainMain> m_mainchainByHash;

+	mutable uv_rwlock_t m_minerDataLock;
+	MinerData m_minerData;
+
 	enum { TIMESTAMP_WINDOW = 60 };
 	bool get_timestamps(uint64_t (&timestamps)[TIMESTAMP_WINDOW]) const;
 	void update_median_timestamp();
@@ -160,7 +174,11 @@ private:
 	std::atomic<uint32_t> m_serversStarted{ 0 };
 	StratumServer* m_stratumServer = nullptr;
 	P2PServer* m_p2pServer = nullptr;
+
+#ifdef WITH_RANDOMX
+	uv_mutex_t m_minerLock;
 	Miner* m_miner = nullptr;
+#endif

 	ConsoleCommands* m_consoleCommands;

@@ -179,10 +197,14 @@ private:
 	uv_async_t m_blockTemplateAsync;
 	uv_async_t m_stopAsync;

-	time_t m_zmqLastActive;
-	time_t m_startTime;
+	std::atomic<uint64_t> m_zmqLastActive;
+	uint64_t m_startTime;
+	uv_async_t m_restartZMQAsync;

 	ZMQReader* m_ZMQReader = nullptr;
+
+	hash m_getMinerDataHash;
+	bool m_getMinerDataPending = false;
 };

 } // namespace p2pool
@@ -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
@@ -131,12 +131,10 @@ void p2pool_api::dump_to_file()
 	{
 		MutexLock lock(m_dumpDataLock);
 		data = std::move(m_dumpData);
-		// cppcheck-suppress accessMoved
 		m_dumpData.clear();
 	}

 	for (auto& it : data) {
-		// cppcheck-suppress uninitvar
 		DumpFileWork* work = new DumpFileWork{ {}, {}, {}, it.first, std::move(it.second) };
 		work->open_req.data = work;
 		work->write_req.data = work;
@@ -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
@@ -34,6 +34,7 @@ public:
 		LOCAL,
 	};

+	// cppcheck-suppress functionConst
 	void on_stop();

 	template<typename T>
@@ -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
@@ -125,10 +125,15 @@ Params::Params(int argc, char* argv[])
 			ok = true;
 		}

+		if (strcmp(argv[i], "--no-autodiff") == 0) {
+			m_autoDiff = false;
+			ok = true;
+		}
+
 		if (!ok) {
 			fprintf(stderr, "Unknown command line parameter %s\n\n", argv[i]);
 			p2pool_usage();
-			panic();
+			throw std::exception();
 		}
 	}

@@ -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,11 +39,16 @@ 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;
 	bool m_mini = false;
+	bool m_autoDiff = true;
 };

 } // namespace p2pool
@@ -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);
@@ -157,8 +157,12 @@ void PoolBlock::serialize_mainchain_data(uint32_t nonce, uint32_t extra_nonce, c

 	for (TxOutput& output : m_outputs) {
 		writeVarint(output.m_reward, m_mainChainData);
-		m_mainChainData.push_back(TXOUT_TO_KEY);
+		m_mainChainData.push_back(output.m_txType);
 		m_mainChainData.insert(m_mainChainData.end(), output.m_ephPublicKey.h, output.m_ephPublicKey.h + HASH_SIZE);
+
+		if (output.m_txType == TXOUT_TO_TAGGED_KEY) {
+			m_mainChainData.push_back(output.m_viewTag);
+		}
 	}

 	m_mainChainOutputsBlobSize = static_cast<int>(m_mainChainData.size()) - m_mainChainOutputsOffset;
@@ -301,9 +305,19 @@ bool PoolBlock::get_pow_hash(RandomX_Hasher_Base* hasher, uint64_t height, const
 uint64_t PoolBlock::get_payout(const Wallet& w) const
 {
 	for (size_t i = 0, n = m_outputs.size(); i < n; ++i) {
+		const TxOutput& out = m_outputs[i];
 		hash eph_public_key;
-		if ((w.get_eph_public_key(m_txkeySec, i, eph_public_key)) && (eph_public_key == m_outputs[i].m_ephPublicKey)) {
-			return m_outputs[i].m_reward;
+
+		if (out.m_txType == TXOUT_TO_TAGGED_KEY) {
+			if (w.get_eph_public_key_with_view_tag(m_txkeySec, i, eph_public_key, out.m_viewTag) && (eph_public_key == out.m_ephPublicKey)) {
+				return out.m_reward;
+			}
+		}
+		else {
+			uint8_t view_tag;
+			if (w.get_eph_public_key(m_txkeySec, i, eph_public_key, view_tag) && (eph_public_key == out.m_ephPublicKey)) {
+				return out.m_reward;
+			}
 		}
 	}

@@ -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
@@ -81,11 +81,13 @@ struct PoolBlock

 	struct TxOutput
 	{
-		FORCEINLINE TxOutput() : m_reward(0), m_ephPublicKey() {}
-		FORCEINLINE TxOutput(uint64_t r, const hash& k) : m_reward(r), m_ephPublicKey(k) {}
+		FORCEINLINE TxOutput() : m_reward(0), m_ephPublicKey(), m_txType(0), m_viewTag(0) {}
+		FORCEINLINE TxOutput(uint64_t r, const hash& k, uint8_t tx_type, uint8_t view_tag) : m_reward(r), m_ephPublicKey(k), m_txType(tx_type), m_viewTag(view_tag) {}

 		uint64_t m_reward;
 		hash m_ephPublicKey;
+		uint8_t m_txType;
+		uint8_t m_viewTag;
 	};

 	std::vector<TxOutput> m_outputs;
@@ -130,7 +132,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();
@@ -139,6 +141,10 @@ struct PoolBlock
 	bool get_pow_hash(RandomX_Hasher_Base* hasher, uint64_t height, const hash& seed_hash, hash& pow_hash);

 	uint64_t get_payout(const Wallet& w) const;
+
+	// Both tx types are allowed by Monero consensus during v15 because it needs to process pre-fork mempool transactions,
+	// but P2Pool can switch to using only TXOUT_TO_TAGGED_KEY for miner payouts starting from v15
+	FORCEINLINE uint8_t get_tx_type() const { return (m_majorVersion < HARDFORK_VIEW_TAGS_VERSION) ? TXOUT_TO_KEY : TXOUT_TO_TAGGED_KEY; }
 };

 } // namespace p2pool
@@ -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
@@ -46,29 +46,7 @@ int PoolBlock::deserialize(const uint8_t* data, size_t size, SideChain& sidechai
 #define READ_BYTE(x) do { if (!read_byte(x)) return __LINE__; } while (0)
 #define EXPECT_BYTE(value) do { uint8_t tmp; READ_BYTE(tmp); if (tmp != (value)) return __LINE__; } while (0)

-		auto read_varint = [&data, data_end](auto& b) -> bool
-		{
-			uint64_t result = 0;
-			int k = 0;
-
-			while (data < data_end) {
-				if (k >= static_cast<int>(sizeof(b)) * 8) {
-					return false;
-				}
-
-				const uint64_t cur_byte = *(data++);
-				result |= (cur_byte & 0x7F) << k;
-				k += 7;
-
-				if ((cur_byte & 0x80) == 0) {
-					b = result;
-					return true;
-				}
-			}
-			return false;
-		};
-
-#define READ_VARINT(x) do { if (!read_varint(x)) return __LINE__; } while(0)
+#define READ_VARINT(x) do { data = readVarint(data, data_end, x); if (!data) return __LINE__; } while(0)

 		auto read_buf = [&data, data_end](void* buf, size_t size) -> bool
 		{
@@ -121,7 +99,7 @@ int PoolBlock::deserialize(const uint8_t* data, size_t size, SideChain& sidechai
 		if (num_outputs > 0) {
 			// Outputs are in the buffer, just read them
 			// Each output is at least 34 bytes, exit early if there's not enough data left
-			// 1 byte for reward, 1 byte for TXOUT_TO_KEY, 32 bytes for eph_pub_key
+			// 1 byte for reward, 1 byte for tx_type, 32 bytes for eph_pub_key
 			constexpr uint64_t MIN_OUTPUT_SIZE = 34;

 			if (num_outputs > std::numeric_limits<uint64_t>::max() / MIN_OUTPUT_SIZE) return __LINE__;
@@ -130,15 +108,23 @@ int PoolBlock::deserialize(const uint8_t* data, size_t size, SideChain& sidechai
 			m_outputs.clear();
 			m_outputs.reserve(num_outputs);

+			const uint8_t expected_tx_type = get_tx_type();
+
 			for (uint64_t i = 0; i < num_outputs; ++i) {
 				TxOutput t;

 				READ_VARINT(t.m_reward);
 				total_reward += t.m_reward;

-				EXPECT_BYTE(TXOUT_TO_KEY);
+				EXPECT_BYTE(expected_tx_type);
+				t.m_txType = expected_tx_type;
+
 				READ_BUF(t.m_ephPublicKey.h, HASH_SIZE);

+				if (expected_tx_type == TXOUT_TO_TAGGED_KEY) {
+					READ_BYTE(t.m_viewTag);
+				}
+
 				m_outputs.emplace_back(std::move(t));
 			}

@@ -187,7 +173,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);
@@ -201,7 +187,6 @@ int PoolBlock::deserialize(const uint8_t* data, size_t size, SideChain& sidechai
 		const int sidechain_hash_offset = static_cast<int>((data - data_begin) + outputs_blob_size_diff);
 		READ_BUF(m_sidechainId.h, HASH_SIZE);

-		// cppcheck-suppress duplicateExpression
 		if (static_cast<uint64_t>(data - tx_extra_begin) != tx_extra_size) return __LINE__;

 		EXPECT_BYTE(0);
@@ -350,7 +335,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;
 }
@@ -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;

@@ -176,7 +180,6 @@ void RandomX_Hasher::set_seed(const hash& seed)
 	}

 	{
-		// cppcheck-suppress unreadVariable
 		ON_SCOPE_LEAVE([this]() { uv_rwlock_wrunlock(&m_cacheLock); });

 		if (m_stopped.load()) {
@@ -220,6 +223,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 +279,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 +287,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;

@@ -316,7 +326,6 @@ bool RandomX_Hasher::calculate(const void* data, size_t size, uint64_t /*height*
 {
 	// First try to use the dataset if it's ready
 	if (uv_rwlock_tryrdlock(&m_datasetLock) == 0) {
-		// cppcheck-suppress unreadVariable
 		ON_SCOPE_LEAVE([this]() { uv_rwlock_rdunlock(&m_datasetLock); });

 		if (m_stopped.load()) {
@@ -357,6 +366,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)
@@ -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
 {
@@ -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,10 +21,12 @@
 #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"
@@ -58,7 +60,8 @@ static constexpr uint8_t mini_consensus_id[HASH_SIZE] = { 57,130,201,26,149,174,
 SideChain::SideChain(p2pool* pool, NetworkType type, const char* pool_name)
 	: m_pool(pool)
 	, m_networkType(type)
-	, m_chainTip(nullptr)
+	, m_chainTip{ nullptr }
+	, m_seenWalletsLastPruneTime(0)
 	, m_poolName(pool_name ? pool_name : "default")
 	, m_targetBlockTime(10)
 	, m_minDifficulty(MIN_DIFFICULTY, 0)
@@ -76,12 +79,12 @@ SideChain::SideChain(p2pool* pool, NetworkType type, const char* pool_name)
 		panic();
 	}

-	uv_mutex_init_checked(&m_sidechainLock);
+	uv_rwlock_init_checked(&m_sidechainLock);
+	uv_mutex_init_checked(&m_seenWalletsLock);
 	uv_mutex_init_checked(&m_seenBlocksLock);
+	uv_rwlock_init_checked(&m_curDifficultyLock);

 	m_difficultyData.reserve(m_chainWindowSize);
-	m_tmpShares.reserve(m_chainWindowSize * 2);
-	m_tmpRewards.reserve(m_chainWindowSize * 2);

 	LOGINFO(1, "generating consensus ID");

@@ -108,6 +111,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) {
@@ -142,6 +146,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;
@@ -149,27 +157,32 @@ 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()
 {
-	uv_mutex_destroy(&m_sidechainLock);
+	uv_rwlock_destroy(&m_sidechainLock);
+	uv_mutex_destroy(&m_seenWalletsLock);
 	uv_mutex_destroy(&m_seenBlocksLock);
-	for (auto& it : m_blocksById) {
+	uv_rwlock_destroy(&m_curDifficultyLock);
+	for (const auto& it : m_blocksById) {
 		delete it.second;
 	}
 }

-void SideChain::fill_sidechain_data(PoolBlock& block, Wallet* w, const hash& txkeySec, std::vector<MinerShare>& shares)
+void SideChain::fill_sidechain_data(PoolBlock& block, const Wallet* w, const hash& txkeySec, std::vector<MinerShare>& shares) const
 {
-	MutexLock lock(m_sidechainLock);
+	ReadLock lock(m_sidechainLock);

 	block.m_minerWallet = *w;
 	block.m_txkeySec = txkeySec;
 	block.m_uncles.clear();

-	if (!m_chainTip) {
+	const PoolBlock* tip = m_chainTip;
+
+	if (!tip) {
 		block.m_parent = {};
 		block.m_sidechainHeight = 0;
 		block.m_difficulty = m_minDifficulty;
@@ -179,8 +192,8 @@ void SideChain::fill_sidechain_data(PoolBlock& block, Wallet* w, const hash& txk
 		return;
 	}

-	block.m_parent = m_chainTip->m_sidechainId;
-	block.m_sidechainHeight = m_chainTip->m_sidechainHeight + 1;
+	block.m_parent = tip->m_sidechainId;
+	block.m_sidechainHeight = tip->m_sidechainHeight + 1;

 	// Collect uncles from 3 previous block heights

@@ -188,15 +201,19 @@ void SideChain::fill_sidechain_data(PoolBlock& block, Wallet* w, const hash& txk
 	std::vector<hash> mined_blocks;
 	mined_blocks.reserve(UNCLE_BLOCK_DEPTH * 2 + 1);

-	PoolBlock* tmp = m_chainTip;
-	for (uint64_t i = 0, n = std::min<uint64_t>(UNCLE_BLOCK_DEPTH, m_chainTip->m_sidechainHeight + 1); tmp && (i < n); ++i) {
+	const PoolBlock* tmp = tip;
+	for (uint64_t i = 0, n = std::min<uint64_t>(UNCLE_BLOCK_DEPTH, tip->m_sidechainHeight + 1); tmp && (i < n); ++i) {
 		mined_blocks.push_back(tmp->m_sidechainId);
 		mined_blocks.insert(mined_blocks.end(), tmp->m_uncles.begin(), tmp->m_uncles.end());
 		tmp = get_parent(tmp);
 	}

-	for (uint64_t i = 0, n = std::min<uint64_t>(UNCLE_BLOCK_DEPTH, m_chainTip->m_sidechainHeight + 1); i < n; ++i) {
-		for (PoolBlock* uncle : m_blocksByHeight[m_chainTip->m_sidechainHeight - i]) {
+	for (uint64_t i = 0, n = std::min<uint64_t>(UNCLE_BLOCK_DEPTH, tip->m_sidechainHeight + 1); i < n; ++i) {
+		auto it = m_blocksByHeight.find(tip->m_sidechainHeight - i);
+		if (it == m_blocksByHeight.end()) {
+			continue;
+		}
+		for (const PoolBlock* uncle : it->second) {
 			// Only add verified and valid blocks
 			if (!uncle || !uncle->m_verified || uncle->m_invalid) {
 				continue;
@@ -210,17 +227,14 @@ void SideChain::fill_sidechain_data(PoolBlock& block, Wallet* w, const hash& txk
 			// Only add it if it's on the same chain
 			bool same_chain = false;
 			do {
-				tmp = m_chainTip;
-				while (tmp->m_sidechainHeight > uncle->m_sidechainHeight) {
+				tmp = tip;
+				while (tmp && (tmp->m_sidechainHeight > uncle->m_sidechainHeight)) {
 					tmp = get_parent(tmp);
-					if (!tmp) {
-						break;
-					}
 				}
 				if (!tmp || (tmp->m_sidechainHeight < uncle->m_sidechainHeight)) {
 					break;
 				}
-				PoolBlock* tmp2 = uncle;
+				const PoolBlock* tmp2 = uncle;
 				for (size_t j = 0; (j < UNCLE_BLOCK_DEPTH) && tmp && tmp2 && (tmp->m_sidechainHeight + UNCLE_BLOCK_DEPTH >= block.m_sidechainHeight); ++j) {
 					if (tmp->m_parent == tmp2->m_parent) {
 						same_chain = true;
@@ -253,8 +267,8 @@ void SideChain::fill_sidechain_data(PoolBlock& block, Wallet* w, const hash& txk
 		block.m_uncles.erase(std::unique(block.m_uncles.begin(), block.m_uncles.end()), block.m_uncles.end());
 	}

-	block.m_difficulty = m_curDifficulty;
-	block.m_cumulativeDifficulty = m_chainTip->m_cumulativeDifficulty + block.m_difficulty;
+	block.m_difficulty = difficulty();
+	block.m_cumulativeDifficulty = tip->m_cumulativeDifficulty + block.m_difficulty;

 	for (const hash& uncle_id : block.m_uncles) {
 		auto it = m_blocksById.find(uncle_id);
@@ -359,6 +373,7 @@ bool SideChain::block_seen(const PoolBlock& block)
 {
 	// Check if it's some old block
 	const PoolBlock* tip = m_chainTip;
+
 	if (tip && tip->m_sidechainHeight > block.m_sidechainHeight + m_chainWindowSize * 2 &&
 		block.m_cumulativeDifficulty < tip->m_cumulativeDifficulty) {
 		return true;
@@ -384,9 +399,10 @@ bool SideChain::add_external_block(PoolBlock& block, std::vector<hash>& missing_
 		return false;
 	}

-	bool too_low_diff = (block.m_difficulty < m_curDifficulty);
+	const difficulty_type expected_diff = difficulty();
+	bool too_low_diff = (block.m_difficulty < expected_diff);
 	{
-		MutexLock lock(m_sidechainLock);
+		ReadLock lock(m_sidechainLock);
 		if (m_blocksById.find(block.m_sidechainId) != m_blocksById.end()) {
 			LOGINFO(4, "add_external_block: block " << block.m_sidechainId << " is already added");
 			return true;
@@ -398,7 +414,9 @@ bool SideChain::add_external_block(PoolBlock& block, std::vector<hash>& missing_
 			difficulty_type diff2 = block.m_difficulty;
 			diff2 += block.m_difficulty;

-			for (PoolBlock* tmp = m_chainTip; tmp && (tmp->m_sidechainHeight + m_chainWindowSize > m_chainTip->m_sidechainHeight); tmp = get_parent(tmp)) {
+			const PoolBlock* tip = m_chainTip;
+
+			for (const PoolBlock* tmp = tip; tmp && (tmp->m_sidechainHeight + m_chainWindowSize > tip->m_sidechainHeight); tmp = get_parent(tmp)) {
 				if (diff2 >= tmp->m_difficulty) {
 					too_low_diff = false;
 					break;
@@ -410,7 +428,7 @@ bool SideChain::add_external_block(PoolBlock& block, std::vector<hash>& missing_
 	LOGINFO(4, "add_external_block: height = " << block.m_sidechainHeight << ", id = " << block.m_sidechainId << ", mainchain height = " << block.m_txinGenHeight);

 	if (too_low_diff) {
-		LOGWARN(4, "add_external_block: block has too low difficulty " << block.m_difficulty << ", expected >= ~" << m_curDifficulty << ". Ignoring it.");
+		LOGWARN(4, "add_external_block: block has too low difficulty " << block.m_difficulty << ", expected >= ~" << expected_diff << ". Ignoring it.");
 		return true;
 	}

@@ -441,7 +459,7 @@ bool SideChain::add_external_block(PoolBlock& block, std::vector<hash>& missing_
 	}

 	// Check if it has the correct parent and difficulty to go right to monerod for checking
-	const MinerData& miner_data = m_pool->miner_data();
+	MinerData miner_data = m_pool->miner_data();
 	if ((block.m_prevId == miner_data.prev_id) && miner_data.difficulty.check_pow(pow_hash)) {
 		LOGINFO(0, log::LightGreen() << "add_external_block: block " << block.m_sidechainId << " has enough PoW for Monero network, submitting it");
 		m_pool->submit_block_async(block.m_mainChainData);
@@ -466,7 +484,7 @@ bool SideChain::add_external_block(PoolBlock& block, std::vector<hash>& missing_

 	missing_blocks.clear();
 	{
-		MutexLock lock(m_sidechainLock);
+		WriteLock lock(m_sidechainLock);
 		if (!block.m_parent.empty() && (m_blocksById.find(block.m_parent) == m_blocksById.end())) {
 			missing_blocks.push_back(block.m_parent);
 		}
@@ -506,14 +524,13 @@ 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_seenWalletsLock);
+		m_seenWallets[new_block->m_minerWallet.spend_public_key()] = new_block->m_localTimestamp;
 	}

-	PoolBlock* new_block = new PoolBlock(block);
-
-	MutexLock lock(m_sidechainLock);
+	WriteLock lock(m_sidechainLock);

 	auto result = m_blocksById.insert({ new_block->m_sidechainId, new_block });
 	if (!result.second) {
@@ -533,18 +550,21 @@ 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 {
 		verify_loop(new_block);
 	}
-
-	m_seenWallets[new_block->m_minerWallet.spend_public_key()] = new_block->m_localTimestamp;
 }

-PoolBlock* SideChain::find_block(const hash& id)
+PoolBlock* SideChain::find_block(const hash& id) const
 {
-	MutexLock lock(m_sidechainLock);
+	ReadLock lock(m_sidechainLock);

 	auto it = m_blocksById.find(id);
 	if (it != m_blocksById.end()) {
@@ -556,20 +576,25 @@ PoolBlock* SideChain::find_block(const hash& id)

 void SideChain::watch_mainchain_block(const ChainMain& data, const hash& possible_id)
 {
-	MutexLock lock(m_sidechainLock);
+	WriteLock lock(m_sidechainLock);
 	m_watchBlock = data;
 	m_watchBlockSidechainId = possible_id;
 }

-bool SideChain::get_block_blob(const hash& id, std::vector<uint8_t>& blob)
+bool SideChain::get_block_blob(const hash& id, std::vector<uint8_t>& blob) const
 {
-	MutexLock lock(m_sidechainLock);
+	ReadLock lock(m_sidechainLock);

-	PoolBlock* block = nullptr;
+	const PoolBlock* block = nullptr;

 	// Empty hash means we return current sidechain tip
-	if (id == hash()) {
+	if (id.empty()) {
 		block = m_chainTip;
+
+		// Don't return stale chain tip
+		if (block && (block->m_txinGenHeight + 2 < m_pool->miner_data().height)) {
+			return false;
+		}
 	}
 	else {
 		auto it = m_blocksById.find(id);
@@ -589,76 +614,94 @@ bool SideChain::get_block_blob(const hash& id, std::vector<uint8_t>& blob)
 	return true;
 }

-bool SideChain::get_outputs_blob(PoolBlock* block, uint64_t total_reward, std::vector<uint8_t>& blob)
+bool SideChain::get_outputs_blob(PoolBlock* block, uint64_t total_reward, std::vector<uint8_t>& blob) const
 {
 	blob.clear();

-	MutexLock lock(m_sidechainLock);
+	ReadLock lock(m_sidechainLock);

 	auto it = m_blocksById.find(block->m_sidechainId);
 	if (it != m_blocksById.end()) {
 		PoolBlock* b = it->second;
 		const size_t n = b->m_outputs.size();

-		blob.reserve(n * 38 + 64);
+		blob.reserve(n * 39 + 64);
 		writeVarint(n, blob);

 		for (const PoolBlock::TxOutput& output : b->m_outputs) {
 			writeVarint(output.m_reward, blob);
-			blob.emplace_back(TXOUT_TO_KEY);
+			blob.emplace_back(output.m_txType);
 			blob.insert(blob.end(), output.m_ephPublicKey.h, output.m_ephPublicKey.h + HASH_SIZE);
+
+			if (output.m_txType == TXOUT_TO_TAGGED_KEY) {
+				blob.emplace_back(output.m_viewTag);
+			}
 		}

 		block->m_outputs = b->m_outputs;
 		return true;
 	}

-	if (!get_shares(block, m_tmpShares) || !split_reward(total_reward, m_tmpShares, m_tmpRewards) || (m_tmpRewards.size() != m_tmpShares.size())) {
+	std::vector<MinerShare> tmpShares;
+	std::vector<uint64_t> tmpRewards;
+
+	if (!get_shares(block, tmpShares) || !split_reward(total_reward, tmpShares, tmpRewards) || (tmpRewards.size() != tmpShares.size())) {
 		return false;
 	}

-	const size_t n = m_tmpShares.size();
+	const size_t n = tmpShares.size();

-	blob.reserve(n * 38 + 64);
+	blob.reserve(n * 39 + 64);

 	writeVarint(n, blob);

 	block->m_outputs.clear();
 	block->m_outputs.reserve(n);

+	const uint8_t tx_type = block->get_tx_type();
+
 	hash eph_public_key;
 	for (size_t i = 0; i < n; ++i) {
-		writeVarint(m_tmpRewards[i], blob);
+		writeVarint(tmpRewards[i], blob);

-		blob.emplace_back(TXOUT_TO_KEY);
+		blob.emplace_back(tx_type);

-		if (!m_tmpShares[i].m_wallet->get_eph_public_key(block->m_txkeySec, i, eph_public_key)) {
+		uint8_t view_tag;
+		if (!tmpShares[i].m_wallet->get_eph_public_key(block->m_txkeySec, i, eph_public_key, view_tag)) {
 			LOGWARN(6, "get_eph_public_key failed at index " << i);
 		}
 		blob.insert(blob.end(), eph_public_key.h, eph_public_key.h + HASH_SIZE);

-		block->m_outputs.emplace_back(m_tmpRewards[i], eph_public_key);
+		if (tx_type == TXOUT_TO_TAGGED_KEY) {
+			blob.emplace_back(view_tag);
+		}
+
+		block->m_outputs.emplace_back(tmpRewards[i], eph_public_key, tx_type, view_tag);
 	}

 	return true;
 }

-void SideChain::print_status()
+void SideChain::print_status() const
 {
 	std::vector<hash> blocks_in_window;
 	blocks_in_window.reserve(m_chainWindowSize * 9 / 8);

-	MutexLock lock(m_sidechainLock);
+	const difficulty_type diff = difficulty();
+
+	ReadLock lock(m_sidechainLock);

 	uint64_t rem;
-	uint64_t pool_hashrate = udiv128(m_curDifficulty.hi, m_curDifficulty.lo, m_targetBlockTime, &rem);
+	uint64_t pool_hashrate = udiv128(diff.hi, diff.lo, m_targetBlockTime, &rem);

-	const difficulty_type& network_diff = m_pool->miner_data().difficulty;
+	difficulty_type network_diff = m_pool->miner_data().difficulty;
 	uint64_t network_hashrate = udiv128(network_diff.hi, network_diff.lo, 120, &rem);

+	const PoolBlock* tip = m_chainTip;
+
 	uint64_t block_depth = 0;
-	PoolBlock* cur = m_chainTip;
-	const uint64_t tip_height = m_chainTip ? m_chainTip->m_sidechainHeight : 0;
+	const PoolBlock* cur = tip;
+	const uint64_t tip_height = tip ? tip->m_sidechainHeight : 0;

 	uint32_t total_blocks_in_window = 0;
 	uint32_t total_uncles_in_window = 0;
@@ -707,10 +750,14 @@ void SideChain::print_status()
 	uint64_t your_reward = 0;
 	uint64_t total_reward = 0;

-	if (m_chainTip) {
+	if (tip) {
 		std::sort(blocks_in_window.begin(), blocks_in_window.end());
 		for (uint64_t i = 0; (i < m_chainWindowSize) && (i <= tip_height); ++i) {
-			for (PoolBlock* block : m_blocksByHeight[tip_height - i]) {
+			auto it = m_blocksByHeight.find(tip_height - i);
+			if (it == m_blocksByHeight.end()) {
+				continue;
+			}
+			for (const PoolBlock* block : it->second) {
 				if (!std::binary_search(blocks_in_window.begin(), blocks_in_window.end(), block->m_sidechainId)) {
 					LOGINFO(4, "orphan block at height " << log::Gray() << block->m_sidechainHeight << log::NoColor() << ": " << log::Gray() << block->m_sidechainId);
 					++total_orphans;
@@ -721,15 +768,25 @@ void SideChain::print_status()
 			}
 		}

-		Wallet w = m_pool->params().m_wallet;
-		const std::vector<PoolBlock::TxOutput>& outs = m_chainTip->m_outputs;
+		const Wallet& w = m_pool->params().m_wallet;

 		hash eph_public_key;
-		for (size_t i = 0, n = outs.size(); i < n; ++i) {
-			if (w.get_eph_public_key(m_chainTip->m_txkeySec, i, eph_public_key) && (outs[i].m_ephPublicKey == eph_public_key)) {
-				your_reward = outs[i].m_reward;
+		for (size_t i = 0, n = tip->m_outputs.size(); i < n; ++i) {
+			const PoolBlock::TxOutput& out = tip->m_outputs[i];
+			if (!your_reward) {
+				if (out.m_txType == TXOUT_TO_TAGGED_KEY) {
+					if (w.get_eph_public_key_with_view_tag(tip->m_txkeySec, i, eph_public_key, out.m_viewTag) && (out.m_ephPublicKey == eph_public_key)) {
+						your_reward = out.m_reward;
+					}
+				}
+				else {
+					uint8_t view_tag;
+					if (w.get_eph_public_key(tip->m_txkeySec, i, eph_public_key, view_tag) && (out.m_ephPublicKey == eph_public_key)) {
+						your_reward = out.m_reward;
+					}
+				}
 			}
-			total_reward += outs[i].m_reward;
+			total_reward += out.m_reward;
 		}
 	}

@@ -738,62 +795,107 @@ 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) << ')'
 	);
 }

+double SideChain::get_reward_share(const Wallet& w) const
+{
+	uint64_t reward = 0;
+	uint64_t total_reward = 0;
+	{
+		ReadLock lock(m_sidechainLock);
+
+		const PoolBlock* tip = m_chainTip;
+		if (tip) {
+			hash eph_public_key;
+			for (size_t i = 0, n = tip->m_outputs.size(); i < n; ++i) {
+				const PoolBlock::TxOutput& out = tip->m_outputs[i];
+				if (!reward) {
+					if (out.m_txType == TXOUT_TO_TAGGED_KEY) {
+						if (w.get_eph_public_key_with_view_tag(tip->m_txkeySec, i, eph_public_key, out.m_viewTag) && (out.m_ephPublicKey == eph_public_key)) {
+							reward = out.m_reward;
+						}
+					}
+					else {
+						uint8_t view_tag;
+						if (w.get_eph_public_key(tip->m_txkeySec, i, eph_public_key, view_tag) && (out.m_ephPublicKey == eph_public_key)) {
+							reward = out.m_reward;
+						}
+					}
+				}
+				total_reward += out.m_reward;
+			}
+		}
+	}
+	return total_reward ? (static_cast<double>(reward) / static_cast<double>(total_reward)) : 0.0;
+}
+
 difficulty_type SideChain::total_hashes() const
 {
-	return m_chainTip ? m_chainTip->m_cumulativeDifficulty : difficulty_type();
+	const PoolBlock* tip = m_chainTip;
+	return tip ? tip->m_cumulativeDifficulty : difficulty_type();
 }

 uint64_t SideChain::miner_count()
 {
-	const time_t cur_time = time(nullptr);
+	const uint64_t cur_time = seconds_since_epoch();

-	MutexLock lock(m_sidechainLock);
+	MutexLock lock(m_seenWalletsLock);

-	// Delete wallets that weren't seen for more than 72 hours and return how many remain
-	for (auto it = m_seenWallets.begin(); it != m_seenWallets.end();) {
-		if (it->second + 72 * 60 * 60 <= cur_time) {
-			it = m_seenWallets.erase(it);
-		}
-		else {
-			++it;
+	// Every 5 minutes, delete wallets that weren't seen for more than 72 hours
+	if (m_seenWalletsLastPruneTime + 5 * 60 <= cur_time) {
+		for (auto it = m_seenWallets.begin(); it != m_seenWallets.end();) {
+			if (it->second + 72 * 60 * 60 < cur_time) {
+				it = m_seenWallets.erase(it);
+			}
+			else {
+				++it;
+			}
 		}
+		m_seenWalletsLastPruneTime = cur_time;
 	}

 	return m_seenWallets.size();
 }

-time_t SideChain::last_updated() const
+uint64_t SideChain::last_updated() const
 {
-	return m_chainTip ? m_chainTip->m_localTimestamp : 0;
+	const PoolBlock* tip = m_chainTip;
+	return tip ? tip->m_localTimestamp : 0;
 }

 bool SideChain::is_default() const
@@ -997,17 +1099,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
@@ -1275,7 +1379,13 @@ void SideChain::verify(PoolBlock* block)
 		});

 	std::vector<uint64_t> rewards;
-	split_reward(total_reward, shares, rewards);
+	if (!split_reward(total_reward, shares, rewards)) {
+		LOGWARN(3, "block at height = " << block->m_sidechainHeight <<
+			", id = " << block->m_sidechainId <<
+			", mainchain height = " << block->m_txinGenHeight << ": split_reward failed");
+		block->m_invalid = true;
+		return;
+	}

 	if (rewards.size() != block->m_outputs.size()) {
 		LOGWARN(3, "block at height = " << block->m_sidechainHeight <<
@@ -1287,17 +1397,20 @@ void SideChain::verify(PoolBlock* block)
 	}

 	for (size_t i = 0, n = rewards.size(); i < n; ++i) {
-		if (rewards[i] != block->m_outputs[i].m_reward) {
+		const PoolBlock::TxOutput& out = block->m_outputs[i];
+
+		if (rewards[i] != out.m_reward) {
 			LOGWARN(3, "block at height = " << block->m_sidechainHeight <<
 				", id = " << block->m_sidechainId <<
 				", mainchain height = " << block->m_txinGenHeight <<
-				" has invalid reward at index " << i << ": got " << block->m_outputs[i].m_reward << ", expected " << rewards[i]);
+				" has invalid reward at index " << i << ": got " << out.m_reward << ", expected " << rewards[i]);
 			block->m_invalid = true;
 			return;
 		}

 		hash eph_public_key;
-		if (!shares[i].m_wallet->get_eph_public_key(block->m_txkeySec, i, eph_public_key)) {
+		uint8_t view_tag;
+		if (!shares[i].m_wallet->get_eph_public_key(block->m_txkeySec, i, eph_public_key, view_tag)) {
 			LOGWARN(3, "block at height = " << block->m_sidechainHeight <<
 				", id = " << block->m_sidechainId <<
 				", mainchain height = " << block->m_txinGenHeight <<
@@ -1306,7 +1419,16 @@ void SideChain::verify(PoolBlock* block)
 			return;
 		}

-		if (eph_public_key != block->m_outputs[i].m_ephPublicKey) {
+		if ((out.m_txType == TXOUT_TO_TAGGED_KEY) && (out.m_viewTag != view_tag)) {
+			LOGWARN(3, "block at height = " << block->m_sidechainHeight <<
+				", id = " << block->m_sidechainId <<
+				", mainchain height = " << block->m_txinGenHeight <<
+				" has an incorrect view tag at index " << i);
+			block->m_invalid = true;
+			return;
+		}
+
+		if (eph_public_key != out.m_ephPublicKey) {
 			LOGWARN(3, "block at height = " << block->m_sidechainHeight <<
 				", id = " << block->m_sidechainId <<
 				", mainchain height = " << block->m_txinGenHeight <<
@@ -1332,16 +1454,21 @@ void SideChain::update_chain_tip(PoolBlock* block)
 		return;
 	}

+	const PoolBlock* tip = m_chainTip;
+
 	bool is_alternative;
-	if (is_longer_chain(m_chainTip, block, is_alternative)) {
+	if (is_longer_chain(tip, block, is_alternative)) {
 		difficulty_type diff;
 		if (get_difficulty(block, m_difficultyData, diff)) {
 			m_chainTip = block;
-			m_curDifficulty = diff;
+			{
+				WriteLock lock(m_curDifficultyLock);
+				m_curDifficulty = diff;
+			}

 			LOGINFO(2, "new chain tip: next height = " << log::Gray() << block->m_sidechainHeight + 1 << log::NoColor() <<
-				", next difficulty = " << log::Gray() << m_curDifficulty << log::NoColor() <<
-				", main chain height = " << log::Gray() << m_chainTip->m_txinGenHeight);
+				", next difficulty = " << log::Gray() << diff << log::NoColor() <<
+				", main chain height = " << log::Gray() << block->m_txinGenHeight);

 			block->m_wantBroadcast = true;
 			if (m_pool) {
@@ -1351,18 +1478,19 @@ void SideChain::update_chain_tip(PoolBlock* block)
 				StratumServer* s = m_pool->stratum_server();
 				if (s && is_alternative) {
 					s->reset_share_counters();
+					LOGINFO(0, log::LightCyan() << "SYNCHRONIZED");
 				}
 			}
 			prune_old_blocks();
 		}
 	}
-	else if (block->m_sidechainHeight > m_chainTip->m_sidechainHeight) {
+	else if (block->m_sidechainHeight > tip->m_sidechainHeight) {
 		LOGINFO(4, "block " << block->m_sidechainId <<
 			", height = " << block->m_sidechainHeight <<
-			" is not a longer chain than " << m_chainTip->m_sidechainId <<
-			", height " << m_chainTip->m_sidechainHeight);
+			" is not a longer chain than " << tip->m_sidechainId <<
+			", height " << tip->m_sidechainHeight);
 	}
-	else if (block->m_sidechainHeight + UNCLE_BLOCK_DEPTH > m_chainTip->m_sidechainHeight) {
+	else if (block->m_sidechainHeight + UNCLE_BLOCK_DEPTH > tip->m_sidechainHeight) {
 		LOGINFO(4, "possible uncle block: id = " << log::Gray() << block->m_sidechainId << log::NoColor() <<
 			", height = " << log::Gray() << block->m_sidechainHeight);
 		m_pool->update_block_template_async();
@@ -1403,7 +1531,7 @@ void SideChain::update_chain_tip(PoolBlock* block)
 	}
 }

-PoolBlock* SideChain::get_parent(const PoolBlock* block)
+PoolBlock* SideChain::get_parent(const PoolBlock* block) const
 {
 	if (block) {
 		auto it = m_blocksById.find(block->m_parent);
@@ -1423,13 +1551,15 @@ bool SideChain::is_longer_chain(const PoolBlock* block, const PoolBlock* candida
 	}

 	if (!block) {
+		// Switching from an empty to a non-empty chain
+		is_alternative = true;
 		return true;
 	}

 	// If these two blocks are on the same chain, they must have a common ancestor

 	const PoolBlock* block_ancestor = block;
-	while (block_ancestor->m_sidechainHeight > candidate->m_sidechainHeight) {
+	while (block_ancestor && (block_ancestor->m_sidechainHeight > candidate->m_sidechainHeight)) {
 		const hash& id = block_ancestor->m_parent;
 		block_ancestor = get_parent(block_ancestor);
 		if (!block_ancestor) {
@@ -1495,8 +1625,9 @@ bool SideChain::is_longer_chain(const PoolBlock* block, const PoolBlock* candida
 	}

 	// Final check: candidate chain must be built on top of recent mainchain blocks
-	if (candidate_mainchain_height + 10 < m_pool->miner_data().height) {
-		LOGWARN(3, "received a longer alternative chain but it's stale: height " << candidate_mainchain_height << ", current height " << m_pool->miner_data().height);
+	MinerData data = m_pool->miner_data();
+	if (candidate_mainchain_height + 10 < data.height) {
+		LOGWARN(3, "received a longer alternative chain but it's stale: height " << candidate_mainchain_height << ", current height " << data.height);
 		return false;
 	}

@@ -1577,13 +1708,16 @@ 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) {
+	const PoolBlock* tip = m_chainTip;
+
+	if (tip->m_sidechainHeight < prune_distance) {
 		return;
 	}

-	const uint64_t h = m_chainTip->m_sidechainHeight - prune_distance;
+	const uint64_t h = tip->m_sidechainHeight - prune_distance;

 	uint64_t num_blocks_pruned = 0;

@@ -1592,9 +1726,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);
@@ -1629,11 +1763,11 @@ void SideChain::prune_old_blocks()
 	}
 }

-void SideChain::get_missing_blocks(std::vector<hash>& missing_blocks)
+void SideChain::get_missing_blocks(std::vector<hash>& missing_blocks) const
 {
 	missing_blocks.clear();

-	MutexLock lock(m_sidechainLock);
+	ReadLock lock(m_sidechainLock);

 	for (auto& b : m_blocksById) {
 		if (b.second->m_verified) {
@@ -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,21 +43,22 @@ public:
 	SideChain(p2pool* pool, NetworkType type, const char* pool_name = nullptr);
 	~SideChain();

-	void fill_sidechain_data(PoolBlock& block, Wallet* w, const hash& txkeySec, std::vector<MinerShare>& shares);
+	void fill_sidechain_data(PoolBlock& block, const Wallet* w, const hash& txkeySec, std::vector<MinerShare>& shares) const;

 	bool block_seen(const PoolBlock& block);
 	void unsee_block(const PoolBlock& block);
 	bool add_external_block(PoolBlock& block, std::vector<hash>& missing_blocks);
 	void add_block(const PoolBlock& block);
-	void get_missing_blocks(std::vector<hash>& missing_blocks);
+	void get_missing_blocks(std::vector<hash>& missing_blocks) const;

-	PoolBlock* find_block(const hash& id);
+	PoolBlock* find_block(const hash& id) const;
 	void watch_mainchain_block(const ChainMain& data, const hash& possible_id);

-	bool get_block_blob(const hash& id, std::vector<uint8_t>& blob);
-	bool get_outputs_blob(PoolBlock* block, uint64_t total_reward, std::vector<uint8_t>& blob);
+	bool get_block_blob(const hash& id, std::vector<uint8_t>& blob) const;
+	bool get_outputs_blob(PoolBlock* block, uint64_t total_reward, std::vector<uint8_t>& blob) const;

-	void print_status();
+	void print_status() const;
+	double get_reward_share(const Wallet& w) const;

 	// Consensus ID can be used to spawn independent P2Pools with their own sidechains
 	// It's never sent over the network to avoid revealing it to the possible man in the middle
@@ -65,11 +66,11 @@ public:
 	const std::vector<uint8_t>& consensus_id() const { return m_consensusId; }
 	uint64_t chain_window_size() const { return m_chainWindowSize; }
 	NetworkType network_type() const { return m_networkType; }
-	const difficulty_type& difficulty() const { return m_curDifficulty; }
+	FORCEINLINE difficulty_type difficulty() const { ReadLock lock(m_curDifficultyLock); return m_curDifficulty; }
 	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;

@@ -88,7 +89,7 @@ private:
 	void verify_loop(PoolBlock* block);
 	void verify(PoolBlock* block);
 	void update_chain_tip(PoolBlock* block);
-	PoolBlock* get_parent(const PoolBlock* block);
+	PoolBlock* get_parent(const PoolBlock* block) const;

 	// Checks if "candidate" has longer (higher difficulty) chain than "block"
 	bool is_longer_chain(const PoolBlock* block, const PoolBlock* candidate, bool& is_alternative);
@@ -98,13 +99,14 @@ private:
 	bool load_config(const std::string& filename);
 	bool check_config();

-	mutable uv_mutex_t m_sidechainLock;
-	PoolBlock* m_chainTip;
+	mutable uv_rwlock_t m_sidechainLock;
+	std::atomic<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;
-	std::vector<MinerShare> m_tmpShares;
-	std::vector<uint64_t> m_tmpRewards;
+
+	uv_mutex_t m_seenWalletsLock;
+	unordered_map<hash, uint64_t> m_seenWallets;
+	uint64_t m_seenWalletsLastPruneTime;

 	uv_mutex_t m_seenBlocksLock;
 	unordered_set<hash> m_seenBlocks;
@@ -119,7 +121,9 @@ private:
 	uint64_t m_unclePenalty;

 	std::vector<uint8_t> m_consensusId;
+	std::string m_consensusIdDisplayStr;

+	mutable uv_rwlock_t m_curDifficultyLock;
 	difficulty_type m_curDifficulty;

 	ChainMain m_watchBlock;
@@ -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,9 +27,11 @@ static constexpr char log_category_prefix[] = "StratumServer ";

 static constexpr int DEFAULT_BACKLOG = 128;
 static constexpr uint64_t DEFAULT_BAN_TIME = 600;
+static constexpr uint64_t MIN_DIFF = 1000;
+static constexpr uint64_t AUTO_DIFF_TARGET_TIME = 30;

 // Use short target format (4 bytes) for diff <= 4 million
-static constexpr uint64_t TARGET_4_BYTES_LIMIT = std::numeric_limits<uint64_t>::max() / 4000000;
+static constexpr uint64_t TARGET_4_BYTES_LIMIT = std::numeric_limits<uint64_t>::max() / 4000000 + 1;

 #include "tcp_server.inl"

@@ -38,9 +40,9 @@ namespace p2pool {
 StratumServer::StratumServer(p2pool* pool)
 	: TCPServer(StratumClient::allocate)
 	, m_pool(pool)
+	, m_autoDiff(pool->params().m_autoDiff)
 	, m_extraNonce(0)
-	, m_rd{}
-	, m_rng(m_rd())
+	, m_rng(RandomDeviceSeed::instance)
 	, m_cumulativeHashes(0)
 	, m_cumulativeHashesAtLastShare(0)
 	, m_hashrateDataHead(0)
@@ -51,11 +53,13 @@ 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);
-	uv_mutex_init_checked(&m_submittedSharesPoolLock);
 	uv_rwlock_init_checked(&m_hashrateDataLock);

 	m_submittedSharesPool.resize(10);
@@ -66,7 +70,7 @@ StratumServer::StratumServer(p2pool* pool)
 	const int err = uv_async_init(&m_loop, &m_blobsAsync, on_blobs_ready);
 	if (err) {
 		LOGERR(1, "uv_async_init failed, error " << uv_err_name(err));
-		return;
+		panic();
 	}
 	m_blobsAsync.data = this;
 	m_blobsQueue.reserve(2);
@@ -82,7 +86,6 @@ StratumServer::~StratumServer()

 	uv_mutex_destroy(&m_blobsQueueLock);
 	uv_mutex_destroy(&m_rngLock);
-	uv_mutex_destroy(&m_submittedSharesPoolLock);
 	uv_rwlock_destroy(&m_hashrateDataLock);

 	for (SubmittedShare* share : m_submittedSharesPool) {
@@ -99,6 +102,7 @@ void StratumServer::on_block(const BlockTemplate& block)
 		LOGINFO(4, "no clients connected");
 		return;
 	}
+	m_extraNonce.exchange(num_connections);

 	BlobsData* blobs_data = new BlobsData{};

@@ -110,9 +114,7 @@ void StratumServer::on_block(const BlockTemplate& block)
 	// Even if they do, they'll be added to the beginning of the list and will get their block template in on_login()
 	// We'll iterate through the list backwards so when we get to the beginning and run out of extra_nonce values, it'll be only new clients left
 	blobs_data->m_numClientsExpected = num_connections;
-	m_extraNonce.exchange(blobs_data->m_numClientsExpected);
-
-	blobs_data->m_blobSize = block.get_hashing_blobs(0, blobs_data->m_numClientsExpected, blobs_data->m_blobs, blobs_data->m_height, difficulty, sidechain_difficulty, blobs_data->m_seedHash, nonce_offset, blobs_data->m_templateId);
+	blobs_data->m_blobSize = block.get_hashing_blobs(0, num_connections, blobs_data->m_blobs, blobs_data->m_height, difficulty, sidechain_difficulty, blobs_data->m_seedHash, nonce_offset, blobs_data->m_templateId);

 	// Integrity checks
 	if (blobs_data->m_blobSize < 76) {
@@ -176,11 +178,13 @@ void StratumServer::on_block(const BlockTemplate& block)
 	}
 }

-bool StratumServer::get_custom_user(const char* s, std::string& user)
+template<size_t N>
+static bool get_custom_user(const char* s, char (&user)[N])
 {
-	user.clear();
+	size_t len = 0;
+
 	// Find first of '+' or '.', drop non-printable characters
-	while (s && (user.length() < 64)) {
+	while (s && (len < N - 1)) {
 		const char c = *s;
 		if (!c) {
 			break;
@@ -190,15 +194,16 @@ bool StratumServer::get_custom_user(const char* s, std::string& user)
 		}
 		// Limit to printable ASCII characters
 		if (c >= ' ' && c <= '~') {
-			user += c;
+			user[len++] = c;
 		}
 		++s;
 	}
+	user[len] = '\0';

-	return !user.empty();
+	return (len > 0);
 }

-bool StratumServer::get_custom_diff(const char* s, difficulty_type& diff)
+static bool get_custom_diff(const char* s, difficulty_type& diff)
 {
 	const char* diff_str = nullptr;

@@ -217,8 +222,8 @@ bool StratumServer::get_custom_diff(const char* s, difficulty_type& diff)
 	if (diff_str) {
 		const uint64_t t = strtoull(diff_str + 1, nullptr, 10);
 		if (t) {
-			// Don't let clients set difficulty less than 1000
-			diff = { std::max<uint64_t>(t + 1, 1000), 0 };
+			// Don't let clients set difficulty less than MIN_DIFF
+			diff = { std::max<uint64_t>(t + 1, MIN_DIFF), 0 };
 			return true;
 		}
 	}
@@ -248,16 +253,15 @@ bool StratumServer::on_login(StratumClient* client, uint32_t id, const char* log
 	}

 	if (get_custom_user(login, client->m_customUser)) {
-		LOGINFO(5, "client " << log::Gray() << static_cast<char*>(client->m_addrString) << " set custom user " << client->m_customUser);
+		const char* s = client->m_customUser;
+		LOGINFO(5, "client " << log::Gray() << static_cast<char*>(client->m_addrString) << " set custom user " << s);
 	}

 	uint32_t job_id;
 	{
-		MutexLock lock(client->m_jobsLock);
+		job_id = ++client->m_perConnectionJobId;

-		job_id = client->m_perConnectionJobId++;
-
-		StratumClient::SavedJob& saved_job = client->m_jobs[job_id % array_size(&StratumClient::m_jobs)];
+		StratumClient::SavedJob& saved_job = client->m_jobs[job_id % StratumClient::JOBS_SIZE];
 		saved_job.job_id = job_id;
 		saved_job.extra_nonce = extra_nonce;
 		saved_job.template_id = template_id;
@@ -265,7 +269,7 @@ bool StratumServer::on_login(StratumClient* client, uint32_t id, const char* log
 	}

 	const bool result = send(client,
-		[client, id, &hashing_blob, job_id, blob_size, target, height, &seed_hash](void* buf)
+		[client, id, &hashing_blob, job_id, blob_size, target, height, &seed_hash](void* buf, size_t buf_size)
 		{
 			do {
 				client->m_rpcId = static_cast<uint32_t>(static_cast<StratumServer*>(client->m_owner)->get_random64());
@@ -278,7 +282,7 @@ bool StratumServer::on_login(StratumClient* client, uint32_t id, const char* log
 				target_hex.m_size -= sizeof(uint32_t);
 			}

-			log::Stream s(reinterpret_cast<char*>(buf));
+			log::Stream s(buf, buf_size);
 			s << "{\"id\":" << id << ",\"jsonrpc\":\"2.0\",\"result\":{\"id\":\"";
 			s << log::Hex(client->m_rpcId) << "\",\"job\":{\"blob\":\"";
 			s << log::hex_buf(hashing_blob, blob_size) << "\",\"job_id\":\"";
@@ -305,6 +309,11 @@ bool StratumServer::on_submit(StratumClient* client, uint32_t id, const char* jo
 		job_id = (job_id << 4) + d;
 	}

+	if (!job_id) {
+		LOGWARN(4, "client " << static_cast<char*>(client->m_addrString) << " invalid params ('job_id' can't be 0)");
+		return false;
+	}
+
 	uint32_t nonce = 0;

 	for (int i = static_cast<int>(sizeof(uint32_t)) - 1; i >= 0; --i) {
@@ -333,9 +342,7 @@ bool StratumServer::on_submit(StratumClient* client, uint32_t id, const char* jo

 	bool found = false;
 	{
-		MutexLock lock(client->m_jobsLock);
-
-		const StratumClient::SavedJob& saved_job = client->m_jobs[job_id % array_size(&StratumClient::m_jobs)];
+		const StratumClient::SavedJob& saved_job = client->m_jobs[job_id % StratumClient::JOBS_SIZE];
 		if (saved_job.job_id == job_id) {
 			template_id = saved_job.template_id;
 			extra_nonce = saved_job.extra_nonce;
@@ -351,33 +358,33 @@ bool StratumServer::on_submit(StratumClient* client, uint32_t id, const char* jo
 		if (!block.get_difficulties(template_id, mainchain_diff, sidechain_diff)) {
 			LOGWARN(4, "client " << static_cast<char*>(client->m_addrString) << " got a stale share");
 			return send(client,
-				[id](void* buf)
+				[id](void* buf, size_t buf_size)
 				{
-					log::Stream s(reinterpret_cast<char*>(buf));
+					log::Stream s(buf, buf_size);
 					s << "{\"id\":" << id << ",\"jsonrpc\":\"2.0\",\"error\":{\"message\":\"Stale share\"}}\n";
 					return s.m_pos;
 				});
 		}

 		if (mainchain_diff.check_pow(resultHash)) {
-			const std::string& s = client->m_customUser;
-			LOGINFO(0, log::Green() << "client " << static_cast<char*>(client->m_addrString) << (!s.empty() ? " user " : "") << s << " found a mainchain block, submitting it");
+			const char* s = client->m_customUser;
+			LOGINFO(0, log::Green() << "client " << static_cast<char*>(client->m_addrString) << (*s ? " user " : "") << s << " found a mainchain block, submitting it");
 			m_pool->submit_block_async(template_id, nonce, extra_nonce);
 			block.update_tx_keys();
 		}

 		SubmittedShare* share;

-		{
-			MutexLock lock(m_submittedSharesPoolLock);
+		if (!m_submittedSharesPool.empty()) {
+			share = m_submittedSharesPool.back();
+			m_submittedSharesPool.pop_back();
+		}
+		else {
+			share = new SubmittedShare{};
+		}

-			if (!m_submittedSharesPool.empty()) {
-				share = m_submittedSharesPool.back();
-				m_submittedSharesPool.pop_back();
-			}
-			else {
-				share = new SubmittedShare{};
-			}
+		if (target >= TARGET_4_BYTES_LIMIT) {
+			target = (target >> 32) << 32;
 		}

 		share->m_req.data = share;
@@ -393,9 +400,16 @@ bool StratumServer::on_submit(StratumClient* client, uint32_t id, const char* jo
 		share->m_target = target;
 		share->m_resultHash = resultHash;
 		share->m_sidechainDifficulty = sidechain_diff;
+		share->m_timestamp = seconds_since_epoch();
+
+		uint64_t rem;
+		share->m_hashes = (target > 1) ? udiv128(1, 0, target, &rem) : 1;
+		share->m_highEnoughDifficulty = sidechain_diff.check_pow(resultHash);
+
+		update_auto_diff(client, share->m_timestamp, share->m_hashes);

 		// If this share is below sidechain difficulty, process it in this thread because it'll be quick
-		if (!share->m_sidechainDifficulty.check_pow(share->m_resultHash)) {
+		if (!share->m_highEnoughDifficulty) {
 			on_share_found(&share->m_req);
 			on_after_share_found(&share->m_req, 0);
 			return true;
@@ -417,9 +431,9 @@ bool StratumServer::on_submit(StratumClient* client, uint32_t id, const char* jo
 	LOGWARN(4, "client " << static_cast<char*>(client->m_addrString) << " got a share with invalid job id");

 	const bool result = send(client,
-		[id](void* buf)
+		[id](void* buf, size_t buf_size)
 		{
-			log::Stream s(reinterpret_cast<char*>(buf));
+			log::Stream s(buf, buf_size);
 			s << "{\"id\":" << id << ",\"jsonrpc\":\"2.0\",\"error\":{\"message\":\"Invalid job id\"}}\n";
 			return s.m_pos;
 		});
@@ -435,12 +449,57 @@ 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::show_workers()
+{
+	const uint64_t cur_time = seconds_since_epoch();
+	const difficulty_type pool_diff = m_pool->side_chain().difficulty();
+
+	MutexLock lock(m_clientsListLock);
+
+	int addr_len = 0;
+	for (const StratumClient* c = static_cast<StratumClient*>(m_connectedClientsList->m_next); c != m_connectedClientsList; c = static_cast<StratumClient*>(c->m_next)) {
+		addr_len = std::max(addr_len, static_cast<int>(strlen(c->m_addrString)));
+	}
+
+	size_t n = 0;
+
+	LOGINFO(0, log::pad_right("IP:port", addr_len + 8)
+			<< log::pad_right("uptime", 20)
+			<< log::pad_right("difficulty", 20)
+			<< log::pad_right("hashrate", 15)
+			<< "name"
+	);
+
+	for (const StratumClient* c = static_cast<StratumClient*>(m_connectedClientsList->m_next); c != m_connectedClientsList; c = static_cast<StratumClient*>(c->m_next)) {
+		difficulty_type diff;
+		if (c->m_customDiff != 0) {
+			diff = c->m_customDiff;
+		}
+		else if (m_autoDiff && (c->m_autoDiff != 0)) {
+			diff = c->m_autoDiff;
+		}
+		else {
+			diff = pool_diff;
+		}
+		LOGINFO(0, log::pad_right(static_cast<const char*>(c->m_addrString), addr_len + 8)
+				<< log::pad_right(log::Duration(cur_time - c->m_connectedTime), 20)
+				<< log::pad_right(diff, 20)
+				<< log::pad_right(log::Hashrate(c->m_autoDiff.lo / AUTO_DIFF_TARGET_TIME, m_autoDiff && (c->m_autoDiff != 0)), 15)
+				<< (c->m_rpcId ? c->m_customUser : "not logged in")
+		);
+		++n;
+	}
+
+	LOGINFO(0, "Total: " << n << " workers");
+}
+
 void StratumServer::reset_share_counters()
 {
+	m_cumulativeHashes = 0;
 	m_cumulativeHashesAtLastShare = 0;
 	m_cumulativeFoundSharesDiff = 0.0;
 	m_totalFoundShares = 0;
@@ -493,10 +552,83 @@ void StratumServer::print_stratum_status() const
 		"\nShares found       = " << m_totalFoundShares <<
 		"\nAverage effort     = " << average_effort << '%' <<
 		"\nCurrent effort     = " << static_cast<double>(hashes_since_last_share) * 100.0 / m_pool->side_chain().difficulty().to_double() << '%' <<
-		"\nConnections        = " << m_numConnections << " (" << m_numIncomingConnections << " incoming)"
+		"\nConnections        = " << m_numConnections.load() << " (" << m_numIncomingConnections.load() << " incoming)"
 	);
 }

+// Compresses 64-bit hashes value into 16-bit value (5 bits for shift, 11 bits for data)
+namespace {
+
+enum HashValue : uint64_t {
+	bits = 11,
+	mask = (1 << bits) - 1,
+};
+
+static constexpr FORCEINLINE uint64_t hash_uncompress(uint64_t h)
+{
+	return (h & HashValue::mask) << (h >> HashValue::bits);
+};
+
+enum HashMaxValue : uint64_t {
+	value = hash_uncompress(std::numeric_limits<uint16_t>::max())
+};
+
+static FORCEINLINE uint16_t hash_compress(uint64_t h)
+{
+	if (h <= HashValue::mask) {
+		return static_cast<uint16_t>(h);
+	}
+
+	if (h >= HashMaxValue::value) {
+		return std::numeric_limits<uint16_t>::max();
+	}
+
+	const uint64_t shift = bsr(h) - (HashValue::bits - 1);
+	return static_cast<uint16_t>((shift << HashValue::bits) | (h >> shift));
+}
+
+}
+
+void StratumServer::update_auto_diff(StratumClient* client, const uint64_t timestamp, const uint64_t hashes)
+{
+	const uint16_t hashes_compressed = hash_compress(hashes);
+	client->m_autoDiffWindowHashes += hash_uncompress(hashes_compressed);
+
+	const uint32_t k = client->m_autoDiffIndex++;
+	constexpr uint32_t N = StratumClient::AUTO_DIFF_SIZE;
+
+	StratumClient::AutoDiffData& auto_diff_data = client->m_autoDiffData[k % N];
+
+	if (k >= N) {
+		client->m_autoDiffWindowHashes -= hash_uncompress(auto_diff_data.m_hashes);
+	}
+
+	const uint16_t t1 = auto_diff_data.m_timestamp;
+	const uint16_t t2 = static_cast<uint16_t>(timestamp);
+	auto_diff_data.m_timestamp = t2;
+	auto_diff_data.m_hashes = hashes_compressed;
+
+	if (k >= N) {
+		// Full window
+		const uint64_t dt = t2 - t1;
+		client->m_autoDiff.lo = std::max<uint64_t>((client->m_autoDiffWindowHashes * AUTO_DIFF_TARGET_TIME) / (dt ? dt : 1), MIN_DIFF);
+		client->m_autoDiff.hi = 0;
+	}
+	else if (k >= 10) {
+		// Partial window
+		const uint64_t h0 = hash_uncompress(client->m_autoDiffData[0].m_hashes);
+		const uint64_t dt = client->m_autoDiffData[k].m_timestamp - client->m_autoDiffData[0].m_timestamp;
+
+		client->m_autoDiff.lo = std::max<uint64_t>(((client->m_autoDiffWindowHashes - h0) * AUTO_DIFF_TARGET_TIME) / (dt ? dt : 1), MIN_DIFF);
+		client->m_autoDiff.hi = 0;
+	}
+	else if (k == 0) {
+		// First share, fix auto diff to current difficulty until we have at least 10 shares
+		client->m_autoDiff.lo = hashes;
+		client->m_autoDiff.hi = 0;
+	}
+}
+
 void StratumServer::on_blobs_ready()
 {
 	std::vector<BlobsData*> blobs_queue;
@@ -525,7 +657,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);

@@ -553,14 +685,32 @@ void StratumServer::on_blobs_ready()
 			if (client->m_customDiff.lo) {
 				target = std::max(target, client->m_customDiff.target());
 			}
+			else if (m_autoDiff) {
+				if (client->m_autoDiff.lo) {
+					const uint32_t k = client->m_autoDiffIndex;
+					const uint16_t elapsed_time = static_cast<uint16_t>(cur_time) - client->m_autoDiffData[(k - 1) % StratumClient::AUTO_DIFF_SIZE].m_timestamp;
+					if (elapsed_time > AUTO_DIFF_TARGET_TIME * 5) {
+						// More than 500% effort, reduce the auto diff by 1/8 every time until the share is found
+						client->m_autoDiff.lo = std::max<uint64_t>(client->m_autoDiff.lo - client->m_autoDiff.lo / 8, MIN_DIFF);
+					}
+					target = std::max(target, client->m_autoDiff.target());
+				}
+				else {
+					// Not enough shares from the client yet, cut diff in half every 16 seconds
+					const uint64_t num_halvings = (cur_time - client->m_connectedTime) / 16;
+					constexpr uint64_t max_target = (std::numeric_limits<uint64_t>::max() / MIN_DIFF) + 1;
+					for (uint64_t i = 0; (i < num_halvings) && (target < max_target); ++i) {
+						target *= 2;
+					}
+					target = std::min<uint64_t>(target, max_target);
+				}
+			}

 			uint32_t job_id;
 			{
-				MutexLock lock3(client->m_jobsLock);
+				job_id = ++client->m_perConnectionJobId;

-				job_id = client->m_perConnectionJobId++;
-
-				StratumClient::SavedJob& saved_job = client->m_jobs[job_id % array_size(&StratumClient::m_jobs)];
+				StratumClient::SavedJob& saved_job = client->m_jobs[job_id % StratumClient::JOBS_SIZE];
 				saved_job.job_id = job_id;
 				saved_job.extra_nonce = extra_nonce;
 				saved_job.template_id = data->m_templateId;
@@ -568,7 +718,7 @@ void StratumServer::on_blobs_ready()
 			}

 			const bool result = send(client,
-				[data, target, hashing_blob, &job_id](void* buf)
+				[data, target, hashing_blob, &job_id](void* buf, size_t buf_size)
 				{
 					log::hex_buf target_hex(reinterpret_cast<const uint8_t*>(&target), sizeof(uint64_t));

@@ -577,7 +727,7 @@ void StratumServer::on_blobs_ready()
 						target_hex.m_size -= sizeof(uint32_t);
 					}

-					log::Stream s(reinterpret_cast<char*>(buf));
+					log::Stream s(buf, buf_size);
 					s << "{\"jsonrpc\":\"2.0\",\"method\":\"job\",\"params\":{\"blob\":\"";
 					s << log::hex_buf(hashing_blob, data->m_blobSize) << "\",\"job_id\":\"";
 					s << log::Hex(job_id) << "\",\"target\":\"";
@@ -595,15 +745,16 @@ void StratumServer::on_blobs_ready()
 			}
 		}

-		if (numClientsProcessed != m_numConnections) {
-			LOGWARN(1, "client list is broken, expected " << m_numConnections << ", got " << numClientsProcessed << " clients");
+		const uint32_t num_connections = m_numConnections;
+		if (numClientsProcessed != num_connections) {
+			LOGWARN(1, "client list is broken, expected " << num_connections << ", got " << numClientsProcessed << " clients");
 		}
 	}

 	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);

@@ -636,26 +787,23 @@ void StratumServer::update_hashrate_data(uint64_t hashes, time_t timestamp)

 void StratumServer::on_share_found(uv_work_t* req)
 {
-	bkg_jobs_tracker.start("StratumServer::on_share_found");
-
 	SubmittedShare* share = reinterpret_cast<SubmittedShare*>(req->data);
+	if (share->m_highEnoughDifficulty) {
+		bkg_jobs_tracker.start("StratumServer::on_share_found");
+	}
+
 	StratumClient* client = share->m_client;
 	StratumServer* server = share->m_server;
 	p2pool* pool = server->m_pool;

-	uint64_t target = share->m_target;
-	if (target >= TARGET_4_BYTES_LIMIT) {
-		target = (target >> 32) << 32;
-	}
-
-	uint64_t rem;
-	const uint64_t hashes = (target > 1) ? udiv128(1, 0, target, &rem) : 0;
+	const uint64_t target = share->m_target;
+	const uint64_t hashes = share->m_hashes;

 	if (pool->stopped()) {
 		LOGWARN(0, "p2pool is shutting down, but a share was found. Trying to process it anyway!");
 	}

-	if (share->m_sidechainDifficulty.check_pow(share->m_resultHash)) {
+	if (share->m_highEnoughDifficulty) {
 		uint8_t blob[128];
 		uint64_t height;
 		difficulty_type difficulty;
@@ -696,8 +844,8 @@ void StratumServer::on_share_found(uv_work_t* req)
 		server->m_cumulativeFoundSharesDiff += diff;
 		++server->m_totalFoundShares;

-		const std::string& s = client->m_customUser;
-		LOGINFO(0, log::Green() << "SHARE FOUND: mainchain height " << height << ", diff " << sidechain_difficulty << ", client " << static_cast<char*>(client->m_addrString) << (!s.empty() ? " user " : "") << s << ", effort " << effort << '%');
+		const char* s = client->m_customUser;
+		LOGINFO(0, log::Green() << "SHARE FOUND: mainchain height " << height << ", diff " << sidechain_difficulty << ", client " << static_cast<char*>(client->m_addrString) << (*s ? " user " : "") << s << ", effort " << effort << '%');
 		pool->submit_sidechain_block(share->m_templateId, share->m_nonce, share->m_extraNonce);
 	}

@@ -705,7 +853,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 = share->m_timestamp;
 		server->update_hashrate_data(hashes, timestamp);
 		server->api_update_local_stats(timestamp);
 		share->m_result = SubmittedShare::Result::OK;
@@ -719,16 +867,11 @@ void StratumServer::on_share_found(uv_work_t* req)
 void StratumServer::on_after_share_found(uv_work_t* req, int /*status*/)
 {
 	SubmittedShare* share = reinterpret_cast<SubmittedShare*>(req->data);
+	if (share->m_highEnoughDifficulty) {
+		bkg_jobs_tracker.stop("StratumServer::on_share_found");
+	}

-	ON_SCOPE_LEAVE(
-		[share]()
-		{
-			{
-				MutexLock lock(share->m_server->m_submittedSharesPoolLock);
-				share->m_server->m_submittedSharesPool.push_back(share);
-			}
-			bkg_jobs_tracker.stop("StratumServer::on_share_found");
-		});
+	ON_SCOPE_LEAVE([share]() { share->m_server->m_submittedSharesPool.push_back(share); });

 	StratumClient* client = share->m_client;
 	StratumServer* server = share->m_server;
@@ -737,9 +880,9 @@ void StratumServer::on_after_share_found(uv_work_t* req, int /*status*/)

 	if ((client->m_resetCounter.load() == share->m_clientResetCounter) && (client->m_rpcId == share->m_rpcId)) {
 		const bool result = server->send(client,
-			[share](void* buf)
+			[share](void* buf, size_t buf_size)
 			{
-				log::Stream s(reinterpret_cast<char*>(buf));
+				log::Stream s(buf, buf_size);
 				switch (share->m_result) {
 				case SubmittedShare::Result::STALE:
 					s << "{\"id\":" << share->m_id << ",\"jsonrpc\":\"2.0\",\"error\":{\"message\":\"Stale share\"}}\n";
@@ -775,33 +918,39 @@ void StratumServer::on_after_share_found(uv_work_t* req, int /*status*/)

 StratumServer::StratumClient::StratumClient()
 	: m_rpcId(0)
+	, m_perConnectionJobId(0)
 	, m_connectedTime(0)
 	, m_jobs{}
-	, m_perConnectionJobId(0)
+	, m_autoDiffData{}
+	, m_autoDiffWindowHashes(0)
+	, m_autoDiffIndex(0)
 	, m_customDiff{}
+	, m_autoDiff{}
+	, m_customUser{}
 {
-	uv_mutex_init_checked(&m_jobsLock);
-}
-
-StratumServer::StratumClient::~StratumClient()
-{
-	uv_mutex_destroy(&m_jobsLock);
 }

 void StratumServer::StratumClient::reset()
 {
 	Client::reset();
 	m_rpcId = 0;
-	m_connectedTime = 0;
-	memset(m_jobs, 0, sizeof(m_jobs));
 	m_perConnectionJobId = 0;
+	m_connectedTime = 0;
+
+	for (int i = 0; i < JOBS_SIZE; ++i) {
+		m_jobs[i].job_id = 0;
+	}
+
+	m_autoDiffWindowHashes = 0;
+	m_autoDiffIndex = 0;
 	m_customDiff = {};
-	m_customUser.clear();
+	m_autoDiff = {};
+	m_customUser[0] = '\0';
 }

 bool StratumServer::StratumClient::on_connect()
 {
-	m_connectedTime = time(nullptr);
+	m_connectedTime = seconds_since_epoch();
 	return true;
 }

@@ -991,7 +1140,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;
@@ -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 {

@@ -40,7 +39,7 @@ public:
 	struct StratumClient : public Client
 	{
 		StratumClient();
-		~StratumClient();
+		FORCEINLINE ~StratumClient() {}

 		static Client* allocate() { return new StratumClient(); }

@@ -53,20 +52,32 @@ public:
 		bool process_submit(rapidjson::Document& doc, uint32_t id);

 		uint32_t m_rpcId;
-		time_t m_connectedTime;
+		uint32_t m_perConnectionJobId;
+		uint64_t m_connectedTime;

-		uv_mutex_t m_jobsLock;
+		enum { 
+			JOBS_SIZE = 4,
+			AUTO_DIFF_SIZE = 64,
+		};

 		struct SavedJob {
 			uint32_t job_id;
 			uint32_t extra_nonce;
 			uint32_t template_id;
 			uint64_t target;
-		} m_jobs[4];
+		} m_jobs[JOBS_SIZE];
+
+		struct AutoDiffData {
+			uint16_t m_timestamp;
+			uint16_t m_hashes;
+		} m_autoDiffData[AUTO_DIFF_SIZE];
+
+		uint64_t m_autoDiffWindowHashes;
+		uint32_t m_autoDiffIndex;

-		uint32_t m_perConnectionJobId;
 		difficulty_type m_customDiff;
-		std::string m_customUser;
+		difficulty_type m_autoDiff;
+		char m_customUser[32];
 	};

 	bool on_login(StratumClient* client, uint32_t id, const char* login);
@@ -74,19 +85,19 @@ public:
 	uint64_t get_random64();

 	void print_status() override;
+	void show_workers();

 	void reset_share_counters();

 private:
 	void print_stratum_status() const;
-
-	static bool get_custom_diff(const char* s, difficulty_type& diff);
-	static bool get_custom_user(const char* s, std::string& user);
+	void update_auto_diff(StratumClient* client, const uint64_t timestamp, const uint64_t hashes);

 	static void on_share_found(uv_work_t* req);
 	static void on_after_share_found(uv_work_t* req, int status);

 	p2pool* m_pool;
+	bool m_autoDiff;

 	struct BlobsData
 	{
@@ -109,7 +120,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
@@ -127,6 +137,9 @@ private:
 		uint64_t m_target;
 		hash m_resultHash;
 		difficulty_type m_sidechainDifficulty;
+		uint64_t m_timestamp;
+		uint64_t m_hashes;
+		bool m_highEnoughDifficulty;

 		enum class Result {
 			STALE,
@@ -137,12 +150,11 @@ private:
 		} m_result;
 	};

-	uv_mutex_t m_submittedSharesPoolLock;
 	std::vector<SubmittedShare*> m_submittedSharesPool;

 	struct HashrateData
 	{
-		time_t m_timestamp;
+		uint64_t m_timestamp;
 		uint64_t m_cumulativeHashes;
 	};

@@ -159,10 +171,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
@@ -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 @@ public:
 	struct Client
 	{
 		Client();
-		virtual ~Client();
+		virtual ~Client() {}

 		virtual void reset();
 		virtual bool on_connect() = 0;
@@ -70,6 +70,8 @@ public:

 		void init_addr_string(bool is_v6, const sockaddr_storage* peer_addr);

+		alignas(8) char m_readBuf[READ_BUF_SIZE];
+
 		TCPServer* m_owner;

 		// Used to maintain connected clients list
@@ -77,21 +79,17 @@ public:
 		Client* m_next;

 		uv_tcp_t m_socket;
-		uv_connect_t m_connectRequest;

 		bool m_isV6;
 		bool m_isIncoming;
+		bool m_readBufInUse;
+		uint32_t m_numRead;
+
 		raw_ip m_addr;
 		int m_port;
 		char m_addrString[64];

-		bool m_readBufInUse;
-		char m_readBuf[READ_BUF_SIZE];
-		uint32_t m_numRead;
-
-		std::atomic<uint32_t> m_resetCounter{ 0 };
-
-		uv_mutex_t m_sendLock;
+		std::atomic<uint32_t> m_resetCounter;
 	};

 	struct WriteBuf
@@ -107,14 +105,14 @@ public:
 	struct SendCallbackBase
 	{
 		virtual ~SendCallbackBase() {}
-		virtual size_t operator()(void*) = 0;
+		virtual size_t operator()(void*, size_t) = 0;
 	};

 	template<typename T>
 	struct SendCallback : public SendCallbackBase
 	{
 		explicit FORCEINLINE SendCallback(T&& callback) : m_callback(std::move(callback)) {}
-		size_t operator()(void* buf) override { return m_callback(buf); }
+		size_t operator()(void* buf, size_t buf_size) override { return m_callback(buf, buf_size); }

 	private:
 		SendCallback& operator=(SendCallback&&) = delete;
@@ -152,13 +150,13 @@ protected:
 	int m_listenPort;

 	uv_loop_t m_loop;
-	volatile bool m_loopStopped;
+	std::atomic<bool> m_loopStopped;

 	uv_mutex_t m_clientsListLock;
 	std::vector<Client*> m_preallocatedClients;
 	Client* m_connectedClientsList;
-	uint32_t m_numConnections;
-	uint32_t m_numIncomingConnections;
+	std::atomic<uint32_t> m_numConnections;
+	std::atomic<uint32_t> m_numIncomingConnections;

 	uv_mutex_t m_bansLock;
 	unordered_map<raw_ip, std::chrono::steady_clock::time_point> m_bans;
@@ -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,9 +27,9 @@ TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::TCPServer(allocate_client_callback all
 	, m_loopThread{}
 	, m_finished(0)
 	, m_listenPort(-1)
-	, m_loopStopped(false)
-	, m_numConnections(0)
-	, m_numIncomingConnections(0)
+	, m_loopStopped{false}
+	, m_numConnections{ 0 }
+	, m_numIncomingConnections{ 0 }
 {
 	int err = uv_loop_init(&m_loop);
 	if (err) {
@@ -37,10 +37,18 @@ TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::TCPServer(allocate_client_callback all
 		panic();
 	}

-	uv_async_init(&m_loop, &m_dropConnectionsAsync, on_drop_connections);
+	err = uv_async_init(&m_loop, &m_dropConnectionsAsync, on_drop_connections);
+	if (err) {
+		LOGERR(1, "uv_async_init failed, error " << uv_err_name(err));
+		panic();
+	}
 	m_dropConnectionsAsync.data = this;

-	uv_async_init(&m_loop, &m_shutdownAsync, on_shutdown);
+	err = uv_async_init(&m_loop, &m_shutdownAsync, on_shutdown);
+	if (err) {
+		LOGERR(1, "uv_async_init failed, error " << uv_err_name(err));
+		panic();
+	}
 	m_shutdownAsync.data = this;

 	uv_mutex_init_checked(&m_clientsListLock);
@@ -64,6 +72,7 @@ TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::TCPServer(allocate_client_callback all
 }

 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
+// cppcheck-suppress functionStatic
 TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::~TCPServer()
 {
 	if (m_finished.load() == 0) {
@@ -322,6 +331,10 @@ 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)
 {
+	if (ip.is_localhost()) {
+		return false;
+	}
+
 	const auto cur_time = std::chrono::steady_clock::now();

 	MutexLock lock(m_bansLock);
@@ -372,8 +385,11 @@ bool TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::connect_to_peer_nolock(Client* cl
 		return false;
 	}

-	client->m_connectRequest.data = client;
-	err = uv_tcp_connect(&client->m_connectRequest, &client->m_socket, addr, on_connect);
+	uv_connect_t* connect_request = reinterpret_cast<uv_connect_t*>(client->m_readBuf);
+	memset(connect_request, 0, sizeof(uv_connect_t));
+
+	connect_request->data = client;
+	err = uv_tcp_connect(connect_request, &client->m_socket, addr, on_connect);
 	if (err) {
 		LOGERR(1, "failed to initiate tcp connection, error " << uv_err_name(err));
 		m_pendingConnections.erase(client->m_addr);
@@ -488,13 +504,17 @@ template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
 void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::print_status()
 {
 	LOGINFO(0, "status" <<
-		"\nConnections = " << m_numConnections << " (" << m_numIncomingConnections << " incoming)"
+		"\nConnections = " << m_numConnections.load() << " (" << m_numIncomingConnections.load() << " incoming)"
 	);
 }

 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)
 {
+	if (ip.is_localhost()) {
+		return;
+	}
+
 	const auto ban_time = std::chrono::steady_clock::now() + std::chrono::seconds(seconds);

 	MutexLock lock(m_bansLock);
@@ -532,8 +552,6 @@ bool TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::send_internal(Client* client, Sen
 		LOGERR(1, "sending data from another thread, this is not thread safe");
 	}

-	MutexLock lock0(client->m_sendLock);
-
 	WriteBuf* buf = nullptr;

 	{
@@ -550,7 +568,7 @@ bool TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::send_internal(Client* client, Sen

 	// 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);
+	const size_t bytes_written = callback(callback_buf, sizeof(callback_buf));

 	if (bytes_written > WRITE_BUF_SIZE) {
 		LOGERR(0, "send callback wrote " << bytes_written << " bytes, expected no more than " << WRITE_BUF_SIZE << " bytes");
@@ -620,9 +638,11 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::on_new_connection(uv_stream_t* se
 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
 void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::on_connection_close(uv_handle_t* handle)
 {
-	Client* client = static_cast<Client*>(handle->data);
-	MutexLock lock0(client->m_sendLock);
+	if (!server_event_loop_thread) {
+		LOGERR(1, "on_connection_close called from another thread, this is not thread safe");
+	}

+	Client* client = static_cast<Client*>(handle->data);
 	TCPServer* owner = client->m_owner;

 	LOGINFO(5, "peer " << log::Gray() << static_cast<char*>(client->m_addrString) << log::NoColor() << " disconnected");
@@ -808,18 +828,21 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::on_new_client_nolock(uv_stream_t*

 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
 TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::Client::Client()
+	: m_owner(nullptr)
+	, m_prev(nullptr)
+	, m_next(nullptr)
+	, m_socket{}
+	, m_isV6(false)
+	, m_isIncoming(false)
+	, m_readBufInUse(false)
+	, m_numRead(0)
+	, m_addr{}
+	, m_port(0)
+	, m_addrString{}
+	, m_resetCounter{ 0 }
 {
-	Client::reset();
-
-	uv_mutex_init_checked(&m_sendLock);
-
 	m_readBuf[0] = '\0';
-}
-
-template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
-TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::Client::~Client()
-{
-	uv_mutex_destroy(&m_sendLock);
+	m_readBuf[READ_BUF_SIZE - 1] = '\0';
 }

 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
@@ -831,14 +854,13 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::Client::reset()
 	m_prev = nullptr;
 	m_next = nullptr;
 	memset(&m_socket, 0, sizeof(m_socket));
-	memset(&m_connectRequest, 0, sizeof(m_connectRequest));
 	m_isV6 = false;
 	m_isIncoming = false;
+	m_readBufInUse = false;
+	m_numRead = 0;
 	m_addr = {};
 	m_port = -1;
 	m_addrString[0] = '\0';
-	m_readBufInUse = false;
-	m_numRead = 0;
 }

 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
@@ -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.8 (built"
+const char* VERSION = "v2.1 (built"
 #if defined(__clang__)
 	" with clang/" __clang_version__
 #elif defined(__GNUC__)
@@ -66,7 +66,7 @@ void make_thread_background()
 	SetThreadPriorityBoost(GetCurrentThread(), true);
 	SetThreadPriority(GetCurrentThread(), THREAD_MODE_BACKGROUND_BEGIN);
 	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_IDLE);
-#elif !defined(__APPLE__)
+#elif !defined(__APPLE__) && !defined(__FreeBSD__)
 	sched_param param;
 	param.sched_priority = 0;
 	if (sched_setscheduler(0, SCHED_IDLE, &param) != 0) {
@@ -349,7 +349,7 @@ bool resolve_host(std::string& host, bool& is_v6)
 	addrinfo hints{};
 	hints.ai_family = AF_UNSPEC;
 	hints.ai_socktype = SOCK_STREAM;
-	hints.ai_flags = AI_V4MAPPED | AI_ADDRCONFIG;
+	hints.ai_flags = AI_ADDRCONFIG;

 	addrinfo* r = nullptr;
 	const int err = getaddrinfo(host.c_str(), nullptr, &hints, &r);
@@ -382,4 +382,45 @@ bool resolve_host(std::string& host, bool& is_v6)
 	return true;
 }

+RandomDeviceSeed RandomDeviceSeed::instance;
+
+struct BSR8
+{
+	uint8_t data[256];
+
+	static constexpr BSR8 init() {
+		BSR8 result = { 55 };
+
+		for (int i = 1; i < 256; ++i) {
+			int x = i;
+			result.data[i] = 63;
+			while (x < 0x80) {
+				--result.data[i];
+				x <<= 1;
+			}
+		}
+
+		return result;
+	}
+};
+
+static constexpr BSR8 bsr8_table = BSR8::init();
+
+NOINLINE uint64_t bsr_reference(uint64_t x)
+{
+	uint32_t y = static_cast<uint32_t>(x);
+
+	uint64_t n0 = (x == y) ? 0 : 32;
+	y = static_cast<uint32_t>(x >> n0);
+	n0 ^= 32;
+
+	const uint64_t n1 = (y & 0xFFFF0000UL) ? 0 : 16;
+	y <<= n1;
+
+	const uint64_t n2 = (y & 0xFF000000UL) ? 0 : 8;
+	y <<= n2;
+
+	return bsr8_table.data[y >> 24] - n0 - n1 - n2;
+}
+
 } // namespace p2pool
@@ -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
@@ -109,6 +109,40 @@ FORCEINLINE void writeVarint(T value, std::vector<uint8_t>& out)
 	writeVarint(value, [&out](uint8_t b) { out.emplace_back(b); });
 }

+template<typename T>
+const uint8_t* readVarint(const uint8_t* data, const uint8_t* data_end, T& b)
+{
+	uint64_t result = 0;
+	int k = 0;
+
+	while (data < data_end) {
+		if (k >= static_cast<int>(sizeof(T)) * 8) {
+			return nullptr;
+		}
+
+		const uint64_t cur_byte = *(data++);
+		result |= (cur_byte & 0x7F) << k;
+		k += 7;
+
+		if ((cur_byte & 0x80) == 0) {
+			b = result;
+			return data;
+		}
+	}
+
+	return nullptr;
+}
+
+template<typename T>
+FORCEINLINE T read_unaligned(const T* p)
+{
+	static_assert(std::is_integral<T>::value, "T must be an integer type");
+
+	T result;
+	memcpy(&result, p, sizeof(T));
+	return result;
+}
+
 template<typename T, size_t N> FORCEINLINE constexpr size_t array_size(T(&)[N]) { return N; }
 template<typename T, typename U, size_t N> FORCEINLINE constexpr size_t array_size(T(U::*)[N]) { return N; }

@@ -145,6 +179,46 @@ 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();
+}
+
+uint64_t bsr_reference(uint64_t x);
+
+#ifdef HAVE_BUILTIN_CLZLL
+#define bsr(x) (63 - __builtin_clzll(x))
+#elif defined HAVE_BITSCANREVERSE64
+#pragma intrinsic(_BitScanReverse64)
+FORCEINLINE uint64_t bsr(uint64_t x)
+{
+	unsigned long index;
+	_BitScanReverse64(&index, x);
+	return index;
+}
+#else
+#define bsr bsr_reference
+#endif
+
 } // namespace p2pool

 namespace robin_hood {
@@ -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
@@ -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>
@@ -84,16 +84,11 @@ Wallet::Wallet(const char* address) : m_prefix(0), m_checksum(0), m_type(Network
 	decode(address);
 }

-Wallet::~Wallet()
-{
-}
-
 Wallet::Wallet(const Wallet& w)
 {
 	operator=(w);
 }

-// cppcheck-suppress operatorEqVarError
 Wallet& Wallet::operator=(const Wallet& w)
 {
 	if (this == &w) {
@@ -123,7 +118,7 @@ bool Wallet::decode(const char* address)

 	static_assert(last_block_size_index >= 0, "Check ADDRESS_LENGTH");

-	uint8_t data[static_cast<size_t>(num_full_blocks) * sizeof(uint64_t) + last_block_size_index];
+	uint8_t data[static_cast<size_t>(num_full_blocks) * sizeof(uint64_t) + last_block_size_index] = {};
 	int data_index = 0;

 	for (int i = 0; i <= num_full_blocks; ++i) {
@@ -199,10 +194,25 @@ bool Wallet::assign(const hash& spend_pub_key, const hash& view_pub_key, Network
 	return true;
 }

-bool Wallet::get_eph_public_key(const hash& txkey_sec, size_t output_index, hash& eph_public_key) const
+bool Wallet::get_eph_public_key(const hash& txkey_sec, size_t output_index, hash& eph_public_key, uint8_t& view_tag) const
 {
 	hash derivation;
-	if (!generate_key_derivation(m_viewPublicKey, txkey_sec, derivation)) {
+	if (!generate_key_derivation(m_viewPublicKey, txkey_sec, output_index, derivation, view_tag)) {
+		return false;
+	}
+
+	if (!derive_public_key(derivation, output_index, m_spendPublicKey, eph_public_key)) {
+		return false;
+	}
+
+	return true;
+}
+
+bool Wallet::get_eph_public_key_with_view_tag(const hash& txkey_sec, size_t output_index, hash& eph_public_key, uint8_t expected_view_tag) const
+{
+	hash derivation;
+	uint8_t view_tag;
+	if (!generate_key_derivation(m_viewPublicKey, txkey_sec, output_index, derivation, view_tag) || (view_tag != expected_view_tag)) {
 		return false;
 	}

@@ -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
@@ -25,7 +25,6 @@ class Wallet
 {
 public:
 	explicit Wallet(const char* address);
-	~Wallet();

 	Wallet(const Wallet& w);
 	Wallet& operator=(const Wallet& w);
@@ -39,7 +38,8 @@ public:
 	FORCEINLINE const hash& spend_public_key() const { return m_spendPublicKey; }
 	FORCEINLINE const hash& view_public_key() const { return m_viewPublicKey; }

-	bool get_eph_public_key(const hash& txkey_sec, size_t output_index, hash& eph_public_key) const;
+	bool get_eph_public_key(const hash& txkey_sec, size_t output_index, hash& eph_public_key, uint8_t& view_tag) const;
+	bool get_eph_public_key_with_view_tag(const hash& txkey_sec, size_t output_index, hash& eph_public_key, uint8_t expected_view_tag) const;

 	FORCEINLINE bool operator<(const Wallet& w) const { return m_spendPublicKey < w.m_spendPublicKey; }
 	FORCEINLINE bool operator==(const Wallet& w) const { return m_spendPublicKey == w.m_spendPublicKey; }
@@ -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 ";

@@ -50,13 +49,13 @@ ZMQReader::ZMQReader(const char* address, uint32_t zmq_port, MinerCallbackHandle

 	if (!m_publisherPort) {
 		LOGERR(1, "failed to to bind ZMQ publisher port, aborting");
-		panic();
+		throw zmq::error_t(EFSM);
 	}

 	const int err = uv_thread_create(&m_worker, run_wrapper, this);
 	if (err) {
 		LOGERR(1, "failed to start ZMQ thread, error " << uv_err_name(err));
-		panic();
+		throw zmq::error_t(EFSM);
 	}
 }

@@ -72,8 +71,7 @@ ZMQReader::~ZMQReader()
 		uv_thread_join(&m_worker);
 	}
 	catch (const std::exception& e) {
-		LOGERR(1, "exception " << e.what() << ", aborting");
-		panic();
+		LOGERR(1, "exception " << e.what());
 	}
 }

@@ -105,7 +103,7 @@ void ZMQReader::run()
 		zmq_msg_t message;
 		int rc = zmq_msg_init(&message);
 		if (rc != 0) {
-			throw zmq::error_t();
+			throw zmq::error_t(errno);
 		}

 		LOGINFO(1, "worker thread ready");
@@ -113,7 +111,7 @@ void ZMQReader::run()
 		do {
 			rc = zmq_msg_recv(&message, m_subscriber, 0);
 			if (rc < 0) {
-				throw zmq::error_t();
+				throw zmq::error_t(errno);
 			}

 			if (m_finished.load()) {
@@ -126,8 +124,7 @@ void ZMQReader::run()
 		zmq_msg_close(&message);
 	}
 	catch (const std::exception& e) {
-		LOGERR(1, "exception " << e.what() << ", aborting");
-		panic();
+		LOGERR(1, "exception " << e.what());
 	}
 }

@@ -160,10 +157,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);
@@ -197,7 +194,7 @@ void ZMQReader::parse(char* data, size_t size)
 	using namespace rapidjson;

 	Document doc;
-	if (doc.Parse<rapidjson::kParseCommentsFlag | rapidjson::kParseTrailingCommasFlag>(value, end - value).HasParseError()) {
+	if (doc.Parse<kParseCommentsFlag | kParseTrailingCommasFlag>(value, end - value).HasParseError()) {
 		LOGWARN(1, "ZeroMQ message failed to parse, skipping it");
 		return;
 	}
@@ -208,7 +205,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];
@@ -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
@@ -3,12 +3,7 @@ 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)
-
-set(CMAKE_C_STANDARD 99)
-set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake")

 if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.6.0") 
 	set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT p2pool_tests)
@@ -19,49 +14,9 @@ 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 "")
-	set(OPTIMIZATION_FLAGS "-Ofast -s")
-
-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS}")
-	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
-
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS}")
-	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
-
-	if (WIN32)
-		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")
-	else()
-		if (STATIC_LINUX_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++")
-		endif()
-	endif()
-elseif (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
-	set(WARNING_FLAGS "")
-	set(SECURITY_FLAGS "/GS /guard:cf")
-	set(OPTIMIZATION_FLAGS "/O2 /Oi /Ob2 /Ot /DNDEBUG /GL")
-
-	set(CMAKE_C_FLAGS_DEBUG "${WARNING_FLAGS} ${SECURITY_FLAGS} /Od /Ob0 /Zi /MTd /fsanitize=address")
-	set(CMAKE_CXX_FLAGS_DEBUG "${WARNING_FLAGS} ${SECURITY_FLAGS} /Od /Ob0 /Zi /MTd /fsanitize=address")
-
-	set(CMAKE_C_FLAGS_RELEASE "${WARNING_FLAGS} ${SECURITY_FLAGS} ${OPTIMIZATION_FLAGS} /MT")
-	set(CMAKE_CXX_FLAGS_RELEASE "${WARNING_FLAGS} ${SECURITY_FLAGS} ${OPTIMIZATION_FLAGS} /MT")
-
-	set(CMAKE_C_FLAGS_RELWITHDEBINFO "${WARNING_FLAGS} ${SECURITY_FLAGS} /Ob1 /Ot /Zi /MT")
-	set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${WARNING_FLAGS} ${SECURITY_FLAGS} /Ob1 /Ot /Zi /MT")
-elseif (CMAKE_CXX_COMPILER_ID MATCHES Clang)
-	set(WARNING_FLAGS "")
-	set(OPTIMIZATION_FLAGS "-Ofast -funroll-loops -fmerge-all-constants")
-
-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS}")
-	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
-
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS}")
-	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
-endif()
+include(cmake/flags.cmake)

 set(HEADERS
 )
@@ -73,6 +28,7 @@ set(SOURCES
 	src/keccak_tests.cpp
 	src/main.cpp
 	src/pool_block_tests.cpp
+	src/util_tests.cpp
 	src/wallet_tests.cpp
 	../external/src/cryptonote/crypto-ops-data.c
 	../external/src/cryptonote/crypto-ops.c
@@ -158,6 +114,19 @@ endif()

 add_definitions(/DZMQ_STATIC /DP2POOL_LOG_DISABLE)

+include(CheckCXXSourceCompiles)
+
+check_cxx_source_compiles("int main(){ return __builtin_clzll(1);}" HAVE_BUILTIN_CLZLL)
+check_cxx_source_compiles("#include <intrin.h>\n#pragma intrinsic(_BitScanReverse64)\nint main(){unsigned long r;_BitScanReverse64(&r,1);return r;}" HAVE_BITSCANREVERSE64)
+
+if (HAVE_BUILTIN_CLZLL)
+	add_definitions(/DHAVE_BUILTIN_CLZLL)
+endif()
+
+if (HAVE_BITSCANREVERSE64)
+	add_definitions(/DHAVE_BITSCANREVERSE64)
+endif()
+
 add_executable(${CMAKE_PROJECT_NAME} ${HEADERS} ${SOURCES})
 target_link_libraries(${CMAKE_PROJECT_NAME} debug ${ZMQ_LIBRARY_DEBUG} debug ${UV_LIBRARY_DEBUG} optimized ${ZMQ_LIBRARY} optimized ${UV_LIBRARY} ${LIBS})
 add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_SOURCE_DIR}/src/crypto_tests.txt" $<TARGET_FILE_DIR:${CMAKE_PROJECT_NAME}>)
@@ -0,0 +1,53 @@
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_STANDARD 14)
+
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
+	set(GENERAL_FLAGS "-pthread")
+	set(WARNING_FLAGS "-Wall -Wextra")
+	set(OPTIMIZATION_FLAGS "-Ofast -s")
+
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+
+	if (WIN32)
+		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")
+	else()
+		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++")
+		endif()
+	endif()
+elseif (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+	set(GENERAL_FLAGS "")
+	set(WARNING_FLAGS "/Wall /sdl")
+	set(SECURITY_FLAGS "/GS /guard:cf")
+	set(OPTIMIZATION_FLAGS "/O2 /Oi /Ob2 /Ot /DNDEBUG /GL")
+
+	set(CMAKE_C_FLAGS_DEBUG "${GENERAL_FLAGS} ${WARNING_FLAGS} ${SECURITY_FLAGS} /Od /Ob0 /Zi /MTd /fsanitize=address")
+	set(CMAKE_CXX_FLAGS_DEBUG "${GENERAL_FLAGS} ${WARNING_FLAGS} ${SECURITY_FLAGS} /Od /Ob0 /Zi /MTd /fsanitize=address")
+
+	set(CMAKE_C_FLAGS_RELEASE "${GENERAL_FLAGS} ${WARNING_FLAGS} ${SECURITY_FLAGS} ${OPTIMIZATION_FLAGS} /MT")
+	set(CMAKE_CXX_FLAGS_RELEASE "${GENERAL_FLAGS} ${WARNING_FLAGS} ${SECURITY_FLAGS} ${OPTIMIZATION_FLAGS} /MT")
+
+	set(CMAKE_C_FLAGS_RELWITHDEBINFO "${GENERAL_FLAGS} ${WARNING_FLAGS} ${SECURITY_FLAGS} /Ob1 /Ot /Zi /MT")
+	set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${GENERAL_FLAGS} ${WARNING_FLAGS} ${SECURITY_FLAGS} /Ob1 /Ot /Zi /MT")
+
+elseif (CMAKE_CXX_COMPILER_ID MATCHES Clang)
+	set(GENERAL_FLAGS "-pthread")
+	set(WARNING_FLAGS "-Wall -Wextra -Wno-undefined-internal")
+	set(OPTIMIZATION_FLAGS "-Ofast -funroll-loops -fmerge-all-constants")
+
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+	set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${GENERAL_FLAGS} ${WARNING_FLAGS} ${OPTIMIZATION_FLAGS}")
+endif()
@@ -42,7 +42,8 @@ TEST(crypto, derivation)
 				if (result) {
 					f >> expected_derivation;
 				}
-				ASSERT_EQ(p2pool::generate_key_derivation(key1, key2, derivation), result);
+				uint8_t view_tag;
+				ASSERT_EQ(p2pool::generate_key_derivation(key1, key2, 0, derivation, view_tag), result);
 				if (result) {
 					ASSERT_EQ(derivation, expected_derivation);
 				}
@@ -61,6 +62,20 @@ TEST(crypto, derivation)
 					ASSERT_EQ(derived_key, expected_derived_key);
 				}
 			}
+			else if (name == "derive_view_tag") {
+				hash derivation;
+				uint64_t output_index;
+				std::string result_str;
+				f >> derivation >> output_index >> result_str;
+				uint8_t view_tag;
+				p2pool::derive_view_tag(derivation, output_index, view_tag);
+
+				char buf[log::Stream::BUF_SIZE + 1];
+				log::Stream s(buf);
+				s << log::hex_buf(&view_tag, 1) << '\0';
+
+				ASSERT_EQ(buf, result_str);
+			}
 		} while (!f.eof());
 	}

@@ -542,3 +542,73 @@ derive_public_key 5ea95a51ab11b80c7d09d0c8f8952b70c67e81d0fd421bbed43ab77c1b7b30
 derive_public_key 2c312ef971def53361274c37a90bfde86f959d877a636ea641a9c976ee80c7e3 121 b611ebd2bcfefc81cb772e35e3dd0204575cb0da644f68d4f9828a2683861e6c false
 derive_public_key 6fa161dd958022caf185faf873dd9adbc5578352cda505e84fff7cc99a8762a7 333934910 c2b56e207862958751d49643f23079009092c32bf82179a1295e3b85a385c1c3 false
 derive_public_key d85725562544e1984048391413a6112eb221bd217db3baaa9843bee331000e8e 21880446 f3148c3041e634d829e5df463ba3b1d64df282d620d63485e1f10024e003b939 false
+derive_view_tag 0fc47054f355ced4d67de73bfa12e4c78ff19089548fffa7d07a674741860f97 0 76
+derive_view_tag 0fc47054f355ced4d67de73bfa12e4c78ff19089548fffa7d07a674741860f97 1 d6
+derive_view_tag 0fc47054f355ced4d67de73bfa12e4c78ff19089548fffa7d07a674741860f97 2 87
+derive_view_tag 0fc47054f355ced4d67de73bfa12e4c78ff19089548fffa7d07a674741860f97 3 1b
+derive_view_tag 0fc47054f355ced4d67de73bfa12e4c78ff19089548fffa7d07a674741860f97 12 d6
+derive_view_tag 0fc47054f355ced4d67de73bfa12e4c78ff19089548fffa7d07a674741860f97 13 e9
+derive_view_tag 0fc47054f355ced4d67de73bfa12e4c78ff19089548fffa7d07a674741860f97 14 12
+derive_view_tag 0fc47054f355ced4d67de73bfa12e4c78ff19089548fffa7d07a674741860f97 15 26
+derive_view_tag 0fc47054f355ced4d67de73bfa12e4c78ff19089548fffa7d07a674741860f97 127 2c
+derive_view_tag 0fc47054f355ced4d67de73bfa12e4c78ff19089548fffa7d07a674741860f97 128 11
+derive_view_tag a36ba7b4d31349ad278a6df8f77adb76748b59f4929348e67dd92adb9fa174dc 0 70
+derive_view_tag a36ba7b4d31349ad278a6df8f77adb76748b59f4929348e67dd92adb9fa174dc 1 81
+derive_view_tag a36ba7b4d31349ad278a6df8f77adb76748b59f4929348e67dd92adb9fa174dc 2 a0
+derive_view_tag a36ba7b4d31349ad278a6df8f77adb76748b59f4929348e67dd92adb9fa174dc 3 ec
+derive_view_tag a36ba7b4d31349ad278a6df8f77adb76748b59f4929348e67dd92adb9fa174dc 12 22
+derive_view_tag a36ba7b4d31349ad278a6df8f77adb76748b59f4929348e67dd92adb9fa174dc 13 0a
+derive_view_tag a36ba7b4d31349ad278a6df8f77adb76748b59f4929348e67dd92adb9fa174dc 14 87
+derive_view_tag a36ba7b4d31349ad278a6df8f77adb76748b59f4929348e67dd92adb9fa174dc 15 76
+derive_view_tag a36ba7b4d31349ad278a6df8f77adb76748b59f4929348e67dd92adb9fa174dc 127 4b
+derive_view_tag a36ba7b4d31349ad278a6df8f77adb76748b59f4929348e67dd92adb9fa174dc 128 39
+derive_view_tag 7498d5bf0b69e08653f6d420a17f866dd2bd490ab43074f46065cb501fe7e2d8 0 93
+derive_view_tag 7498d5bf0b69e08653f6d420a17f866dd2bd490ab43074f46065cb501fe7e2d8 1 67
+derive_view_tag 7498d5bf0b69e08653f6d420a17f866dd2bd490ab43074f46065cb501fe7e2d8 2 9d
+derive_view_tag 7498d5bf0b69e08653f6d420a17f866dd2bd490ab43074f46065cb501fe7e2d8 3 2d
+derive_view_tag 7498d5bf0b69e08653f6d420a17f866dd2bd490ab43074f46065cb501fe7e2d8 12 63
+derive_view_tag 7498d5bf0b69e08653f6d420a17f866dd2bd490ab43074f46065cb501fe7e2d8 13 cf
+derive_view_tag 7498d5bf0b69e08653f6d420a17f866dd2bd490ab43074f46065cb501fe7e2d8 14 ef
+derive_view_tag 7498d5bf0b69e08653f6d420a17f866dd2bd490ab43074f46065cb501fe7e2d8 15 10
+derive_view_tag 7498d5bf0b69e08653f6d420a17f866dd2bd490ab43074f46065cb501fe7e2d8 127 fc
+derive_view_tag 7498d5bf0b69e08653f6d420a17f866dd2bd490ab43074f46065cb501fe7e2d8 128 73
+derive_view_tag fe7770c4b076e95ddb8026affcfab39d31c7c4a2266e0e25e343bc4badc907d0 0 90
+derive_view_tag fe7770c4b076e95ddb8026affcfab39d31c7c4a2266e0e25e343bc4badc907d0 1 5a
+derive_view_tag fe7770c4b076e95ddb8026affcfab39d31c7c4a2266e0e25e343bc4badc907d0 2 de
+derive_view_tag fe7770c4b076e95ddb8026affcfab39d31c7c4a2266e0e25e343bc4badc907d0 3 21
+derive_view_tag fe7770c4b076e95ddb8026affcfab39d31c7c4a2266e0e25e343bc4badc907d0 12 57
+derive_view_tag fe7770c4b076e95ddb8026affcfab39d31c7c4a2266e0e25e343bc4badc907d0 13 52
+derive_view_tag fe7770c4b076e95ddb8026affcfab39d31c7c4a2266e0e25e343bc4badc907d0 14 6f
+derive_view_tag fe7770c4b076e95ddb8026affcfab39d31c7c4a2266e0e25e343bc4badc907d0 15 eb
+derive_view_tag fe7770c4b076e95ddb8026affcfab39d31c7c4a2266e0e25e343bc4badc907d0 127 93
+derive_view_tag fe7770c4b076e95ddb8026affcfab39d31c7c4a2266e0e25e343bc4badc907d0 128 dc
+derive_view_tag ea9337d0ddf480abdc4fc56a0cb223702729cb230ae7b9de50243ad25ce90e8d 0 c6
+derive_view_tag ea9337d0ddf480abdc4fc56a0cb223702729cb230ae7b9de50243ad25ce90e8d 1 60
+derive_view_tag ea9337d0ddf480abdc4fc56a0cb223702729cb230ae7b9de50243ad25ce90e8d 2 f0
+derive_view_tag ea9337d0ddf480abdc4fc56a0cb223702729cb230ae7b9de50243ad25ce90e8d 3 71
+derive_view_tag ea9337d0ddf480abdc4fc56a0cb223702729cb230ae7b9de50243ad25ce90e8d 12 0e
+derive_view_tag ea9337d0ddf480abdc4fc56a0cb223702729cb230ae7b9de50243ad25ce90e8d 13 42
+derive_view_tag ea9337d0ddf480abdc4fc56a0cb223702729cb230ae7b9de50243ad25ce90e8d 14 b2
+derive_view_tag ea9337d0ddf480abdc4fc56a0cb223702729cb230ae7b9de50243ad25ce90e8d 15 61
+derive_view_tag ea9337d0ddf480abdc4fc56a0cb223702729cb230ae7b9de50243ad25ce90e8d 127 c3
+derive_view_tag ea9337d0ddf480abdc4fc56a0cb223702729cb230ae7b9de50243ad25ce90e8d 128 0a
+derive_view_tag 25d538315bcb81aff9574189ea65f418aeb0392f5cbbc84cd8a33c7ade31ef0a 0 4c
+derive_view_tag 25d538315bcb81aff9574189ea65f418aeb0392f5cbbc84cd8a33c7ade31ef0a 1 9b
+derive_view_tag 25d538315bcb81aff9574189ea65f418aeb0392f5cbbc84cd8a33c7ade31ef0a 2 64
+derive_view_tag 25d538315bcb81aff9574189ea65f418aeb0392f5cbbc84cd8a33c7ade31ef0a 3 ff
+derive_view_tag 25d538315bcb81aff9574189ea65f418aeb0392f5cbbc84cd8a33c7ade31ef0a 12 e3
+derive_view_tag 25d538315bcb81aff9574189ea65f418aeb0392f5cbbc84cd8a33c7ade31ef0a 13 24
+derive_view_tag 25d538315bcb81aff9574189ea65f418aeb0392f5cbbc84cd8a33c7ade31ef0a 14 ea
+derive_view_tag 25d538315bcb81aff9574189ea65f418aeb0392f5cbbc84cd8a33c7ade31ef0a 15 3b
+derive_view_tag 25d538315bcb81aff9574189ea65f418aeb0392f5cbbc84cd8a33c7ade31ef0a 127 47
+derive_view_tag 25d538315bcb81aff9574189ea65f418aeb0392f5cbbc84cd8a33c7ade31ef0a 128 5a
+derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 0 74
+derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 1 77
+derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 2 a9
+derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 3 44
+derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 12 75
+derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 13 05
+derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 14 ca
+derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 15 00
+derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 127 a6
+derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 128 0d
@@ -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);
 		}
 	}
 }
@@ -55,7 +55,7 @@ TEST(hash, empty)
 	hash h;
 	ASSERT_EQ(h.empty(), true);

-	for (int i = 0; i < HASH_SIZE; ++i) {
+	for (size_t i = 0; i < HASH_SIZE; ++i) {
 		hash h2;
 		h2.h[i] = 1;
 		ASSERT_EQ(h2.empty(), false);
@@ -0,0 +1,93 @@
+/*
+ * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
+ * 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
+ * the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common.h"
+#include "util.h"
+#include "gtest/gtest.h"
+
+namespace p2pool {
+
+TEST(util, varint)
+{
+	std::vector<uint8_t> v;
+	v.reserve(16);
+
+	uint64_t check;
+
+	// 0...2^7 - 1
+	for (uint64_t value = 0; value < 0x80; ++value) {
+		v.clear();
+		writeVarint(value, v);
+		ASSERT_EQ(v.size(), 1);
+		ASSERT_EQ(v[0], value);
+		ASSERT_EQ(readVarint(v.data(), v.data() + v.size(), check), v.data() + v.size());
+		ASSERT_EQ(check, value);
+	}
+
+	// 2^7...2^14 - 1
+	for (uint64_t value = 0x80; value < 0x4000; ++value) {
+		v.clear();
+		writeVarint(value, v);
+		ASSERT_EQ(v.size(), 2);
+		ASSERT_EQ(v[0], (value & 0x7F) | 0x80);
+		ASSERT_EQ(v[1], value >> 7);
+		ASSERT_EQ(readVarint(v.data(), v.data() + v.size(), check), v.data() + v.size());
+		ASSERT_EQ(check, value);
+	}
+
+	// 2^14...2^21 - 1
+	for (uint64_t value = 0x4000; value < 0x200000; ++value) {
+		v.clear();
+		writeVarint(value, v);
+		ASSERT_EQ(v.size(), 3);
+		ASSERT_EQ(v[0], (value & 0x7F) | 0x80);
+		ASSERT_EQ(v[1], ((value >> 7) & 0x7F) | 0x80);
+		ASSERT_EQ(v[2], value >> 14);
+		ASSERT_EQ(readVarint(v.data(), v.data() + v.size(), check), v.data() + v.size());
+		ASSERT_EQ(check, value);
+	}
+
+	// 2^64 - 1
+	v.clear();
+	writeVarint(std::numeric_limits<uint64_t>::max(), v);
+	ASSERT_EQ(v.size(), 10);
+	for (int i = 0; i < 9; ++i) {
+		ASSERT_EQ(v[i], 0xFF);
+	}
+	ASSERT_EQ(v[9], 1);
+	ASSERT_EQ(readVarint(v.data(), v.data() + v.size(), check), v.data() + v.size());
+	ASSERT_EQ(check, std::numeric_limits<uint64_t>::max());
+
+	// Invalid value 1
+	uint8_t buf[16];
+	memset(buf, -1, sizeof(buf));
+	ASSERT_EQ(readVarint(buf, buf + sizeof(buf), check), nullptr);
+
+	// Invalid value 2
+	uint8_t buf2[1] = { 0x80 };
+	ASSERT_EQ(readVarint(buf2, buf2 + 1, check), nullptr);
+}
+
+TEST(util, bsr)
+{
+	for (uint64_t i = 0, x = 1; i <= 63; ++i, x <<= 1) {
+		ASSERT_EQ(bsr(x), i);
+		ASSERT_EQ(bsr_reference(x), i);
+	}
+}
+
+}
Author	SHA1	Message	Date
SChernykh	9a5be0a321	p2pool v2.1	2022-05-31 18:20:21 +02:00
SChernykh	c203f6eb0a	Fixed a new cppcheck issue	2022-05-31 16:51:09 +02:00
SChernykh	b713f4e702	CI: added Linux aarch64 build	2022-05-31 16:38:28 +02:00
SChernykh	111087d96a	Fixed block reward share calculation	2022-05-28 22:27:46 +02:00
SChernykh	9e7666d12f	Fixed data races	2022-05-28 21:46:50 +02:00
SChernykh	cb147773b5	Updated cppcheck workflow on Linux	2022-05-26 21:19:01 +02:00
SChernykh	d84bef8f14	Added block reward share percent to miner api	2022-05-26 11:08:16 +02:00
SChernykh	32bb318af4	Fixed cppcheck workflow on Windows	2022-05-25 20:05:17 +02:00
SChernykh	055b5e2256	Updated dependencies	2022-05-25 12:54:40 +02:00
SChernykh	c1754d122f	Update RandomX	2022-05-24 15:42:37 +02:00
SChernykh	6d121122f8	Fixed compiler warnings in tests	2022-05-24 15:18:09 +02:00
SChernykh	bfa8334aeb	Fixed executable stack	2022-05-23 21:41:17 +02:00
SChernykh	0e222afd6a	Exit if server startup fails	2022-05-23 15:50:25 +02:00
SChernykh	b191962d32	Handle startup errors without calling abort()	2022-05-23 09:37:11 +02:00
SChernykh	1cf13e142a	SideChain: fixed alternative chain detection	2022-05-16 15:59:48 +02:00
SChernykh	8f1f81749d	StratumServer: reset cumulative hashes too	2022-05-16 14:36:11 +02:00
SChernykh	72d70eba16	SideChain: added "synchronized" log message	2022-05-16 01:48:37 +02:00
SChernykh	ae3612f595	Fixed worker diff display when autodiff is off	2022-05-15 18:13:36 +02:00
SChernykh	37b6457054	Show worker hashrate only when autodiff is on	2022-05-15 01:15:21 +02:00
SChernykh	9579be5c7d	Optimized SideChain::miner_count()	2022-05-12 22:18:08 +02:00
SChernykh	d05d47fa75	Fixed compilation	2022-05-12 16:10:55 +02:00
SChernykh	bd88c04e9e	SideChain: mutex locks refactoring	2022-05-12 15:24:02 +02:00
SChernykh	eb3a3872eb	Fixed missing blocks download logic	2022-05-12 08:49:34 +02:00
SChernykh	5cea7be405	Allow only one pending get_miner_data	2022-05-12 01:09:59 +02:00
SChernykh	516c382fe4	Update keccak.cpp	2022-05-11 16:13:00 +02:00
SChernykh	710e55422a	Ignore duplicate get_miner_data	2022-05-11 16:10:10 +02:00
SChernykh	3406cf78b4	Don't return stale chain tip to other peers	2022-05-11 15:07:54 +02:00
SChernykh	8fa354796c	Reload peer list when there are no connections	2022-05-11 14:09:28 +02:00
SChernykh	6c6ef1c1b8	Restart ZMQ connection if it looks dead	2022-05-11 13:50:47 +02:00
SChernykh	c3c326c680	Suppress MSVC warnings	2022-05-11 10:55:36 +02:00
SChernykh	92e20485b2	Log: don't allow side effects in LOG() calls	2022-05-10 21:41:53 +02:00
SChernykh	edd782ac23	Fixed custom worker names	2022-05-10 14:01:10 +02:00
SChernykh	a4d84e318d	TCPServer: refactored Client constructor	2022-05-09 19:13:34 +02:00
SChernykh	08ee599f79	Use the same compilation flags for tests	2022-05-09 17:57:31 +02:00
SChernykh	134f2d68a3	Fixed data races	2022-05-09 16:10:55 +02:00
SChernykh	d23c46ff84	Added bsr() function to util	2022-05-09 13:02:06 +02:00
SChernykh	820c5db5e8	Log: check for logrotate only once per loop	2022-05-09 09:58:43 +02:00
SChernykh	990916ab62	StratumServer: added autodiff Autodiff is enabled by default, target time is 30 seconds. It can be disabled with `--no-autodiff` command line option.	2022-05-08 19:03:00 +02:00
SChernykh	d4e362cd76	TCPServer: optimized Client struct size	2022-05-07 12:35:31 +02:00
SChernykh	1dd06cc509	Removed std::string to avoid memory allocation	2022-05-07 11:00:29 +02:00
SChernykh	2e2bd1d137	Added log padding	2022-05-06 20:04:01 +02:00
SChernykh	0818d91f4f	StratumServer: added console command `workers`	2022-05-06 13:19:56 +02:00
SChernykh	6e1f34b168	Termux build instructions	2022-05-05 15:53:04 +02:00
SChernykh	1a35177633	Fixed unsafe usage of log::Stream buffers	2022-05-05 14:38:56 +02:00
SChernykh	c45689b02b	Fixed pthread_cancel detection	2022-05-03 21:03:06 +02:00
SChernykh	8f27d940e3	Don't ban localhost	2022-05-03 13:11:55 +02:00
SChernykh	6b4640c413	Fixes for Termux	2022-05-03 07:32:47 +02:00
SChernykh	8aebcdc580	p2pool v2.0	2022-04-30 17:50:27 +02:00
SChernykh	e23a2e77a8	Updated dependencies	2022-04-30 12:10:09 +02:00
SChernykh	0f9362e14e	More tests for derive_view_tag	2022-04-29 22:25:22 +02:00
SChernykh	ab974b9684	Monero network upgrade information	2022-04-29 14:35:06 +02:00
SChernykh	54acfee036	Merge pull request #144 from SChernykh/view_tags v15 hardfork changes	2022-04-27 19:56:42 +02:00
SChernykh	a78ddb50d5	Fixed logger thread timing logic	2022-04-24 16:22:22 +02:00
SChernykh	b2f86a5f6b	Ban peers with stuck or lagging monerod	2022-04-23 11:29:17 +02:00
SChernykh	2a77695832	Fixed data races in miner	2022-04-09 18:25:12 +02:00
SChernykh	21d8cb917b	Fixed data race in logger	2022-04-09 10:41:20 +02:00
SChernykh	2c70bf8616	View tags support See http://github.com/monero-project/monero/pull/8061	2022-04-09 00:56:42 +02:00
SChernykh	7522111bb7	Fixed data races	2022-04-09 00:38:15 +02:00
SChernykh	7b5b910f3f	Undefined behaviour fixes	2022-04-08 22:49:08 +02:00
SChernykh	afb52e4235	Check return value (Coverity fix)	2022-04-07 19:33:39 +02:00
SChernykh	93cd9a659a	Code cleanup	2022-04-07 19:11:20 +02:00
SChernykh	9e287ab4f0	Logger fixes - Fixed a race condition when stopping the logger - Flush log file only once per batch of log lines	2022-04-07 16:55:35 +02:00
SChernykh	094209f311	P2PServer: optimized update_peer_connections()	2022-04-07 16:48:01 +02:00
SChernykh	dee66c3f32	Added varint unit tests	2022-04-06 16:34:16 +02:00
SChernykh	32533e3c96	FreeBSD build	2022-04-05 19:36:37 +02:00
SChernykh	a073923a82	Updated dependencies	2022-04-05 11:32:39 +02:00
SChernykh	3484b24caa	Updated dependencies	2022-04-04 19:56:42 +02:00
SChernykh	1b3c1eb850	P2PServer: increased peer timeout to 15 minutes	2022-03-30 22:47:10 +02:00
SChernykh	7fe032915f	Ignore SIGPIPE	2022-03-30 21:53:52 +02:00
SChernykh	5b9b73abcc	p2pool v1.9	2022-03-30 20:15:47 +02:00
SChernykh	a2afa29052	Updated copyright	2022-03-30 14:42:26 +02:00
SChernykh	a2d3dbad5e	Use old bock template when update fails	2022-03-30 10:11:35 +02:00
SChernykh	e50cf060cb	Miner: fixed share counter initialization	2022-03-30 08:34:22 +02:00
SChernykh	915988d694	Added logging for the extra_nonce fix	2022-03-30 07:59:59 +02:00
SChernykh	345c231a9a	Update config.json	2022-03-28 19:12:21 +02:00
SChernykh	a7aed2f221	Fixed miner tx creation	2022-03-28 11:28:56 +02:00
SChernykh	292e2580e5	Make sure dataset init doesn't block start	2022-03-24 20:55:35 +01:00
SChernykh	028a5d0c88	Fixed memory leak after loading block cache	2022-03-24 18:30:23 +01:00
SChernykh	8b27faad6d	BlockCache: fixed collisions of same height blocks	2022-03-24 16:03:12 +01:00
SChernykh	cdc3206ee8	Optimized keccak	2022-03-24 12:52:57 +01:00
SChernykh	0c2b7d6010	More time handling fixes	2022-03-23 15:49:24 +01:00
SChernykh	ef15c3b54f	Show sidechain ID in status	2022-03-23 14:17:40 +01:00
SChernykh	f4bcdc7fe9	Use steady_clock to time peer list requests	2022-03-23 11:37:05 +01:00
SChernykh	aada1bb5cc	Use chrono::steady_clock for internal timestamps	2022-03-23 11:30:38 +01:00
SChernykh	796850d8c5	Update CMakeLists.txt	2022-03-18 14:53:30 +01:00
SChernykh	ab0bc0488e	Removed libsodium as it's not used in compilation	2022-03-18 14:43:23 +01:00
SChernykh	f3af02111d	Update README.md	2022-03-18 10:31:06 +01:00
SChernykh	c21d052d7a	Refactored RNG usage across the code	2022-03-17 16:14:29 +01:00
SChernykh	62b1690780	Added an option to disable RandomX for the build	2022-03-15 17:11:45 +01:00
SChernykh	52050bbcfb	Update difficulty_type_tests.cpp	2022-03-10 19:11:49 +01:00