§ 10 · Emission
Block reward
New coins plus fees, claimed in the coinbase
On this page 6 sections
Mining costs electricity and hardware. The block rewardBlock reward: What a block's miner may pay itself: the newly created coins (the subsidy) plus all the fees of the block's transactions. is what pays for it: whoever wins a block gets to write one special transaction, the coinbaseCoinbase transaction: The first transaction in every block. It has no real inputs: it creates the block's new PRL and pays them, plus the fees, to the miner., and pay themselves.
How much? Exactly two things, added together:
- the subsidy: brand-new PRL, set by the emission formula for the block’s height;
- the fees: whatever the block’s other transactions left over between their inputs and outputs.
Nothing else. Every node recomputes both and rejects a block that pays itself a single grain too much.
Try it
Pick a height and read its subsidy off the curve. The fee part depends on what the block contains.
What may a miner claim?
The rule is one comparison, run on every block:
The fees are easy to total: for each transaction, the inputs’ values minus the outputs’ values. The subsidy comes from the height:
A miner may claim less than allowed. The rule is “at most”, so nothing stops it, and the unclaimed part is simply never created: no later block can pick it up. That’s why the issued totals on these pages are a maximum.
Does block 130,825 add up?
Here is its coinbase, the first of its 115 transactions, mined by Kryptex on 20 October 2026:
| Field | Bytes | Value |
|---|---|---|
| Version version | 4 @0 | 2 int32 little-endian. Pearl wallets and pearld coinbases use version 1; relay policy accepts 1-2. |
| Marker marker | 1 @4 | 0x00 Segwit marker (BIP-144): says witness data follows the outputs. |
| Flag flag | 1 @5 | 0x01 Witness flag; 0x01 is the only value Pearl accepts. |
| Input count vin.length | 1 @6 | 1 CompactSize number of inputs. |
| Previous txid vin[0].txid | 32 @7 | 0000000000000000000000000000000000000000000000000000000000000000 All zeros: this input creates new coins (coinbase). |
| Output index vin[0].vout | 4 @39 | 0xffffffff 0xffffffff together with a zero txid marks a coinbase. |
| scriptSig length vin[0].scriptSig.length | 1 @43 | 39 CompactSize length of the scriptSig. |
| Coinbase script vin[0].scriptSig | 39 @44 | 0309ff01048393d76a2f706f6f6c2e6b7279707465782e636f6d2f1550cad31e016e7bf00f2ecb Coinbase data. It starts with the block height 130825 (BIP-34, required in every Pearl block), then anything the miner likes. |
| Sequence vin[0].sequence | 4 @83 | 0xffffffff Final (0xffffffff): no RBF signal, no relative locktime, and locktime is ignored for this input. Pearl wallets use this. |
| Output count vout.length | 1 @87 | 2 CompactSize number of outputs. |
| Amount vout[0].value | 8 @88 | 223,838,373,068 grains (2238.38373068 PRL) int64 little-endian, in grains (1 PRL = 100,000,000 grains). |
| Script length vout[0].scriptPubKey.length | 1 @96 | 34 CompactSize length of the locking script. |
| Locking script vout[0].scriptPubKey | 34 @97 | prl1puv0gqv4x0wd0ylwz086y3sqrg4a6umza9r08aecehjrmdqq7mctsmqaqsh OP_1 OP_PUSHBYTES_32 <output key Q>: a Taproot output. |
| Amount vout[1].value | 8 @131 | 0 grains (0.00000000 PRL) int64 little-endian, in grains (1 PRL = 100,000,000 grains). |
| Script length vout[1].scriptPubKey.length | 1 @139 | 38 CompactSize length of the locking script. |
| Locking script vout[1].scriptPubKey | 38 @140 | witness commitment 78cc1a61dcfcee9c59ddd9f4d56a98764c071e077bcc36fe9d1cf0aad50ebac3 OP_RETURN aa21a9ed ‖ SHA256d(witness Merkle root ‖ nonce): the BIP-141 witness commitment. |
| Witness items witness[0].length | 1 @178 | 1 Number of witness stack items for input 0. |
| Witness reserved value length witness[0][0].length | 1 @179 | 32 CompactSize length of this witness item. |
| Witness reserved value witness[0][0] | 32 @180 | 0000000000000000000000000000000000000000000000000000000000000000 The coinbase witness is one 32-byte value (the witness-commitment nonce); pearld uses zeros. |
| Locktime locktime | 4 @212 | 0 0: no time lock. |
Its first output pays cc84ce1d34000000: read little-endian, 223,838,373,068 grains to a Taproot address. The second output is the zero-value witness commitment. Now check it:
-
The subsidy at height 130,825
⌊2.1 × 10¹⁷ × 650,226 ÷ (781,051 × 781,050)⌋ = 223,833,660,195 grains.
-
The fees of the other 114 transactions
Their inputs minus their outputs, summed: 4,712,873 grains.
-
The limit
223,833,660,195 + 4,712,873 = 223,838,373,068 grains: exactly what the coinbase claims, to the grain.
Other blocks check out the same way:
| Block | Subsidy | Fees | Coinbase pays |
|---|---|---|---|
| 1 | 322,964,134,063 | 0 | 3,229.64134063 PRL |
| 120,000 | 230,169,535,033 | 0 | 2,301.69535033 PRL |
| 130,792 | 223,852,575,691 | 0 | 2,238.52575691 PRL |
| 130,825 | 223,833,660,195 | 4,712,873 | 2,238.38373068 PRL |
| 130,827 | 223,832,513,878 | 46,132 | 2,238.32560010 PRL |
Subsidies and fees are in grains; 1 PRL = 100,000,000 grains.
How big are fees, compared with the subsidy?
Tiny, for now. Block 130,825 had 114 paying transactions, and their fees came to about 0.047 PRL, roughly 0.002% of its reward. Typical payments on 20 October 2026 paid about 50 grains per vbyte; the floor is 1 grain per vbyte.
Many blocks carry no fees at all. In a scan of 200 blocks ending at 130,825 (20 October 2026), 107, or 53%, held only the coinbase. For those, the reward is the subsidy and nothing more.
As the subsidy keeps shrinking, fees will matter more. How a fee is set is on fees and vsize.
Why wait 100 blocks before spending?
Because a block can be undone. If a competing branch with more work replaces it in a reorgReorg: When a node drops the newest block or blocks of its chain because a competing branch with more work appeared. Transactions from the dropped blocks go back to waiting., its coinbase vanishes, and so do the coins it created. Ordinary transactions can usually be mined again in the new branch. A coinbase can’t: it belongs to the block that lost.
So the rules make new coins wait. A coinbase output from height h can only be spent in a block at height h + 100 or later. This is coinbase maturityCoinbase maturity: The rule that newly mined coins cannot be spent until 100 more blocks have been added on top, in case their block is replaced., unchanged from Bitcoin:
| Coinbase mined in | Earliest block that may spend it |
|---|---|
| 130,825 | 130,925 |
| 130,827 | 130,927 |
By then, undoing the coinbase would mean out-working 100 blocks of the main chain. At the 194-second pace that’s about 5 hours 23 minutes of waiting.
What did the genesis block pay?
Nothing. The formula itself returns 0 for height 0, and the genesis coinbase has a single output worth zero, locked by a bare OP_RETURN, which can never be spent. As a belt-and-braces measure, the code also singles it out: “the coinbase for the genesis block is not spendable”.
Block 1, one second later, was the first to pay a reward: 3,229.64134063 PRL. There is no premine. The full story is on the genesis block.
Make a guess
A block contains only its coinbase. Its miner claims 2,000 PRL instead of the 2,238 PRL allowed. Can the next miner claim the missing 238 PRL?
Think of your answer first, then check it.
Answer No. The missing coins are never created.
Each block’s limit is its own subsidy plus its own fees. Nothing carries over, so the 238 PRL simply don’t exist. That’s why “issued so far” figures computed from the formula are a ceiling: real supply can only be equal or lower.
Code: the reward check and the maturity check
The reward check, from validate.go (node/blockchain/validate.go:1069-1084 at v1.5.2, on GitHub):
var totalGrainOut int64
for _, txOut := range transactions[0].MsgTx().TxOut {
totalGrainOut += txOut.Value
}
expectedGrainOut := CalcBlockSubsidy(node.height, b.chainParams) + totalFees
if totalGrainOut > expectedGrainOut {
return ruleError(ErrBadCoinbaseValue, str)
} The maturity check, from validate.go (node/blockchain/validate.go:900-916 at v1.5.2, on GitHub), with
CoinbaseMaturity: 100 in params.go (node/chaincfg/params.go:356 at v1.5.2, on GitHub):
if utxo.IsCoinBase() {
originHeight := utxo.BlockHeight()
blocksSincePrev := txHeight - originHeight
if blocksSincePrev < int32(chainParams.CoinbaseMaturity) {
return 0, ruleError(ErrImmatureSpend, str)
}
} How the coinbase itself is laid out, byte by byte, is on coinbase transaction.