p2pool v1.8

TCPServer: fixed uninitialized variables
TCPServer: reduced memory usage
2022-02-27 19:56:47 +01:00 · 2022-02-25 15:31:35 +01:00 · 2022-02-23 17:07:50 +01:00 · 2022-02-22 11:06:12 +01:00 · 2022-02-22 00:38:08 +01:00 · 2022-02-21 19:59:57 +01:00
50 changed files with 1213 additions and 300 deletions
@@ -159,13 +159,29 @@ jobs:
        submodules: recursive

    - name: Install dependencies
-      run: HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake libuv zmq libpgm
+      run: HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake
+
+    - name: Build libuv
+      run: |
+        cd external/src/libuv
+        mkdir build
+        cd build
+        cmake ..
+        make -j3
+
+    - name: Build libzmq
+      run: |
+        cd external/src/libzmq
+        mkdir build
+        cd build
+        cmake .. -DWITH_TLS=OFF -DWITH_LIBSODIUM=OFF
+        make -j3

    - name: Build p2pool
      run: |
        mkdir build
        cd build
-        cmake ..
+        cmake .. -DSTATIC_BINARY=ON
        make -j3

    - name: Build tests
@@ -173,7 +189,7 @@ jobs:
        cd tests
        mkdir build
        cd build
-        cmake ..
+        cmake .. -DSTATIC_LIBS=ON
        make -j3

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

    - name: Run cppcheck
      run: |
@@ -19,6 +19,7 @@ on:
 env:
  # Path to the CMake build directory.
  build: '${{ github.workspace }}/build'
+  config: 'Release'

 jobs:
  analyze:
@@ -32,18 +33,19 @@ jobs:
          submodules: true

      - name: Configure CMake
-        run: cmake -B ${{ env.build }}
+        run: cmake -B ${{ env.build }} -DCMAKE_BUILD_TYPE=${{ env.config }}

      # Build is not required unless generated source files are used
      # - name: Build CMake
      #   run: cmake --build ${{ env.build }}

      - name: Initialize MSVC Code Analysis
-        uses: microsoft/msvc-code-analysis-action@04825f6d9e00f87422d6bf04e1a38b1f3ed60d99
+        uses: microsoft/msvc-code-analysis-action@47ecec99bf7ce0399ed85cbb5012b6f24eab5959
        # Provide a unique ID to access the sarif output path
        id: run-analysis
        with:
          cmakeBuildDirectory: ${{ env.build }}
+          buildConfiguration: ${{ env.config }}
          # Ruleset file that will determine what checks will be run
          ruleset: NativeRecommendedRules.ruleset

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 2.8.12)
 project(p2pool)

-option(STATIC_LINUX_BINARY "Build static Linux binary" OFF)
+option(STATIC_BINARY "Build static binary" OFF)

 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake")

@@ -27,6 +27,7 @@ set(HEADERS
 	src/keccak.h
 	src/log.h
 	src/mempool.h
+	src/miner.h
 	src/p2p_server.h
 	src/p2pool.h
 	src/p2pool_api.h
@@ -60,6 +61,7 @@ set(SOURCES
 	src/main.cpp
 	src/memory_leak_debug.cpp
 	src/mempool.cpp
+	src/miner.cpp
 	src/p2p_server.cpp
 	src/p2pool.cpp
 	src/p2pool_api.cpp
@@ -122,15 +124,18 @@ add_definitions(/DZMQ_STATIC)

 add_executable(${CMAKE_PROJECT_NAME} ${HEADERS} ${SOURCES})

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

+	set(STATIC_LIBS randomx)
+	if (NOT APPLE)
+		set(STATIC_LIBS ${STATIC_LIBS} pthread dl)
+	endif()
+
 	target_link_libraries(${CMAKE_PROJECT_NAME}
-		"${CMAKE_SOURCE_DIR}/external/src/libsodium/src/libsodium/.libs/libsodium.a"
 		"${CMAKE_SOURCE_DIR}/external/src/libzmq/build/lib/libzmq.a"
 		"${CMAKE_SOURCE_DIR}/external/src/libuv/build/libuv_a.a"
-		randomx
-		pthread
+		${STATIC_LIBS}
 	)
 else()
 	target_link_libraries(${CMAKE_PROJECT_NAME} debug ${ZMQ_LIBRARY_DEBUG} debug ${UV_LIBRARY_DEBUG} optimized ${ZMQ_LIBRARY} optimized ${UV_LIBRARY} ${LIBS})
@@ -4,15 +4,27 @@ Decentralized pool for Monero mining.

 Pool status and monitoring pages can be found at https://p2pool.io/ and https://p2pool.observer/

-### Build status
+### Build Status

 ![C/C++ CI](https://github.com/SChernykh/p2pool/actions/workflows/c-cpp.yml/badge.svg)  
 ![CodeQL](https://github.com/SChernykh/p2pool/actions/workflows/codeql-analysis.yml/badge.svg)  
+![msvc-analysis](https://github.com/SChernykh/p2pool/actions/workflows/msvc-analysis.yml/badge.svg)  
 ![cppcheck](https://github.com/SChernykh/p2pool/actions/workflows/cppcheck.yml/badge.svg)  
 <a href="https://scan.coverity.com/projects/schernykh-p2pool">
  <img alt="Coverity Scan Build Status"
       src="https://scan.coverity.com/projects/23659/badge.svg"/>
 </a>
+# Contents
+- [Pool mining vs Solo mining vs P2Pool mining](#pool-mining-vs-solo-mining-vs-p2pool-mining)
+- [Features](#features)
+- [How PPLNS works in P2Pool](#how-pplns-works-in-p2pool)
+- [Default P2Pool parameters](#default-p2pool-parameters)
+- [How to mine on P2Pool](#how-to-mine-on-p2pool)
+  - [General Considerations](#general-considerations)
+  - [GNU/Linux](#gnulinux)
+  - [Windows](#windows)
+- [Build instructions](#build-instructions)
+- [Donations](#donations)

 ## Pool mining vs Solo mining vs P2Pool mining

@@ -22,7 +34,7 @@ Here's the comparison table of the different ways of mining. While pool mining i
 |-|-|-|-|-|-|-|-|
 |Centralized pool|Regular|0-3%|0.001-0.01 XMR|Yes|Less stable due to pool server outages|Pool admin controls your mined funds, what you mine and can execute network attacks|Only miner software is required
 |Solo|Rare|0%|0.6 XMR or more|No|As stable as your Monero node|100% under your control|Monero node + optional miner
-|**P2Pool**|Regular|0%|less than 0.0004 XMR|No|As stable as your Monero node|100% under your control|Monero node + P2Pool node + miner
+|**P2Pool**|Regular|0%|~0.0003 XMR|No|As stable as your Monero node|100% under your control|Monero node + P2Pool node + miner

 ## Features

@@ -32,7 +44,7 @@ Here's the comparison table of the different ways of mining. While pool mining i
 * PPLNS payout scheme
 * **0% fee**
 * **0 XMR payout fee**
-* **Less than 0.0004 XMR minimal payout**
+* **~0.0003 XMR minimal payout**
 * Fast block times, down to 1 second
 * Uncle blocks are supported to avoid orphans - all your shares will be accounted for!
 * Configurable PPLNS window size and block time
@@ -49,13 +61,134 @@ First you need to find a pool share. This share will stay in PPLNS window for 21

 * Block time: 10 seconds
 * PPLNS window: 2160 blocks (6 hours)
-* Minimum payout = Monero block reward/2160, currently ~0.0004 XMR
+* Minimum payout = Monero block reward/2160, ~0.0003 XMR
+
+## How to mine on P2Pool
+
+### General Considerations
+
+- In order to mine on P2Pool, a synced Monero node using monerod v0.17.3.0 or newer is required. If you do not currently have one configured, you can find instructions to do so [here](https://sethforprivacy.com/guides/run-a-monero-node-advanced/).
+- It is highly recommended that you create a separate restricted user account for mining. P2Pool is still relatively new and may still have serious bugs/vulnerabilities. 
+- You have to use a primary wallet address for mining. Subaddresses and integrated addresses are not supported, just like with monerod solo mining.
+- Starting from P2Pool v1.7, you can add the `--mini` parameter to your P2Pool command to connect to the **p2pool-mini** sidechain. Note that it will also change the default p2p port from 37889 to 37888.
+- Check that ports 18080 (Monero p2p port) and 37889/37888 (P2Pool/P2Pool mini p2p port) are open in your firewall to ensure better connectivity. If you're mining from a computer behind NAT (like a router) you could consider forwarding the ports to your local machine.
+- You can connect multiple miners to the same P2Pool node. The more the better!
+- The below steps assume that you run everything on the same machine. If it's not the case, change `127.0.0.1` to appropriate IP addresses for your setup. 
+- It is highly recommended to create a new mainnet wallet for P2Pool mining because **wallet addresses are public on P2Pool**.
+
+**Wallet software compatible with P2Pool payouts**
+- [Official Monero CLI and GUI v0.17.2.3 and newer](https://www.getmonero.org/downloads/)
+- [Monerujo v2.1.0 "Vertant" and newer](https://www.monerujo.io/)
+- [Cake Wallet v4.2.7 and newer](https://cakewallet.com/)
+- [Monero.com by Cake Wallet](https://monero.com/)
+- [Feather Wallet v1.0.0 and newer](https://featherwallet.org/)
+- [MyMonero](https://mymonero.com/)
+
+### GNU/Linux
+
+1. Download the latest P2Pool binaries [here](https://github.com/SChernykh/p2pool/releases/latest).
+   -  Alternatively, grab the latest source code for P2Pool and [build it](#build-instructions).
+2. Download the latest XMRig (linux-static-x64) binary [here](https://github.com/xmrig/xmrig/releases/latest).
+3. Prepare enough huge pages (required for each instance of monerod/P2Pool/XMRig): 
+```
+sudo sysctl vm.nr_hugepages=3072
+```
+4. Check that ports 18080 (Monero p2p port) and 37889/37888 (P2Pool/P2Pool mini p2p port) are open in your local firewall to ensure better connectivity. 
+5. Start `monerod` with the following command/options: 
+```
+./monerod --zmq-pub tcp://127.0.0.1:18083 --disable-dns-checkpoints --enable-dns-blocklist
+``` 
+**Note:** The `--zmq-pub` option is required for P2Pool to work properly.
+
+6. Start P2Pool with the following command/options:
+```
+./p2pool --host 127.0.0.1 --wallet YOUR_WALLET_ADDRESS
+```
+7. Wait until the initial P2Pool sync is finished (shouldn't take more than 5-10 minutes).
+8. Start XMRig with the following command/options:
+ ```
+ ./xmrig -o 127.0.0.1:3333
+ ```
+   - Note that you don't need to specify your wallet address for XMRig. **Wallet addresses set in XMRig config will be ignored!** 
+   - To set a custom fixed difficulty for your miner (for example, 10000), instead start XMRig with the following options: 
+   ```
+   ./xmrig -u x+10000 -o 127.0.0.1:3333
+   ```
+9. XMRig should connect and start mining!
+
+**Additional Information:** 
+- For a more in-depth beginner friendly walk-through with the option of using Docker, please see SethForPrivacy's guide at: https://sethforprivacy.com/guides/run-a-p2pool-node/
+- You can check the p2pool.log for any warnings or errors using the following command: 
+```
+grep -E 'WARNING|ERROR' p2pool.log
+```
+- P2Pool has verbose logging by default, you can reduce it by using "loglevel N" command where N is between 0 and 6. Default loglevel is 3.
+  - You can use `logrotate` with a config like this to control logfile growth:
+ ```
+<path-to-logfile>
+{
+rotate 7
+daily
+missingok
+delaycompress
+nocreate
+}
+ ```
+
+### Windows 
+
+**Note:** *Windows SmartScreen may block incoming connections by files that are "Downloaded from the Internet". You can allow 'p2pool.exe' and 'monerod.exe' by double-clicking them, clicking "More Info", then click "Run Anyway" and then closing them immediately so you can run them from the command line. Advanced users can use the PowerShell cmdlet `Unblock-File` to remove this flag.*
+
+1. Download the latest P2Pool binaries [here](https://github.com/SChernykh/p2pool/releases/latest).
+    - Alternatively, grab the latest source code for P2Pool and [build it](#build-instructions).
+2. Download the latest XMRig binary [here](https://github.com/xmrig/xmrig/releases/latest).
+3. Expand the P2Pool binaries into an appropriate location (`%USERPROFILE%/bin` or `C:/bin/` are good options)
+4. Expand XMRig binary into an appropriate location (the same folder as P2Pool is fine). 
+5. Prepare huge pages to work properly (each instance of monerod/P2Pool/XMRig needs them): 
+   - On Windows 10 or above, run XMRig at least once as Administrator (right-click Run As Administrator)
+   - On earlier versions of Windows, you'll need to run XMRig as Administrator at least once per login.
+6. Open a command prompt and navigate to the folder where you extracted P2Pool.
+
+**Note:** *When running the below commands, Windows Firewall may prompt to allow connections, click "Allow" if prompted.*
+
+7. Start `monerod` with the following command/options: 
+```
+.\Monero\monerod.exe --zmq-pub tcp://127.0.0.1:18083 --disable-dns-checkpoints --enable-dns-blocklist
+```
+**Note:** The `--zmq-pub` option is required for P2Pool to work properly.
+8. Start P2Pool with the following command/options:
+```
+.\p2pool.exe --host 127.0.0.1 --wallet YOUR_WALLET_ADDRESS
+```
+9. Wait until the initial P2Pool sync is finished (shouldn't take more than 5-10 minutes).
+10. Start XMRig with the following command/options:
+```
+.\xmrig.exe -o 127.0.0.1:3333
+```
+   - Note that you don't need to specify your wallet address for XMRig. **Wallet addresses set in XMRig config will be ignored!** 
+   - To set a custom fixed difficulty for your miner (for example, 10000), instead start XMRig with the following options: 
+     ```
+     xmrig.exe -u x+10000 -o 127.0.0.1:3333
+     ```
+11. XMRig should connect and start mining!
+12. *(Optional but highly recommended)* You can create a Quickstart by creating a batch (.bat) file with the following contents and placing it in your P2Pool directory along with `xmrig.exe`.
+```
+@ECHO OFF
+start cmd /k %~dp0\Monero\monerod.exe --zmq-pub tcp://127.0.0.1:18083 --disable-dns-checkpoints --enable-dns-blocklist
+ECHO Wait until the Monero daemon shows fully synced before continuing. This can take some time. Type 'status' in other window to check progress.
+PAUSE
+start cmd /k %~dp0\p2pool.exe --wallet YOUR_WALLET_ADDRESS
+ECHO Wait until the daemon shows fully synced before continuing. This can take some time.
+PAUSE
+%~dp0\xmrig.exe -u x+30000 -o 127.0.0.1
+```

 ## Build instructions
+Please see the relevant instructions for your platform:

 ### Ubuntu 20.04

-p2pool binary:
+Run the following commands to install the necessary prerequisites, clone this repo, and build P2Pool locally on Ubuntu 20.04:  
 ```
 sudo apt update && sudo apt install git build-essential cmake libuv1-dev libzmq3-dev libsodium-dev libpgm-dev libnorm-dev libgss-dev
 git clone --recursive https://github.com/SChernykh/p2pool
@@ -65,23 +198,13 @@ cmake ..
 make -j$(nproc)
 ```

-monerod binary compatible with p2pool:
-```
-sudo apt update && sudo apt install git build-essential cmake pkg-config libssl-dev libzmq3-dev libunbound-dev libsodium-dev libunwind8-dev liblzma-dev libreadline6-dev libldns-dev libexpat1-dev libpgm-dev qttools5-dev-tools libhidapi-dev libusb-1.0-0-dev libprotobuf-dev protobuf-compiler libudev-dev libboost-chrono-dev libboost-date-time-dev libboost-filesystem-dev libboost-locale-dev libboost-program-options-dev libboost-regex-dev libboost-serialization-dev libboost-system-dev libboost-thread-dev ccache doxygen graphviz
-git clone --recursive https://github.com/monero-project/monero/
-cd monero
-git checkout release-v0.17
-git submodule sync && git submodule update --init --force --recursive
-make release-static -j$(nproc)
-```
-
 ### Arch Linux [AUR](https://wiki.archlinux.org/title/Arch_User_Repository)

 Make the package: [p2pool-git](https://aur.archlinux.org/packages/p2pool-git/)

 ### [Nix/NixOS](https://nixos.org)

-This is a flake only project. So you have to use [nixUnstable with nix flakes](https://nixos.wiki/wiki/Flakes) to build or install p2pool. 
+This is a flake only project. So you have to use [nixUnstable with nix flakes](https://nixos.wiki/wiki/Flakes) to build or install P2Pool. 
 The commands below use the new flake specific reference-format, so be sure to also set `ca-references` in `--experimental-features`.

 Because this project has submodules which are not fixed in _nixUnstable_ yet you have to use the `nix/master` branch:
@@ -99,31 +222,9 @@ Run the binary with arguments:
 nix run git+https://github.com/SChernykh/p2pool?ref=master -- --help
 ```

-### macOS
-
-p2pool binary:
-```
-brew update && brew install git cmake libuv zmq libpgm
-git clone --recursive https://github.com/SChernykh/p2pool
-cd p2pool
-mkdir build && cd build
-cmake ..
-make -j$(sysctl -n hw.logicalcpu)
-```
-
-monerod binary compatible with p2pool:
-```
-git clone --recursive https://github.com/monero-project/monero/
-cd monero
-git checkout release-v0.17
-git submodule sync && git submodule update --init --force --recursive
-brew update && brew bundle --file=contrib/brew/Brewfile
-make -j$(sysctl -n hw.logicalcpu)
-```
-
 ### Windows

-p2pool binary (Visual Studio Community 2019 build):
+P2Pool binary (Visual Studio Community 2019 build):
 *NOTE: You need to have the "Desktop Development with C++" module installed.*
 ```
 git clone --recursive https://github.com/SChernykh/p2pool
@@ -136,92 +237,16 @@ then open generated build\p2pool.sln in Visual Studio and build it there

 Alternatively, you can select "Clone a repository" within the GUI, then select "Build" from the menu. 

-monerod binary compatible with p2pool:
+### macOS
+
+Run the following commands to install the necessary prerequisites, clone this repo, and build P2Pool locally on your Mac:  
 ```
-git clone --recursive https://github.com/monero-project/monero/
-cd monero
-git checkout release-v0.17
-git submodule sync && git submodule update --init --force --recursive
-```
-then follow the instructions from https://github.com/monero-project/monero/#on-windows
-
-## How to mine on P2Pool
-
-This guide assumes that you run everything on the same machine. If it's not the case, change `127.0.0.1` to appropriate IP addresses for your setup. It's highly recommended to create a new mainnet wallet for mining because **wallet addresses are public on p2pool**.
-
-**Wallet software compatible with p2pool payouts**
- Official Monero CLI and GUI v0.17.2.3 and newer
- Monerujo v2.1.0 "Vertant" and newer
- Cake Wallet v4.2.7 and newer
- MyMonero
-
-**General Considerations**
-
- Create a separate restricted user account for mining. p2pool is relatively new and may still have serious bugs/vulnerabilities!
- You have to use the primary wallet address for mining. Subaddresses and integrated addresses are not supported, just like with monerod solo mining.
- Check that ports 18080 (Monero p2p port) and 37889 (p2pool p2p port) are open in your firewall to ensure better connectivity. If you're mining from a computer behind NAT (like a router) you could consider forwarding the ports to your local machine.
- You can connect multiple miners to the same p2pool node. The more the better!
-
-Step-by-step guide:
-
-### GNU/Linux
-
- Download binaries from https://github.com/SChernykh/p2pool/releases/latest
- Alternatively, grab the latest source code for both p2pool and monerod and build them (see above, also notice that the branch name for monerod changed, you'll need to checkout p2pool-api-v0.17)
- Prepare enough huge pages (each of monerod/p2pool/xmrig needs them): `sudo sysctl vm.nr_hugepages=3072`
- Get xmrig (linux-static-x64) binary from https://github.com/xmrig/xmrig/releases/latest
- Check that ports 18080 (Monero p2p port) and 37889 (p2pool p2p port) are open in your firewall to ensure better connectivity
- Use the `monerod` binary bundled with p2pool (official binaries don't have p2pool support yet)
- Run `./monerod --zmq-pub tcp://127.0.0.1:18083 --disable-dns-checkpoints --enable-dns-blocklist` **don't forget --zmq-pub parameter in the command line**
- Double check that it shows **Monero 'Oxygen Orion' (v0.17.2.3-fce167d7c)** on startup. Wait until it's synchronized.
- Run `./p2pool --host 127.0.0.1 --wallet YOUR_WALLET_ADDRESS`
- p2pool has verbose logging by default, you can reduce it by using "loglevel N" command where N is between 0 and 6. Default loglevel is 3.
- You can use `logrotate` with a config like this to control logfile growth:
-    ```
-    <path-to-logfile>
-    {
-	    rotate 7
-	    daily
-	    missingok
-	    delaycompress
-	    nocreate
-    }
-    ```
- Wait until initial p2pool sync is finished, it shouldn't take more than 5-10 minutes, once completed xmrig should be able to connect to the stratum server on port 3333.
- Run `./xmrig -o 127.0.0.1:3333`. Note that you don't need to specify wallet address for xmrig. **Wallet address set in xmrig config will be ignored!**
- To set custom fixed difficulty for your miner (for example, 10000), run `./xmrig -u x+10000 -o 127.0.0.1:3333`
- xmrig should connect and start mining
- Also check p2pool.log for any warnings and errors: `grep -E 'WARNING|ERROR' p2pool.log`
-
-### Windows 
-
-*NOTE: Windows SmartScreen may block incoming connections by files that are "Downloaded from the Internet". You can allow 'p2pool.exe' and 'monerod.exe' by double-clicking them, clicking "More Info", then click "Run Anyway" and then closing them immediately so you can run them from the command line. Advanced users can use the PowerShell cmdlet `Unblock-File` to remove this flag.*
-
- Download p2pool binaries from https://github.com/SChernykh/p2pool/releases/latest
- Download xmrig binary from https://github.com/xmrig/xmrig/releases/latest *(xmrig-6.15.2-gcc-win64.zip is the current version)*
- Expand the p2pool binaries into an appropriate location (`%USERPROFILE%/bin` or `C:/bin/` are good options)
- Expand xmrig binary into appropriate location (same folder as p2pool is fine)
- Prepare huge pages (each of monerod/p2pool/xmrig needs them): 
-  - On Windows 10 or above, run xmrig at least once as Administrator (right-click Run As Administrator)
-  - On earlier versions of Windows, you'll need to run it as admin at least once per login.
- Open a command prompt and navigate to the folder where you extracted p2pool.
- *When running these commands, Windows Firewall may prompt to allow connections, click "Allow"*
- Run `.\Monero\monerod.exe --zmq-pub tcp://127.0.0.1:18083 --disable-dns-checkpoints --enable-dns-blocklist` *NOTE: don't forget --zmq-pub parameter in the command line*
- Double check that it shows **Monero 'Oxygen Orion' (v0.17.2.3-fce167d7c)** on startup. Wait until it's synchronized.
- Run `.\p2pool.exe --host 127.0.0.1 --wallet YOUR_WALLET_ADDRESS`
- Wait until initial p2pool sync is finished, it shouldn't take more than 5-10 minutes, once completed xmrig should be able to connect to the stratum server on port 3333.
- Run `.\xmrig.exe -o 127.0.0.1:3333`. Note that you don't need to specify wallet address for xmrig. **Wallet address set in xmrig config will be ignored!**
- To set custom fixed difficulty for your miner (for example, 10000), run `xmrig.exe -u x+10000 -o 127.0.0.1:3333`
- Windows Quickstart: Create a batch (.bat) file with the following contents and place it in your p2pool directory along with xmrig.exe.
-```
-@ECHO OFF
-start cmd /k %~dp0\Monero\monerod.exe --zmq-pub tcp://127.0.0.1:18083 --disable-dns-checkpoints --enable-dns-blocklist
-ECHO Wait until the Monero daemon shows fully synced before continuing. This can take some time. Type 'status' in other window to check progress.
-PAUSE
-start cmd /k %~dp0\p2pool.exe --wallet YOUR_WALLET_ADDRESS
-ECHO Wait until the daemon shows fully synced before continuing. This can take some time.
-PAUSE
-%~dp0\xmrig.exe -u x+30000 -o 127.0.0.1
+brew update && brew install git cmake libuv zmq libpgm
+git clone --recursive https://github.com/SChernykh/p2pool
+cd p2pool
+mkdir build && cd build
+cmake ..
+make -j$(sysctl -n hw.logicalcpu)
 ```

 ## Donations
@@ -18,7 +18,7 @@ if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
 	if (WIN32)
 		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")
 	else()
-		if (STATIC_LINUX_BINARY)
+		if (STATIC_BINARY)
 			set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")
 		else()
 			set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-libstdc++")
@@ -5,27 +5,27 @@ WALLET_ADDRESS="44MnN1f3Eto8DZYUWuE5XZNUtE3vcRzt2j6PzqWpPau34e6Cf4fAxt6X2MBmrm6F
 ##
 # p2pool settings
 #
+# Use p2pool-mini (uncomment to enable)
+#P2POOL_MINI="--mini"
+#
 # Which port to listen for miner connections
 P2POOL_STRATUM_PORT=3333
 #
 # How much logging - (Less) 0 - 6 (More)
 P2POOL_LOGLEVEL=2
-#
-# The name of docker volume to hold p2pool data (created automatically if it doesnt exist)
-P2POOL_VOLUME=p2pool


 ##
 # Monero Node Settings
 #
-# Version of Monero to build
-MONERO_GIT_TAG=release-v0.17
+# 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"
 #
-# The name of docker volume to hold p2pool data (created automatically if it doesnt exist)
-MONERO_VOLUME=monero
+# Other monerod commandline options
+MONERO_EXTRA_OPTIONS=""


 ##
@@ -34,5 +34,9 @@ MONERO_VOLUME=monero
 # Submit shares at a lower fixed difficulty to show mining progress (comment to disable, edit to customize)
 FIXED_MINING_DIFFICULTY="-u x+500000"
 #
-# Limit the number of CPU cores to use for mining (uncomment to enable, edit to customize)
-#NUM_MINING_CPU="-t 4"
+# set process priority (0 idle, 2 normal to 5 highest)
+MINING_CPU_PRIORITY="--cpu-priority=2"
+#
+# Other XMRIG commandline options
+# See: https://xmrig.com/docs/miner/command-line-options
+XMRIG_EXTRA_OPTIONS=""
@@ -18,7 +18,7 @@ git clone --recursive https://github.com/SChernykh/p2pool
 cd p2pool/docker-compose
 vi .env
 ```
-<b>WALLET_ADDRESS</b> is the only setting that needs to be updated in that file
+**WALLET_ADDRESS** is the only setting that needs to be updated in that file

 #### Build the docker containers
 ```
@@ -31,8 +31,22 @@ docker-compose up
 ```

 #### Optional
-* You can run everythng in the background by adding the "-d" argument to the "docker-compose up" command: ```docker-compose up -d```
-* You can see logs when running in the background for with the "docker logs" command:  ```docker logs -f p2pool-xmrig``` or ```docker logs -f p2pool-p2pool``` or ```docker logs -f p2pool-monero```
-* Open ports 18080 (Monero p2p port) and 37889 (P2Pool p2p port) in your firewall to ensure better connectivity. If you're mining from a computer behind NAT (like a router) you could consider forwarding the ports to your local machine
+* Open ports 18080 (Monero p2p port) and 37889 (P2Pool p2p port) or 37888 (P2Pool-mini p2p port) in your firewall to ensure better connectivity. If you're mining from a computer behind NAT (like a router) you could consider forwarding the ports to your local machine
 * An XMRig CPU miner is included by default, but you can connect additional miners to this same p2pool node using port 3333
 * Configure your kernel for maximum mining performance: [XMRig RandomX Optimization Guide](https://xmrig.com/docs/miner/randomx-optimization-guide)
+* Small miners can mine on p2pool-mini by editing the .env file
+
+
+#### Other usefull commands
+* You can **run everythng in the background** by adding the "-d" argument to the "docker-compose up" command: ```docker-compose up -d```
+* You can **stop everything** with CTRL-C or ```docker-compose down```
+* You can see logs when running in the background for with the "docker logs" command:  ```docker logs -f p2pool-xmrig``` or ```docker logs -f p2pool-p2pool``` or ```docker logs -f p2pool-monero```
+* You can pause mining with: ```docker-compose pause xmrig``` and resume mining with: ```docker-compose unpause xmrig```
+* You can disable mining with: ```docker-compose stop xmrig``` and re-enable mining with: ```docker-compose start xmrig```
+
+
+#### Uninstall
+Change to p2pool/docker-compose directory
+Stop and remove all containers: ```docker-compose down```
+Remove the p2pool data: ```docker volume rm p2pool```
+Remove the monero data: ```docker volume rm monero```
@@ -1,3 +1,4 @@
+---
 version: '3.4'

 networks:
@@ -6,9 +7,9 @@ networks:

 volumes:
  p2pool: 
-    name: ${P2POOL_VOLUME}
+    name: p2pool
  monero:
-    name: ${MONERO_VOLUME}
+    name: monero

 services:
  monero:
@@ -16,7 +17,7 @@ services:
    build:
      context: monero
      args:
-        - MONERO_GIT_TAG=$MONERO_GIT_TAG
+        - MONERO_GIT_TAG=${MONERO_GIT_TAG}
    container_name: p2pool-monero
    networks:
      - p2pool
@@ -38,6 +39,7 @@ services:
      --rpc-bind-port=18081
      --confirm-external-bind
      ${PRUNE_NODE}
+      ${MONERO_EXTRA_OPTIONS}

  p2pool:
    image: p2pool:latest
@@ -47,6 +49,7 @@ services:
      - p2pool
    ports:
      - ${P2POOL_STRATUM_PORT}:3333/tcp
+      - 37888:37888/tcp
      - 37889:37889/tcp
    volumes:
      - p2pool:/home/p2pool/.p2pool:rw
@@ -59,6 +62,7 @@ services:
      --host monero
      --wallet ${WALLET_ADDRESS}
      --loglevel ${P2POOL_LOGLEVEL}
+      ${P2POOL_MINI}

  xmrig:
    image: xmrig:latest
@@ -67,8 +71,6 @@ services:
    networks:
      - p2pool
    privileged: true
-    cap_add:
-      - ALL
    volumes:
      - /dev:/dev:ro
      - /lib/modules:/lib/modules:ro
@@ -78,7 +80,7 @@ services:
    restart: unless-stopped
    command: >-
      ${FIXED_MINING_DIFFICULTY}
-      ${NUM_MINING_CPU}
+      ${MINING_CPU_PRIORITY}
+      ${XMRIG_EXTRA_OPTIONS}
      --randomx-1gb-pages
      -o p2pool:3333
-
@@ -1,5 +1,5 @@
 FROM ubuntu:latest
-ARG MONERO_GIT_TAG="master"
+ARG MONERO_GIT_TAG="latest"

 RUN set -e && \
    apt-get update -q -y --no-install-recommends && \
@@ -47,6 +47,7 @@ RUN set -e && \
 WORKDIR /usr/src
 RUN git clone --recursive https://github.com/monero-project/monero && \
    cd monero && \
+    if [ "x$MONERO_GIT_TAG" = "xlatest" ]; then MONERO_GIT_TAG=$(git describe --tags $(git rev-list --tags --max-count=1)); fi && \
    git checkout $MONERO_GIT_TAG && \
    git submodule sync && git submodule update --init --force --recursive && \
    make release-static -j$(nproc)
@@ -54,9 +55,8 @@ RUN git clone --recursive https://github.com/monero-project/monero && \
 # ---

 FROM ubuntu:latest
-ARG MONERO_GIT_TAG="master"

-COPY --from=0 /usr/src/monero/build/Linux/$MONERO_GIT_TAG/release/bin/* /
+COPY --from=0 /usr/src/monero/build/Linux/*/release/bin/* /

 RUN set -e && \
    apt-get update -q -y --no-install-recommends && \
@@ -1002,7 +1002,7 @@ void BlockTemplate::submit_sidechain_block(uint32_t template_id, uint32_t nonce,
 		m_poolBlockTemplate->m_nonce = nonce;
 		m_poolBlockTemplate->m_extraNonce = extra_nonce;
 		memcpy(m_poolBlockTemplate->m_mainChainData.data() + m_nonceOffset, &nonce, NONCE_SIZE);
-		memcpy(m_poolBlockTemplate->m_mainChainData.data() + m_extraNonceOffsetInTemplate, &extra_nonce, NONCE_SIZE);
+		memcpy(m_poolBlockTemplate->m_mainChainData.data() + m_extraNonceOffsetInTemplate, &extra_nonce, EXTRA_NONCE_SIZE);

 		SideChain& side_chain = m_pool->side_chain();

@@ -113,6 +113,8 @@ FORCEINLINE uint64_t udiv128(uint64_t hi, uint64_t lo, uint64_t divisor, uint64_
 }
 #endif

+template<typename T> FORCEINLINE T round_up(T a, size_t granularity) { return static_cast<T>(((a + (granularity - static_cast<size_t>(1))) / granularity) * granularity); }
+
 struct hash
 {
 	alignas(8) uint8_t h[HASH_SIZE];
@@ -21,6 +21,7 @@
 #include "p2pool.h"
 #include "stratum_server.h"
 #include "p2p_server.h"
+#include "miner.h"
 #include "side_chain.h"
 #include <iostream>

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

-static cmdfunc do_help, do_status, do_loglevel, do_addpeers, do_droppeers, do_showpeers, do_exit;
+static cmdfunc do_help, do_status, do_loglevel, do_addpeers, do_droppeers, do_showpeers, do_showbans, do_outpeers, do_inpeers, do_start_mining, do_stop_mining, do_exit;

 static cmd cmds[] = {
 	{ STRCONST("help"), "", "display list of commands", do_help },
@@ -78,17 +79,21 @@ static cmd cmds[] = {
 	{ STRCONST("addpeers"), "<peeraddr>", "add peer", do_addpeers },
 	{ STRCONST("droppeers"), "", "disconnect all peers", do_droppeers },
 	{ STRCONST("peers"), "", "show all peers", do_showpeers },
+	{ STRCONST("bans"), "", "show all banned IPs", do_showbans },
+	{ STRCONST("outpeers"), "", "set maximum number of outgoing connections", do_outpeers },
+	{ STRCONST("inpeers"), "", "set maximum number of incoming connections", do_inpeers },
+	{ STRCONST("start_mining"), "<threads>", "start mining", do_start_mining },
+	{ STRCONST("stop_mining"), "", "stop mining", do_stop_mining },
 	{ STRCONST("exit"), "", "terminate p2pool", do_exit },
 	{ STRCNULL, NULL, NULL, NULL }
 };

 static int do_help(p2pool * /* m_pool */, const char * /* args */)
 {
-	int i;
-
 	LOGINFO(0, "List of commands");
-	for (i=0; cmds[i].name.len; i++)
+	for (int i = 0; cmds[i].name.len; ++i) {
 		LOGINFO(0, cmds[i].name.str << " " << cmds[i].arg << "\t" << cmds[i].descr);
+	}
 	return 0;
 }

@@ -101,13 +106,16 @@ static int do_status(p2pool *m_pool, const char * /* args */)
 	if (m_pool->p2p_server()) {
 		m_pool->p2p_server()->print_status();
 	}
+	if (m_pool->miner()) {
+		m_pool->miner()->print_status();
+	}
 	bkg_jobs_tracker.print_status();
 	return 0;
 }

 static int do_loglevel(p2pool * /* m_pool */, const char *args)
 {
-	int level = atoi(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);
@@ -138,6 +146,49 @@ static int do_showpeers(p2pool* m_pool, const char* /* args */)
 	return 0;
 }

+static int do_showbans(p2pool* m_pool, const char* /* args */)
+{
+	if (m_pool->stratum_server()) {
+		m_pool->stratum_server()->print_bans();
+	}
+	if (m_pool->p2p_server()) {
+		m_pool->p2p_server()->print_bans();
+	}
+	return 0;
+}
+
+static int do_outpeers(p2pool* m_pool, const char* args)
+{
+	if (m_pool->p2p_server()) {
+		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)
+{
+	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;
+}
+
+static int 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*/)
+{
+	m_pool->stop_mining();
+	return 0;
+}
+
 static int do_exit(p2pool *m_pool, const char * /* args */)
 {
 	bkg_jobs_tracker.wait();
@@ -32,9 +32,12 @@ namespace {
 class RandomBytes
 {
 public:
-	RandomBytes() : rd(), rng(rd()), dist(0, 255)
+	RandomBytes() : rng(s), dist(0, 255)
 	{
 		uv_mutex_init_checked(&m);
+
+		// Diffuse the initial state in case it has low quality
+		rng.discard(10000);
 	}

 	~RandomBytes()
@@ -54,7 +57,22 @@ public:
 private:
 	uv_mutex_t m;

-	std::random_device rd;
+	// Fills the whole initial MT19937-64 state with non-deterministic random numbers
+	struct SeedSequence
+	{
+		using result_type = std::random_device::result_type;
+
+		template<typename T>
+		static void generate(T begin, T end)
+		{
+			std::random_device rd;
+			for (T i = begin; i != end; ++i) {
+				*i = rd();
+			}
+		}
+	};
+
+	SeedSequence s;
 	std::mt19937_64 rng;
 	std::uniform_int_distribution<> dist;
 };
@@ -55,13 +55,25 @@ JSONRPCRequest::JSONRPCRequest(const char* address, int port, const char* req, C
 	m_connect.data = this;
 	m_write.data = this;

-	const size_t len = strlen(req);
+	const char* uri = "/json_rpc";
+
+	size_t len = req ? strlen(req) : 0;
+	if (!len) {
+		LOGERR(1, "Empty JSONRPCRequest, fix the code!");
+		m_valid = false;
+		return;
+	}
+
+	if (req[0] == '/') {
+		uri = req;
+		len = 0;
+	}

 	m_request.reserve(std::max<size_t>(len + 128, log::Stream::BUF_SIZE + 1));
 	m_request.resize(log::Stream::BUF_SIZE + 1);

 	log::Stream s(m_request.data());
-	s << "POST /json_rpc HTTP/1.1\nContent-Type: application/json\nContent-Length: " << len << "\n\n";
+	s << "POST " << uri << " HTTP/1.1\nContent-Type: application/json\nContent-Length: " << len << "\n\n";

 	m_request.resize(s.m_pos);
 	m_request.insert(m_request.end(), req, req + len);
@@ -65,7 +65,12 @@ public:

 		uv_cond_init(&m_cond);
 		uv_mutex_init(&m_mutex);
-		uv_thread_create(&m_worker, run_wrapper, this);
+
+		const int err = uv_thread_create(&m_worker, run_wrapper, this);
+		if (err) {
+			fprintf(stderr, "failed to start logger thread (%s), aborting\n", uv_err_name(err));
+			abort();
+		}

 		do {} while (!worker_started);

@@ -86,9 +91,13 @@ public:
 		}
 	}

-	FORCEINLINE ~Worker()
+	~Worker()
 	{
-		stop();
+		try {
+			stop();
+		}
+		catch (...) {
+		}
 	}

 	FORCEINLINE void stop()
@@ -315,6 +324,29 @@ NOINLINE void Stream::writeCurrentTime()
 	m_numberWidth = 1;
 }

+NOINLINE void put_rawip(const raw_ip& value, Stream* wrapper)
+{
+	const char* addr_str;
+	char addr_str_buf[64];
+
+	static constexpr uint8_t ipv4_prefix[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255 };
+	const bool is_v6 = (memcmp(value.data, ipv4_prefix, 12) != 0);
+
+	if (is_v6) {
+		addr_str = inet_ntop(AF_INET6, value.data, addr_str_buf, sizeof(addr_str_buf));
+	}
+	else {
+		addr_str = inet_ntop(AF_INET, value.data + 12, addr_str_buf, sizeof(addr_str_buf));
+	}
+
+	if (addr_str) {
+		*wrapper << addr_str;
+	}
+	else {
+		*wrapper << "N/A";
+	}
+}
+
 } // namespace log

 } // namespace p2pool
@@ -384,6 +384,13 @@ template<> struct log::Stream::Entry<NetworkType>
 	}
 };

+void put_rawip(const raw_ip& value, Stream* wrapper);
+
+template<> struct log::Stream::Entry<raw_ip>
+{
+	static FORCEINLINE void put(const raw_ip& value, Stream* wrapper) { put_rawip(value, wrapper); }
+};
+
 namespace {
 	template<log::Severity severity> void apply_severity(log::Stream&);

@@ -21,7 +21,7 @@
 #include "stratum_server.h"
 #include "p2p_server.h"

-static void usage()
+void p2pool_usage()
 {
 	printf("P2Pool %s\n"
 		"\nUsage:\n\n" \
@@ -36,15 +36,22 @@ static void usage()
 		"--loglevel           Verbosity of the log, integer number between 0 and %d\n"
 		"--config             Name of the p2pool config file\n"
 		"--data-api           Path to the p2pool JSON data (use it in tandem with an external web-server)\n"
-		"--stratum-api        Enable /local/ path in api path for Stratum Server statistics\n"
+		"--local-api          Enable /local/ path in api path for Stratum Server and built-in miner statistics\n"
+		"--stratum-api        An alias for --local-api\n"
 		"--no-cache           Disable p2pool.cache\n"
 		"--no-color           Disable colors in console output\n"
 		"--no-randomx         Disable internal RandomX hasher: p2pool will use RPC calls to monerod to check PoW hashes\n"
+		"--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"
 		"--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",
 		p2pool::VERSION,
 		p2pool::log::MAX_GLOBAL_LOG_LEVEL,
+		p2pool::DEFAULT_P2P_PORT,
+		p2pool::DEFAULT_P2P_PORT_MINI,
 #ifdef _WIN32
 		"p2pool.exe"
 #else
@@ -61,13 +68,13 @@ void memory_tracking_stop();
 int main(int argc, char* argv[])
 {
 	if (argc == 1) {
-		usage();
+		p2pool_usage();
 		return 0;
 	}

 	for (int i = 1; i < argc; ++i) {
 		if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "/help") || !strcmp(argv[i], "-h") || !strcmp(argv[i], "/h")) {
-			usage();
+			p2pool_usage();
 			return 0;
 		}
 	}
@@ -0,0 +1,223 @@
+/*
+ * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
+ * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "common.h"
+#include "miner.h"
+#include "p2pool.h"
+#include "stratum_server.h"
+#include "block_template.h"
+#include "pow_hash.h"
+#include "randomx.h"
+#include "params.h"
+#include "p2pool_api.h"
+#include <thread>
+
+static constexpr char log_category_prefix[] = "Miner ";
+
+using namespace std::chrono;
+
+namespace p2pool {
+
+Miner::Miner(p2pool* pool, uint32_t threads)
+	: m_pool(pool)
+	, m_threads(threads)
+	, m_stopped(false)
+	, m_startTimestamp(high_resolution_clock::now())
+	, m_nonce(0)
+	, m_nonceTimestamp(m_startTimestamp)
+	, m_extraNonce(0xF19E3779U)
+	, m_totalHashes(0)
+	, m_job{}
+	, m_jobIndex(0)
+{
+	on_block(m_pool->block_template());
+
+	m_minerThreads.reserve(threads);
+
+	for (uint32_t i = 0; i < threads; ++i) {
+		WorkerData* data = new WorkerData{ this, i + 1, threads, {} };
+		const int err = uv_thread_create(&data->m_worker, run, data);
+		if (err) {
+			LOGERR(1, "failed to start worker thread " << data->m_index << '/' << threads << ", error " << uv_err_name(err));
+			delete data;
+			continue;
+		}
+		m_minerThreads.push_back(data);
+	}
+}
+
+Miner::~Miner()
+{
+	m_stopped = true;
+
+	for (WorkerData* data : m_minerThreads) {
+		uv_thread_join(&data->m_worker);
+		delete data;
+	}
+}
+
+void Miner::print_status()
+{
+	const uint32_t hash_count = 0 - m_nonce.load();
+
+	const double dt = static_cast<double>(duration_cast<nanoseconds>(high_resolution_clock::now() - m_nonceTimestamp).count()) / 1e9;
+	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)
+	);
+}
+
+void Miner::on_block(const BlockTemplate& block)
+{
+	const uint32_t next_index = m_jobIndex ^ 1;
+	Job& j = m_job[next_index];
+	hash seed;
+	j.m_blobSize = block.get_hashing_blob(m_extraNonce, j.m_blob, j.m_height, j.m_diff, j.m_sidechainDiff, seed, j.m_nonceOffset, j.m_templateId);
+
+	const uint32_t hash_count = 0 - m_nonce.exchange(0);
+	m_jobIndex = next_index;
+
+	const auto cur_ts = high_resolution_clock::now();
+	const double dt = static_cast<double>(duration_cast<nanoseconds>(cur_ts - m_nonceTimestamp).count()) / 1e9;
+
+	m_nonceTimestamp = cur_ts;
+	m_totalHashes += hash_count;
+
+	if (m_pool->api() && m_pool->params().m_localStats) {
+		m_pool->api()->set(p2pool_api::Category::LOCAL, "miner",
+			[cur_ts, hash_count, dt, 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
+					<< ",\"time_running\":" << time_running
+					<< ",\"shares_found\":" << m_sharesFound.load()
+					<< ",\"threads\":" << m_threads
+					<< "}";
+			});
+	}
+}
+
+void Miner::run(void* data)
+{
+	WorkerData* d = static_cast<WorkerData*>(data);
+	LOGINFO(1, "worker thread " << d->m_index << '/' << d->m_count << " started");
+	make_thread_background();
+	d->m_miner->run(d);
+	LOGINFO(1, "worker thread " << d->m_index << '/' << d->m_count << " stopped");
+}
+
+void Miner::run(WorkerData* data)
+{
+	RandomX_Hasher_Base* hasher = m_pool->hasher();
+	randomx_cache* cache = hasher->cache();
+	randomx_dataset* dataset = hasher->dataset();
+
+	if (!cache && !dataset) {
+		LOGERR(1, "worker thread " << data->m_index << '/' << data->m_count << ": RandomX cache and dataset are not ready");
+		return;
+	}
+
+	randomx_flags flags = randomx_get_flags();
+	if (dataset) {
+		flags |= RANDOMX_FLAG_FULL_MEM;
+	}
+
+	randomx_vm* vm = randomx_create_vm(flags | RANDOMX_FLAG_LARGE_PAGES, dataset ? nullptr : cache, dataset);
+	if (!vm) {
+		LOGWARN(1, "couldn't allocate RandomX VM using large pages");
+		vm = randomx_create_vm(flags, dataset ? nullptr : cache, dataset);
+		if (!vm) {
+			LOGERR(1, "couldn't allocate RandomX VM");
+			return;
+		}
+	}
+
+	uint32_t index = 0;
+	Job job[2];
+
+	uint32_t seed_counter = 0;
+	bool first = true;
+
+	Miner* miner = data->m_miner;
+
+	while (!m_stopped) {
+		if (hasher->seed_counter() != seed_counter) {
+			LOGINFO(5, "worker thread " << data->m_index << '/' << data->m_count << " paused (waiting for RandomX cache/dataset update)");
+			hasher->sync_wait();
+			seed_counter = hasher->seed_counter();
+			if (flags & RANDOMX_FLAG_FULL_MEM) {
+				dataset = hasher->dataset();
+				randomx_vm_set_dataset(vm, dataset);
+			}
+			else {
+				cache = hasher->cache();
+				randomx_vm_set_cache(vm, cache);
+			}
+			LOGINFO(5, "worker thread " << data->m_index << '/' << data->m_count << " resumed");
+		}
+
+		if (first) {
+			first = false;
+			memcpy(&job[index], &miner->m_job[miner->m_jobIndex], sizeof(Job));
+			job[index].set_nonce(miner->m_nonce.fetch_sub(1), miner->m_extraNonce);
+			randomx_calculate_hash_first(vm, job[index].m_blob, job[index].m_blobSize);
+		}
+
+		const Job& j = job[index];
+		index ^= 1;
+		memcpy(&job[index], &miner->m_job[miner->m_jobIndex], sizeof(Job));
+		job[index].set_nonce(miner->m_nonce.fetch_sub(1), miner->m_extraNonce);
+
+		hash h;
+		randomx_calculate_hash_next(vm, job[index].m_blob, job[index].m_blobSize, &h);
+
+		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)) {
+			LOGINFO(0, log::Green() << "SHARE FOUND: mainchain height " << j.m_height << ", diff " << j.m_sidechainDiff << ", worker thread " << data->m_index << '/' << data->m_count);
+			m_pool->submit_sidechain_block(j.m_templateId, j.m_nonce, j.m_extraNonce);
+			++m_sharesFound;
+		}
+
+		std::this_thread::yield();
+	}
+
+	randomx_destroy_vm(vm);
+}
+
+void Miner::Job::set_nonce(uint32_t nonce, uint32_t extra_nonce)
+{
+	m_nonce = nonce;
+	m_extraNonce = extra_nonce;
+
+	uint8_t* p = m_blob + m_nonceOffset;
+	p[0] = static_cast<uint8_t>(nonce);
+	p[1] = static_cast<uint8_t>(nonce >> 8);
+	p[2] = static_cast<uint8_t>(nonce >> 16);
+	p[3] = static_cast<uint8_t>(nonce >> 24);
+}
+
+} // namespace p2pool
@@ -0,0 +1,83 @@
+/*
+ * This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
+ * Copyright (c) 2021 SChernykh <https://github.com/SChernykh>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "uv_util.h"
+#include <chrono>
+
+namespace p2pool {
+
+class p2pool;
+class BlockTemplate;
+
+class Miner
+{
+public:
+	Miner(p2pool* pool, uint32_t threads);
+	~Miner();
+
+	void print_status();
+	void on_block(const BlockTemplate& block);
+
+private:
+	static void run(void* data);
+
+	p2pool* m_pool;
+	uint32_t m_threads;
+
+	struct WorkerData
+	{
+		Miner* m_miner;
+		uint32_t m_index;
+		uint32_t m_count;
+		uv_thread_t m_worker;
+	};
+
+	std::vector<WorkerData*> m_minerThreads;
+	volatile bool m_stopped;
+
+	std::chrono::time_point<std::chrono::high_resolution_clock> m_startTimestamp;
+
+	std::atomic<uint32_t> m_nonce;
+	std::chrono::time_point<std::chrono::high_resolution_clock> m_nonceTimestamp;
+	const uint32_t m_extraNonce;
+
+	uint64_t m_totalHashes;
+	std::atomic<uint32_t> m_sharesFound;
+
+	struct Job
+	{
+		uint8_t m_blob[128] = {};
+		uint32_t m_blobSize = 0;
+		uint32_t m_templateId = 0;
+		difficulty_type m_diff = {};
+		difficulty_type m_sidechainDiff = {};
+		uint64_t m_height = 0;
+		size_t m_nonceOffset = 0;
+		uint32_t m_nonce = 0;
+		uint32_t m_extraNonce = 0;
+
+		void set_nonce(uint32_t nonce, uint32_t extra_nonce);
+	};
+	Job m_job[2];
+	volatile uint32_t m_jobIndex;
+
+	void run(WorkerData* data);
+};
+
+} // namespace p2pool
@@ -23,14 +23,16 @@
 #include "side_chain.h"
 #include "pool_block.h"
 #include "block_cache.h"
+#include "json_rpc_request.h"
+#include "json_parsers.h"
+#include <rapidjson/document.h>
 #include <fstream>
 #include <numeric>

 static constexpr char log_category_prefix[] = "P2PServer ";
 static constexpr char saved_peer_list_file_name[] = "p2pool_peers.txt";
-static const char* seed_nodes[] = {
-	"seeds.p2pool.io"
-};
+static const char* seed_nodes[] = { "seeds.p2pool.io", ""};
+static const char* seed_nodes_mini[] = { "seeds-mini.p2pool.io", "" };

 static constexpr int DEFAULT_BACKLOG = 16;
 static constexpr uint64_t DEFAULT_BAN_TIME = 600;
@@ -50,9 +52,13 @@ P2PServer::P2PServer(p2pool* pool)
 	, m_block(new PoolBlock())
 	, m_timer{}
 	, m_timerCounter(0)
+	, m_timerInterval(2)
 	, m_peerId(m_rng())
 	, m_peerListLastSaved(0)
 {
+	set_max_outgoing_peers(pool->params().m_maxOutgoingPeers);
+	set_max_incoming_peers(pool->params().m_maxIncomingPeers);
+
 	uv_mutex_init_checked(&m_rngLock);
 	uv_mutex_init_checked(&m_blockLock);
 	uv_mutex_init_checked(&m_peerListLock);
@@ -81,7 +87,7 @@ P2PServer::P2PServer(p2pool* pool)
 	}

 	m_timer.data = this;
-	err = uv_timer_start(&m_timer, on_timer, 1000, 2000);
+	err = uv_timer_start(&m_timer, on_timer, 1000, m_timerInterval * 1000);
 	if (err) {
 		LOGERR(1, "failed to start timer, error " << uv_err_name(err));
 		panic();
@@ -171,6 +177,8 @@ void P2PServer::update_peer_connections()
 	const time_t cur_time = time(nullptr);
 	const time_t last_updated = m_pool->side_chain().last_updated();

+	bool has_good_peers = false;
+
 	std::vector<raw_ip> connected_clients;
 	{
 		MutexLock lock(m_clientsListLock);
@@ -203,6 +211,9 @@ void P2PServer::update_peer_connections()

 			if (!disconnected) {
 				connected_clients.emplace_back(client->m_addr);
+				if (client->m_handshakeComplete && !client->m_handshakeInvalid && (client->m_listenPort >= 0)) {
+					has_good_peers = true;
+				}
 			}
 		}
 	}
@@ -226,8 +237,20 @@ void P2PServer::update_peer_connections()
 		peer_list = m_peerList;
 	}

-	// Try to have at least 10 outgoing connections
-	for (uint32_t i = m_numConnections - m_numIncomingConnections; (i < 10) && !peer_list.empty();) {
+	uint32_t N = m_maxOutgoingPeers;
+
+	// Special case: when we can't find p2pool peers, scan through monerod peers (try 25 peers at a time)
+	if (!has_good_peers && !m_peerListMonero.empty()) {
+		LOGINFO(3, "Scanning monerod peers, " << m_peerListMonero.size() << " left");
+		for (uint32_t i = 0; (i < 25) && !m_peerListMonero.empty(); ++i) {
+			peer_list.push_back(m_peerListMonero.back());
+			m_peerListMonero.pop_back();
+		}
+		N = static_cast<uint32_t>(peer_list.size());
+	}
+
+	// Try to have at least N outgoing connections (N defaults to 10, can be set via --out-peers command line parameter)
+	for (uint32_t i = m_numConnections - m_numIncomingConnections; (i < N) && !peer_list.empty();) {
 		const uint64_t k = get_random64() % peer_list.size();
 		const Peer& peer = peer_list[k];

@@ -249,14 +272,16 @@ void P2PServer::update_peer_connections()
 		peer_list.pop_back();
 	}

-	if ((m_numConnections == 0) && ((m_timerCounter % 30) == 0)) {
+	if (!has_good_peers && ((m_timerCounter % 30) == 0)) {
 		LOGERR(1, "no connections to other p2pool nodes, check your monerod/p2pool/network/firewall setup!!!");
+		if (m_peerListMonero.empty()) {
+			load_monerod_peer_list();
+		}
 	}
 }

 void P2PServer::update_peer_list()
 {
-	const time_t cur_time = time(nullptr);
 	{
 		MutexLock lock(m_clientsListLock);

@@ -265,9 +290,9 @@ void P2PServer::update_peer_list()
 				continue;
 			}

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

 				const bool result = send(client,
 					[](void* buf)
@@ -278,7 +303,7 @@ void P2PServer::update_peer_list()
 					});

 				if (result) {
-					client->m_lastPeerListRequestTime = std::chrono::system_clock::now();
+					client->m_lastPeerListRequestTime = std::chrono::high_resolution_clock::now();
 					++client->m_peerListPendingRequests;
 				}
 			}
@@ -367,13 +392,12 @@ void P2PServer::save_peer_list()
 void P2PServer::load_peer_list()
 {
 	std::string saved_list;
+	const size_t old_size = m_peerList.size();

-	// Load peers from seed nodes if we're on the default sidechain
-	if (m_pool->side_chain().is_default()) {
-		const int p2p_port = DEFAULT_P2P_PORT;
-
-		for (size_t i = 0; i < array_size(seed_nodes); ++i) {
-			LOGINFO(4, "loading peers from " << seed_nodes[i]);
+	// 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) {
+		for (size_t i = 0; nodes[i][0]; ++i) {
+			LOGINFO(4, "loading peers from " << nodes[i]);

 			addrinfo hints{};
 			hints.ai_family = AF_UNSPEC;
@@ -381,7 +405,7 @@ void P2PServer::load_peer_list()
 			hints.ai_flags = AI_V4MAPPED | AI_ADDRCONFIG;

 			addrinfo* result;
-			const int err = getaddrinfo(seed_nodes[i], nullptr, &hints, &result);
+			const int err = getaddrinfo(nodes[i], nullptr, &hints, &result);
 			if (err == 0) {
 				for (addrinfo* r = result; r != NULL; r = r->ai_next) {
 					const char* addr_str;
@@ -404,7 +428,7 @@ void P2PServer::load_peer_list()
 					}

 					if (s.m_pos) {
-						LOGINFO(4, "added " << static_cast<char*>(buf) << " from " << seed_nodes[i]);
+						LOGINFO(4, "added " << static_cast<char*>(buf) << " from " << nodes[i]);
 						if (!saved_list.empty()) {
 							saved_list += ',';
 						}
@@ -414,9 +438,16 @@ void P2PServer::load_peer_list()
 				freeaddrinfo(result);
 			}
 			else {
-				LOGWARN(3, "getaddrinfo failed for " << seed_nodes[i] << ": " << gai_strerror(err));
+				LOGWARN(3, "getaddrinfo failed for " << nodes[i] << ": " << gai_strerror(err));
 			}
 		}
+	};
+
+	if (m_pool->side_chain().is_default()) {
+		load_from_seed_nodes(seed_nodes, DEFAULT_P2P_PORT);
+	}
+	else if (m_pool->side_chain().is_mini()) {
+		load_from_seed_nodes(seed_nodes_mini, DEFAULT_P2P_PORT_MINI);
 	}

 	// Finally load peers from p2pool_peers.txt
@@ -486,7 +517,102 @@ void P2PServer::load_peer_list()
 			}
 		});

-	LOGINFO(4, "peer list loaded (" << m_peerList.size() << " peers)");
+	LOGINFO(4, "peer list loaded (" << (m_peerList.size() - old_size) << " peers)");
+}
+
+void P2PServer::load_monerod_peer_list()
+{
+	const Params& params = m_pool->params();
+
+	JSONRPCRequest::call(params.m_host.c_str(), params.m_rpcPort, "/get_peer_list",
+		[this](const char* data, size_t size)
+		{
+			constexpr char err_str[] = "/get_peer_list RPC request returned invalid JSON ";
+
+			using namespace rapidjson;
+
+			Document doc;
+			if (doc.Parse(data, size).HasParseError()) {
+				LOGWARN(4, err_str << "(parse error)");
+				return;
+			}
+
+			if (!doc.IsObject()) {
+				LOGWARN(4, err_str << "(not an object)");
+				return;
+			}
+
+			if (!doc.HasMember("white_list")) {
+				LOGWARN(4, err_str << "('white_list' not found)");
+				return;
+			}
+
+			const auto& white_list = doc["white_list"];
+
+			if (!white_list.IsArray()) {
+				LOGWARN(4, err_str << "('white_list' is not an array)");
+				return;
+			}
+
+			const int port = m_pool->side_chain().is_mini() ? DEFAULT_P2P_PORT_MINI : DEFAULT_P2P_PORT;
+
+			const SizeType n = white_list.Size();
+
+			m_peerListMonero.clear();
+			m_peerListMonero.reserve(n);
+
+			for (SizeType i = 0; i < n; ++i) {
+				auto& v = white_list[i];
+				const char* ip;
+				uint64_t last_seen;
+				if (!parseValue(v, "host", ip) || !parseValue(v, "last_seen", last_seen)) {
+					continue;
+				}
+
+				Peer p;
+				p.m_lastSeen = last_seen;
+
+				if (strchr(ip, ':')) {
+					sockaddr_in6 addr6;
+					const int err = uv_ip6_addr(ip, port, &addr6);
+					if (err) {
+						continue;
+					}
+					p.m_isV6 = true;
+					memcpy(p.m_addr.data, &addr6.sin6_addr, sizeof(in6_addr));
+				}
+				else {
+					sockaddr_in addr4;
+					const int err = uv_ip4_addr(ip, port, &addr4);
+					if (err) {
+						continue;
+					}
+					p.m_isV6 = false;
+					p.m_addr = {};
+					p.m_addr.data[10] = 0xFF;
+					p.m_addr.data[11] = 0xFF;
+					memcpy(p.m_addr.data + 12, &addr4.sin_addr, sizeof(in_addr));
+				}
+
+				p.m_port = port;
+				p.m_numFailedConnections = 0;
+
+				if (!is_banned(p.m_addr)) {
+					m_peerListMonero.push_back(p);
+				}
+			}
+
+			// Put recently active peers first in the list
+			std::sort(m_peerListMonero.begin(), m_peerListMonero.end(), [](const Peer& a, const Peer& b) { return a.m_lastSeen > b.m_lastSeen; });
+
+			LOGINFO(4, "monerod peer list loaded (" << m_peerListMonero.size() << " peers)");
+		},
+		[](const char* data, size_t size)
+		{
+			if (size > 0) {
+				LOGWARN(4, "/get_peer_list RPC request failed: error " << log::const_buf(data, size));
+			}
+		}, &m_loop);
 }

 void P2PServer::update_peer_in_list(bool is_v6, const raw_ip& ip, int port)
@@ -675,7 +801,7 @@ void P2PServer::on_broadcast()
 				}

 				return p - p0;
-				});
+			});
 		}
 	}
 }
@@ -819,7 +945,7 @@ void P2PServer::download_missing_blocks()
 			}
 		}

-		send(client,
+		const bool result = send(client,
 			[&id](void* buf)
 			{
 				uint8_t* p0 = reinterpret_cast<uint8_t*>(buf);
@@ -833,6 +959,10 @@ void P2PServer::download_missing_blocks()

 				return p - p0;
 			});
+
+		if (result) {
+			++client->m_blockPendingRequests;
+		}
 	}
 }

@@ -859,10 +989,13 @@ P2PServer::P2PClient::P2PClient()
 	, m_handshakeComplete(false)
 	, m_handshakeInvalid(false)
 	, m_listenPort(-1)
-	, m_nextPeerListRequest(0)
+	, m_fastPeerListRequestCount(0)
+	, m_prevIncomingPeerListRequest{}
+	, m_nextOutgoingPeerListRequest(0)
 	, m_lastPeerListRequestTime{}
 	, m_peerListPendingRequests(0)
 	, m_pingTime(0)
+	, m_blockPendingRequests(0)
 	, m_lastAlive(0)
 	, m_lastBroadcastTimestamp(0)
 	, m_lastBlockrequestTimestamp(0)
@@ -885,10 +1018,13 @@ void P2PServer::P2PClient::reset()
 	m_handshakeComplete = false;
 	m_handshakeInvalid = false;
 	m_listenPort = -1;
-	m_nextPeerListRequest = 0;
+	m_fastPeerListRequestCount = 0;
+	m_prevIncomingPeerListRequest = {};
+	m_nextOutgoingPeerListRequest = 0;
 	m_lastPeerListRequestTime = {};
 	m_peerListPendingRequests = 0;
 	m_pingTime = 0;
+	m_blockPendingRequests = 0;
 	m_lastAlive = 0;
 	m_lastBroadcastTimestamp = 0;
 	m_lastBlockrequestTimestamp = 0;
@@ -903,6 +1039,15 @@ bool P2PServer::P2PClient::on_connect()
 {
 	P2PServer* server = static_cast<P2PServer*>(m_owner);

+	if (!server) {
+		return false;
+	}
+
+	if (m_isIncoming && (server->m_numIncomingConnections > server->m_maxIncomingPeers)) {
+		LOGINFO(5, "Connection from " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " rejected (incoming connections limit was reached)");
+		return false;
+	}
+
 	// Don't allow multiple connections to/from the same IP
 	// server->m_clientsListLock is already locked here
 	for (P2PClient* client = static_cast<P2PClient*>(server->m_connectedClientsList->m_next); client != server->m_connectedClientsList; client = static_cast<P2PClient*>(client->m_next)) {
@@ -936,6 +1081,8 @@ bool P2PServer::P2PClient::on_read(char* data, uint32_t size)
 	uint8_t* buf = buf_begin;
 	uint32_t bytes_left = m_numRead;

+	uint32_t num_block_requests = 0;
+
 	uint32_t bytes_read;
 	do {
 		MessageId id = static_cast<MessageId>(buf[0]);
@@ -993,6 +1140,13 @@ bool P2PServer::P2PClient::on_read(char* data, uint32_t size)
 			break;

 		case MessageId::LISTEN_PORT:
+			if (m_listenPort >= 0) {
+				LOGWARN(4, "peer " << static_cast<char*>(m_addrString) << " sent an unexpected LISTEN_PORT");
+				ban(DEFAULT_BAN_TIME);
+				server->remove_peer_from_list(this);
+				return false;
+			}
+
 			LOGINFO(5, "peer " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " sent LISTEN_PORT");

 			if (bytes_left >= 1 + sizeof(int32_t)) {
@@ -1006,6 +1160,14 @@ bool P2PServer::P2PClient::on_read(char* data, uint32_t size)
 			break;

 		case MessageId::BLOCK_REQUEST:
+			++num_block_requests;
+			if (num_block_requests > 100) {
+				LOGWARN(4, "peer " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " sent too many BLOCK_REQUEST messages at once");
+				ban(DEFAULT_BAN_TIME);
+				server->remove_peer_from_list(this);
+				return false;
+			}
+
 			LOGINFO(5, "peer " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " sent BLOCK_REQUEST");

 			if (bytes_left >= 1 + HASH_SIZE) {
@@ -1019,12 +1181,21 @@ bool P2PServer::P2PClient::on_read(char* data, uint32_t size)
 			break;

 		case MessageId::BLOCK_RESPONSE:
+			if (m_blockPendingRequests <= 0) {
+				LOGWARN(4, "peer " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " sent an unexpected BLOCK_RESPONSE");
+				ban(DEFAULT_BAN_TIME);
+				server->remove_peer_from_list(this);
+				return false;
+			}
+
 			LOGINFO(5, "peer " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " sent BLOCK_RESPONSE");

 			if (bytes_left >= 1 + sizeof(uint32_t)) {
 				const uint32_t block_size = *reinterpret_cast<uint32_t*>(buf + 1);
 				if (bytes_left >= 1 + sizeof(uint32_t) + block_size) {
 					bytes_read = 1 + sizeof(uint32_t) + block_size;
+
+					--m_blockPendingRequests;
 					if (!on_block_response(buf + 1 + sizeof(uint32_t), block_size)) {
 						ban(DEFAULT_BAN_TIME);
 						server->remove_peer_from_list(this);
@@ -1086,7 +1257,7 @@ bool P2PServer::P2PClient::on_read(char* data, uint32_t size)
 					bytes_read = 2u + num_peers * 19u;

 					using namespace std::chrono;
-					m_pingTime = duration_cast<milliseconds>(system_clock::now() - m_lastPeerListRequestTime).count();
+					m_pingTime = duration_cast<milliseconds>(high_resolution_clock::now() - m_lastPeerListRequestTime).count();

 					--m_peerListPendingRequests;
 					if (!on_peer_list_response(buf + 1)) {
@@ -1436,6 +1607,7 @@ void P2PServer::P2PClient::on_after_handshake(uint8_t* &p)
 	memcpy(p, empty.h, HASH_SIZE);
 	p += HASH_SIZE;

+	++m_blockPendingRequests;
 	m_lastBroadcastTimestamp = time(nullptr);
 }

@@ -1570,7 +1742,21 @@ bool P2PServer::P2PClient::on_block_broadcast(const uint8_t* buf, uint32_t size)

 bool P2PServer::P2PClient::on_peer_list_request(const uint8_t*)
 {
+	using namespace std::chrono;
+
 	P2PServer* server = static_cast<P2PServer*>(m_owner);
+	const auto cur_time = steady_clock::now();
+
+	// Allow peer list requests no more than once every 30 seconds
+	if (duration_cast<seconds>(cur_time - m_prevIncomingPeerListRequest).count() < 30) {
+		++m_fastPeerListRequestCount;
+		if (m_fastPeerListRequestCount >= 3) {
+			LOGWARN(4, "peer " << log::Gray() << static_cast<char*>(m_addrString) << log::NoColor() << " is sending PEER_LIST_REQUEST too often");
+			return false;
+		}
+	}
+
+	m_prevIncomingPeerListRequest = cur_time;

 	Peer peers[PEER_LIST_RESPONSE_MAX_PEERS];
 	uint32_t num_selected_peers = 0;
@@ -1781,6 +1967,8 @@ void P2PServer::P2PClient::post_handle_incoming_block(const uint32_t reset_count
 		if (!result) {
 			return;
 		}
+
+		++m_blockPendingRequests;
 	}
 }

@@ -29,6 +29,7 @@ class BlockCache;
 static constexpr size_t P2P_BUF_SIZE = 128 * 1024;
 static constexpr size_t PEER_LIST_RESPONSE_MAX_PEERS = 16;
 static constexpr int DEFAULT_P2P_PORT = 37889;
+static constexpr int DEFAULT_P2P_PORT_MINI = 37888;

 class P2PServer : public TCPServer<P2P_BUF_SIZE, P2P_BUF_SIZE>
 {
@@ -109,11 +110,15 @@ public:
 		bool m_handshakeInvalid;
 		int m_listenPort;

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

+		int m_blockPendingRequests;
+
 		time_t m_lastAlive;
 		time_t m_lastBroadcastTimestamp;
 		time_t m_lastBlockrequestTimestamp;
@@ -130,11 +135,19 @@ public:
 	void show_peers();
 	size_t peer_list_size() const { return m_peerList.size(); }

+	uint32_t max_outgoing_peers() const { return m_maxOutgoingPeers; }
+	uint32_t max_incoming_peers() const { return m_maxIncomingPeers; }
+
+	void set_max_outgoing_peers(uint32_t n) { m_maxOutgoingPeers = std::min(std::max(n, 10U), 1000U); }
+	void set_max_incoming_peers(uint32_t n) { m_maxIncomingPeers = std::min(std::max(n, 10U), 1000U); }
+
 private:
 	p2pool* m_pool;
 	BlockCache* m_cache;
 	bool m_cacheLoaded;
 	std::string m_initialPeerList;
+	uint32_t m_maxOutgoingPeers;
+	uint32_t m_maxIncomingPeers;

 	uv_rwlock_t m_cachedBlocksLock;
 	unordered_map<hash, PoolBlock*> m_cachedBlocks;
@@ -151,6 +164,7 @@ private:
 	void save_peer_list_async();
 	void save_peer_list();
 	void load_peer_list();
+	void load_monerod_peer_list();
 	void update_peer_in_list(bool is_v6, const raw_ip& ip, int port);
 	void remove_peer_from_list(P2PClient* client);
 	void remove_peer_from_list(const raw_ip& ip);
@@ -163,7 +177,8 @@ private:
 	PoolBlock* m_block;

 	uv_timer_t m_timer;
-	uint32_t m_timerCounter;
+	uint64_t m_timerCounter;
+	uint64_t m_timerInterval;

 	uint64_t m_peerId;

@@ -179,6 +194,7 @@ private:
 	};

 	std::vector<Peer> m_peerList;
+	std::vector<Peer> m_peerListMonero;
 	time_t m_peerListLastSaved;

 	struct Broadcast
@@ -27,10 +27,12 @@
 #include "side_chain.h"
 #include "stratum_server.h"
 #include "p2p_server.h"
+#include "miner.h"
 #include "params.h"
 #include "console_commands.h"
 #include "crypto.h"
 #include "p2pool_api.h"
+#include "pool_block.h"
 #include <thread>
 #include <fstream>

@@ -109,7 +111,22 @@ p2pool::p2pool(int argc, char* argv[])

 	m_api = m_params->m_apiPath.empty() ? nullptr : new p2pool_api(m_params->m_apiPath, m_params->m_localStats);

-	m_sideChain = new SideChain(this, type);
+	if (m_params->m_localStats && !m_api) {
+		LOGERR(1, "--local-api and --stratum-api command line parameters can't be used without --data-api");
+		panic();
+	}
+
+	m_sideChain = new SideChain(this, type, m_params->m_mini ? "mini" : nullptr);
+
+	if (m_params->m_p2pAddresses.empty()) {
+		const int p2p_port = m_sideChain->is_mini() ? DEFAULT_P2P_PORT_MINI : DEFAULT_P2P_PORT;
+
+		char buf[log::Stream::BUF_SIZE + 1];
+		log::Stream s(buf);
+		s << "[::]:" << p2p_port << ",0.0.0.0:" << p2p_port << '\0';
+
+		m_params->m_p2pAddresses = buf;
+	}

 	if (m_params->m_disableRandomX) {
 		m_hasher = new RandomX_Hasher_RPC(this);
@@ -328,8 +345,13 @@ void p2pool::handle_chain_main(ChainMain& data, const char* extra)
 		", reward = " << log::Gray() << log::XMRAmount(data.reward));

 	if (!sidechain_id.empty()) {
-		if (side_chain().has_block(sidechain_id)) {
+		PoolBlock* block = side_chain().find_block(sidechain_id);
+		if (block) {
 			LOGINFO(0, log::LightGreen() << "BLOCK FOUND: main chain block at height " << data.height << " was mined by this p2pool" << BLOCK_FOUND);
+			const uint64_t payout = block->get_payout(params().m_wallet);
+			if (payout) {
+				LOGINFO(0, log::LightCyan() << "You received a payout of " << log::LightGreen() << log::XMRAmount(payout) << log::LightCyan() << " in block " << log::LightGreen() << data.height);
+			}
 			api_update_block_found(&data);
 		}
 		else {
@@ -580,6 +602,9 @@ void p2pool::download_block_headers(uint64_t current_height)
 					m_ZMQReader = new ZMQReader(m_params->m_host.c_str(), m_params->m_zmqPort, this);
 					m_stratumServer = new StratumServer(this);
 					m_p2pServer = new P2PServer(this);
+					if (m_params->m_minerThreads) {
+						start_mining(m_params->m_minerThreads);
+					}
 					api_update_network_stats();
 				}
 			}
@@ -646,22 +671,12 @@ void p2pool::update_median_timestamp()

 void p2pool::stratum_on_block()
 {
-#if 0
-	uint8_t hashing_blob[128];
-	uint64_t height;
-	difficulty_type difficulty;
-	difficulty_type sidechain_difficulty;
-	hash seed_hash;
-	size_t nonce_offset;
-	uint32_t template_id;
-
-	m_blockTemplate->get_hashing_blob(0, hashing_blob, height, difficulty, sidechain_difficulty, seed_hash, nonce_offset, template_id);
-	submit_block(template_id, 0, 0);
-#else
+	if (m_miner) {
+		m_miner->on_block(*m_blockTemplate);
+	}
 	if (m_stratumServer) {
 		m_stratumServer->on_block(*m_blockTemplate);
 	}
-#endif
 }

 void p2pool::get_info()
@@ -1104,7 +1119,7 @@ void p2pool::api_update_stats_mod()
 	m_api->set(p2pool_api::Category::GLOBAL, "stats_mod",
 		[&mainnet_tip, last_block_found_time, &last_block_found_buf, last_block_found_height, miners, hashrate, round_hashes, stratum_port](log::Stream& s)
 		{
-			s << "{\"config\":{\"ports\":[{\"port\":" << stratum_port << ",\"tls\":false}],\"fee\":0,\"minPaymentThreshold\":400000000},\"network\":{\"height\":"
+			s << "{\"config\":{\"ports\":[{\"port\":" << stratum_port << ",\"tls\":false}],\"fee\":0,\"minPaymentThreshold\":300000000},\"network\":{\"height\":"
 				<< mainnet_tip.height << "},\"pool\":{\"stats\":{\"lastBlockFound\":\""
 				<< last_block_found_time << "000\"},\"blocks\":[\""
 				<< static_cast<char*>(last_block_found_buf) << static_cast<char*>(last_block_found_buf) + HASH_SIZE * 2 - 4 << ':'
@@ -1204,6 +1219,21 @@ bool p2pool::get_difficulty_at_height(uint64_t height, difficulty_type& diff)
 	return true;
 }

+void p2pool::start_mining(uint32_t threads)
+{
+	stop_mining();
+	m_miner = new Miner(this, threads);
+}
+
+void p2pool::stop_mining()
+{
+	Miner* miner = m_miner;
+	if (miner) {
+		m_miner = nullptr;
+		delete miner;
+	}
+}
+
 static void on_signal(uv_signal_t* handle, int signum)
 {
 	p2pool* pool = reinterpret_cast<p2pool*>(handle->data);
@@ -1312,6 +1342,7 @@ int p2pool::run()

 	bkg_jobs_tracker.wait();

+	delete m_miner;
 	delete m_stratumServer;
 	delete m_p2pServer;

@@ -29,6 +29,7 @@ class Mempool;
 class SideChain;
 class StratumServer;
 class P2PServer;
+class Miner;
 class ConsoleCommands;
 class p2pool_api;
 class ZMQReader;
@@ -58,6 +59,7 @@ public:

 	StratumServer* stratum_server() const { return m_stratumServer; }
 	P2PServer* p2p_server() const { return m_p2pServer; }
+	Miner* miner() const { return m_miner; }

 	virtual void handle_tx(TxMempoolData& tx) override;
 	virtual void handle_miner_data(MinerData& data) override;
@@ -78,6 +80,9 @@ public:

 	bool get_difficulty_at_height(uint64_t height, difficulty_type& diff);

+	void start_mining(uint32_t threads);
+	void stop_mining();
+
 	time_t zmq_last_active() const { return m_zmqLastActive; }
 	time_t start_time() const { return m_startTime; }

@@ -155,6 +160,7 @@ private:
 	std::atomic<uint32_t> m_serversStarted{ 0 };
 	StratumServer* m_stratumServer = nullptr;
 	P2PServer* m_p2pServer = nullptr;
+	Miner* m_miner = nullptr;

 	ConsoleCommands* m_consoleCommands;

@@ -20,70 +20,115 @@
 #include "stratum_server.h"
 #include "p2p_server.h"

+void p2pool_usage();
+
 namespace p2pool {

 Params::Params(int argc, char* argv[])
 {
 	for (int i = 1; i < argc; ++i) {
+		bool ok = false;
+
 		if ((strcmp(argv[i], "--host") == 0) && (i + 1 < argc)) {
 			m_host = argv[++i];
+			ok = true;
 		}

 		if ((strcmp(argv[i], "--rpc-port") == 0) && (i + 1 < argc)) {
-			m_rpcPort = static_cast<uint32_t>(atoi(argv[++i]));
+			m_rpcPort = strtoul(argv[++i], nullptr, 10);
+			ok = true;
 		}

 		if ((strcmp(argv[i], "--zmq-port") == 0) && (i + 1 < argc)) {
-			m_zmqPort = static_cast<uint32_t>(atoi(argv[++i]));
+			m_zmqPort = strtoul(argv[++i], nullptr, 10);
+			ok = true;
 		}

 		if (strcmp(argv[i], "--light-mode") == 0) {
 			m_lightMode = true;
+			ok = true;
 		}

 		if ((strcmp(argv[i], "--wallet") == 0) && (i + 1 < argc)) {
 			m_wallet.decode(argv[++i]);
+			ok = true;
 		}

 		if ((strcmp(argv[i], "--stratum") == 0) && (i + 1 < argc)) {
 			m_stratumAddresses = argv[++i];
+			ok = true;
 		}

 		if ((strcmp(argv[i], "--p2p") == 0) && (i + 1 < argc)) {
 			m_p2pAddresses = argv[++i];
+			ok = true;
 		}

 		if ((strcmp(argv[i], "--addpeers") == 0) && (i + 1 < argc)) {
 			m_p2pPeerList = argv[++i];
+			ok = true;
 		}

 		if ((strcmp(argv[i], "--loglevel") == 0) && (i + 1 < argc)) {
-			const int level = std::min(std::max(atoi(argv[++i]), 0), log::MAX_GLOBAL_LOG_LEVEL);
+			const int level = std::min(std::max<int>(strtol(argv[++i], nullptr, 10), 0), log::MAX_GLOBAL_LOG_LEVEL);
 			log::GLOBAL_LOG_LEVEL = level;
+			ok = true;
 		}

 		if ((strcmp(argv[i], "--config") == 0) && (i + 1 < argc)) {
 			m_config = argv[++i];
+			ok = true;
 		}

 		if ((strcmp(argv[i], "--data-api") == 0) && (i + 1 < argc)) {
 			m_apiPath = argv[++i];
+			ok = true;
 		}

-		if (strcmp(argv[i], "--stratum-api") == 0) {
+		if ((strcmp(argv[i], "--local-api") == 0) || (strcmp(argv[i], "--stratum-api") == 0)) {
 			m_localStats = true;
+			ok = true;
 		}

 		if (strcmp(argv[i], "--no-cache") == 0) {
 			m_blockCache = false;
+			ok = true;
 		}

 		if (strcmp(argv[i], "--no-color") == 0) {
 			log::CONSOLE_COLORS = false;
+			ok = true;
 		}

 		if (strcmp(argv[i], "--no-randomx") == 0) {
 			m_disableRandomX = true;
+			ok = true;
+		}
+
+		if ((strcmp(argv[i], "--out-peers") == 0) && (i + 1 < argc)) {
+			m_maxOutgoingPeers = std::min(std::max(strtoul(argv[++i], nullptr, 10), 10UL), 1000UL);
+			ok = true;
+		}
+
+		if ((strcmp(argv[i], "--in-peers") == 0) && (i + 1 < argc)) {
+			m_maxIncomingPeers = std::min(std::max(strtoul(argv[++i], nullptr, 10), 10UL), 1000UL);
+			ok = true;
+		}
+
+		if ((strcmp(argv[i], "--start-mining") == 0) && (i + 1 < argc)) {
+			m_minerThreads = std::min(std::max(strtoul(argv[++i], nullptr, 10), 1UL), 64UL);
+			ok = true;
+		}
+
+		if (strcmp(argv[i], "--mini") == 0) {
+			m_mini = true;
+			ok = true;
+		}
+
+		if (!ok) {
+			fprintf(stderr, "Unknown command line parameter %s\n\n", argv[i]);
+			p2pool_usage();
+			panic();
 		}
 	}

@@ -96,16 +141,6 @@ Params::Params(int argc, char* argv[])

 		m_stratumAddresses = buf;
 	}
-
-	if (m_p2pAddresses.empty()) {
-		const int p2p_port = DEFAULT_P2P_PORT;
-
-		char buf[log::Stream::BUF_SIZE + 1];
-		log::Stream s(buf);
-		s << "[::]:" << p2p_port << ",0.0.0.0:" << p2p_port << '\0';
-
-		m_p2pAddresses = buf;
-	}
 }

 bool Params::ok() const
@@ -40,6 +40,10 @@ struct Params
 	bool m_localStats = false;
 	bool m_blockCache = true;
 	bool m_disableRandomX = false;
+	uint32_t m_maxOutgoingPeers = 10;
+	uint32_t m_maxIncomingPeers = 1000;
+	uint32_t m_minerThreads = 0;
+	bool m_mini = false;
 };

 } // namespace p2pool
@@ -298,4 +298,16 @@ bool PoolBlock::get_pow_hash(RandomX_Hasher_Base* hasher, uint64_t height, const
 	return hasher->calculate(blob, blob_size, height, seed_hash, pow_hash);
 }

+uint64_t PoolBlock::get_payout(const Wallet& w) const
+{
+	for (size_t i = 0, n = m_outputs.size(); i < n; ++i) {
+		hash eph_public_key;
+		if ((w.get_eph_public_key(m_txkeySec, i, eph_public_key)) && (eph_public_key == m_outputs[i].m_ephPublicKey)) {
+			return m_outputs[i].m_reward;
+		}
+	}
+
+	return 0;
+}
+
 } // namespace p2pool
@@ -137,6 +137,8 @@ struct PoolBlock

 	int deserialize(const uint8_t* data, size_t size, SideChain& sidechain);
 	bool get_pow_hash(RandomX_Hasher_Base* hasher, uint64_t height, const hash& seed_hash, hash& pow_hash);
+
+	uint64_t get_payout(const Wallet& w) const;
 };

 } // namespace p2pool
@@ -37,7 +37,7 @@ RandomX_Hasher::RandomX_Hasher(p2pool* pool)
 	, m_dataset(nullptr)
 	, m_seed{}
 	, m_index(0)
-	, m_setSeedCounter(0)
+	, m_seedCounter(0)
 {
 	uint64_t memory_allocated = 0;

@@ -119,6 +119,10 @@ RandomX_Hasher::~RandomX_Hasher()

 void RandomX_Hasher::set_seed_async(const hash& seed)
 {
+	if (m_seed[m_index] == seed) {
+		return;
+	}
+
 	struct Work
 	{
 		p2pool* pool;
@@ -127,10 +131,7 @@ void RandomX_Hasher::set_seed_async(const hash& seed)
 		uv_work_t req;
 	};

-	Work* work = new Work{};
-	work->pool = m_pool;
-	work->hasher = this;
-	work->seed = seed;
+	Work* work = new Work{ m_pool, this, seed, {} };
 	work->req.data = work;

 	const int err = uv_queue_work(uv_default_loop_checked(), &work->req,
@@ -167,7 +168,7 @@ void RandomX_Hasher::set_seed(const hash& seed)
 	WriteLock lock(m_datasetLock);
 	uv_rwlock_wrlock(&m_cacheLock);

-	m_setSeedCounter.fetch_add(1);
+	m_seedCounter.fetch_add(1);

 	if (m_seed[m_index] == seed) {
 		uv_rwlock_wrunlock(&m_cacheLock);
@@ -269,7 +270,7 @@ void RandomX_Hasher::set_seed(const hash& seed)
 void RandomX_Hasher::set_old_seed(const hash& seed)
 {
 	// set_seed() must go first, wait for it
-	while (m_setSeedCounter.load() == 0) {
+	while (m_seedCounter.load() == 0) {
 		std::this_thread::sleep_for(std::chrono::milliseconds(1));
 	}

@@ -305,6 +306,12 @@ void RandomX_Hasher::set_old_seed(const hash& seed)
 	LOGINFO(1, log::LightCyan() << "old cache updated");
 }

+void RandomX_Hasher::sync_wait()
+{
+	ReadLock lock(m_datasetLock);
+	ReadLock lock2(m_cacheLock);
+}
+
 bool RandomX_Hasher::calculate(const void* data, size_t size, uint64_t /*height*/, const hash& seed, hash& result)
 {
 	// First try to use the dataset if it's ready
@@ -353,7 +360,6 @@ 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_loopStopped(false)
 	, m_loopThread{}
 {
 	int err = uv_loop_init(&m_loop);
@@ -385,11 +391,7 @@ RandomX_Hasher_RPC::RandomX_Hasher_RPC(p2pool* pool)
 RandomX_Hasher_RPC::~RandomX_Hasher_RPC()
 {
 	uv_async_send(&m_shutdownAsync);
-
-	using namespace std::chrono;
-	while (!m_loopStopped) {
-		std::this_thread::sleep_for(milliseconds(1));
-	}
+	uv_thread_join(&m_loopThread);

 	uv_mutex_destroy(&m_requestMutex);
 	uv_mutex_destroy(&m_condMutex);
@@ -405,7 +407,6 @@ void RandomX_Hasher_RPC::loop(void* data)
 	uv_run(&hasher->m_loop, UV_RUN_DEFAULT);
 	uv_loop_close(&hasher->m_loop);
 	LOGINFO(1, "event loop stopped");
-	hasher->m_loopStopped = true;
 }

 bool RandomX_Hasher_RPC::calculate(const void* data_ptr, size_t size, uint64_t height, const hash& /*seed*/, hash& h)
@@ -35,6 +35,11 @@ public:
 	virtual void set_seed_async(const hash&) {}
 	virtual void set_old_seed(const hash&) {}

+	virtual randomx_cache* cache() const { return nullptr; }
+	virtual randomx_dataset* dataset() const { return nullptr; }
+	virtual uint32_t seed_counter() const { return 0; }
+	virtual void sync_wait() {}
+
 	virtual bool calculate(const void* data, size_t size, uint64_t height, const hash& seed, hash& result) = 0;
 };

@@ -49,6 +54,11 @@ public:

 	void set_old_seed(const hash& seed) override;

+	randomx_cache* cache() const override { return m_cache[m_index]; }
+	randomx_dataset* dataset() const override { return m_dataset; }
+	uint32_t seed_counter() const override { return m_seedCounter.load(); }
+	void sync_wait() override;
+
 	bool calculate(const void* data, size_t size, uint64_t height, const hash& seed, hash& result) override;

 private:
@@ -78,7 +88,7 @@ private:
 	hash m_seed[2];
 	uint32_t m_index;

-	std::atomic<uint32_t> m_setSeedCounter;
+	std::atomic<uint32_t> m_seedCounter;
 };

 class RandomX_Hasher_RPC : public RandomX_Hasher_Base
@@ -96,7 +106,6 @@ private:

 	uv_mutex_t m_requestMutex;
 	uv_loop_t m_loop;
-	volatile bool m_loopStopped;

 	uv_thread_t m_loopThread;
 	uv_mutex_t m_condMutex;
@@ -27,6 +27,7 @@
 #include "intrin_portable.h"
 #include "keccak.h"
 #include "p2p_server.h"
+#include "stratum_server.h"
 #include "params.h"
 #include "json_parsers.h"
 #include <rapidjson/document.h>
@@ -51,9 +52,8 @@ static_assert(1 <= UNCLE_BLOCK_DEPTH && UNCLE_BLOCK_DEPTH <= 10, "Invalid UNCLE_

 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
-};
+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 };
+static constexpr uint8_t mini_consensus_id[HASH_SIZE] = { 57,130,201,26,149,174,199,250,66,80,189,18,108,216,194,220,136,23,63,24,64,113,221,44,219,86,39,163,53,24,126,196 };

 SideChain::SideChain(p2pool* pool, NetworkType type, const char* pool_name)
 	: m_pool(pool)
@@ -97,11 +97,16 @@ SideChain::SideChain(p2pool* pool, NetworkType type, const char* pool_name)
 	  << m_unclePenalty    << '\0';

 	constexpr char default_config[] = "mainnet\0" "default\0" "\0" "10\0" "100000\0" "2160\0" "20\0";
+	constexpr char mini_config[] = "mainnet\0" "mini\0" "\0" "10\0" "100000\0" "2160\0" "20\0";

 	// Hardcoded default consensus ID
 	if (memcmp(buf, default_config, sizeof(default_config) - 1) == 0) {
 		m_consensusId.assign(default_consensus_id, default_consensus_id + HASH_SIZE);
 	}
+	// Hardcoded mini consensus ID
+	else if (memcmp(buf, mini_config, sizeof(mini_config) - 1) == 0) {
+		m_consensusId.assign(mini_consensus_id, mini_consensus_id + HASH_SIZE);
+	}
 	else {
 		const randomx_flags flags = randomx_get_flags();
 		randomx_cache* cache = randomx_alloc_cache(flags | RANDOMX_FLAG_LARGE_PAGES);
@@ -477,6 +482,11 @@ bool SideChain::add_external_block(PoolBlock& block, std::vector<hash>& missing_
 			m_watchBlockSidechainId = {};
 			data = m_watchBlock;
 			block_found = true;
+
+			const uint64_t payout = block.get_payout(m_pool->params().m_wallet);
+			if (payout) {
+				LOGINFO(0, log::LightCyan() << "You received a payout of " << log::LightGreen() << log::XMRAmount(payout) << log::LightCyan() << " in block " << log::LightGreen() << data.height);
+			}
 		}
 	}

@@ -532,10 +542,16 @@ void SideChain::add_block(const PoolBlock& block)
 	m_seenWallets[new_block->m_minerWallet.spend_public_key()] = new_block->m_localTimestamp;
 }

-bool SideChain::has_block(const hash& id)
+PoolBlock* SideChain::find_block(const hash& id)
 {
 	MutexLock lock(m_sidechainLock);
-	return m_blocksById.find(id) != m_blocksById.end();
+
+	auto it = m_blocksById.find(id);
+	if (it != m_blocksById.end()) {
+		return it->second;
+	}
+
+	return nullptr;
 }

 void SideChain::watch_mainchain_block(const ChainMain& data, const hash& possible_id)
@@ -785,6 +801,11 @@ bool SideChain::is_default() const
 	return (memcmp(m_consensusId.data(), default_consensus_id, HASH_SIZE) == 0);
 }

+bool SideChain::is_mini() const
+{
+	return (memcmp(m_consensusId.data(), mini_consensus_id, HASH_SIZE) == 0);
+}
+
 bool SideChain::split_reward(uint64_t reward, const std::vector<MinerShare>& shares, std::vector<uint64_t>& rewards)
 {
 	const size_t num_shares = shares.size();
@@ -965,7 +986,8 @@ void SideChain::verify_loop(PoolBlock* block)

 			// This block is now verified

-			if (is_longer_chain(highest_block, block)) {
+			bool is_alternative;
+			if (is_longer_chain(highest_block, block, is_alternative)) {
 				highest_block = block;
 			}
 			else if (highest_block && (highest_block->m_sidechainHeight > block->m_sidechainHeight)) {
@@ -1310,7 +1332,8 @@ void SideChain::update_chain_tip(PoolBlock* block)
 		return;
 	}

-	if (is_longer_chain(m_chainTip, block)) {
+	bool is_alternative;
+	if (is_longer_chain(m_chainTip, block, is_alternative)) {
 		difficulty_type diff;
 		if (get_difficulty(block, m_difficultyData, diff)) {
 			m_chainTip = block;
@@ -1323,6 +1346,12 @@ void SideChain::update_chain_tip(PoolBlock* block)
 			block->m_wantBroadcast = true;
 			if (m_pool) {
 				m_pool->update_block_template_async();
+
+				// Reset stratum share counters when switching to an alternative chain to avoid confusion
+				StratumServer* s = m_pool->stratum_server();
+				if (s && is_alternative) {
+					s->reset_share_counters();
+				}
 			}
 			prune_old_blocks();
 		}
@@ -1385,8 +1414,10 @@ PoolBlock* SideChain::get_parent(const PoolBlock* block)
 	return nullptr;
 }

-bool SideChain::is_longer_chain(const PoolBlock* block, const PoolBlock* candidate)
+bool SideChain::is_longer_chain(const PoolBlock* block, const PoolBlock* candidate, bool& is_alternative)
 {
+	is_alternative = false;
+
 	if (!candidate || !candidate->m_verified || candidate->m_invalid) {
 		return false;
 	}
@@ -1429,6 +1460,8 @@ bool SideChain::is_longer_chain(const PoolBlock* block, const PoolBlock* candida
 	}

 	// They're on totally different chains. Compare total difficulties over the last m_chainWindowSize blocks
+	is_alternative = true;
+
 	difficulty_type block_total_diff;
 	difficulty_type candidate_total_diff;

@@ -51,7 +51,7 @@ public:
 	void add_block(const PoolBlock& block);
 	void get_missing_blocks(std::vector<hash>& missing_blocks);

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

 	bool get_block_blob(const hash& id, std::vector<uint8_t>& blob);
@@ -71,6 +71,7 @@ public:
 	uint64_t miner_count();
 	time_t last_updated() const;
 	bool is_default() const;
+	bool is_mini() const;

 	const PoolBlock* chainTip() const { return m_chainTip; }

@@ -90,7 +91,7 @@ private:
 	PoolBlock* get_parent(const PoolBlock* block);

 	// Checks if "candidate" has longer (higher difficulty) chain than "block"
-	bool is_longer_chain(const PoolBlock* block, const PoolBlock* candidate);
+	bool is_longer_chain(const PoolBlock* block, const PoolBlock* candidate, bool& is_alternative);
 	void update_depths(PoolBlock* block);
 	void prune_old_blocks();

@@ -439,6 +439,13 @@ void StratumServer::print_status()
 	print_stratum_status();
 }

+void StratumServer::reset_share_counters()
+{
+	m_cumulativeHashesAtLastShare = 0;
+	m_cumulativeFoundSharesDiff = 0.0;
+	m_totalFoundShares = 0;
+}
+
 void StratumServer::print_stratum_status() const
 {
 	uint64_t hashes_15m, hashes_1h, hashes_24h, total_hashes;
@@ -473,8 +480,9 @@ void StratumServer::print_stratum_status() const
 	const uint64_t hashrate_24h = (dt_24h > 0) ? (hashes_24h / dt_24h) : 0;

 	double average_effort = 0.0;
-	if (m_cumulativeFoundSharesDiff > 0.0) {
-		average_effort = static_cast<double>(m_cumulativeHashesAtLastShare) * 100.0 / m_cumulativeFoundSharesDiff;
+	const double diff = m_cumulativeFoundSharesDiff;
+	if (diff > 0.0) {
+		average_effort = static_cast<double>(m_cumulativeHashesAtLastShare) * 100.0 / diff;
 	}

 	LOGINFO(0, "status" <<
@@ -516,6 +524,8 @@ void StratumServer::on_blobs_ready()

 	size_t numClientsProcessed = 0;
 	uint32_t extra_nonce = 0;
+
+	const time_t cur_time = time(nullptr);
 	{
 		MutexLock lock2(m_clientsListLock);

@@ -523,7 +533,12 @@ void StratumServer::on_blobs_ready()
 			++numClientsProcessed;

 			if (!client->m_rpcId) {
-				// Not logged in yet, on_login() will send the job to this client
+				// Not logged in yet, on_login() will send the job to this client. Also close inactive connections.
+				if (cur_time >= client->m_connectedTime + 10) {
+					LOGWARN(4, "client " << static_cast<char*>(client->m_addrString) << " didn't send login data");
+					client->ban(DEFAULT_BAN_TIME);
+					client->close();
+				}
 				continue;
 			}

@@ -760,6 +775,7 @@ void StratumServer::on_after_share_found(uv_work_t* req, int /*status*/)

 StratumServer::StratumClient::StratumClient()
 	: m_rpcId(0)
+	, m_connectedTime(0)
 	, m_jobs{}
 	, m_perConnectionJobId(0)
 	, m_customDiff{}
@@ -776,12 +792,19 @@ void StratumServer::StratumClient::reset()
 {
 	Client::reset();
 	m_rpcId = 0;
+	m_connectedTime = 0;
 	memset(m_jobs, 0, sizeof(m_jobs));
 	m_perConnectionJobId = 0;
 	m_customDiff = {};
 	m_customUser.clear();
 }

+bool StratumServer::StratumClient::on_connect()
+{
+	m_connectedTime = time(nullptr);
+	return true;
+}
+
 bool StratumServer::StratumClient::on_read(char* data, uint32_t size)
 {
 	if ((data != m_readBuf + m_numRead) || (data + size > m_readBuf + sizeof(m_readBuf))) {
@@ -1013,8 +1036,9 @@ void StratumServer::api_update_local_stats(time_t timestamp)
 	const uint64_t hashrate_24h = (dt_24h > 0) ? (hashes_24h / dt_24h) : 0;

 	double average_effort = 0.0;
-	if (m_cumulativeFoundSharesDiff > 0.0) {
-		average_effort = static_cast<double>(m_cumulativeHashesAtLastShare) * 100.0 / m_cumulativeFoundSharesDiff;
+	const double diff = m_cumulativeFoundSharesDiff;
+	if (diff > 0.0) {
+		average_effort = static_cast<double>(m_cumulativeHashesAtLastShare) * 100.0 / diff;
 	}

 	int shares_found = m_totalFoundShares;
@@ -45,7 +45,7 @@ public:
 		static Client* allocate() { return new StratumClient(); }

 		void reset() override;
-		bool on_connect() override { return true; }
+		bool on_connect() override;
 		bool on_read(char* data, uint32_t size) override;

 		bool process_request(char* data, uint32_t size);
@@ -53,6 +53,7 @@ public:
 		bool process_submit(rapidjson::Document& doc, uint32_t id);

 		uint32_t m_rpcId;
+		time_t m_connectedTime;

 		uv_mutex_t m_jobsLock;

@@ -74,6 +75,8 @@ public:

 	void print_status() override;

+	void reset_share_counters();
+
 private:
 	void print_stratum_status() const;

@@ -48,6 +48,7 @@ public:
 	virtual void on_connect_failed(bool is_v6, const raw_ip& ip, int port);

 	void ban(const raw_ip& ip, uint64_t seconds);
+	virtual void print_bans();

 	struct Client
 	{
@@ -95,9 +96,9 @@ public:

 	struct WriteBuf
 	{
-		Client* m_client;
-		uv_write_t m_write;
-		char m_data[WRITE_BUF_SIZE];
+		Client* m_client = nullptr;
+		uv_write_t m_write = {};
+		std::vector<uint8_t> m_data;
 	};

 	uv_mutex_t m_writeBuffersLock;
@@ -160,7 +161,7 @@ protected:
 	uint32_t m_numIncomingConnections;

 	uv_mutex_t m_bansLock;
-	unordered_map<raw_ip, time_t> m_bans;
+	unordered_map<raw_ip, std::chrono::steady_clock::time_point> m_bans;

 	bool is_banned(const raw_ip& ip);

@@ -322,11 +322,13 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::on_connect_failed(bool, const raw
 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
 bool TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::is_banned(const raw_ip& ip)
 {
+	const auto cur_time = std::chrono::steady_clock::now();
+
 	MutexLock lock(m_bansLock);

 	auto it = m_bans.find(ip);
 	if (it != m_bans.end()) {
-		const bool banned = (time(nullptr) < it->second);
+		const bool banned = (cur_time < it->second);
 		if (!banned) {
 			m_bans.erase(it);
 		}
@@ -435,14 +437,14 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::shutdown_tcp()

 	using namespace std::chrono;

-	const system_clock::time_point start_time = system_clock::now();
+	const auto start_time = steady_clock::now();
 	int64_t counter = 0;
 	uv_async_t asy;

 	constexpr uint32_t timeout_seconds = 30;

 	while (!m_loopStopped) {
-		const int64_t elapsed_time = duration_cast<milliseconds>(system_clock::now() - start_time).count();
+		const int64_t elapsed_time = duration_cast<milliseconds>(steady_clock::now() - start_time).count();

 		if (elapsed_time >= (counter + 1) * 1000) {
 			++counter;
@@ -493,8 +495,34 @@ void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::print_status()
 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
 void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::ban(const raw_ip& ip, uint64_t seconds)
 {
+	const auto ban_time = std::chrono::steady_clock::now() + std::chrono::seconds(seconds);
+
 	MutexLock lock(m_bansLock);
-	m_bans[ip] = time(nullptr) + seconds;
+	m_bans[ip] = ban_time;
+}
+
+template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
+void TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::print_bans()
+{
+	using namespace std::chrono;
+	const auto cur_time = steady_clock::now();
+
+	std::vector<std::pair<raw_ip, std::chrono::steady_clock::time_point>> bans;
+	{
+		MutexLock lock(m_bansLock);
+
+		bans.reserve(m_bans.size());
+		for (const auto& b : m_bans) {
+			bans.emplace_back(std::make_pair(b.first, b.second));
+		}
+	}
+
+	for (const auto& b : bans) {
+		if (cur_time < b.second) {
+			const uint64_t t = duration_cast<seconds>(b.second - cur_time).count();
+			LOGINFO(0, b.first << " is banned (" << t << " seconds left)");
+		}
+	}
 }

 template<size_t READ_BUF_SIZE, size_t WRITE_BUF_SIZE>
@@ -520,10 +548,12 @@ bool TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::send_internal(Client* client, Sen
 		buf = new WriteBuf();
 	}

-	const size_t bytes_written = callback(buf->m_data);
+	// callback_buf is used in only 1 thread, so it's safe
+	static uint8_t callback_buf[WRITE_BUF_SIZE];
+	const size_t bytes_written = callback(callback_buf);

-	if (bytes_written > sizeof(buf->m_data)) {
-		LOGERR(0, "send callback wrote " << bytes_written << " bytes, expected no more than " << sizeof(buf->m_data) << " bytes");
+	if (bytes_written > WRITE_BUF_SIZE) {
+		LOGERR(0, "send callback wrote " << bytes_written << " bytes, expected no more than " << WRITE_BUF_SIZE << " bytes");
 		panic();
 	}

@@ -538,9 +568,11 @@ bool TCPServer<READ_BUF_SIZE, WRITE_BUF_SIZE>::send_internal(Client* client, Sen

 	buf->m_client = client;
 	buf->m_write.data = buf;
+	buf->m_data.reserve(round_up(bytes_written, 64));
+	buf->m_data.assign(callback_buf, callback_buf + bytes_written);

 	uv_buf_t bufs[1];
-	bufs[0].base = buf->m_data;
+	bufs[0].base = reinterpret_cast<char*>(buf->m_data.data());
 	bufs[0].len = static_cast<int>(bytes_written);

 	const int err = uv_write(&buf->m_write, reinterpret_cast<uv_stream_t*>(&client->m_socket), bufs, 1, Client::on_write);
@@ -32,7 +32,7 @@ namespace p2pool {
 #define STR2(X) STR(X)
 #define STR(X) #X

-const char* VERSION = "v1.4.0 (built"
+const char* VERSION = "v1.8 (built"
 #if defined(__clang__)
 	" with clang/" __clang_version__
 #elif defined(__GNUC__)
@@ -79,7 +79,7 @@ static_assert(rev_alphabet.num_symbols == 58, "Check alphabet");

 namespace p2pool {

-Wallet::Wallet(const char* address)
+Wallet::Wallet(const char* address) : m_prefix(0), m_checksum(0), m_type(NetworkType::Invalid)
 {
 	decode(address);
 }
@@ -1,6 +1,8 @@
 cmake_minimum_required(VERSION 2.8.12)
 project(p2pool_tests)

+option(STATIC_LIBS "Use locally built libuv and libzmq static libs" OFF)
+
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_CXX_STANDARD 14)
@@ -86,6 +88,7 @@ set(SOURCES
 	../src/log.cpp
 	../src/memory_leak_debug.cpp
 	../src/mempool.cpp
+	../src/miner.cpp
 	../src/p2p_server.cpp
 	../src/p2pool.cpp
 	../src/p2pool_api.cpp
@@ -118,17 +121,28 @@ elseif (NOT APPLE)
 	set(LIBS ${LIBS} pthread gss dl)
 endif()

-if (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
-	find_library(ZMQ_LIBRARY_DEBUG NAMES libzmq-v142-mt-sgd-4_3_5 PATHS "../external/lib/libzmq/Debug")
-	find_library(ZMQ_LIBRARY NAMES libzmq-v142-mt-s-4_3_5 PATHS "../external/lib/libzmq/Release")
-	find_library(UV_LIBRARY_DEBUG NAMES uv_a PATHS "../external/lib/libuv/Debug")
-	find_library(UV_LIBRARY NAMES uv_a PATHS "../external/lib/libuv/Release")
-elseif (CMAKE_CXX_COMPILER_ID MATCHES GNU OR CMAKE_CXX_COMPILER_ID MATCHES Clang)
-	find_library(ZMQ_LIBRARY_DEBUG NAMES zmq libzmq.a)
-	find_library(ZMQ_LIBRARY NAMES zmq libzmq.a)
-	find_library(UV_LIBRARY_DEBUG NAMES uv libuv.a)
-	find_library(UV_LIBRARY NAMES uv libuv.a)
-	find_library(SODIUM_LIBRARY sodium)
+if (STATIC_LIBS)
+	set(ZMQ_LIBRARY "${CMAKE_SOURCE_DIR}/../external/src/libzmq/build/lib/libzmq.a")
+	set(ZMQ_LIBRARY_DEBUG "${CMAKE_SOURCE_DIR}/../external/src/libzmq/build/lib/libzmq.a")
+	set(UV_LIBRARY_DEBUG "${CMAKE_SOURCE_DIR}/../external/src/libuv/build/libuv_a.a")
+	set(UV_LIBRARY "${CMAKE_SOURCE_DIR}/../external/src/libuv/build/libuv_a.a")
+else()
+	if (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+		find_library(ZMQ_LIBRARY_DEBUG NAMES libzmq-v142-mt-sgd-4_3_5 PATHS "../external/lib/libzmq/Debug")
+		find_library(ZMQ_LIBRARY NAMES libzmq-v142-mt-s-4_3_5 PATHS "../external/lib/libzmq/Release")
+		find_library(UV_LIBRARY_DEBUG NAMES uv_a PATHS "../external/lib/libuv/Debug")
+		find_library(UV_LIBRARY NAMES uv_a PATHS "../external/lib/libuv/Release")
+	elseif (CMAKE_CXX_COMPILER_ID MATCHES GNU OR CMAKE_CXX_COMPILER_ID MATCHES Clang)
+		find_library(ZMQ_LIBRARY_DEBUG NAMES zmq libzmq.a)
+		find_library(ZMQ_LIBRARY NAMES zmq libzmq.a)
+		find_library(UV_LIBRARY_DEBUG NAMES uv libuv.a)
+		find_library(UV_LIBRARY NAMES uv libuv.a)
+		find_library(SODIUM_LIBRARY sodium)
+	endif()
+
+	if (SODIUM_LIBRARY)
+		set(LIBS ${LIBS} ${SODIUM_LIBRARY})
+	endif()
 endif()

 find_library(PGM_LIBRARY pgm)
@@ -142,10 +156,6 @@ if (NORM_LIBRARY)
 	set(LIBS ${LIBS} ${NORM_LIBRARY})
 endif()

-if (SODIUM_LIBRARY)
-	set(LIBS ${LIBS} ${SODIUM_LIBRARY})
-endif()
-
 add_definitions(/DZMQ_STATIC /DP2POOL_LOG_DISABLE)

 add_executable(${CMAKE_PROJECT_NAME} ${HEADERS} ${SOURCES})
@@ -17,6 +17,8 @@

 #include "gtest/gtest.h"

+void p2pool_usage() {}
+
 int main(int argc, char** argv)
 {
 	testing::InitGoogleTest(&argc, argv);
@@ -125,7 +125,7 @@ TEST(pool_block, verify)
 		p += n;

 		sidechain.add_block(b);
-		ASSERT_TRUE(sidechain.has_block(b.m_sidechainId));
+		ASSERT_TRUE(sidechain.find_block(b.m_sidechainId) != nullptr);
 	}

 	const PoolBlock* tip = sidechain.chainTip();
Author	SHA1	Message	Date
SChernykh	0db57e5047	p2pool v1.8	2022-02-27 19:56:47 +01:00
SChernykh	e7919514d4	TCPServer: fixed uninitialized variables	2022-02-25 15:31:35 +01:00
SChernykh	7ab21c6afd	TCPServer: reduced memory usage	2022-02-23 17:07:50 +01:00
SChernykh	2209e0cc70	P2PServer: relaxed peer list request restriction	2022-02-22 11:06:12 +01:00
SChernykh	a73b4616a4	Fixed Coverity issues	2022-02-22 00:38:08 +01:00
SChernykh	9593311332	Added `bans` console command	2022-02-21 19:59:57 +01:00
SChernykh	9a09d15bea	P2PServer: use high_resolution_clock for ping time	2022-02-21 18:46:53 +01:00
SChernykh	f082488e4b	TCPServer: use steady_clock for bans	2022-02-21 18:41:36 +01:00
SChernykh	c56773d4d6	Update cppcheck.yml	2022-02-21 16:59:32 +01:00
SChernykh	752e2381d6	P2PServer: added more protocol checks	2022-02-21 16:54:53 +01:00
SChernykh	03f829e18c	Fixed formatting	2022-02-21 10:05:47 +01:00
Hayden Cardwell	06b66c99db	Cleanup/Re-work of README	2022-02-21 09:55:14 +01:00
SChernykh	0b0ad9ff82	Fix tests compilation	2022-02-21 09:32:32 +01:00
SChernykh	de9f13d393	Check for unknown command line parameters	2022-02-21 08:02:36 +01:00
SChernykh	272d206741	stats_mod api: updated min payout value	2022-02-20 17:08:27 +01:00
SChernykh	c9493ec7fa	Merge pull request #123 from bladedoyle/mini Support mini pool. Cleanup	2022-02-20 16:16:10 +01:00
Blade Doyle	5ef4134955	Support mini pool. Cleanup	2022-02-19 15:27:37 -08:00
SChernykh	8045c40026	Check for proper `--local-api` usage	2022-02-18 16:21:28 +01:00
SChernykh	d4a1b14820	Use monerod peers to find p2pool nodes	2022-02-17 22:10:52 +01:00
SChernykh	cc6ce4a366	Reset stratum share counters after initial sync	2022-02-17 11:19:11 +01:00
SChernykh	25e5f80a81	Merge pull request #121 from hayden-cardwell/master Add a link to SethForPrivacy's Linux guide	2022-02-17 09:48:00 +01:00
Hayden Cardwell	d4b339b1a3	Add a link to SethForPrivacy's Linux guide Added a link to SethForPrivacy's guide within the Linux instructions, to potentially assist those who may need a bit more hand holding, or followed his previous guide to deploy a node.	2022-02-16 18:14:51 -06:00
SChernykh	4bdd524d84	Merge pull request #120 from SChernykh/tmp MacOS CI: build and static link libuv and libzmq	2022-02-16 12:20:05 +01:00
SChernykh	b78fe02405	MacOS CI: build and static link libuv and libzmq	2022-02-16 11:27:34 +01:00
SChernykh	dfa0c7ffb1	Merge pull request #119 from SamsungGalaxyPlayer/patch-3 Add monero.com to list of compatible wallets	2022-02-15 21:33:00 +01:00
Justin Ehrenhofer	ec97a14da7	Add monero.com to list of compatible wallets Monero.com used the 4.2.8 Cake Wallet base, so all versions of that app are compatible	2022-02-15 10:06:35 -06:00
SChernykh	3a2e9e8b94	Merge pull request #117 from SamsungGalaxyPlayer/patch-1 Remove outdated note to "current" version	2022-02-15 17:03:45 +01:00
Justin Ehrenhofer	069c96aa1d	Remove outdated note to "current" version	2022-02-15 09:55:05 -06:00
SChernykh	42370bf11e	p2pool v1.7	2022-02-14 19:29:55 +01:00
SChernykh	dc506bb1b9	Update README.md	2022-02-14 14:08:36 +01:00
SChernykh	ec2f4467fb	Added `--mini` command line option to connect to p2pool-mini	2022-02-14 13:57:59 +01:00
SChernykh	9f449320b5	StartumServer: disconnect and ban inactive clients	2022-02-08 15:00:08 +01:00
SChernykh	8767ef9e19	Display payout amount when a block is found	2022-01-29 17:09:43 +01:00
SChernykh	cf184295b4	Updated version	2022-01-26 19:42:49 +01:00
SChernykh	0cd9876a46	Updated dependencies	2022-01-25 00:05:38 +01:00
SChernykh	1e4e4bd08e	Added miner statistics to data api	2022-01-24 10:42:21 +01:00
SChernykh	a640e41d74	Improved RNG initialization	2022-01-24 00:37:39 +01:00
SChernykh	f90e00edea	Moved "how to mine" up in the readme	2022-01-23 15:55:57 +01:00
SChernykh	38ffd73b54	Fixed new Coverity issue	2022-01-23 13:03:56 +01:00
SChernykh	c10a5ce323	Miner code cleanup	2022-01-23 11:03:26 +01:00
SChernykh	e2931f94b5	Added embedded miner	2022-01-22 23:30:19 +01:00
SChernykh	95c268be4c	Update msvc-analysis.yml	2022-01-20 13:41:38 +01:00
SChernykh	4ac4f8f860	Update README.md XMR block reward has decreased, so minimum payout is now ~0.0003 XMR	2022-01-20 13:22:34 +01:00
SChernykh	248fcee174	Update version	2022-01-09 17:19:20 +01:00
SChernykh	89bcceb986	Added p2pool mini seed nodes and default port	2021-12-30 11:10:18 +01:00
SChernykh	2b01350add	Added `outpeers` and `inpeers` console commands	2021-12-26 15:28:33 +01:00
SChernykh	f1b6212c82	P2PServer: add connection limits #87 Added `--out-peers` and `--in-peers` command line options.	2021-12-26 14:59:45 +01:00
SChernykh	7d961ab3b9	Merge pull request #89 from bladedoyle/monero_p2pool_support Monero latest release supports p2pool	2021-12-24 22:40:54 +01:00
Blade Doyle	862e7d965b	Monero latest release supports p2pool	2021-12-24 11:38:53 -08:00
SChernykh	da2d9f7e2e	Update README.md	2021-12-07 19:11:51 +01:00