dodomine v2

contracts/DODOToken/DODOMineV2/BaseMine.sol

@@ -0,0 +1,216 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+import {SafeERC20} from "../../lib/SafeERC20.sol";
+import {IERC20} from "../../intf/IERC20.sol";
+import {SafeMath} from "../../lib/SafeMath.sol";
+import {DecimalMath} from "../../lib/DecimalMath.sol";
+import {InitializableOwnable} from "../../lib/InitializableOwnable.sol";
+import {IRewardVault, RewardVault} from "./RewardVault.sol";
+
+
+contract BaseMine is InitializableOwnable {
+    using SafeERC20 for IERC20;
+    using SafeMath for uint256;
+
+    // ============ Storage ============
+    
+    struct RewardTokenInfo {
+        address rewardToken;
+        uint256 startBlock;
+        uint256 endBlock;
+        address rewardVault;
+        address rewardDistributor;
+
+        uint256 rewardPerBlock;
+        uint256 accRewardPerShare;
+        uint256 lastRewardBlock;
+
+        mapping(address => uint256) userRewardPerTokenPaid;
+        mapping(address => uint256) userRewards;
+    }
+
+    RewardTokenInfo[] public rewardTokenInfos;
+
+    uint256 internal _totalSupply;
+    mapping(address => uint256) internal _balances;
+
+    // ============ Event =============
+
+    event Claim(uint256 indexed i, address indexed user, uint256 reward);
+    event UpdateReward(uint256 indexed i, uint256 rewardPerBlock);
+    event UpdateEndBlock(uint256 indexed i, uint256 endBlock);
+    event RewardDistributorChanged(uint256 indexed i, address rewardDistributor);
+    event NewRewardToken(uint256 indexed i, address rewardToken);
+    event RemoveRewardToken(address rewardToken);
+
+    // ============ Modifier ==========
+
+    modifier onlyRewardDistributor(uint i) {
+        require(msg.sender == rewardTokenInfos[i].rewardDistributor, "DODOMineV2: ACCESS_RESTRICTED");
+        _;
+    }
+
+    modifier updateReward(address user) {
+        uint256 len = rewardTokenInfos.length;
+        for (uint i = 0; i < len; i++) {
+            RewardTokenInfo storage rt = rewardTokenInfos[i];
+            rt.accRewardPerShare = rewardPerLpToken(i);
+            rt.lastRewardBlock = lastBlockRewardApplicable(i);
+            if (user != address(0)) {
+                rt.userRewards[user] = getPendingReward(i, user);
+                rt.userRewardPerTokenPaid[user] = rt.accRewardPerShare;
+            }
+        }
+        _;
+    }
+
+    // ============ View  ============
+
+    function lastBlockRewardApplicable(uint i) public view returns (uint256) {
+        uint256 startBlock = rewardTokenInfos[i].startBlock;
+        uint256 endBlock = rewardTokenInfos[i].endBlock;
+        if(block.number < endBlock) {
+            if(block.number < startBlock) 
+                return startBlock;
+            else 
+                return block.number;
+        }else {
+            return endBlock;
+        }
+    }
+
+    function rewardPerLpToken(uint i) public view returns (uint256) {
+        RewardTokenInfo memory rt = rewardTokenInfos[i];
+        if (totalSupply() == 0) {
+            return rt.accRewardPerShare;
+        }
+        return rt.accRewardPerShare.add(
+            DecimalMath.divFloor(
+                lastBlockRewardApplicable(i).sub(rt.lastRewardBlock).mul(rt.rewardPerBlock), 
+                totalSupply()
+            )
+        );
+    }
+
+    function getPendingReward(uint i, address user) public view returns (uint256) {
+        RewardTokenInfo storage rt = rewardTokenInfos[i];
+        return DecimalMath.mulFloor(
+            balanceOf(user),
+            rewardPerLpToken(i).sub(rt.userRewardPerTokenPaid[user])
+        ).add(rt.userRewards[user]);
+    }
+
+    function totalSupply() public view returns (uint256) {
+        return _totalSupply;
+    }
+
+    function balanceOf(address user) public view returns (uint256) {
+        return _balances[user];
+    }
+
+    // ============ Claim ============
+
+    function getReward(uint i) public updateReward(msg.sender) {
+        RewardTokenInfo storage rt = rewardTokenInfos[i];
+        uint256 reward = rt.userRewards[msg.sender];
+        if (reward > 0) {
+            rt.userRewards[msg.sender] = 0;
+            IRewardVault(rt.rewardVault).reward(msg.sender, reward);
+            emit Claim(i, msg.sender, reward);
+        }
+    }
+
+    function getAllRewards() public {
+        uint256 len = rewardTokenInfos.length;
+        for (uint i = 0; i < len; i++) {
+            getReward(i);
+        }
+    }
+
+    // =============== Ownable  ================
+
+    function setRewardDistribution(uint i, address rewardDistributor) external onlyOwner {
+        RewardTokenInfo storage rt = rewardTokenInfos[i];
+        rt.rewardDistributor = rewardDistributor;
+        emit RewardDistributorChanged(i, rewardDistributor);
+    }
+
+    function addRewardToken(address rewardToken, address rewardDistributor,uint256 startBlock, uint256 endBlock) external onlyOwner {
+        require(rewardToken != address(0),"DODOMineV2: TOKEN_INVALID");
+        require(startBlock > block.number, "DODOMineV2: START_BLOCK_INVALID");
+        require(endBlock > startBlock ,"DODOMineV2: DURATION_INVALID");
+        require(rewardDistributor != address(0), "DODOMineV2: REWARD_DISTRIBUTOR_INVALID");
+
+        uint256 len = rewardTokenInfos.length;
+        for (uint i = 0; i < len; i++) {
+            require(rewardToken != rewardTokenInfos[i].rewardToken, "DODOMineV2: TOKEN_ALREADY_ADDED");
+        }
+
+        RewardTokenInfo storage rt = rewardTokenInfos.push();
+        rt.rewardToken = rewardToken;
+        rt.startBlock = startBlock;
+        rt.endBlock = endBlock;
+        rt.rewardDistributor = rewardDistributor;
+        rt.rewardVault = address(new RewardVault(rewardToken));
+
+        emit NewRewardToken(len, rewardToken);
+        emit RewardDistributorChanged(len, rewardDistributor);
+    }
+
+    function removeRewardToken(address rewardToken) external onlyOwner {
+        uint256 len = rewardTokenInfos.length;
+        for (uint256 i = 0; i < len; i++) {
+            if (rewardToken == rewardTokenInfos[i].rewardToken) {
+                rewardTokenInfos[i] = rewardTokenInfos[len - 1];
+                rewardTokenInfos.pop();
+                emit RemoveRewardToken(rewardToken);
+                break;
+            }
+        }
+    }
+
+    function setEndBlock(uint i, uint256 newEndBlock) external onlyRewardDistributor(i) updateReward(address(0)) {
+        require(block.number < newEndBlock, "DODOMineV2: END_BLOCK_INVALID");
+        RewardTokenInfo storage rt = rewardTokenInfos[i];
+        require(block.number > rt.startBlock, "DODOMineV2: NOT_START");
+        require(block.number < rt.endBlock, "DODOMineV2: ALREADY_CLOSE");
+        
+        //TODO: gas ？需要额外维护 已分发reward变量，总reward 两个storage
+        // uint256 vaultBalance = IERC20(rt.rewardToken).balanceOf(rt.rewardVault);
+        // uint256 preReward = DecimalMath.mulFloor(newEndBlock.sub(block.number), rt.rewardPerBlock);
+        // require(preReward <= vaultBalance, "DODOMineV2: REWARD_NOT_ENOUGH");
+        
+        rt.endBlock = newEndBlock;
+        rt.lastRewardBlock = block.number;
+        
+        emit UpdateEndBlock(i, newEndBlock);
+    }
+
+    function setReward(uint i, uint256 newRewardPerBlock) external onlyRewardDistributor(i) updateReward(address(0)) {
+        RewardTokenInfo storage rt = rewardTokenInfos[i];
+        uint256 endBlock = rt.endBlock;
+
+        require(block.number < endBlock, "DODOMineV2: ALREADY_FINISHED");
+
+        //TODO: 
+        // uint256 vaultBalance = IERC20(rt.rewardToken).balanceOf(rt.rewardVault);
+        // uint256 startBlock = rt.startBlock;
+        // uint256 preReward;
+        // if(startBlock > block.number) {
+        //     preReward = DecimalMath.mulFloor(endBlock.sub(startBlock), newRewardPerBlock);
+        // }else {
+        //     preReward = DecimalMath.mulFloor(endBlock.sub(block.number), newRewardPerBlock);
+        // }
+        // require(preReward <= vaultBalance, "DODOMineV2: REWARD_NOT_ENOUGH");
+        
+        rt.rewardPerBlock = newRewardPerBlock;
+        emit UpdateReward(i, newRewardPerBlock);
+    }
+}

contracts/DODOToken/DODOMineV2/LpMine.sol

@@ -0,0 +1,67 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+import {SafeERC20} from "../../lib/SafeERC20.sol";
+import {IERC20} from "../../intf/IERC20.sol";
+import {SafeMath} from "../../lib/SafeMath.sol";
+import {IDODOApproveProxy} from "../../intf/IDODOApproveProxy.sol";
+import {BaseMine} from "./BaseMine.sol";
+
+
+contract LpMine is BaseMine {
+    using SafeERC20 for IERC20;
+    using SafeMath for uint256;
+
+    // ============ Storage ============
+    
+    address public immutable _LP_TOKEN_;
+    address public immutable _DODO_APPROVE_PROXY_;
+
+    constructor(address lpToken, address dodoApproveProxy) public {
+        _LP_TOKEN_ = lpToken;
+        _DODO_APPROVE_PROXY_ = dodoApproveProxy;
+    }
+
+    // ============ Event  ============
+    event Deposit(address indexed user, uint256 amount);
+    event Withdraw(address indexed user, uint256 amount);
+
+
+    // ============ Deposit && Withdraw && Exit ============
+
+    function deposit(uint256 amount) virtual public updateReward(msg.sender) {
+        require(amount > 0, "DODOMineV2: CANNOT_DEPOSIT_ZERO");
+        _totalSupply = _totalSupply.add(amount);
+        _balances[msg.sender] = _balances[msg.sender].add(amount);
+        IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(
+            _LP_TOKEN_,
+            msg.sender,
+            address(this),
+            amount
+        );
+        emit Deposit(msg.sender, amount);
+    }
+
+    function withdraw(uint256 amount) virtual public updateReward(msg.sender) {
+        require(amount > 0, "DODOMineV2: CANNOT_WITHDRAW_ZERO");
+        _totalSupply = _totalSupply.sub(amount);
+        _balances[msg.sender] = _balances[msg.sender].sub(amount);
+        IERC20(_LP_TOKEN_).safeTransfer(msg.sender, amount);
+        emit Withdraw(msg.sender, amount);
+    }
+
+    function withdrawAll() external {
+        withdraw(balanceOf(msg.sender));
+    }
+
+    function exit() external {
+        withdraw(balanceOf(msg.sender));
+        getAllRewards();
+    }
+}

contracts/DODOToken/DODOMineV2/RewardVault.sol

@@ -0,0 +1,31 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+
+import {Ownable} from "../../lib/Ownable.sol";
+import {SafeERC20} from "../../lib/SafeERC20.sol";
+import {IERC20} from "../../intf/IERC20.sol";
+
+
+interface IRewardVault {
+    function reward(address to, uint256 amount) external;
+}
+
+contract RewardVault is Ownable {
+    using SafeERC20 for IERC20;
+
+    address public rewardToken;
+
+    constructor(address _rewardToken) public {
+        rewardToken = _rewardToken;
+    }
+
+    function reward(address to, uint256 amount) external onlyOwner {
+        IERC20(rewardToken).safeTransfer(to, amount);
+    }
+}

contracts/DODOToken/DODOMineV2/vDODOMine.sol

@@ -0,0 +1,59 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+
+import {SafeERC20} from "../../lib/SafeERC20.sol";
+import {IERC20} from "../../intf/IERC20.sol";
+import {SafeMath} from "../../lib/SafeMath.sol";
+import {BaseMine} from "./BaseMine.sol";
+
+interface IVDODOToken {
+    function availableBalanceOf(address account) external view returns (uint256);
+}
+
+contract vDODOMine is BaseMine {
+    using SafeERC20 for IERC20;
+    using SafeMath for uint256;
+
+    // ============ Storage ============
+    address public immutable _vDODO_TOKEN_;
+
+    constructor(address vDODOToken) public {
+        _vDODO_TOKEN_ = vDODOToken;
+    }
+
+    // ============ Event =============
+
+    event Deposit(address indexed user, uint256 amount);
+    event Withdraw(address indexed user, uint256 amount);
+
+
+    function deposit(uint256 amount) public {
+        require(amount > 0, "vDODOMineETH: CANNOT_DEPOSIT_ZERO");
+        require(IVDODOToken(_vDODO_TOKEN_).availableBalanceOf(msg.sender) >= amount, "vDODOMineETH: vDODO_NOT_ENOUGH");
+        _totalSupply = _totalSupply.add(amount);
+        _balances[msg.sender] = _balances[msg.sender].add(amount);
+        emit Deposit(msg.sender, amount);
+    }
+
+    function withdraw(uint256 amount) public {
+        require(amount > 0, "DODOMineV2: CANNOT_WITHDRAW_ZERO");
+        _totalSupply = _totalSupply.sub(amount);
+        _balances[msg.sender] = _balances[msg.sender].sub(amount);
+        emit Withdraw(msg.sender, amount);
+    }
+
+    function withdrawAll() external {
+        withdraw(balanceOf(msg.sender));
+    }
+
+    function exit() external {
+        withdraw(balanceOf(msg.sender));
+        getAllRewards();
+    }
+}

contracts/DODOToken/Governance.sol

@@ -5,14 +5,53 @@
 
 */
 pragma solidity 0.6.9;
-pragma experimental ABIEncoderV2;
 
 import {InitializableOwnable} from "../lib/InitializableOwnable.sol";
+import {SafeMath} from "../lib/SafeMath.sol";
+
+interface IVDODOMine {
+    function balanceOf(address account) external view returns (uint256);
+}
 
-//todo
 contract Governance is InitializableOwnable {
+    using SafeMath for uint256;
 
-    function getLockedvDODO(address account) external pure returns (uint256 lockedvDODO) {
+    // ============ Storage ============
-        lockedvDODO = 0;//todo for test
+    address[] public _VDODO_MINE_LIST_;
+
+
+    // ============ Event =============
+    event AddMineContract(address mineContract);
+    event RemoveMineContract(address mineContract);
+
+
+    function getLockedvDODO(address account) external view returns (uint256 lockedvDODO) {
+        uint256 len = _VDODO_MINE_LIST_.length;
+        for(uint i = 0; i < len; i++){
+            uint256 curLocked = IVDODOMine(_VDODO_MINE_LIST_[i]).balanceOf(account);
+            lockedvDODO = lockedvDODO.add(curLocked);
+        }
+    }
+
+    // =============== Ownable  ================
+
+    function addMineContract(address[] memory mineContracts) external onlyOwner {
+        for(uint i = 0; i < mineContracts.length; i++){
+            require(mineContracts[i] != address(0),"ADDRESS_INVALID");
+            _VDODO_MINE_LIST_.push(mineContracts[i]);
+            emit AddMineContract(mineContracts[i]);
+        }
+    }
+
+    function removeMineContract(address mineContract) external onlyOwner {
+        uint256 len = _VDODO_MINE_LIST_.length;
+        for (uint256 i = 0; i < len; i++) {
+            if (mineContract == _VDODO_MINE_LIST_[i]) {
+                _VDODO_MINE_LIST_[i] = _VDODO_MINE_LIST_[len - 1];
+                _VDODO_MINE_LIST_.pop();
+                emit RemoveMineContract(mineContract);
+                break;
+            }
+        }
     }
 }

contracts/DODOToken/LockedTokenVault.sol

@@ -25,7 +25,7 @@ contract LockedTokenVault is Ownable {
     using SafeMath for uint256;
     using SafeERC20 for IERC20;
 
-    address _TOKEN_;
+    address public immutable _TOKEN_;
 
     mapping(address => uint256) internal originBalances;
     mapping(address => uint256) internal claimedBalances;

contracts/intf/IDODOApproveProxy.sol

@@ -0,0 +1,13 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+
+interface IDODOApproveProxy {
+    function isAllowedProxy(address _proxy) external view returns (bool);
+    function claimTokens(address token,address who,address dest,uint256 amount) external;
+}

deploy-detail-periphery.txt

@@ -197,7 +197,8 @@ network type: kovan
 Deploy time: 2021/3/10 下午11:27:00
 Deploy type: UpCrowdPoolingFactory
 UpCrowdPoolingFactory address:  0xe1C4300B47ccE8B162D8d036Db356c563a904757
-Init UpCpFactory Tx: 0x97ad372abbb2321e24e3e388585d47f0b1120980566abc3268c8305b04dc61f7====================================================
+Init UpCpFactory Tx: 0x97ad372abbb2321e24e3e388585d47f0b1120980566abc3268c8305b04dc61f7
+====================================================
 network type: bsclive
 Deploy time: 2021/3/13 下午11:36:30
 Deploy type: UpCrowdPoolingFactory

migrations/4_deploy_periphery.js

@@ -16,6 +16,7 @@ const DODOToken = artifacts.require("DODOToken");
 const UpCrowdPoolingFactory = artifacts.require("UpCrowdPoolingFactory");
 const CpFactory = artifacts.require("CrowdPoolingFactory");
 const MultiCall = artifacts.require("Multicall");
+const LockedTokenVault = artifacts.require("LockedTokenVault");
 
 module.exports = async (deployer, network, accounts) => {
     let CONFIG = GetConfig(network, accounts)
@@ -39,6 +40,22 @@ module.exports = async (deployer, network, accounts) => {
     let multiSigAddress = CONFIG.multiSigAddress;
     let defaultMaintainer = CONFIG.defaultMaintainer;
 
+    if(deploySwitch.LockedVault) {
+        logger.log("====================================================");
+        logger.log("network type: " + network);
+        logger.log("Deploy time: " + new Date().toLocaleString());
+        logger.log("Deploy type: LockedVault");
+        await deployer.deploy(
+            LockedTokenVault,
+            "0xd8C30a4E866B188F16aD266dC3333BD47F34ebaE",
+            1616468400,
+            2592000,
+            "100000000000000000"
+        );
+        logger.log("LockedVault address: ", LockedTokenVault.address);
+        //TODO: approve && deposit
+    }
+    
     if (deploySwitch.UpCP) {
         logger.log("====================================================");
         logger.log("network type: " + network);

truffle-config.js

@@ -54,7 +54,8 @@ module.exports = {
     DVM:            false,
     CP:             false,
     CPFactory:      false,
-    MultiCall:      false
+    MultiCall:      false,
+    LockedVault:    false
   },
 
   networks: {