Fees & Mass

Every transaction pays the network to carry it. Kaspa collects that payment in an unusual way and prices it on an unusual scale, and both choices are deliberate.

The fee is a gap, not a field

There is no fee field in a Kaspa transaction. The fee is whatever the inputs are worth minus whatever the outputs are worth:

fee = sum(inputs) - sum(outputs)

Coins that go in and do not come out are the miner’s. A transaction that spends 10 KAS and creates 9.9997 KAS has paid 0.0003 KAS, and it says so nowhere.

Inherited from Bitcoin, and for the same reason: the fee needs no field because it cannot be lied about. Sum both sides and it falls out.

Mass, not bytes

Bitcoin prices a transaction by how much room it takes. Kaspa prices it by how much of the network’s actual scarcity it consumes, measured in a unit called a gram.

There are three separate kinds of scarcity, and a transaction is measured on all three:

Size still matters, since it feeds two of the three. But size alone cannot tell a node that a transaction shattered one coin into a thousand tiny ones, and that is the transaction that costs the network most. Bytes are a proxy. Mass measures the thing itself.

You pay for your worst dimension

A transaction’s fee is set by its heaviest dimension, and the other two ride along free.

The mempool normalizes the three against their block limits so they can be compared on one scale, then prices the largest. A transaction that is heavy on storage but trivial on compute pays for the storage; padding it with script work up to that same level costs nothing extra. Only the relay floor is narrower - it applies to compute and transient mass alone, because storage growth is already capped by the block limit.

The practical shape of that rule: there is no reward for shaving bytes off a transaction whose cost is really about the coins it creates.

Storage mass keeps the UTXO set honest

The UTXO set is the one thing pruning never discards, so it is the one resource a spammer could damage permanently. KIP-9 prices that damage directly.

Storage mass compares the coins a transaction creates against the coins it consumes, using a large constant of one trillion:

storage mass = max(0, C × (|outputs| / H(outputs) − |inputs| / A(inputs)))

The two averages are what make it bite. The output side uses a harmonic mean, which is dominated by the smallest value present, so one tiny output drags the whole term up. The input side uses an arithmetic mean. The consequences:

• Splitting is expensive. Turning one coin into many small ones - especially dust - carries heavy storage mass, and the smaller the pieces the worse it gets.
• Merging is free. Consolidating many coins into one produces no storage mass at all, because the formula floors at zero. Cleaning up your own wallet costs nothing beyond the compute.
• A normal payment barely notices. One or two inputs and two outputs of ordinary size land near zero on this dimension.

Kaspa does not have a dust limit, because it does not need one. Bitcoin forbids tiny outputs by policy; Kaspa lets you make them and charges you what they actually cost. Whether it is working is visible in the UTXO count - the set grows with real usage and not much else.

What a payment costs

The expected fee is a rate times a mass:

fee = fee rate × mass

Fee rate is in sompi per gram, and the minimum a node will relay is 100 sompi per gram - raised from 1 at Toccata, when the old floor stopped being meaningful against a real fee market.

An ordinary one-input, two-output payment runs a few thousand grams. At the floor that is a fee in the low hundreds of thousands of sompi - a few thousandths of a single KAS. Live averages and medians are charted at average transaction fee and median transaction fee.

Nodes publish suggested rates in three buckets, each an estimate of what it takes to be included within a given window:

Those numbers are derived from what is actually waiting in the mempool, not from a fixed schedule - so when nothing is queued, all three collapse toward the floor. Paying above the floor buys position, and position only matters when there is a queue.

See Also: The Mempool, Throughput