去中心化交易所 #

恒定乘积公式：x * y = k

x: 代币A数量
y: 代币B数量
k: 恒定乘积

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

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

contract SimpleDEX is ERC20 {
    IERC20 public token0;
    IERC20 public token1;
    
    uint256 public constant FEE_NUMERATOR = 997;
    uint256 public constant FEE_DENOMINATOR = 1000;
    
    constructor(address _token0, address _token1) ERC20("LP Token", "LP") {
        token0 = IERC20(_token0);
        token1 = IERC20(_token1);
    }
    
    function addLiquidity(
        uint256 amount0,
        uint256 amount1
    ) public returns (uint256 liquidity) {
        token0.transferFrom(msg.sender, address(this), amount0);
        token1.transferFrom(msg.sender, address(this), amount1);
        
        uint256 totalSupply_ = totalSupply();
        
        if (totalSupply_ == 0) {
            liquidity = sqrt(amount0 * amount1);
        } else {
            liquidity = min(
                (amount0 * totalSupply_) / token0.balanceOf(address(this)),
                (amount1 * totalSupply_) / token1.balanceOf(address(this))
            );
        }
        
        require(liquidity > 0, "Insufficient liquidity");
        _mint(msg.sender, liquidity);
    }
    
    function removeLiquidity(uint256 liquidity) public returns (uint256 amount0, uint256 amount1) {
        uint256 totalSupply_ = totalSupply();
        
        amount0 = (liquidity * token0.balanceOf(address(this))) / totalSupply_;
        amount1 = (liquidity * token1.balanceOf(address(this))) / totalSupply_;
        
        _burn(msg.sender, liquidity);
        
        token0.transfer(msg.sender, amount0);
        token1.transfer(msg.sender, amount1);
    }
    
    function swap(
        address tokenIn,
        uint256 amountIn,
        uint256 amountOutMin
    ) public returns (uint256 amountOut) {
        require(tokenIn == address(token0) || tokenIn == address(token1), "Invalid token");
        
        IERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn);
        
        bool isToken0 = tokenIn == address(token0);
        
        (IERC20 tokenIn_, IERC20 tokenOut_) = isToken0 
            ? (token0, token1) 
            : (token1, token0);
        
        uint256 reserveIn = tokenIn_.balanceOf(address(this));
        uint256 reserveOut = tokenOut_.balanceOf(address(this));
        
        amountOut = getAmountOut(amountIn, reserveIn, reserveOut);
        
        require(amountOut >= amountOutMin, "Slippage too high");
        
        tokenOut_.transfer(msg.sender, amountOut);
    }
    
    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) public pure returns (uint256) {
        uint256 amountInWithFee = (amountIn * FEE_NUMERATOR) / FEE_DENOMINATOR;
        return (amountInWithFee * reserveOut) / (reserveIn + amountInWithFee);
    }
    
    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;
    }
}

// x * y = k
// 价格 = y / x

function getPrice(
    uint256 reserveIn,
    uint256 reserveOut
) public pure returns (uint256) {
    return (reserveOut * 1e18) / reserveIn;
}

function calculateSlippage(
    uint256 amountIn,
    uint256 reserveIn,
    uint256 reserveOut
) public pure returns (uint256) {
    uint256 amountOut = getAmountOut(amountIn, reserveIn, reserveOut);
    uint256 spotPrice = reserveOut / reserveIn;
    uint256 effectivePrice = amountOut / amountIn;
    
    return ((spotPrice - effectivePrice) * 100) / spotPrice;
}

// 使用缓存减少存储读取
function swapOptimized(
    address tokenIn,
    uint256 amountIn,
    uint256 amountOutMin
) public returns (uint256 amountOut) {
    uint256 reserve0 = token0.balanceOf(address(this));
    uint256 reserve1 = token1.balanceOf(address(this));
    
    // 使用缓存的值进行计算
    // ...
}