ApolloX

1pragma solidity ^0.5.16;
2
3import "./Ownable.sol";
4import "./ApolloxSafeMath.sol";
5import "./IERC20.sol";
6import "./SafeERC20.sol";
7import "./ECDSA.sol";
8
9pragma experimental ABIEncoderV2;
10
11contract ApolloxExchangeTreasury is Ownable {
12    using ApolloxSafeMath for uint;
13    using SafeERC20 for IERC20;
14
15    event ReceiveEther(uint amount);
16    event Claimed(uint256 indexed id, address indexed to, bool isETH, address currency, uint256 amount, uint256 deadline);
17    event TransferToCounterParty(bool isETH, address currency, uint256 amount);
18    event Paused();
19    event Unpaused();
20    event NewTruthHolder(address oldTruthHolder, address newTruthHolder);
21    event NewOperator(address oldOperator, address newOperator);
22    event NewCounterParty(address oldCounterParty, address newCounterParty);
23    event AddCurrency(address indexed currency);
24    event RemoveCurrency(address indexed currency);
25
26    bool public paused;
27    address public truthHolder;
28    address public operator;
29    address payable public counterParty;
30    mapping(address => bool) public supportCurrency;
31    mapping(uint => uint) public claimHistory;
32
33    modifier notPaused() {
34        require(!paused, "paused");
35        _;
36    }
37
38    modifier onlyOperator() {
39        require(msg.sender == operator, "only operator can call");
40        _;
41    }
42
43    constructor (address truthHolder_, address operator_, address payable counterParty_) public {
44        paused = false;
45        truthHolder = truthHolder_;
46        operator = operator_;
47        counterParty = counterParty_;
48    }
49
50    function() external payable {
51        if (msg.value > 0) {
52            emit ReceiveEther(msg.value);
53        }
54    }
55
56    function _transfer(address payable to, bool isETH, address currency, uint amount) internal {
57        if(isETH) {
58            require(address(this).balance >= amount, "not enough ether balance");
59            require(to.send(amount), "ether transfer failed");
60        } else {
61            IERC20 token = IERC20(currency);
62            uint balance = token.balanceOf(address(this));
63            require(balance >= amount, "not enough currency balance");
64            token.safeTransfer(to, amount);
65        }
66    }
67
68    function transferToCounterParty(bool isETH, address currency, uint amount) external onlyOperator {
69        _transfer(counterParty, isETH, currency, amount);
70        emit TransferToCounterParty(isETH, currency, amount);
71    }
72
73    function claim(bytes calldata message, bytes calldata signature) external notPaused {
74        address source = source(message, signature);
75        require(source == truthHolder, "only accept truthHolder signed message");
76
77        (uint256 id, address payable to, bool isETH, address currency, uint256 amount, uint256 deadline) = abi.decode(message, (uint256, address, bool, address, uint256, uint256));
78        require(claimHistory[id] == 0, "already claimed");
79        require(isETH || supportCurrency[currency], "currency not support");
80        require(block.timestamp < deadline, "already passed deadline");
81
82        claimHistory[id] = block.number;
83        _transfer(to, isETH, currency, amount);
84        emit Claimed(id, to, isETH, currency, amount, deadline);
85    }
86
87    function source(bytes memory message, bytes memory signature) public pure returns (address) {
88        bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", keccak256(message)));
89        return ECDSA.recover(hash, signature);
90    }
91
92    function _pause() external onlyOwner {
93        paused = true;
94        emit Paused();
95    }
96
97    function _unpause() external onlyOwner {
98        paused = false;
99        emit Unpaused();
100    }
101
102    function _changeTruthHolder(address newTruthHolder) external onlyOwner {
103        address oldHolder = truthHolder;
104        truthHolder = newTruthHolder;
105        emit NewTruthHolder(oldHolder, newTruthHolder);
106    }
107
108    function _setOperator(address newOperator) external onlyOwner {
109        address oldOperator = operator;
110        operator = newOperator;
111        emit NewOperator(oldOperator, newOperator);
112    }
113
114    function _setCounterParty(address payable newCounterParty) external onlyOwner {
115        address payable oldCounterParty = counterParty;
116        counterParty = newCounterParty;
117        emit NewCounterParty(oldCounterParty, newCounterParty);
118    }
119
120    function _addCurrency(address currency) external onlyOwner {
121        supportCurrency[currency] = true;
122        emit AddCurrency(currency);
123    }
124
125    function _removeCurrency(address currency) external onlyOwner {
126        delete supportCurrency[currency];
127        emit RemoveCurrency(currency);
128    }
129