Pools

At the difficulty of 20 October 2026, a single H100 GPU mining alone would find a block about once every 218 days, on average, and it could easily wait twice that. Most people can’t live with that kind of lottery.

So, as in Bitcoin, miners join a mining pool. Everyone mines for the pool, the pool wins blocks far more often than any one member could, and it splits the rewards by how much work each member did. Pearl adds one twist: the pool’s software also has to turn each winning ticket into the block’s zero-knowledge certificate.

Try it

Enter a GPU’s speed to see how long it would take to find a block on its own.

What is a share?

A share is a ticket that beats an easier target, one the pool sets low enough that each member finds shares regularly. Shares don’t win blocks; they’re evidence of work. The pool counts them to decide each member’s cut. Now and then a share also beats the network’s real bar, and that one wins a block.

On Pearl, the checking happens in layers:

1. On the GPU

   Every ticket is compared on the chip with the job’s target, which the gateway has already converted to the rank-penalized form. Almost all are discarded.

2. At the pool

   A ticket that passes is sent as a plain proof: the sizes, the rank, and the tile’s real rows of A and columns of B, as the 1 KiB chunks that contain them, plus Merkle paths to the matrix fingerprints. The pool verifies the paths, regenerates the noise, recomputes the tile’s diary and ticket, and compares it with the share target. Pearl’s verifier has a parameter for exactly this, an override target to use instead of the block’s.

3. For a block

   If the ticket also beats the network’s bar, the pool proves it in zero knowledge, sets the header’s proof commitment, builds the certificate and submits the block to a node.

Checking a share costs the pool one tile’s worth of arithmetic: at k = 8,192 and a 2 × 64 tile, about a million multiply-accumulates, plus regenerating that tile’s noise. Proving a winning share takes seconds of CPU, but only once per block.

What is the gateway?

pearl-gateway is Pearl’s reference software for the middle box in the picture. Pearl’s miner README calls it the bridge between a Pearl full node and the miner process: it fetches block templates from the node, hands jobs to the GPU miner, checks plain proofs, turns a winning one into a zero-knowledge certificate, and submits the block.

Its job targets are already adjusted for the rank penalty: it refuses a rank below 128 and scales the target by 128/r before the GPU sees it, so the GPU’s on-chip check already follows the rule the network will apply.

Can I mine solo?

Yes. Solo mining means running the whole stack yourself: your own pearld node, the gateway, and a GPU miner. Pearl’s official Docker image for the vLLM miner does exactly this: it starts pearl-gateway in the background, points it at a pearld node’s RPC address, then starts serving the model. Every block you win pays its whole reward to you, and every block you win takes as long as the lottery says.

Pearl also ships a simple CPU miner inside its proof-of-work library. Its own documentation calls it a naive implementation for completeness and testing, not for production.

Who mines Pearl?

The chain itself shows a few things.

Pool tags in coinbases. A coinbase’s input script is free-form space, and pools often sign their blocks there. Block 130,825’s coinbase reads, after the block height and a timestamp, /pool.kryptex.com/, followed by 12 bytes of extranonce:

Its single paying output, 2,238.38373068 PRL, is exactly that block’s subsidy plus the fees of its other 114 transactions. PRLScan labels the block’s miner as Kryptex.

Merged-mining tags. The coinbase of block 130,792 carries the text NOCKCHAIN-AI-POW-AUX and a 32-byte value, and an extra OP_RETURN output starting with the ASCII NAC*. That looks like merged mining: the same work also committed to another chain. That block split its reward 99% / 1% between two Taproot outputs. In a 200-block sample, the eight coinbase-only blocks that left out the witness commitment all came from this miner.

Independent counts. Sites such as MiningBoard and PRLScan publish pool statistics. A 2026 study (Basu, arXiv 2606.04819) used pool data to list per-GPU rates, about 500–700 TH/s for an H100, and reported that the most widely used third-party miner contains no AI inference code. That study’s measurement covers one pool.

/// `nbits_override`: when set (e.g. pool share difficulty from `mining.set_difficulty`),
/// jackpot difficulty is checked against this compact target instead of `block_header.nbits`.
pub fn verify_plain_proof(
    block_header: &IncompleteBlockHeader,
    plain_proof: &PlainProof,
    nbits_override: Option<u32>,
    seed_derivation: SeedDerivation,
) -> Result<()> {
    let (private_params, mut public_params) = plain_proof.parse_proof(*block_header, seed_derivation)?;
    public_params.sanity_check()?;
    // … every revealed entry must be in [-64, 64] …
    let compiled = CompiledPublicParams::from(&public_params);
    let noise = compute_noise(&compiled);
    let jackpot = compute_jackpot(&compiled, &private_params.s_a, &private_params.s_b, &noise);
    public_params.hash_jackpot = compute_jackpot_hash(&jackpot, compiled.a_noise_seed());
    check_jackpot_against_nbits(&public_params, nbits_override)?;
    Ok(())
}