Welcome!

   c2pool is a mining pool for Dash with no operator. It pays miners from the coinbase of the blocks they find, the way p2pool does, so nobody holds anyone else’s coins. It is a new node written from scratch in C++. It runs as one program, with no Dash Core behind it.

   The earlier proposal for this work, c2pool-daemonless-finalize (fa758340f1bd2391d17bb43667f76c5d9070d737b68e018e42ed75b09c6ba631, 2 x 125.5 DASH), reached the funding threshold only after the last superblock inside its window had passed (2558864, October 21). The next superblock, 2575480, falls after that proposal’s end date (November 4), so it will never be paid. The window was too short. That was my mistake.

   This proposal asks for 252 DASH, paid once at superblock 2575480. That is the 251 DASH of the unpaid proposal plus the 1 DASH collateral it burned. Most of the work is already done, and it can be checked on the chain.

   What you can check

1. No dashd on the serving path. As of November 2, the daemon-less nodes have found 79 blocks since October 22, 78 of them already confirmed. Each one carries /P2Pool-DASH/c2pool/ in the coinbase: https://mnowatch.org/blocks/?search=c2pool.
2. My p2pool codebase pools are also running along and extracting blocks too https://mnowatch.org/blocks/?search=P2Pool. Each one carries /P2Pool-Dash in the coinbase
3. Superblock coinbase without dashd. At superblock 2558864 a daemon-less node built its template from its own state and recorded it before the block arrived. The coinbase value matched the mined block to the duff, and so did every treasury output, the masternode payment and the masternode list root. Only the miner’s own payout differed.
4. The same UTXO set as Dash Core. The node now keeps the full UTXO set. It was loaded at height 2,564,044 only after its MuHash matched two independent Dash Core nodes, and it has followed the chain block by block since.
5. Cold start. A new node with an empty data directory rebuilds the masternode list from a compiled anchor in about a minute and starts handing out work.
6. Dash P2P on its own. The node finds its own peers and listens on IPv6.
7. In the Dash docs. docs.dash.org now lists c2pool, the C++ reimplementation, among the community forks of p2pool (dashpay/docs #587): https://docs.dash.org/en/stable/docs/user/mining/p2pool.html#community-forks. There are signed releases, v0.2.7 and v0.2.8.
8. Current with Dash Core. Dash Core 23.1.9 was released on October 29, and its changes were ported into the node the next day (PR #2100). Dash Core 23.1.10 was released on November 2. I went through every source change in it. The node needs no change:

• • The governance fix changes how masternodes vote on superblock triggers. The c2pool node does not vote, and the rule that picks the winning trigger is unchanged.
  • The BLS fix hardens batch verification. The node verifies each ChainLock and InstantSend signature on its own, not in batches.
  • The DKG fixes apply to masternodes taking part in a quorum. The node only checks the final commitments mined in blocks, and their rules did not change.

   If you run a masternode, please upgrade to 23.1.10 before superblock 2575480 (around November 20). It fixes a bug that could keep a superblock from paying any proposal, this one included.

   Transactions injected into a running node

   The node accepts a signed transaction over its local control API and carries it in its own block template. The node holds no keys. Transactions are signed on an offline machine. No restart is needed for the injection itself; a one-time restart earlier installed the control-plane credential.

   Two examples, both with zero fee, which ordinary nodes will not relay:

• Block 2565253 carries a consolidation of 189 small outputs (539aa4b7aeceeb17c302cd51f402f3371f527ef73178466b5e3c2f80b9b40a28).
  Block 2565421 carries the collateral of this proposal (639a53cfa9f19f16414a9dd679ebfdc930633e18eedd8cd5f06ff4a90925b705). It was mined about 17 minutes after it was submitted.

   Also built, at no extra cost

• An offline signer that builds and signs these transactions and signs messages, so keys never sit on a networked machine. It signed both transactions above and the ownership message for this page.
• Miner alerts carried over the pool’s own P2P network, so a stopped rig is reported even where messaging services are blocked.
• A v36 sharechain for Dash. Shares commit to the block’s transactions, so a found block is rebuilt in full.
• Hardening. Line limits on stratum, local-only logs and control endpoints, and masked miner and peer addresses on public dashboards.

   What remains

• Compact block reception.
• Fourteen days of sustained daemon-less mining. That window completes on November 5. I will post each one here when it lands.

   If you abstained

You do not have to trust me. Three checks take a few minutes:

• The MNOWATCH list above: the blocks, the dates, the ChainLocks.
• Block 2565421: the second transaction is this proposal’s collateral, with zero fee with the miner's consent.
• The code: https://github.com/frstrtr/c2pool

   If they hold, a yes vote pays for work that is already done.

   The ask

   252 DASH, once, to XdgF55wEHBRWwbuBniNYH4GvvaoYMgL84u. That is the pool’s own address. Every block the pool finds (~2800 transactions - mostly dust around 1 dashtoshi at this moment) already puts a small output there, so the work and the funding sit on one address you can check.

   The C++ engine is covered by an open-source grant. The treasury pays only for the Dash-specific part. The hardest part was independent Dash consensus.

   To vote yes:

gobject vote-many c7b462b7c8d81df10ce34ebd4436afd715f288c25a7c949835f889015248b247 funding yes

Code: https://github.com/frstrtr/c2pool
Pool: https://dash.voidbind.com
Forum: https://www.dash.org/forum/threads/69511/