Building DeFi Applications: A Comprehensive Development Guide for 2025

contract LendingPool {
    mapping(address => uint256) public deposits;
    mapping(address => uint256) public borrows;
    mapping(address => uint256) public collateral;
    
    uint256 public totalDeposits;
    uint256 public totalBorrows;
    uint256 public constant COLLATERAL_RATIO = 150; // 150%
    
    IOracle public priceOracle;
    IInterestRateModel public interestModel;
    
    function deposit(uint256 amount) external {
        require(amount > 0, "Amount must be positive");
        token.transferFrom(msg.sender, address(this), amount);
        deposits[msg.sender] += amount;
        totalDeposits += amount;
        emit Deposit(msg.sender, amount);
    }
    
    function borrow(uint256 amount) external {
        require(amount > 0, "Amount must be positive");
        
        // Check collateralization
        uint256 maxBorrow = calculateMaxBorrow(msg.sender);
        require(borrows[msg.sender] + amount <= maxBorrow, 
                "Insufficient collateral");
        
        borrows[msg.sender] += amount;
        totalBorrows += amount;
        
        token.transfer(msg.sender, amount);
        emit Borrow(msg.sender, amount);
    }
    
    function calculateMaxBorrow(address user) public view returns (uint256) {
        uint256 collateralValue = collateral[user] * 
                                  priceOracle.getPrice(collateralToken);
        return (collateralValue * 100) / COLLATERAL_RATIO;
    }
    
    function liquidate(address borrower) external {
        uint256 healthFactor = calculateHealthFactor(borrower);
        require(healthFactor < 1e18, "Position is healthy");
        
        // Liquidation logic with bonus for liquidator
        uint256 debtToCover = borrows[borrower];
        uint256 collateralToSeize = calculateCollateralToSeize(
            debtToCover, 
            borrower
        );
        
        // Transfer logic...
        emit Liquidation(borrower, msg.sender, debtToCover);
    }
}

contract SimpleAMM {
    uint256 public reserveA;
    uint256 public reserveB;
    uint256 public constant FEE = 30; // 0.3%
    
    mapping(address => uint256) public liquidityTokens;
    uint256 public totalLiquidity;
    
    function addLiquidity(uint256 amountA, uint256 amountB) external {
        require(amountA > 0 && amountB > 0, "Invalid amounts");
        
        tokenA.transferFrom(msg.sender, address(this), amountA);
        tokenB.transferFrom(msg.sender, address(this), amountB);
        
        uint256 liquidity;
        if (totalLiquidity == 0) {
            liquidity = sqrt(amountA * amountB);
        } else {
            liquidity = min(
                (amountA * totalLiquidity) / reserveA,
                (amountB * totalLiquidity) / reserveB
            );
        }
        
        liquidityTokens[msg.sender] += liquidity;
        totalLiquidity += liquidity;
        
        reserveA += amountA;
        reserveB += amountB;
        
        emit LiquidityAdded(msg.sender, amountA, amountB, liquidity);
    }
    
    function swap(
        address tokenIn, 
        uint256 amountIn
    ) external returns (uint256 amountOut) {
        require(amountIn > 0, "Amount must be positive");
        
        bool isTokenA = tokenIn == address(tokenA);
        (uint256 reserveIn, uint256 reserveOut) = isTokenA ? 
            (reserveA, reserveB) : (reserveB, reserveA);
        
        // Apply fee
        uint256 amountInWithFee = amountIn * (10000 - FEE);
        
        // Calculate output using constant product formula
        amountOut = (amountInWithFee * reserveOut) / 
                    (reserveIn * 10000 + amountInWithFee);
        
        // Update reserves
        if (isTokenA) {
            reserveA += amountIn;
            reserveB -= amountOut;
        } else {
            reserveB += amountIn;
            reserveA -= amountOut;
        }
        
        // Transfer tokens
        IERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn);
        (isTokenA ? tokenB : tokenA).transfer(msg.sender, amountOut);
        
        emit Swap(msg.sender, tokenIn, amountIn, amountOut);
    }
}

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract PriceConsumer {
    AggregatorV3Interface internal priceFeed;
    
    constructor(address _priceFeed) {
        priceFeed = AggregatorV3Interface(_priceFeed);
    }
    
    function getLatestPrice() public view returns (int256) {
        (
            uint80 roundID,
            int256 price,
            uint256 startedAt,
            uint256 timeStamp,
            uint80 answeredInRound
        ) = priceFeed.latestRoundData();
        
        // Validate price feed data
        require(timeStamp > 0, "Round not complete");
        require(answeredInRound >= roundID, "Stale price");
        require(price > 0, "Invalid price");
        
        return price;
    }
    
    function getPriceWithSanityCheck() public view returns (uint256) {
        int256 price = getLatestPrice();
        
        // Implement additional sanity checks
        // Compare with historical average, check for dramatic changes
        
        return uint256(price);
    }
}