🔄 第17课：去中心化交易所

DeFi 阶段四 ✅ 验证通过

📖 一、中心化交易所 vs 去中心化交易所

📖 二、AMM核心原理

2.1 恒定乘积公式

x × y = k —— 流动性池中两种代币数量的乘积保持恒定。

2.2 滑点与价格影响

📖 三、实现简易DEX

// contracts/SimpleDEX.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/**
 * @title SimpleDEX
 * @dev 基于恒定乘积公式的去中心化交易所
 */
contract SimpleDEX {
    using SafeERC20 for IERC20;

    address public immutable tokenA;  // 例如: WETH
    address public immutable tokenB;  // 例如: USDC
    uint256 public reserveA;          // TokenA储备量
    uint256 public reserveB;          // TokenB储备量
    uint256 public feeRate;           // 手续费率（基点，如30=0.3%）
    uint256 public constant FEE_DENOMINATOR = 10000;

    mapping(address => uint256) public liquidity;   // LP份额
    uint256 public totalLiquidity;                          // 总LP份额

    event Swap(address indexed user, address tokenIn, uint256 amountIn, address tokenOut, uint256 amountOut);
    event LiquidityAdded(address indexed provider, uint256 amountA, uint256 amountB, uint256 shares);
    event LiquidityRemoved(address indexed provider, uint256 amountA, uint256 amountB, uint256 shares);

    constructor(address _tokenA, address _tokenB, uint256 _feeRate) {
        require(_tokenA != _tokenB, "Same token");
        require(_feeRate < 1000, "Fee too high"); // 最高10%
        tokenA = _tokenA;
        tokenB = _tokenB;
        feeRate = _feeRate;
    }

    // ═══════ 添加流动性 ═══════
    function addLiquidity(uint256 amountA, uint256 amountB) external returns (uint256 shares) {
        require(amountA > 0 && amountB > 0, "Zero amounts");

        if (totalLiquidity == 0) {
            // 首次添加流动性：份额 = √(amountA × amountB)
            shares = sqrt(amountA * amountB);
        } else {
            // 后续添加：按比例计算份额
            shares = min(
                (amountA * totalLiquidity) / reserveA,
                (amountB * totalLiquidity) / reserveB
            );
        }

        require(shares > 0, "Insufficient shares");

        // 转入代币
        IERC20(tokenA).safeTransferFrom(msg.sender, address(this), amountA);
        IERC20(tokenB).safeTransferFrom(msg.sender, address(this), amountB);

        // 更新状态
        reserveA += amountA;
        reserveB += amountB;
        liquidity[msg.sender] += shares;
        totalLiquidity += shares;

        emit LiquidityAdded(msg.sender, amountA, amountB, shares);
    }

    // ═══════ 移除流动性 ═══════
    function removeLiquidity(uint256 shares) external returns (uint256 amountA, uint256 amountB) {
        require(shares > 0, "Zero shares");
        require(liquidity[msg.sender] >= shares, "Insufficient shares");

        // 按份额比例计算可取回的代币
        amountA = (shares * reserveA) / totalLiquidity;
        amountB = (shares * reserveB) / totalLiquidity;

        // 更新状态
        liquidity[msg.sender] -= shares;
        totalLiquidity -= shares;
        reserveA -= amountA;
        reserveB -= amountB;

        // 转出代币
        IERC20(tokenA).safeTransfer(msg.sender, amountA);
        IERC20(tokenB).safeTransfer(msg.sender, amountB);

        emit LiquidityRemoved(msg.sender, amountA, amountB, shares);
    }

    // ═══════ 交换代币 ═══════
    function swapAForB(uint256 amountIn, uint256 minAmountOut) external returns (uint256 amountOut) {
        require(amountIn > 0, "Zero input");

        // 计算手续费后的输入
        uint256 amountInWithFee = amountIn * (FEE_DENOMINATOR - feeRate) / FEE_DENOMINATOR;
        
        // 恒定乘积公式: (reserveA + amountInWithFee) * (reserveB - amountOut) = reserveA * reserveB
        amountOut = (reserveB * amountInWithFee) / (reserveA + amountInWithFee);
        
        // 滑点保护
        require(amountOut >= minAmountOut, "Slippage exceeded");

        // 转入tokenA，转出tokenB
        IERC20(tokenA).safeTransferFrom(msg.sender, address(this), amountIn);
        IERC20(tokenB).safeTransfer(msg.sender, amountOut);

        // 更新储备量
        reserveA += amountIn;
        reserveB -= amountOut;

        emit Swap(msg.sender, tokenA, amountIn, tokenB, amountOut);
    }

    function swapBForA(uint256 amountIn, uint256 minAmountOut) external returns (uint256 amountOut) {
        require(amountIn > 0, "Zero input");

        uint256 amountInWithFee = amountIn * (FEE_DENOMINATOR - feeRate) / FEE_DENOMINATOR;
        amountOut = (reserveA * amountInWithFee) / (reserveB + amountInWithFee);
        require(amountOut >= minAmountOut, "Slippage exceeded");

        IERC20(tokenB).safeTransferFrom(msg.sender, address(this), amountIn);
        IERC20(tokenA).safeTransfer(msg.sender, amountOut);

        reserveB += amountIn;
        reserveA -= amountOut;

        emit Swap(msg.sender, tokenB, amountIn, tokenA, amountOut);
    }

    // ═══════ 查询函数 ═══════
    function getAmountOut(address tokenIn, uint256 amountIn) external view returns (uint256) {
        uint256 amountInWithFee = amountIn * (FEE_DENOMINATOR - feeRate) / FEE_DENOMINATOR;
        if (tokenIn == tokenA) {
            return (reserveB * amountInWithFee) / (reserveA + amountInWithFee);
        } else {
            return (reserveA * amountInWithFee) / (reserveB + amountInWithFee);
        }
    }

    function getPrice() external view returns (uint256) {
        require(reserveA > 0, "No liquidity");
        return (reserveB * 1e18) / reserveA;  // 价格精度18位小数
    }

    // ═══════ 辅助函数 ═══════
    function sqrt(uint256 y) internal pure returns (uint256 z) {
        if (y > 3) {
            z = y;
            uint256 x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
}

📖 四、无常损失

📖 五、Uniswap演进

🧪 练习

📖 八、自动做市商数学深入

// 恒定乘积公式推导
// 初始: x₀ * y₀ = k
// 用Δx换Δy: (x₀ + Δx) * (y₀ - Δy) = k
// Δy = y₀ - k/(x₀ + Δx)
// Δy = y₀ * Δx / (x₀ + Δx)

// 考虑手续费(0.3%):
// 有效输入: Δx * (1 - 0.003) = Δx * 997/1000
// Δy = y₀ * (Δx * 997/1000) / (x₀ + Δx * 997/1000)

// 价格影响(滑点):
// priceImpact = 1 - Δy/Δx / (y₀/x₀)
// = 1 - y₀*x₀ / ((x₀+Δx)*y₀/Δy) ≈ Δx/x₀ (小量近似)

// ✅ 池子越大, 同等交易量滑点越小
// 这就是为什么流动性深度如此重要!