P2Pool solves a problem the previous Stratum schema only hinted at: traditional pools are centralized choke points. A handful of operators control most of Monero's hashrate, decide which transactions to include, hold miner funds in custody, and can be coerced, hacked, or attack the network themselves. P2Pool eliminates the operator entirely by replacing the pool's database with a sidechain — a separate blockchain where every share is a real block, and payouts are settled trustlessly in the Monero coinbase itself.
The previous Stratum schema described how a pool dispatches jobs and aggregates shares. What it glossed over is the structural issue with that model: the pool operator is a single point of trust. They choose which transactions to include in blocks, hold the rewards before paying miners out, and can — as the August 2025 selfish-mining incident on Monero demonstrated — actively attack the network they're supposed to secure. Solo mining avoids this but punishes small miners with brutal income variance. P2Pool is the third option.
The same developer (also known as sech1) who co-authored RandomX. He took P2Pool — a concept attempted on Bitcoin in 2011 and largely abandoned — fixed its critical orphan-block problem with uncle blocks, and rebuilt the whole thing from scratch in C++. Launched October 2021. By 2024 it was carrying a meaningful chunk of Monero's network hashrate.
P2Pool runs its own blockchain — the sharechain. It has its own blocks, its own difficulty, its own ~10-second target time. Crucially, both chains use the same RandomX proof of work. A miner hashing a Monero block template is simultaneously testing it against two difficulty targets: the easy one (sharechain) and the hard one (Monero). The same hash satisfies whichever target it falls below.
A P2Pool miner runs three processes locally. There is no remote pool server — your laptop is the pool. The three processes chain together: monerod gives you the chain state, p2pool builds block templates including payouts to PPLNS-window miners, XMRig hashes them.
Your local Monero full node. Holds the chain, the mempool, gossips with peers. The same daemon described in the P2P schema. Note: must be a full node, not a remote — P2Pool builds templates from your mempool view.
The sidechain daemon. Connects to your monerod, gossips with other P2Pool peers worldwide on its own P2P network, maintains the sharechain, and pretends to be a Stratum pool for your local XMRig.
The actual miner. Identical to the XMRig you'd run with a centralized pool — it sees P2Pool as just another Stratum server. Same login / submit flow from the prior Stratum schema.
Your existing miner doesn't know it's mining on a sidechain. P2Pool implements the same JSON-RPC Stratum dialect the Stratum schema documented — login, getjob, submit, keepalived. The only difference is the target values it ships, which correspond to the sharechain difficulty instead of an arbitrary pool difficulty. This is by design: any existing miner works.
In a traditional pool, a "share" is just a database row in the pool operator's ledger. In P2Pool, a share is a real block on the sharechain — gossiped over a P2P network, validated by every node, with its own proof of work. Each share is also a complete Monero block template with a coinbase that pays out to every miner currently in the PPLNS window. If the proof of work happens to also satisfy the Monero network target, that template gets relayed to monerod as an actual Monero block, and those payouts settle on the main chain.
Your p2pool daemon asks your local monerod for a block template, then modifies the coinbase to include payouts to every miner with shares in the current PPLNS window — proportional to share difficulty.
Your miner runs RandomX on the template, iterating the nonce just like in the Stratum schema. Each hash is checked against both targets: sharechain (easy) and Monero (hard).
If the hash < sharechain target, you found a sharechain block. It's broadcast over the P2Pool P2P network. Every other P2Pool node validates and appends it. You now have one share in the PPLNS window.
If the hash < Monero target (much rarer), the template is a real Monero block. P2Pool submits it to monerod via submit_block. Everyone in the PPLNS window — including you — gets paid in the coinbase.
Bitcoin's P2Pool failed because of orphans: with a 10-second block time and global gossip, two miners would constantly find the same-height block independently and one would be discarded — wasting that miner's work. Monero's P2Pool borrowed Ethereum's solution: uncle blocks. If two shares are found at the same height, one becomes the main share and the other becomes its uncle. The uncle is included in the next block's references, earns its miner credit (worth ~80% of a regular share), and counts in the PPLNS window. Almost no work is wasted.
Miner A and Miner B both find a sharechain block at height H within a few seconds. Network sees both. Only one can be on the main chain.
By tie-breaking rules (typically first-seen), one block becomes the main share at height H. The other is recorded as its uncle. Uncles can be up to 3 blocks behind and still be included.
The uncle's miner gets credit (~80% of a full share). Their work isn't wasted. This is what makes 10-second blocks workable on a global P2P network.
When P2Pool finds a Monero block, the coinbase transaction inside it has not one output but typically tens to hundreds — one for each unique miner address in the PPLNS window. Each output's amount is the Monero block reward × (that miner's share difficulty / total PPLNS difficulty). This is final, on-chain, non-reversible the moment the Monero block is accepted. There is no separate payout step.
The minimum payout floor (~0.00027 XMR) exists because every miner in the window must get a tx output, and outputs have a non-zero size cost. Below that floor, including the output would cost more in tx bytes than it pays out. Miners whose share contribution rounds below the floor get nothing this round — but their shares typically remain in the window for the next block, so the credit isn't lost over time.
P2Pool is not strictly better than centralized pools — it has real trade-offs. The big ones: you need a minimum hashrate to make sense, and you need to run more local infrastructure. The decision is mostly about your priorities.
| Property | Centralized pool | P2Pool | Solo |
|---|---|---|---|
| Fee | 1–2% typical | 0% | 0% |
| Custody | Pool holds funds | Never — paid in coinbase | You hold immediately |
| Payout cadence | Hours / threshold | ~hours (when block found) | Days to weeks for small miners |
| Variance | Low | Low–medium | Extreme |
| Min effective hashrate | Any | ~1 kH/s recommended (mini sidechain) | ~1 MH/s+ to see income |
| Local infrastructure | None | Full monerod + p2pool daemon | Full monerod |
| Decides what to mine | Pool operator | You | You |
| Censorship resistance | Weak | Strong — every miner sets their own template | Strong |
| Network centralization impact | High (single operator's hashrate) | Low (distributed across nodes) | None |
The default P2Pool sidechain has a fairly high difficulty target — if your miner is below ~1-2 kH/s, you'll wait a long time between shares. P2Pool mini is a separate sidechain (same code, --mini flag) with lower difficulty, smaller blocks, and faster shares. Useful for laptops, single-board computers, low-end hardware. Same trustless properties; just a smaller pool.
P2Pool isn't just a nice-to-have for miners. It's structurally important to Monero in ways that go beyond payout convenience. A privacy coin where 60% of new blocks come from one company's servers is one subpoena away from a censorship event. A privacy coin where blocks come from thousands of independent home miners — each picking their own transactions, each holding their own monerod, each beyond any single jurisdiction — is much harder to leverage.
Every P2Pool miner builds their own block template from their own monerod's mempool. There is no central decision about which transactions land in blocks. Compares favorably to large pools that may filter txs.
The August 2025 selfish-mining incident — where a pool exploited timing to do short reorgs — would have been impossible with P2Pool, because the "pool" has no central decision-maker to coordinate the attack.
RandomX exists to make Monero mining CPU-friendly and accessible. Centralized pools partially undermined that goal by concentrating economic control. P2Pool restores it — solo-grade decentralization with pool-grade variance.