There's a simple pattern behind every on-chain lending market. Once you see it, the jargon falls away and the behavior becomes predictable.

This post explains the pattern using @MorphoLabs's mental model, then answers a common edge-case ("what if there's no liquidity when I try to withdraw?").

I'll also show how we use the same model inside @rosetta_hl to make yield routing boring, fast, and policy-safe.

Depositor (you): supplies USDT0.
Vault: a risk-curator that issues you vault shares (think: xUSDT0) and spreads funds across markets.
Market (e.g., UBTC/USDT0): where suppliers earn and borrowers take loans.
Borrower: locks UBTC as collateral, borrows USDT0; their interest becomes your yield.

That's it. Four roles. Two tokens. Two layers of shares.

1. Deposit → Vault

You send USDT0 to the vault. The vault mints xUSDT0 for you. Those shares represent a slice of the vault's whole pot (across all markets).

2. Vault → Market

The vault allocates your USDT0 to one or more markets (say UBTC/USDT0). In return, the market gives market shares to the vault. These are the vault's receipt inside that specific market.

3. Borrowing happens

Borrowers post UBTC, borrow USDT0. Interest accrues to the system. No one mints extra supplier shares; instead, the price per share (PPS) rises.

4. Withdraw

You return xUSDT0 to the vault. The vault burns your shares, redeems market shares for USDT0 (+ accrued interest), takes its fee on the yield portion, and pays you.

PPS = Total assets claimable by suppliers / Total shares outstanding

Shares don't change (except when minted/burned on deposit/withdrawal).
Claims rise as borrowers' debt grows with interest. Implementation details vary (index math vs explicit balances), but the effect is the same: your claim per share increases over time.

A toy example

Two useful mental models:

Supplier POV: "My denominator (shares) is flat; my numerator (claim) grows."
Borrower POV: "My debt index grows; I owe a bit more over time."

Both are true; they're the same mechanism described from opposite sides.

You'll sometimes hear: "interest increases liabilities, not assets." Correct—from the market's balance-sheet view:

Assets: the USDT0 supplied to the market contract.
Liabilities: the USDT0 owed by borrowers (indexed up by interest).
Available liquidity: Assets − Liabilities actually sitting idle in the pool.

What matters for suppliers is the conversion index that turns your shares into claimable assets. Whether we say "assets grew" or "liabilities accrued" is framing; the PPS rises either way.

I deposit 100 USDT0
A borrower posts 1000 UBTC → borrows 100 USDT0
The pool now shows 0 available liquidity
I want to withdraw. What happens?

Short version: you wait until liquidity reappears. That can happen via:

Repayment: the borrower returns USDT0 (plus interest).
New supply: someone else supplies fresh USDT0.
Liquidation: if the UBTC collateral falls enough that LTV limits are breached, liquidators repay the debt to seize collateral; USDT0 flows back, creating liquidity.

Most lending markets don't forcibly unwind a healthy borrower just because a supplier wants to leave. That's the nature of maturity-transformation here: suppliers earn because capital is lent out. No free lunch on instant exit at 100% utilization.

Good designs compensate you for queuing by continuing to accrue yield while you wait. Great designs avoid the queue most of the time.

Vault shares (xUSDT0): your claim on the vault's aggregate pot (all markets, all positions).
Market shares: the vault's claim inside each market.

Value accrues at both layers via their respective PPS. The vault is effectively an allocator that tracks many market-level PPS curves and converts them into a single vault-level PPS for you.

Rosetta discovers yield, routes capital, and settles on Hyperliquid. Under the hood: an SDK, a block-level indexer (to compute PPS and utilization in real time), a Policy Engine, Connectors (e.g., @MorphoLabs, @felixprotocol, @hyperlendx, HIP-3 markets on HyperEVM), and an Execution Engine.

In practical terms:

Withdrawal reliability: We price withdrawal latency as a first-class risk. The Policy Engine caps per-market utilization, enforces minimum idle buffers, and avoids borrow-concentration. Net: fewer "no liquidity" surprises.
Policy-safe routing: You set rules (LTV floors, max utilization, counterparty filters, chain/market allowlists). We emit signals and execute within those guardrails.
Block-level truth: Our indexer computes PPS and utilization at block cadence, not hourly or daily. If a market turns, we know—fast.
Composability without chaos: Connectors abstract integration. Markets may differ, but the PPS/claims model is universal. Rosetta treats them uniformly and auditably.
Self-custody by default: We orchestrate; you hold keys. Shares and claims stay transparently on-chain.

If you like the clarity of the model above, Rosetta's job is to operationalize it: keep capital in the best markets that still meet your policy, and keep exits smooth most of the time.

PPS is the variable to watch. It encodes your economic reality.
"No liquidity" isn't a bug; it's the cost of being fully utilized. Good vaults manage buffers and concentration so you rarely feel it.
Accounting debates (assets vs. liabilities) are secondary to the share-conversion math that pays you.
Aggregators exist to minimize tail events (queues) without sacrificing yield.

Lending markets are simple: fixed shares, growing claims. Vaults turn many PPS curves into one. When utilization hits 100%, withdrawals queue until liquidity returns (repayments, new supply, or liquidation). Rosetta makes that edge case rarer—and the whole experience saner—by routing with policy, tracking PPS at the block level, and enforcing utilization, buffer, and concentration limits.

If you're building on HyperEVM or operating capital at scale, this is the model we use internally. It's simple, composable, and—most importantly—predictive.