第四章：抵押型稳定币设计

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

contract CDPEngine {
    // CDP核心数据结构
    struct CDP {
        uint256 collateral;      // 抵押品数量
        uint256 debt;           // 债务数量（铸造的稳定币）
        uint256 accumulatedRate; // 累积利率（用于计算利息）
    }
    
    // 抵押品类型信息 - 风险参数五元组
    struct CollateralType {
        // 风险参数
        uint256 debtCeiling;        // 债务上限
        uint256 liquidationRatio;   // 清算比率（如150%）
        uint256 stabilityFee;       // 稳定费率（年化）
        uint256 liquidationPenalty; // 清算罚金（如13%）
        uint256 targetRatio;        // 目标抵押率（如175%）
        
        // 状态变量
        uint256 totalCollateral;     // 该类型总抵押量
        uint256 totalDebt;          // 该类型总债务
        uint256 debtFloor;          // 最小债务量
        uint256 accumulatedRate;    // 累积利率
        uint256 lastUpdateTime;     // 上次更新时间
        
        // 配置
        address priceOracle;        // 价格预言机地址
        address gemAdapter;         // 抵押品适配器
        bool isActive;              // 是否激活
    }
    
    // 状态变量
    mapping(bytes32 => CollateralType) public collateralTypes;
    mapping(bytes32 => mapping(address => CDP)) public cdps;
    mapping(address => uint256) public systemDebt;  // 系统债务
    mapping(address => uint256) public systemSurplus; // 系统盈余
    
    uint256 public globalDebtCeiling;  // 全局债务上限
    uint256 public baseRate = 1e27;    // 基础利率（Ray单位）
    uint256 constant RAY = 1e27;       // Ray精度
    
    // 事件
    event CDPOpened(bytes32 indexed ilk, address indexed user);
    event CollateralLocked(bytes32 indexed ilk, address indexed user, uint256 amount);
    event DebtGenerated(bytes32 indexed ilk, address indexed user, uint256 amount);
    event CDPClosed(bytes32 indexed ilk, address indexed user);
    
    // 开启新的CDP
    function openCDP(bytes32 ilk) external returns (uint256 cdpId) {
        require(collateralTypes[ilk].debtCeiling > 0, "Collateral type not initialized");
        
        // 初始化用户的CDP
        cdps[ilk][msg.sender] = CDP({
            collateral: 0,
            debt: 0,
            accumulatedRate: collateralTypes[ilk].accumulatedRate
        });
        
        emit CDPOpened(ilk, msg.sender);
    }
    
    // 锁定抵押品
    function lockCollateral(bytes32 ilk, uint256 amount) external {
        CDP storage cdp = cdps[ilk][msg.sender];
        CollateralType storage collType = collateralTypes[ilk];
        
        // 从用户转入抵押品（需要先approve）
        // 这里假设有一个gem adapter处理不同类型的抵押品
        IGemAdapter(collType.gemAdapter).join(msg.sender, amount);
        
        cdp.collateral += amount;
        collType.totalCollateral += amount;
        
        emit CollateralLocked(ilk, msg.sender, amount);
    }
    
    // 计算CDP的抵押率
    function getCDPStatus(bytes32 ilk, address user) 
        public 
        view 
        returns (
            uint256 collateralValue,
            uint256 debtValue,
            uint256 collateralizationRatio,
            bool isSafe
        ) 
    {
        CDP memory cdp = cdps[ilk][user];
        CollateralType memory collType = collateralTypes[ilk];
        
        // 获取抵押品价格
        uint256 price = IPriceOracle(collType.priceOracle).getPrice(ilk);
        
        // 计算价值
        collateralValue = cdp.collateral * price / 1e18;
        debtValue = cdp.debt * collType.accumulatedRate / RAY;
        
        // 计算抵押率
        if (debtValue > 0) {
            collateralizationRatio = collateralValue * 100 / debtValue;
        } else {
            collateralizationRatio = type(uint256).max;
        }
        
        // 检查是否安全
        isSafe = collateralizationRatio >= collType.liquidationRatio;
    }
}

library RateMath {
    uint256 constant RAY = 1e27;
    uint256 constant YEAR = 365 days;
    
    // 计算复利
    function compound(uint256 principal, uint256 rate, uint256 time) 
        internal 
        pure 
        returns (uint256) 
    {
        // 使用泰勒级数近似计算 e^(rate * time)
        // 对于小的rate * time，这个近似非常准确
        uint256 ratePerSecond = rate / YEAR;
        uint256 exp = time * ratePerSecond / RAY;
        
        // e^x ≈ 1 + x + x^2/2 + x^3/6 + ...
        uint256 result = RAY + exp;
        uint256 term = exp;
        
        // 计算前几项以提高精度
        for (uint256 i = 2; i <= 6; i++) {
            term = term * exp / (i * RAY);
            result += term;
            
            // 如果项太小，停止计算
            if (term < 1) break;
        }
        
        return principal * result / RAY;
    }
}

contract StabilityFeeCollector {
    using RateMath for uint256;
    
    struct RateUpdate {
        uint256 rate;           // 当前利率
        uint256 accumulated;    // 累积因子
        uint256 lastUpdate;     // 上次更新时间
    }
    
    mapping(bytes32 => RateUpdate) public rates;
    
    // 更新累积利率
    function updateAccumulatedRate(bytes32 ilk) public returns (uint256) {
        RateUpdate storage r = rates[ilk];
        
        if (block.timestamp > r.lastUpdate) {
            uint256 timeDelta = block.timestamp - r.lastUpdate;
            
            // 计算新的累积因子
            uint256 newAccumulated = r.accumulated.compound(
                r.rate,
                timeDelta
            );
            
            r.accumulated = newAccumulated;
            r.lastUpdate = block.timestamp;
        }
        
        return r.accumulated;
    }
    
    // 计算债务的当前价值（包含利息）
    function debtWithInterest(
        bytes32 ilk,
        uint256 principal
    ) public view returns (uint256) {
        RateUpdate memory r = rates[ilk];
        uint256 timeDelta = block.timestamp - r.lastUpdate;
        
        uint256 currentAccumulated = r.accumulated.compound(
            r.rate,
            timeDelta
        );
        
        return principal * currentAccumulated / RAY;
    }
}

contract DebtAccounting {
    // 系统会计变量
    mapping(address => uint256) public dai;      // DAI余额
    mapping(address => uint256) public sin;      // 坏账（系统债务）
    uint256 public vice;                         // 全局未拍卖坏账
    uint256 public surplus;                      // 系统盈余
    
    uint256 constant RAD = 1e45;                 // 高精度单位
    
    // 铸造稳定币
    function mint(address user, uint256 amount) internal {
        dai[user] += amount;
        
        // 同时增加等额的系统债务
        sin[address(this)] += amount;
    }
    
    // 销毁稳定币偿还债务
    function burn(address user, uint256 amount) internal {
        require(dai[user] >= amount, "Insufficient balance");
        
        dai[user] -= amount;
        sin[address(this)] -= amount;
    }
    
    // 处理盈余
    function handleSurplus() external {
        // 当系统有盈余时，可以：
        // 1. 销毁MKR代币（通过拍卖）
        // 2. 增加储备金
        // 3. 降低稳定费率
        
        if (surplus > surplusBuffer) {
            uint256 auctionAmount = surplus - surplusBuffer;
            // 启动盈余拍卖...
        }
    }
    
    // 处理坏账
    function handleBadDebt() external {
        // 当系统有坏账时，需要：
        // 1. 铸造MKR代币（通过拍卖）
        // 2. 使用储备金
        // 3. 提高稳定费率
        
        if (vice > debtBuffer) {
            uint256 auctionAmount = vice - debtBuffer;
            // 启动债务拍卖...
        }
    }
}

contract LiquidationEngine {
    struct Auction {
        uint256 collateralAmount;  // 拍卖的抵押品数量
        uint256 debtAmount;        // 需要偿还的债务
        address cdpOwner;          // CDP原主人
        uint256 startTime;         // 拍卖开始时间
        uint256 startPrice;        // 起始价格
        uint256 endTime;           // 拍卖结束时间
        address highBidder;        // 最高出价者
        uint256 highBid;           // 最高出价
    }
    
    mapping(uint256 => Auction) public auctions;
    uint256 public nextAuctionId;
    
    // 清算参数
    uint256 public liquidationPenalty = 13e16;  // 13%罚金
    uint256 public auctionDuration = 6 hours;    // 拍卖持续时间
    uint256 public bufferPercentage = 3e16;      // 3%缓冲
    
    // 触发清算
    function liquidate(bytes32 ilk, address user) external returns (uint256 auctionId) {
        // 检查CDP状态
        (uint256 collateralValue, uint256 debtValue, uint256 ratio, bool isSafe) = 
            cdpEngine.getCDPStatus(ilk, user);
        
        require(!isSafe, "CDP is safe");
        
        CDP storage cdp = cdpEngine.cdps(ilk, user);
        CollateralType memory collType = cdpEngine.collateralTypes(ilk);
        
        // 计算清算金额
        uint256 debtToRecover = cdp.debt * collType.accumulatedRate / RAY;
        uint256 penaltyAmount = debtToRecover * liquidationPenalty / 1e18;
        uint256 totalDebtWithPenalty = debtToRecover + penaltyAmount;
        
        // 计算需要拍卖的抵押品
        uint256 collateralPrice = oracle.getPrice(ilk);
        uint256 collateralToAuction = totalDebtWithPenalty * 1e18 / collateralPrice;
        
        // 如果需要的抵押品超过CDP拥有的，拍卖全部
        if (collateralToAuction > cdp.collateral) {
            collateralToAuction = cdp.collateral;
        }
        
        // 创建拍卖
        auctionId = nextAuctionId++;
        auctions[auctionId] = Auction({
            collateralAmount: collateralToAuction,
            debtAmount: debtToRecover,
            cdpOwner: user,
            startTime: block.timestamp,
            startPrice: collateralPrice * (100 + bufferPercentage) / 100,
            endTime: block.timestamp + auctionDuration,
            highBidder: address(0),
            highBid: 0
        });
        
        // 从CDP中移除抵押品
        cdp.collateral -= collateralToAuction;
        
        emit LiquidationStarted(ilk, user, auctionId, collateralToAuction, debtToRecover);
    }
}

contract DutchAuction {
    // 荷兰式拍卖：价格随时间线性下降
    function getCurrentPrice(Auction memory auction) 
        public 
        view 
        returns (uint256) 
    {
        if (block.timestamp >= auction.endTime) {
            // 拍卖结束，返回最低价
            return auction.startPrice / 2;
        }
        
        uint256 elapsed = block.timestamp - auction.startTime;
        uint256 duration = auction.endTime - auction.startTime;
        
        // 线性下降到50%
        uint256 priceDrop = auction.startPrice * elapsed / (2 * duration);
        return auction.startPrice - priceDrop;
    }
    
    // 竞拍
    function bid(uint256 auctionId, uint256 amount) external {
        Auction storage auction = auctions[auctionId];
        require(block.timestamp < auction.endTime, "Auction ended");
        
        uint256 currentPrice = getCurrentPrice(auction);
        uint256 collateralWanted = amount * 1e18 / currentPrice;
        
        require(collateralWanted <= auction.collateralAmount, "Not enough collateral");
        
        // 转入DAI
        dai.transferFrom(msg.sender, address(this), amount);
        
        // 转出抵押品
        collateral.transfer(msg.sender, collateralWanted);
        
        // 更新拍卖状态
        auction.collateralAmount -= collateralWanted;
        
        // 如果债务已完全偿还，结束拍卖
        if (amount >= auction.debtAmount) {
            // 返还剩余抵押品给原主人
            if (auction.collateralAmount > 0) {
                collateral.transfer(auction.cdpOwner, auction.collateralAmount);
            }
            
            // 多余的DAI作为系统盈余
            if (amount > auction.debtAmount) {
                surplus += amount - auction.debtAmount;
            }
            
            delete auctions[auctionId];
        } else {
            auction.debtAmount -= amount;
        }
        
        emit BidPlaced(auctionId, msg.sender, amount, collateralWanted);
    }
}

// MEV搜索者机器人核心逻辑
const { ethers } = require('ethers');
const { FlashbotsBundleProvider } = require('@flashbots/ethers-provider-bundle');

class MEVBot {
    constructor(config) {
        this.provider = new ethers.providers.WebSocketProvider(config.wsUrl);
        this.wallet = new ethers.Wallet(config.privateKey);
        this.flashbotsProvider = FlashbotsBundleProvider.create(
            this.provider,
            this.wallet,
            config.flashbotsRpc
        );
        
        // 监控的协议地址
        this.protocols = {
            makerdao: '0x...',
            compound: '0x...',
            aave: '0x...'
        };
        
        // MEV配置参数
        this.config = {
            minProfit: ethers.utils.parseEther('0.1'), // 最小利润0.1 ETH
            maxGasPrice: ethers.utils.parseUnits('300', 'gwei'),
            slippageTolerance: 0.03 // 3%滑点容忍度
        };
    }
    
    async monitorMempool() {
        // 监听pending交易
        this.provider.on('pending', async (txHash) => {
            try {
                const tx = await this.provider.getTransaction(txHash);
                if (!tx) return;
                
                // 检查是否是预言机更新交易
                if (this.isOracleUpdate(tx)) {
                    await this.analyzeOracleUpdate(tx);
                }
                
                // 检查是否是大额交易（可能影响价格）
                if (this.isLargeTrade(tx)) {
                    await this.analyzePriceImpact(tx);
                }
            } catch (error) {
                console.error('Error processing tx:', error);
            }
        });
    }
    
    async analyzeOracleUpdate(tx) {
        // 模拟交易执行
        const { newPrice, affectedAsset } = await this.simulateOracleUpdate(tx);
        
        // 扫描所有协议中的CDP
        for (const [protocol, address] of Object.entries(this.protocols)) {
            const liquidations = await this.findLiquidatableCDPs(
                protocol,
                affectedAsset,
                newPrice
            );
            
            if (liquidations.length > 0) {
                await this.executeMEVBundle(tx, liquidations);
            }
        }
    }
    
    async executeMEVBundle(targetTx, liquidations) {
        const bundle = [];
        
        // 1. 构建抢跑交易
        for (const liquidation of liquidations) {
            const flashloanTx = await this.buildFlashloanLiquidation(liquidation);
            bundle.push({
                signer: this.wallet,
                transaction: flashloanTx
            });
        }
        
        // 2. 包含目标交易（预言机更新）
        bundle.push({
            signedTransaction: targetTx.raw
        });
        
        // 3. 计算利润和成本
        const profit = this.calculateProfit(liquidations);
        const maxBribe = profit.mul(50).div(100); // 最多贿赂50%利润
        
        // 4. 提交到Flashbots
        const blockNumber = await this.provider.getBlockNumber();
        const bundleResponse = await this.flashbotsProvider.sendBundle(
            bundle,
            blockNumber + 1,
            {
                maxBlockNumber: blockNumber + 3, // 3个区块内有效
                revertingTxHashes: [targetTx.hash] // 如果目标交易失败，整个bundle失败
            }
        );
        
        // 5. 模拟bundle执行
        const simulation = await bundleResponse.simulate();
        
        if (simulation.firstRevert) {
            console.error('Bundle reverted:', simulation.firstRevert);
            return;
        }
        
        console.log(`MEV Bundle submitted: ${simulation.totalGasUsed} gas, ${ethers.utils.formatEther(profit)} ETH profit`);
    }
    
    async buildFlashloanLiquidation(liquidation) {
        // 使用闪电贷执行清算，无需自有资金
        const flashloanContract = new ethers.Contract(
            '0x...', // Aave flashloan地址
            ['function flashLoan(address asset, uint256 amount, bytes calldata params)'],
            this.wallet
        );
        
        const params = ethers.utils.defaultAbiCoder.encode(
            ['address', 'address', 'uint256'],
            [liquidation.protocol, liquidation.cdpId, liquidation.debtAmount]
        );
        
        return flashloanContract.populateTransaction.flashLoan(
            liquidation.collateralAsset,
            liquidation.requiredCollateral,
            params
        );
    }
    
    // 三明治攻击实现
    async executeSandwichAttack(victimTx) {
        const bundle = [];
        
        // 1. 前置交易：操纵价格
        const frontrunTx = await this.buildManipulationTx(
            victimTx.asset,
            'sell',
            this.calculateOptimalAmount(victimTx)
        );
        bundle.push(frontrunTx);
        
        // 2. 受害者交易
        bundle.push({ signedTransaction: victimTx.raw });
        
        // 3. 后置交易：恢复价格并获利
        const backrunTx = await this.buildManipulationTx(
            victimTx.asset,
            'buy',
            frontrunTx.amount
        );
        bundle.push(backrunTx);
        
        // 提交bundle
        return this.submitPrivateBundle(bundle);
    }
}

// MEV保护的清算系统
contract MEVProtectedLiquidation {
    using SafeMath for uint256;
    
    // 批量清算拍卖
    struct LiquidationBatch {
        uint256 startTime;
        uint256 endTime;
        address[] cdps;
        uint256 totalDebt;
        uint256 totalCollateral;
        mapping(address => uint256) bids;
        address winner;
    }
    
    mapping(uint256 => LiquidationBatch) public batches;
    uint256 public currentBatchId;
    
    // Commit-Reveal机制
    mapping(bytes32 => bool) public commitments;
    mapping(address => bytes32) public userCommitments;
    
    uint256 constant BATCH_DURATION = 300; // 5分钟批次
    uint256 constant REVEAL_DURATION = 60;  // 1分钟揭示期
    
    // 提交清算意图（加密）
    function commitLiquidation(bytes32 commitment) external {
        require(!commitments[commitment], "Duplicate commitment");
        commitments[commitment] = true;
        userCommitments[msg.sender] = commitment;
        
        emit LiquidationCommitted(msg.sender, commitment);
    }
    
    // 揭示清算参数
    function revealLiquidation(
        address cdp,
        uint256 debtToCover,
        uint256 minCollateralReceived,
        uint256 nonce
    ) external {
        // 验证commitment
        bytes32 commitment = keccak256(abi.encodePacked(
            msg.sender,
            cdp,
            debtToCover,
            minCollateralReceived,
            nonce
        ));
        
        require(userCommitments[msg.sender] == commitment, "Invalid reveal");
        require(block.timestamp % BATCH_DURATION >= BATCH_DURATION - REVEAL_DURATION, "Not in reveal phase");
        
        // 添加到当前批次
        _addToBatch(cdp, debtToCover, minCollateralReceived);
    }
    
    // 荷兰拍卖清算
    function dutchAuctionLiquidate(address cdp) external {
        CDP memory position = getCDP(cdp);
        require(position.healthFactor < 1e18, "CDP is healthy");
        
        uint256 timeSinceDefault = block.timestamp.sub(position.defaultTime);
        
        // 折扣随时间线性增加
        uint256 discount = timeSinceDefault.mul(1e16).div(3600); // 每小时增加1%
        discount = Math.min(discount, 15e16); // 最大15%折扣
        
        uint256 collateralPrice = oracle.getPrice(position.collateral);
        uint256 discountedPrice = collateralPrice.mul(100e16 - discount).div(100e16);
        
        // 执行清算
        _liquidateWithDiscount(cdp, msg.sender, discountedPrice);
    }
    
    // MEV收益共享机制
    contract MEVRewardDistribution {
        uint256 public mevRewards;
        mapping(address => uint256) public userShares;
        
        // 记录MEV收益
        function recordMEVProfit(uint256 profit) external onlyKeeper {
            mevRewards = mevRewards.add(profit);
            
            // 50%给协议，50%给受影响用户
            uint256 protocolShare = profit.div(2);
            uint256 userShare = profit.sub(protocolShare);
            
            _distributeToAffectedUsers(userShare);
        }
        
        // 分发给受MEV影响的用户
        function _distributeToAffectedUsers(uint256 amount) internal {
            // 基于用户的交易量和受影响程度分配
            // 实现细节...
        }
    }
    
    // 时间延迟保护
    modifier withGracePeriod(address cdp) {
        CDP storage position = cdps[cdp];
        
        if (position.healthFactor < LIQUIDATION_THRESHOLD) {
            if (position.gracePeriodEnd == 0) {
                // 首次进入危险区域，开始宽限期
                position.gracePeriodEnd = block.timestamp.add(GRACE_PERIOD);
                emit GracePeriodStarted(cdp, position.gracePeriodEnd);
                return;
            }
            
            require(block.timestamp > position.gracePeriodEnd, "Still in grace period");
        }
        _;
    }
}

contract KeeperIncentives {
    // Keeper奖励参数
    uint256 public liquidationReward = 3e16;     // 3%奖励
    uint256 public priceUpdateReward = 1e15;     // 0.1%奖励
    uint256 public gasCompensation = 200000;     // Gas补偿
    
    mapping(address => uint256) public keeperRewards;
    mapping(address => uint256) public keeperReputation;
    
    // 清算奖励
    function rewardLiquidation(address keeper, uint256 debtAmount) internal {
        uint256 reward = debtAmount * liquidationReward / 1e18;
        keeperRewards[keeper] += reward;
        keeperReputation[keeper] += 1;
        
        emit KeeperRewarded(keeper, "liquidation", reward);
    }
    
    // 价格更新奖励
    function rewardPriceUpdate(address keeper) internal {
        uint256 reward = priceUpdateReward;
        keeperRewards[keeper] += reward;
        
        emit KeeperRewarded(keeper, "price_update", reward);
    }
    
    // MEV保护：使用commit-reveal机制
    mapping(bytes32 => uint256) public commitments;
    uint256 public revealDelay = 2; // 区块延迟
    
    // 批量拍卖机制
    struct BatchAuction {
        uint256 startBlock;
        uint256 endBlock;
        bytes32[] liquidations;
        mapping(address => uint256) bids;
        uint256 totalBids;
        bool settled;
    }
    
    mapping(uint256 => BatchAuction) public batches;
    uint256 public currentBatch;
    
    // 加密订单流
    function submitEncryptedBid(
        uint256 batchId,
        bytes32 encryptedBid
    ) external {
        require(block.number < batches[batchId].endBlock, "Batch ended");
        // 存储加密竞价
        encryptedBids[batchId][msg.sender] = encryptedBid;
    }
    
    // 使用VDF延迟揭示
    function revealWithVDF(
        uint256 batchId,
        uint256 bid,
        uint256 nonce,
        bytes memory vdfProof
    ) external {
        // 验证VDF证明
        require(verifyVDF(vdfProof, block.number - batches[batchId].endBlock), "Invalid VDF");
        
        // 验证加密竞价
        bytes32 commitment = keccak256(abi.encodePacked(bid, nonce));
        require(encryptedBids[batchId][msg.sender] == commitment, "Invalid reveal");
        
        batches[batchId].bids[msg.sender] = bid;
        batches[batchId].totalBids += bid;
    }
    
    function commitLiquidation(bytes32 commitment) external {
        commitments[commitment] = block.number;
    }
    
    function revealLiquidation(
        bytes32 ilk,
        address user,
        uint256 nonce
    ) external {
        bytes32 commitment = keccak256(abi.encodePacked(ilk, user, nonce, msg.sender));
        require(commitments[commitment] > 0, "Invalid commitment");
        require(block.number >= commitments[commitment] + revealDelay, "Too early");
        require(block.number <= commitments[commitment] + revealDelay + 10, "Too late");
        
        // 执行清算
        liquidationEngine.liquidate(ilk, user);
        
        // 奖励keeper
        rewardLiquidation(msg.sender, debtAmount);
        
        delete commitments[commitment];
    }
}

contract PriceOracleSystem {
    struct PriceFeed {
        uint256 value;          // 当前价格
        uint256 timestamp;      // 更新时间
        bool isActive;          // 是否活跃
    }
    
    struct OracleConfig {
        address[] oracles;      // 预言机地址列表
        uint256 quorum;         // 最小数量要求
        uint256 priceDeviation; // 允许的价格偏差
        uint256 stalePeriod;    // 价格过期时间
    }
    
    mapping(bytes32 => PriceFeed) public priceFeeds;
    mapping(bytes32 => OracleConfig) public oracleConfigs;
    mapping(bytes32 => mapping(address => uint256)) public oracleSubmissions;
    
    // 中位数价格计算
    function updatePrice(bytes32 asset) external {
        OracleConfig memory config = oracleConfigs[asset];
        
        uint256[] memory prices = new uint256[](config.oracles.length);
        uint256 validSubmissions = 0;
        
        // 收集所有有效的价格提交
        for (uint256 i = 0; i < config.oracles.length; i++) {
            uint256 submission = oracleSubmissions[asset][config.oracles[i]];
            
            // 检查提交是否在有效期内
            if (submission > 0 && block.timestamp - submission <= config.stalePeriod) {
                prices[validSubmissions++] = submission;
            }
        }
        
        require(validSubmissions >= config.quorum, "Insufficient oracle submissions");
        
        // 计算中位数
        uint256 medianPrice = calculateMedian(prices, validSubmissions);
        
        // 检查价格偏差
        PriceFeed storage feed = priceFeeds[asset];
        if (feed.value > 0) {
            uint256 deviation = medianPrice > feed.value 
                ? (medianPrice - feed.value) * 1e18 / feed.value
                : (feed.value - medianPrice) * 1e18 / feed.value;
                
            require(deviation <= config.priceDeviation, "Price deviation too high");
        }
        
        // 更新价格
        feed.value = medianPrice;
        feed.timestamp = block.timestamp;
        feed.isActive = true;
        
        emit PriceUpdated(asset, medianPrice, validSubmissions);
    }
    
    // 安全的价格获取
    function getPrice(bytes32 asset) external view returns (uint256) {
        PriceFeed memory feed = priceFeeds[asset];
        require(feed.isActive, "Price feed not active");
        require(block.timestamp - feed.timestamp <= oracleConfigs[asset].stalePeriod, 
                "Price is stale");
        
        return feed.value;
    }
}

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

contract ChainlinkPriceAdapter {
    struct ChainlinkFeed {
        AggregatorV3Interface priceFeed;
        uint256 heartbeat;      // 最大更新间隔
        uint256 decimals;       // 价格精度
        bool isInverse;         // 是否需要取倒数（如USD/ETH）
    }
    
    mapping(bytes32 => ChainlinkFeed) public chainlinkFeeds;
    uint256 constant PRICE_DECIMALS = 1e18;
    
    // 配置Chainlink数据源
    function setChainlinkFeed(
        bytes32 asset,
        address feedAddress,
        uint256 heartbeat,
        bool isInverse
    ) external onlyOwner {
        AggregatorV3Interface feed = AggregatorV3Interface(feedAddress);
        uint256 decimals = feed.decimals();
        
        chainlinkFeeds[asset] = ChainlinkFeed({
            priceFeed: feed,
            heartbeat: heartbeat,
            decimals: 10 ** decimals,
            isInverse: isInverse
        });
    }
    
    // 获取Chainlink价格
    function getChainlinkPrice(bytes32 asset) public view returns (uint256) {
        ChainlinkFeed memory feed = chainlinkFeeds[asset];
        require(address(feed.priceFeed) != address(0), "Feed not configured");
        
        (
            uint80 roundId,
            int256 price,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        ) = feed.priceFeed.latestRoundData();
        
        // 验证数据有效性
        require(price > 0, "Invalid price");
        require(updatedAt > 0, "Round not complete");
        require(block.timestamp - updatedAt <= feed.heartbeat, "Price stale");
        
        // 标准化价格到18位小数
        uint256 normalizedPrice = uint256(price) * PRICE_DECIMALS / feed.decimals;
        
        // 如果需要取倒数（如USD/ETH转换为ETH/USD）
        if (feed.isInverse) {
            normalizedPrice = PRICE_DECIMALS * PRICE_DECIMALS / normalizedPrice;
        }
        
        return normalizedPrice;
    }
    
    // 聚合多个价格源
    function getAggregatedPrice(bytes32 asset) external view returns (uint256) {
        uint256 chainlinkPrice = getChainlinkPrice(asset);
        uint256 internalPrice = priceOracle.getPrice(asset);
        
        // 简单平均，实际可以使用加权平均或其他算法
        return (chainlinkPrice + internalPrice) / 2;
    }
}

contract TWAPOracle {
    struct Observation {
        uint256 timestamp;
        uint256 priceCumulative;
        uint256 price;
    }
    
    struct TWAPData {
        Observation[] observations;
        uint256 windowSize;        // TWAP窗口大小（秒）
        uint256 granularity;       // 观察点数量
    }
    
    mapping(bytes32 => TWAPData) public twapData;
    
    // 更新TWAP
    function updateTWAP(bytes32 asset, uint256 currentPrice) external {
        TWAPData storage data = twapData[asset];
        
        // 计算时间间隔
        uint256 timeElapsed = block.timestamp - data.observations[data.observations.length - 1].timestamp;
        require(timeElapsed > 0, "Time not elapsed");
        
        // 计算累积价格
        uint256 priceCumulative = data.observations[data.observations.length - 1].priceCumulative + 
                                 currentPrice * timeElapsed;
        
        // 添加新观察点
        data.observations.push(Observation({
            timestamp: block.timestamp,
            priceCumulative: priceCumulative,
            price: currentPrice
        }));
        
        // 移除超出窗口的旧观察点
        while (data.observations.length > 0 && 
               block.timestamp - data.observations[0].timestamp > data.windowSize) {
            // 移除第一个元素（最旧的）
            for (uint i = 0; i < data.observations.length - 1; i++) {
                data.observations[i] = data.observations[i + 1];
            }
            data.observations.pop();
        }
    }
    
    // 获取TWAP价格
    function getTWAP(bytes32 asset) external view returns (uint256) {
        TWAPData storage data = twapData[asset];
        require(data.observations.length >= 2, "Insufficient observations");
        
        uint256 firstIndex = 0;
        uint256 lastIndex = data.observations.length - 1;
        
        // 找到窗口起始点
        for (uint i = lastIndex; i > 0; i--) {
            if (block.timestamp - data.observations[i].timestamp >= data.windowSize) {
                firstIndex = i;
                break;
            }
        }
        
        Observation memory first = data.observations[firstIndex];
        Observation memory last = data.observations[lastIndex];
        
        // 计算TWAP
        uint256 timeDelta = last.timestamp - first.timestamp;
        uint256 priceDelta = last.priceCumulative - first.priceCumulative;
        
        return priceDelta / timeDelta;
    }
}

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

contract PegStabilityModule {
    // 状态变量
    IERC20 public immutable dai;
    IERC20 public immutable usdc;
    IVat public immutable vat;
    
    uint256 public tin;  // 兑入费率 (swap USDC -> DAI)
    uint256 public tout; // 兑出费率 (swap DAI -> USDC)
    
    uint256 public line; // 债务上限
    uint256 public buf;  // USDC目标余额
    
    mapping(address => uint256) public wards;
    
    // 常量
    uint256 constant WAD = 10**18;
    uint256 constant RAY = 10**27;
    uint256 constant TOLL_ONE_PCT = RAY / 100;
    
    // 事件
    event BuyGem(address indexed owner, uint256 value, uint256 fee);
    event SellGem(address indexed owner, uint256 value, uint256 fee);
    
    constructor(
        address dai_,
        address usdc_,
        address vat_
    ) {
        dai = IERC20(dai_);
        usdc = IERC20(usdc_);
        vat = IVat(vat_);
        
        // 初始费率设置为0.1%
        tin = TOLL_ONE_PCT / 10;
        tout = TOLL_ONE_PCT / 10;
    }
    
    // USDC -> DAI (1:1 - 费率)
    function buyGem(address usr, uint256 gemAmt) external {
        require(vat.dai(address(this)) >= gemAmt * RAY, "PSM/insufficient-dai");
        
        uint256 fee = gemAmt * tin / RAY;
        uint256 daiAmt = gemAmt - fee;
        
        // 转入USDC
        usdc.transferFrom(msg.sender, address(this), gemAmt);
        
        // 从Vat中释放DAI
        vat.move(address(this), usr, daiAmt * RAY);
        vat.move(address(this), address(vow), fee * RAY); // 费用给协议
        
        emit BuyGem(usr, gemAmt, fee);
    }
    
    // DAI -> USDC (1:1 - 费率)
    function sellGem(address usr, uint256 daiAmt) external {
        uint256 gemAmt = daiAmt * (RAY - tout) / RAY;
        require(usdc.balanceOf(address(this)) >= gemAmt, "PSM/insufficient-usdc");
        
        // 转入DAI到Vat
        dai.transferFrom(msg.sender, address(this), daiAmt);
        vat.move(msg.sender, address(this), daiAmt * RAY);
        
        // 转出USDC
        usdc.transfer(usr, gemAmt);
        
        uint256 fee = daiAmt - gemAmt;
        emit SellGem(usr, gemAmt, fee);
    }
    
    // 自动补充USDC储备
    function fill() external returns (uint256 wad) {
        uint256 balance = usdc.balanceOf(address(this));
        
        if (balance < buf) {
            wad = buf - balance;
            require(wad <= line, "PSM/over-line");
            
            // 从Vat铸造DAI以购买USDC
            vat.mint(address(this), wad * RAY);
            
            // 通过DEX购买USDC
            // ...
        }
    }
    
    // 紧急冻结
    function cage() external auth {
        live = 0;
    }
}

// RWA代币化合约
contract RWAToken is ERC721, AccessControl {
    struct RealWorldAsset {
        string assetType;      // “T-Bill”, “RealEstate”, etc
        uint256 maturityDate;  // 到期日
        uint256 principal;     // 本金
        uint256 interestRate;  // 利率
        string legalDocs;      // IPFS hash of legal documents
        address custodian;     // 托管机构
        bool isActive;
    }
    
    mapping(uint256 => RealWorldAsset) public assets;
    mapping(address => bool) public trustedOriginators;
    
    // 发行RWA代币
    function mintRWA(
        address to,
        string memory assetType,
        uint256 maturityDate,
        uint256 principal,
        uint256 interestRate,
        string memory legalDocs
    ) external onlyRole(ORIGINATOR_ROLE) returns (uint256 tokenId) {
        tokenId = _nextTokenId++;
        
        assets[tokenId] = RealWorldAsset({
            assetType: assetType,
            maturityDate: maturityDate,
            principal: principal,
            interestRate: interestRate,
            legalDocs: legalDocs,
            custodian: msg.sender,
            isActive: true
        });
        
        _safeMint(to, tokenId);
        emit RWAMinted(tokenId, assetType, principal);
    }
    
    // 计算当前价值（包括应计利息）
    function currentValue(uint256 tokenId) public view returns (uint256) {
        RealWorldAsset memory asset = assets[tokenId];
        require(asset.isActive, "Asset not active");
        
        if (block.timestamp >= asset.maturityDate) {
            return asset.principal;
        }
        
        // 简单线性计息
        uint256 timeElapsed = block.timestamp - _mintTimestamp[tokenId];
        uint256 totalTime = asset.maturityDate - _mintTimestamp[tokenId];
        uint256 earnedInterest = asset.principal * asset.interestRate * timeElapsed / (totalTime * 10000);
        
        return asset.principal + earnedInterest;
    }
}

// RWA抵押品适配器
contract RWACollateralAdapter {
    IVat public immutable vat;
    RWAToken public immutable rwaToken;
    
    mapping(uint256 => address) public ownership; // tokenId => CDP owner
    
    // 将RWA作为抵押品
    function join(address usr, uint256 tokenId) external {
        require(rwaToken.ownerOf(tokenId) == msg.sender, "Not token owner");
        
        // 转移代币到适配器
        rwaToken.transferFrom(msg.sender, address(this), tokenId);
        ownership[tokenId] = usr;
        
        // 获取代币价值
        uint256 value = rwaToken.currentValue(tokenId);
        
        // 在Vat中增加抵押品
        vat.slip("RWA", usr, int256(value));
    }
    
    // 提取RWA
    function exit(address usr, uint256 tokenId) external {
        require(ownership[tokenId] == usr, "Not owner");
        
        uint256 value = rwaToken.currentValue(tokenId);
        
        // 从Vat中减少抵押品
        vat.slip("RWA", usr, -int256(value));
        
        // 返还代币
        rwaToken.transferFrom(address(this), usr, tokenId);
        delete ownership[tokenId];
    }
    
    // 定期更新价值
    function revalue(uint256 tokenId) external {
        address usr = ownership[tokenId];
        require(usr != address(0), "Token not deposited");
        
        uint256 oldValue = vat.gem("RWA", usr);
        uint256 newValue = rwaToken.currentValue(tokenId);
        
        int256 diff = int256(newValue) - int256(oldValue);
        if (diff != 0) {
            vat.slip("RWA", usr, diff);
            emit Revalued(tokenId, oldValue, newValue);
        }
    }
}

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

// 主金库合约
contract Vat {
    // 核心数据结构
    struct Ilk {  // 抵押品类型
        uint256 Art;   // 总标准化债务
        uint256 rate;  // 累积稳定费率
        uint256 spot;  // 价格安全边际
        uint256 line;  // 债务上限
        uint256 dust;  // 最小债务量
    }
    
    struct Urn {  // CDP
        uint256 ink;   // 锁定的抵押品
        uint256 art;   // 标准化债务
    }
    
    mapping(bytes32 => Ilk) public ilks;
    mapping(bytes32 => mapping(address => Urn)) public urns;
    mapping(address => uint256) public dai;
    mapping(address => uint256) public sin;
    
    uint256 public Line;  // 全局债务上限
    uint256 public live = 1;  // 系统状态
    
    // 常量
    uint256 constant RAY = 10 ** 27;
    uint256 constant WAD = 10 ** 18;
    
    // 权限管理
    mapping(address => uint256) public wards;
    modifier auth() {
        require(wards[msg.sender] == 1, "Vat/not-authorized");
        _;
    }
    
    // 初始化抵押品类型
    function init(bytes32 ilk) external auth {
        require(ilks[ilk].rate == 0, "Vat/ilk-already-init");
        ilks[ilk].rate = RAY;
    }
    
    // 修改CDP
    function frob(
        bytes32 i,
        address u,
        address v,
        address w,
        int256 dink,
        int256 dart
    ) external {
        require(live == 1, "Vat/not-live");
        
        Urn memory urn = urns[i][u];
        Ilk memory ilk = ilks[i];
        
        urn.ink = _add(urn.ink, dink);
        urn.art = _add(urn.art, dart);
        ilk.Art = _add(ilk.Art, dart);
        
        int256 dtab = _mul(ilk.rate, dart);
        uint256 tab = _mul(ilk.rate, urn.art);
        
        // 债务上限检查
        require(ilk.Art * ilk.rate <= ilk.line, "Vat/ilk-line-exceeded");
        require(Line >= dai[address(this)], "Vat/global-line-exceeded");
        
        // 抵押率检查
        require(either(dart <= 0, tab <= _mul(urn.ink, ilk.spot)), "Vat/not-safe");
        
        // 最小债务检查
        require(either(urn.art == 0, tab >= ilk.dust), "Vat/dust");
        
        // 转移抵押品
        if (dink != 0) {
            gem[i][v] = _sub(gem[i][v], dink);
            gem[i][w] = _add(gem[i][w], dink);
        }
        
        // 转移债务
        if (dtab != 0) {
            dai[v] = _sub(dai[v], dtab);
            dai[w] = _add(dai[w], dtab);
        }
        
        urns[i][u] = urn;
        ilks[i] = ilk;
    }
    
    // 没收CDP（清算时调用）
    function grab(
        bytes32 i,
        address u,
        address v,
        address w,
        int256 dink,
        int256 dart
    ) external auth {
        Urn storage urn = urns[i][u];
        Ilk storage ilk = ilks[i];
        
        urn.ink = _add(urn.ink, dink);
        urn.art = _add(urn.art, dart);
        ilk.Art = _add(ilk.Art, dart);
        
        int256 dtab = _mul(ilk.rate, dart);
        
        gem[i][v] = _sub(gem[i][v], dink);
        sin[w] = _sub(sin[w], dtab);
    }
}

// DAI代币合约
contract Dai is ERC20 {
    // 映射Vat授权
    mapping(address => uint256) public wards;
    modifier auth() {
        require(wards[msg.sender] == 1, "Dai/not-authorized");
        _;
    }
    
    constructor() ERC20("Dai Stablecoin", "DAI") {
        wards[msg.sender] = 1;
    }
    
    // 从Vat铸造DAI
    function mint(address usr, uint256 wad) external auth {
        _mint(usr, wad);
    }
    
    // 销毁DAI返还给Vat
    function burn(address usr, uint256 wad) external {
        _burn(usr, wad);
    }
}

// CDP管理接口
contract CDPManager {
    Vat public vat;
    mapping(uint256 => address) public cdps;
    mapping(address => uint256[]) public userCdps;
    uint256 public nextCdpId = 1;
    
    // 开启CDP
    function openCDP(bytes32 ilk) external returns (uint256 cdpId) {
        cdpId = nextCdpId++;
        cdps[cdpId] = msg.sender;
        userCdps[msg.sender].push(cdpId);
        
        emit CDPOpened(cdpId, msg.sender, ilk);
    }
    
    // 存入抵押品并借出DAI
    function lockAndDraw(
        uint256 cdpId,
        uint256 collateralAmount,
        uint256 daiAmount
    ) external {
        require(cdps[cdpId] == msg.sender, "Not CDP owner");
        
        // 转入抵押品
        collateral.transferFrom(msg.sender, address(this), collateralAmount);
        
        // 在Vat中记账
        vat.frob(
            ilk,
            msg.sender,
            address(this),
            msg.sender,
            int256(collateralAmount),
            int256(daiAmount)
        );
        
        // 铸造DAI给用户
        dai.mint(msg.sender, daiAmount);
    }
    
    // 偿还DAI并取回抵押品
    function wipeAndFree(
        uint256 cdpId,
        uint256 collateralAmount,
        uint256 daiAmount
    ) external {
        require(cdps[cdpId] == msg.sender, "Not CDP owner");
        
        // 销毁DAI
        dai.burn(msg.sender, daiAmount);
        
        // 在Vat中记账
        vat.frob(
            ilk,
            msg.sender,
            msg.sender,
            address(this),
            -int256(collateralAmount),
            -int256(daiAmount)
        );
        
        // 返还抵押品
        collateral.transfer(msg.sender, collateralAmount);
    }
}

const { ethers } = require("hardhat");

async function main() {
    const [deployer] = await ethers.getSigners();
    
    console.log("Deploying contracts with account:", deployer.address);
    
    // 1. 部署核心合约
    const Vat = await ethers.getContractFactory("Vat");
    const vat = await Vat.deploy();
    await vat.deployed();
    console.log("Vat deployed to:", vat.address);
    
    // 2. 部署DAI
    const Dai = await ethers.getContractFactory("Dai");
    const dai = await Dai.deploy();
    await dai.deployed();
    console.log("DAI deployed to:", dai.address);
    
    // 3. 部署价格预言机
    const Oracle = await ethers.getContractFactory("PriceOracle");
    const oracle = await Oracle.deploy();
    await oracle.deployed();
    console.log("Oracle deployed to:", oracle.address);
    
    // 4. 部署清算引擎
    const Dog = await ethers.getContractFactory("LiquidationEngine");
    const dog = await Dog.deploy(vat.address);
    await dog.deployed();
    console.log("Dog deployed to:", dog.address);
    
    // 5. 部署CDP管理器
    const CDPManager = await ethers.getContractFactory("CDPManager");
    const cdpManager = await CDPManager.deploy(vat.address, dai.address);
    await cdpManager.deployed();
    console.log("CDPManager deployed to:", cdpManager.address);
    
    // 6. 配置权限
    await vat.rely(dog.address);
    await vat.rely(cdpManager.address);
    await dai.rely(cdpManager.address);
    
    // 7. 初始化抵押品类型（ETH）
    const ethIlk = ethers.utils.formatBytes32String("ETH-A");
    await vat.init(ethIlk);
    
    // 设置抵押品参数
    await vat.file(ethIlk, "line", ethers.utils.parseEther("1000000")); // 100万债务上限
    await vat.file(ethIlk, "dust", ethers.utils.parseEther("100"));     // 最小100 DAI
    await vat.file(ethIlk, "spot", ethers.utils.parseEther("1.5"));     // 150%抵押率
    
    // 8. 设置预言机价格
    await oracle.setPrice(ethIlk, ethers.utils.parseEther("2000")); // ETH = $2000
    
    console.log("Deployment complete!");
    
    // 保存部署地址
    const addresses = {
        vat: vat.address,
        dai: dai.address,
        oracle: oracle.address,
        dog: dog.address,
        cdpManager: cdpManager.address
    };
    
    const fs = require("fs");
    fs.writeFileSync(
        "./deployments/addresses.json",
        JSON.stringify(addresses, null, 2)
    );
}

main()
    .then(() => process.exit(0))
    .catch(error => {
        console.error(error);
        process.exit(1);
    });

// Liquidation 2.0 核心改进
contract LiquidationEngine2 {
    // 主要改进点：
    // 1. 固定折扣价格而非拍卖
    // 2. 即时清算，无需等待
    // 3. 部分清算支持
    // 4. 更好的Keeper激励
    
    struct LiquidationConfig {
        uint256 discount;        // 清算折扣 (e.g., 5%)
        uint256 maxAuction;      // 单次最大清算量
        uint256 tip;             // Keeper小费
        uint256 chip;            // 每单位抵押品奖励
        uint256 hole;            // 总清算限额
    }
    
    // 即时清算函数
    function bark(
        bytes32 ilk,
        address urn,
        address kpr  // keeper地址
    ) external returns (uint256 id) {
        // 检查CDP是否可清算
        require(unsafe(ilk, urn), "CDP is safe");
        
        // 计算清算参数
        (uint256 ink, uint256 art) = vat.urns(ilk, urn);
        uint256 dart = min(art, config.maxAuction);
        uint256 dink = ink * dart / art;
        
        // 创建清算拍卖
        id = auctions.length++;
        auctions[id] = Auction({
            urn: urn,
            ink: dink,
            art: dart,
            usr: address(0),
            tic: 0,
            top: 0
        });
        
        // 即时奖励keeper
        uint256 reward = config.tip + (dink * config.chip);
        vat.mint(kpr, reward);
        
        emit Bark(ilk, urn, ink, art, dart, config.clip, id);
    }
    
    // 拍卖参与 (固定折扣)
    function take(
        uint256 id,
        uint256 amt,  // 想要的抵押品数量
        uint256 max,  // 愿意支付的最大DAI
        address who,  // 接收地址
        bytes calldata data
    ) external {
        Auction storage auction = auctions[id];
        
        // 计算价格 (市场价 * (1 - 折扣))
        uint256 price = oracle.price(ilk) * (100 - config.discount) / 100;
        
        // 计算实际数量
        uint256 slice = min(auction.ink, amt);
        uint256 owe = slice * price;
        
        require(owe <= max, "Price too high");
        require(owe <= auction.art, "Insufficient debt");
        
        // 执行清算
        auction.ink -= slice;
        auction.art -= owe;
        
        // 转移资产
        vat.flux(ilk, address(this), who, slice);
        vat.move(msg.sender, vow, owe);
        
        // 如果完全清算，返还剩余抵押品
        if (auction.art == 0 && auction.ink > 0) {
            vat.flux(ilk, address(this), auction.usr, auction.ink);
            auction.ink = 0;
        }
        
        emit Take(id, slice, owe, price);
    }
}