How Child Pays For Parent (CPFP) Works: Mathematical Fee-Bumping and Miner Scoring

When a transaction is broadcast with a fee rate that is too low to satisfy current network demand, it can become stuck indefinitely in mempools. Child Pays For Parent (CPFP) is a fee-bumping technique that allows a recipient (or a sender spending a change output) to accelerate the stuck parent transaction by creating a high-fee child transaction.

This guide details the mathematical scoring mechanisms miners use to evaluate unconfirmed packages and select them for inclusion in candidate blocks.

1. The Core Mining Dilemma

Miners compile transactions into candidate blocks to maximize their fee revenue. However, a miner cannot select a child transaction for a block unless all of its ancestor transactions are also included in that block.

If a parent transaction $T_P$ has a low feerate ($1\text{ sat/vB}$) and its child transaction $T_C$ has an extremely high feerate ($100\text{ sat/vB}$), the miner cannot simply mine $T_C$ and pocket the premium. To capture the fee on $T_C$, they must also mine $T_P$.

To solve this dependency problem, mining algorithms evaluate transactions not in isolation, but as packages of ancestors.

2. The Mathematical Package Formula

When evaluating a transaction $T$, a miner’s mempool scoring engine calculates its Ancestor Feerate (also referred to as its mining score):

$$F_{\text{package}}(T) = \frac{\text{Fee}(T) + \sum_{A \in \text{Ancestors}(T)} \text{Fee}(A)}{\text{Size}(T) + \sum_{A \in \text{Ancestors}(T)} \text{Size}(A)}$$

Where:

• $\text{Ancestors}(T)$ is the set of all unconfirmed parent transactions of $T$ that are currently in the mempool.

• $\text{Size}$ is measured in virtual bytes (vB).

• $\text{Fee}$ is denominated in satoshis (Sats).

3. Step-by-Step Mathematical Example

Let's walk through a live scenario where a user has received a payment that is stuck in the mempool:

The Stuck Parent ($T_P$):

• Size: $250\text{ vB}$

• Fee: $250\text{ Sats}$ (Feerate: $1\text{ sat/vB}$)

• Status: Stuck (Current market rate is $20\text{ sat/vB}$)

The Bumping Child ($T_C$):

The recipient spends the unconfirmed output from $T_P$ to construct a child transaction $T_C$ back to themselves:

• Size: $200\text{ vB}$

• Fee: $10,000\text{ Sats}$ (Individual Feerate: $50\text{ sat/vB}$)

Miner Package Evaluation:

A miner scans the mempool and computes the package feerate for $T_C$:

$$\begin{aligned} F_{\text{package}}(T_C) &= \frac{\text{Fee}(T_C) + \text{Fee}(T_P)}{\text{Size}(T_C) + \text{Size}(T_P)} \ F_{\text{package}}(T_C) &= \frac{10,000 + 250}{200 + 250} \ F_{\text{package}}(T_C) &= \frac{10,250\text{ Sats}}{450\text{ vB}} \approx \mathbf{22.78\text{ sat/vB}} \end{aligned}$$

The Outcome:

Because the collective package score of $22.78\text{ sat/vB}$ exceeds the current market clearance rate of $20\text{ sat/vB}$, the miner's block selection algorithm includes both $T_P$ and $T_C$ in their next candidate block.

⚡ 4. Package Relay and BIP 331 (Mempool Constraints)

Historically, CPFP suffered from a critical bootstrap problem on the P2P network layer:

 THE BOOTSTRAPPING BOTTLENECK

 ┌──────────────────────────────────────┐
 │ Child Transaction (50 sat/vB) │
 └──────────────────┬───────────────────┘
 │ (Rejected!)
 ▼
 ┌──────────────────────────────────────┐
 │ Parent Transaction (0.5 sat/vB) │
 │ * Below local minrelaytxfee (1 sat) │
 └──────────────────────────────────────┘

• The Relay Block: If a parent transaction $T_P$ was broadcast with a fee rate below a node's local minrelaytxfee (e.g., $0.5\text{ sat/vB}$), the node would immediately reject $T_P$ and refuse to add it to its mempool or propagate it.

• The Child Trap: Since the parent transaction was never accepted into the node's mempool, the high-fee child transaction $T_C$ would also be rejected as "orphaned" (inputs spend from a non-existent parent).

• The Solution (BIP 331 - Package Relay): To resolve this, modern Bitcoin Core protocols implement Package Relay. This allows peers to announce and transmit groups of transactions together (e.g., $T_P + T_C$ as a single bundle), letting the high-fee child sponsor the parent through the gossip layer.