🪙 Day 29 of #30DaysOfSolidity — Building a Collateral-Backed Stablecoin in Solidity — Step-by-Step Guide

Author: Saurav Kumar
Tags: solidity, defi, stablecoin, ethereum, blockchain
Difficulty: Intermediate → Advanced
Reading Time: ~10 minutes

💡 Introduction

In decentralized finance (DeFi), stablecoins play a crucial role in bridging traditional finance and crypto.
They provide price stability, liquidity, and on-chain utility—acting as the backbone of protocols like MakerDAO (DAI), Aave, and Curve.

In this guide, we’ll build a collateral-backed stablecoin named StableUSD (sUSD) using Solidity and Foundry, demonstrating how to maintain a 1:1 peg to the US dollar through collateralization and oracle-based pricing.

This article is part of my DeFi Engineering Series, where I recreate real-world protocols from scratch.

---

🧠 What You’ll Learn

• How stablecoins maintain their price peg
• How to design collateralized minting and redemption flows
• How to integrate oracles (mock or Chainlink-style)
• How to implement collateralization ratios and burn/mint mechanics
• How to test everything using Foundry

---

📂 Project File Structure

Here’s the Foundry project layout:

day-29-stablecoin/
├─ foundry.toml
├─ .gitignore
├─ script/
│   └─ Deploy.s.sol
├─ src/
│   ├─ StableUSD.sol
│   ├─ OracleManager.sol
│   ├─ CollateralPool.sol
│   ├─ Treasury.sol
│   ├─ MockOracle.sol
│   ├─ MockERC20.sol
│   └─ interfaces/
│       └─ IAggregatorV3.sol
└─ test/
    └─ Stablecoin.t.sol

---

🧩 System Overview

Component	Description
StableUSD.sol	ERC20 token for sUSD, mint/burn controlled
OracleManager.sol	Connects to Chainlink or mock price feeds
CollateralPool.sol	Core logic for deposits, minting & redemption
Treasury.sol	Admin contract for reserves and fee collection

---

🏗️ Architecture Diagram

User → CollateralPool → StableUSD  
           ↓  
        OracleManager  
           ↓  
         Treasury

• Users deposit collateral (e.g., WETH).
• OracleManager provides price data in USD.
• CollateralPool mints sUSD tokens based on collateral value.
• Treasury manages reserves and stability actions.

---

⚙️ Setup Commands

forge init day-29-stablecoin
cd day-29-stablecoin
forge install OpenZeppelin/openzeppelin-contracts
forge install foundry-rs/forge-std

---

🧩 Smart Contracts

📁 src/interfaces/IAggregatorV3.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IAggregatorV3 {
    function latestRoundData()
        external
        view
        returns (
            uint80,
            int256 answer,
            uint256,
            uint256,
            uint80
        );
}

---

📁 src/StableUSD.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

contract StableUSD is ERC20, AccessControl {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");

    constructor() ERC20("Stable USD", "sUSD") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {
        _mint(to, amount);
    }

    function burn(address from, uint256 amount) external onlyRole(MINTER_ROLE) {
        _burn(from, amount);
    }
}

✅ Implements ERC20
✅ Controlled mint/burn via roles

---

📁 src/OracleManager.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "./interfaces/IAggregatorV3.sol";

contract OracleManager {
    IAggregatorV3 public oracle;

    constructor(address _oracle) {
        oracle = IAggregatorV3(_oracle);
    }

    function getLatestPrice() external view returns (uint256) {
        (, int256 answer,,,) = oracle.latestRoundData();
        require(answer > 0, "Invalid price");
        return uint256(answer);
    }
}

💡 Use Chainlink price feeds for live ETH/USD in production.

---

📁 src/MockOracle.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract MockOracle {
    int256 private price;

    constructor(int256 _price) {
        price = _price;
    }

    function latestRoundData()
        external
        view
        returns (uint80, int256, uint256, uint256, uint80)
    {
        return (0, price, 0, 0, 0);
    }

    function updatePrice(int256 _price) external {
        price = _price;
    }
}

✅ Simulates Chainlink oracles for local testing

---

📁 src/MockERC20.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MockERC20 is ERC20 {
    constructor(string memory name, string memory symbol) ERC20(name, symbol) {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

✅ Mock collateral asset (like WETH) for testing mint/redeem logic

---

📁 src/CollateralPool.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./StableUSD.sol";
import "./OracleManager.sol";

contract CollateralPool {
    IERC20 public collateral;
    StableUSD public stable;
    OracleManager public oracle;

    uint256 public constant COLLATERAL_RATIO = 150; // 150%
    mapping(address => uint256) public collateralBalance;

    constructor(IERC20 _collateral, StableUSD _stable, OracleManager _oracle) {
        collateral = _collateral;
        stable = _stable;
        oracle = _oracle;
    }

    function deposit(uint256 amount) external {
        require(amount > 0, "Invalid amount");
        collateral.transferFrom(msg.sender, address(this), amount);
        collateralBalance[msg.sender] += amount;
    }

    function mint(uint256 amountCollateral) external {
        require(collateralBalance[msg.sender] >= amountCollateral, "Insufficient collateral");

        uint256 price = oracle.getLatestPrice();
        uint256 usdValue = (amountCollateral * price) / 1e8;
        uint256 mintAmount = (usdValue * 100) / COLLATERAL_RATIO;

        stable.mint(msg.sender, mintAmount * 1e18);
    }

    function redeem(uint256 sUSDAmount) external {
        stable.burn(msg.sender, sUSDAmount);

        uint256 price = oracle.getLatestPrice();
        uint256 collateralToReturn = (sUSDAmount * 1e8 * COLLATERAL_RATIO) / (price * 100);

        require(collateralBalance[msg.sender] >= collateralToReturn, "Not enough collateral");
        collateralBalance[msg.sender] -= collateralToReturn;
        collateral.transfer(msg.sender, collateralToReturn);
    }
}

⚡ Implements over-collateralized mint/redeem flow
⚡ Maintains peg using oracle price
⚡ 150% ratio ensures safety

---

📁 src/Treasury.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Treasury {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    function withdraw(address token, address to, uint256 amount) external {
        require(msg.sender == owner, "Not authorized");
        (bool ok,) = token.call(abi.encodeWithSignature("transfer(address,uint256)", to, amount));
        require(ok, "Transfer failed");
    }
}

✅ Simple treasury for system fund management

---

📁 script/Deploy.s.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "forge-std/Script.sol";
import "../src/StableUSD.sol";
import "../src/OracleManager.sol";
import "../src/CollateralPool.sol";
import "../src/MockERC20.sol";
import "../src/MockOracle.sol";

contract Deploy is Script {
    function run() external {
        vm.startBroadcast();

        MockERC20 collateral = new MockERC20("Wrapped ETH", "WETH");
        MockOracle oracle = new MockOracle(1800e8);
        StableUSD stable = new StableUSD();
        OracleManager oracleManager = new OracleManager(address(oracle));
        CollateralPool pool = new CollateralPool(collateral, stable, oracleManager);

        stable.grantRole(stable.MINTER_ROLE(), address(pool));

        vm.stopBroadcast();
    }
}

✅ Deploys all components in one transaction

---

📁 test/Stablecoin.t.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "forge-std/Test.sol";
import "../src/StableUSD.sol";
import "../src/CollateralPool.sol";
import "../src/OracleManager.sol";
import "../src/MockERC20.sol";
import "../src/MockOracle.sol";

contract StablecoinTest is Test {
    StableUSD stable;
    OracleManager oracle;
    CollateralPool pool;
    MockERC20 collateral;

    function setUp() public {
        collateral = new MockERC20("Wrapped ETH", "WETH");
        stable = new StableUSD();
        oracle = new OracleManager(address(new MockOracle(1800e8)));
        pool = new CollateralPool(IERC20(address(collateral)), stable, oracle);
        stable.grantRole(stable.MINTER_ROLE(), address(pool));
    }

    function testMintStablecoin() public {
        collateral.mint(address(this), 1 ether);
        collateral.approve(address(pool), 1 ether);
        pool.deposit(1 ether);
        pool.mint(1 ether);
        assertGt(stable.balanceOf(address(this)), 0);
    }
}

✅ Tests deposit → mint flow
✅ Confirms minting works using oracle-based pricing

---

🧪 Test & Run

forge build
forge test -vv

---

🧮 Peg Example

If 1 ETH = $1800 and collateral ratio = 150%,
then 1 ETH mints:

(1800 * 100 / 150) = 1200 sUSD

---

🧠 Key Learnings

✅ How stablecoins maintain a peg
✅ Using oracles to stabilize token value
✅ Over-collateralization mechanics
✅ Writing and testing DeFi smart contracts

---

🛡️ Security & Design Notes

• Always use verified Chainlink oracles in production.
• Implement liquidation logic for under-collateralized users.
• Add pause and governance controls for protocol safety.
• Track debt positions per user in a full system.

---

🚀 Next Steps

• Multi-collateral vaults (ETH, USDC, WBTC)
• Dynamic interest and stability fees
• DAO-based parameter governance
• Integration with Uniswap for peg stabilization

---

🧭 Conclusion

Stablecoins are the core monetary layer of DeFi — building one from scratch deepens your understanding of price oracles, collateralization, and supply control.

This StableUSD demo shows how trustless monetary systems can maintain stability purely through code and math.