We break down where yield actually comes from: tracing it from borrowers and explaining how Rosetta's indexer tracks these flows at every block to make yield transparent, composable, and programmable.

Open any Defi protocol website and you'll see a yield number flashing back at you: 5%, 8%, 20%. It feels like free money. But yield never appears from nowhere.

Gauntlet USDT0 vault on Rosetta — @gauntlet_xyz USDT0 vault on Rosetta

There's no secret pool printing rewards. The protocol simply enforces a transparent, onchain version of what traditional finance hides in closed ledgers: except here, every movement, every interest accrual, and every compounding step happens at the block level, visible and verifiable by anyone.

In protocols like @MorphoLabs and @aave yield emerges naturally from the flow between borrowers and lenders: value moving, not value being created. Every percentage on your screen reflects someone else's position: a borrower paying interest, a lender earning it, and the protocol connecting them.

And while many so-called "yield" platforms inflate returns through token emissions or unsustainable loops, Morpho and Aave derive yield from real, on-chain credit markets: interest paid by borrowers, not printed incentives.

What we call yield is simply the record of value in motion.

Before we go deeper, it's worth noting that most users don't lend directly but they interact through vaults. Vaults are orchestration layers that bundle deposits and route them into underlying markets on Morpho. Vaults don't generate yield themselves; they just coordinate access to it. In this article, we focus on the yield engine underneath. If you're curious about vault design, we've shared more here.

That engine begins with how DeFi redefines interest itself as a continuously updating balance. In traditional finance, your savings account earns interest only when the bank pays it. In DeFi, something more elegant happens: the accounting itself becomes continuous.

There are two ledgers operating side by side:

The Real Ledger (cash flow): This is where actual repayments occur. Borrowers don't pay every block; they pay when they interact (repay, adjust, or close). When a supplier withdraws, funds come from the pool's available liquidity which already reflects borrowers' accrued debt.
The Represented Ledger (accounting): Even without new transactions, the protocol updates internal exchange rates every block to represent what lenders should have earned over time. It isnt minting new tokens but adjusting the conversion between shares and assets so that balances reflect accrued interest.

This is where @rosetta_hl comes in. Our indexer calculates your updated value every block unlike other event-based systems that only update when transactions occur.

Let's continue with the architecture of the yield; structure allows lending markets like Morpho to behave like an instantaneous, interest-bearing savings system: efficient, fully collateralized, and constantly synchronized between time and liquidity.

The money doesn't move, but the math does.

If borrowers pay 5% and suppliers earn 4%, where does the 1% go?

Usually: Nowhere. The market doesn't take a spread or profit from the gap. That "missing" part simply reflects utilization: how much of the pool is actually borrowed.

If only 80% of the assets are lent out, then only that 80% is generating interest for suppliers. In other words, every supplier shares the yield, but only that borrowed capital actually generates it.

With zero protocol fee (common in Morpho), the gap is mostly utilization.
With a reserve factor (common in Aave/Compound, e.g., 10–15%), a slice of interest is routed to the protocol's reserves.

Every supplier shares the yield, but only the borrowed capital actually generates it.

The Math of Yield

Every yield starts with the borrow rate, determined each block by the protocol's IRM (Interest Rate Model). This value represents the instantaneous per-second borrowing rate for that market.

Borrow APY expresses that per-second rate over an entire year, with compounding:

borrowAPY = e^(borrowRate × secondsPerYear) − 1

(borrowRate → current rate per second (returned by the IRM contract))

Suppliers don't earn the full borrow rate: they earn a share of it, depending on how much of the pool's liquidity is in use:

supplyAPY = borrowAPY × utilization × (1 − fee)

Where utilization is totalBorrowAssets / totalSupplyAssets, and fee is protocol fee, which is in general 0 at Morpho. However in Aave, there are significant reserve factors (protocol fees), like 10, 15%.

Interest Rate Model (IRM)

Every lending market needs a rulebook for how rates move. This rulebook is called the Interest Rate Model (IRM). It continuously reads live market data: how much is supplied, how much is borrowed and adjusts the borrow rate accordingly.

WHYPE/USDT0 market — WHYPE/ USDT0 market on Rosetta

The rates are following a curve, which is being adjusted according to the utilization rate over time. While most protocols use fixed, piecewise-linear curves (like Compound or Aave), Morpho uses the AdaptiveCurveIRM, a model that adapts itself to the market over time. It doesn't need governance updates or manual tuning; it reacts autonomously.

So instead of a static formula, Morpho's rates evolve dynamically: balancing supply and demand until the system naturally stabilizes near its target utilization (90%).

Think of it like a thermostat:

When borrowing demand overheats, rates rise to cool it down; when demand falls, rates drop to warm it back up.
When demand falls (utilization drops), rates go down to warm it back up.

But why 90% is set as the target?

Below ~90%, capital sits idle and suppliers earn less.
Above ~90%, liquidity can run thin when suppliers want to withdraw.

So the system self‑regulates around that zone.

The Two Mechanisms

1. The Curve Mechanism (Normal Curve)

At any moment, the interest rate is defined by a curve that grows with utilization.

At u_target = 0.9, the rate is r₉₀%. If utilization hits 100%, the rate jumps to 4 × r₉₀%.

If utilization drops to 0%, it falls to ¼ × r₉₀%. That "×4" steepness is a constant (C = 4) coded into the protocol. It means the curve reacts sharply when utilization strays from the target — rewarding lenders and punishing borrowers when liquidity runs tight.

if err < 0:
    r = ((1 - 1 / C) * err + 1) * rateAtTarget
elif err > 0:
    r = ((C - 1) * err + 1) * rateAtTarget
else:
    r = rateAtTarget

2. The Adaptive Mechanism (Up or Down Shift)

The curve itself shifts up or down over time based on market behavior. If utilization stays above 90%, the target rate r₉₀% continuously moves upward -> incentivizing repayment. If utilization stays below 90%, it gradually declines -> incentivizing borrowing.

This shift is defined by:

r90_t = r90_last * math.exp(kp * e_u * dt)

e(u) = normalized error between current and target utilization
Δt = time since last update (in seconds)
kₚ = 50, the adjustment speed constant

TL;DR

The faster adaptation happens when utilization drifts further from 90% — or when it stays away from that target for longer.

We've built all of this into @rosetta_hl's indexer—every tick, every shift, every fraction of interest is tracked and displayed in real time, block by block.

Our system mirrors both the realized and the ever-accruing value of assets, ensuring the vault's true worth is always known in real time. Today, the same engine that measures yield now routes it.

Rosetta's Yield Router uses these deeply indexed insights to move capital intelligently across markets but understanding where yield's born, how it moves, and where it belongs next.