Origin

1// SPDX-License-Identifier: agpl-3.0
2pragma solidity ^0.8.0;
3
4/**
5 * @title OUSD Timelock Contract
6 * @author Origin Protocol Inc
7 */
8import "@openzeppelin/contracts/utils/math/SafeMath.sol";
9
10interface CapitalPausable {
11    function pauseCapital() external;
12
13    function unpauseCapital() external;
14}
15
16contract Timelock {
17    using SafeMath for uint256;
18
19    event NewAdmin(address indexed newAdmin);
20    event NewPendingAdmin(address indexed newPendingAdmin);
21    event NewDelay(uint256 indexed newDelay);
22    event CancelTransaction(
23        bytes32 indexed txHash,
24        address indexed target,
25        string signature,
26        bytes data,
27        uint256 eta
28    );
29    event ExecuteTransaction(
30        bytes32 indexed txHash,
31        address indexed target,
32        string signature,
33        bytes data,
34        uint256 eta
35    );
36    event QueueTransaction(
37        bytes32 indexed txHash,
38        address indexed target,
39        string signature,
40        bytes data,
41        uint256 eta
42    );
43
44    uint256 public constant GRACE_PERIOD = 3 days;
45    uint256 public constant MINIMUM_DELAY = 1 minutes;
46    uint256 public constant MAXIMUM_DELAY = 2 days;
47
48    address public admin;
49    address public pendingAdmin;
50    uint256 public delay;
51
52    mapping(bytes32 => bool) public queuedTransactions;
53
54    /**
55     * @dev Throws if called by any account other than the Admin.
56     */
57    modifier onlyAdmin() {
58        require(msg.sender == admin, "Caller is not the admin");
59        _;
60    }
61
62    constructor(address admin_, uint256 delay_) {
63        require(
64            delay_ >= MINIMUM_DELAY,
65            "Timelock::constructor: Delay must exceed minimum delay."
66        );
67        require(
68            delay_ <= MAXIMUM_DELAY,
69            "Timelock::setDelay: Delay must not exceed maximum delay."
70        );
71
72        admin = admin_;
73        delay = delay_;
74    }
75
76    function setDelay(uint256 delay_) public {
77        require(
78            msg.sender == address(this),
79            "Timelock::setDelay: Call must come from Timelock."
80        );
81        require(
82            delay_ >= MINIMUM_DELAY,
83            "Timelock::setDelay: Delay must exceed minimum delay."
84        );
85        require(
86            delay_ <= MAXIMUM_DELAY,
87            "Timelock::setDelay: Delay must not exceed maximum delay."
88        );
89        delay = delay_;
90
91        emit NewDelay(delay);
92    }
93
94    function acceptAdmin() public {
95        require(
96            msg.sender == pendingAdmin,
97            "Timelock::acceptAdmin: Call must come from pendingAdmin."
98        );
99        admin = msg.sender;
100        pendingAdmin = address(0);
101
102        emit NewAdmin(admin);
103    }
104
105    function setPendingAdmin(address pendingAdmin_) public onlyAdmin {
106        pendingAdmin = pendingAdmin_;
107
108        emit NewPendingAdmin(pendingAdmin);
109    }
110
111    function queueTransaction(
112        address target,
113        string memory signature,
114        bytes memory data,
115        uint256 eta
116    ) internal returns (bytes32) {
117        require(
118            msg.sender == admin,
119            "Timelock::queueTransaction: Call must come from admin."
120        );
121        require(
122            eta >= getBlockTimestamp().add(delay),
123            "Timelock::queueTransaction: Estimated execution block must satisfy delay."
124        );
125
126        bytes32 txHash = keccak256(
127            abi.encode(target, signature, keccak256(data), eta)
128        );
129        queuedTransactions[txHash] = true;
130
131        emit QueueTransaction(txHash, target, signature, data, eta);
132        return txHash;
133    }
134
135    function cancelTransaction(
136        address target,
137        string memory signature,
138        bytes memory data,
139        uint256 eta
140    ) internal {
141        require(
142            msg.sender == admin,
143            "Timelock::cancelTransaction: Call must come from admin."
144        );
145
146        bytes32 txHash = keccak256(
147            abi.encode(target, signature, keccak256(data), eta)
148        );
149        queuedTransactions[txHash] = false;
150
151        emit CancelTransaction(txHash, target, signature, data, eta);
152    }
153
154    function _getRevertMsg(bytes memory _returnData)
155        internal
156        pure
157        returns (string memory)
158    {
159        // If the _res length is less than 68, then the transaction failed
160        // silently (without a revert message)
161        if (_returnData.length < 68) return "Transaction reverted silently";
162
163        assembly {
164            // Slice the sighash.
165            _returnData := add(_returnData, 0x04)
166        }
167        return abi.decode(_returnData, (string));
168    }
169
170    function executeTransaction(
171        address target,
172        string memory signature,
173        bytes memory data,
174        uint256 eta
175    ) internal returns (bytes memory) {
176        require(
177            msg.sender == admin,
178            "Timelock::executeTransaction: Call must come from admin."
179        );
180
181        bytes32 txHash = keccak256(
182            abi.encode(target, signature, keccak256(data), eta)
183        );
184        require(
185            queuedTransactions[txHash],
186            "Timelock::executeTransaction: Transaction hasn't been queued."
187        );
188        require(
189            getBlockTimestamp() >= eta,
190            "Timelock::executeTransaction: Transaction hasn't surpassed time lock."
191        );
192        require(
193            getBlockTimestamp() <= eta.add(GRACE_PERIOD),
194            "Timelock::executeTransaction: Transaction is stale."
195        );
196
197        queuedTransactions[txHash] = false;
198
199        bytes memory callData;
200
201        if (bytes(signature).length == 0) {
202            callData = data;
203        } else {
204            callData = abi.encodePacked(
205                bytes4(keccak256(bytes(signature))),
206                data
207            );
208        }
209
210        (bool success, bytes memory returnData) = target.call(callData);
211
212        if (!success) {
213            revert(_getRevertMsg(returnData));
214        }
215
216        emit ExecuteTransaction(txHash, target, signature, data, eta);
217
218        return returnData;
219    }
220
221    function getBlockTimestamp() internal view returns (uint256) {
222        // solium-disable-next-line security/no-block-members
223        return block.timestamp;
224    }
225
226    function pauseCapital(address target) external {
227        require(
228            msg.sender == admin,
229            "Timelock::pauseCapital: Call must come from admin."
230        );
231        CapitalPausable(target).pauseCapital();
232    }
233
234    function unpauseCapital(address target) external {
235        require(
236            msg.sender == admin,
237            "Timelock::unpauseCapital: Call must come from admin."
238        );
239        CapitalPausable(tar