DeFi Lending Protocols: Aave, Compound, Marginfi Complete Guide 2026

aave = {
    "name": "Aave",
    "token": "AAVE",
    "tvl": "$20B+",
    "chains": ["Ethereum", "Polygon", "Arbitrum", "Optimism", "Avalanche"],
    "features": [
        "Variable borrowing rates",
        "Stable borrowing rates",
        "Flash loans",
        "Credit delegation",
        "Portal (cross-chain)",
        "V3 (Multi-chain)"
    ]
}

compound = {
    "name": "Compound",
    "token": "COMP",
    "tvl": "$2B+",
    "model": "Algorithmically adjusted rates",
    "features": [
        "cTokens",
        "Comp accrual",
        "Governance",
        "Compound V3"
    ]
}

marginfi = {
    "name": "Marginfi",
    "chain": "Solana",
    "focus": "Risk management",
    "features": [
        "Isolated lending pools",
        "Bank-only accounts",
        "Flash loans",
        "Multi-asset collateral"
    ]
}

// Simplified lending pool contract
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

contract SimpleLendingPool is Ownable {
    // Token addresses
    IERC20 public immutable depositToken;
    IERC20 public immutable borrowToken;
    
    // Rate calculations
    uint256 public constant RESERVE_FACTOR = 0.1e18; // 10%
    uint256 public constant INTEREST_RATE_MODEL = 0.1e18;
    
    // State
    uint256 public totalDeposits;
    uint256 public totalBorrows;
    uint256 public totalReserves;
    uint256 public currentBorrowRate;
    uint256 public currentSupplyRate;
    
    // User positions
    mapping(address => uint256) public deposits;
    mapping(address => uint256) public borrows;
    mapping(address => uint256) public depositTimestamps;
    mapping(address => uint256) public borrowTimestamps;
    
    // Collateral
    mapping(address => uint256) public collateralValue;
    mapping(address => mapping(address => uint256)) public collateralDeposited;
    mapping(address => uint256) public collateralFactor;
    
    constructor(address _depositToken, address _borrowToken) {
        depositToken = IERC20(_depositToken);
        borrowToken = IERC20(_borrowToken);
    }
    
    // Supply (deposit) function
    function supply(uint256 amount) external {
        require(amount > 0, "Cannot supply 0");
        
        // Transfer tokens from user
        depositToken.transferFrom(msg.sender, address(this), amount);
        
        // Update state
        deposits[msg.sender] += amount;
        totalDeposits += amount;
        depositTimestamps[msg.sender] = block.timestamp;
        
        // Accrue interest
        _accrueInterest();
        
        // Update supply rate
        _updateSupplyRate();
    }
    
    // Borrow function
    function borrow(uint256 amount) external {
        require(amount > 0, "Cannot borrow 0");
        require(borrows[msg.sender] + amount <= _getMaxBorrow(msg.sender), "Insufficient collateral");
        
        // Transfer borrowed tokens
        borrowToken.transfer(msg.sender, amount);
        
        // Update state
        borrows[msg.sender] += amount;
        totalBorrows += amount;
        borrowTimestamps[msg.sender] = block.timestamp;
        
        // Accrue interest
        _accrueInterest();
        
        // Update rates
        _updateBorrowRate();
    }
    
    // Repay function
    function repay(uint256 amount) external {
        require(amount > 0, "Cannot repay 0");
        require(borrows[msg.sender] > 0, "No debt to repay");
        
        // Calculate repay amount
        uint256 repayAmount = amount > borrows[msg.sender] 
            ? borrows[msg.sender] 
            : amount;
        
        // Transfer tokens from user
        borrowToken.transferFrom(msg.sender, address(this), repayAmount);
        
        // Update state
        borrows[msg.sender] -= repayAmount;
        totalBorrows -= repayAmount;
        
        // Accrue interest
        _accrueInterest();
    }
    
    // Withdraw function
    function withdraw(uint256 amount) external {
        require(amount > 0, "Cannot withdraw 0");
        require(deposits[msg.sender] >= amount, "Insufficient deposit");
        require(deposits[msg.sender] - amount >= borrows[msg.sender] * collateralFactor[msg.sender], 
            "Cannot withdraw: would liquidate");
        
        // Update state
        deposits[msg.sender] -= amount;
        totalDeposits -= amount;
        
        // Calculate withdraw amount + interest
        uint256 withdrawAmount = amount;
        
        // Transfer tokens
        depositToken.transfer(msg.sender, withdrawAmount);
    }
    
    // Interest calculation
    function _accrueInterest() internal {
        // Simplified: would calculate time-based interest
        uint256 timeElapsed = block.timestamp - lastAccrualTime;
        if (timeElapsed > 0) {
            uint256 interest = (totalBorrows * currentBorrowRate * timeElapsed) / 365 days;
            totalBorrows += interest;
        }
    }
    
    // Update borrow rate based on utilization
    function _updateBorrowRate() internal {
        uint256 utilization = totalDeposits > 0 
            ? (totalBorrows * 1e18) / totalDeposits 
            : 0;
        
        // Linear rate model
        currentBorrowRate = INTEREST_RATE_MODEL + (utilization * INTEREST_RATE_MODEL / 1e18);
    }
    
    function _updateSupplyRate() internal {
        uint256 utilization = totalDeposits > 0 
            ? (totalBorrows * 1e18) / totalDeposits 
            : 0;
        
        currentSupplyRate = (currentBorrowRate * utilization * (1e18 - RESERVE_FACTOR)) / 1e18;
    }
    
    function _getMaxBorrow(address user) internal view returns (uint256) {
        return collateralValue[user] * collateralFactor[user] - borrows[user];
    }
}

# Common interest rate models
interest_rate_models = {
    "linear": {
        "formula": "rate = base + utilization * slope",
        "example": "0 + utilization * 0.15"
    },
    "jump": {
        "formula": "rate = base + min(utilization, kink) * slope1 + max(0, utilization - kink) * slope2",
        "description": "Rates jump after a certain utilization (kink)"
    },
    "aave": {
        "variable": "Rates adjust continuously based on utilization",
        "stable": "Fixed rate for period, then adjusts"
    }
}

// Liquidation mechanism
function liquidate(
    address borrower,
    address collateralAsset,
    uint256 amount
) external {
    // Check if borrower is undercollateralized
    require(
        _getAccountHealth(borrower) < 1e18,
        "Account is healthy"
    );
    
    // Calculate liquidation bonus
    uint256 bonus = (amount * LIQUIDATION_BONUS) / 1e18;
    
    // Transfer collateral to liquidator
    IERC20(collateralAsset).transfer(
        msg.sender,
        collateralAmount + bonus
    );
    
    // Reduce borrower's debt
    borrows[borrower] -= amount;
    totalBorrows -= amount;
}

# Health factor calculation
def calculate_health_factor(borrows, collateral, prices):
    """
    Health Factor = (Collateral Value * Threshold) / Borrowed Value
    
    Health Factor > 1: Healthy
    Health Factor < 1: Liquidatable
    """
    total_collateral_value = sum(
        collateral[asset] * prices[asset] * liquidation_threshold[asset]
        for asset in collateral
    )
    
    total_borrow_value = sum(
        borrows[asset] * prices[asset]
        for asset in borrows
    )
    
    if total_borrow_value == 0:
        return float('inf')  # No debt = infinite health
    
    health_factor = total_collateral_value / total_borrow_value
    
    return health_factor

# Typical risk parameters
risk_params = {
    "collateral_factors": {
        "ETH": 0.80,    # Can borrow 80% of ETH value
        "WBTC": 0.70,   # Can borrow 70% of BTC value
        "USDC": 0.90,   # Can borrow 90% of stablecoin value
        "DOGE": 0.40    # Can borrow 40% of volatile asset
    },
    "liquidation_threshold": {
        "ETH": 0.85,   # Liquidate at 85% LTV
        "WBTC": 0.75,
        "USDC": 0.95,
        "DOGE": 0.50
    },
    "liquidation_bonus": "5-10%"
}

// Aave Flash Loan
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IFlashLoanReceiver {
    function executeOperation(
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata premiums,
        address initiator,
        bytes calldata params
    ) external returns (bool);
}

contract FlashLoanExample is IFlashLoanReceiver {
    IFlashLoan public flashLoanPool;
    
    function executeFlashLoan(uint256 amount) external {
        address[] memory assets = new address[](1);
        assets[0] = address(USDC);
        
        uint256[] memory amounts = new uint256[](1);
        amounts[0] = amount;
        
        uint256[] memory modes = new uint256[](1);
        modes[0] = 0; // 0 = repay, 1 = don't repay (as collateral)
        
        flashLoanPool.flashLoan(
            address(this),
            assets,
            amounts,
            modes,
            address(this),
            bytes(""),
            0
        );
    }
    
    function executeOperation(
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata premiums,
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        // Your logic here (arbitrage, liquidation, etc.)
        
        // Approve repay
        for (uint i = 0; i < assets.length; i++) {
            uint256 amountOwing = amounts[i] + premiums[i];
            IERC20(assets[i]).approve(address(flashLoanPool), amountOwing);
        }
        
        return true;
    }
}

# Credit delegation allows trusted addresses to borrow on your behalf
credit_delegation = {
    "use_case": "Allow another wallet to borrow against your collateral",
    "benefits": [
        "Earn yield on deposits while allowing borrowing",
        "No need to move funds",
        "Set limits and trusted addresses"
    ]
}

# Marginfi's isolated pools
isolated_pools = {
    "description": "Separate pools for different risk profiles",
    "benefit": "If one pool fails, others are protected",
    "example": "Each asset pair has its own liquidity pool"
}

# Earn while borrowing
strategy = {
    "deposit": "Supply ETH to earn ~3-4%",
    "borrow": "Borrow USDC against ETH at ~5%",
    "invest": "Put borrowed USDC in higher yield (e.g., 8%)",
    "net": "Earn ~3% on borrowed capital",
    "risk": "If ETH drops, liquidation risk"
}

# Leverage strategy
leverage_strategy = {
    "step1": "Supply 1 ETH (worth $3000)",
    "step2": "Borrow 2000 USDC (66% LTV)",
    "step3": "Swap USDC for ETH",
    "step4": "Supply new ETH, repeat",
    "result": "3x leverage - 3 ETH exposure for 1 ETH",
    "risk": "High liquidation risk if ETH drops"
}

# Move collateral to optimize
collateral_switching = {
    "scenario": "Higher yields available on different asset",
    "action": [
        "Repay borrow with stablecoin",
        "Withdraw volatile collateral",
        "Supply volatile collateral to high-yield protocol",
        "Borrow stablecoin again"
    ]
}

security_risks = {
    "reentrancy": "External calls before state updates",
    "overflow": "Math errors in calculations",
    "oracle_manipulation": "Fake price data",
    "liquidation_bots": "MEV extraction"
}

safety_practices = {
    "keep_healthy_hf": "Stay above 1.5 health factor",
    "diversify": "Don't put all in one collateral",
    "monitor": "Watch positions actively",
    "set_alerts": "Get notified of price movements",
    "leave_buffer": "Don't max out borrowing"
}

future_trends = {
    "2026": [
        "Institutional integration",
        "Real-world asset collateral",
        "Credit scoring on-chain",
        "Cross-chain lending"
    ],
    "2027_2028": [
        "AI-powered risk management",
        "Automated portfolio management",
        "Permissioned pools",
        "Identity integration"
    ]
}

innovations = {
    "real_world_assets": "Use real estate, invoices as collateral",
    "income_derivative": "Stream income as collateral",
    "nft_collateral": "NFT-backed loans",
    "credit_scoring": "On-chain reputation scores"
}