CDP lending: when you borrow from the protocol, not a pool

Our piece on lending aggregation made the general case: on-chain credit is fragmented, and the 1delta API collapses thousands of disjoint markets into one queryable surface. The Midnight piece then poked at the deepest assumption on that surface - that lending happens in a pool - and showed the first market that replaced the pool with an order book.

There is a second, much older way to leave the pool behind: the collateralized debt position, or CDP. It predates pooled lending - MakerDAO's DAI is the original - and it answers the question "where does the borrowed money come from?" in the most radical way possible: from nowhere. There is no supplier on the other side of your loan. You lock collateral in a position you own and the protocol mints its stablecoin against it.

This article is about what that flip does to lending mechanics, told through the three CDP surfaces we index: Liquity V2, the modern reference design; its friendly-fork family (USDaf, Felix, Nerite, Quill, Ēnosys Loans, Soneta, Ebisu); and River, which carries the older Liquity V1 lineage forward on BNB, Base and Hemi.

No depositors, no utilization curve

Pooled lending - Aave, Compound, Morpho Blue, Euler - has one substrate: suppliers deposit into a shared pot, borrowers draw from it, and a utilization curve maps how full the pot is to a floating interest rate. Every borrow is funded by someone else's deposit, so the pool must price the tug-of-war between the two sides every block.

A CDP protocol has no pot. Opening a position - Liquity calls it a trove - means locking collateral and minting brand-new stablecoins as debt. Three things fall out of that immediately:

• Borrow liquidity isn't someone's deposits. Nobody has to supply the borrow asset before you can borrow it. There's no utilization spike when a whale withdraws, and no "pool is 100% drawn" failure mode - supply is bounded only by explicit debt caps where a deployment sets them.
• Nothing discovers the interest rate. With no supply-and-demand for deposits, a rate doesn't emerge - someone has to choose it. This is exactly where CDP designs diverge, and the axis on which Liquity V2 and River sit at opposite ends: V2 lets each borrower set their own rate; River's lineage has the protocol set it (and charges a one-off mint fee instead).
• The protocol must defend its own peg. Pool lenders hand out assets that already exist; a CDP mints one into existence and now owes the market a mechanism that keeps it at $1. That mechanism - redemption - is the most misunderstood part of CDP lending, and it's a risk surface pooled lending simply doesn't have.

Liquity V2, the modern reference design

Liquity V2 (Ethereum, minting BOLD) is the cleanest statement of the modern CDP. Its structure:

• One branch per collateral. WETH, wstETH and rETH each get a full, isolated contract set - their own trove registry, price feed, liquidation machinery and Stability Pool. Branch risk parameters differ (roughly 110% minimum collateral ratio for WETH, 120%+ for the LSTs), and a failing branch can be shut down without touching the others.
• Troves are NFTs, and you can have many. A trove is an ERC-721 with its own collateral, debt and health. One wallet can run several troves per branch - a conservative one and an aggressive one, say - which is why we model troves as sub-accounts rather than one position per wallet.
• You set your own interest rate. This is V2's signature move. Every trove carries a borrower-chosen annual rate, adjustable at any time within deployment bounds. Interest accrues continuously into the trove's debt. Why would anyone volunteer to pay more than the minimum? Because of redemptions - more on that in a moment. Borrowers who don't want to manage the rate can delegate it to a batch manager, who charges a small management fee (capped at 10%/yr) on top.
• The fees are few and knowable. An upfront fee on opening and on every debt increase (about seven days of the branch's average interest rate, applied to the new debt), the continuous interest at your chosen rate, and a matching fee if you change your rate within the seven-day cooldown - after the cooldown, rate changes are free. Repaying is free, any time. Closing burns the full live debt and returns all collateral.
• The earn side is the Stability Pool. BOLD holders deposit into a branch's Stability Pool and receive 75% of that branch's borrow interest, paid in BOLD, plus liquidated collateral at a discount when liquidations hit. This is the yield surface a CDP offers instead of a deposit rate - and unlike a pool deposit, it never collateralizes anything.

The result is a borrow market with a strange and interesting shape: the "borrow rate" is not one number but a distribution of self-chosen rates, and the branch's average moves as borrowers reposition.

Redemptions: the mechanic that holds the peg

A protocol that mints its own dollar owes the market an answer to "why is this worth $1?" Liquity's answer is redemption: anyone can hand BOLD to the protocol and receive $1 worth of collateral per token, paid out of live troves at the oracle price. If BOLD trades below par, arbitrageurs buy it, redeem it, and close the gap. It's a hard floor, not vibes.

The crucial - and most misunderstood - property: redemption is not liquidation. Your trove can be redeemed against while perfectly healthy. The redeemed borrower loses collateral and has their debt reduced by the same dollar value - roughly USD-neutral, but their collateral exposure shrinks, which is precisely what a leveraged ETH borrower didn't want.

Who gets redeemed first is where the two protocol generations split:

• Liquity V2 orders redemptions by interest rate - lowest-rate troves first. Your chosen rate is therefore a bid in a continuous auction for redemption protection: pay more, stand further back in the line. A borrower can watch the "debt in front" of their rate and reposition. This is what turns the user-set rate from a gimmick into a market: the redemption queue prices peg protection.
• The V1 lineage (River today) orders redemptions by collateral ratio - lowest CR first. Protection means holding more collateral, not paying a higher rate.

Two more involuntary events complete the risk picture. Liquidation hits troves whose collateral ratio falls below the branch minimum: the Stability Pool absorbs the debt and takes the collateral at a penalty (5% in vanilla V2; 10-20% if the pool is empty and the debt is redistributed to other troves), with anything above the penalty returned to the borrower as claimable surplus. And in V2, a redemption that shrinks a trove below the minimum debt (2,000 BOLD on mainnet) puts it in a zombie state - out of the redemption queue entirely until the owner tops it back up or closes it.

The forks: one design, many deployments

Liquity published V2 as a reference implementation with a friendly-fork program, and an ecosystem grew around it. We index seven forks alongside the original - nine deployments, 45 collateral branches, seven chains:

The pattern in that last column is the interesting part. No fork changed the mechanics. User-set rates, rate-ordered redemptions, branch isolation, the Stability Pool split - all of it survives every fork. What forks actually touch is the parameter sheet: minimum debt, collateral ratios, rate bounds, gas compensation, debt caps, the oracle stack, whether contracts are immutable or upgradeable, and which collateral gets wrapped. A fork is a configuration of the design, not a new design.

For an aggregator this is the good kind of fragmentation. Because the write surface is identical, one integration covers the whole family, and each fork is a config row - addresses, deviation parameters, and nothing else. The deviations that do exist (Felix's mutable ratios, Nerite's debt caps that can block a borrow even at healthy collateral, non-standard price-feed scaling on some branches) live in metadata that a generator re-validates against the chain, not in code.

River: the older lineage, still shipping

Not everything CDP-shaped descends from V2. River (the rebranded Satoshi Protocol, minting satUSD on BNB, Base and Hemi) carries the Liquity V1 design forward through the Prisma lineage - and it's a useful contrast, because nearly every axis V2 opened up, V1 had fixed:

• One trove per wallet per market, keyed by address. No NFTs, no trove ids - your address is your position. Simpler, but you can't run a conservative and an aggressive position side by side.
• The protocol sets the rate. Borrowers pay a protocol-set interest rate (currently 0% across River's markets) plus a one-off mint fee on opening and on each debt increase - a base rate that decays with a 12-hour half-life between 0.5% and 5%, spiking when redemption volume spikes. Cheap, predictable, nothing to manage - and no rate market.
• Redemptions are CR-ordered, so the defense is capital, not interest (the right-hand ladder above).
• One Stability Pool per chain backstops every market, rather than one per branch - and with rates at 0% its yield is liquidation gains plus incentive emissions, not interest.
• A global Recovery Mode kicks in if the whole system's collateral ratio drops below 150%: collateral withdrawals pause, debt increases are restricted, and liquidation thresholds tighten. V2 replaced this system-wide brake with per-branch safety modes and shutdown - branch isolation instead of shared fate.

Side by side, the two generations answer every CDP design question differently:

Making CDPs comparable to pools

The aggregation question, as always: how does something with no deposits, no utilization and a per-borrower rate land in the same unified surface as an Aave market?

• A branch is a market; troves are sub-accounts. Each collateral branch surfaces as one market record. A user's positions come back as one sub-account per trove - matching V2's many-troves-per-wallet reality - plus a dedicated sub-account for their Stability Pool deposit. River's address-keyed troves collapse to a single sub-account per market, same shape.
• The rate card tells the truth. A CDP borrow rate isn't a pool rate, so we don't pretend it is: the market carries the deployment's rate bounds and the live branch average, and each trove position carries its chosen rate. The earn side maps the Stability Pool yield onto the deposit rate every consumer already reads. Utilization, which doesn't exist, is simply not invented.
• The action layer absorbs the sharp edges. CDP writes come with protocol-specific ceremony - insert-position hints for the rate-ordered trove list, fee guards on anything that charges the upfront or mint fee, repayments that must clamp above the minimum-debt floor, closes that burn the live accrued debt rather than a stale quote, plus the long tail (zombie-trove recovery, liquidation-surplus claims). The API quotes and encodes all of it server-side; a consumer calls open, borrow, repay, close like on any other lender.
• Even position discovery differs per generation - V2 troves are NFTs that must be found, River troves are just address lookups - and none of that leaks through the response shape.

One integration, nine deployments, two protocol generations, one shape - the same trick as three generations of Aave, applied to a protocol family that reinvented its own rate model along the way.

Why this matters for builders

CDP borrowing is a genuinely different product, not a variant of pool borrowing. The borrower gets rate control (V2) or near-zero cost (River) and immunity from utilization spikes; in exchange they take on redemption risk - a healthy position can still lose collateral exposure when the peg needs defending. The earn side pays real, interest-funded yield (V2's Stability Pools) without the earn deposit itself ever being borrowed against. For anyone building borrowing UX, margin, or yield products, that's a distinct set of trade-offs worth offering next to pooled markets - and with the whole family surfaced through one API shape, offering it costs one integration, not nine.

One-sentence takeaway

CDP lending replaces the pool with a mint - no depositors, no utilization, a rate someone must choose - and the two live answers to who chooses it (each borrower, in Liquity V2 and its seven forks; the protocol, in River's V1 lineage) both surface through the 1delta API as ordinary markets with sub-account positions.

Where to go next

• API reference - endpoints, response shapes, and x-api-key setup.
• Docs site - supported protocols and network coverage.
• Cross-protocol lending aggregation - the general model CDPs plug into.
• When lending leaves the pool - Morpho Midnight's order book, the other departure from pooled lending.
• How we unify fixed-term lending - the same unification story for fixed-rate, fixed-term markets.