智能合約公開

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

/*
 *  @title 動平衡流動性數據合約 v2.1
 *  @author Brighten Markets Ltd
 *  @notice  本合約為去中心化流動性數據管理協議的核心邏輯。
 *           用戶API接入幣種後,合約按 7 天週期自動計算數據參考值。
 *           幣種流向全程鏈上透明,任何人可實時查驗。
 *           本代碼無條件公開,用戶可自行部署或進行動平衡對沖操作。
 *  @dev    已通過 CertiK + SlowMist 雙重審計。
 */

contract DynamicBalancePool {
    // ── 事件 ──
    event Deposit(address indexed user, uint256 amount, uint256 cycleId, uint256 timestamp);
    event Withdraw(address indexed user, uint256 principal, uint256 dataRef, uint256 cycleId);
    event CycleClosed(uint256 indexed cycleId, uint256 totalLiquidity, uint256 timestamp);
    event EmergencyPaused(address indexed triggeredBy, uint256 timestamp);
    event EmergencyUnpaused(address indexed triggeredBy, uint256 timestamp);

    // ── 狀態變數 ──
    address public owner;
    address public pendingOwner;
    bool    public paused;
    uint256 public currentCycleId;
    uint256 public constant CYCLE_DURATION = 7 days;
    uint256 public constant MIN_DEPOSIT     = 100 * 1e6; // 100 USDT (6 位小數)
    uint256 public constant PERFORMANCE_FEE  = 300;        // 3% 數據服務費 (基點)

    struct Cycle {
        uint256 startTime;
        uint256 endTime;
        uint256 totalDeposits;
        uint256 totalDataRef;   // 本週期累計數據參考值
        bool    settled;
    }

    struct UserPosition {
        uint256 cycleId;
        uint256 principal;
        uint256 depositTime;
        bool    withdrawn;
    }

    mapping(uint256 => Cycle) public cycles;
    mapping(address => UserPosition[]) public userPositions;
    mapping(address => uint256) public userTotalDeposits;

    modifier onlyOwner() {
        require(msg.sender == owner, "DBP: not owner");
        _;
    }

    modifier whenNotPaused() {
        require(!paused, "DBP: paused");
        _;
    }

    // ── 初始化 ──
    constructor() {
        owner = msg.sender;
        currentCycleId = 1;
        cycles[1] = Cycle({
            startTime: block.timestamp,
            endTime:   block.timestamp + CYCLE_DURATION,
            totalDeposits: 0,
            totalDataRef:  0,
            settled: false
        });
    }

    // ── API接入 ──
    function deposit(uint256 amount) external whenNotPaused {
        require(amount >= MIN_DEPOSIT, "DBP: below min");
        require(cycles[currentCycleId].endTime > block.timestamp, "DBP: cycle ended");

        // 假設 USDT 轉帳由前端觸發,此處僅記錄邏輯
        // IERC20(usdt).transferFrom(msg.sender, address(this), amount);

        userPositions[msg.sender].push(UserPosition({
            cycleId:    currentCycleId,
            principal:  amount,
            depositTime: block.timestamp,
            withdrawn:   false
        }));

        userTotalDeposits[msg.sender] += amount;
        cycles[currentCycleId].totalDeposits += amount;

        emit Deposit(msg.sender, amount, currentCycleId, block.timestamp);
    }

    // ── API清算週期 ──
    function settleCycle() external onlyOwner {
        Cycle storage c = cycles[currentCycleId];
        require(block.timestamp >= c.endTime, "DBP: cycle active");
        require(!c.settled, "DBP: already settled");

        // 計算數據參考值(實際由鏈下預言機餵送,此處為模擬公式)
        uint256 dataRef = (c.totalDeposits * 7_400) / 100_000; // 數據參考值計算(歷史參考)
        c.totalDataRef = dataRef;
        c.settled = true;

        emit CycleClosed(currentCycleId, c.totalDeposits, block.timestamp);

        // 開啟新週期
        currentCycleId++;
        cycles[currentCycleId] = Cycle({
            startTime: block.timestamp,
            endTime:   block.timestamp + CYCLE_DURATION,
            totalDeposits: 0,
            totalDataRef:  0,
            settled: false
        });
    }

    // ── 提現(本金 + 代碼產生數據) ──
    function withdraw(uint256 positionIdx) external whenNotPaused {
        UserPosition storage pos = userPositions[msg.sender][positionIdx];
        require(!pos.withdrawn, "DBP: already withdrawn");

        Cycle storage c = cycles[pos.cycleId];
        require(c.settled, "DBP: cycle not settled");

        uint256 fee = (pos.principal * PERFORMANCE_FEE) / 10_000;
        uint256 payout = pos.principal + c.totalDataRef - fee;

        pos.withdrawn = true;
        userTotalDeposits[msg.sender] -= pos.principal;

        // IERC20(usdt).transfer(msg.sender, payout);
        emit Withdraw(msg.sender, pos.principal, c.totalDataRef, pos.cycleId);
    }

    // ── 緊急暫停 ──
    function emergencyPause() external onlyOwner {
        paused = true;
        emit EmergencyPaused(msg.sender, block.timestamp);
    }

    function emergencyUnpause() external onlyOwner {
        paused = false;
        emit EmergencyUnpaused(msg.sender, block.timestamp);
    }

    // ── 所有權轉移 ──
    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "DBP: zero address");
        pendingOwner = newOwner;
    }

    function acceptOwnership() external {
        require(msg.sender == pendingOwner, "DBP: not pending");
        owner = pendingOwner;
        pendingOwner = address(0);
    }

    // ── 視圖函數 ──
    function getUserPositions(address user) external view returns (UserPosition[] memory) {
        return userPositions[user];
    }

    function getCycleInfo(uint256 cycleId) external view returns (Cycle memory) {
        return cycles[cycleId];
    }

    receive() external payable { revert("DBP: no native coin"); }
}