A stablecoin is a cryptocurrency whose buying power stays relatively the same with the passing of time. ## The 3 functions of money - Storage of Value -> a way to keep the value we generated ()e.g: buying crypto, stocks...) - Unit of Account -> a way to measure how valuable something is (e.g: prices in dollars (good). prices in bitcoins (bad, because the prices would fluctuate all the time) - Medium of Exchange -> an agreed upon method to transact with each other # Categories ### Relative stability (pegged / anchored or floating) ***Pegged*** -> have their value tied to another asset (USDC) ***Floating*** -> use math and other mechanisms to maintain a constant buying power (RYE - Reflexor Labs) ### Stability method (governed or algorithmic) ***Governed*** -> there's a centralized entity burning and minting stablecoins (bad) (USDC, USDT, TUSD) ***Algorithmic*** -> the stability is maintained by a permissionless algorithm that mints and burns tokens with no human intervention (xDAI, RYE) ### Collateral type (endogenous or exogenous) USDC is collateralized by the US Dollar (exogenous, because the US Dollar doesn't depend on USDC) xDAI is collateralized by many assets (ETH...) (exogenous, because ETH doesn't depend on the value of xDAI) Exogenous collateral is collateral that originates from outside the protocol Endogenous collateral is collateral that originates from inside the protocol. > If the stablecoin fails, does the underlying collateral also fail? If yes, it's endogenous. If not, it's exogenous. ### What is Collateral? **Collateral** is basically an asset you put up as a safety net when you’re borrowing something. Think of it like a deposit you give to prove you’re good for the loan. In traditional finance, it’s super common—like when you take out a mortgage to buy a house, the house itself becomes the collateral. If you can’t pay back the loan, the bank can take the house to cover their losses. In the **web3 world**, collateral works in a similar way but with digital assets, and it’s all managed by smart contracts instead of banks. For example, in decentralized finance (DeFi), you might lock up some cryptocurrency—like Ethereum (ETH)—as collateral to borrow another asset, say a stablecoin like DAI. The smart contract enforces the rules: it holds your ETH and decides how much you can borrow based on its value. If things go south and you don’t repay, the contract can automatically sell your ETH to settle the debt. No middleman, just code doing the heavy lifting! --- ### What Does "Over-Collateralized" Mean? Now, **over-collateralized** is when the value of the collateral you put up is _higher_ than the value of what you’re borrowing. It’s like giving extra security to make sure the lender (or the protocol, in DeFi) is protected, especially since crypto prices can swing wildly. Here’s an example: - You want to borrow $100 worth of a stablecoin. - The protocol says, “Cool, but you need to lock up $150 worth of ETH as collateral.” Why the extra $50? It’s a buffer. Crypto prices are volatile—ETH could drop in value overnight. If it falls too much, the protocol needs enough collateral to still cover the $100 loan. In DeFi, over-collateralization is standard because there’s no credit check or trust involved; the system relies purely on the value of your assets and the code. ### Collateral in Stablecoins: A Web3 Twist Stablecoins—like USDC, UST, or DAI—bring collateral into focus in a different way. They’re designed to hold a steady value (usually $1), and collateral often backs that stability. But not all stablecoins handle collateral the same way, which ties into the document you shared about algorithmic stablecoins. - **Anchored Stablecoins** (e.g., USDC, USDT): These are typically backed by external assets like fiat dollars or other stable stuff held in reserve. Think of it as collateral that’s outside the crypto ecosystem, giving it more stability (in theory—there’s debate about whether they’re fully backed). - **Reflexive Stablecoins** (e.g., UST with LUNA): These use collateral from within their own system, like LUNA tokens backing UST. The catch? If the system’s value tanks (like LUNA’s crash), the collateral loses worth too, and the whole thing can spiral out of control. In the reflexive case, over-collateralization might not save you if the collateral itself is tied to the system’s health. That’s why UST collapsed—its collateral (LUNA) wasn’t independent enough to weather the storm. --- ### Why Over-Collateralization Matters in DeFi In DeFi lending or stablecoin systems, over-collateralization is a shield against volatility. For instance: - If you use a volatile token as collateral (say, a reflexive system’s token), the protocol might demand 150% or even 200% of the loan value to cover potential price drops. - With something like ETH in MakerDAO, you might lock up $150 of ETH to borrow $100 of DAI. If ETH dips, the extra collateral gives the system wiggle room before it has to liquidate you. Smart contracts enforce this automatically. They’ll check the collateral’s value in real-time (via price oracles) and liquidate if it falls below a threshold. It’s all coded, trustless, and fast—perfect for the web3 vibe you’re already familiar with! --- ### Tying It Together with an Analogy Imagine you’re lending a friend $100, but you ask them to leave their $150 gaming console with you as collateral. If they don’t pay you back, you sell the console—it’s worth more than the loan, so you’re covered even if its value drops a bit. In web3, the smart contract is you, the crypto is the console, and over-collateralization ensures there’s always enough value to settle the debt, no trust required.