Protocol Comparison Brief · May 2026

Eight chassis tranche yield.
One has scars.

A side-by-side of eight DeFi yield-tranching protocols. Seven untested theories. One chassis that has actually absorbed real losses on real defaults.

The eight chassis

  • Royco Dawn · pure two-tranche wrapper (Senior / Junior)
  • Strata · pure two-tranche wrapper (Senior / Junior)
  • Infinifi · stablecoin issuer with three-tier deposit waterfall
  • Covenant · two ERC-20s per market (Yield Coin / Leverage Coin)
  • Knox Finance · fixed-maturity three-tier (Senior / Spectrum / Junior)
  • Lotus Protocol · tranched lending, WTGXX-backed Senior Pre-launch
  • Mezzanine · managed tranched stablecoin yield Pre-launch
  • Goldfinch V1 · per-loan Senior/Junior on real-world private credit
The only proof point
$17.9M in real Junior losses absorbed
1 of 8 chassis · 3 documented defaults
Goldfinch V1 is the only one of the eight with documented real-world Junior loss absorption. The other seven are too new (or pre-launch) and operate on collateral profiles that haven't (publicly) generated a default that tested the waterfall.

Prepared by

Mike Blank · May 2026

Read time

12 slides · ~11 min · slide 02 makes the case against looping

Why tranching · the case against looping

Looping screws everyone the same. Tranching lets you choose your pain.


The looping trap

  • One risk profile for the whole vault. Looping stacks leverage on the same yield source – every depositor ends up holding the loop, whether they wanted that risk or not.
  • Yield comes from leverage, not underwriting. Loss is socialized: at typical 5–10× loop factors, a 5% hit on the underlying becomes a 25–50% hit on every depositor equally.
  • Reflexive in stress. Collateral drops or borrow rates spike → loops unwind → forced selling and exit-queue stress → collateral drops further. The wstETH:ETH unwind on Aave (Jul 2025) ran this script in days – staking exit queues hit 9–18 days while spot stETH depegged.
  • Phantom TVL hides insolvency. Recursive collateral inflates headline TVL beyond the underwriting that backs it. Stream Finance's xUSD/deUSD loops printed ~3.25× phantom TVL until a Balancer V2 rounding exploit (Nov 2025) detonated ~$285M of cross-protocol bad debt across Euler and Morpho.

What tranching changes

  • Two contractual loss positions on the same underlying. Junior absorbs the first dollar; Senior is protected up to a defined cushion.
  • Yield is priced against the position, not the leverage. Junior earns a risk premium for absorbing volatility; Senior earns a capped, protected coupon.
  • Loss is ranked, not socialized. A 5% drawdown that hits a loop's depositors equally instead burns Junior's buffer while leaving Senior whole.
  • Scale comes from underwriting, not leverage. The constraint moves from "how much can we lever" to "how much first-loss capital can we attract" – a fundamentally different question.

The punchline

Looping makes yield by adding risk to everyone. Tranching makes yield by giving risk to someone who wants it.

The counterpoint · May 2026

Tranching only delivers ranked-loss as advertised when the underlying is predictable. Over an actively managed vault, the senior tranche is mostly a leveraged bet on the curator.

  • Manager discretion eats the waterfall. Idiosyncratic execution risk, strategy drift, and key-person bets can't be subordinated away.
  • Utilization-based buffers are procyclical. Senior coverage scales with current junior capital – in stress, junior capital depletes or refuses to participate, and the insurance disappears precisely when seniors need it.
  • Subordination doesn't cover oracle or contract risk. Ranked loss only governs the economic waterfall. A bad price feed, a reentrancy bug, or a rounding error hits Senior and Junior pari passu.
  • DeFi tails are binary. Exploits and opsec failures are typically unrecoverable – Balancer V2's Nov 2025 rounding bug (~$128M) is the recent example – and total wipeouts make subordination notional, not real.

Where it does work: predictable, non-discretionary cash flow – HyperLiquid's HLP fee stream, BarnBridge-style fixed-maturity tranches – is the right canvas.

Source: @0scaronchain, May 14, 2026

How it works in practice · Royco as a worked example

$100 in. Split. Stacked. Then hit by a loss.


The structural flow

01 · Deposit
$100 USDC enters the Royco vault.
02 · Split into Senior + Junior
~$70 → srRoyUSDC (Senior, downside-protected) · ~$30 → Junior tranche (first-loss). Ratio set by the utilization curve.
03 · Yield routing
Underlying earns ~8% APY. Dynamic curve reweights toward whichever tranche is scarce – Junior gets more when first-loss capital is undersupplied.
04 · Loss waterfall
Every dollar of loss hits Junior from $1. Senior only takes a haircut after Junior is fully exhausted.

Before / after a 30% loss · $100 deposit

Day 0
Senior$70
Junior$30
After −30% ($30)
Senior$70
Junior · wiped$0

Junior absorbs every dollar of loss until exhausted. Senior is untouched up to the subordination boundary.

$100 across five states · illustrative

State Junior Senior Note
Day 0 $30 $70 Pool initialized
+8% underlying yield +~$4.50 (~15% APY) +~$3.50 (~5% APY) Junior captures the risk premium
−5% loss event ($5) $25 $70 Junior absorbs all of it
−30% loss event ($30) $0 – wiped $70 Junior exhausted; Senior at boundary
−40% loss event ($40) $0 $60 (−14%) Senior begins to bleed

*Illustrative figures; actual srRoyUSDC ratios and APYs vary by vault and utilization. Royco's observation-period mechanic means transient mark-to-market dips don't trigger Junior loss recognition – only persistent declines count.

The point

Same underlying yield. Same dollar of loss. Two completely different outcomes per dollar of capital.

The landscape · side by side · sorted by launch date

The comparison matrix.


Dimension Goldfinch V1 Royco Dawn Strata Covenant Infinifi Knox Finance
Core abstraction Tranched private-credit lending pools Risk-tranching wrapper for any yield source Generalized 2-tranche structuring chassis Permissionless leverage / credit marketplace On-chain fractional-reserve stablecoin bank Fixed-maturity 3-tier structured-yield platform
Senior instrument FIDU (Senior Pool LP token) Senior tranche tokens (e.g., srRoyUSDC) Senior token (e.g., srUSDe) Yield Coin ("zToken") iUSD (base) Senior / Fixed position (Position 01)
Junior instrument Backer position per Borrower Pool Junior tranche token Junior token (e.g., jrUSDe) Leverage Coin siUSD (liquid stake) → liUSD (locked 1–8 wk) Junior / Variable position (Position 03); plus a Spectrum middle tier (Position 02) – Knox is the only 3-tier chassis in the set
Loss waterfall Junior absorbs first; every payment pays Senior interest + principal before Junior Junior absorbs from $1; Senior protected first-dollar Junior absorbs first, then Senior Leverage Coin wiped → Yield Coin face-value reduced pro rata liUSD → siUSD → iUSD Junior absorbs from $1 → Spectrum next → Senior last; enforced at maturity
Senior yield source Pro-rata share of pool interest, scaled by ~4× leverage and net of "leverage tax" subsidizing Junior Underlying yield, capped/protected Guaranteed minimum benchmark + uncapped upside Implied funding rate from Latent Swap AMM ~8% APY on siUSD junior*; iUSD itself non-yield Pre-agreed fixed APY set per pool, paid first, backed by Junior + Spectrum
Junior yield source Headline borrower interest rate + GFI rewards Underlying yield + risk premium from Senior Risk premium from Senior + leveraged upside Leveraged exposure to collateral price/yield 14–15.7% APY on liUSD; 8% on siUSD* Uncapped residual + share of surplus above Junior hurdle (set per pool)
Yield-split mechanism Fixed leverage ratio per pool (typically ~4×) Dynamic utilization curve (Aave-style) Junior-first cascade with senior floor Market price of Yield Coin sets funding rate Fixed by tier Fixed senior coupon + capped Spectrum + Surplus Participation above caps
Lockups? Yes – Senior Pool withdrawal queue; Backer capital locked through loan term No No No – both tokens are fungible ERC-20s Yes – 1–8 weeks on liUSD Yes – fixed maturity per pool, set at deployment; position is ERC-20 transferable on secondary
Underlying assets Real-world private credit loans Any yield source (lending, staking, RWAs) Ethena USDe; expanding to lending vaults, RWAs Any collateral asset Aave, Pendle PTs, Ethena sUSDe, Fluid Morpho, Aave, Pendle, and other ERC-4626 vaults
Live products Borrower Pools + Senior Pool (V1); Goldfinch Prime (single-tier RWA wrapper) srRoyUSDC, roywstETH, sroywstETH srUSDe / jrUSDe Per-market Yield/Leverage Coin pairs; sUSDz Yield Fund iUSD / siUSD / liUSD Multiple curated fixed-maturity vaults live at app.knox.finance/explore
Closest TradFi analogue Securitized loan tranches / mezzanine fund CDO / CLO senior-mezz-equity stack CDO sr/jr tranching Repo + total-return swap Fractional-reserve bank with tiered deposits Structured note – senior coupon + mezz w/ kicker + equity first-loss

*Infinifi yield figures captured 6 May 2026; rates are variable and update continuously. Knox does not publish platform-wide reference APYs – Senior, Spectrum, and Junior parameters are set per pool at deployment; see app.knox.finance/explore for live pool terms. Lotus Protocol and Mezzanine are excluded from this comparison because they are not yet live; see slide 10 for narrative coverage.

01 Royco Dawn

A two-tranche wrapper that sits on top of any yield source.


Mechanics

  • Senior: "smart-contract-enforced downside protection." Junior absorbs losses from the very first dollar – no deductible.
  • Junior: first-loss capital up to a defined coverage amount. Earns the underlying yield plus a risk premium paid by Senior in exchange for the protection.
  • Yield split is dynamic, not fixed. A utilization curve (Aave-style) reweights yield toward whichever tranche is undersupplied – when Junior capital is scarce, more yield flows to Junior to attract first-loss capital, and vice versa.
  • Observation period: a meaningful nuance – temporary mark-to-market drawdowns that revert don't trigger Junior loss recognition. Only persistent losses count, which prevents Junior wipeout from transient volatility.

Live vaults

srRoyUSDC Senior USDC
roywstETH wstETH-collateralized USDC borrow into srRoyUSDC
sroywstETH Looped / leveraged variant

Why the observation period matters

The observation-period logic is the single most insurance-shaped design choice in the set – it explicitly models the difference between a marked loss and a realized loss.

02 Infinifi

An onchain bank with a three-tier deposit waterfall.


A stablecoin issuer with a three-tier deposit hierarchy that mimics traditional fractional-reserve banking. Tranches are tied to stablecoin issuance, not wrapped vaults.

iUSD
Base 1:1 USD stablecoin · Most senior · Last to take losses
non-yield
siUSD
Liquid staked iUSD · Mid tier
~8% APY
liUSD
Locked iUSD, 1–8 wk exit · Most junior · First wiped
14.1–15.72% APY

Loss waterfall

Explicit, coded: in a hack or bank-run, liUSD holders are wiped first, then siUSD, then iUSD. The longer the lock and higher the yield, the earlier in the firing line.

Underlying allocation

Aave, Pendle principal tokens, Ethena sUSDe, Fluid. A reserve buffer stays unallocated to support redemptions. Reportedly ~$1.60 of Ethena exposure per $1 deposited.

The asymmetry

liUSD pays 2× the yield of siUSD but takes 100% of the first loss. The premium is for the firing-line position, not the lock duration alone.

03 · 04 Strata & Covenant

The purist chassis, and the one that doesn't call itself one.


03

Strata.

The most "pure" generalized tranching chassis of the four.

  • Senior (e.g., srUSDe): over-collateralized, yield-bearing, with a guaranteed minimum yield linked to a benchmark rate, plus uncapped upside.
  • Junior (e.g., jrUSDe): a "liquid insurance pool" for Senior. Absorbs volatility and loss first; receives a risk premium in return.
  • Yield flows junior-first on upside as well as downside – Junior captures upside amplification, Senior is paid its guaranteed minimum, then residual flows back.
  • Roadmap: launched on Ethena USDe; expanding to lending vaults, multi-strategy vaults, delta-neutral, tokenized private credit, RWAs.
Mental model BarnBridge / Saffron, with a more general-purpose chassis.
04

Covenant.

Not branded as tranching, but the economics are equivalent – and the senior-side loss rule is genuinely novel.

  • Yield Coin (zToken): a fully-collateralized debt claim – functions like a tradeable perpetual bond. Loss only if collateral falls below debt notional → analogous to senior debt.
  • Leverage Coin: residual claim on collateral. Captures upside above debt notional, and absorbs the first dollar of loss when collateral declines → analogous to equity / junior tranche.
  • Loss cascade: Leverage Coin holders absorb collateral declines first → on liquidation, Leverage Coin can be wiped → if collateral still fails to cover, Yield Coin face value is reduced pro rata across all holders – a flat haircut, not a time-priority hierarchical write-down.
  • Pricing: market-driven via a Latent Swap AMM. As LTV rises, Leverage Coin price falls and Yield Coin implied rate rises, attracting lenders – replacing cliff-style liquidations with continuous price-based adjustment.
The novel bit Pro-rata haircut on senior, not time-priority. Live on Monad / Monad Testnet.
05 Knox Finance

A three-tier structured-yield platform with a fixed senior coupon and fixed maturities.


Mechanics

  • Three positions, not two: Senior (Position 01) – pre-agreed fixed APY, paid first. Spectrum (Position 02) – user-selectable APY cap on a rate grid; multiple Spectrum tranches per pool, filled from lowest cap to highest. Junior (Position 03) – uncapped residual, first-loss from $1.
  • Surplus Participation: when underlying performance exceeds Spectrum's caps, surplus goes to Junior first up to its hurdle, then is shared across Spectrum and Junior weighted by risk. This is the only protocol in the set with a mezz-style middle tier that earns an explicit kicker.
  • Fixed maturities: each pool has a fixed maturity set at deployment. No early withdrawal from the pool itself, but every position is minted as a transferable ERC-20 so secondary markets can clear early exits.
  • Loss waterfall: Junior absorbs from $1 → Spectrum (highest-cap first) → Senior last; enforced at maturity. Per Knox's explainer, optional pool-level safeguards (operator pause, early redemption) can exist if enabled at deployment.
  • Underlying: curated yield from Morpho, Aave, Pendle, and other ERC-4626 vaults. Knox is a fixed-income chassis on top of established protocols, not its own yield source.

Three positions

Senior · Position 01
Fixed coupon · Paid first · Backed by Spectrum + Junior
Pre-agreed fixed APY
Spectrum · Position 02
User-selectable cap on a rate grid · Surplus Participation above cap
Capped, paid in cap order
Junior · Position 03
First-loss from $1 · Uncapped residual · Hurdle set per pool
Uncapped residual

Why the fixed senior coupon matters

Knox is the only protocol in the set where Senior earns a contractual fixed coupon, not a capped pass-through. That is structurally the closest analogue to how an insurance vault pays predictable claims out of a subordinated capital cushion.

06 Goldfinch V1

The most TradFi-style of the eight – and the only one that's been tested.


The data below is relevant to Goldfinch V1, not to the existing product Goldfinch Prime.

How it works

  • Junior tranche (Backers): individual underwriters who manually evaluate each Borrower Pool. Provide first-loss capital. Earn the headline borrower rate plus GFI rewards.
  • Senior tranche (Senior Pool LPs): passive LPs deposit USDC into the Senior Pool and receive FIDU. The Senior Pool deploys across active Borrower Pools, levering Backer capital at ~4× by default – e.g., $200K of Backer capital pulls ~$800K of Senior Pool capital into the same pool.
  • Repayment waterfall: every borrower payment pays Senior interest + principal first, then Junior. Backers miss repayment first on any shortfall.
  • Yield split: Senior earns a lower net rate (leverage tax subsidizes Junior); Junior earns the headline rate plus underwriting rewards.
  • Underlying: real-world private credit – historically loans to fintech lenders in emerging markets (Africa, LatAm, SE Asia).

Note on Prime

Goldfinch's newer Prime product offers diversified exposure to institutional private credit funds (Apollo, Ares, Golub) on Base – a single-tier wrapper, not the V1 sr/jr structure. V1 is what's directly comparable here; Prime represents Goldfinch's strategic pivot away from active sr/jr tranching toward a fund-of-funds model.

Three documented defaults · The only real-world test

Default Pool size Total writedown Backer wiped Senior portion Off-protocol
Tugende Kenya
Aug 2023
$5.0M $5.0M (full) ~$1.0M ~$4.0M (3.95% NAV) DAO: $1M USDC from treasury
Stratos
Oct 2023
$20.0M $7.0M (REZI + POKT to $0) ~$4.0M (full junior) ~$3.0M Warbler Labs backstopped both
Lend East
Apr 2024
$10.15M $5.9M (after $4.25M repaid) ~$2.0M ~$3.9M None announced
Total $35.15M ~$17.9M ~$7.0M (gross) ~$10.9M

*Approximate figures based on public defaults documentation.

07 · 08 Lotus Protocol & Mezzanine

The two newest chassis – pre-launch and partially undisclosed.


Excluded from the comparison matrix on slide 04 because neither is live with public on-chain data. Treatment here reflects what is publicly known as of May 2026.

07

Lotus Protocol.Coming 2026

Tranched lending, not tranched wrapping – with an RWA yield floor under Senior. Pre-launch (Q2 2026); pre-deposit vaults opened May 2026. Founder/CEO: David Reising (ex-Index Coop, hyETH/Morpho relaunch with Gauntlet).

  • Connected LLTV-ordered tranches inside one market: a market = collateral + oracle + loan asset + IR model + liquidation module; a tranche = one LLTV configuration inside it.
  • Lower LLTV = more senior. Higher LLTV = more junior, higher rate.
  • Loss containment: bad debt is not socialized across the market. Defaults from a high-LLTV tranche stay inside that tranche – senior tranches in the same market are insulated.
  • Liquidity cascade: unused junior liquidity flows down to support senior borrowers unidirectionally – never the reverse.
  • LotusUSD + yield floor: Senior base asset backed in part by WisdomTree's WTGXX Treasury Money Market Digital Fund. Pricing: "Base Rate + Credit Spread." The only protocol in the deck with an embedded RWA yield floor under Senior.
Mental model Tick-based CLO with a money-market reserve floor – fits vault reserves, not capacity.
08

Mezzanine.Coming 2026

Tranched stablecoin yield with active management. Newer than the rest; mechanics partially undisclosed.

  • Positioning: "Institutional-grade yield through a tranching architecture that balances performance and protection."
  • Architecture: diversified, risk-stratified stablecoin yield with senior/junior style tranching, driven by "governance, automation, and AI-powered DeFi expertise." Non-custodial smart contracts.
  • Team: co-founded by Stephen (@phtevenstrong), founder of DeFi Dojo. His public commentary on 3Jane's sUSD3/USD3 split is the closest available reference for how he thinks about loss waterfalls.
  • Closest analogue in this deck: Infinifi's three-tier stablecoin deposit waterfall, but with active strategy management rather than fixed allocation.
  • Not yet public: tranche token names, exact loss-waterfall ordering, lockup terms, full underlying strategy list, live TVL and APYs, and where "AI-powered" sits in the stack.
The edge (if real) Active management overlay on top of tranching – maps to a vault's need to rotate yield sources without re-tranching. Hasn't shown the mechanics an underwriter could price.
Cross-cutting observations

Eight chassis, sliced five ways.


01

Where is the first dollar of loss absorbed?

  • Royco Dawn / Strata: Junior tranche, by design, from $1.
  • Infinifi: liUSD (locked) holders.
  • Covenant: Leverage Coin holder for that market.
  • Knox: Junior / Position 03, from $1.
  • Lotus: highest-LLTV tranche of the originating market – not socialized.
  • Mezzanine: junior tranche per public material; token name not yet disclosed.
  • Goldfinch: Backers (Junior tranche), per Borrower Pool.
02

Who sets the senior/junior yield split?

  • Royco Dawn: utilization curve (algorithmic).
  • Strata: junior-first cascade with senior floor.
  • Infinifi: protocol-set per tier.
  • Covenant: open market (Yield Coin price → implied rate).
  • Knox: fixed senior coupon + Spectrum cap + Surplus Participation above caps.
  • Lotus: LLTV-determined rate per tranche; demand-driven within each tranche.
  • Mezzanine: active management – governance + automation set the allocation.
  • Goldfinch: fixed leverage ratio per pool (~4×).
03

How general is the chassis?

  • Strata / Royco Dawn: wrappers over arbitrary yield sources.
  • Infinifi: purpose-built as a stablecoin issuer.
  • Covenant: per-collateral leverage marketplace.
  • Knox: fixed-maturity structured-yield wrapper on top of curated DeFi protocols.
  • Lotus: tranching inside a lending market – not a wrapper.
  • Mezzanine: managed stablecoin-yield mezz strategy.
  • Goldfinch: purpose-built for real-world private credit underwriting.
04

Liquid vs. locked

  • Fully liquid: Royco Dawn, Strata, Covenant, Lotus.
  • Locked (with secondary): Knox (fixed maturities, ERC-20 transferable on secondary).
  • Locked: Infinifi (to bucket risk tiers), Goldfinch (to match loan tenor).
  • Not yet disclosed: Mezzanine.
05

Senior loss treatment when Junior is exhausted

  • Royco Dawn / Strata / Goldfinch: standard cascade – Senior takes losses next.
  • Infinifi / Knox: explicit three-step waterfall (Junior → middle tier → Senior).
  • Covenant: distinctive – pro-rata face-value haircut across all Yield Coin holders, no time priority.
  • Lotus: distinctive – loss is contained within the originating LLTV tranche and does not propagate up the stack inside the same market.
  • Mezzanine: not yet publicly disclosed.
The takeaway
For the insurance vault

Goldfinch took the only real hit. Here's what every other chassis still has to prove.

Royco's observation-period nuance, Infinifi's tiered deposits, Knox's fixed senior coupon, Lotus's LLTV-level loss containment with an RWA yield floor, and Mezzanine's active-management overlay each map onto a different piece of an insurance vault – but none has been through a documented default.

8

Chassis evaluated

3

Goldfinch V1 defaults documented

~$17.9M

Total writedown across V1 history

~$7.0M

Junior (Backer) capital wiped