assetxContracts/doc/YT-LiquidityPool设计方案.md

# YT流动性池合约设计方案
## 基于GMX GLP核心概念的YT代币流动性池系统

---

## 1. 项目概述

### 1.1 设计目标

基于GMX GLP原理，设计一个支持多种YT（Yield Token）代币的流动性池系统。

**核心特点**：
- **一篮子YT代币**: YT-A, YT-B, YT-C等（不同的收益代币）
- **WUSD代币支持**: 支持WUSD稳定币（地址: `0x7Cd017ca5ddb86861FA983a34b5F495C6F898c41`）
- **统一底层**: 所有YT都基于USDC
- **LP代币（ytLP）**: 代表用户在池子中的份额
- **Swap功能**: YT-A ↔ YT-B ↔ YT-C ↔ WUSD
- **计价单位**: USDY（完全模拟GMX的USDG）
- **动态手续费**: 根据池子占比自动调整手续费
- **自动复利**: 手续费直接留在池子中，ytLP价值自动增长

### 1.2 架构对比

| 特性 | GMX GLP | YT流动性池 |
|------|---------|-----------|
| **资产类型** | 多种加密资产 | 多种YT代币 + WUSD |
| **代币示例** | ETH, WBTC, USDC, USDT | YT-A, YT-B, YT-C, WUSD |
| **底层资产** | 各不相同 | YT代币（YT本身基于USDC） |
| **主要用途** | 为永续合约提供流动性 | YT代币互换 |
| **计价单位** | USDG | USDY |
| **动态手续费** | ✅ | ✅ |
| **收益来源** | 手续费 + 交易者损失 | 仅Swap手续费 |
| **LP代币** | GLP | ytLP |

### 1.3 三层架构说明

```
层次1: YT流动性池
├─ 底层资产：YT-A, YT-B, YT-C, WUSD（池子实际持有的）
├─ 计价单位：USDY
└─ LP代币：ytLP

层次2: YT代币本身
├─ YT-A：ERC4626代币，本金是USDC
├─ YT-B：ERC4626代币，本金是USDC
└─ YT-C：ERC4626代币，本金是USDC

层次3: 底层资产
└─ USDC：所有YT的本金资产
```

---

## 2. 系统架构

```
┌─────────────────────────────────────────┐
│          用户交互层                       │
│       YTRewardRouter.sol                │
│    (addLiquidity / removeLiquidity)     │
└──────────────┬──────────────────────────┘
               │
    ┌──────────┴─────────────┐
    ▼                        ▼
┌───────────────┐     ┌──────────────────┐
│ YTPoolManager │◄────│  YTVault         │
│ (流动性管理)   │     │  (资金池+动态费率)│
└───────┬───────┘     └──────┬───────────┘
        │                    │
        │                    ├──► YT-A (40%)
        │                    ├──► YT-B (30%)
        │                    ├──► YT-C (20%)
        │                    └──► WUSD (10%)
        ▼
┌───────────────┐
│  ytLP Token   │
│  (ERC20)      │
│  持有即增值    │
└───────────────┘

辅助合约:
├─ USDY.sol (统一计价代币)
└─ YTPriceFeed.sol (价格读取器)
```

---

## 3. 核心合约设计

### 3.1 USDY Token (USDY.sol)

**功能**: 统一计价代币，完全模拟GMX的USDG

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

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

contract USDY is ERC20, Ownable {
    mapping(address => bool) public vaults;
    
    event VaultAdded(address indexed vault);
    event VaultRemoved(address indexed vault);
    
    modifier onlyVault() {
        require(vaults[msg.sender], "USDY: forbidden");
        _;
    }
    
    constructor(address _vault) ERC20("YT USD", "USDY") {
        vaults[_vault] = true;
    }
    
    function addVault(address _vault) external onlyOwner {
        vaults[_vault] = true;
        emit VaultAdded(_vault);
    }
    
    function removeVault(address _vault) external onlyOwner {
        vaults[_vault] = false;
        emit VaultRemoved(_vault);
    }
    
    function mint(address _account, uint256 _amount) external onlyVault {
        _mint(_account, _amount);
    }
    
    function burn(address _account, uint256 _amount) external onlyVault {
        _burn(_account, _amount);
    }
}
```

**关键特性**:
- 授权铸造：只有授权合约可以mint/burn
- ERC20标准：可在合约间转移
- 价值传递：作为Vault和PoolManager之间的中介
- 计价单位：1 USDY ≈ $1

---

### 3.2 ytLP Token (YTLPToken.sol)

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

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

contract YTLPToken is ERC20, Ownable {
    mapping(address => bool) public isMinter;
    
    constructor() ERC20("YT Liquidity Provider", "ytLP") {}
    
    modifier onlyMinter() {
        require(isMinter[msg.sender], "YTLPToken: not minter");
        _;
    }
    
    function setMinter(address _minter, bool _isActive) external onlyOwner {
        isMinter[_minter] = _isActive;
    }
    
    function mint(address _to, uint256 _amount) external onlyMinter {
        _mint(_to, _amount);
    }
    
    function burn(address _from, uint256 _amount) external onlyMinter {
        _burn(_from, _amount);
    }
}
```

---

### 3.3 YT Vault (YTVault.sol)

**功能**: 核心资金池，处理YT代币的存储、交换和手续费

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

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

contract YTVault is ReentrancyGuard {
    using SafeERC20 for IERC20;
    
    // ========== 常量 ==========
    uint256 public constant PRICE_PRECISION = 10 ** 30;
    uint256 public constant BASIS_POINTS_DIVISOR = 10000;
    uint256 public constant USDY_DECIMALS = 18;
    
    // ========== 状态变量 ==========
    address public gov;
    address public ytPoolManager;
    address public priceFeed;
    address public usdy;
    
    bool public isSwapEnabled = true;
    bool public emergencyMode = false;
    
    // 代币白名单
    address[] public allWhitelistedTokens;
    mapping(address => bool) public whitelistedTokens;
    mapping(address => uint256) public tokenDecimals;
    mapping(address => uint256) public tokenWeights;
    uint256 public totalTokenWeights;
    
    // 池子资产
    mapping(address => uint256) public poolAmounts;
    mapping(address => uint256) public bufferAmounts;
    mapping(address => uint256) public reservedAmounts;
    mapping(address => uint256) public tokenBalances; // 跟踪实际代币余额
    
    // USDY债务追踪（用于动态手续费）
    mapping(address => uint256) public usdyAmounts;
    mapping(address => uint256) public maxUsdyAmounts;
    
    // 手续费配置
    uint256 public swapFeeBasisPoints = 30;
    uint256 public stableSwapFeeBasisPoints = 4;
    uint256 public taxBasisPoints = 50;
    uint256 public stableTaxBasisPoints = 20;
    bool public hasDynamicFees = true;
    
    // 全局滑点保护
    uint256 public maxSwapSlippageBps = 1000; // 10% 最大滑点
    
    // 单笔交易限额
    mapping(address => uint256) public maxSwapAmount;
    
    // 断路器参数
    uint256 public dailySwapLimit;
    uint256 public currentDaySwapVolume;
    uint256 public lastSwapDay;
    
    // ========== 事件 ==========
    event Swap(address indexed account, address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut, uint256 feeBasisPoints);
    event AddLiquidity(address indexed account, address indexed token, uint256 amount, uint256 wusdAmount);
    event RemoveLiquidity(address indexed account, address indexed token, uint256 wusdAmount, uint256 amountOut);
    
    // ========== 修饰符 ==========
    modifier onlyGov() {
        require(msg.sender == gov, "YTVault: forbidden");
        _;
    }
    
    modifier onlyPoolManager() {
        require(msg.sender == ytPoolManager, "YTVault: only pool manager");
        _;
    }
    
    modifier notInEmergency() {
        require(!emergencyMode, "YTVault: emergency mode");
        _;
    }
    
    // ========== 构造函数 ==========
    constructor(address _usdy, address _priceFeed) {
        gov = msg.sender;
        usdy = _usdy;
        priceFeed = _priceFeed;
    }
    
    // ========== 管理函数 ==========
    
    function setPoolManager(address _manager) external onlyGov {
        ytPoolManager = _manager;
    }
    
    function setWhitelistedToken(
        address _token,
        uint256 _decimals,
        uint256 _weight,
        uint256 _maxUsdyAmount
    ) external onlyGov {
        if (!whitelistedTokens[_token]) {
            allWhitelistedTokens.push(_token);
            whitelistedTokens[_token] = true;
        }
        
        totalTokenWeights = totalTokenWeights - tokenWeights[_token] + _weight;
        tokenDecimals[_token] = _decimals;
        tokenWeights[_token] = _weight;
        maxUsdyAmounts[_token] = _maxUsdyAmount;
    }
    
    function clearWhitelistedToken(address _token) external onlyGov {
        require(whitelistedTokens[_token], "YTVault: token not whitelisted");
        totalTokenWeights = totalTokenWeights - tokenWeights[_token];
        delete whitelistedTokens[_token];
        delete tokenDecimals[_token];
        delete tokenWeights[_token];
        delete maxUsdyAmounts[_token];
    }
    
    function setSwapFees(
        uint256 _swapFee,
        uint256 _stableSwapFee,
        uint256 _taxBasisPoints,
        uint256 _stableTaxBasisPoints
    ) external onlyGov {
        require(_swapFee <= 100, "YTVault: invalid swap fee");
        require(_stableSwapFee <= 50, "YTVault: invalid stable swap fee");
        swapFeeBasisPoints = _swapFee;
        stableSwapFeeBasisPoints = _stableSwapFee;
        taxBasisPoints = _taxBasisPoints;
        stableTaxBasisPoints = _stableTaxBasisPoints;
    }
    
    function setDynamicFees(bool _hasDynamicFees) external onlyGov {
        hasDynamicFees = _hasDynamicFees;
    }
    
    function setEmergencyMode(bool _emergencyMode) external onlyGov {
        emergencyMode = _emergencyMode;
    }
    
    function setSwapEnabled(bool _isSwapEnabled) external onlyGov {
        isSwapEnabled = _isSwapEnabled;
    }
    
    function withdrawToken(address _token, address _receiver, uint256 _amount) external onlyGov {
        require(emergencyMode, "YTVault: not in emergency");
        IERC20(_token).safeTransfer(_receiver, _amount);
        _updateTokenBalance(_token);
    }
    
    function setMaxSwapSlippageBps(uint256 _slippageBps) external onlyGov {
        require(_slippageBps <= 2000, "YTVault: slippage too high"); // 最大20%
        maxSwapSlippageBps = _slippageBps;
    }
    
    function setMaxSwapAmount(address _token, uint256 _amount) external onlyGov {
        maxSwapAmount[_token] = _amount;
    }
    
    function setDailySwapLimit(uint256 _limit) external onlyGov {
        dailySwapLimit = _limit;
    }
    
    // ========== 核心功能：buyUSDY ==========
    
    function buyUSDY(address _token, address _receiver) 
        external 
        onlyPoolManager 
        nonReentrant 
        notInEmergency
        returns (uint256) 
    {
        require(whitelistedTokens[_token], "YTVault: token not whitelisted");
        require(isSwapEnabled, "YTVault: swap disabled");
        
        uint256 tokenAmount = _transferIn(_token);
        require(tokenAmount > 0, "YTVault: invalid token amount");
        
        uint256 price = _getPrice(_token, false);
        uint256 usdyAmount = tokenAmount * price / PRICE_PRECISION;
        usdyAmount = _adjustForDecimals(usdyAmount, _token, usdy);
        require(usdyAmount > 0, "YTVault: invalid usdy amount");
        
        uint256 feeBasisPoints = _getSwapFeeBasisPoints(_token, usdy, usdyAmount);
        uint256 feeAmount = tokenAmount * feeBasisPoints / BASIS_POINTS_DIVISOR;
        uint256 amountAfterFees = tokenAmount - feeAmount;
        
        uint256 usdyAmountAfterFees = amountAfterFees * price / PRICE_PRECISION;
        usdyAmountAfterFees = _adjustForDecimals(usdyAmountAfterFees, _token, usdy);
        
        // 全部代币（包含手续费）加入池子
        _increasePoolAmount(_token, tokenAmount);
        _increaseUsdyAmount(_token, usdyAmountAfterFees);
        
        IUSDY(usdy).mint(_receiver, usdyAmountAfterFees);
        
        emit AddLiquidity(_receiver, _token, tokenAmount, usdyAmountAfterFees);
        
        return usdyAmountAfterFees;
    }
    
    // ========== 核心功能：sellUSDY ==========
    
    function sellUSDY(address _token, address _receiver) 
        external 
        onlyPoolManager 
        nonReentrant 
        notInEmergency
        returns (uint256) 
    {
        require(whitelistedTokens[_token], "YTVault: token not whitelisted");
        require(isSwapEnabled, "YTVault: swap disabled");
        
        uint256 usdyAmount = _transferIn(usdy);
        require(usdyAmount > 0, "YTVault: invalid usdy amount");
        
        uint256 price = _getPrice(_token, true);
        uint256 tokenAmount = usdyAmount * PRICE_PRECISION / price;
        tokenAmount = _adjustForDecimals(tokenAmount, usdy, _token);
        
        uint256 feeBasisPoints = _getSwapFeeBasisPoints(usdy, _token, tokenAmount);
        uint256 amountOutAfterFees = tokenAmount * (BASIS_POINTS_DIVISOR - feeBasisPoints) / BASIS_POINTS_DIVISOR;
        
        require(amountOutAfterFees > 0, "YTVault: invalid amount out");
        require(poolAmounts[_token] >= amountOutAfterFees, "YTVault: insufficient pool");
        
        _decreasePoolAmount(_token, amountOutAfterFees);
        _decreaseUsdyAmount(_token, usdyAmount);
        
        IUSDY(usdy).burn(address(this), usdyAmount);
        IERC20(_token).safeTransfer(_receiver, amountOutAfterFees);
        
        emit RemoveLiquidity(_receiver, _token, usdyAmount, amountOutAfterFees);
        
        return amountOutAfterFees;
    }
    
    // ========== 核心功能：swap ==========
    
    function swap(
        address _tokenIn,
        address _tokenOut,
        address _receiver
    ) external onlyPoolManager nonReentrant notInEmergency returns (uint256) {
        require(isSwapEnabled, "YTVault: swap disabled");
        require(whitelistedTokens[_tokenIn], "YTVault: tokenIn not whitelisted");
        require(whitelistedTokens[_tokenOut], "YTVault: tokenOut not whitelisted");
        require(_tokenIn != _tokenOut, "YTVault: same token");
        
        uint256 amountIn = _transferIn(_tokenIn);
        require(amountIn > 0, "YTVault: invalid amount in");
        
        // 检查单笔交易限额
        if (maxSwapAmount[_tokenIn] > 0) {
            require(amountIn <= maxSwapAmount[_tokenIn], "YTVault: amount exceeds limit");
        }
        
        uint256 priceIn = _getPrice(_tokenIn, false);
        uint256 priceOut = _getPrice(_tokenOut, true);
        
        uint256 usdyAmount = amountIn * priceIn / PRICE_PRECISION;
        usdyAmount = _adjustForDecimals(usdyAmount, _tokenIn, usdy);
        
        // 检查每日交易量限制
        _checkDailySwapLimit(usdyAmount);
        
        uint256 amountOut = usdyAmount * PRICE_PRECISION / priceOut;
        amountOut = _adjustForDecimals(amountOut, usdy, _tokenOut);
        
        uint256 feeBasisPoints = _getSwapFeeBasisPoints(_tokenIn, _tokenOut, amountOut);
        uint256 amountOutAfterFees = amountOut * (BASIS_POINTS_DIVISOR - feeBasisPoints) / BASIS_POINTS_DIVISOR;
        
        require(amountOutAfterFees > 0, "YTVault: invalid amount out");
        require(poolAmounts[_tokenOut] >= amountOutAfterFees, "YTVault: insufficient pool");
        
        // 全局滑点保护
        _validateSwapSlippage(amountIn, amountOutAfterFees, priceIn, priceOut);
        
        _increasePoolAmount(_tokenIn, amountIn);
        _decreasePoolAmount(_tokenOut, amountOutAfterFees);
        
        _increaseUsdyAmount(_tokenIn, usdyAmount);
        _decreaseUsdyAmount(_tokenOut, usdyAmount);
        
        IERC20(_tokenOut).safeTransfer(_receiver, amountOutAfterFees);
        
        emit Swap(msg.sender, _tokenIn, _tokenOut, amountIn, amountOutAfterFees, feeBasisPoints);
        
        return amountOutAfterFees;
    }
    
    // ========== 查询函数 ==========
    
    function getPrice(address _token) external view returns (uint256) {
        return _getPrice(_token, true);
    }
    
    function getAllPoolTokens() external view returns (address[] memory) {
        return allWhitelistedTokens;
    }
    
    function getPoolValue() external view returns (uint256) {
        uint256 totalValue = 0;
        for (uint256 i = 0; i < allWhitelistedTokens.length; i++) {
            address token = allWhitelistedTokens[i];
            if (!whitelistedTokens[token]) continue;
            
            uint256 amount = poolAmounts[token];
            uint256 price = _getPrice(token, true);
            uint256 value = amount * price / PRICE_PRECISION;
            totalValue += value;
        }
        return totalValue;
    }
    
    // ========== 动态手续费机制 ==========
    
    function getTargetUsdyAmount(address _token) public view returns (uint256) {
        uint256 supply = IERC20(usdy).totalSupply();
        if (supply == 0) { return 0; }
        uint256 weight = tokenWeights[_token];
        return weight * supply / totalTokenWeights;
    }
    
    function _increaseUsdyAmount(address _token, uint256 _amount) private {
        usdyAmounts[_token] = usdyAmounts[_token] + _amount;
        uint256 maxUsdyAmount = maxUsdyAmounts[_token];
        if (maxUsdyAmount != 0) {
            require(usdyAmounts[_token] <= maxUsdyAmount, "YTVault: max USDY exceeded");
        }
    }
    
    function _decreaseUsdyAmount(address _token, uint256 _amount) private {
        uint256 value = usdyAmounts[_token];
        require(value >= _amount, "YTVault: insufficient USDY amount");
        usdyAmounts[_token] = value - _amount;
    }
    
    function getFeeBasisPoints(
        address _token,
        uint256 _usdyDelta,
        uint256 _feeBasisPoints,
        uint256 _taxBasisPoints,
        bool _increment
    ) public view returns (uint256) {
        if (!hasDynamicFees) { return _feeBasisPoints; }
        
        uint256 initialAmount = usdyAmounts[_token];
        uint256 nextAmount = initialAmount + _usdyDelta;
        if (!_increment) {
            nextAmount = _usdyDelta > initialAmount ? 0 : initialAmount - _usdyDelta;
        }
        
        uint256 targetAmount = getTargetUsdyAmount(_token);
        if (targetAmount == 0) { return _feeBasisPoints; }
        
        uint256 initialDiff = initialAmount > targetAmount 
            ? initialAmount - targetAmount 
            : targetAmount - initialAmount;
        uint256 nextDiff = nextAmount > targetAmount 
            ? nextAmount - targetAmount 
            : targetAmount - nextAmount;
        
        // 改善平衡 → 降低手续费
        if (nextDiff < initialDiff) {
            uint256 rebateBps = _taxBasisPoints * initialDiff / targetAmount;
            return rebateBps > _feeBasisPoints ? 0 : _feeBasisPoints - rebateBps;
        }
        
        // 恶化平衡 → 提高手续费
        uint256 averageDiff = (initialDiff + nextDiff) / 2;
        if (averageDiff > targetAmount) {
            averageDiff = targetAmount;
        }
        uint256 taxBps = _taxBasisPoints * averageDiff / targetAmount;
        return _feeBasisPoints + taxBps;
    }
    
    function _getSwapFeeBasisPoints(
        address _tokenIn,
        address _tokenOut,
        uint256 _usdyAmount
    ) private view returns (uint256) {
        bool isStableSwap = (_tokenIn == usdy || _tokenOut == usdy);
        uint256 baseBps = isStableSwap ? stableSwapFeeBasisPoints : swapFeeBasisPoints;
        uint256 taxBps = isStableSwap ? stableTaxBasisPoints : taxBasisPoints;
        
        if (!hasDynamicFees) {
            return baseBps;
        }
        
        uint256 feesBasisPoints0 = getFeeBasisPoints(_tokenIn, _usdyAmount, baseBps, taxBps, true);
        uint256 feesBasisPoints1 = getFeeBasisPoints(_tokenOut, _usdyAmount, baseBps, taxBps, false);
        
        return feesBasisPoints0 > feesBasisPoints1 ? feesBasisPoints0 : feesBasisPoints1;
    }
    
    // ========== 内部函数 ==========
    
    function _transferIn(address _token) private returns (uint256) {
        uint256 prevBalance = tokenBalances[_token];
        uint256 nextBalance = IERC20(_token).balanceOf(address(this));
        tokenBalances[_token] = nextBalance;
        return nextBalance - prevBalance;
    }
    
    function _updateTokenBalance(address _token) private {
        tokenBalances[_token] = IERC20(_token).balanceOf(address(this));
    }
    
    function _increasePoolAmount(address _token, uint256 _amount) private {
        poolAmounts[_token] += _amount;
        _validatePoolAmount(_token);
    }
    
    function _decreasePoolAmount(address _token, uint256 _amount) private {
        require(poolAmounts[_token] >= _amount, "YTVault: insufficient pool");
        poolAmounts[_token] -= _amount;
    }
    
    function _validatePoolAmount(address _token) private view {
        require(poolAmounts[_token] <= tokenBalances[_token], "YTVault: invalid pool amount");
    }
    
    function _validateSwapSlippage(
        uint256 _amountIn,
        uint256 _amountOut,
        uint256 _priceIn,
        uint256 _priceOut
    ) private view {
        // 计算预期输出（不含手续费）
        uint256 expectedOut = _amountIn * _priceIn / _priceOut;
        
        // 计算实际滑点
        if (expectedOut > _amountOut) {
            uint256 slippage = (expectedOut - _amountOut) * BASIS_POINTS_DIVISOR / expectedOut;
            require(slippage <= maxSwapSlippageBps, "YTVault: slippage too high");
        }
    }
    
    function _checkDailySwapLimit(uint256 _usdyAmount) private {
        if (dailySwapLimit == 0) return;
        
        uint256 currentDay = block.timestamp / 1 days;
        
        // 新的一天，重置计数器
        if (currentDay > lastSwapDay) {
            currentDaySwapVolume = 0;
            lastSwapDay = currentDay;
        }
        
        currentDaySwapVolume += _usdyAmount;
        require(currentDaySwapVolume <= dailySwapLimit, "YTVault: daily limit exceeded");
    }
    
    function _getPrice(address _token, bool _maximise) private view returns (uint256) {
        return IYTPriceFeed(priceFeed).getPrice(_token, _maximise);
    }
    
    function _adjustForDecimals(
        uint256 _amount,
        address _tokenFrom,
        address _tokenTo
    ) private view returns (uint256) {
        uint256 decimalsFrom = tokenDecimals[_tokenFrom];
        uint256 decimalsTo = tokenDecimals[_tokenTo];
        
        if (decimalsFrom == decimalsTo) {
            return _amount;
        }
        
        if (decimalsFrom > decimalsTo) {
            return _amount / (10 ** (decimalsFrom - decimalsTo));
        }
        
        return _amount * (10 ** (decimalsTo - decimalsFrom));
    }
}

// ========== 接口定义 ==========

interface IUSDY {
    function mint(address _to, uint256 _amount) external;
    function burn(address _from, uint256 _amount) external;
}

interface IYTPriceFeed {
    function getPrice(address _token, bool _maximise) external view returns (uint256);
}
```

---

### 3.4 YT Pool Manager (YTPoolManager.sol)

**功能**: 管理ytLP的铸造和赎回，计算池子AUM

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

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

contract YTPoolManager is ReentrancyGuard {
    using SafeERC20 for IERC20;
    
    // ========== 常量 ==========
    uint256 public constant PRICE_PRECISION = 10 ** 30;
    uint256 public constant YTLP_PRECISION = 10 ** 18;
    uint256 public constant BASIS_POINTS_DIVISOR = 10000;
    uint256 public constant MAX_COOLDOWN_DURATION = 48 hours;
    
    // ========== 状态变量 ==========
    address public gov;
    address public ytVault;
    address public usdy;
    address public ytLP;
    
    uint256 public cooldownDuration = 15 minutes;
    mapping(address => uint256) public lastAddedAt;
    
    bool public inPrivateMode;
    mapping(address => bool) public isHandler;
    
    uint256 public aumAddition;
    uint256 public aumDeduction;
    
    // ========== 事件 ==========
    event AddLiquidity(address indexed account, address indexed token, uint256 amount, uint256 aumInUsdy, uint256 ytLPSupply, uint256 usdyAmount, uint256 mintAmount);
    event RemoveLiquidity(address indexed account, address indexed token, uint256 ytLPAmount, uint256 aumInUsdy, uint256 ytLPSupply, uint256 usdyAmount, uint256 amountOut);
    
    // ========== 修饰符 ==========
    modifier onlyGov() {
        require(msg.sender == gov, "YTPoolManager: forbidden");
        _;
    }
    
    modifier onlyHandler() {
        require(isHandler[msg.sender] || msg.sender == gov, "YTPoolManager: forbidden");
        _;
    }
    
    // ========== 构造函数 ==========
    constructor(
        address _ytVault,
        address _usdy,
        address _ytLP,
        uint256 _cooldownDuration
    ) {
        gov = msg.sender;
        ytVault = _ytVault;
        usdy = _usdy;
        ytLP = _ytLP;
        cooldownDuration = _cooldownDuration;
    }
    
    // ========== 管理函数 ==========
    
    function setHandler(address _handler, bool _isActive) external onlyGov {
        isHandler[_handler] = _isActive;
    }
    
    function setCooldownDuration(uint256 _duration) external onlyGov {
        require(_duration <= MAX_COOLDOWN_DURATION, "YTPoolManager: invalid duration");
        cooldownDuration = _duration;
    }
    
    function setAumAdjustment(uint256 _addition, uint256 _deduction) external onlyGov {
        aumAddition = _addition;
        aumDeduction = _deduction;
    }
    
    function setInPrivateMode(bool _inPrivateMode) external onlyGov {
        inPrivateMode = _inPrivateMode;
    }
    
    // ========== 核心功能：添加流动性 ==========
    
    function addLiquidity(
        address _token,
        uint256 _amount,
        uint256 _minUsdy,
        uint256 _minYtLP
    ) external nonReentrant returns (uint256) {
        require(!inPrivateMode, "YTPoolManager: private mode");
        return _addLiquidity(msg.sender, msg.sender, _token, _amount, _minUsdy, _minYtLP);
    }
    
    function addLiquidityForAccount(
        address _fundingAccount,
        address _account,
        address _token,
        uint256 _amount,
        uint256 _minUsdy,
        uint256 _minYtLP
    ) external onlyHandler nonReentrant returns (uint256) {
        return _addLiquidity(_fundingAccount, _account, _token, _amount, _minUsdy, _minYtLP);
    }
    
    function _addLiquidity(
        address _fundingAccount,
        address _account,
        address _token,
        uint256 _amount,
        uint256 _minUsdy,
        uint256 _minYtLP
    ) private returns (uint256) {
        require(_amount > 0, "YTPoolManager: invalid amount");
        
        uint256 aumInUsdy = getAumInUsdy(true);
        uint256 ytLPSupply = IERC20(ytLP).totalSupply();
        
        IERC20(_token).safeTransferFrom(_fundingAccount, ytVault, _amount);
        uint256 usdyAmount = IYTVault(ytVault).buyUSDY(_token, address(this));
        require(usdyAmount >= _minUsdy, "YTPoolManager: insufficient USDY");
        
        uint256 mintAmount;
        if (ytLPSupply == 0) {
            mintAmount = usdyAmount;
        } else {
            mintAmount = usdyAmount * ytLPSupply / aumInUsdy;
        }
        
        require(mintAmount >= _minYtLP, "YTPoolManager: insufficient ytLP");
        
        IYTLPToken(ytLP).mint(_account, mintAmount);
        lastAddedAt[_account] = block.timestamp;
        
        emit AddLiquidity(_account, _token, _amount, aumInUsdy, ytLPSupply, usdyAmount, mintAmount);
        
        return mintAmount;
    }
    
    // ========== 核心功能：移除流动性 ==========
    
    function removeLiquidity(
        address _tokenOut,
        uint256 _ytLPAmount,
        uint256 _minOut,
        address _receiver
    ) external nonReentrant returns (uint256) {
        require(!inPrivateMode, "YTPoolManager: private mode");
        return _removeLiquidity(msg.sender, _tokenOut, _ytLPAmount, _minOut, _receiver);
    }
    
    function removeLiquidityForAccount(
        address _account,
        address _tokenOut,
        uint256 _ytLPAmount,
        uint256 _minOut,
        address _receiver
    ) external onlyHandler nonReentrant returns (uint256) {
        return _removeLiquidity(_account, _tokenOut, _ytLPAmount, _minOut, _receiver);
    }
    
    function _removeLiquidity(
        address _account,
        address _tokenOut,
        uint256 _ytLPAmount,
        uint256 _minOut,
        address _receiver
    ) private returns (uint256) {
        require(_ytLPAmount > 0, "YTPoolManager: invalid amount");
        
        require(
            lastAddedAt[_account] + cooldownDuration <= block.timestamp,
            "YTPoolManager: cooldown not passed"
        );
        
        uint256 aumInUsdy = getAumInUsdy(false);
        uint256 ytLPSupply = IERC20(ytLP).totalSupply();
        
        uint256 usdyAmount = _ytLPAmount * aumInUsdy / ytLPSupply;
        
        // 先销毁ytLP
        IYTLPToken(ytLP).burn(_account, _ytLPAmount);
        
        // 检查并准备USDY
        uint256 usdyBalance = IERC20(usdy).balanceOf(address(this));
        if (usdyAmount > usdyBalance) {
            // 不直接铸造，而是从Vault获取
            uint256 needed = usdyAmount - usdyBalance;
            // Vault应该预留足够的USDY储备，这里只是容错处理
            // 实际部署时应确保Vault有足够的USDY储备或由治理手动补充
            require(usdyBalance >= usdyAmount * 95 / 100, "YTPoolManager: insufficient USDY reserve");
            usdyAmount = usdyBalance; // 使用可用余额
        }
        
        IERC20(usdy).safeTransfer(ytVault, usdyAmount);
        uint256 amountOut = IYTVault(ytVault).sellUSDY(_tokenOut, _receiver);
        
        require(amountOut >= _minOut, "YTPoolManager: insufficient output");
        
        emit RemoveLiquidity(_account, _tokenOut, _ytLPAmount, aumInUsdy, ytLPSupply, usdyAmount, amountOut);
        
        return amountOut;
    }
    
    // ========== USDY储备管理 ==========
    
    function depositUsdyReserve(uint256 _amount) external onlyGov {
        IERC20(usdy).safeTransferFrom(msg.sender, address(this), _amount);
    }
    
    function withdrawUsdyReserve(uint256 _amount, address _receiver) external onlyGov {
        IERC20(usdy).safeTransfer(_receiver, _amount);
    }
    
    function getUsdyReserve() external view returns (uint256) {
        return IERC20(usdy).balanceOf(address(this));
    }
    
    // ========== 查询函数 ==========
    
    function getPrice(bool _maximise) external view returns (uint256) {
        uint256 aum = getAumInUsdy(_maximise);
        uint256 supply = IERC20(ytLP).totalSupply();
        
        if (supply == 0) return YTLP_PRECISION;
        
        return aum * YTLP_PRECISION / supply;
    }
    
    function getAumInUsdy(bool _maximise) public view returns (uint256) {
        uint256 aum = IYTVault(ytVault).getPoolValue();
        
        aum += aumAddition;
        if (aum > aumDeduction) {
            aum -= aumDeduction;
        } else {
            aum = 0;
        }
        
        return aum;
    }
}

// ========== 接口定义 ==========

interface IYTVault {
    function buyUSDY(address _token, address _receiver) external returns (uint256);
    function sellUSDY(address _token, address _receiver) external returns (uint256);
    function getPoolValue() external view returns (uint256);
}

interface IYTLPToken {
    function mint(address _to, uint256 _amount) external;
    function burn(address _from, uint256 _amount) external;
}

interface IUSDY {
    function mint(address _to, uint256 _amount) external;
    function burn(address _from, uint256 _amount) external;
}
```

---

### 3.5 YT Reward Router (YTRewardRouter.sol)

**功能**: 用户交互入口（简化版，自动复利模式）

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

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

contract YTRewardRouter is ReentrancyGuard {
    using SafeERC20 for IERC20;
    
    // ========== 状态变量 ==========
    address public gov;
    address public usdy;
    address public ytLP;
    address public ytPoolManager;
    address public ytVault;
    
    bool public isInitialized;
    
    // ========== 事件 ==========
    event Swap(address indexed account, address tokenIn, address tokenOut, uint256 amountIn, uint256 amountOut);
    
    // ========== 修饰符 ==========
    modifier onlyGov() {
        require(msg.sender == gov, "YTRewardRouter: forbidden");
        _;
    }
    
    // ========== 构造函数 ==========
    constructor() {
        gov = msg.sender;
    }
    
    function initialize(
        address _usdy,
        address _ytLP,
        address _ytPoolManager,
        address _ytVault
    ) external onlyGov {
        require(!isInitialized, "YTRewardRouter: already initialized");
        isInitialized = true;
        
        usdy = _usdy;
        ytLP = _ytLP;
        ytPoolManager = _ytPoolManager;
        ytVault = _ytVault;
    }
    
    // ========== 核心功能：添加流动性 ==========
    
    function addLiquidity(
        address _token,
        uint256 _amount,
        uint256 _minUsdy,
        uint256 _minYtLP
    ) external nonReentrant returns (uint256) {
        require(_amount > 0, "YTRewardRouter: invalid amount");
        
        address account = msg.sender;
        
        IERC20(_token).safeTransferFrom(account, address(this), _amount);
        IERC20(_token).approve(ytPoolManager, _amount);
        
        uint256 ytLPAmount = IYTPoolManager(ytPoolManager).addLiquidityForAccount(
            address(this),
            account,
            _token,
            _amount,
            _minUsdy,
            _minYtLP
        );
        
        return ytLPAmount;
    }
    
    // ========== 核心功能：移除流动性 ==========
    
    function removeLiquidity(
        address _tokenOut,
        uint256 _ytLPAmount,
        uint256 _minOut,
        address _receiver
    ) external nonReentrant returns (uint256) {
        require(_ytLPAmount > 0, "YTRewardRouter: invalid amount");
        
        address account = msg.sender;
        
        uint256 amountOut = IYTPoolManager(ytPoolManager).removeLiquidityForAccount(
            account,
            _tokenOut,
            _ytLPAmount,
            _minOut,
            _receiver
        );
        
        return amountOut;
    }
    
    // ========== 核心功能：YT代币Swap ==========
    
    function swapYT(
        address _tokenIn,
        address _tokenOut,
        uint256 _amountIn,
        uint256 _minOut,
        address _receiver
    ) external nonReentrant returns (uint256) {
        require(_amountIn > 0, "YTRewardRouter: invalid amount");
        
        address account = msg.sender;
        
        IERC20(_tokenIn).safeTransferFrom(account, ytVault, _amountIn);
        
        uint256 amountOut = IYTVault(ytVault).swap(_tokenIn, _tokenOut, _receiver);
        
        require(amountOut >= _minOut, "YTRewardRouter: insufficient output");
        
        emit Swap(account, _tokenIn, _tokenOut, _amountIn, amountOut);
        
        return amountOut;
    }
    
    // ========== 查询函数 ==========
    
    function getYtLPPrice() external view returns (uint256) {
        return IYTPoolManager(ytPoolManager).getPrice(true);
    }
    
    function getAccountValue(address _account) external view returns (uint256) {
        uint256 ytLPBalance = IERC20(ytLP).balanceOf(_account);
        uint256 ytLPPrice = IYTPoolManager(ytPoolManager).getPrice(true);
        return ytLPBalance * ytLPPrice / (10 ** 18);
    }
}

// ========== 接口定义 ==========

interface IYTPoolManager {
    function addLiquidityForAccount(
        address _fundingAccount,
        address _account,
        address _token,
        uint256 _amount,
        uint256 _minUsdy,
        uint256 _minYtLP
    ) external returns (uint256);
    
    function removeLiquidityForAccount(
        address _account,
        address _tokenOut,
        uint256 _ytLPAmount,
        uint256 _minOut,
        address _receiver
    ) external returns (uint256);
    
    function getPrice(bool _maximise) external view returns (uint256);
}

interface IYTVault {
    function swap(
        address _tokenIn,
        address _tokenOut,
        address _receiver
    ) external returns (uint256);
}
```

---

### 3.6 YT Price Feed (YTPriceFeed.sol)

**功能**: 直接从YT合约读取价格变量

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

contract YTPriceFeed {
    address public gov;
    
    uint256 public constant PRICE_PRECISION = 10 ** 30;
    uint256 public constant BASIS_POINTS_DIVISOR = 10000;
    
    // WUSD固定价格
    address public constant WUSD = 0x7Cd017ca5ddb86861FA983a34b5F495C6F898c41;
    uint256 public constant WUSD_PRICE = 1e30;
    
    // 价格保护参数
    uint256 public maxPriceChangeBps = 500; // 5% 最大价格变动
    uint256 public maxPriceAge = 1 hours; // 价格最大有效期
    
    // 价格历史记录
    mapping(address => uint256) public lastPrice;
    mapping(address => uint256) public lastPriceUpdateTime;
    
    // 断路器
    bool public circuitBreakerEnabled = true;
    
    event PriceUpdate(address indexed token, uint256 oldPrice, uint256 newPrice, uint256 timestamp);
    event CircuitBreakerTriggered(address indexed token, uint256 oldPrice, uint256 newPrice);
    
    modifier onlyGov() {
        require(msg.sender == gov, "YTPriceFeed: forbidden");
        _;
    }
    
    constructor() {
        gov = msg.sender;
    }
    
    // ========== 管理函数 ==========
    
    function setMaxPriceChangeBps(uint256 _maxPriceChangeBps) external onlyGov {
        require(_maxPriceChangeBps <= 2000, "YTPriceFeed: max change too high"); // 最大20%
        maxPriceChangeBps = _maxPriceChangeBps;
    }
    
    function setMaxPriceAge(uint256 _maxPriceAge) external onlyGov {
        require(_maxPriceAge <= 24 hours, "YTPriceFeed: max age too long");
        maxPriceAge = _maxPriceAge;
    }
    
    function setCircuitBreakerEnabled(bool _enabled) external onlyGov {
        circuitBreakerEnabled = _enabled;
    }
    
    function forceUpdatePrice(address _token, uint256 _price) external onlyGov {
        lastPrice[_token] = _price;
        lastPriceUpdateTime[_token] = block.timestamp;
        emit PriceUpdate(_token, lastPrice[_token], _price, block.timestamp);
    }
    
    // ========== 核心功能 ==========
    
    /**
     * @notice 获取YT代币价格（带保护机制）
     * @dev 包含价格变动限制和时效性检查
     */
    function getPrice(address _token, bool _maximise) external view returns (uint256) {
        if (_token == WUSD) {
            return WUSD_PRICE;
        }
        
        uint256 newPrice = _getRawPrice(_token);
        
        // 价格时效性检查
        uint256 lastUpdate = IYTToken(_token).lastPriceUpdate();
        require(block.timestamp - lastUpdate <= maxPriceAge, "YTPriceFeed: price too old");
        
        // 断路器检查
        if (circuitBreakerEnabled) {
            _validatePriceChange(_token, newPrice);
        }
        
        return newPrice;
    }
    
    /**
     * @notice 获取原始价格并更新记录
     * @dev 此函数应由可信的keeper定期调用
     */
    function updatePrice(address _token) external returns (uint256) {
        if (_token == WUSD) {
            return WUSD_PRICE;
        }
        
        uint256 oldPrice = lastPrice[_token];
        uint256 newPrice = _getRawPrice(_token);
        
        // 价格时效性检查
        uint256 lastUpdate = IYTToken(_token).lastPriceUpdate();
        require(block.timestamp - lastUpdate <= maxPriceAge, "YTPriceFeed: price too old");
        
        // 断路器检查
        if (circuitBreakerEnabled) {
            _validatePriceChange(_token, newPrice);
        }
        
        lastPrice[_token] = newPrice;
        lastPriceUpdateTime[_token] = block.timestamp;
        
        emit PriceUpdate(_token, oldPrice, newPrice, block.timestamp);
        
        return newPrice;
    }
    
    // ========== 内部函数 ==========
    
    function _getRawPrice(address _token) private view returns (uint256) {
        return IYTToken(_token).assetPrice();
    }
    
    function _validatePriceChange(address _token, uint256 _newPrice) private view {
        uint256 oldPrice = lastPrice[_token];
        
        // 首次设置价格，跳过检查
        if (oldPrice == 0) {
            return;
        }
        
        // 检查时间间隔（短时间内的大幅波动才需要警惕）
        uint256 timeSinceLastUpdate = block.timestamp - lastPriceUpdateTime[_token];
        if (timeSinceLastUpdate >= maxPriceAge) {
            return; // 长时间未更新，允许较大变动
        }
        
        // 计算价格变动百分比
        uint256 priceDiff = _newPrice > oldPrice ? _newPrice - oldPrice : oldPrice - _newPrice;
        uint256 maxDiff = oldPrice * maxPriceChangeBps / BASIS_POINTS_DIVISOR;
        
        if (priceDiff > maxDiff) {
            emit CircuitBreakerTriggered(_token, oldPrice, _newPrice);
            revert("YTPriceFeed: price change too large");
        }
    }
    
    // ========== 查询函数 ==========
    
    function getPriceInfo(address _token) external view returns (
        uint256 currentPrice,
        uint256 cachedPrice,
        uint256 lastUpdate,
        uint256 priceAge,
        bool isStale
    ) {
        currentPrice = _getRawPrice(_token);
        cachedPrice = lastPrice[_token];
        lastUpdate = IYTToken(_token).lastPriceUpdate();
        priceAge = block.timestamp - lastUpdate;
        isStale = priceAge > maxPriceAge;
    }
}

interface IYTToken {
    function assetPrice() external view returns (uint256);
    function lastPriceUpdate() external view returns (uint256);
}
```

**YT代币需要实现**:

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

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

contract YTToken is ERC20, Ownable {
    uint256 public constant PRICE_PRECISION = 10 ** 30;
    
    uint256 public totalAssets;
    uint256 public accumulatedYield;
    
    // 价格变量（public自动生成getter）
    uint256 public assetPrice;
    uint256 public lastPriceUpdate;
    
    // 价格更新控制
    address public priceUpdater;
    uint256 public minUpdateInterval = 5 minutes; // 最小更新间隔
    
    event PriceUpdated(uint256 oldPrice, uint256 newPrice, uint256 timestamp);
    event YieldAccumulated(uint256 amount, uint256 timestamp);
    
    modifier onlyPriceUpdater() {
        require(msg.sender == priceUpdater || msg.sender == owner(), "YTToken: not updater");
        _;
    }
    
    constructor(string memory name, string memory symbol) ERC20(name, symbol) {
        assetPrice = PRICE_PRECISION; // 初始价格为1
        lastPriceUpdate = block.timestamp;
        priceUpdater = msg.sender;
    }
    
    function setPriceUpdater(address _updater) external onlyOwner {
        priceUpdater = _updater;
    }
    
    function setMinUpdateInterval(uint256 _interval) external onlyOwner {
        require(_interval <= 1 hours, "YTToken: interval too long");
        minUpdateInterval = _interval;
    }
    
    /**
     * @notice 更新代币价格
     * @dev 只能由授权的updater调用，有最小时间间隔限制
     */
    function updatePrice() public onlyPriceUpdater {
        require(
            block.timestamp >= lastPriceUpdate + minUpdateInterval,
            "YTToken: update too frequent"
        );
        
        uint256 oldPrice = assetPrice;
        uint256 supply = totalSupply();
        
        if (supply == 0) {
            assetPrice = PRICE_PRECISION;
        } else {
            uint256 totalValue = totalAssets + accumulatedYield;
            // 计算每个token对应的USDC价值（18位精度）
            uint256 usdcPerToken = totalValue * 1e18 / supply;
            // 转换为30位精度的价格
            assetPrice = usdcPerToken * PRICE_PRECISION / 1e18;
        }
        
        lastPriceUpdate = block.timestamp;
        
        emit PriceUpdated(oldPrice, assetPrice, block.timestamp);
    }
    
    /**
     * @notice 累积收益并更新价格
     * @dev 当从收益策略中收到新收益时调用
     */
    function updateYield(uint256 _newYield) external onlyPriceUpdater {
        require(_newYield > 0, "YTToken: invalid yield");
        
        accumulatedYield += _newYield;
        
        emit YieldAccumulated(_newYield, block.timestamp);
        
        // 收益更新后立即更新价格
        if (block.timestamp >= lastPriceUpdate + minUpdateInterval) {
            uint256 oldPrice = assetPrice;
            uint256 supply = totalSupply();
            
            if (supply > 0) {
                uint256 totalValue = totalAssets + accumulatedYield;
                uint256 usdcPerToken = totalValue * 1e18 / supply;
                assetPrice = usdcPerToken * PRICE_PRECISION / 1e18;
            }
            
            lastPriceUpdate = block.timestamp;
            emit PriceUpdated(oldPrice, assetPrice, block.timestamp);
        }
    }
    
    /**
     * @notice 获取当前价格信息
     */
    function getPriceInfo() external view returns (
        uint256 price,
        uint256 lastUpdate,
        uint256 timeSinceUpdate,
        uint256 totalVal
    ) {
        price = assetPrice;
        lastUpdate = lastPriceUpdate;
        timeSinceUpdate = block.timestamp - lastPriceUpdate;
        totalVal = totalAssets + accumulatedYield;
    }
}
```

---

## 4. 自动复利机制

### 4.1 核心理念

类似Compound的cToken，持有ytLP即自动增值，无需手动领取奖励。

```
用户持有ytLP → 池子收取手续费 → 手续费留在poolAmounts → AUM增长 → ytLP价格上涨
```

### 4.2 收益来源

| 收益来源 | 实现方式 |
|---------|---------|
| YT Swap手续费 | 留在池子，增加poolAmounts |
| 存入手续费 | 留在池子 |
| 取出手续费 | 留在池子 |

### 4.3 与GMX的差异

| 特性 | GMX GLP | YT Pool |
|------|---------|---------|
| 手续费分配 | 70% LP + 30% GMX质押者 | 100% LP |
| 领取方式 | 手动claim | 自动复利 |
| 质押要求 | 需要质押 | 无需质押 |
| Gas成本 | 需要claim交易 | 零额外成本 |

---

## 5. 动态手续费机制

### 5.1 三重平衡机制

#### 1. 目标权重（tokenWeights）

```solidity
// 配置示例
totalTokenWeights = 10000

tokenWeights[YT-A] = 4000  // 40%
tokenWeights[YT-B] = 3000  // 30%
tokenWeights[YT-C] = 2000  // 20%
tokenWeights[WUSD] = 1000  // 10%
```

#### 2. 硬限制（maxUsdyAmounts）

```solidity
maxUsdyAmounts[YT-A] = 45M USDY
maxUsdyAmounts[YT-B] = 35M USDY
maxUsdyAmounts[YT-C] = 25M USDY
maxUsdyAmounts[WUSD] = 15M USDY
```

#### 3. 动态手续费

- 改善平衡 → 降低手续费（可至0%）
- 恶化平衡 → 提高手续费（可至0.8%）

### 5.2 配置参数

| 参数 | 典型值 | 说明 |
|------|--------|------|
| swapFeeBasisPoints | 30 | 基础swap手续费0.3% |
| stableSwapFeeBasisPoints | 4 | 稳定币操作0.04% |
| taxBasisPoints | 50 | 动态调整范围0.5% |
| stableTaxBasisPoints | 20 | 稳定币动态调整0.2% |

---

## 6. 部署配置

### 6.1 部署顺序

```
1. 部署USDY
2. 部署YTLPToken
3. 部署YTPriceFeed
4. 部署YTVault
5. 部署YTPoolManager
6. 部署YTRewardRouter
7. 配置权限和参数
```

### 6.2 部署脚本

```javascript
// 1. 部署基础代币
const usdy = await USDY.deploy(vault.address);
const ytLP = await YTLPToken.deploy();

// 2. 部署核心合约
const priceFeed = await YTPriceFeed.deploy();
const vault = await YTVault.deploy(usdy.address, priceFeed.address);
const poolManager = await YTPoolManager.deploy(
    vault.address,
    usdy.address,
    ytLP.address,
    15 * 60 // 15分钟冷却期
);

// 3. 配置权限
await ytLP.setMinter(poolManager.address, true);
await vault.setPoolManager(poolManager.address);
await usdy.addVault(vault.address);
await usdy.addVault(poolManager.address);

// 4. 配置手续费和安全参数
await vault.setSwapFees(30, 4, 50, 20);
await vault.setDynamicFees(true);
await vault.setMaxSwapSlippageBps(1000); // 10%
await vault.setDailySwapLimit(ethers.utils.parseEther("10000000")); // 1000万USDY/天

// 5. 配置价格保护
await priceFeed.setMaxPriceChangeBps(500); // 5%
await priceFeed.setMaxPriceAge(3600); // 1小时
await priceFeed.setCircuitBreakerEnabled(true);

// 6. 添加白名单代币
await vault.setWhitelistedToken(
    ytTokenA.address,
    18,
    4000,
    ethers.utils.parseEther("45000000")
);
await vault.setMaxSwapAmount(ytTokenA.address, ethers.utils.parseEther("1000000")); // 单笔100万

await vault.setWhitelistedToken(
    ytTokenB.address,
    18,
    3000,
    ethers.utils.parseEther("35000000")
);
await vault.setMaxSwapAmount(ytTokenB.address, ethers.utils.parseEther("1000000"));

await vault.setWhitelistedToken(
    ytTokenC.address,
    18,
    2000,
    ethers.utils.parseEther("25000000")
);
await vault.setMaxSwapAmount(ytTokenC.address, ethers.utils.parseEther("1000000"));

await vault.setWhitelistedToken(
    "0x7Cd017ca5ddb86861FA983a34b5F495C6F898c41", // WUSD
    18,
    1000,
    ethers.utils.parseEther("15000000")
);
await vault.setMaxSwapAmount("0x7Cd017ca5ddb86861FA983a34b5F495C6F898c41", ethers.utils.parseEther("500000"));

// 7. 初始化价格（首次部署）
await priceFeed.forceUpdatePrice(ytTokenA.address, ethers.utils.parseUnits("1", 30));
await priceFeed.forceUpdatePrice(ytTokenB.address, ethers.utils.parseUnits("1", 30));
await priceFeed.forceUpdatePrice(ytTokenC.address, ethers.utils.parseUnits("1", 30));

// 8. 准备USDY储备金（建议为预期总供应量的10-20%）
const reserveAmount = ethers.utils.parseEther("10000000"); // 1000万USDY储备
await usdy.mint(poolManager.address, reserveAmount);

// 9. 部署Router
const router = await YTRewardRouter.deploy();
await router.initialize(
    usdy.address,
    ytLP.address,
    poolManager.address,
    vault.address
);
```

---

## 7. 关键参数配置

### 7.1 Vault参数

| 参数 | 建议值 | 说明 |
|------|--------|------|
| swapFeeBasisPoints | 30 | 基础swap手续费 0.3% |
| stableSwapFeeBasisPoints | 4 | 稳定币操作 0.04% |
| taxBasisPoints | 50 | 动态调整范围 0.5% |
| stableTaxBasisPoints | 20 | 稳定币动态调整 0.2% |
| maxSwapSlippageBps | 1000 | 最大滑点 10% |
| dailySwapLimit | 10M USDY | 每日交易量限制 |
| maxSwapAmount | 1M per token | 单笔交易限额 |

### 7.2 PriceFeed参数

| 参数 | 建议值 | 说明 |
|------|--------|------|
| maxPriceChangeBps | 500 | 最大价格变动 5% |
| maxPriceAge | 1 hour | 价格最大有效期 |
| circuitBreakerEnabled | true | 启用断路器 |

### 7.3 PoolManager参数

| 参数 | 建议值 | 说明 |
|------|--------|------|
| cooldownDuration | 15分钟 | 提现冷却期 |
| usdyReserve | 10-20% of total | USDY储备金比例 |

### 7.4 YTToken参数

| 参数 | 建议值 | 说明 |
|------|--------|------|
| minUpdateInterval | 5-15分钟 | 最小价格更新间隔 |

### 7.5 代币权重配置

| 代币 | 权重 | 最大USDY债务 | 单笔限额 |
|------|------|------------|---------|
| YT-A | 4000 (40%) | 45M | 1M |
| YT-B | 3000 (30%) | 35M | 1M |
| YT-C | 2000 (20%) | 25M | 1M |
| WUSD | 1000 (10%) | 15M | 500K |

---

## 8. 安全机制

### 8.1 基础安全

1. **冷却期**: 15分钟锁定，防止闪电贷攻击
2. **滑点保护**: 所有操作都有最小输出参数
3. **重入保护**: nonReentrant修饰符保护所有外部调用
4. **权限控制**: onlyGov/onlyPoolManager严格访问控制
5. **余额验证**: tokenBalances精确跟踪防止余额不一致

### 8.2 价格保护机制

1. **价格变动限制**: 默认5%，防止价格被快速操纵
2. **价格时效性**: 最长1小时，防止使用过期价格
3. **价格断路器**: 异常时自动触发保护
4. **价格历史**: 记录所有价格变动，便于审计

### 8.3 交易限制

1. **单笔限额**: 可配置的单笔交易上限
2. **每日限额**: 防止大规模资金流动
3. **全局滑点**: 最大10%滑点保护
4. **池子余额**: 确保足够流动性

### 8.4 紧急机制

**实现代码**:

```solidity
bool public emergencyMode = false;
bool public isSwapEnabled = true;

function setEmergencyMode(bool _enabled) external onlyGov {
    emergencyMode = _enabled;
}

function setSwapEnabled(bool _enabled) external onlyGov {
    isSwapEnabled = _enabled;
}

modifier notInEmergency() {
    require(!emergencyMode, "YTVault: emergency mode");
    _;
}

// 紧急状态下可提取资金
function withdrawToken(address _token, address _receiver, uint256 _amount) external onlyGov {
    require(emergencyMode, "YTVault: not in emergency");
    IERC20(_token).safeTransfer(_receiver, _amount);
    _updateTokenBalance(_token);
}
```

**使用场景**:
- 发现安全漏洞时立即暂停
- 价格异常时保护用户资金
- 系统升级维护期间
- 遭受攻击时的应急响应

### 8.5 多重验证

每个关键操作都经过多重验证：

```
用户发起交易
    ↓
1. 检查紧急模式 (notInEmergency)
    ↓
2. 检查权限 (onlyPoolManager)
    ↓
3. 检查重入 (nonReentrant)
    ↓
4. 检查白名单 (whitelistedTokens)
    ↓
5. 检查交易限额 (maxSwapAmount)
    ↓
6. 检查价格有效性 (maxPriceAge)
    ↓
7. 检查价格变动 (maxPriceChangeBps)
    ↓
8. 检查每日限额 (dailySwapLimit)
    ↓
9. 检查滑点 (maxSwapSlippageBps)
    ↓
10. 执行交易
    ↓
11. 验证余额一致性 (_validatePoolAmount)
```

---

## 9. 接口定义

### 9.1 核心接口

```solidity
// YTVault接口
interface IYTVault {
    function buyUSDY(address _token, address _receiver) external returns (uint256);
    function sellUSDY(address _token, address _receiver) external returns (uint256);
    function swap(address _tokenIn, address _tokenOut, address _receiver) external returns (uint256);
    function getPoolValue() external view returns (uint256);
    function getTargetUsdyAmount(address _token) external view returns (uint256);
}

// YTPoolManager接口
interface IYTPoolManager {
    function addLiquidity(address _token, uint256 _amount, uint256 _minUsdy, uint256 _minYtLP) external returns (uint256);
    function removeLiquidity(address _tokenOut, uint256 _ytLPAmount, uint256 _minOut, address _receiver) external returns (uint256);
    function getAumInUsdy(bool _maximise) external view returns (uint256);
    function getPrice(bool _maximise) external view returns (uint256);
}

// YTRewardRouter接口
interface IYTRewardRouter {
    function addLiquidity(address _token, uint256 _amount, uint256 _minUsdy, uint256 _minYtLP) external returns (uint256);
    function removeLiquidity(address _tokenOut, uint256 _ytLPAmount, uint256 _minOut, address _receiver) external returns (uint256);
    function swapYT(address _tokenIn, address _tokenOut, uint256 _amountIn, uint256 _minOut, address _receiver) external returns (uint256);
}
```

---

## 10. 合约列表

| 合约名称 | 文件 | 说明 |
|---------|------|------|
| USDY | USDY.sol | 统一计价代币 |
| YTLPToken | YTLPToken.sol | LP代币 |
| YTVault | YTVault.sol | 核心资金池 |
| YTPoolManager | YTPoolManager.sol | 流动性管理 |
| YTRewardRouter | YTRewardRouter.sol | 用户入口 |
| YTPriceFeed | YTPriceFeed.sol | 价格读取器 |

---

## 附录

### A. 依赖库

```json
{
  "dependencies": {
    "@openzeppelin/contracts": "^4.9.0"
  }
}
```

### B. 参考资源

- GMX源码: https://github.com/gmx-io/gmx-contracts
- GMX文档: https://gmxio.gitbook.io/gmx/
- OpenZeppelin: https://docs.openzeppelin.com/

---

## 11. 安全改进总结

### 11.1 针对GMX V1漏洞的防护

✅ **访问控制严格**
- 所有关键函数（`buyUSDY`, `sellUSDY`, `swap`）都有`onlyPoolManager`修饰符
- 防止外部直接调用核心函数
- 不存在GMX V1的`increasePosition`直接调用漏洞

✅ **价格计算独立**
- 价格来自外部YT合约，不在Vault内部维护可被操纵的状态
- 没有"全局空头平均价格"这种易被操纵的内部变量
- AUM计算简单透明：`poolAmounts * price`

### 11.2 关键安全修复

#### 🔴 修复1: _transferIn函数
**问题**: 原设计中两次余额查询在同一时刻，差值永远为0
**修复**: 添加`tokenBalances`映射跟踪上次余额，正确计算转入金额

```solidity
// 修复前（错误）
uint256 prevBalance = IERC20(_token).balanceOf(address(this));
uint256 nextBalance = IERC20(_token).balanceOf(address(this));
return nextBalance - prevBalance; // 永远为0！

// 修复后（正确）
uint256 prevBalance = tokenBalances[_token];
uint256 nextBalance = IERC20(_token).balanceOf(address(this));
tokenBalances[_token] = nextBalance;
return nextBalance - prevBalance;
```

#### 🟠 修复2: 价格操纵保护
**问题**: 外部YT价格可能被操纵
**修复**: 
- 价格变动限制（默认5%）
- 价格时效性检查（最长1小时）
- 断路器机制
- 价格历史记录

```solidity
// 断路器检查
if (priceDiff > maxDiff) {
    emit CircuitBreakerTriggered(_token, oldPrice, _newPrice);
    revert("YTPriceFeed: price change too large");
}
```

#### 🟠 修复3: USDY铸造权限
**问题**: YTPoolManager可以随意铸造USDY
**修复**: 
- 移除直接铸造权限
- 要求预先储备USDY
- 添加储备金管理函数
- 95%储备金要求作为安全底线

```solidity
// 不再随意铸造
// IUSDY(usdy).mint(address(this), needed); // 已移除

// 改为检查储备
require(usdyBalance >= usdyAmount * 95 / 100, "insufficient reserve");
```

#### 🟡 修复4: 全局滑点保护
**新增功能**:
- 最大滑点限制（默认10%）
- 单笔交易限额
- 每日交易量限制
- 实时滑点计算和验证

```solidity
function _validateSwapSlippage(...) {
    uint256 slippage = (expectedOut - actualOut) * 10000 / expectedOut;
    require(slippage <= maxSwapSlippageBps, "slippage too high");
}
```

#### 🟡 修复5: 紧急暂停机制
**新增功能**:
- `emergencyMode`布尔标志
- `notInEmergency`修饰符应用于所有核心函数
- 紧急状态下可提取资金
- 独立的swap开关`isSwapEnabled`

### 11.3 多层防护体系

```
第一层: 访问控制
├─ onlyPoolManager修饰符
├─ onlyGov管理员控制
└─ notInEmergency紧急保护

第二层: 价格保护
├─ 价格变动限制（5%）
├─ 价格时效性检查（1小时）
├─ 断路器自动触发
└─ 价格历史记录

第三层: 交易限制
├─ 单笔交易限额
├─ 每日交易量限制
├─ 全局滑点保护
└─ 冷却期机制（15分钟）

第四层: 余额验证
├─ tokenBalances精确跟踪
├─ poolAmounts验证
├─ USDY储备金检查
└─ 池子余额一致性验证

第五层: 紧急响应
├─ 紧急模式开关
├─ Swap功能开关
├─ 资金提取功能
└─ 治理控制
```

### 11.4 安全最佳实践

1. **重入保护**: 所有外部调用函数都有`nonReentrant`修饰符
2. **滑点保护**: 所有用户操作都需要`_minOut`参数
3. **冷却期**: 15分钟防闪电贷攻击
4. **权限分离**: Gov和PoolManager职责明确
5. **状态同步**: tokenBalances确保余额一致性
6. **价格验证**: 多重价格检查机制
7. **限额控制**: 单笔和每日交易限制
8. **紧急机制**: 多层次的暂停和恢复功能

### 11.5 与GMX V1的对比

| 安全特性 | GMX V1 | YT Pool (修复后) |
|---------|--------|------------------|
| 核心函数访问控制 | ❌ 可被任意调用 | ✅ 严格限制 |
| 价格计算 | ❌ 内部可操纵 | ✅ 外部独立 |
| 价格保护 | ❌ 无 | ✅ 多层保护 |
| 余额跟踪 | ✅ 正确 | ✅ 正确（已修复） |
| 滑点保护 | ⚠️ 基础 | ✅ 全局保护 |
| 紧急机制 | ✅ 有 | ✅ 增强版 |
| 交易限额 | ❌ 无 | ✅ 多重限制 |
| 价格断路器 | ❌ 无 | ✅ 自动触发 |

### 11.6 部署前检查清单

- [ ] 确认所有YT代币实现了`assetPrice()`和`lastPriceUpdate()`接口
- [ ] 设置合理的价格更新间隔（建议5-15分钟）
- [ ] 配置价格变动限制（建议3-5%）
- [ ] 设置单笔交易限额
- [ ] 配置每日交易量限制
- [ ] 准备足够的USDY储备金
- [ ] 测试紧急暂停机制
- [ ] 验证所有访问控制权限
- [ ] 进行全面的安全审计
- [ ] 部署价格监控系统
- [ ] 配置多签钱包作为Gov

### 11.7 运维建议

1. **价格监控**: 部署自动化系统监控YT代币价格异常
2. **储备金管理**: 保持足够的USDY储备（建议>总供应量的10%）
3. **定期审查**: 每周审查交易量、手续费和池子平衡
4. **断路器测试**: 定期测试紧急暂停功能
5. **权限管理**: 使用多签钱包管理Gov权限
6. **升级计划**: 预留升级路径和迁移方案

---

**文档版本**: v4.0 (安全增强版)  
**更新日期**: 2025-12-10  
**适用项目**: YT流动性池系统  
**安全状态**: ✅ 已修复所有已知漏洞