Odyssey系统中的债券质押模型（STAKING BOND）核心合约源码

该合约实现了以下主要功能，具体如图片所示：

• 最小质押金额检查： 确保每次质押金额不低于100U。
• 管理费收取： 每次质押需支付1%的管理费，最高不超过10U。
• 多期限质押： 支持30至540天的不同质押期限。
• 复利收益计算： 每12小时自动计算复利收益。
• 出局机制检查： 用户领取的累计收益达到本金5倍时，需重新质押才能继续领取收益。
• 奖励释放选项： 提供立即、10天、20天或30天的奖励释放选项。
• 费用分配逻辑： 管理费和其他费用将按特定规则分配。

为了适应实际生产环境，还需实现以下功能：

• LP代币创建： 与去中心化交易所（DEX）交互，创建LP代币。
• 线性释放机制： 实现时间锁，确保奖励逐步释放。
• 社区奖励系统： 建立一套激励社区参与的奖励机制。
• 涡轮交易机制： 设计一种促进买卖平衡的交易机制。
• 完整的权限管理和安全审计： 确保合约的安全性和可靠性。

该合约是Odyssey系统的核心部分，可根据具体需求进一步扩展其他功能模块。

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

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

contract OdysseyStakingBond is ReentrancyGuard, Ownable {
    
    // 代币接口
    IERC20 public usdtToken;
    IERC20 public odyToken;
    address public lpToken;
    
    // 质押参数
    uint256 public constant MIN_STAKE_AMOUNT = 100 * 10**18; // 100U
    uint256 public constant MANAGEMENT_FEE_RATE = 100; // 1% (基础单位10000)
    uint256 public constant MAX_MANAGEMENT_FEE = 10 * 10**18; // 10U封顶
    
    // 质押期限和收益率配置
    struct StakingTier {
        uint256 duration; // 天数
        uint256 dailyYield; // 日收益率 (0.7% = 70)
        uint256 apy; // 年化收益率
        bool active;
    }
    
    mapping(uint256 => StakingTier) public stakingTiers;
    uint256[] public tierIds;
    
    // 用户质押信息
    struct UserStake {
        uint256 stakeId;
        address user;
        uint256 usdtAmount;
        uint256 odyAmount;
        uint256 lpAmount;
        uint256 tierId;
        uint256 startTime;
        uint256 endTime;
        uint256 totalReward;
        uint256 claimedReward;
        uint256 lastClaimTime;
        bool isActive;
    }
    
    mapping(address => UserStake[]) public userStakes;
    mapping(uint256 => address) public stakeOwner;
    uint256 public totalStakes;
    
    // 事件
    event Staked(address indexed user, uint256 stakeId, uint256 usdtAmount, uint256 tierId);
    event RewardClaimed(address indexed user, uint256 stakeId, uint256 rewardAmount);
    event Unstaked(address indexed user, uint256 stakeId, uint256 returnedAmount);
    
    constructor(address _usdt, address _ody, address _lp) {
        usdtToken = IERC20(_usdt);
        odyToken = IERC20(_ody);
        lpToken = _lp;
        
        // 初始化质押等级配置
        _initializeTiers();
    }
    
    function _initializeTiers() internal {
        // 对应图片中的5个期限
        stakingTiers[1] = StakingTier(30, 70, 118140, true);  // 0.7%, 1181.40%
        stakingTiers[2] = StakingTier(90, 80, 174336, true);  // 0.8%, 1743.36%
        stakingTiers[3] = StakingTier(180, 90, 255129, true); // 0.9%, 2551.29%
        stakingTiers[4] = StakingTier(360, 100, 371263, true); // 1.0%, 3712.63%
        stakingTiers[5] = StakingTier(540, 100, 371263, true); // 1.0%, 3712.63%
        
        tierIds = [1, 2, 3, 4, 5];
    }
    
    // 债券质押函数
    function stakeBond(uint256 usdtAmount, uint256 tierId) external nonReentrant {
        require(usdtAmount >= MIN_STAKE_AMOUNT, "Amount below minimum");
        require(stakingTiers[tierId].active, "Invalid tier");
        
        // 计算管理费 (1%，最高10U)
        uint256 managementFee = (usdtAmount * MANAGEMENT_FEE_RATE) / 10000;
        managementFee = managementFee > MAX_MANAGEMENT_FEE ? MAX_MANAGEMENT_FEE : managementFee;
        
        uint256 netAmount = usdtAmount - managementFee;
        
        // 转账USDT
        require(usdtToken.transferFrom(msg.sender, address(this), usdtAmount), "USDT transfer failed");
        
        // 分配50% USDT购买ODY，组成LP
        uint256 halfAmount = netAmount / 2;
        (uint256 odyAmount, uint256 lpAmount) = _createLPToken(halfAmount);
        
        // 创建质押记录
        uint256 stakeId = totalStakes++;
        StakingTier memory tier = stakingTiers[tierId];
        
        UserStake memory newStake = UserStake({
            stakeId: stakeId,
            user: msg.sender,
            usdtAmount: usdtAmount,
            odyAmount: odyAmount,
            lpAmount: lpAmount,
            tierId: tierId,
            startTime: block.timestamp,
            endTime: block.timestamp + (tier.duration * 1 days),
            totalReward: 0,
            claimedReward: 0,
            lastClaimTime: block.timestamp,
            isActive: true
        });
        
        userStakes[msg.sender].push(newStake);
        stakeOwner[stakeId] = msg.sender;
        
        // 分配管理费
        _distributeManagementFee(managementFee);
        
        emit Staked(msg.sender, stakeId, usdtAmount, tierId);
    }
    
    // 创建LP代币（简化版）
    function _createLPToken(uint256 usdtAmount) internal returns (uint256 odyAmount, uint256 lpAmount) {
        // 实际项目中这里会调用DEX路由创建LP
        // 此处为简化实现
        odyAmount = _calculateEquivalentODY(usdtAmount);
        
        // 模拟LP创建
        lpAmount = usdtAmount + odyAmount;
        
        // 将LP发送到永久锁仓地址
        // _permanentLock(lpAmount);
        
        return (odyAmount, lpAmount);
    }
    
    // 计算可领取收益
    function calculatePendingReward(uint256 stakeId) public view returns (uint256) {
        UserStake memory stake = _getStake(stakeId);
        require(stake.isActive, "Stake not active");
        
        if (block.timestamp <= stake.lastClaimTime) {
            return 0;
        }
        
        uint256 timePassed = block.timestamp - stake.lastClaimTime;
        uint256 periodsPassed = timePassed / (12 hours); // 每12小时复利
        
        StakingTier memory tier = stakingTiers[stake.tierId];
        uint256 pendingReward = 0;
        
        // 简化版复利计算
        uint256 principal = stake.usdtAmount;
        for (uint256 i = 0; i < periodsPassed; i++) {
            uint256 periodReward = (principal * tier.dailyYield / 2) / 10000; // 日收益的一半（12小时）
            pendingReward += periodReward;
            principal += periodReward; // 复利
        }
        
        return pendingReward;
    }
    
    // 领取收益
    function claimReward(uint256 stakeId, uint256 releaseOption) external nonReentrant {
        UserStake storage stake = _getStake(stakeId);
        require(stake.user == msg.sender, "Not stake owner");
        require(stake.isActive, "Stake not active");
        
        uint256 pendingReward = calculatePendingReward(stakeId);
        require(pendingReward > 0, "No reward to claim");
        
        // 检查出局机制（5倍限制）
        require(_checkExitCondition(stake, pendingReward), "Exit condition triggered");
        
        // 处理释放选项和燃烧机制
        uint256 netReward = _processReleaseOption(pendingReward, releaseOption);
        
        // 更新质押记录
        stake.claimedReward += pendingReward;
        stake.lastClaimTime = block.timestamp;
        
        // 转账奖励
        require(usdtToken.transfer(msg.sender, netReward), "Reward transfer failed");
        
        emit RewardClaimed(msg.sender, stakeId, netReward);
    }
    
    // 处理释放选项（立即、10天、20天、30天）
    function _processReleaseOption(uint256 reward, uint256 option) internal returns (uint256) {
        uint256 burnRate;
        
        if (option == 0) { // 立即释放
            burnRate = 1500; // 15%
        } else if (option == 1) { // 10天释放
            burnRate = 1000; // 10%
        } else if (option == 2) { // 20天释放
            burnRate = 500;  // 5%
        } else { // 30天释放
            burnRate = 0;    // 0%
        }
        
        uint256 burnAmount = (reward * burnRate) / 10000;
        uint256 netReward = reward - burnAmount;
        
        if (burnAmount > 0) {
            _distributeBurnedFee(burnAmount);
        }
        
        return netReward;
    }
    
    // 检查出局条件（5倍限制）
    function _checkExitCondition(UserStake memory stake, uint256 newReward) internal pure returns (bool) {
        uint256 totalClaimed = stake.claimedReward + newReward;
        uint256 exitThreshold = stake.usdtAmount * 5;
        
        return totalClaimed <= exitThreshold;
    }
    
    // 分配管理费
    function _distributeManagementFee(uint256 fee) internal {
        // 50%底池, 30%基金会, 10%奖励池, 10%创世节点
        // 简化实现：暂时发送到指定地址
        address foundation = 0x...; // 基金会地址
        address rewardPool = 0x...; // 奖励池地址
        address genesisNode = 0x...; // 创世节点地址
        
        usdtToken.transfer(foundation, fee * 3000 / 10000);
        usdtToken.transfer(rewardPool, fee * 1000 / 10000);
        usdtToken.transfer(genesisNode, fee * 1000 / 10000);
        // 剩余50%留在合约作为底池
    }
    
    // 分配燃烧费用
    function _distributeBurnedFee(uint256 burnedAmount) internal {
        // 40%底池, 30%基金会, 15%创世节点, 15%奖励池
        address foundation = 0x...;
        address rewardPool = 0x...;
        address genesisNode = 0x...;
        
        usdtToken.transfer(foundation, burnedAmount * 3000 / 10000);
        usdtToken.transfer(rewardPool, burnedAmount * 1500 / 10000);
        usdtToken.transfer(genesisNode, burnedAmount * 1500 / 10000);
        // 剩余40%留在合约
    }
    
    // 辅助函数
    function _getStake(uint256 stakeId) internal view returns (UserStake storage) {
        address owner = stakeOwner[stakeId];
        for (uint256 i = 0; i < userStakes[owner].length; i++) {
            if (userStakes[owner][i].stakeId == stakeId) {
                return userStakes[owner][i];
            }
        }
        revert("Stake not found");
    }
    
    function _calculateEquivalentODY(uint256 usdtAmount) internal view returns (uint256) {
        // 简化实现：实际需要从DEX获取价格
        return usdtAmount; // 1:1假设
    }
    
    // 获取用户所有质押
    function getUserStakes(address user) external view returns (UserStake[] memory) {
        return userStakes[user];
    }
    
    // 管理员函数：更新质押等级
    function updateStakingTier(uint256 tierId, uint256 dailyYield, uint256 apy, bool active) external onlyOwner {
        stakingTiers[tierId].dailyYield = dailyYield;
        stakingTiers[tierId].apy = apy;
        stakingTiers[tierId].active = active;
    }
}

一、经济飞轮的燃料：双轨质押系统

这一系统是整个项目的入口，负责吸收资金（USDT）并锁定代币（ODY）。

债券质押（Staking Bond）

作用： 为去中心化交易所（DEX）的流动性池（LP）提供深度。用户投入的USDT，50%用于购买ODY，50%与ODY组成LP对，并永久锁仓。这直接为ODY交易创造了坚实的底池，有效抵御价格暴跌。

特点： 高年化收益率（1181% - 3712%）、有锁定期、本金线性释放。虽然风险较高，但收益潜力巨大。

单币质押（Staking）

作用： 直接锁定ODY代币，减少市场流通量。提供活期和定期两种选择，以满足不同用户的需求。

特点： 收益率低于债券质押，但操作更为简便。本金的线性释放机制有助于避免到期时的大规模抛售。

二、经济飞轮的润滑与驱动：激励与分配机制

这部分机制负责将系统产生的收益和费用进行再分配，吸引更多人参与。

质押管理费（Management Fees）

作用： 系统的重要收入来源。任何质押行为都会产生1%的管理费，最高不超过10U。

分配： 费用将被分配到底池（维持稳定）、基金会（项目开发）、奖励池和创世节点，确保各方利益一致。

联盟社区奖励（Alliance Community Rewards）

作用： 采用类似传销的模式，旨在快速扩大用户基础。用户通过个人持仓、直接推荐和社区规模来提升等级（V1-V12），等级越高，享受的全局收益分成比例越高（5%-120%）。

效果： 强烈激励用户不仅自己投资，还要积极邀请新成员加入，构建庞大的社区网络。

奖励池机制（Reward Pool Mechanism）

作用： 将管理费、燃烧费和交易费汇集起来，进行二次分配，奖励对生态系统有贡献的用户。

分配：

• 社区榜（80%）： 奖励给社区网络最大的前101名用户，鼓励团队建设。
• 个人榜（20%）： 奖励给个人持仓最多的前20名用户，鼓励大额持仓。

三、经济飞轮的稳定器与刹车：循环与消耗机制

这些机制是项目的核心设计，旨在解决高收益项目面临的最大问题——抛压。它们强制要求收益进行再投资，而不是直接提现卖出。

奖励出局机制（Reward Exit Mechanism）

作用： 强制复投。当用户领取的累计收益达到其本金的5倍时，必须将收益重新投入质押，否则无法继续领取。

效果： 大幅减少短期抛压，将利润不断重新投入系统，形成内生循环。这是项目声称“长久性”的关键。

涡轮交易机制（Turbo Trading Mechanism）

作用： 人为制造买入需求并延缓卖出。用户若要卖出ODY，必须先买入等量的ODY并冷却12小时。

效果： 1）任何卖出行为都会先产生一个等量的买入订单，为币价提供支撑；2）12小时冷却期降低了冲动抛售的风险，并给市场反应时间；3）3%的交易手续费为系统持续“输血”。

奖励领取释放机制（Reward Collection Release）

作用： 用经济激励引导用户延迟兑现。用户领取收益时，如果选择更长的释放周期（10天、20天、30天），需要燃烧的手续费比例会降低（从15%降至0%）。

效果： 鼓励用户选择缓慢释放，而不是立即抛售，进一步平滑了卖压。燃烧掉的费用又回流到系统，实现通缩。

核心逻辑总结

Odyssey模式是一个通过精密规则设计来解决“庞氏悖论”的复杂系统。它不依赖新资金流入来支付老用户收益，而是通过以下机制实现：

• 锁定流动性： 债券质押锁定LP，单币质押锁定代币。
• 强制循环： 5倍出局机制强制复投。
• 制造买压： 涡轮交易机制要求先买后卖。
• 延迟与通缩： 释放机制和燃烧手续费。

自我强化的经济闭环。

其成功高度依赖于规则的严格实施和新用户的不断加入。对于用户来说，这是一场收益与风险并存的复杂金融游戏。