p2pool v2.2.1

16-bit wrap around wasn't processed correctly

.dockerignore

@@ -0,0 +1 @@
+**/build

.github/workflows/c-cpp.yml

@@ -1,10 +1,6 @@
 name: C/C++ CI
 
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
+on: [push, pull_request]
 
 jobs:
   build-ubuntu:
@@ -22,7 +18,7 @@ jobs:
       run: |
         sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
         sudo apt update
-        sudo apt install -y git build-essential cmake libuv1-dev libzmq3-dev libsodium-dev libpgm-dev libnorm-dev libgss-dev ${{ matrix.config.c }} ${{ matrix.config.cpp }}
+        sudo apt install -y git build-essential cmake libuv1-dev libzmq3-dev libsodium-dev libpgm-dev libnorm-dev libgss-dev libcurl4-openssl-dev libidn2-0-dev ${{ matrix.config.c }} ${{ matrix.config.cpp }}
 
     - name: Checkout repository
       uses: actions/checkout@v2
@@ -34,7 +30,7 @@ jobs:
         mkdir build
         cd build
         cmake .. -DCMAKE_C_COMPILER=${{ matrix.config.c }} -DCMAKE_CXX_COMPILER=${{ matrix.config.cpp }}
-        make -j2
+        make -j$(nproc)
 
     - name: Build tests
       run: |
@@ -42,7 +38,7 @@ jobs:
         mkdir build
         cd build
         cmake .. -DCMAKE_C_COMPILER=${{ matrix.config.c }} -DCMAKE_CXX_COMPILER=${{ matrix.config.cpp }}
-        make -j2
+        make -j$(nproc)
 
     - name: Run tests
       run: cd tests/build && ./p2pool_tests
@@ -53,6 +49,121 @@ jobs:
         name: p2pool-${{ matrix.config.os }}
         path: build/p2pool
 
+  build-ubuntu-static-libs:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Install dependencies
+      run: |
+        sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+        sudo apt update
+        sudo apt install -y git build-essential cmake autoconf libgss-dev gcc-11 g++-11
+        sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 100 --slave /usr/bin/g++ g++ /usr/bin/g++-11 --slave /usr/bin/gcov gcov /usr/bin/gcov-11
+
+    - name: Checkout repository
+      uses: actions/checkout@v2
+      with:
+        submodules: true
+
+    - name: Build libcurl
+      run: |
+        cd external/src/curl
+        autoreconf -fi
+        ./configure --without-ssl --without-hyper --without-zlib --without-brotli --without-zstd --without-default-ssl-backend --without-ca-bundle --without-ca-path --without-ca-fallback --without-libpsl --without-libgsasl --without-librtmp --without-winidn --without-libidn2 --without-nghttp2 --without-ngtcp2 --without-nghttp3 --without-quiche --without-msh3 --without-zsh-functions-dir --without-fish-functions-dir --disable-ftp --disable-file --disable-ldap --disable-ldaps --disable-rtsp --disable-proxy --disable-dict --disable-telnet --disable-tftp --disable-pop3 --disable-imap --disable-smb --disable-smtp --disable-gopher --disable-mqtt --disable-manual --disable-ntlm --disable-ntlm-wb --disable-tls-srp --disable-unix-sockets --disable-cookies --disable-socketpair --disable-doh --disable-dateparse --disable-netrc --disable-progress-meter --disable-dnsshuffle --disable-hsts --disable-alt-svc --disable-ares
+        make -j$(nproc)
+
+    - name: Build libuv
+      run: |
+        cd external/src/libuv
+        mkdir build
+        cd build
+        cmake .. -DBUILD_TESTING=OFF
+        make -j$(nproc)
+
+    - name: Build libzmq
+      run: |
+        cd external/src/libzmq
+        mkdir build
+        cd build
+        cmake .. -DWITH_TLS=OFF -DWITH_LIBSODIUM=OFF -DWITH_LIBBSD=OFF -DBUILD_TESTS=OFF
+        make -j$(nproc)
+
+    - name: Build p2pool
+      run: |
+        mkdir build
+        cd build
+        cmake .. -DSTATIC_LIBS=ON
+        make -j$(nproc)
+
+    - name: Build tests
+      run: |
+        cd tests
+        mkdir build
+        cd build
+        cmake .. -DSTATIC_LIBS=ON
+        make -j$(nproc)
+
+    - name: Run tests
+      run: cd tests/build && ./p2pool_tests
+
+    - name: Archive binary
+      uses: actions/upload-artifact@v2
+      with:
+        name: p2pool-ubuntu-static-libs
+        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 autoconf gcc-aarch64-linux-gnu g++-aarch64-linux-gnu binutils-aarch64-linux-gnu
+
+    - name: Checkout repository
+      uses: actions/checkout@v2
+      with:
+        submodules: true
+
+    - name: Build libcurl
+      run: |
+        cd external/src/curl
+        autoreconf -fi
+        ./configure --host=aarch64-linux-gnu --without-ssl --without-hyper --without-zlib --without-brotli --without-zstd --without-default-ssl-backend --without-ca-bundle --without-ca-path --without-ca-fallback --without-libpsl --without-libgsasl --without-librtmp --without-winidn --without-libidn2 --without-nghttp2 --without-ngtcp2 --without-nghttp3 --without-quiche --without-msh3 --without-zsh-functions-dir --without-fish-functions-dir --disable-ftp --disable-file --disable-ldap --disable-ldaps --disable-rtsp --disable-proxy --disable-dict --disable-telnet --disable-tftp --disable-pop3 --disable-imap --disable-smb --disable-smtp --disable-gopher --disable-mqtt --disable-manual --disable-ntlm --disable-ntlm-wb --disable-tls-srp --disable-unix-sockets --disable-cookies --disable-socketpair --disable-doh --disable-dateparse --disable-netrc --disable-progress-meter --disable-dnsshuffle --disable-hsts --disable-alt-svc --disable-ares
+        make -j$(nproc)
+
+    - 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++ -DBUILD_TESTING=OFF
+        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
@@ -71,22 +182,45 @@ jobs:
       uses: eine/setup-msys2@v2
       with:
         update: true
-        install: mingw-w64-x86_64-toolchain make mingw-w64-x86_64-cmake mingw-w64-x86_64-zeromq mingw-w64-x86_64-libsodium mingw-w64-x86_64-libuv
+        install: mingw-w64-x86_64-toolchain mingw-w64-x86_64-cmake make autoconf libtool automake
+
+    - name: Build libcurl
+      run: |
+        cd external/src/curl
+        autoreconf -fi
+        ./configure --without-ssl --without-hyper --without-zlib --without-brotli --without-zstd --without-default-ssl-backend --without-ca-bundle --without-ca-path --without-ca-fallback --without-libpsl --without-libgsasl --without-librtmp --without-winidn --without-libidn2 --without-nghttp2 --without-ngtcp2 --without-nghttp3 --without-quiche --without-msh3 --without-zsh-functions-dir --without-fish-functions-dir --disable-ftp --disable-file --disable-ldap --disable-ldaps --disable-rtsp --disable-proxy --disable-dict --disable-telnet --disable-tftp --disable-pop3 --disable-imap --disable-smb --disable-smtp --disable-gopher --disable-mqtt --disable-manual --disable-ntlm --disable-ntlm-wb --disable-tls-srp --disable-unix-sockets --disable-cookies --disable-socketpair --disable-doh --disable-dateparse --disable-netrc --disable-progress-meter --disable-dnsshuffle --disable-hsts --disable-alt-svc --disable-ares
+        make -j$(nproc)
+
+    - name: Build libuv
+      run: |
+        cd external/src/libuv
+        mkdir build
+        cd build
+        cmake .. -G "Unix Makefiles" -DBUILD_TESTING=OFF
+        make -j$(nproc)
+
+    - name: Build libzmq
+      run: |
+        cd external/src/libzmq
+        mkdir build
+        cd build
+        cmake .. -G "Unix Makefiles" -DWITH_TLS=OFF -DWITH_LIBSODIUM=OFF -DWITH_LIBBSD=OFF -DBUILD_TESTS=OFF -DZMQ_HAVE_IPC=OFF
+        make -j$(nproc)
 
     - name: Build p2pool
       run: |
         mkdir build
         cd build
-        cmake .. -G "Unix Makefiles"
-        make -j2
+        cmake .. -G "Unix Makefiles" -DSTATIC_LIBS=ON
+        make -j$(nproc)
 
     - name: Build tests
       run: |
         cd tests
         mkdir build
         cd build
-        cmake .. -G "Unix Makefiles"
-        make -j2
+        cmake .. -G "Unix Makefiles" -DSTATIC_LIBS=ON
+        make -j$(nproc)
 
     - name: Run tests
       run: |
@@ -160,14 +294,21 @@ jobs:
         submodules: recursive
 
     - name: Install dependencies
-      run: HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake
+      run: HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake autoconf libtool automake
+
+    - name: Build libcurl
+      run: |
+        cd external/src/curl
+        autoreconf -fi
+        ./configure --without-ssl --without-hyper --without-zlib --without-brotli --without-zstd --without-default-ssl-backend --without-ca-bundle --without-ca-path --without-ca-fallback --without-libpsl --without-libgsasl --without-librtmp --without-winidn --without-libidn2 --without-nghttp2 --without-ngtcp2 --without-nghttp3 --without-quiche --without-msh3 --without-zsh-functions-dir --without-fish-functions-dir --disable-ftp --disable-file --disable-ldap --disable-ldaps --disable-rtsp --disable-proxy --disable-dict --disable-telnet --disable-tftp --disable-pop3 --disable-imap --disable-smb --disable-smtp --disable-gopher --disable-mqtt --disable-manual --disable-ntlm --disable-ntlm-wb --disable-tls-srp --disable-unix-sockets --disable-cookies --disable-socketpair --disable-doh --disable-dateparse --disable-netrc --disable-progress-meter --disable-dnsshuffle --disable-hsts --disable-alt-svc --disable-ares
+        make -j3
 
     - name: Build libuv
       run: |
         cd external/src/libuv
         mkdir build
         cd build
-        cmake ..
+        cmake .. -DBUILD_TESTING=OFF
         make -j3
 
     - name: Build libzmq
@@ -175,7 +316,7 @@ jobs:
         cd external/src/libzmq
         mkdir build
         cd build
-        cmake .. -DWITH_TLS=OFF -DWITH_LIBSODIUM=OFF
+        cmake .. -DWITH_TLS=OFF -DWITH_LIBSODIUM=OFF -DWITH_LIBBSD=OFF -DBUILD_TESTS=OFF
         make -j3
 
     - name: Build p2pool

.github/workflows/codeql-analysis.yml

@@ -13,10 +13,7 @@ name: "CodeQL"
 
 on:
   push:
-    branches: [ master ]
   pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ master ]
   schedule:
     - cron: '44 11 * * 0'
 
@@ -40,7 +37,7 @@ jobs:
     steps:
     - name: Install dependencies
       run: |
-          sudo apt update && sudo apt install git build-essential cmake libuv1-dev libzmq3-dev libsodium-dev libpgm-dev libnorm-dev libgss-dev
+          sudo apt update && sudo apt install git build-essential cmake libuv1-dev libzmq3-dev libsodium-dev libpgm-dev libnorm-dev libgss-dev libcurl4-openssl-dev libidn2-0-dev
 
     - name: Checkout repository
       uses: actions/checkout@v2
@@ -49,7 +46,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v2
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -60,7 +57,7 @@ jobs:
     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
+      uses: github/codeql-action/autobuild@v2
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -74,4 +71,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v2

.github/workflows/cppcheck.yml

@@ -1,10 +1,6 @@
 name: cppcheck
 
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
+on: [push, pull_request]
 
 jobs:
   cppcheck-ubuntu:
@@ -12,14 +8,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 +34,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
 

.github/workflows/msvc-analysis.yml

@@ -10,9 +10,7 @@ name: Microsoft C++ Code Analysis
 
 on:
   push:
-    branches: [ master ]
   pull_request:
-    branches: [ master ]
   schedule:
     - cron: '40 10 * * 0'
 
@@ -51,7 +49,7 @@ jobs:
 
       # Upload SARIF file to GitHub Code Scanning Alerts
       - name: Upload SARIF to GitHub
-        uses: github/codeql-action/upload-sarif@v1
+        uses: github/codeql-action/upload-sarif@v2
         with:
           sarif_file: ${{ steps.run-analysis.outputs.sarif }}
 

.gitmodules

@@ -19,3 +19,6 @@
 [submodule "external/src/robin-hood-hashing"]
 	path = external/src/robin-hood-hashing
 	url = https://github.com/SChernykh/robin-hood-hashing
+[submodule "external/src/curl"]
+	path = external/src/curl
+	url = https://github.com/SChernykh/curl

CMakeLists.txt

@@ -1,14 +1,13 @@
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.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") 
-	set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT p2pool)
-endif()
+set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT p2pool)
 
 if (WITH_RANDOMX)
 	add_definitions(-DWITH_RANDOMX)
@@ -20,7 +19,6 @@ include(cmake/flags.cmake)
 
 set(HEADERS
 	external/src/cryptonote/crypto-ops.h
-	external/src/llhttp/llhttp.h
 	src/block_cache.h
 	src/block_template.h
 	src/common.h
@@ -51,9 +49,6 @@ set(HEADERS
 set(SOURCES
 	external/src/cryptonote/crypto-ops-data.c
 	external/src/cryptonote/crypto-ops.c
-	external/src/llhttp/api.c
-	external/src/llhttp/http.c
-	external/src/llhttp/llhttp.c
 	src/block_cache.cpp
 	src/block_template.cpp
 	src/console_commands.cpp
@@ -85,10 +80,10 @@ endif()
 include_directories(src)
 include_directories(external/src)
 include_directories(external/src/cryptonote)
+include_directories(external/src/curl/include)
 include_directories(external/src/libuv/include)
 include_directories(external/src/cppzmq)
 include_directories(external/src/libzmq/include)
-include_directories(external/src/llhttp)
 if (WITH_RANDOMX)
 	include_directories(external/src/RandomX/src)
 endif()
@@ -97,10 +92,11 @@ include_directories(external/src/robin-hood-hashing/src/include)
 
 if (WIN32)
 	set(LIBS ${LIBS} ws2_32 iphlpapi userenv psapi)
+	add_definitions(-DCURL_STATICLIB)
 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)
@@ -108,11 +104,20 @@ if (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
 	find_library(ZMQ_LIBRARY NAMES libzmq-v142-mt-s-4_3_5 PATHS "external/lib/libzmq/Release")
 	find_library(UV_LIBRARY_DEBUG NAMES uv_a PATHS "external/lib/libuv/Debug")
 	find_library(UV_LIBRARY NAMES uv_a PATHS "external/lib/libuv/Release")
+	find_library(CURL_LIBRARY_DEBUG NAMES libcurld PATHS "external/lib/libcurl/Debug")
+	find_library(CURL_LIBRARY NAMES libcurl PATHS "external/lib/libcurl/Release")
 elseif (CMAKE_CXX_COMPILER_ID MATCHES GNU OR CMAKE_CXX_COMPILER_ID MATCHES Clang)
 	find_library(ZMQ_LIBRARY_DEBUG NAMES zmq libzmq.a)
 	find_library(ZMQ_LIBRARY NAMES zmq libzmq.a)
 	find_library(UV_LIBRARY_DEBUG NAMES uv libuv.a)
 	find_library(UV_LIBRARY NAMES uv libuv.a)
+	if (WIN32)
+		find_library(CURL_LIBRARY_DEBUG NAMES libcurl.a PATHS "external/src/curl/lib/.libs" NO_DEFAULT_PATH)
+		find_library(CURL_LIBRARY NAMES libcurl.a PATHS "external/src/curl/lib/.libs" NO_DEFAULT_PATH)
+	else()
+		find_library(CURL_LIBRARY_DEBUG NAMES curl)
+		find_library(CURL_LIBRARY NAMES curl)
+	endif()
 	find_library(SODIUM_LIBRARY sodium)
 endif()
 
@@ -131,28 +136,62 @@ if (SODIUM_LIBRARY)
 	set(LIBS ${LIBS} ${SODIUM_LIBRARY})
 endif()
 
+if(APPLE)
+	find_library(FOUNDATION_LIB Foundation)
+	find_library(CORE_FOUNDATION_LIB CoreFoundation)
+	find_library(SYSTEM_CONFIGURATION_LIB SystemConfiguration)
+	set(LIBS ${LIBS} ${FOUNDATION_LIB} ${CORE_FOUNDATION_LIB} ${SYSTEM_CONFIGURATION_LIB})
+endif()
+
 add_definitions(/DZMQ_STATIC)
 
+set(CMAKE_REQUIRED_FLAGS "${GENERAL_FLAGS}")
+
+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)
-	add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_STRIP} ${CMAKE_PROJECT_NAME})
+if (STATIC_BINARY OR STATIC_LIBS)
+	if (WIN32)
+		add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_STRIP} "${CMAKE_PROJECT_NAME}.exe")
+	else()
+		add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_STRIP} ${CMAKE_PROJECT_NAME})
+	endif()
 
 	if (WITH_RANDOMX)
 		set(STATIC_LIBS randomx)
 	endif()
 
-	if (CMAKE_SYSTEM_NAME STREQUAL FreeBSD)
+	if (WIN32)
+		set(STATIC_LIBS ${STATIC_LIBS} ws2_32 iphlpapi userenv psapi wldap32)
+	elseif (CMAKE_SYSTEM_NAME STREQUAL FreeBSD)
 		set(STATIC_LIBS ${STATIC_LIBS} pthread)
-	elseif (NOT APPLE)
+	elseif (APPLE)
+		find_library(FOUNDATION_LIB Foundation)
+		find_library(CORE_FOUNDATION_LIB CoreFoundation)
+		find_library(SYSTEM_CONFIGURATION_LIB SystemConfiguration)
+		set(STATIC_LIBS ${STATIC_LIBS} ${FOUNDATION_LIB} ${CORE_FOUNDATION_LIB} ${SYSTEM_CONFIGURATION_LIB})
+	else()
 		set(STATIC_LIBS ${STATIC_LIBS} pthread dl)
 	endif()
 
 	target_link_libraries(${CMAKE_PROJECT_NAME}
 		"${CMAKE_SOURCE_DIR}/external/src/libzmq/build/lib/libzmq.a"
 		"${CMAKE_SOURCE_DIR}/external/src/libuv/build/libuv_a.a"
+		"${CMAKE_SOURCE_DIR}/external/src/curl/lib/.libs/libcurl.a"
 		${STATIC_LIBS}
 	)
 else()
-	target_link_libraries(${CMAKE_PROJECT_NAME} debug ${ZMQ_LIBRARY_DEBUG} debug ${UV_LIBRARY_DEBUG} optimized ${ZMQ_LIBRARY} optimized ${UV_LIBRARY} ${LIBS})
+	target_link_libraries(${CMAKE_PROJECT_NAME} debug ${ZMQ_LIBRARY_DEBUG} debug ${UV_LIBRARY_DEBUG} debug ${CURL_LIBRARY_DEBUG} optimized ${ZMQ_LIBRARY} optimized ${UV_LIBRARY} optimized ${CURL_LIBRARY} ${LIBS})
 endif()

Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:latest
+FROM ubuntu:20.04
 
 RUN set -e && \
     apt-get update -q -y --no-install-recommends && \
@@ -12,7 +12,8 @@ RUN set -e && \
         libsodium-dev \
         libpgm-dev \
         libnorm-dev \
-        libgss-dev
+        libgss-dev \
+        libcurl4-openssl-dev
 
 ADD . /usr/src/p2pool
 WORKDIR /usr/src/p2pool
@@ -24,7 +25,7 @@ RUN git submodule update --init --recursive && \
 
 # ---
 
-FROM ubuntu:latest
+FROM ubuntu:20.04
 COPY --from=0 /usr/src/p2pool/build/p2pool /
 
 RUN set -e && \
@@ -32,6 +33,7 @@ RUN set -e && \
     DEBIAN_FRONTEND="noninteractive" apt-get install -q -y --no-install-recommends \
     libzmq5 \
     libuv1 \
+    libcurl4 \
       && \
     apt-get clean
 
@@ -43,6 +45,7 @@ USER p2pool
 
 EXPOSE 3333
 EXPOSE 37889
+EXPOSE 37888
 
 VOLUME /home/p2pool/.p2pool
 

README.md

@@ -66,12 +66,12 @@ First you need to find a pool share. This share will stay in PPLNS window for 21
 
 ## 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 will undergo a network upgrade on August 13th, 2022 (block 2,688,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
+|v14 (active until August 13th, 2022)|v0.17.3.0 or newer|v1.0 or newer
+|v15, v16 (active after August 13th, 2022)|v0.18.0.0 or newer|v2.2 or newer
 
 ## How to mine on P2Pool
 
@@ -200,7 +200,7 @@ Please see the relevant instructions for your platform:
 
 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
+sudo apt update && sudo apt install git build-essential cmake libuv1-dev libzmq3-dev libsodium-dev libpgm-dev libnorm-dev libgss-dev libcurl4-openssl-dev libidn2-0-dev
 git clone --recursive https://github.com/SChernykh/p2pool
 cd p2pool
 mkdir build && cd build
@@ -208,9 +208,11 @@ cmake ..
 make -j$(nproc)
 ```
 
-### Arch Linux [AUR](https://wiki.archlinux.org/title/Arch_User_Repository)
+### [Arch Linux](https://archlinux.org/packages/community/x86_64/p2pool/)
 
-Make the package: [p2pool-git](https://aur.archlinux.org/packages/p2pool-git/)
+```
+pacman -S p2pool
+```
 
 ### [Nix/NixOS](https://nixos.org)
 
@@ -271,6 +273,18 @@ 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 libcurl
+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:

cmake/flags.cmake

@@ -6,14 +6,15 @@ set(CMAKE_C_STANDARD 99)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 
 if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
-	set(WARNING_FLAGS "-Wall -Wextra -Werror")
+	set(GENERAL_FLAGS "-pthread")
+	set(WARNING_FLAGS "-Wall -Wextra -Wcast-align -Wcast-qual -Wlogical-op -Wstrict-overflow=2 -Wundef -Wformat=2 -Wpointer-arith -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,27 @@ 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_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_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(WARNING_FLAGS "-Wall -Wextra -Wno-undefined-internal -Werror")
+	set(GENERAL_FLAGS "-pthread")
+	set(WARNING_FLAGS "-Wall -Wextra -Wno-undefined-internal -Wunreachable-code-aggressive -Wmissing-prototypes -Wmissing-variable-declarations -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()

cppcheck/includes.txt

@@ -1,10 +1,10 @@
 ../src/
 ../external/src/
 ../external/src/cryptonote/
-../external/src/libuv/
+../external/src/libuv/include/
 ../external/src/cppzmq/
-../external/src/libzmq/
-../external/src/llhttp/
+../external/src/libzmq/include/
+../external/src/curl/include
 ../external/src/RandomX/src/
 ../external/src/rapidjson/include
 ../external/src/robin-hood-hashing/src/include

cppcheck/run.cmd

@@ -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 (

cppcheck/run.sh

@@ -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

cppcheck/suppressions.txt

@@ -1,6 +1,3 @@
 missingIncludeSystem
 unusedFunction
 useStlAlgorithm
-functionStatic
-functionConst
-unmatchedSuppression

docker-compose/.env

@@ -1,42 +0,0 @@
-##
-# Monero Wallet Address for mining rewards (replace this with your own address)
-WALLET_ADDRESS="44MnN1f3Eto8DZYUWuE5XZNUtE3vcRzt2j6PzqWpPau34e6Cf4fAxt6X2MBmrm6F9YMEiMNjN6W4Shn4pLcfNAja621jwyg"
-
-##
-# p2pool settings
-#
-# Use p2pool-mini (uncomment to enable)
-#P2POOL_MINI="--mini"
-#
-# Which port to listen for miner connections
-P2POOL_STRATUM_PORT=3333
-#
-# How much logging - (Less) 0 - 6 (More)
-P2POOL_LOGLEVEL=2
-
-
-##
-# Monero Node Settings
-#
-# Version of Monero to build. Must be v0.17.3.0 or later for p2pool support. "latest" pulls the most recent release tag
-MONERO_GIT_TAG=latest
-#
-# Limit the size of the blockchain on disk (comment to disable)
-PRUNE_NODE="--prune-blockchain"
-#
-# Other monerod commandline options
-MONERO_EXTRA_OPTIONS=""
-
-
-##
-# Xmrig Miner Settings
-#
-# Submit shares at a lower fixed difficulty to show mining progress (comment to disable, edit to customize)
-FIXED_MINING_DIFFICULTY="-u x+500000"
-#
-# set process priority (0 idle, 2 normal to 5 highest)
-MINING_CPU_PRIORITY="--cpu-priority=2"
-#
-# Other XMRIG commandline options
-# See: https://xmrig.com/docs/miner/command-line-options
-XMRIG_EXTRA_OPTIONS=""

docker-compose/README.md

@@ -8,6 +8,8 @@ Run your own <b>Monero Node + P2Pool + XMRig</b> in Docker
 [Install Docker](https://docs.docker.com/engine/install/)  
 [Install Docker Compose](https://docs.docker.com/compose/install/)
 
+Note: The docker compose plugin uses the command "docker compose" while the pip installed command is "docker-compose".
+
 #### Clone the P2Pool project
 ```
 git clone --recursive https://github.com/SChernykh/p2pool
@@ -16,18 +18,18 @@ git clone --recursive https://github.com/SChernykh/p2pool
 #### Configure your Monero address for mining rewards
 ```
 cd p2pool/docker-compose
-vi .env
+./configure
 ```
-**WALLET_ADDRESS** is the only setting that needs to be updated in that file
+Make sure to set your own monero **Wallet Address**.  The default is to donate mining to P2Pool development.
 
 #### Build the docker containers
 ```
-docker-compose build
+docker compose build
 ```
 
-#### Run the node, pool, and CPU miner
+#### Run the node, pool, and CPU miner (or updated configuration)
 ```
-docker-compose up
+docker compose up
 ```
 
 #### Optional
@@ -38,15 +40,15 @@ docker-compose up
 
 
 #### Other usefull commands
-* You can **run everythng in the background** by adding the "-d" argument to the "docker-compose up" command: ```docker-compose up -d```
-* You can **stop everything** with CTRL-C or ```docker-compose down```
+* You can **run everything in the background** by adding the "-d" argument to the "docker compose up" command: ```docker compose up -d```
+* You can **stop everything** with CTRL-C or ```docker compose down```
 * You can see logs when running in the background for with the "docker logs" command:  ```docker logs -f p2pool-xmrig``` or ```docker logs -f p2pool-p2pool``` or ```docker logs -f p2pool-monero```
-* You can pause mining with: ```docker-compose pause xmrig``` and resume mining with: ```docker-compose unpause xmrig```
-* You can disable mining with: ```docker-compose stop xmrig``` and re-enable mining with: ```docker-compose start xmrig```
+* You can pause mining with: ```docker compose pause xmrig``` and resume mining with: ```docker compose unpause xmrig```
+* You can disable mining with: ```docker compose stop xmrig``` and re-enable mining with: ```docker compose start xmrig```
 
 
 #### Uninstall
-Change to p2pool/docker-compose directory
-Stop and remove all containers: ```docker-compose down```
-Remove the p2pool data: ```docker volume rm p2pool```
+Change to p2pool/docker-compose directory <br />
+Stop and remove all containers: ```docker compose down``` <br />
+Remove the p2pool data: ```docker volume rm p2pool``` <br />
 Remove the monero data: ```docker volume rm monero```

docker-compose/cfg/Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.10.5-bullseye
+
+WORKDIR /app
+
+ADD requirements.txt /app/
+RUN /usr/local/bin/pip3 install -r requirements.txt
+
+ADD configure.py /app/
+ADD defaults /app/
+ADD current_config.jinja2 /app/
+ADD docker-compose.jinja2 /app/
+
+ENTRYPOINT ["/usr/local/bin/python3"]
+CMD ["/app/configure.py"]

docker-compose/cfg/configure.py

@@ -0,0 +1,597 @@
+#!/bin/env python3
+import time
+import json
+from jinja2 import Template
+import npyscreen
+
+
+def load_default_config():
+    # Read defaults
+    with open("defaults") as defaults_file:
+        defaults = json.load(defaults_file)
+    return defaults
+
+
+def load_current_config():
+    # Read current config
+    with open("/docker-compose/current_config") as current_config:
+        config = json.load(current_config)
+    return config
+
+
+##
+# Help text in a box at the bottom of the screen
+class HelpBox(npyscreen.BoxTitle):
+    def display_help_message(self, field):
+        if field == "Configure Monero Node":
+            self.set_values(
+                [
+                    "Configure and run a Monero Node",
+                    "",
+                    "Note: You must either configure a local node or specify a public node",
+                ]
+            )
+        elif field == "Configure XMRig CPU Miner":
+            self.set_values(
+                [
+                    "Configure and run an XMRig CPU Miner",
+                    "",
+                    "Note: You must either configure am XMRig CPU Miner or expose the",
+                    "      P2Pool stratum port and connect an external miner, or both",
+                ]
+            )
+        elif field == "Wallet Address:":
+            self.set_values(
+                [
+                    "Your monero wallet address for receiving mining reqards",
+                    "",
+                    "Note: You have to use a primary wallet address for mining",
+                    "      Subaddresses and integrated addresses are not supported!",
+                ]
+            )
+        elif field == "P2Pool Sidechain:":
+            self.set_values(
+                [
+                    "Which P2Pool sidechain to mine on",
+                    "    use main for faster miners",
+                    "    use mini for slower miners",
+                ]
+            )
+        elif field == "Expose Stratum Port":
+            self.set_values(
+                [
+                    "Expose the P2Pool stratum port to your network so external miners",
+                    "can connect",
+                    "Note: You may choose to open this port in your hosts firewall and/or",
+                    "      router to allow miners outside your network to connect",
+                ]
+            )
+        elif field == "Stratum Port:":
+            self.set_values(
+                [
+                    "Port number to expose P2Pool stratum to your network to allow",
+                    "external miners to connect",
+                ]
+            )
+        elif field == "P2Pool Log Level:":
+            self.set_values(["Verbosity of the log; (Less) 0 - 6 (More)"])
+        elif field == "Enable Autodiff":
+            self.set_values(
+                ["Use automatic difficulty adjustment for miners connected to stratum"]
+            )
+        elif field == "Additional P2Pool Options:":
+            self.set_values(
+                [
+                    "Additional options to pass to p2pool commandline",
+                    "",
+                    "Note: Advanced - Only add options if you know what you are doing",
+                    "      See ouput of 'p2pool --help' for available options",
+                ]
+            )
+        elif field == "Monero Version:":
+            self.set_values(
+                [
+                    "Version of Monero to build; 'latest' for the most recent release",
+                    "",
+                    "Note: Must be v0.17.3.0 or later for p2pool support",
+                    "      See: https://github.com/monero-project/monero/tags",
+                ]
+            )
+        elif field == "Prune Blockchain":
+            self.set_values(
+                ["Prune the Monero node to limit the size of the blockchain on disk"]
+            )
+        elif field == "Monero Log Level:":
+            self.set_values(["Verbosity of the log; (Less) 0 - 4 (More)"])
+        elif field == "Additional monerod Options:":
+            self.set_values(
+                [
+                    "Additional options to pass to monerod commandline",
+                    "",
+                    "Note: Advanced - Only add options if you know what you are doing",
+                    "      See 'https://monerodocs.org/interacting/monerod-reference/'",
+                ]
+            )
+        elif field == "Public Node:":
+            self.set_values(
+                [
+                    "Public Monero Node to Use",
+                    "",
+                    "Note: The public node must have both Monero RPC and zmq-pub ports",
+                    "      available",
+                ]
+            )
+        elif field == "Node Login:":
+            self.set_values(
+                [
+                    "Specify username[:password] required to connect to public monero",
+                    "node RPC API (if required)"
+                ]
+            )
+        elif field == "Username:":
+            self.set_values(["Set a username for the miner"])
+        elif field == "Use Fixed Difficulty":
+            self.set_values(
+                [
+                    "Used a fixed minig difficulty",
+                    "",
+                    "Note: Allows you to see XMRig submitting shares below P2Pool threshold",
+                ]
+            )
+        elif field == "Fixed Difficulty:":
+            self.set_values(
+                [
+                    "Set a fixed mining difficulty",
+                    "",
+                    "Note: Allows you to see XMRig submitting shares below P2Pool threshold",
+                ]
+            )
+        elif field == "CPU Use %:":
+            self.set_values(
+                ["maximum CPU threads count (in percentage) hint for autoconfig"]
+            )
+        elif field == "Additional XMRig Options:":
+            self.set_values(
+                [
+                    "Additional options to pass to xmrig",
+                    "",
+                    "Note: Advanced - Only add options if you know what you are doing",
+                    "      See 'https://xmrig.com/docs/miner/command-line-options'",
+                ]
+            )
+        elif field == "Save":
+            self.set_values(["Save current configuration"])
+        elif field == "Cancel":
+            self.set_values(["Exit without saving"])
+        self.clear()
+        self.display()
+
+
+##
+# Custom (integer) values for title slider
+class IntegerSlider(npyscreen.Slider):
+    def translate_value(self):
+        from_val = int(str(self.value).split(".")[0])
+        out_of_val = int(str(self.out_of).split(".")[0])
+        if from_val >= 1000:
+            from_val = str(from_val / 1000).split(".")[0] + "K"
+            out_of_val = str(out_of_val / 1000).split(".")[0] + "K"
+        return "{}/{}".format(from_val, out_of_val)
+
+
+class TitleIntegerSlider(npyscreen.TitleSlider):
+    _entry_type = IntegerSlider
+
+
+##
+# Patched updateDependents for FormControlCheckbox
+class PatchedFormControlCheckbox(npyscreen.FormControlCheckbox):
+    def updateDependents(self):
+        if self.value:
+            for w in self._visibleWhenSelected:
+                try:
+                    w.fc_visible
+                except AttributeError:
+                    w.fc_visible = {}
+                w.fc_visible[self.name] = True
+            for w in self._notVisibleWhenSelected:
+                try:
+                    w.fc_visible
+                except AttributeError:
+                    w.fc_visible = {}
+                w.fc_visible[self.name] = False
+        else:
+            for w in self._visibleWhenSelected:
+                try:
+                    w.fc_visible
+                except AttributeError:
+                    w.fc_visible = {}
+                w.fc_visible[self.name] = False
+            for w in self._notVisibleWhenSelected:
+                try:
+                    w.fc_visible
+                except AttributeError:
+                    w.fc_visible = {}
+                w.fc_visible[self.name] = True
+        for w in self._visibleWhenSelected + self._notVisibleWhenSelected:
+            w.hidden = False in w.fc_visible.values()
+            w.editable = not False in w.fc_visible.values()
+        self.parent.display()
+
+    def set_value(self, value):
+        self.value = value
+        self.display()
+
+    def display(self):
+        self.updateDependents()
+        super()
+
+
+class SaveButton(npyscreen.Button):
+    def whenToggled(self):
+        self.parent.save_and_exit()
+
+
+class CancelButton(npyscreen.Button):
+    def whenToggled(self):
+        self.parent.cancel_and_exit()
+
+
+##
+# Configuration Form
+class ConfigForm(npyscreen.FormBaseNew):
+    ALLOW_RESIZE = False
+    name_size = 20
+    indent = 5
+
+    def while_editing(self, arg):
+        self.help.display_help_message(arg.name)
+
+    def create(self):
+        # Add Hot-Key Controls
+        self.add_handlers({"^D": self.load_defaults})
+        # Add Global Configuration
+        self.add(
+            npyscreen.TitleText,
+            name="## General Configuration",
+            editable=False,
+            begin_entry_at=50,
+        )
+        self.configure_monero_node = self.add(
+            PatchedFormControlCheckbox,
+            name="Configure Monero Node",
+            value=True,
+            relx=self.indent,
+        )
+        self.configure_xmrig_miner = self.add(
+            PatchedFormControlCheckbox,
+            name="Configure XMRig CPU Miner",
+            value=True,
+            relx=self.indent,
+        )
+        self.nextrely += 1
+        self.nextrely += 1
+        # Add P2Pool Configuration
+        self.add(
+            npyscreen.TitleText,
+            name="## P2Pool Configuration",
+            editable=False,
+            begin_entry_at=50,
+        )
+        self.wallet_address = self.add(
+            npyscreen.TitleText,
+            name="Wallet Address:",
+            value="",
+            begin_entry_at=self.name_size,
+            relx=self.indent,
+        )
+        self.sidechain = self.add(
+            npyscreen.TitleSelectOne,
+            name="P2Pool Sidechain:",
+            values=["main", "mini"],
+            scroll_exit=True,
+            max_height=2,
+            value=[
+                0,
+            ],
+            begin_entry_at=self.name_size,
+            relx=self.indent,
+        )
+        self.expose_stratum_port = self.add(
+            PatchedFormControlCheckbox,
+            name="Expose Stratum Port",
+            value=True,
+            begin_entry_at=self.name_size,
+            relx=self.indent,
+        )
+        self.stratum_port = self.add(
+            npyscreen.TitleText,
+            name="Stratum Port:",
+            value="3333",
+            begin_entry_at=self.name_size,
+            relx=self.indent,
+        )
+        self.expose_stratum_port.addVisibleWhenSelected(self.stratum_port)
+        self.p2pool_log_level = self.add(
+            TitleIntegerSlider,
+            name="P2Pool Log Level:",
+            out_of=6,
+            value=3,
+            lowest=0,
+            step=1,
+            width=43,
+            begin_entry_at=20,
+            label=True,
+            block_color=None,
+            relx=self.indent,
+        )
+        self.autodiff = self.add(
+            PatchedFormControlCheckbox,
+            name="Enable Autodiff",
+            value=True,
+            begin_entry_at=self.name_size,
+            relx=self.indent,
+        )
+        self.p2pool_extra = self.add(
+            npyscreen.TitleText,
+            name="Additional P2Pool Options:",
+            value="",
+            begin_entry_at=self.name_size + 10,
+            relx=self.indent,
+        )
+        self.nextrely += 1
+        self.nextrely += 1
+        # Add Monero Configuration
+        self.add(
+            npyscreen.TitleText,
+            name="## Monero Node Configuration",
+            editable=False,
+            begin_entry_at=50,
+        )
+        self.monero_git_tag = self.add(
+            npyscreen.TitleText,
+            name="Monero Version:",
+            value="latest",
+            begin_entry_at=self.name_size,
+            relx=self.indent,
+        )
+        self.configure_monero_node.addVisibleWhenSelected(self.monero_git_tag)
+        self.prune_node = self.add(
+            npyscreen.Checkbox,
+            name="Prune Blockchain",
+            value=True,
+            begin_entry_at=self.name_size,
+            relx=self.indent,
+        )
+        self.configure_monero_node.addVisibleWhenSelected(self.prune_node)
+        self.monero_log_level = self.add(
+            TitleIntegerSlider,
+            name="Monero Log Level:",
+            out_of=4,
+            value=0,
+            lowest=0,
+            step=1,
+            width=43,
+            begin_entry_at=20,
+            label=True,
+            block_color=None,
+            relx=self.indent,
+        )
+        self.configure_monero_node.addVisibleWhenSelected(self.monero_log_level)
+        self.monero_extra = self.add(
+            npyscreen.TitleText,
+            name="Additional monerod Options:",
+            value="",
+            begin_entry_at=self.name_size + 10,
+            relx=self.indent,
+        )
+        self.configure_monero_node.addVisibleWhenSelected(self.monero_extra)
+        self.public_node = self.add(
+            npyscreen.TitleText,
+            name="Public Node:",
+            value="",
+            begin_entry_at=self.name_size,
+            relx=self.indent,
+        )
+        self.configure_monero_node.addInvisibleWhenSelected(self.public_node)
+        self.node_login = self.add(
+            npyscreen.TitleText,
+            name="Node Login:",
+            value="",
+            begin_entry_at=self.name_size,
+            relx=self.indent,
+        )
+        self.configure_monero_node.addInvisibleWhenSelected(self.node_login)
+        self.nextrely += 1
+        self.nextrely += 1
+        # Add XMRig Configuration
+        self.add(
+            npyscreen.TitleText,
+            name="## XMRig Miner Configuration",
+            editable=False,
+            begin_entry_at=50,
+        )
+        self.username = self.add(
+            npyscreen.TitleText,
+            name="Username:",
+            value="",
+            begin_entry_at=self.name_size,
+            relx=self.indent,
+        )
+        self.configure_xmrig_miner.addVisibleWhenSelected(self.username)
+        self.use_fixed_difficulty = self.add(
+            PatchedFormControlCheckbox,
+            name="Use Fixed Difficulty",
+            value=True,
+            relx=self.indent,
+        )
+        self.configure_xmrig_miner.addVisibleWhenSelected(self.use_fixed_difficulty)
+        self.autodiff.addInvisibleWhenSelected(self.use_fixed_difficulty)
+        self.fixed_difficulty = self.add(
+            TitleIntegerSlider,
+            name="Fixed Difficulty:",
+            out_of=2000000,
+            value=500000,
+            lowest=50000,
+            step=50000,
+            width=51,
+            begin_entry_at=20,
+            label=True,
+            relx=self.indent,
+        )
+        self.configure_xmrig_miner.addVisibleWhenSelected(self.fixed_difficulty)
+        self.use_fixed_difficulty.addVisibleWhenSelected(self.fixed_difficulty)
+        self.autodiff.addInvisibleWhenSelected(self.fixed_difficulty)
+        self.cpu_threads = self.add(
+            TitleIntegerSlider,
+            name="CPU Use %:",
+            out_of=100,
+            value=100,
+            lowest=1,
+            step=10,
+            width=48,
+            begin_entry_at=20,
+            label=True,
+            relx=self.indent,
+        )
+        self.configure_xmrig_miner.addVisibleWhenSelected(self.cpu_threads)
+        self.xmrig_extra = self.add(
+            npyscreen.TitleText,
+            name="Additional XMRig Options:",
+            value="",
+            begin_entry_at=self.name_size + 10,
+            relx=self.indent,
+        )
+        self.configure_xmrig_miner.addVisibleWhenSelected(self.xmrig_extra)
+        self.nextrely += 1
+        self.nextrely += 1
+        # Add "Save" button
+        self.save_button = self.add(SaveButton, name="Save", relx=1)
+        self.nextrely -= 1
+        self.cancel_button = self.add(CancelButton, name="Cancel", relx=8)
+        self.nextrely += 1
+        # Add Help Box
+        self.help = self.add(
+            HelpBox,
+            name="Commands:  ^D: Load Defaults  -  ^C: Exit Without Saving",
+            values=[""],
+            rely=-8,
+            editable=False,
+        )
+        # Start with current config
+        self.set_config(load_current_config())
+
+    def set_config(self, config):
+        self.configure_monero_node.set_value(config["configure_monero"])
+        self.configure_xmrig_miner.set_value(config["configure_xmrig"])
+        self.wallet_address.set_value(config["wallet_address"])
+        self.sidechain.set_value(config["sidechain"])
+        self.expose_stratum_port.set_value(config["expose_stratum_port"])
+        self.stratum_port.set_value(config["stratum_port"])
+        self.p2pool_log_level.set_value(config["p2pool_log_level"])
+        self.autodiff.set_value(config["enable_autodiff"])
+        self.p2pool_extra.set_value(config["p2pool_options"])
+        self.monero_git_tag.set_value(config["monero_version"])
+        self.prune_node.value = config["prune_blockchain"]
+        self.monero_log_level.set_value(config["monero_log_level"])
+        self.monero_extra.set_value(config["monero_options"])
+        self.public_node.set_value(config["public_monero_node"])
+        self.node_login.set_value(config["monero_node_login"])
+        self.username.set_value(config["xmrig_username"])
+        self.use_fixed_difficulty.set_value(config["use_fixed_difficulty"])
+        self.fixed_difficulty.set_value(config["fixed_difficulty"])
+        self.cpu_threads.set_value(config["cpu_percent"])
+        self.xmrig_extra.set_value(config["xmrig_options"])
+        self.DISPLAY()
+
+    def get_config(self):
+        config = {
+            "configure_monero": self.configure_monero_node.value,
+            "configure_xmrig": self.configure_xmrig_miner.value,
+            "wallet_address": self.wallet_address.value,
+            "sidechain": self.sidechain.value,
+            "expose_stratum_port": self.expose_stratum_port.value,
+            "stratum_port": self.stratum_port.value,
+            "p2pool_log_level": self.p2pool_log_level.value,
+            "enable_autodiff": self.autodiff.value,
+            "p2pool_options": self.p2pool_extra.value,
+            "monero_version": self.monero_git_tag.value,
+            "prune_blockchain": self.prune_node.value,
+            "monero_log_level": self.monero_log_level.value,
+            "monero_options": self.monero_extra.value,
+            "public_monero_node": self.public_node.value,
+            "monero_node_login": self.node_login.value,
+            "xmrig_username": self.username.value,
+            "use_fixed_difficulty": self.use_fixed_difficulty.value,
+            "fixed_difficulty": self.fixed_difficulty.value,
+            "cpu_percent": self.cpu_threads.value,
+            "xmrig_options": self.xmrig_extra.value,
+        }
+        return config
+
+    # Control methods
+    def load_defaults(self, arg):
+        ok = npyscreen.notify_ok_cancel(
+            "Set all values to defaults", title="Load Defaults"
+        )
+        if not ok:
+            return
+        defaults = load_default_config()
+        self.set_config(defaults)
+
+    def save_and_exit(self):
+        config = self.get_config()
+        # Save "current config" values file
+        with open("current_config.jinja2", "r") as current_config:
+            template = current_config.read()
+        rendered = Template(template).render(config)
+        with open("/docker-compose/current_config", "w") as current_config:
+            current_config.write(rendered)
+        # Render and save docker-compose file
+        with open("docker-compose.jinja2", "r") as compose_file:
+            template = compose_file.read()
+        rendered = Template(template).render(config, trim_blocks=True)
+        with open("/docker-compose/docker-compose.yml", "w") as compose_file:
+            compose_file.write(rendered)
+        npyscreen.notify("Saved current settings", title="Saved")
+        self.find_parent_app().switchForm(None)
+        self.find_parent_app().saved = True
+
+    def cancel_and_exit(self):
+        self.find_parent_app().switchForm(None)
+        self.find_parent_app().saved = False
+
+
+##
+# Our P2Pool configuration App
+class ConfigApp(npyscreen.NPSAppManaged):
+    def onStart(self):
+        self.f = self.addForm(
+            "MAIN",
+            ConfigForm,
+            name="P2Pool for docker-compose: Global Configuration",
+            lines=45,
+            columns=80,
+            minimum_lines=45,
+            minimum_columns=80,
+        )
+
+
+if __name__ == "__main__":
+    try:
+        time.sleep(1)  # Give docker a second to initialize the terminal
+        App = ConfigApp()
+        App.run()
+        print("\n\n")
+        if App.saved:
+            print("Configuration Saved")
+            print(
+                'Run "docker compose up -d" to start (if you are using the docker-compose plugin'
+            )
+            print(
+                'or, "docker-compose up -d" (if you are using pip installed docker-compose)'
+            )
+        else:
+            print("Configuration Aborted")
+    except KeyboardInterrupt:
+        print("Configuration Aborted")

docker-compose/cfg/current_config.jinja2

@@ -0,0 +1,22 @@
+{
+    "wallet_address": {{ wallet_address | tojson(indent=2) }},
+    "configure_monero": {{ configure_monero | tojson(indent=2) }},
+    "configure_xmrig": {{ configure_xmrig | tojson(indent=2) }},
+    "sidechain": {{ sidechain | tojson(indent=2) }},
+    "expose_stratum_port": {{ expose_stratum_port | tojson(indent=2) }},
+    "stratum_port": {{ stratum_port | tojson(indent=2) }},
+    "p2pool_log_level": {{ p2pool_log_level | int | tojson(indent=2) }},
+    "enable_autodiff": {{ enable_autodiff | tojson(indent=2) }},
+    "p2pool_options": {{ p2pool_options | tojson(indent=2) }},
+    "monero_version": {{ monero_version | tojson(indent=2) }},
+    "prune_blockchain": {{ prune_blockchain | tojson(indent=2) }},
+    "monero_log_level": {{ monero_log_level | int | tojson(indent=2) }},
+    "monero_options": {{ monero_options | tojson(indent=2) }},
+    "public_monero_node": {{ public_monero_node | tojson(indent=2) }},
+    "monero_node_login": {{ monero_node_login | tojson(indent=2) }},
+    "xmrig_username": {{ xmrig_username | tojson(indent=2) }},
+    "use_fixed_difficulty": {{ use_fixed_difficulty | tojson(indent=2) }},
+    "fixed_difficulty": {{ fixed_difficulty | int | tojson(indent=2) }},
+    "cpu_percent": {{ cpu_percent | int | tojson(indent=2) }},
+    "xmrig_options": {{ xmrig_options | tojson(indent=2) }}
+}

docker-compose/cfg/defaults

@@ -0,0 +1,22 @@
+{
+    "wallet_address": "44MnN1f3Eto8DZYUWuE5XZNUtE3vcRzt2j6PzqWpPau34e6Cf4fAxt6X2MBmrm6F9YMEiMNjN6W4Shn4pLcfNAja621jwyg",
+    "configure_monero": true,
+    "configure_xmrig": true,
+    "sidechain": [0],
+    "expose_stratum_port": false,
+    "stratum_port": "3333",
+    "p2pool_log_level": 3,
+    "enable_autodiff": true,
+    "p2pool_options": "",
+    "monero_version": "latest",
+    "prune_blockchain": true,
+    "monero_log_level": 0,
+    "monero_options": "",
+    "public_monero_node": "",
+    "monero_node_login": "",
+    "xmrig_username": "p2pool",
+    "use_fixed_difficulty": true,
+    "fixed_difficulty": 500000,
+    "cpu_percent": 100,
+    "xmrig_options": ""
+}

docker-compose/cfg/docker-compose.jinja2

@@ -0,0 +1,125 @@
+---
+version: '3.4'
+
+networks:
+  p2pool:
+    driver: bridge
+
+volumes:
+  p2pool: 
+    name: p2pool
+{% if configure_monero == True %}
+  monero:
+    name: monero
+{% endif %}
+
+services:
+  p2pool:
+    image: p2pool:latest
+    build: ../
+    container_name: p2pool-p2pool
+    networks:
+      - p2pool
+    ports:
+{% if sidechain[0] == 0 %}
+      - 37888:37888/tcp
+{% else %}
+      - 37889:37889/tcp
+{% endif %}
+{% if expose_stratum_port == True %}
+      - {{ stratum_port | int }}:3333/tcp
+{% endif %}
+    volumes:
+      - p2pool:/home/p2pool/.p2pool:rw
+      - /dev/null:/home/p2pool/.p2pool/p2pool.log:rw
+      - /dev/hugepages:/dev/hugepages:rw
+{% if configure_monero == True %}
+    depends_on:
+      - monero
+{% endif %}
+    restart: unless-stopped
+    command: >-
+{% if configure_monero == True %}
+      --host monero
+{% else %}
+      --host {{ public_monero_node }}
+      --rpc-login {{ monero_node_login }}
+{% endif %}
+      --wallet {{ wallet_address }}
+      --loglevel {{ p2pool_log_level | int }}
+{% if sidechain[0] == 1 %}
+      --mini
+{% endif %}
+{% if enable_autodiff == False %}
+      --no-autodiff
+{% endif %}
+{% if p2pool_options != "" %}
+      {{ p2pool_options }}
+{% endif %}
+
+
+{% if configure_monero == True %}
+  monero:
+    image: monero:latest
+    build:
+      context: monero
+      args:
+        - MONERO_GIT_TAG={{ monero_version }}
+    container_name: p2pool-monero
+    networks:
+      - p2pool
+    ports:
+      - 18080:18080/tcp
+    volumes:
+      - monero:/home/monero/.bitmonero:rw
+      - /dev/null:/home/monero/.bitmonero/bitmonero.log:rw
+      - /dev/hugepages:/dev/hugepages:rw
+    restart: unless-stopped
+    command: >-
+      --zmq-pub tcp://0.0.0.0:18083
+      --disable-dns-checkpoints
+      --enable-dns-blocklist
+      --non-interactive
+      --p2p-bind-ip=0.0.0.0
+      --p2p-bind-port=18080
+      --rpc-bind-ip=0.0.0.0
+      --rpc-bind-port=18081
+      --confirm-external-bind
+      --log-level={{ monero_log_level | int }}
+{% if prune_blockchain == True %}
+      --prune-blockchain
+{% endif %}
+{% if monero_options != "" %}
+      {{ monero_options }}
+{% endif %}
+{% endif %}
+
+
+{% if configure_xmrig == True %}
+  xmrig:
+    image: xmrig:latest
+    build: xmrig
+    container_name: p2pool-xmrig
+    networks:
+      - p2pool
+    privileged: true
+    volumes:
+      - /dev:/dev:ro
+      - /lib/modules:/lib/modules:ro
+      - /dev/hugepages:/dev/hugepages:rw
+    depends_on:
+      - p2pool
+    restart: unless-stopped
+    command: >-
+      --randomx-1gb-pages
+      -o p2pool:3333
+{% if enable_autodiff == False and use_fixed_difficulty == True %}
+      -u {{ xmrig_username }}+{{ fixed_difficulty | int }}
+{% else %}
+      -u {{ xmrig_username }}
+{% endif %}
+      --cpu-max-threads-hint={{ cpu_percent | int }}
+{% if xmrig_options != "" %}
+      {{ xmrig_options }}
+{% endif %}
+{% endif %}

docker-compose/cfg/requirements.txt

@@ -0,0 +1,3 @@
+npyscreen==4.10.5
+MarkupSafe==2.0.1
+jinja2==2.11.3

docker-compose/configure

@@ -0,0 +1,6 @@
+#!/bin/bash
+echo ""
+echo ""
+echo "Building and Running P2Pool docker-compose Configuration"
+docker build -t p2pool_config:latest cfg
+docker run -it --rm -v $PWD:/docker-compose --user $(id -u):$(id -g) p2pool_config:latest

docker-compose/current_config

@@ -0,0 +1,24 @@
+{
+    "wallet_address": "44MnN1f3Eto8DZYUWuE5XZNUtE3vcRzt2j6PzqWpPau34e6Cf4fAxt6X2MBmrm6F9YMEiMNjN6W4Shn4pLcfNAja621jwyg",
+    "configure_monero": true,
+    "configure_xmrig": true,
+    "sidechain": [
+  0
+],
+    "expose_stratum_port": false,
+    "stratum_port": "3333",
+    "p2pool_log_level": 3,
+    "enable_autodiff": true,
+    "p2pool_options": "",
+    "monero_version": "latest",
+    "prune_blockchain": true,
+    "monero_log_level": 0,
+    "monero_options": "",
+    "public_monero_node": "",
+    "monero_node_login": "",
+    "xmrig_username": "p2pool",
+    "use_fixed_difficulty": true,
+    "fixed_difficulty": 500000,
+    "cpu_percent": 100,
+    "xmrig_options": ""
+}

docker-compose/docker-compose.yml

@@ -8,16 +8,50 @@ networks:
 volumes:
   p2pool: 
     name: p2pool
+
   monero:
     name: monero
 
+
 services:
+  p2pool:
+    image: p2pool:latest
+    build: ../
+    container_name: p2pool-p2pool
+    networks:
+      - p2pool
+    ports:
+
+      - 37888:37888/tcp
+
+
+    volumes:
+      - p2pool:/home/p2pool/.p2pool:rw
+      - /dev/null:/home/p2pool/.p2pool/p2pool.log:rw
+      - /dev/hugepages:/dev/hugepages:rw
+
+    depends_on:
+      - monero
+
+    restart: unless-stopped
+    command: >-
+
+      --host monero
+
+      --wallet 44MnN1f3Eto8DZYUWuE5XZNUtE3vcRzt2j6PzqWpPau34e6Cf4fAxt6X2MBmrm6F9YMEiMNjN6W4Shn4pLcfNAja621jwyg
+      --loglevel 3
+
+
+
+
+
+
   monero:
     image: monero:latest
     build:
       context: monero
       args:
-        - MONERO_GIT_TAG=${MONERO_GIT_TAG}
+        - MONERO_GIT_TAG=latest
     container_name: p2pool-monero
     networks:
       - p2pool
@@ -38,31 +72,14 @@ services:
       --rpc-bind-ip=0.0.0.0
       --rpc-bind-port=18081
       --confirm-external-bind
-      ${PRUNE_NODE}
-      ${MONERO_EXTRA_OPTIONS}
+      --log-level=0
+
+      --prune-blockchain
+
+
+
+
 
-  p2pool:
-    image: p2pool:latest
-    build: ../
-    container_name: p2pool-p2pool
-    networks:
-      - p2pool
-    ports:
-      - ${P2POOL_STRATUM_PORT}:3333/tcp
-      - 37888:37888/tcp
-      - 37889:37889/tcp
-    volumes:
-      - p2pool:/home/p2pool/.p2pool:rw
-      - /dev/null:/home/p2pool/.p2pool/p2pool.log:rw
-      - /dev/hugepages:/dev/hugepages:rw
-    depends_on:
-      - monero
-    restart: unless-stopped
-    command: >-
-      --host monero
-      --wallet ${WALLET_ADDRESS}
-      --loglevel ${P2POOL_LOGLEVEL}
-      ${P2POOL_MINI}
 
   xmrig:
     image: xmrig:latest
@@ -79,8 +96,10 @@ services:
       - p2pool
     restart: unless-stopped
     command: >-
-      ${FIXED_MINING_DIFFICULTY}
-      ${MINING_CPU_PRIORITY}
-      ${XMRIG_EXTRA_OPTIONS}
       --randomx-1gb-pages
       -o p2pool:3333
+
+      -u p2pool
+
+      --cpu-max-threads-hint=100
+

docker-compose/monero/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:latest
+FROM ubuntu:20.04
 ARG MONERO_GIT_TAG="latest"
 
 RUN set -e && \
@@ -54,7 +54,7 @@ RUN git clone --recursive https://github.com/monero-project/monero && \
 
 # ---
 
-FROM ubuntu:latest
+FROM ubuntu:20.04
 
 COPY --from=0 /usr/src/monero/build/Linux/*/release/bin/* /
 
@@ -63,7 +63,8 @@ RUN set -e && \
     DEBIAN_FRONTEND="noninteractive" apt-get install -q -y --no-install-recommends \
     libgssapi-krb5-2 \
       && \
-    apt-get clean
+    apt-get clean && \
+    rm -rf /var/lib/apt
 
 RUN groupadd -r monero -g 1000 && \
     useradd -u 1000 -r -g monero -s /sbin/nologin -c "monero node user" monero

docker-compose/xmrig/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:latest
+FROM ubuntu:20.04
 
 RUN set -e && \
     apt-get update -q -y --no-install-recommends && \
@@ -20,7 +20,7 @@ RUN git clone https://github.com/xmrig/xmrig.git && \
 
 # ---
 
-FROM ubuntu:latest
+FROM ubuntu:20.04
 
 COPY --from=0 /usr/src/xmrig/build/xmrig /
 

external/src/llhttp/LICENSE-MIT

@@ -1,22 +0,0 @@
-This software is licensed under the MIT License.
-
-Copyright Fedor Indutny, 2018.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to permit
-persons to whom the Software is furnished to do so, subject to the
-following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-USE OR OTHER DEALINGS IN THE SOFTWARE.

external/src/llhttp/api.c

@@ -1,375 +0,0 @@
-#ifdef _MSC_VER
-#pragma warning(disable : 4100 4668 4710 4711 4820)
-#elif defined __GNUC__
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "llhttp.h"
-
-#define CALLBACK_MAYBE(PARSER, NAME)                                          \
-  do {                                                                        \
-    const llhttp_settings_t* settings;                                        \
-    settings = (const llhttp_settings_t*) (PARSER)->settings;                 \
-    if (settings == NULL || settings->NAME == NULL) {                         \
-      err = 0;                                                                \
-      break;                                                                  \
-    }                                                                         \
-    err = settings->NAME((PARSER));                                           \
-  } while (0)
-
-#define SPAN_CALLBACK_MAYBE(PARSER, NAME, START, LEN)                         \
-  do {                                                                        \
-    const llhttp_settings_t* settings;                                        \
-    settings = (const llhttp_settings_t*) (PARSER)->settings;                 \
-    if (settings == NULL || settings->NAME == NULL) {                         \
-      err = 0;                                                                \
-      break;                                                                  \
-    }                                                                         \
-    err = settings->NAME((PARSER), (START), (LEN));                           \
-    if (err == -1) {                                                          \
-      err = HPE_USER;                                                         \
-      llhttp_set_error_reason((PARSER), "Span callback error in " #NAME);     \
-    }                                                                         \
-  } while (0)
-
-void llhttp_init(llhttp_t* parser, llhttp_type_t type,
-                 const llhttp_settings_t* settings) {
-  llhttp__internal_init(parser);
-
-  parser->type = type;
-  parser->settings = (void*) settings;
-}
-
-
-#if defined(__wasm__)
-
-extern int wasm_on_message_begin(llhttp_t * p);
-extern int wasm_on_url(llhttp_t* p, const char* at, size_t length);
-extern int wasm_on_status(llhttp_t* p, const char* at, size_t length);
-extern int wasm_on_header_field(llhttp_t* p, const char* at, size_t length);
-extern int wasm_on_header_value(llhttp_t* p, const char* at, size_t length);
-extern int wasm_on_headers_complete(llhttp_t * p, int status_code,
-                                    uint8_t upgrade, int should_keep_alive);
-extern int wasm_on_body(llhttp_t* p, const char* at, size_t length);
-extern int wasm_on_message_complete(llhttp_t * p);
-
-static int wasm_on_headers_complete_wrap(llhttp_t* p) {
-  return wasm_on_headers_complete(p, p->status_code, p->upgrade,
-                                  llhttp_should_keep_alive(p));
-}
-
-const llhttp_settings_t wasm_settings = {
-  wasm_on_message_begin,
-  wasm_on_url,
-  wasm_on_status,
-  wasm_on_header_field,
-  wasm_on_header_value,
-  wasm_on_headers_complete_wrap,
-  wasm_on_body,
-  wasm_on_message_complete,
-  NULL,
-  NULL,
-};
-
-
-llhttp_t* llhttp_alloc(llhttp_type_t type) {
-  llhttp_t* parser = malloc(sizeof(llhttp_t));
-  llhttp_init(parser, type, &wasm_settings);
-  return parser;
-}
-
-void llhttp_free(llhttp_t* parser) {
-  free(parser);
-}
-
-/* Some getters required to get stuff from the parser */
-
-uint8_t llhttp_get_type(llhttp_t* parser) {
-  return parser->type;
-}
-
-uint8_t llhttp_get_http_major(llhttp_t* parser) {
-  return parser->http_major;
-}
-
-uint8_t llhttp_get_http_minor(llhttp_t* parser) {
-  return parser->http_minor;
-}
-
-uint8_t llhttp_get_method(llhttp_t* parser) {
-  return parser->method;
-}
-
-int llhttp_get_status_code(llhttp_t* parser) {
-  return parser->status_code;
-}
-
-uint8_t llhttp_get_upgrade(llhttp_t* parser) {
-  return parser->upgrade;
-}
-
-#endif  // defined(__wasm__)
-
-
-void llhttp_reset(llhttp_t* parser) {
-  llhttp_type_t type = parser->type;
-  const llhttp_settings_t* settings = parser->settings;
-  void* data = parser->data;
-  uint8_t lenient_flags = parser->lenient_flags;
-
-  llhttp__internal_init(parser);
-
-  parser->type = type;
-  parser->settings = (void*) settings;
-  parser->data = data;
-  parser->lenient_flags = lenient_flags;
-}
-
-
-llhttp_errno_t llhttp_execute(llhttp_t* parser, const char* data, size_t len) {
-  return llhttp__internal_execute(parser, data, data + len);
-}
-
-
-void llhttp_settings_init(llhttp_settings_t* settings) {
-  memset(settings, 0, sizeof(*settings));
-}
-
-
-llhttp_errno_t llhttp_finish(llhttp_t* parser) {
-  int err;
-
-  /* We're in an error state. Don't bother doing anything. */
-  if (parser->error != 0) {
-    return 0;
-  }
-
-  switch (parser->finish) {
-    case HTTP_FINISH_SAFE_WITH_CB:
-      CALLBACK_MAYBE(parser, on_message_complete);
-      if (err != HPE_OK) return err;
-
-    /* FALLTHROUGH */
-    case HTTP_FINISH_SAFE:
-      return HPE_OK;
-    case HTTP_FINISH_UNSAFE:
-      parser->reason = "Invalid EOF state";
-      return HPE_INVALID_EOF_STATE;
-    default:
-      abort();
-  }
-}
-
-
-void llhttp_pause(llhttp_t* parser) {
-  if (parser->error != HPE_OK) {
-    return;
-  }
-
-  parser->error = HPE_PAUSED;
-  parser->reason = "Paused";
-}
-
-
-void llhttp_resume(llhttp_t* parser) {
-  if (parser->error != HPE_PAUSED) {
-    return;
-  }
-
-  parser->error = 0;
-}
-
-
-void llhttp_resume_after_upgrade(llhttp_t* parser) {
-  if (parser->error != HPE_PAUSED_UPGRADE) {
-    return;
-  }
-
-  parser->error = 0;
-}
-
-
-llhttp_errno_t llhttp_get_errno(const llhttp_t* parser) {
-  return parser->error;
-}
-
-
-const char* llhttp_get_error_reason(const llhttp_t* parser) {
-  return parser->reason;
-}
-
-
-void llhttp_set_error_reason(llhttp_t* parser, const char* reason) {
-  parser->reason = reason;
-}
-
-
-const char* llhttp_get_error_pos(const llhttp_t* parser) {
-  return parser->error_pos;
-}
-
-
-const char* llhttp_errno_name(llhttp_errno_t err) {
-#define HTTP_ERRNO_GEN(CODE, NAME, _) case HPE_##NAME: return "HPE_" #NAME;
-  switch (err) {
-    HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
-    default: abort();
-  }
-#undef HTTP_ERRNO_GEN
-}
-
-
-const char* llhttp_method_name(llhttp_method_t method) {
-#define HTTP_METHOD_GEN(NUM, NAME, STRING) case HTTP_##NAME: return #STRING;
-  switch (method) {
-    HTTP_ALL_METHOD_MAP(HTTP_METHOD_GEN)
-    default: abort();
-  }
-#undef HTTP_METHOD_GEN
-}
-
-
-void llhttp_set_lenient_headers(llhttp_t* parser, int enabled) {
-  if (enabled) {
-    parser->lenient_flags |= LENIENT_HEADERS;
-  } else {
-    parser->lenient_flags &= ~LENIENT_HEADERS;
-  }
-}
-
-
-void llhttp_set_lenient_chunked_length(llhttp_t* parser, int enabled) {
-  if (enabled) {
-    parser->lenient_flags |= LENIENT_CHUNKED_LENGTH;
-  } else {
-    parser->lenient_flags &= ~LENIENT_CHUNKED_LENGTH;
-  }
-}
-
-
-void llhttp_set_lenient_keep_alive(llhttp_t* parser, int enabled) {
-  if (enabled) {
-    parser->lenient_flags |= LENIENT_KEEP_ALIVE;
-  } else {
-    parser->lenient_flags &= ~LENIENT_KEEP_ALIVE;
-  }
-}
-
-/* Callbacks */
-
-
-int llhttp__on_message_begin(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  CALLBACK_MAYBE(s, on_message_begin);
-  return err;
-}
-
-
-int llhttp__on_url(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  SPAN_CALLBACK_MAYBE(s, on_url, p, endp - p);
-  return err;
-}
-
-
-int llhttp__on_url_complete(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  CALLBACK_MAYBE(s, on_url_complete);
-  return err;
-}
-
-
-int llhttp__on_status(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  SPAN_CALLBACK_MAYBE(s, on_status, p, endp - p);
-  return err;
-}
-
-
-int llhttp__on_status_complete(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  CALLBACK_MAYBE(s, on_status_complete);
-  return err;
-}
-
-
-int llhttp__on_header_field(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  SPAN_CALLBACK_MAYBE(s, on_header_field, p, endp - p);
-  return err;
-}
-
-
-int llhttp__on_header_field_complete(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  CALLBACK_MAYBE(s, on_header_field_complete);
-  return err;
-}
-
-
-int llhttp__on_header_value(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  SPAN_CALLBACK_MAYBE(s, on_header_value, p, endp - p);
-  return err;
-}
-
-
-int llhttp__on_header_value_complete(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  CALLBACK_MAYBE(s, on_header_value_complete);
-  return err;
-}
-
-
-int llhttp__on_headers_complete(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  CALLBACK_MAYBE(s, on_headers_complete);
-  return err;
-}
-
-
-int llhttp__on_message_complete(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  CALLBACK_MAYBE(s, on_message_complete);
-  return err;
-}
-
-
-int llhttp__on_body(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  SPAN_CALLBACK_MAYBE(s, on_body, p, endp - p);
-  return err;
-}
-
-
-int llhttp__on_chunk_header(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  CALLBACK_MAYBE(s, on_chunk_header);
-  return err;
-}
-
-
-int llhttp__on_chunk_complete(llhttp_t* s, const char* p, const char* endp) {
-  int err;
-  CALLBACK_MAYBE(s, on_chunk_complete);
-  return err;
-}
-
-
-/* Private */
-
-
-void llhttp__debug(llhttp_t* s, const char* p, const char* endp,
-                   const char* msg) {
-  if (p == endp) {
-    fprintf(stderr, "p=%p type=%d flags=%02x next=null debug=%s\n", s, s->type,
-            s->flags, msg);
-  } else {
-    fprintf(stderr, "p=%p type=%d flags=%02x next=%02x   debug=%s\n", s,
-            s->type, s->flags, *p, msg);
-  }
-}

external/src/llhttp/http.c

@@ -1,155 +0,0 @@
-#ifdef _MSC_VER
-#pragma warning(disable : 4100 4668 4710 4711 4820)
-#elif defined __GNUC__
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#endif
-
-#include <stdio.h>
-#ifndef LLHTTP__TEST
-# include "llhttp.h"
-#else
-# define llhttp_t llparse_t
-#endif  /* */
-
-int llhttp_message_needs_eof(const llhttp_t* parser);
-int llhttp_should_keep_alive(const llhttp_t* parser);
-
-int llhttp__before_headers_complete(llhttp_t* parser, const char* p,
-                                    const char* endp) {
-  /* Set this here so that on_headers_complete() callbacks can see it */
-  if ((parser->flags & F_UPGRADE) &&
-      (parser->flags & F_CONNECTION_UPGRADE)) {
-    /* For responses, "Upgrade: foo" and "Connection: upgrade" are
-     * mandatory only when it is a 101 Switching Protocols response,
-     * otherwise it is purely informational, to announce support.
-     */
-    parser->upgrade =
-        (parser->type == HTTP_REQUEST || parser->status_code == 101);
-  } else {
-    parser->upgrade = (parser->method == HTTP_CONNECT);
-  }
-  return 0;
-}
-
-
-/* Return values:
- * 0 - No body, `restart`, message_complete
- * 1 - CONNECT request, `restart`, message_complete, and pause
- * 2 - chunk_size_start
- * 3 - body_identity
- * 4 - body_identity_eof
- * 5 - invalid transfer-encoding for request
- */
-int llhttp__after_headers_complete(llhttp_t* parser, const char* p,
-                                   const char* endp) {
-  int hasBody;
-
-  hasBody = parser->flags & F_CHUNKED || parser->content_length > 0;
-  if (parser->upgrade && (parser->method == HTTP_CONNECT ||
-                          (parser->flags & F_SKIPBODY) || !hasBody)) {
-    /* Exit, the rest of the message is in a different protocol. */
-    return 1;
-  }
-
-  if (parser->flags & F_SKIPBODY) {
-    return 0;
-  } else if (parser->flags & F_CHUNKED) {
-    /* chunked encoding - ignore Content-Length header, prepare for a chunk */
-    return 2;
-  } else if (parser->flags & F_TRANSFER_ENCODING) {
-    if (parser->type == HTTP_REQUEST &&
-        (parser->lenient_flags & LENIENT_CHUNKED_LENGTH) == 0) {
-      /* RFC 7230 3.3.3 */
-
-      /* If a Transfer-Encoding header field
-       * is present in a request and the chunked transfer coding is not
-       * the final encoding, the message body length cannot be determined
-       * reliably; the server MUST respond with the 400 (Bad Request)
-       * status code and then close the connection.
-       */
-      return 5;
-    } else {
-      /* RFC 7230 3.3.3 */
-
-      /* If a Transfer-Encoding header field is present in a response and
-       * the chunked transfer coding is not the final encoding, the
-       * message body length is determined by reading the connection until
-       * it is closed by the server.
-       */
-      return 4;
-    }
-  } else {
-    if (!(parser->flags & F_CONTENT_LENGTH)) {
-      if (!llhttp_message_needs_eof(parser)) {
-        /* Assume content-length 0 - read the next */
-        return 0;
-      } else {
-        /* Read body until EOF */
-        return 4;
-      }
-    } else if (parser->content_length == 0) {
-      /* Content-Length header given but zero: Content-Length: 0\r\n */
-      return 0;
-    } else {
-      /* Content-Length header given and non-zero */
-      return 3;
-    }
-  }
-}
-
-
-int llhttp__after_message_complete(llhttp_t* parser, const char* p,
-                                   const char* endp) {
-  int should_keep_alive;
-
-  should_keep_alive = llhttp_should_keep_alive(parser);
-  parser->finish = HTTP_FINISH_SAFE;
-  parser->flags = 0;
-
-  /* NOTE: this is ignored in loose parsing mode */
-  return should_keep_alive;
-}
-
-
-int llhttp_message_needs_eof(const llhttp_t* parser) {
-  if (parser->type == HTTP_REQUEST) {
-    return 0;
-  }
-
-  /* See RFC 2616 section 4.4 */
-  if (parser->status_code / 100 == 1 || /* 1xx e.g. Continue */
-      parser->status_code == 204 ||     /* No Content */
-      parser->status_code == 304 ||     /* Not Modified */
-      (parser->flags & F_SKIPBODY)) {     /* response to a HEAD request */
-    return 0;
-  }
-
-  /* RFC 7230 3.3.3, see `llhttp__after_headers_complete` */
-  if ((parser->flags & F_TRANSFER_ENCODING) &&
-      (parser->flags & F_CHUNKED) == 0) {
-    return 1;
-  }
-
-  if (parser->flags & (F_CHUNKED | F_CONTENT_LENGTH)) {
-    return 0;
-  }
-
-  return 1;
-}
-
-
-int llhttp_should_keep_alive(const llhttp_t* parser) {
-  if (parser->http_major > 0 && parser->http_minor > 0) {
-    /* HTTP/1.1 */
-    if (parser->flags & F_CONNECTION_CLOSE) {
-      return 0;
-    }
-  } else {
-    /* HTTP/1.0 or earlier */
-    if (!(parser->flags & F_CONNECTION_KEEP_ALIVE)) {
-      return 0;
-    }
-  }
-
-  return !llhttp_message_needs_eof(parser);
-}

external/src/llhttp/llhttp.h

@@ -1,564 +0,0 @@
-#ifndef INCLUDE_LLHTTP_H_
-#define INCLUDE_LLHTTP_H_
-
-#define LLHTTP_VERSION_MAJOR 6
-#define LLHTTP_VERSION_MINOR 0
-#define LLHTTP_VERSION_PATCH 4
-
-#ifndef LLHTTP_STRICT_MODE
-# define LLHTTP_STRICT_MODE 0
-#endif
-
-#ifndef INCLUDE_LLHTTP_ITSELF_H_
-#define INCLUDE_LLHTTP_ITSELF_H_
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdint.h>
-
-typedef struct llhttp__internal_s llhttp__internal_t;
-struct llhttp__internal_s {
-  int32_t _index;
-  void* _span_pos0;
-  void* _span_cb0;
-  int32_t error;
-  const char* reason;
-  const char* error_pos;
-  void* data;
-  void* _current;
-  uint64_t content_length;
-  uint8_t type;
-  uint8_t method;
-  uint8_t http_major;
-  uint8_t http_minor;
-  uint8_t header_state;
-  uint8_t lenient_flags;
-  uint8_t upgrade;
-  uint8_t finish;
-  uint16_t flags;
-  uint16_t status_code;
-  void* settings;
-};
-
-int llhttp__internal_init(llhttp__internal_t* s);
-int llhttp__internal_execute(llhttp__internal_t* s, const char* p, const char* endp);
-
-#ifdef __cplusplus
-}  /* extern "C" */
-#endif
-#endif  /* INCLUDE_LLHTTP_ITSELF_H_ */
-
-#ifndef LLLLHTTP_C_HEADERS_
-#define LLLLHTTP_C_HEADERS_
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-enum llhttp_errno {
-  HPE_OK = 0,
-  HPE_INTERNAL = 1,
-  HPE_STRICT = 2,
-  HPE_LF_EXPECTED = 3,
-  HPE_UNEXPECTED_CONTENT_LENGTH = 4,
-  HPE_CLOSED_CONNECTION = 5,
-  HPE_INVALID_METHOD = 6,
-  HPE_INVALID_URL = 7,
-  HPE_INVALID_CONSTANT = 8,
-  HPE_INVALID_VERSION = 9,
-  HPE_INVALID_HEADER_TOKEN = 10,
-  HPE_INVALID_CONTENT_LENGTH = 11,
-  HPE_INVALID_CHUNK_SIZE = 12,
-  HPE_INVALID_STATUS = 13,
-  HPE_INVALID_EOF_STATE = 14,
-  HPE_INVALID_TRANSFER_ENCODING = 15,
-  HPE_CB_MESSAGE_BEGIN = 16,
-  HPE_CB_HEADERS_COMPLETE = 17,
-  HPE_CB_MESSAGE_COMPLETE = 18,
-  HPE_CB_CHUNK_HEADER = 19,
-  HPE_CB_CHUNK_COMPLETE = 20,
-  HPE_PAUSED = 21,
-  HPE_PAUSED_UPGRADE = 22,
-  HPE_PAUSED_H2_UPGRADE = 23,
-  HPE_USER = 24
-};
-typedef enum llhttp_errno llhttp_errno_t;
-
-enum llhttp_flags {
-  F_CONNECTION_KEEP_ALIVE = 0x1,
-  F_CONNECTION_CLOSE = 0x2,
-  F_CONNECTION_UPGRADE = 0x4,
-  F_CHUNKED = 0x8,
-  F_UPGRADE = 0x10,
-  F_CONTENT_LENGTH = 0x20,
-  F_SKIPBODY = 0x40,
-  F_TRAILING = 0x80,
-  F_TRANSFER_ENCODING = 0x200
-};
-typedef enum llhttp_flags llhttp_flags_t;
-
-enum llhttp_lenient_flags {
-  LENIENT_HEADERS = 0x1,
-  LENIENT_CHUNKED_LENGTH = 0x2,
-  LENIENT_KEEP_ALIVE = 0x4
-};
-typedef enum llhttp_lenient_flags llhttp_lenient_flags_t;
-
-enum llhttp_type {
-  HTTP_BOTH = 0,
-  HTTP_REQUEST = 1,
-  HTTP_RESPONSE = 2
-};
-typedef enum llhttp_type llhttp_type_t;
-
-enum llhttp_finish {
-  HTTP_FINISH_SAFE = 0,
-  HTTP_FINISH_SAFE_WITH_CB = 1,
-  HTTP_FINISH_UNSAFE = 2
-};
-typedef enum llhttp_finish llhttp_finish_t;
-
-enum llhttp_method {
-  HTTP_DELETE = 0,
-  HTTP_GET = 1,
-  HTTP_HEAD = 2,
-  HTTP_POST = 3,
-  HTTP_PUT = 4,
-  HTTP_CONNECT = 5,
-  HTTP_OPTIONS = 6,
-  HTTP_TRACE = 7,
-  HTTP_COPY = 8,
-  HTTP_LOCK = 9,
-  HTTP_MKCOL = 10,
-  HTTP_MOVE = 11,
-  HTTP_PROPFIND = 12,
-  HTTP_PROPPATCH = 13,
-  HTTP_SEARCH = 14,
-  HTTP_UNLOCK = 15,
-  HTTP_BIND = 16,
-  HTTP_REBIND = 17,
-  HTTP_UNBIND = 18,
-  HTTP_ACL = 19,
-  HTTP_REPORT = 20,
-  HTTP_MKACTIVITY = 21,
-  HTTP_CHECKOUT = 22,
-  HTTP_MERGE = 23,
-  HTTP_MSEARCH = 24,
-  HTTP_NOTIFY = 25,
-  HTTP_SUBSCRIBE = 26,
-  HTTP_UNSUBSCRIBE = 27,
-  HTTP_PATCH = 28,
-  HTTP_PURGE = 29,
-  HTTP_MKCALENDAR = 30,
-  HTTP_LINK = 31,
-  HTTP_UNLINK = 32,
-  HTTP_SOURCE = 33,
-  HTTP_PRI = 34,
-  HTTP_DESCRIBE = 35,
-  HTTP_ANNOUNCE = 36,
-  HTTP_SETUP = 37,
-  HTTP_PLAY = 38,
-  HTTP_PAUSE = 39,
-  HTTP_TEARDOWN = 40,
-  HTTP_GET_PARAMETER = 41,
-  HTTP_SET_PARAMETER = 42,
-  HTTP_REDIRECT = 43,
-  HTTP_RECORD = 44,
-  HTTP_FLUSH = 45
-};
-typedef enum llhttp_method llhttp_method_t;
-
-#define HTTP_ERRNO_MAP(XX) \
-  XX(0, OK, OK) \
-  XX(1, INTERNAL, INTERNAL) \
-  XX(2, STRICT, STRICT) \
-  XX(3, LF_EXPECTED, LF_EXPECTED) \
-  XX(4, UNEXPECTED_CONTENT_LENGTH, UNEXPECTED_CONTENT_LENGTH) \
-  XX(5, CLOSED_CONNECTION, CLOSED_CONNECTION) \
-  XX(6, INVALID_METHOD, INVALID_METHOD) \
-  XX(7, INVALID_URL, INVALID_URL) \
-  XX(8, INVALID_CONSTANT, INVALID_CONSTANT) \
-  XX(9, INVALID_VERSION, INVALID_VERSION) \
-  XX(10, INVALID_HEADER_TOKEN, INVALID_HEADER_TOKEN) \
-  XX(11, INVALID_CONTENT_LENGTH, INVALID_CONTENT_LENGTH) \
-  XX(12, INVALID_CHUNK_SIZE, INVALID_CHUNK_SIZE) \
-  XX(13, INVALID_STATUS, INVALID_STATUS) \
-  XX(14, INVALID_EOF_STATE, INVALID_EOF_STATE) \
-  XX(15, INVALID_TRANSFER_ENCODING, INVALID_TRANSFER_ENCODING) \
-  XX(16, CB_MESSAGE_BEGIN, CB_MESSAGE_BEGIN) \
-  XX(17, CB_HEADERS_COMPLETE, CB_HEADERS_COMPLETE) \
-  XX(18, CB_MESSAGE_COMPLETE, CB_MESSAGE_COMPLETE) \
-  XX(19, CB_CHUNK_HEADER, CB_CHUNK_HEADER) \
-  XX(20, CB_CHUNK_COMPLETE, CB_CHUNK_COMPLETE) \
-  XX(21, PAUSED, PAUSED) \
-  XX(22, PAUSED_UPGRADE, PAUSED_UPGRADE) \
-  XX(23, PAUSED_H2_UPGRADE, PAUSED_H2_UPGRADE) \
-  XX(24, USER, USER) \
-
-
-#define HTTP_METHOD_MAP(XX) \
-  XX(0, DELETE, DELETE) \
-  XX(1, GET, GET) \
-  XX(2, HEAD, HEAD) \
-  XX(3, POST, POST) \
-  XX(4, PUT, PUT) \
-  XX(5, CONNECT, CONNECT) \
-  XX(6, OPTIONS, OPTIONS) \
-  XX(7, TRACE, TRACE) \
-  XX(8, COPY, COPY) \
-  XX(9, LOCK, LOCK) \
-  XX(10, MKCOL, MKCOL) \
-  XX(11, MOVE, MOVE) \
-  XX(12, PROPFIND, PROPFIND) \
-  XX(13, PROPPATCH, PROPPATCH) \
-  XX(14, SEARCH, SEARCH) \
-  XX(15, UNLOCK, UNLOCK) \
-  XX(16, BIND, BIND) \
-  XX(17, REBIND, REBIND) \
-  XX(18, UNBIND, UNBIND) \
-  XX(19, ACL, ACL) \
-  XX(20, REPORT, REPORT) \
-  XX(21, MKACTIVITY, MKACTIVITY) \
-  XX(22, CHECKOUT, CHECKOUT) \
-  XX(23, MERGE, MERGE) \
-  XX(24, MSEARCH, M-SEARCH) \
-  XX(25, NOTIFY, NOTIFY) \
-  XX(26, SUBSCRIBE, SUBSCRIBE) \
-  XX(27, UNSUBSCRIBE, UNSUBSCRIBE) \
-  XX(28, PATCH, PATCH) \
-  XX(29, PURGE, PURGE) \
-  XX(30, MKCALENDAR, MKCALENDAR) \
-  XX(31, LINK, LINK) \
-  XX(32, UNLINK, UNLINK) \
-  XX(33, SOURCE, SOURCE) \
-
-
-#define RTSP_METHOD_MAP(XX) \
-  XX(1, GET, GET) \
-  XX(3, POST, POST) \
-  XX(6, OPTIONS, OPTIONS) \
-  XX(35, DESCRIBE, DESCRIBE) \
-  XX(36, ANNOUNCE, ANNOUNCE) \
-  XX(37, SETUP, SETUP) \
-  XX(38, PLAY, PLAY) \
-  XX(39, PAUSE, PAUSE) \
-  XX(40, TEARDOWN, TEARDOWN) \
-  XX(41, GET_PARAMETER, GET_PARAMETER) \
-  XX(42, SET_PARAMETER, SET_PARAMETER) \
-  XX(43, REDIRECT, REDIRECT) \
-  XX(44, RECORD, RECORD) \
-  XX(45, FLUSH, FLUSH) \
-
-
-#define HTTP_ALL_METHOD_MAP(XX) \
-  XX(0, DELETE, DELETE) \
-  XX(1, GET, GET) \
-  XX(2, HEAD, HEAD) \
-  XX(3, POST, POST) \
-  XX(4, PUT, PUT) \
-  XX(5, CONNECT, CONNECT) \
-  XX(6, OPTIONS, OPTIONS) \
-  XX(7, TRACE, TRACE) \
-  XX(8, COPY, COPY) \
-  XX(9, LOCK, LOCK) \
-  XX(10, MKCOL, MKCOL) \
-  XX(11, MOVE, MOVE) \
-  XX(12, PROPFIND, PROPFIND) \
-  XX(13, PROPPATCH, PROPPATCH) \
-  XX(14, SEARCH, SEARCH) \
-  XX(15, UNLOCK, UNLOCK) \
-  XX(16, BIND, BIND) \
-  XX(17, REBIND, REBIND) \
-  XX(18, UNBIND, UNBIND) \
-  XX(19, ACL, ACL) \
-  XX(20, REPORT, REPORT) \
-  XX(21, MKACTIVITY, MKACTIVITY) \
-  XX(22, CHECKOUT, CHECKOUT) \
-  XX(23, MERGE, MERGE) \
-  XX(24, MSEARCH, M-SEARCH) \
-  XX(25, NOTIFY, NOTIFY) \
-  XX(26, SUBSCRIBE, SUBSCRIBE) \
-  XX(27, UNSUBSCRIBE, UNSUBSCRIBE) \
-  XX(28, PATCH, PATCH) \
-  XX(29, PURGE, PURGE) \
-  XX(30, MKCALENDAR, MKCALENDAR) \
-  XX(31, LINK, LINK) \
-  XX(32, UNLINK, UNLINK) \
-  XX(33, SOURCE, SOURCE) \
-  XX(34, PRI, PRI) \
-  XX(35, DESCRIBE, DESCRIBE) \
-  XX(36, ANNOUNCE, ANNOUNCE) \
-  XX(37, SETUP, SETUP) \
-  XX(38, PLAY, PLAY) \
-  XX(39, PAUSE, PAUSE) \
-  XX(40, TEARDOWN, TEARDOWN) \
-  XX(41, GET_PARAMETER, GET_PARAMETER) \
-  XX(42, SET_PARAMETER, SET_PARAMETER) \
-  XX(43, REDIRECT, REDIRECT) \
-  XX(44, RECORD, RECORD) \
-  XX(45, FLUSH, FLUSH) \
-
-
-#ifdef __cplusplus
-}  /* extern "C" */
-#endif
-#endif  /* LLLLHTTP_C_HEADERS_ */
-
-#ifndef INCLUDE_LLHTTP_API_H_
-#define INCLUDE_LLHTTP_API_H_
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <stddef.h>
-
-#if defined(__wasm__)
-#define LLHTTP_EXPORT __attribute__((visibility("default")))
-#else
-#define LLHTTP_EXPORT
-#endif
-
-typedef llhttp__internal_t llhttp_t;
-typedef struct llhttp_settings_s llhttp_settings_t;
-
-typedef int (*llhttp_data_cb)(llhttp_t*, const char *at, size_t length);
-typedef int (*llhttp_cb)(llhttp_t*);
-
-struct llhttp_settings_s {
-  /* Possible return values 0, -1, `HPE_PAUSED` */
-  llhttp_cb      on_message_begin;
-
-  /* Possible return values 0, -1, HPE_USER */
-  llhttp_data_cb on_url;
-  llhttp_data_cb on_status;
-  llhttp_data_cb on_header_field;
-  llhttp_data_cb on_header_value;
-
-  /* Possible return values:
-   * 0  - Proceed normally
-   * 1  - Assume that request/response has no body, and proceed to parsing the
-   *      next message
-   * 2  - Assume absence of body (as above) and make `llhttp_execute()` return
-   *      `HPE_PAUSED_UPGRADE`
-   * -1 - Error
-   * `HPE_PAUSED`
-   */
-  llhttp_cb      on_headers_complete;
-
-  /* Possible return values 0, -1, HPE_USER */
-  llhttp_data_cb on_body;
-
-  /* Possible return values 0, -1, `HPE_PAUSED` */
-  llhttp_cb      on_message_complete;
-
-  /* When on_chunk_header is called, the current chunk length is stored
-   * in parser->content_length.
-   * Possible return values 0, -1, `HPE_PAUSED`
-   */
-  llhttp_cb      on_chunk_header;
-  llhttp_cb      on_chunk_complete;
-
-  /* Information-only callbacks, return value is ignored */
-  llhttp_cb      on_url_complete;
-  llhttp_cb      on_status_complete;
-  llhttp_cb      on_header_field_complete;
-  llhttp_cb      on_header_value_complete;
-};
-
-/* Initialize the parser with specific type and user settings.
- *
- * NOTE: lifetime of `settings` has to be at least the same as the lifetime of
- * the `parser` here. In practice, `settings` has to be either a static
- * variable or be allocated with `malloc`, `new`, etc.
- */
-LLHTTP_EXPORT
-void llhttp_init(llhttp_t* parser, llhttp_type_t type,
-                 const llhttp_settings_t* settings);
-
-#if defined(__wasm__)
-
-LLHTTP_EXPORT
-llhttp_t* llhttp_alloc(llhttp_type_t type);
-
-LLHTTP_EXPORT
-void llhttp_free(llhttp_t* parser);
-
-LLHTTP_EXPORT
-uint8_t llhttp_get_type(llhttp_t* parser);
-
-LLHTTP_EXPORT
-uint8_t llhttp_get_http_major(llhttp_t* parser);
-
-LLHTTP_EXPORT
-uint8_t llhttp_get_http_minor(llhttp_t* parser);
-
-LLHTTP_EXPORT
-uint8_t llhttp_get_method(llhttp_t* parser);
-
-LLHTTP_EXPORT
-int llhttp_get_status_code(llhttp_t* parser);
-
-LLHTTP_EXPORT
-uint8_t llhttp_get_upgrade(llhttp_t* parser);
-
-#endif  // defined(__wasm__)
-
-/* Reset an already initialized parser back to the start state, preserving the
- * existing parser type, callback settings, user data, and lenient flags.
- */
-LLHTTP_EXPORT
-void llhttp_reset(llhttp_t* parser);
-
-/* Initialize the settings object */
-LLHTTP_EXPORT
-void llhttp_settings_init(llhttp_settings_t* settings);
-
-/* Parse full or partial request/response, invoking user callbacks along the
- * way.
- *
- * If any of `llhttp_data_cb` returns errno not equal to `HPE_OK` - the parsing
- * interrupts, and such errno is returned from `llhttp_execute()`. If
- * `HPE_PAUSED` was used as a errno, the execution can be resumed with
- * `llhttp_resume()` call.
- *
- * In a special case of CONNECT/Upgrade request/response `HPE_PAUSED_UPGRADE`
- * is returned after fully parsing the request/response. If the user wishes to
- * continue parsing, they need to invoke `llhttp_resume_after_upgrade()`.
- *
- * NOTE: if this function ever returns a non-pause type error, it will continue
- * to return the same error upon each successive call up until `llhttp_init()`
- * is called.
- */
-LLHTTP_EXPORT
-llhttp_errno_t llhttp_execute(llhttp_t* parser, const char* data, size_t len);
-
-/* This method should be called when the other side has no further bytes to
- * send (e.g. shutdown of readable side of the TCP connection.)
- *
- * Requests without `Content-Length` and other messages might require treating
- * all incoming bytes as the part of the body, up to the last byte of the
- * connection. This method will invoke `on_message_complete()` callback if the
- * request was terminated safely. Otherwise a error code would be returned.
- */
-LLHTTP_EXPORT
-llhttp_errno_t llhttp_finish(llhttp_t* parser);
-
-/* Returns `1` if the incoming message is parsed until the last byte, and has
- * to be completed by calling `llhttp_finish()` on EOF
- */
-LLHTTP_EXPORT
-int llhttp_message_needs_eof(const llhttp_t* parser);
-
-/* Returns `1` if there might be any other messages following the last that was
- * successfully parsed.
- */
-LLHTTP_EXPORT
-int llhttp_should_keep_alive(const llhttp_t* parser);
-
-/* Make further calls of `llhttp_execute()` return `HPE_PAUSED` and set
- * appropriate error reason.
- *
- * Important: do not call this from user callbacks! User callbacks must return
- * `HPE_PAUSED` if pausing is required.
- */
-LLHTTP_EXPORT
-void llhttp_pause(llhttp_t* parser);
-
-/* Might be called to resume the execution after the pause in user's callback.
- * See `llhttp_execute()` above for details.
- *
- * Call this only if `llhttp_execute()` returns `HPE_PAUSED`.
- */
-LLHTTP_EXPORT
-void llhttp_resume(llhttp_t* parser);
-
-/* Might be called to resume the execution after the pause in user's callback.
- * See `llhttp_execute()` above for details.
- *
- * Call this only if `llhttp_execute()` returns `HPE_PAUSED_UPGRADE`
- */
-LLHTTP_EXPORT
-void llhttp_resume_after_upgrade(llhttp_t* parser);
-
-/* Returns the latest return error */
-LLHTTP_EXPORT
-llhttp_errno_t llhttp_get_errno(const llhttp_t* parser);
-
-/* Returns the verbal explanation of the latest returned error.
- *
- * Note: User callback should set error reason when returning the error. See
- * `llhttp_set_error_reason()` for details.
- */
-LLHTTP_EXPORT
-const char* llhttp_get_error_reason(const llhttp_t* parser);
-
-/* Assign verbal description to the returned error. Must be called in user
- * callbacks right before returning the errno.
- *
- * Note: `HPE_USER` error code might be useful in user callbacks.
- */
-LLHTTP_EXPORT
-void llhttp_set_error_reason(llhttp_t* parser, const char* reason);
-
-/* Returns the pointer to the last parsed byte before the returned error. The
- * pointer is relative to the `data` argument of `llhttp_execute()`.
- *
- * Note: this method might be useful for counting the number of parsed bytes.
- */
-LLHTTP_EXPORT
-const char* llhttp_get_error_pos(const llhttp_t* parser);
-
-/* Returns textual name of error code */
-LLHTTP_EXPORT
-const char* llhttp_errno_name(llhttp_errno_t err);
-
-/* Returns textual name of HTTP method */
-LLHTTP_EXPORT
-const char* llhttp_method_name(llhttp_method_t method);
-
-
-/* Enables/disables lenient header value parsing (disabled by default).
- *
- * Lenient parsing disables header value token checks, extending llhttp's
- * protocol support to highly non-compliant clients/server. No
- * `HPE_INVALID_HEADER_TOKEN` will be raised for incorrect header values when
- * lenient parsing is "on".
- *
- * **(USE AT YOUR OWN RISK)**
- */
-LLHTTP_EXPORT
-void llhttp_set_lenient_headers(llhttp_t* parser, int enabled);
-
-
-/* Enables/disables lenient handling of conflicting `Transfer-Encoding` and
- * `Content-Length` headers (disabled by default).
- *
- * Normally `llhttp` would error when `Transfer-Encoding` is present in
- * conjunction with `Content-Length`. This error is important to prevent HTTP
- * request smuggling, but may be less desirable for small number of cases
- * involving legacy servers.
- *
- * **(USE AT YOUR OWN RISK)**
- */
-LLHTTP_EXPORT
-void llhttp_set_lenient_chunked_length(llhttp_t* parser, int enabled);
-
-
-/* Enables/disables lenient handling of `Connection: close` and HTTP/1.0
- * requests responses.
- *
- * Normally `llhttp` would error on (in strict mode) or discard (in loose mode)
- * the HTTP request/response after the request/response with `Connection: close`
- * and `Content-Length`. This is important to prevent cache poisoning attacks,
- * but might interact badly with outdated and insecure clients. With this flag
- * the extra request/response will be parsed normally.
- *
- * **(USE AT YOUR OWN RISK)**
- */
-void llhttp_set_lenient_keep_alive(llhttp_t* parser, int enabled);
-
-#ifdef __cplusplus
-}  /* extern "C" */
-#endif
-#endif  /* INCLUDE_LLHTTP_API_H_ */
-
-#endif  /* INCLUDE_LLHTTP_H_ */

src/block_template.cpp

@@ -50,6 +50,8 @@ BlockTemplate::BlockTemplate(p2pool* pool)
 	, m_difficulty{}
 	, m_seedHash{}
 	, m_timestamp(0)
+	, m_txkeyPub{}
+	, m_txkeySec{}
 	, m_poolBlockTemplate(new PoolBlock())
 	, m_finalReward(0)
 {
@@ -73,8 +75,6 @@ BlockTemplate::BlockTemplate(p2pool* pool)
 #if TEST_MEMPOOL_PICKING_ALGORITHM
 	m_knapsack.reserve(512 * 309375);
 #endif
-
-	update_tx_keys();
 }
 
 BlockTemplate::~BlockTemplate()
@@ -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;
@@ -197,6 +197,8 @@ void BlockTemplate::update(const MinerData& data, const Mempool& mempool, Wallet
 		*this = *m_oldTemplates[id % array_size(&BlockTemplate::m_oldTemplates)];
 	};
 
+	get_tx_keys(m_txkeyPub, m_txkeySec, miner_wallet->spend_public_key(), data.prev_id);
+
 	m_height = data.height;
 	m_difficulty = data.difficulty;
 	m_seedHash = data.seed_hash;
@@ -575,7 +577,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
@@ -1058,13 +1059,6 @@ std::vector<uint8_t> BlockTemplate::get_block_template_blob(uint32_t template_id
 	return m_blockTemplateBlob;
 }
 
-void BlockTemplate::update_tx_keys()
-{
-	WriteLock lock(m_lock);
-
-	generate_keys(m_txkeyPub, m_txkeySec);
-}
-
 void BlockTemplate::submit_sidechain_block(uint32_t template_id, uint32_t nonce, uint32_t extra_nonce)
 {
 	WriteLock lock(m_lock);

src/block_template.h

@@ -47,15 +47,13 @@ public:
 	uint32_t get_hashing_blobs(uint32_t extra_nonce_start, uint32_t count, std::vector<uint8_t>& blobs, uint64_t& height, difficulty_type& difficulty, difficulty_type& sidechain_difficulty, hash& seed_hash, size_t& nonce_offset, uint32_t& template_id) const;
 
 	std::vector<uint8_t> get_block_template_blob(uint32_t template_id, size_t& nonce_offset, size_t& extra_nonce_offset) const;
-	void update_tx_keys();
 
 	FORCEINLINE uint64_t height() const { return m_height; }
-	FORCEINLINE uint64_t timestamp() const { return m_timestamp; }
 	FORCEINLINE difficulty_type difficulty() const { return m_difficulty; }
 
 	void submit_sidechain_block(uint32_t template_id, uint32_t nonce, uint32_t extra_nonce);
 
-	FORCEINLINE uint64_t final_reward() const { return m_finalReward; }
+	FORCEINLINE const std::vector<MinerShare>& shares() const { return m_shares; }
 
 private:
 	p2pool* m_pool;
@@ -83,7 +81,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;
 

src/common.h

@@ -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
 
@@ -198,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()
@@ -309,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");
@@ -317,6 +333,9 @@ void* malloc_hook(size_t n) noexcept;
 void* realloc_hook(void* ptr, size_t size) noexcept;
 void* calloc_hook(size_t count, size_t size) noexcept;
 void free_hook(void* p) noexcept;
+char* strdup_hook(const char* s) noexcept;
+
+extern const char* BLOCK_FOUND;
 
 } // namespace p2pool
 

src/console_commands.cpp

@@ -31,27 +31,57 @@ static constexpr char log_category_prefix[] = "ConsoleCommands ";
 
 namespace p2pool {
 
-bool ConsoleCommands::stopped = false;
-
 ConsoleCommands::ConsoleCommands(p2pool* pool)
 	: m_pool(pool)
+	, m_loop{}
+	, m_shutdownAsync{}
+	, m_tty{}
+	, m_loopThread{}
+	, m_readBuf{}
+	, m_readBufInUse(false)
 {
-	m_worker = new std::thread(&ConsoleCommands::run, this);
+	if (uv_guess_handle(0) != UV_TTY) {
+		LOGERR(1, "tty is not available");
+		throw std::exception();
+	}
+
+	int err = uv_loop_init(&m_loop);
+	if (err) {
+		LOGERR(1, "failed to create event loop, error " << uv_err_name(err));
+		throw std::exception();
+	}
+
+	err = uv_async_init(&m_loop, &m_shutdownAsync, on_shutdown);
+	if (err) {
+		LOGERR(1, "uv_async_init failed, error " << uv_err_name(err));
+		throw std::exception();
+	}
+	m_shutdownAsync.data = this;
+
+	err = uv_tty_init(&m_loop, &m_tty, 0, 1);
+	if (err) {
+		LOGERR(1, "uv_tty_init failed, error " << uv_err_name(err));
+		throw std::exception();
+	}
+	m_tty.data = this;
+
+	err = uv_read_start(reinterpret_cast<uv_stream_t*>(&m_tty), allocCallback, stdinReadCallback);
+	if (err) {
+		LOGERR(1, "uv_read_start failed, error " << uv_err_name(err));
+		throw std::exception();
+	}
+
+	err = uv_thread_create(&m_loopThread, loop, this);
+	if (err) {
+		LOGERR(1, "failed to start event loop thread, error " << uv_err_name(err));
+		throw std::exception();
+	}
 }
 
 ConsoleCommands::~ConsoleCommands()
 {
-	stopped = true;
-
-#ifdef _WIN32
-	TerminateThread(reinterpret_cast<HANDLE>(m_worker->native_handle()), 0);
-#else
-	pthread_cancel(m_worker->native_handle());
-#endif
-
-	m_worker->join();
-	delete m_worker;
-
+	uv_async_send(&m_shutdownAsync);
+	uv_thread_join(&m_loopThread);
 	LOGINFO(1, "stopped");
 }
 
@@ -63,7 +93,7 @@ typedef struct strconst {
 #define STRCONST(x)	{x, sizeof(x)-1}
 #define STRCNULL	{NULL, 0}
 
-typedef int (cmdfunc)(p2pool *pool, const char *args);
+typedef void (cmdfunc)(p2pool *pool, const char *args);
 
 typedef struct cmd {
 	strconst name;
@@ -72,7 +102,7 @@ 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_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;
@@ -85,6 +115,7 @@ 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 },
@@ -96,16 +127,15 @@ static cmd cmds[] = {
 	{ STRCNULL, NULL, NULL, NULL }
 };
 
-static int do_help(p2pool * /* m_pool */, const char * /* args */)
+static void do_help(p2pool * /* m_pool */, const char * /* args */)
 {
 	LOGINFO(0, "List of commands");
 	for (int i = 0; cmds[i].name.len; ++i) {
 		LOGINFO(0, cmds[i].name.str << " " << cmds[i].arg << "\t" << cmds[i].descr);
 	}
-	return 0;
 }
 
-static int do_status(p2pool *m_pool, const char * /* args */)
+static void do_status(p2pool *m_pool, const char * /* args */)
 {
 	m_pool->side_chain().print_status();
 	if (m_pool->stratum_server()) {
@@ -118,43 +148,45 @@ static int do_status(p2pool *m_pool, const char * /* args */)
 	m_pool->print_miner_status();
 #endif
 	bkg_jobs_tracker.print_status();
-	return 0;
 }
 
-static int do_loglevel(p2pool * /* m_pool */, const char *args)
+static void do_loglevel(p2pool * /* m_pool */, const char *args)
 {
 	int level = strtol(args, nullptr, 10);
 	level = std::min(std::max(level, 0), log::MAX_GLOBAL_LOG_LEVEL);
 	log::GLOBAL_LOG_LEVEL = level;
 	LOGINFO(0, "log level set to " << level);
-	return 0;
 }
 
-static int do_addpeers(p2pool *m_pool, const char *args)
+static void do_addpeers(p2pool *m_pool, const char *args)
 {
 	if (m_pool->p2p_server()) {
 		m_pool->p2p_server()->connect_to_peers(args);
 	}
-	return 0;
 }
 
-static int do_droppeers(p2pool *m_pool, const char * /* args */)
+static void do_droppeers(p2pool *m_pool, const char * /* args */)
 {
 	if (m_pool->p2p_server()) {
 		m_pool->p2p_server()->drop_connections();
 	}
-	return 0;
 }
 
-static int do_showpeers(p2pool* m_pool, const char* /* args */)
+static void do_showpeers(p2pool* m_pool, const char* /* args */)
 {
 	if (m_pool->p2p_server()) {
 		m_pool->p2p_server()->show_peers();
 	}
-	return 0;
 }
 
-static int do_showbans(p2pool* m_pool, const char* /* args */)
+static void do_showworkers(p2pool* m_pool, const char* /* args */)
+{
+	if (m_pool->stratum_server()) {
+		m_pool->stratum_server()->show_workers();
+	}
+}
+
+static void do_showbans(p2pool* m_pool, const char* /* args */)
 {
 	if (m_pool->stratum_server()) {
 		m_pool->stratum_server()->print_bans();
@@ -162,87 +194,98 @@ static int do_showbans(p2pool* m_pool, const char* /* args */)
 	if (m_pool->p2p_server()) {
 		m_pool->p2p_server()->print_bans();
 	}
-	return 0;
 }
 
-static int do_outpeers(p2pool* m_pool, const char* args)
+static void do_outpeers(p2pool* m_pool, const char* args)
 {
 	if (m_pool->p2p_server()) {
 		m_pool->p2p_server()->set_max_outgoing_peers(strtoul(args, nullptr, 10));
 		LOGINFO(0, "max outgoing peers set to " << m_pool->p2p_server()->max_outgoing_peers());
 	}
-	return 0;
 }
 
-static int do_inpeers(p2pool* m_pool, const char* args)
+static void do_inpeers(p2pool* m_pool, const char* args)
 {
 	if (m_pool->p2p_server()) {
 		m_pool->p2p_server()->set_max_incoming_peers(strtoul(args, nullptr, 10));
 		LOGINFO(0, "max incoming peers set to " << m_pool->p2p_server()->max_incoming_peers());
 	}
-	return 0;
 }
 
 #ifdef WITH_RANDOMX
-static int do_start_mining(p2pool* m_pool, const char* args)
+static void do_start_mining(p2pool* m_pool, const char* args)
 {
 	uint32_t threads = strtoul(args, nullptr, 10);
 	threads = std::min(std::max(threads, 1u), 64u);
 	m_pool->start_mining(threads);
-	return 0;
 }
 
-static int do_stop_mining(p2pool* m_pool, const char* /*args*/)
+static void 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 */)
+static void do_exit(p2pool *m_pool, const char * /* args */)
 {
 	bkg_jobs_tracker.wait();
 	m_pool->stop();
-
-	return 1;
 }
 
-void ConsoleCommands::run()
+void ConsoleCommands::allocCallback(uv_handle_t* handle, size_t /*suggested_size*/, uv_buf_t* buf)
 {
-	LOGINFO(1, "started");
+	ConsoleCommands* pThis = static_cast<ConsoleCommands*>(handle->data);
 
-	std::string command;
-	command.reserve(1024);
+	if (pThis->m_readBufInUse) {
+		buf->len = 0;
+		buf->base = nullptr;
+		return;
+	}
 
-	do {
-		std::getline(std::cin, command);
+	buf->len = sizeof(pThis->m_readBuf);
+	buf->base = pThis->m_readBuf;
+	pThis->m_readBufInUse = true;
+}
 
-		if (std::cin.eof()) {
-			LOGINFO(1, "EOF, stopping");
-			return;
-		}
+void ConsoleCommands::stdinReadCallback(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf)
+{
+	ConsoleCommands* pThis = static_cast<ConsoleCommands*>(stream->data);
 
-		if (stopped) {
-			LOGINFO(1, "stopping");
-			return;
-		}
+	if (nread > 0) {
+		for (size_t i = 0; i < static_cast<size_t>(nread); ++i) {
+			if ((buf->base[i] == '\r') || (buf->base[i] == '\n')) {
+				buf->base[i] = '\0';
 
-		cmd* c = cmds;
-		for (; c->name.len; ++c) {
-			if (!strncmp(command.c_str(), c->name.str, c->name.len)) {
-				const char *args = command.c_str() + c->name.len + 1;
-				if (c->func(m_pool, args)) {
-					LOGINFO(1, "exit requested, stopping");
-					return;
+				cmd* c = cmds;
+				for (; c->name.len; ++c) {
+					if (!strncmp(buf->base, c->name.str, c->name.len)) {
+						const char* args = (c->name.len + 1 <= i) ? (buf->base + c->name.len + 1) : "";
+						c->func(pThis->m_pool, args);
+						break;
+					}
+				}
+
+				if (!c->name.len) {
+					LOGWARN(0, "Unknown command " << buf->base);
 				}
 				break;
 			}
 		}
+	}
+	else if (nread < 0) {
+		LOGWARN(4, "read error " << uv_err_name(static_cast<int>(nread)));
+	}
 
-		if (!c->name.len) {
-			LOGWARN(0, "Unknown command " << command);
-		}
-	} while (true);
+	pThis->m_readBufInUse = false;
+}
+
+void ConsoleCommands::loop(void* data)
+{
+	LOGINFO(1, "event loop started");
+	ConsoleCommands* pThis = static_cast<ConsoleCommands*>(data);
+	uv_run(&pThis->m_loop, UV_RUN_DEFAULT);
+	uv_loop_close(&pThis->m_loop);
+	LOGINFO(1, "event loop stopped");
 }
 
 } // namespace p2pool

src/console_commands.h

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <thread>
+#include "uv_util.h"
 
 namespace p2pool {
 
@@ -31,10 +31,26 @@ public:
 
 private:
 	p2pool* m_pool;
-	std::thread* m_worker;
 
-	static bool stopped;
-	void run();
+	uv_loop_t m_loop;
+	uv_async_t m_shutdownAsync;
+	uv_tty_t m_tty;
+	uv_thread_t m_loopThread;
+
+	char m_readBuf[64];
+	bool m_readBufInUse;
+
+	static void loop(void* data);
+
+	static void on_shutdown(uv_async_t* async)
+	{
+		ConsoleCommands* pThis = reinterpret_cast<ConsoleCommands*>(async->data);
+		uv_close(reinterpret_cast<uv_handle_t*>(&pThis->m_shutdownAsync), nullptr);
+		uv_close(reinterpret_cast<uv_handle_t*>(&pThis->m_tty), nullptr);
+	}
+
+	static void allocCallback(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf);
+	static void stdinReadCallback(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf);
 };
 
 } // namespace p2pool

src/crypto.cpp

@@ -24,6 +24,10 @@ extern "C" {
 #include "crypto-ops.h"
 }
 
+// l = 2^252 + 27742317777372353535851937790883648493.
+// l fits 15 times in 32 bytes (iow, 15 l is the highest multiple of l that fits in 32 bytes)
+static constexpr uint8_t limit[32] = { 0xe3, 0x6a, 0x67, 0x72, 0x8b, 0xce, 0x13, 0x29, 0x8f, 0x30, 0x82, 0x8c, 0x0b, 0xa4, 0x10, 0x39, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0 };
+
 namespace p2pool {
 
 namespace {
@@ -79,10 +83,6 @@ static FORCEINLINE bool less32(const uint8_t* k0, const uint8_t* k1)
 // cppcheck-suppress constParameter
 void generate_keys(hash& pub, hash& sec)
 {
-	// l = 2^252 + 27742317777372353535851937790883648493.
-	// l fits 15 times in 32 bytes (iow, 15 l is the highest multiple of l that fits in 32 bytes)
-	static constexpr uint8_t limit[32] = { 0xe3, 0x6a, 0x67, 0x72, 0x8b, 0xce, 0x13, 0x29, 0x8f, 0x30, 0x82, 0x8c, 0x0b, 0xa4, 0x10, 0x39, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0 };
-
 	do {
 		do { randomBytes(sec.h); } while (!less32(sec.h, limit));
 		sc_reduce32(sec.h);
@@ -93,6 +93,29 @@ void generate_keys(hash& pub, hash& sec)
 	ge_p3_tobytes(pub.h, &point);
 }
 
+void generate_keys_deterministic(hash& pub, hash& sec, const uint8_t* entropy, size_t len)
+{
+	uint32_t counter = 0;
+
+	do {
+		do {
+			++counter;
+			keccak_custom([entropy, len, counter](int offset)
+			{
+				if (offset < static_cast<int>(len)) {
+					return entropy[offset];
+				}
+				return static_cast<uint8_t>(counter >> ((offset - len) * 8));
+			}, static_cast<int>(len + sizeof(counter)), sec.h, HASH_SIZE);
+		} while (!less32(sec.h, limit));
+		sc_reduce32(sec.h);
+	} while (!sc_isnonzero(sec.h));
+
+	ge_p3 point;
+	ge_scalarmult_base(&point, sec.h);
+	ge_p3_tobytes(pub.h, &point);
+}
+
 bool check_keys(const hash& pub, const hash& sec)
 {
 	// From ge_scalarmult_base's comment: "preconditions a[31] <= 127"
@@ -226,24 +249,59 @@ public:
 		return true;
 	}
 
+	void get_tx_keys(hash& pub, hash& sec, const hash& wallet_spend_key, const hash& monero_block_id)
+	{
+		std::array<uint8_t, HASH_SIZE * 2> index;
+		memcpy(index.data(), wallet_spend_key.h, HASH_SIZE);
+		memcpy(index.data() + HASH_SIZE, monero_block_id.h, HASH_SIZE);
+
+		{
+			MutexLock lock(m);
+			auto it = tx_keys.find(index);
+			if (it != tx_keys.end()) {
+				pub = it->second.first;
+				sec = it->second.second;
+				return;
+			}
+		}
+
+		static constexpr char domain[] = "tx_secret_key";
+		static constexpr size_t N = sizeof(domain) - 1;
+		uint8_t entropy[N + HASH_SIZE * 2];
+
+		memcpy(entropy, domain, N);
+		memcpy(entropy + N, wallet_spend_key.h, HASH_SIZE);
+		memcpy(entropy + N + HASH_SIZE, monero_block_id.h, HASH_SIZE);
+
+		generate_keys_deterministic(pub, sec, entropy, sizeof(entropy));
+
+		{
+			MutexLock lock(m);
+			tx_keys.emplace(index, std::pair<hash, hash>(pub, sec));
+		}
+	}
+
 	void clear()
 	{
 		MutexLock lock(m);
 
 		derivations.clear();
 		public_keys.clear();
+		tx_keys.clear();
 	}
 
 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 + sizeof(size_t)>, DerivationEntry> derivations;
 	unordered_map<std::array<uint8_t, HASH_SIZE * 2 + sizeof(size_t)>, hash> public_keys;
+	unordered_map<std::array<uint8_t, HASH_SIZE * 2>, std::pair<hash, hash>> tx_keys;
 };
 
 static Cache* cache = nullptr;
@@ -258,6 +316,11 @@ 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 get_tx_keys(hash& pub, hash& sec, const hash& wallet_spend_key, const hash& monero_block_id)
+{
+	cache->get_tx_keys(pub, sec, wallet_spend_key, monero_block_id);
+}
+
 void derive_view_tag(const hash& derivation, size_t output_index, uint8_t& view_tag)
 {
 	constexpr uint8_t salt[] = "view_tag";

src/crypto.h

@@ -20,6 +20,8 @@
 namespace p2pool {
 
 void generate_keys(hash& pub, hash& sec);
+void generate_keys_deterministic(hash& pub, hash& sec, const uint8_t* entropy, size_t len);
+void get_tx_keys(hash& pub, hash& sec, const hash& wallet_spend_key, const hash& monero_block_id);
 bool check_keys(const hash& pub, const hash& sec);
 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);

src/json_parsers.h

@@ -104,7 +104,7 @@ struct parse_wrapper<T, difficulty_type>
 			if (!from_hex(s[i], d)) {
 				return false;
 			}
-			out_value.hi = (out_value.hi << 4) || (out_value.lo >> 60);
+			out_value.hi = (out_value.hi << 4) | (out_value.lo >> 60);
 			out_value.lo = (out_value.lo << 4) | d;
 		}
 

src/json_rpc_request.cpp

@@ -18,235 +18,379 @@
 #include "common.h"
 #include "uv_util.h"
 #include "json_rpc_request.h"
-#include "llhttp.h"
-#include <string>
+#include <curl/curl.h>
 
 static constexpr char log_category_prefix[] = "JSONRPCRequest ";
 
 namespace p2pool {
+namespace JSONRPCRequest {
 
-JSONRPCRequest::JSONRPCRequest(const char* address, int port, const char* req, CallbackBase* cb, CallbackBase* close_cb, uv_loop_t* loop)
-	: m_socket{}
-	, m_connect{}
-	, m_write{}
+struct CurlContext
+{
+	CurlContext(const std::string& address, int port, const std::string& req, const std::string& auth, CallbackBase* cb, CallbackBase* close_cb, uv_loop_t* loop);
+	~CurlContext();
+
+	static int socket_func(CURL* easy, curl_socket_t s, int action, void* userp, void* socketp)
+	{
+		CurlContext* ctx = reinterpret_cast<CurlContext*>(socketp ? socketp : userp);
+		return ctx->on_socket(easy, s, action);
+	}
+
+	static int timer_func(CURLM* multi, long timeout_ms, void* ctx)
+	{
+		return reinterpret_cast<CurlContext*>(ctx)->on_timer(multi, timeout_ms);
+	}
+
+	static size_t write_func(const void* buffer, size_t size, size_t count, void* ctx)
+	{
+		return reinterpret_cast<CurlContext*>(ctx)->on_write(buffer, size, count);
+	}
+
+	int on_socket(CURL* easy, curl_socket_t s, int action);
+	int on_timer(CURLM* multi, long timeout_ms);
+
+	static void on_timeout(uv_handle_t* req);
+
+	size_t on_write(const void* buffer, size_t size, size_t count);
+
+	static void curl_perform(uv_poll_t* req, int status, int events);
+	void check_multi_info();
+
+	static void on_close(uv_handle_t* h);
+
+	void close_handles();
+
+	uv_poll_t m_pollHandle;
+	curl_socket_t m_socket;
+
+	CallbackBase* m_callback;
+	CallbackBase* m_closeCallback;
+
+	uv_loop_t* m_loop;
+	uv_timer_t m_timer;
+	uv_async_t m_async;
+	CURLM* m_multiHandle;
+	CURL* m_handle;
+
+	std::string m_url;
+	std::string m_req;
+	std::string m_auth;
+
+	std::vector<char> m_response;
+	std::string m_error;
+
+	curl_slist* m_headers;
+};
+
+CurlContext::CurlContext(const std::string& address, int port, const std::string& req, const std::string& auth, CallbackBase* cb, CallbackBase* close_cb, uv_loop_t* loop)
+	: m_pollHandle{}
+	, m_socket{}
 	, m_callback(cb)
 	, m_closeCallback(close_cb)
-	, m_contentLength(0)
-	, m_contentLengthHeader(false)
-	, m_readBufInUse(false)
-	, m_valid(true)
+	, m_loop(loop)
+	, m_timer{}
+	, m_async{}
+	, m_multiHandle(nullptr)
+	, m_handle(nullptr)
+	, m_req(req)
+	, m_auth(auth)
+	, m_headers(nullptr)
 {
-	m_readBuf[0] = '\0';
+	{
+		char buf[log::Stream::BUF_SIZE + 1];
+		buf[0] = '\0';
 
-	uv_tcp_init(loop ? loop : uv_default_loop_checked(), &m_socket);
-	uv_tcp_nodelay(&m_socket, 1);
+		log::Stream s(buf);
+		s << "http://" << address << ':' << port;
 
-	sockaddr_storage addr;
-	if (uv_ip4_addr(address, port, reinterpret_cast<sockaddr_in*>(&addr)) != 0) {
-		const int err = uv_ip6_addr(address, port, reinterpret_cast<sockaddr_in6*>(&addr));
-		if (err) {
-			LOGERR(1, "invalid IP address " << address << " or port " << port);
-			m_valid = false;
+		if (!m_req.empty() && (m_req.front() == '/')) {
+			s << m_req.c_str() << '\0';
+			m_req.clear();
+		}
+		else {
+			s << "/json_rpc\0";
+		}
+
+		m_url = buf;
+	}
+
+	int err = uv_timer_init(m_loop, &m_timer);
+	if (err) {
+		LOGERR(1, "uv_timer_init failed, error " << uv_err_name(err));
+		throw std::runtime_error("uv_timer_init failed");
+	}
+	m_timer.data = this;
+
+	err = uv_async_init(m_loop, &m_async, reinterpret_cast<uv_async_cb>(on_timeout));
+	if (err) {
+		LOGERR(1, "uv_async_init failed, error " << uv_err_name(err));
+		uv_close(reinterpret_cast<uv_handle_t*>(&m_timer), nullptr);
+		throw std::runtime_error("uv_async_init failed");
+	}
+	m_async.data = this;
+
+	m_multiHandle = curl_multi_init();
+	if (!m_multiHandle) {
+		static constexpr char msg[] = "curl_multi_init() failed";
+		LOGERR(1, msg);
+		uv_close(reinterpret_cast<uv_handle_t*>(&m_async), nullptr);
+		uv_close(reinterpret_cast<uv_handle_t*>(&m_timer), nullptr);
+		throw std::runtime_error(msg);
+	}
+
+#define curl_multi_setopt_checked(...) \
+	do { \
+		const CURLMcode r = curl_multi_setopt(__VA_ARGS__); \
+		if (r != CURLM_OK) { \
+			static constexpr char msg[] = "curl_multi_setopt(" #__VA_ARGS__ ") failed"; \
+			LOGERR(1, msg << ": " << curl_multi_strerror(r)); \
+			throw std::runtime_error(msg); \
+		} \
+	} while (0)
+
+	curl_multi_setopt_checked(m_multiHandle, CURLMOPT_SOCKETFUNCTION, socket_func);
+	curl_multi_setopt_checked(m_multiHandle, CURLMOPT_SOCKETDATA, this);
+	
+	curl_multi_setopt_checked(m_multiHandle, CURLMOPT_TIMERFUNCTION, timer_func);
+	curl_multi_setopt_checked(m_multiHandle, CURLMOPT_TIMERDATA, this);
+
+	m_handle = curl_easy_init();
+	if (!m_handle) {
+		static constexpr char msg[] = "curl_easy_init() failed";
+		LOGERR(1, msg);
+		curl_multi_cleanup(m_multiHandle);
+		uv_close(reinterpret_cast<uv_handle_t*>(&m_async), nullptr);
+		uv_close(reinterpret_cast<uv_handle_t*>(&m_timer), nullptr);
+		throw std::runtime_error(msg);
+	}
+
+#define curl_easy_setopt_checked(...) \
+	do { \
+		const CURLcode r = curl_easy_setopt(__VA_ARGS__); \
+		if (r != CURLE_OK) { \
+			static constexpr char msg[] = "curl_easy_setopt(" #__VA_ARGS__ ") failed"; \
+			LOGERR(1, msg << ": " << curl_easy_strerror(r)); \
+			throw std::runtime_error(msg); \
+		} \
+	} while (0)
+
+	curl_easy_setopt_checked(m_handle, CURLOPT_WRITEFUNCTION, write_func);
+	curl_easy_setopt_checked(m_handle, CURLOPT_WRITEDATA, this);
+
+	curl_easy_setopt_checked(m_handle, CURLOPT_URL, m_url.c_str());
+	curl_easy_setopt_checked(m_handle, CURLOPT_POSTFIELDS, m_req.c_str());
+	curl_easy_setopt_checked(m_handle, CURLOPT_CONNECTTIMEOUT, 1);
+	curl_easy_setopt_checked(m_handle, CURLOPT_TIMEOUT, 10);
+
+	m_headers = curl_slist_append(m_headers, "Content-Type: application/json");
+	if (m_headers) {
+		curl_easy_setopt_checked(m_handle, CURLOPT_HTTPHEADER, m_headers);
+	}
+
+	if (!m_auth.empty()) {
+		curl_easy_setopt_checked(m_handle, CURLOPT_HTTPAUTH, CURLAUTH_DIGEST | CURLAUTH_ONLY);
+		curl_easy_setopt_checked(m_handle, CURLOPT_USERPWD, m_auth.c_str());
+	}
+
+	CURLMcode curl_err = curl_multi_add_handle(m_multiHandle, m_handle);
+	if (curl_err != CURLM_OK) {
+		LOGERR(1, "curl_multi_add_handle failed, error " << curl_multi_strerror(curl_err));
+		curl_easy_cleanup(m_handle);
+		curl_multi_cleanup(m_multiHandle);
+		uv_close(reinterpret_cast<uv_handle_t*>(&m_async), nullptr);
+		uv_close(reinterpret_cast<uv_handle_t*>(&m_timer), nullptr);
+		throw std::runtime_error("curl_multi_add_handle failed");
+	}
+}
+
+CurlContext::~CurlContext()
+{
+	if (m_error.empty() && !m_response.empty()) {
+		(*m_callback)(m_response.data(), m_response.size());
+	}
+	delete m_callback;
+
+	(*m_closeCallback)(m_error.c_str(), m_error.length());
+	delete m_closeCallback;
+
+	curl_slist_free_all(m_headers);
+}
+
+int CurlContext::on_socket(CURL* /*easy*/, curl_socket_t s, int action)
+{
+	switch (action) {
+	case CURL_POLL_IN:
+	case CURL_POLL_OUT:
+	case CURL_POLL_INOUT:
+		{
+			if (!m_socket) {
+				m_socket = s;
+				curl_multi_assign(m_multiHandle, s, this);
+			}
+			else if (m_socket != s) {
+				LOGERR(1, "This code can't work with multiple parallel requests. Fix the code!");
+			}
+
+			int events = 0;
+			if (action != CURL_POLL_IN)  events |= UV_WRITABLE;
+			if (action != CURL_POLL_OUT) events |= UV_READABLE;
+
+			if (!m_pollHandle.data) {
+				uv_poll_init_socket(m_loop, &m_pollHandle, s);
+				m_pollHandle.data = this;
+			}
+
+			uv_poll_start(&m_pollHandle, events, curl_perform);
+		}
+		break;
+
+	case CURL_POLL_REMOVE:
+	default:
+		curl_multi_assign(m_multiHandle, s, nullptr);
+		close_handles();
+		break;
+	}
+
+	return 0;
+}
+
+int CurlContext::on_timer(CURLM* /*multi*/, long timeout_ms)
+{
+	if (timeout_ms < 0) {
+		uv_timer_stop(&m_timer);
+		return 0;
+	}
+
+	if (timeout_ms == 0) {
+		// 0 ms timeout, but we can't just call on_timeout() here - we have to kick the UV loop
+		uv_async_send(&m_async);
+		return 0;
+	}
+
+	uv_timer_start(&m_timer, reinterpret_cast<uv_timer_cb>(on_timeout), timeout_ms, 0);
+	return 0;
+}
+
+void CurlContext::on_timeout(uv_handle_t* req)
+{
+	CurlContext* ctx = reinterpret_cast<CurlContext*>(req->data);
+
+	int running_handles = 0;
+	curl_multi_socket_action(ctx->m_multiHandle, CURL_SOCKET_TIMEOUT, 0, &running_handles);
+	ctx->check_multi_info();
+
+	if (running_handles == 0) {
+		ctx->close_handles();
+	}
+}
+
+size_t CurlContext::on_write(const void* buffer, size_t size, size_t count)
+{
+	const char* p = reinterpret_cast<const char*>(buffer);
+	m_response.insert(m_response.end(), p, p + size * count);
+	return count;
+}
+
+void CurlContext::curl_perform(uv_poll_t* req, int status, int events)
+{
+	int flags = 0;
+	if (status < 0) {
+		flags |= CURL_CSELECT_ERR;
+		LOGERR(1, "uv_poll_start returned error " << uv_err_name(status));
+	}
+	else {
+		if (events & UV_READABLE) flags |= CURL_CSELECT_IN;
+		if (events & UV_WRITABLE) flags |= CURL_CSELECT_OUT;
+	}
+
+	CurlContext* ctx = reinterpret_cast<CurlContext*>(req->data);
+
+	int running_handles;
+	curl_multi_socket_action(ctx->m_multiHandle, ctx->m_socket, flags, &running_handles);
+	ctx->check_multi_info();
+}
+
+void CurlContext::check_multi_info()
+{
+	int pending;
+	while (CURLMsg* message = curl_multi_info_read(m_multiHandle, &pending)) {
+		if (message->msg == CURLMSG_DONE) {
+			if (message->data.result != CURLE_OK) {
+				m_error = curl_easy_strerror(message->data.result);
+			}
+			else {
+				long http_code = 0;
+				curl_easy_getinfo(message->easy_handle, CURLINFO_RESPONSE_CODE, &http_code);
+
+				if (http_code != 200) {
+					char buf[32] = {};
+					log::Stream s(buf);
+					s << "HTTP error " << static_cast<int>(http_code) << '\0';
+					m_error = buf;
+				}
+				else if (m_response.empty()) {
+					m_error = "empty response";
+				}
+			}
+
+			curl_multi_remove_handle(m_multiHandle, m_handle);
+			curl_easy_cleanup(m_handle);
+			curl_multi_cleanup(m_multiHandle);
 			return;
 		}
 	}
+}
 
-	m_socket.data = this;
-	m_connect.data = this;
-	m_write.data = this;
+void CurlContext::on_close(uv_handle_t* h)
+{
+	CurlContext* ctx = reinterpret_cast<CurlContext*>(h->data);
+	h->data = nullptr;
 
-	const char* uri = "/json_rpc";
-
-	size_t len = req ? strlen(req) : 0;
-	if (!len) {
-		LOGERR(1, "Empty JSONRPCRequest, fix the code!");
-		m_valid = false;
+	if (ctx->m_timer.data || ctx->m_async.data || ctx->m_pollHandle.data) {
 		return;
 	}
 
-	if (req[0] == '/') {
-		uri = req;
-		len = 0;
+	delete ctx;
+}
+
+void CurlContext::close_handles()
+{
+	if (m_pollHandle.data && !uv_is_closing(reinterpret_cast<uv_handle_t*>(&m_pollHandle))) {
+		uv_poll_stop(&m_pollHandle);
+		uv_close(reinterpret_cast<uv_handle_t*>(&m_pollHandle), on_close);
 	}
 
-	m_request.reserve(std::max<size_t>(len + 128, log::Stream::BUF_SIZE + 1));
-	m_request.resize(log::Stream::BUF_SIZE + 1);
+	if (m_async.data && !uv_is_closing(reinterpret_cast<uv_handle_t*>(&m_async))) {
+		uv_close(reinterpret_cast<uv_handle_t*>(&m_async), on_close);
+	}
 
-	log::Stream s(m_request.data());
-	s << "POST " << uri << " HTTP/1.1\nContent-Type: application/json\nContent-Length: " << len << "\n\n";
-
-	m_request.resize(s.m_pos);
-	m_request.insert(m_request.end(), req, req + len);
-
-	m_response.reserve(sizeof(m_readBuf));
-
-	const int err = uv_tcp_connect(&m_connect, &m_socket, reinterpret_cast<const sockaddr*>(&addr), on_connect);
-	if (err) {
-		LOGERR(1, "failed to initiate tcp connection to " << address << ", error " << uv_err_name(err));
-		m_valid = false;
+	if (m_timer.data && !uv_is_closing(reinterpret_cast<uv_handle_t*>(&m_timer))) {
+		uv_close(reinterpret_cast<uv_handle_t*>(&m_timer), on_close);
 	}
 }
 
-void JSONRPCRequest::on_connect(uv_connect_t* req, int status)
+void Call(const std::string& address, int port, const std::string& req, const std::string& auth, CallbackBase* cb, CallbackBase* close_cb, uv_loop_t* loop)
 {
-	JSONRPCRequest* pThis = static_cast<JSONRPCRequest*>(req->data);
-
-	if (status != 0) {
-		pThis->m_error = uv_err_name(status);
-		LOGERR(1, "failed to connect, error " << pThis->m_error);
-		pThis->close();
-		return;
+	if (!loop) {
+		loop = uv_default_loop();
 	}
 
-	uv_buf_t buf[1];
-	buf[0].base = pThis->m_request.data();
-	buf[0].len = static_cast<uint32_t>(pThis->m_request.size());
-
-	uv_write(&pThis->m_write, reinterpret_cast<uv_stream_t*>(&pThis->m_socket), buf, 1, on_write);
-}
-
-void JSONRPCRequest::on_write(uv_write_t* handle, int status)
-{
-	JSONRPCRequest* pThis = static_cast<JSONRPCRequest*>(handle->data);
-
-	if (status != 0) {
-		pThis->m_error = uv_err_name(status);
-		LOGERR(1, "failed to send request, error " << pThis->m_error);
-		pThis->close();
-		return;
-	}
-
-	uv_read_start(reinterpret_cast<uv_stream_t*>(&pThis->m_socket), on_alloc, on_read);
-}
-
-void JSONRPCRequest::on_alloc(uv_handle_t* handle, size_t /*suggested_size*/, uv_buf_t* buf)
-{
-	JSONRPCRequest* pThis = static_cast<JSONRPCRequest*>(handle->data);
-
-	if (pThis->m_readBufInUse) {
-		LOGERR(1, "read buffer is already in use");
-	}
-
-	buf->len = sizeof(pThis->m_readBuf);
-	buf->base = pThis->m_readBuf;
-	pThis->m_readBufInUse = true;
-}
-
-void JSONRPCRequest::on_read(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf)
-{
-	JSONRPCRequest* pThis = static_cast<JSONRPCRequest*>(stream->data);
-	pThis->m_readBufInUse = false;
-
-	if (nread > 0) {
-		pThis->on_read(buf->base, nread);
-	}
-	else if (nread < 0) {
-		if (nread != UV_EOF){
-			pThis->m_error = uv_err_name(static_cast<int>(nread));
-			LOGERR(1, "failed to read response, error " << pThis->m_error);
-		}
-		pThis->close();
-	}
-}
-
-void JSONRPCRequest::on_read(const char* data, size_t size)
-{
-	m_response.append(data, size);
-
-	static constexpr char headers_end[] = "\r\n\r\n";
-	if (m_response.find(headers_end) == std::string::npos) {
-		return;
-	}
-
-	llhttp_settings_t settings{};
-
-	settings.on_status = [](llhttp_t*, const char* at, size_t length)
-	{
-		if ((length == 2) && (!memcmp(at, "Ok", 2) || !memcmp(at, "OK", 2))) {
-			return 0;
-		}
-		return -1;
-	};
-
-	settings.on_header_field = [](llhttp_t* parser, const char* at, size_t length)
-	{
-		JSONRPCRequest* pThis = static_cast<JSONRPCRequest*>(parser->data);
-		static const char header[] = "Content-Length";
-		pThis->m_contentLengthHeader = ((length == sizeof(header) - 1) && (memcmp(at, header, length) == 0));
-		return 0;
-	};
-
-	settings.on_header_value = [](llhttp_t* parser, const char* at, size_t length)
-	{
-		JSONRPCRequest* pThis = static_cast<JSONRPCRequest*>(parser->data);
-		if (pThis->m_contentLengthHeader) {
-			uint32_t k = 0;
-			for (const char* p = at; p < at + length; ++p) {
-				if ('0' <= *p && *p <= '9') {
-					k = k * 10 + (*p - '0');
-				}
-				else {
-					return -1;
-				}
+	const bool result = CallOnLoop(loop,
+		[=]()
+		{
+			try {
+				new CurlContext(address, port, req, auth, cb, close_cb, loop);
 			}
-			if (!k) {
-				return -1;
+			catch (const std::exception& e) {
+				const char* msg = e.what();
+				(*close_cb)(msg, strlen(msg));
 			}
-			pThis->m_contentLength = k;
-		}
-		return 0;
-	};
+		});
 
-	settings.on_body = [](llhttp_t* parser, const char* at, size_t length)
-	{
-		JSONRPCRequest* pThis = static_cast<JSONRPCRequest*>(parser->data);
-		if (pThis->m_contentLength && (length >= pThis->m_contentLength) && pThis->m_callback) {
-			(*pThis->m_callback)(at, length);
-			delete pThis->m_callback;
-			pThis->m_callback = nullptr;
-		}
-		return 0;
-	};
-
-	llhttp_t parser;
-	llhttp_init(&parser, HTTP_RESPONSE, &settings);
-
-	parser.data = this;
-
-	const llhttp_errno result = llhttp_execute(&parser, m_response.c_str(), m_response.length());
-	if (result != HPE_OK) {
-		m_error = "failed to parse response";
-		LOGERR(1, m_error << ", result = " << static_cast<int>(result));
-		close();
-		return;
-	}
-
-	if (!m_callback) {
-		close();
+	if (!result) {
+		LOGERR(1, "JSON RPC \"" << req << "\" failed");
 	}
 }
 
-void JSONRPCRequest::close()
-{
-	uv_handle_t* h = reinterpret_cast<uv_handle_t*>(&m_socket);
-	if (!uv_is_closing(h)) {
-		uv_close(h, on_close);
-	}
-}
-
-void JSONRPCRequest::on_close(uv_handle_t* handle)
-{
-	JSONRPCRequest* req = static_cast<JSONRPCRequest*>(handle->data);
-	if (req->m_closeCallback) {
-		(*req->m_closeCallback)(req->m_error.c_str(), req->m_error.length());
-	}
-	delete req;
-}
-
-JSONRPCRequest::~JSONRPCRequest()
-{
-	delete m_callback;
-	delete m_closeCallback;
-}
-
+} // namespace JSONRPCRequest
 } // namespace p2pool

src/json_rpc_request.h

@@ -18,77 +18,32 @@
 #pragma once
 
 namespace p2pool {
+namespace JSONRPCRequest {
 
-class JSONRPCRequest
+struct CallbackBase
 {
-public:
-	template<typename T>
-	static FORCEINLINE void call(const char* address, int port, const char* req, T&& cb)
-	{
-		// It will be deleted in one of the tcp callbacks eventually
-		JSONRPCRequest* r = new JSONRPCRequest(address, port, req, new Callback<T>(std::move(cb)), nullptr, nullptr);
-		if (!r->m_valid) {
-			delete r;
-		}
-	}
-
-	template<typename T, typename U>
-	static FORCEINLINE void call(const char* address, int port, const char* req, T&& cb, U&& close_cb, uv_loop_t* loop = nullptr)
-	{
-		// It will be deleted in one of the tcp callbacks eventually
-		CallbackBase* close_callback = new Callback<U>(std::move(close_cb));
-		JSONRPCRequest* r = new JSONRPCRequest(address, port, req, new Callback<T>(std::move(cb)), close_callback, loop);
-		if (!r->m_valid) {
-			constexpr char err[] = "internal error";
-			(*close_callback)(err, sizeof(err) - 1);
-			delete r;
-		}
-	}
-
-private:
-	struct CallbackBase
-	{
-		virtual ~CallbackBase() {}
-		virtual void operator()(const char* data, size_t size) = 0;
-	};
-
-	template<typename T>
-	struct Callback : public CallbackBase
-	{
-		explicit FORCEINLINE Callback(T&& cb) : m_cb(std::move(cb)) {}
-		void operator()(const char* data, size_t size) override { m_cb(data, size); }
-
-	private:
-		Callback& operator=(Callback&&) = delete;
-		T m_cb;
-	};
-
-	JSONRPCRequest(const char* address, int port, const char* req, CallbackBase* cb, CallbackBase* close_cb, uv_loop_t* loop);
-	~JSONRPCRequest();
-
-	static void on_connect(uv_connect_t* req, int status);
-	static void on_write(uv_write_t* handle, int status);
-	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);
-	void close();
-	static void on_close(uv_handle_t* handle);
-
-	uv_tcp_t m_socket;
-	uv_connect_t m_connect;
-	uv_write_t m_write;
-
-	CallbackBase* m_callback;
-	CallbackBase* m_closeCallback;
-	uint32_t m_contentLength;
-	bool m_contentLengthHeader;
-
-	std::vector<char> m_request;
-	std::string m_response;
-	char m_readBuf[65536];
-	bool m_readBufInUse;
-	bool m_valid;
-	std::string m_error;
+	virtual ~CallbackBase() {}
+	virtual void operator()(const char* data, size_t size) = 0;
 };
 
+template<typename T>
+struct Callback : public CallbackBase
+{
+	explicit FORCEINLINE Callback(T&& cb) : m_cb(std::move(cb)) {}
+	void operator()(const char* data, size_t size) override { m_cb(data, size); }
+
+private:
+	Callback& operator=(Callback&&) = delete;
+	T m_cb;
+};
+
+void Call(const std::string& address, int port, const std::string& req, const std::string& auth, CallbackBase* cb, CallbackBase* close_cb, uv_loop_t* loop);
+
+template<typename T, typename U>
+FORCEINLINE void call(const std::string& address, int port, const std::string& req, const std::string& auth, T&& cb, U&& close_cb, uv_loop_t* loop = nullptr)
+{
+	Call(address, port, req, auth, new Callback<T>(std::move(cb)), new Callback<U>(std::move(close_cb)), loop);
+}
+
+} // namespace JSONRPCRequest
 } // namespace p2pool

src/keccak.cpp

@@ -48,7 +48,7 @@ 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];
 
-#define X(i) { \
+#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; \
@@ -57,9 +57,11 @@ NOINLINE void keccakf(uint64_t* st)
 			st[i + 20] ^= t; \
 		}
 
-		X(0); X(1); X(2); X(3); X(4);
-
-#undef X
+		THETA(0);
+		THETA(1);
+		THETA(2);
+		THETA(3);
+		THETA(4);
 
 		// Rho Pi
 		const uint64_t t = st[1];
@@ -89,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];
 	}
@@ -173,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);

src/log.cpp

@@ -194,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);
@@ -232,6 +223,13 @@ private:
 			// 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);
 	}
@@ -278,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);

src/log.h

@@ -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; \

src/main.cpp

@@ -20,6 +20,7 @@
 #include "p2pool.h"
 #include "stratum_server.h"
 #include "p2p_server.h"
+#include <curl/curl.h>
 
 void p2pool_usage()
 {
@@ -44,7 +45,9 @@ 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"
+		"--rpc-login          Specify username[:password] required for Monero RPC server\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",
@@ -79,15 +82,25 @@ int main(int argc, char* argv[])
 		}
 	}
 
-	int result;
-
 	memory_tracking_start();
 
 	p2pool::init_crypto_cache();
-	{
+
+	int result = static_cast<int>(curl_global_init_mem(CURL_GLOBAL_ALL, p2pool::malloc_hook, p2pool::free_hook, p2pool::realloc_hook, p2pool::strdup_hook, p2pool::calloc_hook));
+	if (result != CURLE_OK) {
+		return result;
+	}
+
+	try {
 		p2pool::p2pool pool(argc, argv);
 		result = pool.run();
 	}
+	catch (...) {
+		result = 1;
+	}
+
+	curl_global_cleanup();
+
 	p2pool::destroy_crypto_cache();
 
 	memory_tracking_stop();

src/memory_leak_debug.cpp

@@ -144,6 +144,19 @@ void free_hook(void* p) noexcept
 	free(p);
 }
 
+char* strdup_hook(const char* s) noexcept
+{
+#ifdef _MSC_VER
+	char* s1 = _strdup(s);
+#else
+	char* s1 = strdup(s);
+#endif
+	if (s1) {
+		add_alocation(s1, strlen(s) + 1);
+	}
+	return s1;
+}
+
 void* realloc_hook(void* ptr, size_t size) noexcept
 {
 	remove_allocation(ptr);
@@ -236,7 +249,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 {
@@ -246,5 +261,14 @@ void* realloc_hook(void* ptr, size_t size) noexcept { return realloc(ptr, size);
 void* calloc_hook(size_t count, size_t size) noexcept { return calloc(count, size); }
 void free_hook(void* p) noexcept { free(p); }
 
+char* strdup_hook(const char* s) noexcept
+{
+#ifdef _MSC_VER
+	return _strdup(s);
+#else
+	return strdup(s);
+#endif
+}
+
 }
 #endif

src/miner.cpp

@@ -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 ";
@@ -79,8 +80,9 @@ void Miner::print_status()
 	const uint64_t hr = (dt > 0.0) ? static_cast<uint64_t>(hash_count / dt) : 0;
 
 	LOGINFO(0, "status" <<
-		"\nThreads  = " << m_threads <<
-		"\nHashrate = " << log::Hashrate(hr)
+		"\nThreads      = " << m_threads <<
+		"\nHashrate     = " << log::Hashrate(hr) <<
+		"\nShares found = " << m_sharesFound.load()
 	);
 }
 
@@ -101,22 +103,31 @@ 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;
 
 				s << "{\"current_hashrate\":" << hr
-					<< ",\"total_hashes\":" << m_totalHashes
+					<< ",\"total_hashes\":" << m_totalHashes.load()
 					<< ",\"time_running\":" << time_running
 					<< ",\"shares_found\":" << m_sharesFound.load()
+					<< ",\"block_reward_share_percent\":" << block_reward_share_percent
 					<< ",\"threads\":" << m_threads
 					<< "}";
 			});
 	}
 }
 
+void Miner::reset_share_counters()
+{
+	m_totalHashes = 0;
+	m_sharesFound = 0;
+}
+
 void Miner::run(void* data)
 {
 	WorkerData* d = static_cast<WorkerData*>(data);
@@ -194,7 +205,6 @@ void Miner::run(WorkerData* data)
 		if (j.m_diff.check_pow(h)) {
 			LOGINFO(0, log::Green() << "worker thread " << data->m_index << '/' << data->m_count << " found a mainchain block, submitting it");
 			m_pool->submit_block_async(j.m_templateId, j.m_nonce, j.m_extraNonce);
-			m_pool->block_template().update_tx_keys();
 		}
 
 		if (j.m_sidechainDiff.check_pow(h)) {

src/miner.h

@@ -33,6 +33,7 @@ public:
 
 	void print_status();
 	void on_block(const BlockTemplate& block);
+	void reset_share_counters();
 
 private:
 	static void run(void* data);
@@ -57,7 +58,7 @@ private:
 	std::chrono::high_resolution_clock::time_point m_nonceTimestamp;
 	const uint32_t m_extraNonce;
 
-	uint64_t m_totalHashes;
+	std::atomic<uint64_t> m_totalHashes;
 	std::atomic<uint32_t> m_sharesFound;
 
 	struct Job

src/p2p_server.cpp

@@ -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 {
@@ -75,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);
@@ -122,6 +124,10 @@ P2PServer::~P2PServer()
 
 	delete m_block;
 	delete m_cache;
+
+	for (const Broadcast* data : m_broadcastQueue) {
+		delete data;
+	}
 }
 
 void P2PServer::add_cached_block(const PoolBlock& block)
@@ -149,6 +155,7 @@ void P2PServer::clear_cached_blocks()
 
 	WriteLock lock(m_cachedBlocksLock);
 
+	// cppcheck-suppress identicalConditionAfterEarlyExit
 	if (!m_cachedBlocks) {
 		return;
 	}
@@ -288,6 +295,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();
 		}
@@ -310,9 +318,14 @@ void P2PServer::update_peer_list()
 				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;
 					});
@@ -406,8 +419,13 @@ void P2PServer::save_peer_list()
 
 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) {
@@ -417,7 +435,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);
@@ -426,7 +444,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) {
@@ -443,7 +463,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 += ',';
 						}
@@ -539,36 +559,38 @@ void P2PServer::load_monerod_peer_list()
 {
 	const Params& params = m_pool->params();
 
-	JSONRPCRequest::call(params.m_host.c_str(), params.m_rpcPort, "/get_peer_list",
+	JSONRPCRequest::call(params.m_host, params.m_rpcPort, "/get_peer_list", params.m_rpcLogin,
 		[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();
@@ -767,7 +789,7 @@ void P2PServer::on_broadcast()
 
 	ON_SCOPE_LEAVE([&broadcast_queue]()
 		{
-			for (Broadcast* data : broadcast_queue) {
+			for (const Broadcast* data : broadcast_queue) {
 				delete data;
 			}
 		});
@@ -780,7 +802,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;
 
@@ -798,9 +821,14 @@ void P2PServer::on_broadcast()
 
 				if (send_pruned) {
 					LOGINFO(6, "sending BLOCK_BROADCAST (pruned) to " << log::Gray() << static_cast<char*>(client->m_addrString));
-					*(p++) = static_cast<uint8_t>(MessageId::BLOCK_BROADCAST);
 
 					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);
+
 					memcpy(p, &len, sizeof(uint32_t));
 					p += sizeof(uint32_t);
 
@@ -811,9 +839,14 @@ void P2PServer::on_broadcast()
 				}
 				else {
 					LOGINFO(5, "sending BLOCK_BROADCAST (full)   to " << log::Gray() << static_cast<char*>(client->m_addrString));
-					*(p++) = static_cast<uint8_t>(MessageId::BLOCK_BROADCAST);
 
 					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);
+
 					memcpy(p, &len, sizeof(uint32_t));
 					p += sizeof(uint32_t);
 
@@ -837,25 +870,12 @@ uint64_t P2PServer::get_random64()
 
 void P2PServer::print_status()
 {
-	const int64_t uptime = seconds_since_epoch() - 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())
 	);
 }
 
@@ -863,11 +883,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()
@@ -980,12 +1005,17 @@ void P2PServer::download_missing_blocks()
 		}
 
 		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);
@@ -1012,6 +1042,7 @@ void P2PServer::check_zmq()
 	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();
 	}
 }
 
@@ -1348,12 +1379,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;
@@ -1465,12 +1501,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);
@@ -1615,8 +1656,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);
@@ -1679,15 +1726,21 @@ 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);
 
-			const uint32_t len = static_cast<uint32_t>(blob.size());
 			memcpy(p, &len, sizeof(uint32_t));
 			p += sizeof(uint32_t);
 
@@ -1801,7 +1854,7 @@ bool P2PServer::P2PClient::on_peer_list_request(const uint8_t*)
 	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");
+			LOGWARN(4, "peer " << static_cast<char*>(m_addrString) << " is sending PEER_LIST_REQUEST too often");
 			return false;
 		}
 	}
@@ -1841,12 +1894,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);
 
@@ -2002,12 +2060,17 @@ void P2PServer::P2PClient::post_handle_incoming_block(const uint32_t reset_count
 		}
 
 		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);

src/p2p_server.h

@@ -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; }
@@ -181,7 +181,7 @@ private:
 
 	uint64_t m_peerId;
 
-	uv_mutex_t m_peerListLock;
+	mutable uv_mutex_t m_peerListLock;
 
 	struct Peer
 	{
@@ -194,7 +194,7 @@ private:
 
 	std::vector<Peer> m_peerList;
 	std::vector<Peer> m_peerListMonero;
-	uint64_t m_peerListLastSaved;
+	std::atomic<uint64_t> m_peerListLastSaved;
 
 	struct Broadcast
 	{

src/p2pool.cpp

@@ -35,6 +35,7 @@
 #include "crypto.h"
 #include "p2pool_api.h"
 #include "pool_block.h"
+#include "keccak.h"
 #include <thread>
 #include <fstream>
 
@@ -60,13 +61,13 @@ p2pool::p2pool(int argc, char* argv[])
 
 	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;
@@ -75,7 +76,7 @@ p2pool::p2pool(int argc, char* argv[])
 	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();
@@ -90,24 +91,31 @@ 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);
@@ -120,7 +128,7 @@ p2pool::p2pool(int argc, char* argv[])
 
 	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);
@@ -148,7 +156,14 @@ p2pool::p2pool(int argc, char* argv[])
 
 	m_blockTemplate = new BlockTemplate(this);
 	m_mempool = new Mempool();
-	m_consoleCommands = new ConsoleCommands(this);
+
+	try {
+		m_consoleCommands = new ConsoleCommands(this);
+	}
+	catch (...) {
+		LOGERR(1, "Couldn't start console commands handler");
+		m_consoleCommands = nullptr;
+	}
 }
 
 p2pool::~p2pool()
@@ -294,7 +309,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);
 				}
@@ -302,11 +318,11 @@ void p2pool::handle_miner_data(MinerData& data)
 		}
 
 		for (uint64_t h : missing_heights) {
-			char buf[log::Stream::BUF_SIZE + 1];
+			char buf[log::Stream::BUF_SIZE + 1] = {};
 			log::Stream s(buf);
 			s << "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"get_block_header_by_height\",\"params\":{\"height\":" << h << "}}\0";
 
-			JSONRPCRequest::call(m_params->m_host.c_str(), m_params->m_rpcPort, buf,
+			JSONRPCRequest::call(m_params->m_host, m_params->m_rpcPort, buf, m_params->m_rpcLogin,
 				[this, h](const char* data, size_t size)
 				{
 					ChainMain block;
@@ -404,6 +420,13 @@ void p2pool::submit_block_async(uint32_t template_id, uint32_t nonce, uint32_t e
 		m_submitBlockData.blob.clear();
 	}
 
+	// If p2pool is stopped, m_submitBlockAsync is most likely already closed
+	if (m_stopped) {
+		LOGWARN(0, "p2pool is shutting down, but a block was found. Trying to submit it anyway!");
+		submit_block();
+		return;
+	}
+
 	const int err = uv_async_send(&m_submitBlockAsync);
 	if (err) {
 		LOGERR(1, "uv_async_send failed, error " << uv_err_name(err));
@@ -421,6 +444,13 @@ void p2pool::submit_block_async(const std::vector<uint8_t>& blob)
 		m_submitBlockData.blob = blob;
 	}
 
+	// If p2pool is stopped, m_submitBlockAsync is most likely already closed
+	if (m_stopped) {
+		LOGWARN(0, "p2pool is shutting down, but a block was found. Trying to submit it anyway!");
+		submit_block();
+		return;
+	}
+
 	const int err = uv_async_send(&m_submitBlockAsync);
 	if (err) {
 		LOGERR(1, "uv_async_send failed, error " << uv_err_name(err));
@@ -438,7 +468,11 @@ 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_stop(uv_default_loop());
+	uv_close(reinterpret_cast<uv_handle_t*>(&pool->m_restartZMQAsync), nullptr);
+
+	uv_loop_t* loop = uv_default_loop_checked();
+	delete GetLoopUserData(loop, false);
+	uv_stop(loop);
 }
 
 void p2pool::submit_block() const
@@ -498,7 +532,7 @@ void p2pool::submit_block() const
 	}
 	request.append("\"]}");
 
-	JSONRPCRequest::call(m_params->m_host.c_str(), m_params->m_rpcPort, request.c_str(),
+	JSONRPCRequest::call(m_params->m_host, m_params->m_rpcPort, request, m_params->m_rpcLogin,
 		[height, diff, template_id, nonce, extra_nonce, is_external](const char* data, size_t size)
 		{
 			rapidjson::Document doc;
@@ -550,7 +584,7 @@ void p2pool::submit_block() const
 					LOGWARN(3, "submit_block (external blob): RPC request failed, error " << log::const_buf(data, size));
 				}
 				else {
-					LOGERR(0, "submit_block (external blob): RPC request failed, error " << log::const_buf(data, size));
+					LOGERR(0, "submit_block: RPC request failed, error " << log::const_buf(data, size));
 				}
 			}
 		});
@@ -564,6 +598,11 @@ void p2pool::submit_sidechain_block(uint32_t template_id, uint32_t nonce, uint32
 
 void p2pool::update_block_template_async()
 {
+	// If p2pool is stopped, m_blockTemplateAsync is most likely already closed
+	if (m_stopped) {
+		return;
+	}
+
 	const int err = uv_async_send(&m_blockTemplateAsync);
 	if (err) {
 		LOGERR(1, "uv_async_send failed, error " << uv_err_name(err));
@@ -588,7 +627,7 @@ void p2pool::download_block_headers(uint64_t current_height)
 	const uint64_t seed_height = get_seed_height(current_height);
 	const uint64_t prev_seed_height = (seed_height > SEEDHASH_EPOCH_BLOCKS) ? (seed_height - SEEDHASH_EPOCH_BLOCKS) : 0;
 
-	char buf[log::Stream::BUF_SIZE + 1];
+	char buf[log::Stream::BUF_SIZE + 1] = {};
 	log::Stream s(buf);
 
 	// First download 2 RandomX seeds
@@ -597,7 +636,7 @@ void p2pool::download_block_headers(uint64_t current_height)
 		s.m_pos = 0;
 		s << "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"get_block_header_by_height\",\"params\":{\"height\":" << height << "}}\0";
 
-		JSONRPCRequest::call(m_params->m_host.c_str(), m_params->m_rpcPort, buf,
+		JSONRPCRequest::call(m_params->m_host, m_params->m_rpcPort, buf, m_params->m_rpcLogin,
 			[this, prev_seed_height, height](const char* data, size_t size)
 			{
 				ChainMain block;
@@ -626,13 +665,20 @@ void p2pool::download_block_headers(uint64_t current_height)
 	s.m_pos = 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,
+	JSONRPCRequest::call(m_params->m_host, m_params->m_rpcPort, buf, m_params->m_rpcLogin,
 		[this, start_height, current_height](const char* data, size_t size)
 		{
 			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
@@ -727,7 +773,7 @@ void p2pool::stratum_on_block()
 
 void p2pool::get_info()
 {
-	JSONRPCRequest::call(m_params->m_host.c_str(), m_params->m_rpcPort, "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"get_info\"}",
+	JSONRPCRequest::call(m_params->m_host, m_params->m_rpcPort, "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"get_info\"}", m_params->m_rpcLogin,
 		[this](const char* data, size_t size)
 		{
 			parse_get_info_rpc(data, size);
@@ -736,8 +782,10 @@ void p2pool::get_info()
 		{
 			if (size > 0) {
 				LOGWARN(1, "get_info RPC request failed: error " << log::const_buf(data, size) << ", trying again in 1 second");
-				std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-				get_info();
+				if (!m_stopped) {
+					std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+					get_info();
+				}
 			}
 		});
 }
@@ -781,6 +829,10 @@ void p2pool::load_found_blocks()
 
 void p2pool::parse_get_info_rpc(const char* data, size_t size)
 {
+	if (m_stopped) {
+		return;
+	}
+
 	rapidjson::Document doc;
 	doc.Parse<rapidjson::kParseCommentsFlag | rapidjson::kParseTrailingCommasFlag>(data, size);
 
@@ -833,7 +885,7 @@ void p2pool::parse_get_info_rpc(const char* data, size_t size)
 
 void p2pool::get_version()
 {
-	JSONRPCRequest::call(m_params->m_host.c_str(), m_params->m_rpcPort, "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"get_version\"}",
+	JSONRPCRequest::call(m_params->m_host, m_params->m_rpcPort, "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"get_version\"}", m_params->m_rpcLogin,
 		[this](const char* data, size_t size)
 		{
 			parse_get_version_rpc(data, size);
@@ -842,14 +894,20 @@ void p2pool::get_version()
 		{
 			if (size > 0) {
 				LOGWARN(1, "get_version RPC request failed: error " << log::const_buf(data, size) << ", trying again in 1 second");
-				std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-				get_version();
+				if (!m_stopped) {
+					std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+					get_version();
+				}
 			}
 		});
 }
 
 void p2pool::parse_get_version_rpc(const char* data, size_t size)
 {
+	if (m_stopped) {
+		return;
+	}
+
 	rapidjson::Document doc;
 	doc.Parse<rapidjson::kParseCommentsFlag | rapidjson::kParseTrailingCommasFlag>(data, size);
 
@@ -895,7 +953,9 @@ void p2pool::parse_get_version_rpc(const char* data, size_t size)
 
 void p2pool::get_miner_data()
 {
-	JSONRPCRequest::call(m_params->m_host.c_str(), m_params->m_rpcPort, "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"get_miner_data\"}",
+	m_getMinerDataPending = true;
+
+	JSONRPCRequest::call(m_params->m_host, m_params->m_rpcPort, "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"get_miner_data\"}", m_params->m_rpcLogin,
 		[this](const char* data, size_t size)
 		{
 			parse_get_miner_data_rpc(data, size);
@@ -904,14 +964,31 @@ void p2pool::get_miner_data()
 		{
 			if (size > 0) {
 				LOGWARN(1, "get_miner_data RPC request failed: error " << log::const_buf(data, size) << ", trying again in 1 second");
-				std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-				get_miner_data();
+				if (!m_stopped) {
+					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)
 {
+	if (m_stopped) {
+		return;
+	}
+
+	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);
 
@@ -1296,6 +1373,15 @@ void p2pool::stop_mining()
 		m_miner = nullptr;
 	}
 }
+
+void p2pool::reset_miner()
+{
+	MutexLock lock(m_minerLock);
+
+	if (m_miner) {
+		m_miner->reset_share_counters();
+	}
+}
 #endif
 
 static void on_signal(uv_signal_t* handle, int signum)
@@ -1373,7 +1459,38 @@ static bool init_signals(p2pool* pool)
 
 void p2pool::stop()
 {
-	uv_async_send(&m_stopAsync);
+	// Can be called only once
+	if (m_stopped.exchange(true) == false) {
+		uv_async_send(&m_stopAsync);
+	}
+}
+
+void p2pool::restart_zmq()
+{
+	// If p2pool is stopped, m_restartZMQAsync is most likely already closed
+	if (m_stopped) {
+		return;
+	}
+
+	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()
@@ -1393,6 +1510,11 @@ int p2pool::run()
 		return 1;
 	}
 
+	// Init default loop user data before running it
+	uv_loop_t* loop = uv_default_loop_checked();
+	loop->data = nullptr;
+	GetLoopUserData(loop);
+
 	try {
 		get_info();
 		load_found_blocks();

src/p2pool.h

@@ -91,10 +91,12 @@ public:
 #ifdef WITH_RANDOMX
 	void start_mining(uint32_t threads);
 	void stop_mining();
+	void reset_miner();
 #endif
 
 	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;
@@ -103,10 +105,11 @@ 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;
 
-	bool m_stopped;
+	std::atomic<bool> m_stopped;
 
 	Params* m_params;
 
@@ -197,8 +200,12 @@ private:
 
 	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

src/p2pool_api.cpp

@@ -101,7 +101,7 @@ void p2pool_api::on_stop()
 	uv_close(reinterpret_cast<uv_handle_t*>(&m_dumpToFileAsync), nullptr);
 }
 
-void p2pool_api::dump_to_file_async_internal(const Category& category, const char* filename, DumpFileCallbackBase&& callback)
+void p2pool_api::dump_to_file_async_internal(Category category, const char* filename, DumpFileCallbackBase&& callback)
 {
 	std::vector<char> buf(16384);
 	log::Stream s(buf.data(), buf.size());
@@ -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;

src/p2pool_api.h

@@ -34,10 +34,11 @@ public:
 		LOCAL,
 	};
 
+	// cppcheck-suppress functionConst
 	void on_stop();
 
 	template<typename T>
-	void set(const Category& category, const char* filename, T&& callback) { dump_to_file_async_internal(category, filename, DumpFileCallback<T>(std::move(callback))); }
+	void set(Category category, const char* filename, T&& callback) { dump_to_file_async_internal(category, filename, DumpFileCallback<T>(std::move(callback))); }
 
 private:
 	void create_dir(const std::string& path);
@@ -71,7 +72,7 @@ private:
 		T m_callback;
 	};
 
-	void dump_to_file_async_internal(const Category& category, const char* filename, DumpFileCallbackBase&& callback);
+	void dump_to_file_async_internal(Category category, const char* filename, DumpFileCallbackBase&& callback);
 	void dump_to_file();
 	static void on_fs_open(uv_fs_t* req);
 	static void on_fs_write(uv_fs_t* req);

src/params.cpp

@@ -125,10 +125,20 @@ Params::Params(int argc, char* argv[])
 			ok = true;
 		}
 
+		if (strcmp(argv[i], "--no-autodiff") == 0) {
+			m_autoDiff = false;
+			ok = true;
+		}
+
+		if ((strcmp(argv[i], "--rpc-login") == 0) && (i + 1 < argc)) {
+			m_rpcLogin = argv[++i];
+			ok = true;
+		}
+
 		if (!ok) {
 			fprintf(stderr, "Unknown command line parameter %s\n\n", argv[i]);
 			p2pool_usage();
-			panic();
+			throw std::exception();
 		}
 	}
 

src/params.h

@@ -48,6 +48,8 @@ struct Params
 	uint32_t m_maxIncomingPeers = 1000;
 	uint32_t m_minerThreads = 0;
 	bool m_mini = false;
+	bool m_autoDiff = true;
+	std::string m_rpcLogin;
 };
 
 } // namespace p2pool

src/pool_block_parser.inl

@@ -187,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);
@@ -230,6 +229,15 @@ int PoolBlock::deserialize(const uint8_t* data, size_t size, SideChain& sidechai
 			return __LINE__;
 		}
 
+		// Enforce deterministic tx keys starting from v15
+		if (m_majorVersion >= HARDFORK_VIEW_TAGS_VERSION) {
+			hash pub, sec;
+			get_tx_keys(pub, sec, spend_pub_key, m_prevId);
+			if ((pub != m_txkeyPub) || (sec != m_txkeySec)) {
+				return __LINE__;
+			}
+		}
+
 		READ_BUF(m_parent.h, HASH_SIZE);
 
 		uint64_t num_uncles;

src/pow_hash.cpp

@@ -180,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()) {
@@ -327,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()) {
@@ -372,6 +370,7 @@ bool RandomX_Hasher::calculate(const void* data, size_t size, uint64_t /*height*
 
 RandomX_Hasher_RPC::RandomX_Hasher_RPC(p2pool* pool)
 	: m_pool(pool)
+	, m_loop{}
 	, m_loopThread{}
 {
 	int err = uv_loop_init(&m_loop);
@@ -380,6 +379,9 @@ RandomX_Hasher_RPC::RandomX_Hasher_RPC(p2pool* pool)
 		panic();
 	}
 
+	// Init loop user data before running it
+	GetLoopUserData(&m_loop);
+
 	uv_async_init(&m_loop, &m_shutdownAsync, on_shutdown);
 	uv_async_init(&m_loop, &m_kickTheLoopAsync, nullptr);
 	m_shutdownAsync.data = this;
@@ -428,17 +430,19 @@ bool RandomX_Hasher_RPC::calculate(const void* data_ptr, size_t size, uint64_t h
 	const uint8_t* data = reinterpret_cast<const uint8_t*>(data_ptr);
 	const uint8_t major_version = data[0];
 
-	char buf[log::Stream::BUF_SIZE + 1];
+	char buf[log::Stream::BUF_SIZE + 1] = {};
 	log::Stream s(buf);
 	s << "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"calc_pow\",\"params\":{\"major_version\":" << major_version <<
 		",\"height\":" << height <<
 		",\"block_blob\":\"" << log::hex_buf(data, size) << '"' <<
-		",\"seed_hash\":\"\"}}";
+		",\"seed_hash\":\"\"}}\0";
 
 	volatile int result = 0;
 	volatile bool done = false;
 
-	JSONRPCRequest::call(m_pool->params().m_host.c_str(), m_pool->params().m_rpcPort, buf,
+	const Params& params = m_pool->params();
+
+	JSONRPCRequest::call(params.m_host, params.m_rpcPort, buf, params.m_rpcLogin,
 		[&result, &h](const char* data, size_t size)
 		{
 			rapidjson::Document doc;

src/pow_hash.h

@@ -122,6 +122,8 @@ private:
 		RandomX_Hasher_RPC* server = reinterpret_cast<RandomX_Hasher_RPC*>(async->data);
 		uv_close(reinterpret_cast<uv_handle_t*>(&server->m_shutdownAsync), nullptr);
 		uv_close(reinterpret_cast<uv_handle_t*>(&server->m_kickTheLoopAsync), nullptr);
+
+		delete GetLoopUserData(&server->m_loop, false);
 	}
 };
 

src/side_chain.cpp

@@ -47,11 +47,13 @@
 
 static constexpr char log_category_prefix[] = "SideChain ";
 
-constexpr uint64_t MIN_DIFFICULTY = 100000;
-constexpr size_t UNCLE_BLOCK_DEPTH = 3;
+static constexpr uint64_t MIN_DIFFICULTY = 100000;
+static constexpr size_t UNCLE_BLOCK_DEPTH = 3;
 
 static_assert(1 <= UNCLE_BLOCK_DEPTH && UNCLE_BLOCK_DEPTH <= 10, "Invalid UNCLE_BLOCK_DEPTH");
 
+static constexpr uint64_t MONERO_BLOCK_TIME = 120;
+
 namespace p2pool {
 
 static constexpr uint8_t default_consensus_id[HASH_SIZE] = { 34,175,126,231,181,11,104,146,227,153,218,107,44,108,68,39,178,81,4,212,169,4,142,0,177,110,157,240,68,7,249,24 };
@@ -61,6 +63,7 @@ SideChain::SideChain(p2pool* pool, NetworkType type, const char* pool_name)
 	: m_pool(pool)
 	, m_networkType(type)
 	, m_chainTip{ nullptr }
+	, m_seenWalletsLastPruneTime(0)
 	, m_poolName(pool_name ? pool_name : "default")
 	, m_targetBlockTime(10)
 	, m_minDifficulty(MIN_DIFFICULTY, 0)
@@ -78,12 +81,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");
 
@@ -162,16 +165,18 @@ SideChain::SideChain(p2pool* pool, NetworkType type, const char* pool_name)
 
 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;
@@ -206,7 +211,11 @@ void SideChain::fill_sidechain_data(PoolBlock& block, Wallet* w, const hash& txk
 	}
 
 	for (uint64_t i = 0, n = std::min<uint64_t>(UNCLE_BLOCK_DEPTH, tip->m_sidechainHeight + 1); i < n; ++i) {
-		for (PoolBlock* uncle : m_blocksByHeight[tip->m_sidechainHeight - 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;
@@ -221,16 +230,13 @@ void SideChain::fill_sidechain_data(PoolBlock& block, Wallet* w, const hash& txk
 			bool same_chain = false;
 			do {
 				tmp = tip;
-				while (tmp->m_sidechainHeight > uncle->m_sidechainHeight) {
+				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;
@@ -263,7 +269,7 @@ 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_difficulty = difficulty();
 	block.m_cumulativeDifficulty = tip->m_cumulativeDifficulty + block.m_difficulty;
 
 	for (const hash& uncle_id : block.m_uncles) {
@@ -341,7 +347,7 @@ bool SideChain::get_shares(PoolBlock* tip, std::vector<MinerShare>& shares) cons
 		}
 
 		cur = it->second;
-	} while (block_depth < m_chainWindowSize);
+	} while (true);
 
 	// Combine shares with the same wallet addresses
 	std::sort(shares.begin(), shares.end(), [](const auto& a, const auto& b) { return *a.m_wallet < *b.m_wallet; });
@@ -386,8 +392,6 @@ void SideChain::unsee_block(const PoolBlock& block)
 	m_seenBlocks.erase(block.m_sidechainId);
 }
 
-extern const char* BLOCK_FOUND;
-
 bool SideChain::add_external_block(PoolBlock& block, std::vector<hash>& missing_blocks)
 {
 	if (block.m_difficulty < m_minDifficulty) {
@@ -395,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;
@@ -423,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;
 	}
 
@@ -479,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);
 		}
@@ -520,8 +525,12 @@ void SideChain::add_block(const PoolBlock& block)
 	);
 
 	PoolBlock* new_block = new PoolBlock(block);
+	{
+		MutexLock lock(m_seenWalletsLock);
+		m_seenWallets[new_block->m_minerWallet.spend_public_key()] = new_block->m_localTimestamp;
+	}
 
-	MutexLock lock(m_sidechainLock);
+	WriteLock lock(m_sidechainLock);
 
 	auto result = m_blocksById.insert({ new_block->m_sidechainId, new_block });
 	if (!result.second) {
@@ -551,13 +560,11 @@ void SideChain::add_block(const PoolBlock& 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()) {
@@ -569,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);
 
 	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);
@@ -602,11 +614,11 @@ 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()) {
@@ -630,11 +642,14 @@ bool SideChain::get_outputs_blob(PoolBlock* block, uint64_t total_reward, std::v
 		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 * 39 + 64);
 
@@ -647,12 +662,12 @@ bool SideChain::get_outputs_blob(PoolBlock* block, uint64_t total_reward, std::v
 
 	hash eph_public_key;
 	for (size_t i = 0; i < n; ++i) {
-		writeVarint(m_tmpRewards[i], blob);
+		writeVarint(tmpRewards[i], blob);
 
 		blob.emplace_back(tx_type);
 
 		uint8_t view_tag;
-		if (!m_tmpShares[i].m_wallet->get_eph_public_key(block->m_txkeySec, i, eph_public_key, 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);
@@ -661,24 +676,26 @@ bool SideChain::get_outputs_blob(PoolBlock* block, uint64_t total_reward, std::v
 			blob.emplace_back(view_tag);
 		}
 
-		block->m_outputs.emplace_back(m_tmpRewards[i], eph_public_key, tx_type, 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);
 
 	difficulty_type network_diff = m_pool->miner_data().difficulty;
-	uint64_t network_hashrate = udiv128(network_diff.hi, network_diff.lo, 120, &rem);
+	uint64_t network_hashrate = udiv128(network_diff.hi, network_diff.lo, MONERO_BLOCK_TIME, &rem);
 
 	const PoolBlock* tip = m_chainTip;
 
@@ -736,7 +753,11 @@ void SideChain::print_status()
 	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;
@@ -747,7 +768,7 @@ void SideChain::print_status()
 			}
 		}
 
-		Wallet w = m_pool->params().m_wallet;
+		const Wallet& w = m_pool->params().m_wallet;
 
 		hash eph_public_key;
 		for (size_t i = 0, n = tip->m_outputs.size(); i < n; ++i) {
@@ -811,6 +832,38 @@ void SideChain::print_status()
 	);
 }
 
+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
 {
 	const PoolBlock* tip = m_chainTip;
@@ -821,16 +874,19 @@ uint64_t SideChain::miner_count()
 {
 	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();
@@ -1405,10 +1461,13 @@ void SideChain::update_chain_tip(PoolBlock* block)
 		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() <<
+				", next difficulty = " << log::Gray() << diff << log::NoColor() <<
 				", main chain height = " << log::Gray() << block->m_txinGenHeight);
 
 			block->m_wantBroadcast = true;
@@ -1416,9 +1475,15 @@ void SideChain::update_chain_tip(PoolBlock* block)
 				m_pool->update_block_template_async();
 
 				// Reset stratum share counters when switching to an alternative chain to avoid confusion
-				StratumServer* s = m_pool->stratum_server();
-				if (s && is_alternative) {
-					s->reset_share_counters();
+				if (is_alternative) {
+					StratumServer* s = m_pool->stratum_server();
+					if (s) {
+						s->reset_share_counters();
+					}
+#ifdef WITH_RANDOMX
+					m_pool->reset_miner();
+#endif
+					LOGINFO(0, log::LightCyan() << "SYNCHRONIZED");
 				}
 			}
 			prune_old_blocks();
@@ -1471,7 +1536,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);
@@ -1491,13 +1556,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) {
@@ -1517,6 +1584,7 @@ bool SideChain::is_longer_chain(const PoolBlock* block, const PoolBlock* candida
 			}
 		}
 
+		// cppcheck-suppress knownConditionTrueFalse
 		while (block_ancestor && candidate_ancestor) {
 			if (block_ancestor->m_parent == candidate_ancestor->m_parent) {
 				// If they are really on the same chain, we can just compare cumulative difficulties
@@ -1537,6 +1605,7 @@ bool SideChain::is_longer_chain(const PoolBlock* block, const PoolBlock* candida
 	const PoolBlock* new_chain = candidate;
 
 	uint64_t candidate_mainchain_height = 0;
+	uint64_t candidate_mainchain_min_height = 0;
 	hash mainchain_prev_id;
 
 	for (uint64_t i = 0; (i < m_chainWindowSize) && (old_chain || new_chain); ++i) {
@@ -1546,6 +1615,7 @@ bool SideChain::is_longer_chain(const PoolBlock* block, const PoolBlock* candida
 		}
 
 		if (new_chain) {
+			candidate_mainchain_min_height = candidate_mainchain_min_height ? std::min(candidate_mainchain_min_height, new_chain->m_txinGenHeight) : new_chain->m_txinGenHeight;
 			candidate_total_diff += new_chain->m_difficulty;
 
 			ChainMain data;
@@ -1569,6 +1639,12 @@ bool SideChain::is_longer_chain(const PoolBlock* block, const PoolBlock* candida
 		return false;
 	}
 
+	const uint64_t limit = m_chainWindowSize * 4 * m_targetBlockTime / MONERO_BLOCK_TIME;
+	if (candidate_mainchain_min_height + limit < data.height) {
+		LOGWARN(3, "received a longer alternative chain but it's stale: min height " << candidate_mainchain_min_height << ", must be >= " << (data.height - limit));
+		return false;
+	}
+
 	LOGINFO(3, "received a longer alternative chain: height " <<
 		log::Gray() << block->m_sidechainHeight << log::NoColor() << " -> " <<
 		log::Gray() << candidate->m_sidechainHeight << log::NoColor() << ", cumulative difficulty " <<
@@ -1643,7 +1719,7 @@ void SideChain::update_depths(PoolBlock* block)
 void SideChain::prune_old_blocks()
 {
 	// Leave 2 minutes worth of spare blocks in addition to 2xPPLNS window for lagging nodes which need to sync
-	const uint64_t prune_distance = m_chainWindowSize * 2 + 120 / m_targetBlockTime;
+	const uint64_t prune_distance = m_chainWindowSize * 2 + MONERO_BLOCK_TIME / m_targetBlockTime;
 
 	// Remove old blocks from alternative unconnected chains after long enough time
 	const uint64_t cur_time = seconds_since_epoch();
@@ -1701,11 +1777,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) {
@@ -1783,8 +1859,8 @@ bool SideChain::check_config()
 		return false;
 	}
 
-	if ((m_targetBlockTime < 1) || (m_targetBlockTime > 120)) {
-		LOGERR(1, "block_time is invalid (must be between 1 and 120)");
+	if ((m_targetBlockTime < 1) || (m_targetBlockTime > MONERO_BLOCK_TIME)) {
+		LOGERR(1, "block_time is invalid (must be between 1 and " << MONERO_BLOCK_TIME << ")");
 		return false;
 	}
 

src/side_chain.h

@@ -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,7 +66,7 @@ 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();
@@ -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;
+	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;
+
+	uv_mutex_t m_seenWalletsLock;
 	unordered_map<hash, uint64_t> m_seenWallets;
-	std::vector<MinerShare> m_tmpShares;
-	std::vector<uint64_t> m_tmpRewards;
+	uint64_t m_seenWalletsLastPruneTime;
 
 	uv_mutex_t m_seenBlocksLock;
 	unordered_set<hash> m_seenBlocks;
@@ -121,6 +123,7 @@ private:
 	std::vector<uint8_t> m_consensusId;
 	std::string m_consensusIdDisplayStr;
 
+	mutable uv_rwlock_t m_curDifficultyLock;
 	difficulty_type m_curDifficulty;
 
 	ChainMain m_watchBlock;

src/stratum_server.cpp

@@ -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() / 4000001;
 
 #include "tcp_server.inl"
 
@@ -38,6 +40,7 @@ namespace p2pool {
 StratumServer::StratumServer(p2pool* pool)
 	: TCPServer(StratumClient::allocate)
 	, m_pool(pool)
+	, m_autoDiff(pool->params().m_autoDiff)
 	, m_extraNonce(0)
 	, m_rng(RandomDeviceSeed::instance)
 	, m_cumulativeHashes(0)
@@ -57,7 +60,6 @@ StratumServer::StratumServer(p2pool* pool)
 
 	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);
@@ -68,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);
@@ -84,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) {
@@ -101,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{};
 
@@ -112,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) {
@@ -132,7 +132,7 @@ void StratumServer::on_block(const BlockTemplate& block)
 
 		// Get first 8 bytes of the Merkle root hash from each blob
 		for (size_t i = 0; i < num_connections; ++i) {
-			blob_hashes.emplace_back(*reinterpret_cast<const uint64_t*>(data + i * size + 43));
+			blob_hashes.emplace_back(read_unaligned(reinterpret_cast<const uint64_t*>(data + i * size + 43)));
 		}
 
 		// Find duplicates
@@ -178,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;
@@ -192,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;
 
@@ -219,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,18 +251,21 @@ bool StratumServer::on_login(StratumClient* client, uint32_t id, const char* log
 		LOGINFO(5, "client " << log::Gray() << static_cast<char*>(client->m_addrString) << " set custom difficulty " << client->m_customDiff);
 		target = std::max(target, client->m_customDiff.target());
 	}
+	else if (m_autoDiff) {
+		// Limit autodiff to 4000000 for maximum compatibility
+		target = std::max(target, TARGET_4_BYTES_LIMIT);
+	}
 
 	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;
@@ -267,7 +273,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());
@@ -280,7 +286,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\":\"";
@@ -307,6 +313,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) {
@@ -335,9 +346,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;
@@ -353,33 +362,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) {
+			// "Low diff share" fix: adjust target to the same value as XMRig would use
+			target = std::numeric_limits<uint64_t>::max() / (std::numeric_limits<uint32_t>::max() / (target >> 32));
 		}
 
 		share->m_req.data = share;
@@ -395,9 +404,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;
@@ -419,9 +435,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;
 		});
@@ -441,8 +457,53 @@ void StratumServer::print_status()
 	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;
@@ -495,10 +556,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 uint16_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 uint16_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;
@@ -555,14 +689,35 @@ void StratumServer::on_blobs_ready()
 			if (client->m_customDiff.lo) {
 				target = std::max(target, client->m_customDiff.target());
 			}
+			else if (m_autoDiff) {
+				// Limit autodiff to 4000000 for maximum compatibility
+				target = std::max(target, TARGET_4_BYTES_LIMIT);
+
+				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;
@@ -570,7 +725,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));
 
@@ -579,7 +734,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\":\"";
@@ -597,8 +752,9 @@ 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");
 		}
 	}
 
@@ -638,26 +794,23 @@ void StratumServer::update_hashrate_data(uint64_t hashes, uint64_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;
@@ -698,8 +851,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);
 	}
 
@@ -707,7 +860,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 uint64_t timestamp = seconds_since_epoch();
+		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;
@@ -721,16 +874,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;
@@ -739,9 +887,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";
@@ -777,28 +925,34 @@ 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()
@@ -888,12 +1042,9 @@ bool StratumServer::StratumClient::process_request(char* data, uint32_t /*size*/
 		LOGINFO(6, "incoming keepalive from " << log::Gray() << static_cast<char*>(m_addrString));
 		return true;
 	}
-	else {
-		LOGWARN(4, "client " << static_cast<char*>(m_addrString) << " invalid JSON request (unknown method)");
-		return false;
-	}
 
-	return true;
+	LOGWARN(4, "client " << static_cast<char*>(m_addrString) << " invalid JSON request (unknown method)");
+	return false;
 }
 
 bool StratumServer::StratumClient::process_login(rapidjson::Document& doc, uint32_t id)

src/stratum_server.h

@@ -39,7 +39,7 @@ public:
 	struct StratumClient : public Client
 	{
 		StratumClient();
-		~StratumClient();
+		FORCEINLINE ~StratumClient() {}
 
 		static Client* allocate() { return new StratumClient(); }
 
@@ -52,20 +52,32 @@ public:
 		bool process_submit(rapidjson::Document& doc, uint32_t id);
 
 		uint32_t m_rpcId;
+		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);
@@ -73,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
 	{
@@ -125,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,
@@ -135,7 +150,6 @@ private:
 		} m_result;
 	};
 
-	uv_mutex_t m_submittedSharesPoolLock;
 	std::vector<SubmittedShare*> m_submittedSharesPool;
 
 	struct HashrateData

src/tcp_server.h

@@ -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,19 +79,18 @@ public:
 		Client* m_next;
 
 		uv_tcp_t m_socket;
-		uv_connect_t m_connectRequest;
 
 		bool m_isV6;
 		bool m_isIncoming;
+		bool m_readBufInUse;
+		bool m_isClosing;
+		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 };
+		std::atomic<uint32_t> m_resetCounter;
 	};
 
 	struct WriteBuf
@@ -105,14 +106,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;
@@ -127,6 +128,7 @@ private:
 	static void loop(void* data);
 	static void on_new_connection(uv_stream_t* server, int status);
 	static void on_connection_close(uv_handle_t* handle);
+	static void on_connection_error(uv_handle_t* handle);
 	static void on_connect(uv_connect_t* req, int status);
 	void on_new_client(uv_stream_t* server);
 	void on_new_client_nolock(uv_stream_t* server, Client* client);
@@ -155,8 +157,8 @@ protected:
 	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;
@@ -177,6 +179,8 @@ protected:
 
 		uv_close(reinterpret_cast<uv_handle_t*>(&server->m_dropConnectionsAsync), nullptr);
 		uv_close(reinterpret_cast<uv_handle_t*>(&server->m_shutdownAsync), nullptr);
+
+		delete GetLoopUserData(&server->m_loop, false);
 	}
 };
 

src/tcp_server.inl

@@ -27,9 +27,10 @@ TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::TCPServer(allocate_client_callback all
 	, m_loopThread{}
 	, m_finished(0)
 	, m_listenPort(-1)
+	, m_loop{}
 	, m_loopStopped{false}
-	, m_numConnections(0)
-	, m_numIncomingConnections(0)
+	, m_numConnections{ 0 }
+	, m_numIncomingConnections{ 0 }
 {
 	int err = uv_loop_init(&m_loop);
 	if (err) {
@@ -37,10 +38,21 @@ TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::TCPServer(allocate_client_callback all
 		panic();
 	}
 
-	uv_async_init(&m_loop, &m_dropConnectionsAsync, on_drop_connections);
+	// Init loop user data before running it
+	GetLoopUserData(&m_loop);
+
+	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 +76,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 +335,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);
@@ -360,7 +377,7 @@ bool TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::connect_to_peer_nolock(Client* cl
 	err = uv_tcp_nodelay(&client->m_socket, 1);
 	if (err) {
 		LOGERR(1, "failed to set tcp_nodelay on tcp client handle, error " << uv_err_name(err));
-		m_preallocatedClients.push_back(client);
+		uv_close(reinterpret_cast<uv_handle_t*>(&client->m_socket), on_connection_error);
 		return false;
 	}
 
@@ -368,16 +385,19 @@ bool TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::connect_to_peer_nolock(Client* cl
 
 	if (!m_pendingConnections.insert(client->m_addr).second) {
 		LOGINFO(6, "there is already a pending connection to this IP, not connecting to " << log::Gray() << static_cast<char*>(client->m_addrString));
-		m_preallocatedClients.push_back(client);
+		uv_close(reinterpret_cast<uv_handle_t*>(&client->m_socket), on_connection_error);
 		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);
-		m_preallocatedClients.push_back(client);
+		uv_close(reinterpret_cast<uv_handle_t*>(&client->m_socket), on_connection_error);
 		return false;
 	}
 	else {
@@ -453,7 +473,7 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::shutdown_tcp()
 			}
 			else {
 				LOGWARN(1, "timed out while waiting for event loop to stop");
-				uv_async_init(&m_loop, &asy, nullptr);
+				uv_async_init(&m_loop, &asy, [](uv_async_t* h) { uv_close(reinterpret_cast<uv_handle_t*>(h), nullptr); });
 				uv_stop(&m_loop);
 				uv_async_send(&asy);
 				break;
@@ -488,13 +508,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,6 +556,11 @@ 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");
 	}
 
+	if (client->m_isClosing) {
+		LOGWARN(5, "client " << static_cast<const char*>(client->m_addrString) << " is being disconnected, can't send any more data");
+		return true;
+	}
+
 	WriteBuf* buf = nullptr;
 
 	{
@@ -548,7 +577,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");
@@ -652,6 +681,16 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::on_connection_close(uv_handle_t*
 	}
 }
 
+template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
+void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::on_connection_error(uv_handle_t* handle)
+{
+	Client* client = reinterpret_cast<Client*>(handle->data);
+	TCPServer* server = client->m_owner;
+
+	MutexLock lock(server->m_clientsListLock);
+	server->m_preallocatedClients.push_back(client);
+}
+
 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
 void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::on_connect(uv_connect_t* req, int status)
 {
@@ -677,11 +716,7 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::on_connect(uv_connect_t* req, int
 			LOGWARN(5, "failed to connect to " << static_cast<char*>(client->m_addrString) << ", error " << uv_err_name(status));
 		}
 		server->on_connect_failed(client->m_isV6, client->m_addr, client->m_port);
-		uv_handle_t* h = reinterpret_cast<uv_handle_t*>(&client->m_socket);
-		if (!uv_is_closing(h)) {
-			uv_close(h, nullptr);
-		}
-		server->m_preallocatedClients.push_back(client);
+		uv_close(reinterpret_cast<uv_handle_t*>(&client->m_socket), on_connection_error);
 		return;
 	}
 
@@ -720,14 +755,14 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::on_new_client(uv_stream_t* server
 	err = uv_tcp_nodelay(&client->m_socket, 1);
 	if (err) {
 		LOGERR(1, "failed to set tcp_nodelay on tcp client handle, error " << uv_err_name(err));
-		m_preallocatedClients.push_back(client);
+		uv_close(reinterpret_cast<uv_handle_t*>(&client->m_socket), on_connection_error);
 		return;
 	}
 
 	err = uv_accept(server, reinterpret_cast<uv_stream_t*>(&client->m_socket));
 	if (err) {
 		LOGERR(1, "failed to accept client connection, error " << uv_err_name(err));
-		m_preallocatedClients.push_back(client);
+		uv_close(reinterpret_cast<uv_handle_t*>(&client->m_socket), on_connection_error);
 		return;
 	}
 
@@ -808,10 +843,22 @@ 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_isClosing(false)
+	, m_numRead(0)
+	, m_addr{}
+	, m_port(0)
+	, m_addrString{}
+	, m_resetCounter{ 0 }
 {
-	Client::reset();
-
 	m_readBuf[0] = '\0';
+	m_readBuf[READ_BUF_SIZE - 1] = '\0';
 }
 
 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
@@ -823,14 +870,14 @@ 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_isClosing = 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>
@@ -863,6 +910,11 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::Client::on_read(uv_stream_t* stre
 	Client* pThis = static_cast<Client*>(stream->data);
 	pThis->m_readBufInUse = false;
 
+	if (pThis->m_isClosing) {
+		LOGWARN(5, "client " << static_cast<const char*>(pThis->m_addrString) << " is being disconnected but data received from it, nread = " << nread << ". Ignoring it.");
+		return;
+	}
+
 	if (nread > 0) {
 		if (pThis->m_owner && !pThis->m_owner->m_finished.load()) {
 			if (!pThis->on_read(buf->base, static_cast<uint32_t>(nread))) {
@@ -904,11 +956,13 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::Client::on_write(uv_write_t* req,
 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
 void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::Client::close()
 {
-	if (!m_owner) {
+	if (m_isClosing || !m_owner) {
 		// Already closed
 		return;
 	}
 
+	m_isClosing = true;
+
 	uv_read_stop(reinterpret_cast<uv_stream_t*>(&m_socket));
 
 	uv_tcp_t* s = &m_socket;

src/util.cpp

@@ -32,7 +32,7 @@ namespace p2pool {
 #define STR2(X) STR(X)
 #define STR(X) #X
 
-const char* VERSION = "v2.0 (built"
+const char* VERSION = "v2.2.1 (built"
 #if defined(__clang__)
 	" with clang/" __clang_version__
 #elif defined(__GNUC__)
@@ -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);
@@ -384,4 +384,55 @@ bool resolve_host(std::string& host, bool& is_v6)
 
 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;
+}
+
+UV_LoopUserData* GetLoopUserData(uv_loop_t* loop, bool create)
+{
+	UV_LoopUserData* data = reinterpret_cast<UV_LoopUserData*>(loop->data);
+
+	if (!data && create) {
+		data = new UV_LoopUserData(loop);
+		loop->data = data;
+	}
+
+	return data;
+}
+
 } // namespace p2pool

src/util.h

@@ -136,7 +136,7 @@ const uint8_t* readVarint(const uint8_t* data, const uint8_t* data_end, T& b)
 template<typename T>
 FORCEINLINE T read_unaligned(const T* p)
 {
-	static_assert(std::is_integral<T>::value, "T must be an integer type");
+	static_assert(std::is_trivially_copyable<T>::value, "T must be a trivially copyable type");
 
 	T result;
 	memcpy(&result, p, sizeof(T));
@@ -203,8 +203,28 @@ FORCEINLINE uint64_t seconds_since_epoch()
 	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
 
+void memory_tracking_start();
+void memory_tracking_stop();
+void p2pool_usage();
+
 namespace robin_hood {
 
 template<>

src/uv_util.h

@@ -61,4 +61,116 @@ void uv_mutex_init_checked(uv_mutex_t* mutex);
 void uv_rwlock_init_checked(uv_rwlock_t* lock);
 uv_loop_t* uv_default_loop_checked();
 
+struct UV_LoopCallbackBase
+{
+	virtual ~UV_LoopCallbackBase() {}
+	virtual void operator()() = 0;
+};
+
+template<typename T>
+struct UV_LoopCallback : public UV_LoopCallbackBase
+{
+	explicit FORCEINLINE UV_LoopCallback(T&& cb) : m_cb(std::move(cb)) {}
+	void operator()() override { m_cb(); }
+
+private:
+	UV_LoopCallback& operator=(UV_LoopCallback&&) = delete;
+	T m_cb;
+};
+
+struct UV_LoopUserData
+{
+	uv_loop_t* m_loop;
+	uv_async_t* m_async;
+
+	uv_mutex_t m_callbacksLock;
+	std::vector<UV_LoopCallbackBase*> m_callbacks;
+
+	std::vector<UV_LoopCallbackBase*> m_callbacksToRun;
+
+	explicit UV_LoopUserData(uv_loop_t* loop)
+		: m_loop(loop)
+		, m_async(new uv_async_t{})
+		, m_callbacksLock{}
+		, m_callbacks{}
+		, m_callbacksToRun{}
+	{
+		uv_async_init(m_loop, m_async, async_cb);
+		m_async->data = this;
+
+		uv_mutex_init_checked(&m_callbacksLock);
+
+		m_callbacks.reserve(2);
+		m_callbacksToRun.reserve(2);
+	}
+
+	~UV_LoopUserData()
+	{
+		m_loop->data = nullptr;
+		uv_mutex_destroy(&m_callbacksLock);
+		uv_close(reinterpret_cast<uv_handle_t*>(m_async), [](uv_handle_t* h) { delete reinterpret_cast<uv_async_t*>(h); });
+		for (const UV_LoopCallbackBase* cb : m_callbacks) {
+			delete cb;
+		}
+	}
+
+	static void async_cb(uv_async_t* h)
+	{
+		UV_LoopUserData* data = reinterpret_cast<UV_LoopUserData*>(h->data);
+
+		data->m_callbacksToRun.clear();
+		{
+			MutexLock lock(data->m_callbacksLock);
+			std::swap(data->m_callbacks, data->m_callbacksToRun);
+		}
+
+		for (UV_LoopCallbackBase* cb : data->m_callbacksToRun) {
+			(*cb)();
+			delete cb;
+		}
+	}
+
+	UV_LoopUserData(const UV_LoopUserData&) = delete;
+	UV_LoopUserData& operator=(const UV_LoopUserData&) = delete;
+};
+
+UV_LoopUserData* GetLoopUserData(uv_loop_t* loop, bool create = true);
+
+template<typename T>
+bool CallOnLoop(uv_loop_t* loop, T&& callback)
+{
+	UV_LoopUserData* data = GetLoopUserData(loop, false);
+	if (!data) {
+		return false;
+	}
+
+	UV_LoopCallbackBase* cb = new UV_LoopCallback<T>(std::move(callback));
+	{
+		MutexLock lock(data->m_callbacksLock);
+		data->m_callbacks.push_back(cb);
+	}
+
+	if (uv_async_send(data->m_async) == 0) {
+		return true;
+	}
+
+	// Clean up after uv_async_send error
+	bool found = false;
+	{
+		MutexLock lock(data->m_callbacksLock);
+
+		auto it = std::find(data->m_callbacks.begin(), data->m_callbacks.end(), cb);
+		if (it != data->m_callbacks.end()) {
+			found = true;
+			data->m_callbacks.erase(it);
+		}
+	}
+
+	if (found) {
+		delete cb;
+	}
+
+	return false;
+}
+
 } // namespace p2pool

src/wallet.cpp

@@ -89,7 +89,6 @@ Wallet::Wallet(const Wallet& w)
 	operator=(w);
 }
 
-// cppcheck-suppress operatorEqVarError
 Wallet& Wallet::operator=(const Wallet& w)
 {
 	if (this == &w) {
@@ -119,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) {

src/zmq_reader.cpp

@@ -49,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);
 	}
 }
 
@@ -71,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());
 	}
 }
 
@@ -104,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");
@@ -112,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()) {
@@ -125,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());
 	}
 }
 
@@ -196,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;
 	}

tests/CMakeLists.txt

@@ -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)
@@ -21,48 +16,7 @@ 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
 )
@@ -74,13 +28,10 @@ set(SOURCES
 	src/keccak_tests.cpp
 	src/main.cpp
 	src/pool_block_tests.cpp
-	src/varint_tests.cpp
+	src/util_tests.cpp
 	src/wallet_tests.cpp
 	../external/src/cryptonote/crypto-ops-data.c
 	../external/src/cryptonote/crypto-ops.c
-	../external/src/llhttp/api.c
-	../external/src/llhttp/http.c
-	../external/src/llhttp/llhttp.c
 	../src/block_cache.cpp
 	../src/block_template.cpp
 	../src/console_commands.cpp
@@ -107,10 +58,10 @@ set(SOURCES
 include_directories(../src)
 include_directories(../external/src)
 include_directories(../external/src/cryptonote)
+include_directories(../external/src/curl/include)
 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)
 include_directories(../external/src/rapidjson/include)
 include_directories(../external/src/robin-hood-hashing/src/include)
@@ -118,7 +69,8 @@ include_directories(src)
 include_directories(googletest/googletest/include)
 
 if (WIN32)
-	set(LIBS ${LIBS} ws2_32 iphlpapi userenv psapi)
+	set(LIBS ${LIBS} ws2_32 iphlpapi userenv psapi wldap32)
+	add_definitions(-DCURL_STATICLIB)
 elseif (NOT APPLE)
 	set(LIBS ${LIBS} pthread gss dl)
 endif()
@@ -128,17 +80,28 @@ if (STATIC_LIBS)
 	set(ZMQ_LIBRARY_DEBUG "${CMAKE_SOURCE_DIR}/../external/src/libzmq/build/lib/libzmq.a")
 	set(UV_LIBRARY_DEBUG "${CMAKE_SOURCE_DIR}/../external/src/libuv/build/libuv_a.a")
 	set(UV_LIBRARY "${CMAKE_SOURCE_DIR}/../external/src/libuv/build/libuv_a.a")
+	set(CURL_LIBRARY_DEBUG "${CMAKE_SOURCE_DIR}/../external/src/curl/lib/.libs/libcurl.a")
+	set(CURL_LIBRARY "${CMAKE_SOURCE_DIR}/../external/src/curl/lib/.libs/libcurl.a")
 else()
 	if (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
 		find_library(ZMQ_LIBRARY_DEBUG NAMES libzmq-v142-mt-sgd-4_3_5 PATHS "../external/lib/libzmq/Debug")
 		find_library(ZMQ_LIBRARY NAMES libzmq-v142-mt-s-4_3_5 PATHS "../external/lib/libzmq/Release")
 		find_library(UV_LIBRARY_DEBUG NAMES uv_a PATHS "../external/lib/libuv/Debug")
 		find_library(UV_LIBRARY NAMES uv_a PATHS "../external/lib/libuv/Release")
+		find_library(CURL_LIBRARY_DEBUG NAMES libcurld PATHS "../external/lib/libcurl/Debug")
+		find_library(CURL_LIBRARY NAMES libcurl PATHS "../external/lib/libcurl/Release")
 	elseif (CMAKE_CXX_COMPILER_ID MATCHES GNU OR CMAKE_CXX_COMPILER_ID MATCHES Clang)
 		find_library(ZMQ_LIBRARY_DEBUG NAMES zmq libzmq.a)
 		find_library(ZMQ_LIBRARY NAMES zmq libzmq.a)
 		find_library(UV_LIBRARY_DEBUG NAMES uv libuv.a)
 		find_library(UV_LIBRARY NAMES uv libuv.a)
+		if (WIN32)
+			find_library(CURL_LIBRARY_DEBUG NAMES libcurl.a PATHS "../external/src/curl/lib/.libs" NO_DEFAULT_PATH)
+			find_library(CURL_LIBRARY NAMES libcurl.a PATHS "../external/src/curl/lib/.libs" NO_DEFAULT_PATH)
+		else()
+			find_library(CURL_LIBRARY_DEBUG NAMES curl)
+			find_library(CURL_LIBRARY NAMES curl)
+		endif()
 		find_library(SODIUM_LIBRARY sodium)
 	endif()
 
@@ -158,10 +121,30 @@ if (NORM_LIBRARY)
 	set(LIBS ${LIBS} ${NORM_LIBRARY})
 endif()
 
+if(APPLE)
+	find_library(FOUNDATION_LIB Foundation)
+	find_library(CORE_FOUNDATION_LIB CoreFoundation)
+	find_library(SYSTEM_CONFIGURATION_LIB SystemConfiguration)
+	set(LIBS ${LIBS} ${FOUNDATION_LIB} ${CORE_FOUNDATION_LIB} ${SYSTEM_CONFIGURATION_LIB})
+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})
+target_link_libraries(${CMAKE_PROJECT_NAME} debug ${ZMQ_LIBRARY_DEBUG} debug ${UV_LIBRARY_DEBUG} debug ${CURL_LIBRARY_DEBUG} optimized ${ZMQ_LIBRARY} optimized ${UV_LIBRARY} optimized ${CURL_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}>)
 add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_SOURCE_DIR}/src/mainnet_test2_block.dat" $<TARGET_FILE_DIR:${CMAKE_PROJECT_NAME}>)
 add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_SOURCE_DIR}/src/sidechain_dump.dat" $<TARGET_FILE_DIR:${CMAKE_PROJECT_NAME}>)

tests/cmake/flags.cmake

@@ -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()

tests/src/crypto_tests.cpp

@@ -76,6 +76,16 @@ TEST(crypto, derivation)
 
 				ASSERT_EQ(buf, result_str);
 			}
+			else if (name == "get_tx_keys") {
+				hash wallet_spend_key, monero_block_id, pub_check, sec_check;
+				f >> wallet_spend_key >> monero_block_id >> pub_check >> sec_check;
+
+				hash pub, sec;
+				p2pool::get_tx_keys(pub, sec, wallet_spend_key, monero_block_id);
+
+				ASSERT_EQ(pub, pub_check);
+				ASSERT_EQ(sec, sec_check);
+			}
 		} while (!f.eof());
 	}
 

tests/src/crypto_tests.txt

@@ -612,3 +612,103 @@ derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8
 derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 15 00
 derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 127 a6
 derive_view_tag 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 128 0d
+get_tx_keys 7d213608e7a34afc5a49213d3062f2b9897d8d0b72cce11d308b22fe8879cc00 45f901c7f276eef859f7311794eb72f6f4e960a76e14112ee2dd70e2024f0b8d 77eceaf79ada2418adaa763b5441734140a2f34063abd58067ab83d524de421b 1e7943cffd43aae22631bf761c64a14024a000119cc0c53462b129865b9f8804
+get_tx_keys cb7414d997b129aea90b51c0708a7f0aa9b1daacecf2478316fabff216518090 7dc8479adb9d3bf5fda5a375da1acc970600f28c485dd3b7b9dda56f3a0437e8 4663c0bdb16a87874262006d7645abb6dba7f29cb3bfd56b220a66185b04bde5 a87056a6fa70a6f61a6494e7cb6eb952e7e4f66e6745edd80a30204d877ebd0a
+get_tx_keys ad2d1d5a2d5f8cffe8a916d755cb05bb7a12075084f3fcf7382809796aa324b8 d9baffe842bda66d197de65de34bb33345d3019d67624429c9243aee9101b4c0 282dfc1b0ec4c8e7bd26f842316d9046ab73ea4b7b24a25e15b4897d538af9c8 943d89bdf4656d6133062c18cf00a427c809dd2ab7afcec7587895c3dd53e80e
+get_tx_keys 5fbb50f791424fdfe170f738f776fd835e4337c8bc601f8a94057473da729727 232729b54eb449cb64e2fc48b63a85beffc8b045e9ef02a5a3d5c48a85a9e389 f647c77b3104dfb9f640c5291a9fcbbfa2eda03fd40e5c3ffdd85195540cfc4a eb664101ea49ec81f14a94a0fb2d4614e8a69a7838da5c304781452ae314c80d
+get_tx_keys b6cccd4be208f52ce97bfbc466ab36a85b0b079a145c8088ef7659d1a7392bac a175c9e8049433a6f075efab7b8882398335cf53830721cc1c300f9209e2953b 8086df212aaf26f80d4eb2b9330eab1827a32dfe9db353736cbf01ad4fdb25e4 15940148e7b7ed1dd7917503be2d315509b7b25e6c7df9e67b1033e1017e5005
+get_tx_keys f888ec23a4509080ff7566e664d573068ba418bf2a4be5c1b3e3f058eddab541 3a9fb72955e4387cb0a6900a8332aff577fee7cdf40c82ece12eba1275877e04 0a7a7f8fd15e77ce0d2fbc54e2bb8f4772d83f88144b35a151481f79345a7d23 2ca319bb141cdf1cb63965386d0aa048bf414abc8459674bd5d6ccf068cc7305
+get_tx_keys 680978cd6a075eafe256f324803f93162eb45d1b661684fd186c7bb03fdb24ce cacd708ae9f2128af088be8c67505e6fc779397850edece6cf32a855be488424 b27bd9a14ad888e213ea49f73304e9211c8d5a84413c8ebc7705ce9b0469ee46 3b10110b1943811ee6007fbf4ada868b77897fa38628ba8c5734e32f764f760c
+get_tx_keys b205d5898f0cf7e07da7ab3135356949d98a0e5c8b5b3b5e256a4a18a29210a9 e0aea2ee0cc82bc335f3ff64e002498fa481d9d55253ee87960e674a24436161 ecd1e69fbb7fac82f0ffb678a88a52edf3818275c1f234957e2b9db5caa1730c 7c39af98867a8f930af915657b5aba80fceb554f3b4ca8734a216e03a3f7b60f
+get_tx_keys dc260d51959c71cb8ae2e58225fa0e1d3c7628b25f109ada83dbd2f4a127ece1 ddbeb64ec8ddeca7793307075d98af9868d618d99076ea3139d5aa5eaf7cceb4 f18e457e373e93c531cefadd4a6621385e1afe674b1534a6e94c13a35752d30f 485fa8917be8ef3c329613738cf83fc3bc3518228166405020c6116dd0dfa20c
+get_tx_keys 29c31aa128314e7c7156892d915f1c4ac432f756e0672552659759ded84caeda 274561d25365a1818002f4dcd70d44f3020affd45e7f6c7224caa4849fffffd8 749c54df47e19f8334db6d8c733692f8c58bf9e8627d4704b465d0555b6ba3f4 1b48bc7f6406941ee97152338d23dbd05c31b4921588e1929865c05a3d300f00
+get_tx_keys 965713c69ef2baeabf7f1fbd358342040f3209fc30ac6d453a09a26e05b7ff21 f3c23092f3e1696427b6d0ae4fb444514d77562cb7f791c69ab723a74f9f47bd ba644a27c2751318086ad68970163d5c40807e720e66bfc1de74e4008e4bae20 6848319083aed79f0700d289f2a34ca2fbb36f843e90614caba1cd80ee58ac00
+get_tx_keys 1cfa4a251bc47d7e74bd6c4dd95bf9b58303735ff210aa4e270f21c33c5ef3f8 391673e4676a6fc831762937419aa87451e60ac22c22921d8321a87d6f64c229 4aa5964c3c1b57c4987681c280d156865cac8957d83f0e56aa38df0fd2a37d9a ab7b8335d57ec1a296b8861658267ee92ad896bb188650365fab8a093d95570d
+get_tx_keys ef629fbf9073a4cfa76f145db5d43c99d3ca90584c51fdd6f1eb6be5a4458909 cd5b5d849698e6721f5878d92c168b857f31667c86e9cc73fd242c22d0d6bf24 367d3a1e94e5858fb6d59bcda7fe3db1c10f4792e6c2091286599878b2492ed9 54f4ab64cbf2480247337c065b6efc92317df41ca62ca5e720e0cc4532e81b00
+get_tx_keys c0d24de5d480115d4c47ad95a70dc3f0def037f0fdf6b503b7b3991930919128 9963e81c925425d67057061fe9d42d99b871b34c3b3cc5d4786a8a824b2e3b8c dc1b9a81f61a6270576b983f7d9e0230d12bd79935f23c686bb65936bccc6d85 a66e2b899b74ea804001dbe84939c584b939a333f116bd7d37ef2a8b5eb16d0f
+get_tx_keys 08bfa388334c3d52175af77e1dba5826314e92a6a1598c2fcf152f2f28126f00 29ecd67f1cd2de89e8ddac937984b8b84f1413dd14e960f403881168a9256b59 fd36397c3c681a7234eb633f4d998507aa04812b3ebea211b93fdae4c527490f af3eac01f6b89830f5fd624b3205996b3bab814c7eb28e431c75be097e47d404
+get_tx_keys 3e10a312ea2af6e0d23ca56eab5a62556f165002898d0993af852355434f93f3 018a4a270d0201ac517e45c44cfc10c1ffdb6b81e67232bd92adb8683a99817d c5a440bea7b83325fd0c9c2150cf43f6fd338366262c51ee8a0a4376457467e9 bb15f85e1dc7787a7e8ac45a2fe4c3728c06ef8f6372db9afa13d8ad9f39ce0a
+get_tx_keys 777a5cae8de9cdf45476b4be97592110043140c852af767127ac06423bfe014e 364a78440eaa43ed26a85ce739afefd23695f6b45d1adbabcc672e2b07fe388a ca1d0e18d8bf9c03593dab4e1e6623bd090f92f62058071ab6756819be5d691c fc92965ca30925459d365e24e0c7fb05caab71aaeaeada9184084e994f698004
+get_tx_keys a2b147b42bdf67eff19de7b2ddf113bd529ebd3bfa3c845df286181ccd6f23e6 73b7474bda2200e19b0ab3225a45d28f3aaba2ad0dbbecc9794197c1950a6bf6 981bd41ccbc21a24c34929ee24b5827cad77cd01c69111ce21b234560354163c 8d6718efeb60489a808ac634a911e0059af8e6196e1b26a6109130a46c010302
+get_tx_keys f0cbb06561a873ee4301013c40c0c88797ab3f5f947c812a22f3484a5f3368f0 3870ad939b1b45de04b405584b96d59da4c2a4006fa3883fa5836c8c425b64b2 5449ce32f1a467bb2185adaa8a10f65da7cafd59677346dd43d43c278d1f60a7 9c75e4dce83a72d37035d75158a4ae722a6bee5c0ead55fe14bf03921f4a3c06
+get_tx_keys ec5a0318458911f5fc86b04863a6d5a7b54d38ccf3e652e5efe3c33ffa5702f4 511f4e45e347683c18287b614d54971e3db403acb341934cad471dbc67ab8807 3788bc7513f1614229142de2d733495874040fee9e62900b6cba56129eec3388 941dafa1009fd39c8b4eb467d2233594a056f24697228dcbfc3785899af84701
+get_tx_keys 68d0ad72058a0c1e5ba69646e23b581db24a22cb9facbe073ed86bd37fc7c359 89c8bd261c80ebb19895a8e18b9ed185785896eccce16db63ca52d89b158d198 60e727705e8f18456d0fd85a2f17abe9ccde2279d3db52d31a3c8a8a231035aa 1860ced53351185a3bbe02c85c5f43bbb274981acfc69f6f6bba936b59d72e0a
+get_tx_keys 21ee6d21afa277942f4c928dd50eec19c221522af4c1d1e106b7166547029a22 6a755b46d23a9e9e87f93c57f7ee1e871c8350b4ca0bc5b68fe4d656d28fe3b7 de3ad7466700f2493594890f5f308554f604840ec1761296cff926d91ac2f9c4 b543138115bb436b4b80293104baf4cd26ab076002980a1ec81f0916fc94fd03
+get_tx_keys c9d3d90e061950a95a465cb8e7af536d988bf8e309a9ffc9825f18e49f0a9196 bc4d4d09464f1100060c067dc8db960559ec71ca1eacd609debf1096536981c1 7840bc035a3368795433b8f12ffde37e5141c66286cbbd92a4dc792d9b33fc3d ee4b1e537174092b7921d4b580d2e9ef1a3915c418680eb1c0eb02eb819cdf08
+get_tx_keys 4e58dd10f17e0641a442b60906c2278db341268ac8b3b5b21aa8b025c0987a6e 6a79ed1294720d312ea5e52f1bedf9f5c98631340abf779c922f5c28135fed4c 0aba86c3028654bff6a0592cbc2cc1ad797d7b050063b16c03aadfa446029e04 3a17775b8771abb70bab0884423ef8000189923465ba7886670bedf8f0f23702
+get_tx_keys 8875e0af11aa579262dffa6f97005344fae1f8291820b05f983998a1dbb1bcce 7a5f37f62c730bc70d60dad756ed6c0704174e72774e4a141bc744f7910cf4f9 e308eb4ba46583ab9cf5e753f6c36b64b871da7ad7b48bf669f17f615332ec12 30e7ec75f993e770ffde3d2c9751f45d7ec9d9535a7f7bf74c2eb1a3ec573a04
+get_tx_keys dd9ede5ce885341ddab187bbeb38c3060d5aaa765d0fe4aafc709c98187abed4 2dac082c386c608bd6cc2c87d7d6058d13ef1fd7a9b897cde43ebc59734e216e 2a7eb8aafc247abebdd607cb9fb6af176c5a7ad86e0a4d7772bfb3ddaa943f84 53e661d255b4df07a11495ea31bf9f1a27dd54d5f7d21247f6ff80451fab9a04
+get_tx_keys abfcc9c0db1bd5d50e8bb6283b962c10f1d7b25e60a199d21581fac7701a3a0c cc16f91935b63134799cd9b1c3c56caf8119067e7ec167ac08302ba0e944b3a9 13cf3d6f32c5477023d4efacf5606a91671e2a2949014fc038c6b267a4836e9b 20728833919578bcd0decfb0ddc4f4c4c99fa4a7f1e764d2391bf29ab4971407
+get_tx_keys 8fd65d251c53639be6f754ded1f0ec665ee39de2057a0bb184410b8aa5500cb5 902bd4c455f09713d2a9d8e3ddb35707250003e144cf5623dfda1987e83c0b14 7541d3100d8050094cf919341004a8dcd05fb3c0de0d3b063b216965461d98a6 8072d03d327f2aa94bd399aee45a342488161ee9f4e0e6476b0ba7ed0b20e702
+get_tx_keys f1fa57291ceef8679990b9aa3e9c3d15b2e0ada9032d067c792294680b7167b0 51f271c28f0e9bcfe9979a765fbcc43ccbf1187d6336b36fb2946b7506ce5101 f8d86820511f6ca96e36c2024315b2785c0db0ee32a8369730a2c34930a6da6f 56801dfe40886f1a423eeb0b473875a6f66535202bcb6e2cc3ff7966307a4a09
+get_tx_keys 7c90e526fb6b0031c642b0eeb409378d9695cc5ef528c5630e097efd17beb8a6 66e35a7f40ff2fa0e0ddb1cfb16eac815bbcfb3b6e76ab442ed77a5a35df68f5 c4d748900af239a2bfdb93a8e0a1f15fd9e8dcbae1ab10564accfdfae464eee7 c581bd235ed3c4f5bf2d363bf41094cde7fdb6b62f7982e180687092f4224b08
+get_tx_keys 7eadb928f739e7f9b22082a5bb1233da66705b5085808d8d9ebc0803aadcd6b6 3a2700ff1a5d4ba6585e6f5eae5ecd7f9547580b7021d5171a93dbb80adeaf03 38614ac9e93f77877dfd1a445a4e730406f16ac2a0775e341322492b79f84d08 23a53a6327d989b5cb359eeb65639eb6bf6ee15170f6a0b690fbc570a919d90c
+get_tx_keys 5d8e8ab97b66670a27e4ee92e5126bb2e8a2965ff412000afe07296c82d48669 f55b5d99a8f57ea4c0028c980246b33e084f38591bf285dd5edfa10ad3f3b2ff d6b3c98deb8469df40558654dfe60d0a1aa48caf8778d5c72c3fd6fdbdbc6113 613291ee208e2ff3f9e9da8ba7328a47d2bf97c6850c8341ecdac5cc750f0107
+get_tx_keys c715496080b7e1b1c7289060c9e7885460f8c646f28bb65a6d68b87bd49a9654 c73f7c0ed47be63c79efbef9aabe737be7386ae374b55dd7308c4868f3f670b0 0d3fa599cc8771fd7d534c668d455eab08c3a64dfeb33081ca3e536faf7d2057 82ef1269612172de67b547769190a6da03855cbf8275ed5bff3bf905e76aab09
+get_tx_keys 5c2a8943a2e01dfc18c78b0ec92d08c812e5bb7725973237876297d2282231d4 cac082ac5164c699a13dc1c2c093577679efcfb245d565edc799bedd674a54b2 e441a4039f9e5242863e5fe11e17a471567ae0f9244a38e6707fc1bd35b98e1a ed156061248e5689b5b0219c277d3f6bc8fc014a7dc68449e74c35ae57580c0d
+get_tx_keys d95a3de19720a2efbab2b3d3ce9968ba4911d7e00c0a4e76d670b11cf83f8728 0d7bfaf69378a58892eaf0ccc635e1bf4f072563ed2ffea148781b2f7529cb1f 8a8a1be409942bc52727c4301e3d051c525a5cd36c4d7f9045c8a22ad4b4dae8 e47143db7fd07db864ff070f7881265502c794a53d60e0679ead49a0e49f6f03
+get_tx_keys 70ff3e6d59e894c22c0a93fd9255a609c21085c3ffd9ce1bcba35b3d2dac759e 05ec7e6f94c6a54b17fc1483475db0f4e91ad335e85724dee94a0b4903fcac17 136c92c9d348eea13432172c93147f540244c2daf3a4e4463863abaacfe77704 6ffff5f891f49198eb1538fb957ffbb2a96be2968b0c7fd2c8a0bdec5e48ff0e
+get_tx_keys a839b8447a80b8a6fdc772403f934693163a06abeaf59757602599cea52d0d71 4836e0593eecfdb95b8d8fce89c270c6eeebbcd96f168d1071f6777e3dc5b349 1fe10336a5c1e935a229e990eaef309e1e67e4e461710397cea9291389b06fa4 915b97bc764e1d8221a7f611663af586d1a54d3245ba1f938985924e91eb6902
+get_tx_keys 29642b410315f45037eb07bdc72b1478b1f4cae7f812afbce082cce0f4191307 83133d6c4f6303ce1a33a6ea80c37d0759b270459eb2417b17fbd53df8fb1863 d9068c3f9072cc7f5bf36f0121309ffb159b087ef23411bf7d8c738d535bf9c1 7d1eaf8883dd981a0e135d4e01caf6f8be27197e4305339198c02ce8ca31950d
+get_tx_keys c7296636717cc95d9eba396f76f21607dfb4d6e68e2dd267a9760ea890911f4c d4df7df518ae8a96e1dabd60cd704fed4309e9b33084334f7e0a7bcd6fffcf88 1609b685395137b091c8bd1da6efdaacca1590cd1221b36a808fe6815c7049f8 be6209f2b825308d9226766030facb220ac3831e6025642c5f74194d091a0b02
+get_tx_keys d1437bcf292416ebb37958006fcaa2e2185dd733959b838289311903c4a6ae0a bb4c3c84f8333142cb343e932ad473a54ee36fdaa2167f9319d29f06930f88db 9ae92fab10e1dc17561c6f1d078eb49d3c426cd59ca7db1188522f9802cc44d7 5229b9103403ccaee5ab619d08217c01841b6212140d5aff8704d55b38e10c05
+get_tx_keys 670b89234884058655da41478dc455bf9733873734af3961e3fb9ce3643a29af 3b3b77f60ef257d9af6b368d99f1373dd4584536e6aa78f95e4065e59c43e1ec 1ada3623f6f276a22ebcaaa19f3cba331ff926b6c7a0d2e1a0dacc0c2d5b9dce 1b9aca32ecbc901adebd868773cafa597c01b911349f37e55ef25f2989faf803
+get_tx_keys ae2e56b11b88982cbf8cf53b06ba2e93dcf7eff5fb90a3d9fec270235683b52f bd79423358bf1456726f3d4b52392feab4bb9dc52c6b768e5878f9978978b362 90779129bcf492565880299f43512f9a1c4666cad8050854b947ba782389bdfe d682571e48c8ae2354041d96bf954921f242c778378f5f8de514c8c219bdc103
+get_tx_keys 1482f4d9bfc7fd76e94a7a7a9bf490c5321c523c816dc1d5661d3919da46ed0e e1d4c9b65d0d102c748e638c4008c02acd5f7bcfe765d9fcd0eaa0f9a74957bd 7041007cf6a81ce6700adde666f96b0fa1043121f206db5ae15f9c68356d395d fb401e12bd69128644145bcc3d68ceecd0d8fe89c208f34e893bc99f16e66900
+get_tx_keys 3b89bcf13340eb1e7a95a39247074dfb65fe9902c30284180479d678985ed9f0 1d1b3343461a2a37aaf5c21ca46f3c113cc00dea355514e9b4e96a299fbea830 32ebfb5d5f1ca38e932d141f47554ee55f6ca97ba0af8109054a7286648ac5c1 0f0d337bdd6e62f6c6391c12385017bceadb64bf6dc46b541ca2ef1cf5feac0d
+get_tx_keys fd9819750073cf4187e941dacbcfabc68c524d0fa0207f3a368de738637d0d3b 5cd4351c4f379138967faa094e264589c771088bac027fe21b9af99af9db420b 56c5976a658f381152040a692fdeb7c6b0f72152006e97646783ba724573d8c3 9c9a2074c66f360ca81242914024c7d5095e293478ce4082b176aaa76a36490e
+get_tx_keys 71975b284f84358d08a50e436f439d2fe0e2dd00b673121d172bf21b0024f711 403c2a4d011af5247a36d22d116ff30206ebb91538636ba3fec81ffc4cf4adbe e77eb03578e1e3431f770af237544d17c372bef8224de75cd3309aa43a5b4269 1933c81fd680e4a269edf9626f7407ef2fa7be30432a7e1d5fe614aa257f4808
+get_tx_keys ba6b0b1456eb44421c9a7bb0078354b289e31ba2a5e076dfce8317c728916049 0c5e1ea6ef614c88e1fd24d42b5aa80155eca5d54780c17f9fbeb73bea6f3068 b4d9530a797b18284b39edc7733cbf8b209e63b9836977ca6213ed4e5b2da7ad 88d8c4bd9403085880d12005640ffcc5aceff219283372f11fd024624123d905
+get_tx_keys b785b09e3f5c59e11674b87deaded5a7c391c8c9bd0ba165091c9d187650777d 6f7a6b0125479ab865a4181a8db917e605abb5cd9847eb2f02a8355cb13ddb03 1f36978d1d57aa644a0c258028b99e0b44708b60693840aa6e50ea554e4b0c27 5c85671c2e292fa60c4f9cfa8f96da27f59067fd81f673589de4c24420e62d00
+get_tx_keys c9eaf2162541ff394e8ddcc22ba1cdedbfdf22f3253c97ba52d6d1e303f32f43 1c4533925a74b74802359da6e2b04fb9595c2768ad7a3ec0160c447a14d9e559 66afb680172f358ed91952a41e99f36db723489bd5b1d78da0f0a234859b37ec db9e5c807116f93c807f78e00e7ced552327845d10ded1ea1e4a72846f65790c
+get_tx_keys b7afb73308b29725ab8f1570c66def24768a905a876972c1bb46cf2b4c708e30 cf6e15c3b116b77c2fee274a7077d1a06c5c950993b8e658fcee2c81445666f3 d7ca8109d3ab3fa2565d2c0213fe492adb479aa7bf1fc9d27e83690871107e0f 75f140924ce98b4be06488a6332bea456b6850356854f03277d837981b9c150b
+get_tx_keys 3894d2c95e6ef6e822d256ddb36287f82686cc048a1bcbbad5be009f28384e4b 8dbc226625d37c890ca770023299f8e142e0e6df9ec530e971db11d6a671f41e 2c2e705a66f983e87760d55aa6dd7180cab8864d5e412a434c1646d33d164e00 7d1777ec04e4b8c29037c96d2079bde9ab4d167510fa8875b95a2764a481470c
+get_tx_keys 65fc7c48e0f854d23ec5cb7ffb818ca0149c9f53318fc5d22a96cda6ba971801 f5ce97bc593c4722cc47cec070c13443441905e269ce347f6d36a3d508859f7a fa077f7b050c498e0c7acf57fbed1f7a0f2151ab33e4d748bde6cccea689ca76 37670bdd9f503f2c25be9315af20baaf5d58b336cd1a6e684f6a62334836390d
+get_tx_keys e3cc8ac1113616356388cec01c65a9f44b9c44ab294d5f61920c98bfd2406e5f c4d8db10884c8c4e2ac0adf96c89ea7cae962baeff4219fdaa99bd345114907a 5ecfa6faed8615fcbc834b0be4e576e763a19eba4b7ff9613bc46a1390136fb6 aa1e0e91e146428d01e27653b9d5068534eb914feb52d451cbbc7774e74faa07
+get_tx_keys f89e4e5a305a4a5b4aa9dde28c363a7ba45fe76ff13a349b70b802db46fcd013 c3f02cec4e329d7783eab3b11e335e7c5623d2fe6e7dc17e6b547e34913ae311 597088b23f9fb50b35dbcf3da00398514e7c49c9e170d6b0ec98b8def6ad788f 13ef669bd2b6b806372a6395c5f44a77d9a358ca7ef803ac79448bc0c436c802
+get_tx_keys 25f50275374dc7dfa8fa7849cc9137bf0d11c34814f1fdeba4873fcec7a5230e 3455b25656f286fea6d7574149f51696f37aa21ad216c8ee99dbc73296dda4a1 de599dc29774168c28d548ef1fd34590b696e025ccb2e794decf3e760dda2f70 80d9417d7040df698baf2b1192047fe71509f740ca07c101f427aed21b9d2806
+get_tx_keys 4e45dd055bc760d0db030f1c7e28e614f3e6a021a200e94aeed7beaa1003f531 821b17a52b4a1d03078b877c591d7eacdd176626558fb2715913cfd7003b650e 8d4eb74b299d0f566e1affd47ccba7b9582d824e25392d63691d6ced55e1f0fd 21869058ccbf6b60a1cfe691f431d4d1338b24e4af971986dc7d0e2c5e05a00e
+get_tx_keys 23f3d5dfa97fd1d2a17e98825b1f9beca9458252e576ac38a54403337a3e5f38 d15357b83d4b5b9d4d0d59296e97790947385faf929b5ca1d001abf636e6d0a1 73c529b07adc0d3b3b62304c38a67a50d195f52172b15fb7f8e4d7632f1db32c bf527a36d8ac5c237884082349b63e551294d0eeef1e2dafc57141ace5bf7d04
+get_tx_keys 5734265bca418d627f6db3079a958f197b6e87c94ab48acd65e95bfd8daf1399 fd84921d0e62026d907db32ee91625bbda6cab759cd691e6af79b5bfb4c37ac3 c27080d500da75462d0a4450fc2e635d0f07077eaef3f259f5690f5810c18318 9884c837cfc6e4410e389f4180afc983d97998b375d5ea8701371c53d7b92c00
+get_tx_keys 59f381ac75dfc4fc31e66973657db0b1fd13a247bca04ca43fad62e504d641f8 1c7403b3fb7b27453fa1c980310f82f6e090bb57509ff79069183bacdd4cffa8 5746c9a1acf5e234c1fc0c83d8694267f90079a585a4b96557df8544e5f71eec e6cc4dcb5da8afa62f8d2a222332d574b48d7fd0049abe99406b5fd3fffe1702
+get_tx_keys d3dacd43269424790e0213444585de4ba7930da1e2edcfe51f7affe24ec8fe90 ab5b495738590b75d97b383c7b8a4dbb6f8e8bee797bb92d58fb54e3434ccdd3 ea14af48cdf17863f051cdcc79dc96010573ee0d06183e1741ffe6bd45843a4a cff182102a5477352e09b4359e446546e206972d458ef0ee7f90d0c85e2e6208
+get_tx_keys e8367236c6f9f331cb5f0ec3128d68af1d3579e810dfd0e4b8eac5fada9bb17f c3415a5ed2cdfe0ab7af2966ada2aebf165536a230e478a71c9afa26998f3b71 db01145a152d4d567e6177a1c8e36d7ef0a0d2415d5d43dadea2260da1782b46 82a4206199a9bac70e055ade8217e481041da50c0bf61ae4d54104087e2ff10c
+get_tx_keys 898bacc17b2e3bd33d27b31554a7b0479ffe2cff636a6167ab191b13959ead9c f19083c30751b659e78fbf1cb4b1d9bcd8d9d18dffb763cffa8b919d97274306 1efa8f3cda03a6d415755c695ffe1790195b0b9bb98de1f88f1085d731399da8 b165a1e578f4a44d7abb9727114b440493600a521afb501f6d6fb3f2cdba580b
+get_tx_keys ce3080c09c3cb0902afb640debc717d7924793586ab88e5de59685f5da682492 d887f1ba8c2e90be9fba524fed6907a5906955426d127b513a6fbf3851eafb1c 61d8fa7c7106d2d4bff4976c30aac5a7a2057125ffed6b78f9ef6b46bcf0bf24 3d0a5c6eeefc6c37a1a326c96e502240b47d01cfd9e50d40766cd51965a23806
+get_tx_keys abb68d3fcb6ec538adb3358729f927b607909a284260d2eba98b0e6d14e33aaa 7c49eb9c4eee7f97a2a29e2feb77d884aacc8b04e49a49438d8fe79381203279 b4f0ac34065710dbb427ac06a70c87e3d91af2f12f85468d44d223060c9400ff a97c732baa1c831831941234a41223cba02265f4b19836cb7cad37d8a52b440d
+get_tx_keys 9754ccf2edc3b31223f55cd8bc6b265f5a5ba0a858f17557e0ce0f20deb87ff1 b1a0fd22245b7d482b8fa994478ec995e3686af3eb1a9e7ecf24d18459f4fbcc 5196cccb6d5a3c018d0c69d5f30e392c44d85b282aba67dfea04c1189e469ff9 119541e6d6fa0a48595a59bc919422b93ada2b74626dcc80108d652216755f08
+get_tx_keys a8fa3f5c1a5045f838d05ce5d9dbc77f22fa22375aa8f3e42067ae035ae23fcb e89abd4ebb306f0477945a39f27269c552d26331b9a811725ba97099a40bf260 2b11ae92b8619371dd998931bee58e21dc5515d0f4023a6ccf353708e08fea3c 8174ab01471a7f66167bdce59bddde3569f14b4a68103b82ae937cb36912180d
+get_tx_keys c69a78b58da2d76a252f95adbb48ac6dd6f4b25fd079b5023948415d7635671b f50bb00df3b5b2146433bc6f9ff871bdcecb74e66b5f49a7423bd2536d332fa2 12280bc919532e508c8359a76f991127bb409e07472def74ebee79ad81e1e92c e509c3993ffbeef2048fa64d9e9284992fdae576d37307f40f4d29aebdbeb407
+get_tx_keys a595f6249259bf1ea8edd81ceba69d7b83cf0d40a5333e3eaefe65df59872343 ef870e14f0eaf6d28e66f380c1cac12c2e199c84d97b8faa350d1fba01519e70 71bbf15207539db07915189db1dc8e9afbc7bcdfc2ae61a7e0d1667d0e2f2a16 e96913a55b39bef7ab2539d9cba632302a99337c5bac67e63de0015110fa3d0c
+get_tx_keys 50587d7ab611785dab2d68f51c83450d4b1a1eae2591789e86c30ea9787469ce 3e58cfc6c80e559595212fa29cc9425232ad744619f39742c166ba3110b4b422 b4d1f71056bd36f7ce41a3cf38ad62e48c847114afbdf1b59c0d160889912ba7 716828af952c03c5adc603914eaf28ba49fc8be732588a83914870262cf93407
+get_tx_keys 90797312faa9dcf29fa50923fa98958712899d17839c52134040a42705370fe4 89b7e6b64425bbf46b93c6eeb8b5d739e2f90e9ed606ff0b2fdf75494e4c0522 a24ed39281d69e2e7892fdf90ee4448d1618e685a0cd0a55edf6d4eba7af0443 f5b3ad9fc78524aeeb4f8e8d41b1bd179edc63474c0137cf257fd5943e10c70b
+get_tx_keys 8477be33825b347ef6e48b72bc8e68bda43b7a1d059a3f88dde654516e3094ad 5817c074da79dd5ad6f673adb0290b843e931813f6c52ebbe86aafc48a608779 0793ba243afcb6c6552861ea101f5ed9def4f0e085018ca0a756324c96d58f50 a514b4fdebb7b446774f34e756b1ec7d2260a3dfce5a4a908c76a61db2101209
+get_tx_keys 2dc49ec635d275e581b679b2b6af0afcd8c6a472e3eca8b78013b908a8475786 0b43952461bd4e7f7941d84bf19e2d2f6b040478128061feb362d5875bd77772 adcd427735fe3da32446a0daa57351bd498e9d49bad3f752d7b05725899ee2a6 5feaa761854e1965d15d04483ff16243e134a8d5f991c9043836d17bf1eee70e
+get_tx_keys 5ef78e154a75373babb1c61908ee1494e1116076204e6522cd0e2e098e75f9e0 e1a59e607e5ca134e5914b10ed9c61f8ad18acfe4baf65ac8ad6579ec4e22c8c 64acd6e33c98a81dcae5fb78463dc8eb5d6e7b2e4c6805cc15a15da047984c03 3741d642d87db08141b75f00cacc45068bd7bb4ff000823dbf1561ed9a77540c
+get_tx_keys a722ce6ca6a1867f050b6d9b8daabed06a9e7cc63922d273d6d164b0b75430c9 e72d0f57bcff9728e0aed501e11620459b8e6cd10ac7f9ee8c67745aee01e466 1dea63b3fd781f20feedb428bc83b4b36414bb7e21911fa698b09bc4dc08af15 4c61cbf3c88318a5831f460fa7141519a58f6f0d4ba57125ce0e9777b29d2c0a
+get_tx_keys 521dbf95251fb653465457d9a90e5b51fd2dbf9cc1130806cb19b8ff7ba77700 5a6a753cb91e391a3ceb80842aa940051888c3c0eec8fa4ad7026001d0839b20 a2308ad45e85c2d66e8ff771fb7dbaa9e7113dc4989ab1aa0f8ad52da09d3b5e 99205785b42e2756df10c2191ad2ef93fd02fb387ed28b4cd9afe802f74ca509
+get_tx_keys ddd91ecaa02fbca1583897d425b3ab2afb0165dabc7817a67dfc79e191a092c5 d8171e9ecd6990ccab7b5159f2ff2c817ed1d2e869badffc241d53064686ce70 8e8ba878576f8d95af4c5e51525b8fd6114c334d57a9133a8f0fa44344c4d21d 789f91f6f6709f546a04d87cfbf04104f4b36ac29b961f9bea07f57d9ff70304
+get_tx_keys 636fa68f249f6b516b08539b8adeac1f7c98eb9080176727462315f3c308c24d ceac78f453a090d243cf4f7db75e148c4f47ca832fb358f80831c2baf574e391 a24ed0a2ad541f93f3efcab27172dd4de5c6f2cf227aa4f8aade0c89ca7614e9 5b8f7d3b7de82dec696d790ab7ab0ed6b278a7b8b4a7529b123c8f4de5ff1d06
+get_tx_keys 93124f6e215d53db70823ef7456486aca9c230c9de82305364ae046e67cd413d ed1bdf3b24a2554edfe92112888602680e4d73f09577aa5c142c2cef9f030b18 206268d2812503006f3a8a17c8cad53c8f3b3403a4a327affd59d67e443c73d8 3ed5f8fb02398f365e3c8e7c5d97876e7121069260d31816af0b06fda3759b09
+get_tx_keys 4e391a4f385fc55fd02584135bffe6b65802f57756cdbdd521b1b6fe551b2781 be5d5bebfbfdb4faf81e8e54636292dbf3f257eaafb1eff6ac085775c8008e89 e8eeabeea2c93472122ed6b9c04a16a4a2ee296f9cdfec05010041cd810a38e9 7bec7084624e1e0f08470a8229831762bfb2e8dedc5e13f44b192b52dd5d1600
+get_tx_keys c4c91b14b9218ccf7c463df46c9300e4883b2c5c3446eb13cb23218ea298b64f f92777fe3578b617038b8f1411558af93563252f6a33d32c7d07806aa1315775 35bc3ea7413faf8f8a9fdf3c022d142a4ee706c299d2a5b79800bfb6e57f347f 7893715f9b61fdba063cb5b63c651a2ce597173134df28eda28cb2577fd08308
+get_tx_keys ef6d5edc2354a6c0d83078b80e6a2e88eb6796fd556a199d0182cc510b4f07c0 0f8b9e35dd397f3086e7e33949e9655a29a20035247e1b528ca450328459aacf 3d457bb0fd233b37cf4d994860f0d845c28823bc4befa1e04a023d6b4db6eee8 93432232a41f521477768e37367b1e4dbaad8c227ed44fd6cfdf9e42d3c62107
+get_tx_keys 5b76ef46dade8c0fb949314f0c918b24476bca2973535de9a7e928cc65ee47e7 feb48276d4b0fbfecdc0aeac8aaca7837fa17b25b036c0078e689e5fe00dba7f 49de7826886b329a961d047e601077be5f56ee5ab53f23e96d02b22e665220fe 37d5a15556ec979b95a56c659d42a4dcf58af2c8ebd40d5a3db14e44c5074f0e
+get_tx_keys e99281f2e145f20afe1869416bd084a0c501a8d293160da8a42aba8734e8136f 3d2c5408c26deb78bde28e334efe1aaae2cd4b76a32dcd391a7e51d6dd515902 ebd6e20082bb206de25ac960de53afd1a1a43b310a7e6b17737030042b4b73e6 101ff10911e84a5732d06bd6fd4c1e14deb534ae1d27d5533df27e0c931c5c0f
+get_tx_keys 52185f668c23a8f6b41e7255f1bbfd6372c9a9d251daf710af4eeda4c489fcce cb9f3d8e4734a4fd55f3b78581b9c22e7235087522a590f09ce29fb4621fa360 a3f62830ffa89b6529260723d95d961e12ba7840839b7275766e4b113583b784 c05c085109056b3561255457e42ccab3499b1c219986c535d8a91488e3af5f07
+get_tx_keys 6b4099c14803fe8702ffe3e17c9809152c9f5a2e593a4dc79b0b832143393c72 b043741597bdff40e442ed468ec54e26b82e73bc5c4efa1faeecae9f392c322e 1536fd68a4ee7ad5143e571a8d1b8f3dc545278da72bfbfa158b95d7b886c1e4 7033e41133ec48b7d9bc433a5e5891fc2fa8ae52456d2fb66b92b069c7435404
+get_tx_keys 730d60e2b1ffcbf1993416d239b1962af22fef6487574b062b9993408842fa99 a0c7a51e991381d29a2ea8f946e13ecf49bee22c6f21ecb352fd962bb35073ed e2de50d99828c98d2e26c752e243a681fd047ce7a704de6a4a007fcf7f914259 dff7e6a797d4a32df274445d3a9417d6efb9f9c2a5a020775fde0ca5d7d93a0a
+get_tx_keys f0c14c8737342db317dc26df3d89671fd7b73aec00c338cdaee4d907d451905a 4eca743396934cd3ecef0fb3d494468e9f7dc80ef0e9a2f384adad259bb3acec 65dea1840862814efd757e6119f417ba776749540e2f7c438c2b70b6c22b5f3f 51d03a1ae2176c8187fa08bba68575e08b93be82dc12ef4f8761b1d3f778e20c
+get_tx_keys b0f032801c81bcf837a9b2e23bcb2f8e2d4df7f95dcfc161ee60bd5a80c34044 f9c11bd430d27bbf71c4955f6d9e46fa53824cd8d5fc142f0fcbaf49b59b8c31 c6f2e32aa5b5ccb144ae42b1761fb870c7bf98b23e20c4520aea8f0dea714fcd 38e28ce5bbea9e8b807d9c74fe0aff7650c2989ccea55b6ba4fbb93ef5c36b07
+get_tx_keys 593bc6d239523d218dfe55504869ebd7ad29b13d30a5a11de26fe58cb8855479 81db8d71a3c321f15f0ce0dd74df0e1971c2b59c6ad6f43a708a25fd854fd00d a3274fa896106c3682cd1f4a8c7c156083c4ed56b4b8bfd09232928a9a78b82a 85585745f14815c7d87c7da08e8998f497f1e861ef729d7d86a0096408d0270f
+get_tx_keys 3619f547023deb2f111165c3bf3f36c1ed69e32b7f4b4fa97076397e0c489319 8933bb951525735f4bd1e7ce453e92d8b54eb74e3789acb4f1e5c88de8660d7c 0fdde96aeba654199d217f08abaf5013fb18e3907b9bc70c03644399e70e6619 5820bb2cf8acdda1275c4dd9c0ac43d613f58ffa7bd7af9d1bf3269c5fed7b09
+get_tx_keys 3bc0bf75e710c37bf4d3128a84cd855e17ce607e4d8cf62c6095d7797ebe6f91 267e2b0df6439152aaed566eedbd0e6fb193707163b767d9df00cbf33f3bf464 3a13e6e8b664de002234f4b3d134002caa5dfa6ba169c0130833a920eeac5e69 7be8e0b24f4a3e7956f398d7e0964a96870e6f00063def899a66939946d76a0b
+get_tx_keys 346fb50aed359a896393d1914a5ddcdd450b3dcd53490071ad1e1206cea38a7e ebc9697ca939787c56e90df95cc1c72db7ed2249d3006c6fed8d628798bf1287 8e14f8f953f0744eda2dd5c568aaab445d7e425be9280ea00eec22e779f1ec09 1696e2b080a1073e937ba10bfce9b116791a2b494183b49c13e21dc5362b5107
+get_tx_keys afc4721f844d9fbf35c47d8f97a769b4d869ccde5ed4905f01e4378c4fcc1050 47ede7e9a14b9e26589998d3fb5de17d40054a2b4d5ee803fa9447151f2abf3d 9fac272f57d3c2367cd95bf4eadad844ab3448cac9f4aa11c5df798881075740 2288136c0e00de4d6152fd23a898f935a4fdec6d1d86854aa0c6fdaa66930709
+get_tx_keys 13f49086eee9b4caed107ec87b561e676d4e6c47fa290fa93849bb1b6972d5fa 411367507f9e482dd2ef0797f2b9602885e16526657b39a4552288a6a924cf56 2f1b225080e69488c9afc374754198b4289659027ffb9edcbe18bbf173573ee0 8760812d9d5cc0eb8ce95f0617739223061b07c6f51521eaa8433a0fdf45c20f
+get_tx_keys 3b25ddf310280d8bd911c98c60ffaf93f01784c941212fbe6ac1e5744479801d 0aa509792c094d94070ec6702541523c7f8b3ab69724836c0f4a23d8cb9918cc ca7051e43bfbedc5ea4dcad7581875838bfa2daac6f26691d5ed85fbbb3d5d20 dac3e60cb78e7a33447a8ff59a96097d7aa23b25020c0ec98f9f72b3880e3b0a
+get_tx_keys 3a189530ed141bc0e055dc7fbdb01ed27f365d0d16a6ff49553e0211d02651f5 87a4139f5703b29e9253d7151f853b7c5b5c654efda2328411fa32c45b0de96f 1705292b3e9f6fc28ff7cfb338fe7908352709bb63b18e183e838cbf2b470d94 d9eeb6b002c4a25a0b3ba6b9a8457fe9d6990fd9d12cdb1424aba9e3801b2c0d
+get_tx_keys 87f91cbbb4409ecb9e8fb7e4777ca92a4ffcd001e6254d5e39d9f05dce677775 988e2aca31f8e292783c8a698e8b71d3f239fd7c94c05bee96a91f9f458ffda4 90ea8e86cc8959fe5c2f50874551032432fc1cc5fc1c5af40bfec71ee7b6cc76 83b3c2e6f87def56949e1beac36d467a91a2d8b6ffbed393bd45f3ac5867b10d
+get_tx_keys e3542c51b61a3d9eb0773335582a8d6dd24c32413a969d5cb9629ddc77a8e49f c7d7ce6d43ec125071b8c5115f010164b89a33eb4aedf4ca31700a975177c617 df5476bf0fa51deeda6e0ac0c48e0fd64e8d3abf9b0e60572c757afebe2bb71a ef2c6830783a181234a503da9308a158c47f97d0da0c5b612a8ea67b4ec3e708
+get_tx_keys dfffcad8d938c771497214aad51e5f8e307b9cfb5bf7f37cfcf73ae19344aa50 1e117af98c71f5443715d961d0d0d4436e2451be401db8ad40e2a66de65dbc0d a165ebbedf785963098865897d62821c72e0d89afbeffad3b54012745be4cd78 3ae76a2dfd4acc0e7bb7cfbdd516e269a2294005b1bc877f2feeaf52ac2aa70c
+get_tx_keys cabfa01f1fed98842b2a30a547d34c5be1fbaa1c5753d83519b59f79239956c7 0faf698d4917c7edccb1dc401e9b33d775d6d699eff51ff6a29ca5da2d9df969 4021cad4e8a45714bc893475487d8b07c868bbddd7086f5befaadc92fca9e892 2417b7887c6f287775d736d0fbe1544d53e2ed33adc948ceca8c16f0b14b2d05

tests/src/difficulty_type_tests.cpp

@@ -16,6 +16,8 @@
  */
 
 #include "common.h"
+#include "json_parsers.h"
+#include <rapidjson/document.h>
 #include "gtest/gtest.h"
 #include <random>
 #include <sstream>
@@ -146,6 +148,33 @@ TEST(difficulty_type, input_output)
 	test_value(std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::max(), "340282366920938463463374607431768211455");
 }
 
+TEST(difficulty_type, json_parser)
+{
+	auto test_value = [](uint64_t lo, uint64_t hi, const char* s) {
+		difficulty_type diff{ lo, hi };
+		std::stringstream ss;
+		ss << "{\"diff\":\"" << s << "\"}";
+
+		using namespace rapidjson;
+		Document doc;
+		doc.Parse(ss.str().c_str());
+
+		difficulty_type diff2;
+		parseValue(doc, "diff", diff2);
+		ASSERT_EQ(diff2, diff);
+	};
+
+	test_value(0, 0, "0x0");
+	test_value(1, 0, "0x1");
+	test_value(0x123456789abcdefull, 0, "0x123456789abcdef");
+	test_value(0x123456789abcdefull, 0, "0x123456789ABCDEF");
+	test_value(std::numeric_limits<uint64_t>::max(), 0, "0xffffffffffffffff");
+	test_value(0, 1, "0x10000000000000000");
+	test_value(1, 1, "0x10000000000000001");
+	test_value(0x1122334455667788ull, 0x99aabbccddeeff00ull, "0x99aabbccddeeff001122334455667788");
+	test_value(std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::max(), "0xffffffffffffffffffffffffffffffff");
+}
+
 TEST(difficulty_type, check_pow)
 {
 	hash h;

tests/src/hash_tests.cpp

@@ -16,6 +16,8 @@
  */
 
 #include "common.h"
+#include "json_parsers.h"
+#include <rapidjson/document.h>
 #include "gtest/gtest.h"
 #include <random>
 #include <sstream>
@@ -55,7 +57,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);
@@ -90,4 +92,36 @@ TEST(hash, input_output)
 	check(h, "fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e0");
 }
 
+TEST(hash, json_parser)
+{
+	auto check = [](const hash& h, const char* s) {
+		std::stringstream ss;
+		ss << "{\"hash\":\"" << s << "\"}";
+
+		using namespace rapidjson;
+		Document doc;
+		doc.Parse(ss.str().c_str());
+
+		hash h2;
+		parseValue(doc, "hash", h2);
+		ASSERT_EQ(h2, h);
+	};
+
+	hash h;
+	check(h, "0000000000000000000000000000000000000000000000000000000000000000");
+
+	memset(h.h, -1, HASH_SIZE);
+	check(h, "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+
+	for (uint8_t i = 0; i < HASH_SIZE; ++i) {
+		h.h[i] = i;
+	}
+	check(h, "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f");
+
+	for (uint8_t i = 0; i < HASH_SIZE; ++i) {
+		h.h[i] = 0xff - i;
+	}
+	check(h, "fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0efeeedecebeae9e8e7e6e5e4e3e2e1e0");
+}
+
 }

tests/src/util_tests.cpp

@@ -21,7 +21,7 @@
 
 namespace p2pool {
 
-TEST(varint, read_write)
+TEST(util, varint)
 {
 	std::vector<uint8_t> v;
 	v.reserve(16);
@@ -82,4 +82,12 @@ TEST(varint, read_write)
 	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);
+	}
+}
+
 }