Angle Protocol

1// SPDX-License-Identifier: GPL-3.0
2
3pragma solidity ^0.8.7;
4
5import "./CoreEvents.sol";
6
7/// @title Core
8/// @author Angle Core Team
9/// @notice Keeps track of all the `StableMaster` contracts and facilitates governance by allowing the propagation
10/// of changes across most contracts of the protocol (does not include oracle contract, `RewardsDistributor`, and some
11/// other side contracts like `BondingCurve` or `CollateralSettler`)
12contract Core is CoreEvents, ICore {
13    /// @notice Map to track the addresses with a `GOVERNOR_ROLE` within Angle protocol
14    mapping(address => bool) public governorMap;
15
16    /// @notice Map to track the addresses of the `stableMaster` contracts that have already been deployed
17    /// This is used to avoid deploying a revoked `stableMaster` contract again and hence potentially creating
18    /// inconsistencies in the `GOVERNOR_ROLE` and `GUARDIAN_ROLE` of this `stableMaster`
19    mapping(address => bool) public deployedStableMasterMap;
20
21    /// @notice Address of the guardian, it can be revoked by Angle's governance
22    /// The protocol has only one guardian address
23    address public override guardian;
24
25    /// @notice List of the addresses of the `StableMaster` contracts accepted by the system
26    address[] internal _stablecoinList;
27
28    // List of all the governor addresses of Angle's protocol
29    // Initially only the timelock will be appointed governor but new addresses can be added along the way
30    address[] internal _governorList;
31
32    /// @notice Checks to see if the caller is a `governor`
33    /// The reason for having such modifiers rather than OpenZeppelin's Access Control logic is to make
34    /// sure that governors cannot bypass the `addGovernor` or `revokeGovernor` functions
35    modifier onlyGovernor() {
36        require(governorMap[msg.sender], "1");
37        _;
38    }
39
40    /// @notice Checks to see if the caller is a `guardian` or a `governor`
41    /// Same here, we do not use OpenZeppelin's Access Control logic to make sure that the `guardian`
42    /// cannot bypass the functions defined on purpose in this contract
43    modifier onlyGuardian() {
44        require(governorMap[msg.sender] || msg.sender == guardian, "1");
45        _;
46    }
47
48    /// @notice Checks if the new address given is not null
49    /// @param newAddress Address to check
50    modifier zeroCheck(address newAddress) {
51        require(newAddress != address(0), "0");
52        _;
53    }
54
55    // =============================== CONSTRUCTOR =================================
56
57    /// @notice Initializes the `Core` contract
58    /// @param _governor Address of the governor
59    /// @param _guardian Address of the guardian
60    constructor(address _governor, address _guardian) {
61        // Creating references
62        require(_guardian != address(0) && _governor != address(0), "0");
63        require(_guardian != _governor, "39");
64        _governorList.push(_governor);
65        guardian = _guardian;
66        governorMap[_governor] = true;
67
68        emit GovernorRoleGranted(_governor);
69        emit GuardianRoleChanged(address(0), _guardian);
70    }
71
72    // ========================= GOVERNOR FUNCTIONS ================================
73
74    // ======================== Interactions with `StableMasters` ==================
75
76    /// @notice Changes the `Core` contract of the protocol
77    /// @param newCore Address of the new `Core` contract
78    /// @dev To maintain consistency, checks are performed. The governance of the new `Core`
79    /// contract should be exactly the same as this one, and the `_stablecoinList` should be
80    /// identical
81    function setCore(ICore newCore) external onlyGovernor zeroCheck(address(newCore)) {
82        require(address(this) != address(newCore), "40");
83        require(guardian == newCore.guardian(), "41");
84        // The length of the lists are stored as cache variables to avoid duplicate reads in storage
85        // Checking the consistency of the `_governorList` and of the `_stablecoinList`
86        uint256 governorListLength = _governorList.length;
87        address[] memory _newCoreGovernorList = newCore.governorList();
88        uint256 stablecoinListLength = _stablecoinList.length;
89        address[] memory _newStablecoinList = newCore.stablecoinList();
90        require(
91            governorListLength == _newCoreGovernorList.length && stablecoinListLength == _newStablecoinList.length,
92            "42"
93        );
94        uint256 indexMet;
95        for (uint256 i = 0; i < governorListLength; i++) {
96            if (!governorMap[_newCoreGovernorList[i]]) {
97                indexMet = 1;
98                break;
99            }
100        }
101        for (uint256 i = 0; i < stablecoinListLength; i++) {
102            // The stablecoin lists should preserve exactly the same order of elements
103            if (_stablecoinList[i] != _newStablecoinList[i]) {
104                indexMet = 1;
105                break;
106            }
107        }
108        // Only performing one require, hence making it cheaper for a governance with a correct initialization
109        require(indexMet == 0, "43");
110        // Propagates the change
111        for (uint256 i = 0; i < stablecoinListLength; i++) {
112            IStableMaster(_stablecoinList[i]).setCore(address(newCore));
113        }
114        emit CoreChanged(address(newCore));
115    }
116
117    /// @notice Adds a new stablecoin to the system
118    /// @param agToken Address of the new `AgToken` contract
119    /// @dev To maintain consistency, the address of the `StableMaster` contract corresponding to the
120    /// `AgToken` is automatically retrieved
121    /// @dev The `StableMaster` receives the reference to the governor and guardian addresses of the protocol
122    /// @dev The `AgToken` and `StableMaster` contracts should have previously been initialized with correct references
123    /// in it, with for the `StableMaster` a reference to the `Core` contract and for the `AgToken` a reference to the
124    /// `StableMaster`
125    function deployStableMaster(address agToken) external onlyGovernor zeroCheck(agToken) {
126        address stableMaster = IAgToken(agToken).stableMaster();
127        // Checking if `stableMaster` has not already been deployed
128        require(!deployedStableMasterMap[stableMaster], "44");
129
130        // Storing and initializing information about the stablecoin
131        _stablecoinList.push(stableMaster);
132        // Adding this `stableMaster` in the `deployedStableMasterMap`: it is not going to be possible
133        // to revoke and then redeploy this contract
134        deployedStableMasterMap[stableMaster] = true;
135
136        IStableMaster(stableMaster).deploy(_governorList, guardian, agToken);
137
138        emit StableMasterDeployed(address(stableMaster), agToken);
139    }
140
141    /// @notice Revokes a `StableMaster` contract
142    /// @param stableMaster Address of  the `StableMaster` to revoke
143    /// @dev This function just removes a `StableMaster` contract from the `_stablecoinList`
144    /// @dev The consequence is that the `StableMaster` contract will no longer be affected by changes in
145    /// governor or guardian occuring from the protocol
146    /// @dev This function is mostly here to clean the mappings and save some storage space
147    function revokeStableMaster(address stableMaster) external override onlyGovernor {
148        uint256 stablecoinListLength = _stablecoinList.length;
149        // Checking if `stableMaster` is correct and removing the stablecoin from the `_stablecoinList`
150        require(stablecoinListLength >= 1, "45");
151        uint256 indexMet;
152        for (uint256 i = 0; i < stablecoinListLength - 1; i++) {
153            if (_stablecoinList[i] == stableMaster) {
154                indexMet = 1;
155                _stablecoinList[i] = _stablecoinList[stablecoinListLength - 1];
156                break;
157            }
158        }
159        require(indexMet == 1 || _stablecoinList[stablecoinListLength - 1] == stableMaster, "45");
160        _stablecoinList.pop();
161        // Deleting the stablecoin from the list
162        emit StableMasterRevoked(stableMaster);
163    }
164
165    // =============================== Access Control ==============================
166    // The following functions do not propagate the changes they induce to some bricks of the protocol
167    // like the `CollateralSettler`, the `BondingCurve`, the staking and rewards distribution contracts
168    // and the oracle contracts using Uniswap. Governance should be wary when calling these functions and
169    // make equivalent changes in these contracts to maintain consistency at the scale of the protocol
170
171    /// @notice Adds a new governor address
172    /// @param _governor New governor address
173    /// @dev This function propagates the new governor role across most contracts of the protocol
174    /// @dev Governor is also guardian everywhere in all contracts
175    function addGovernor(address _governor) external override onlyGovernor zeroCheck(_governor) {
176        require(!governorMap[_governor], "46");
177        governorMap[_governor] = true;
178        _governorList.push(_governor);
179        // Propagates the changes to maintain consistency across all the contracts that are attached to this
180        // `Core` contract
181        for (uint256 i = 0; i < _stablecoinList.length; i++) {
182            // Since a zero address check has already been performed in this contract, there is no need
183            // to repeat this check in underlying contracts
184            IStableMaster(_stablecoinList[i]).addGovernor(_governor);
185        }
186
187        emit GovernorRoleGranted(_governor);
188    }
189
190    /// @notice Removes a governor address
191    /// @param _governor Governor address to remove
192    /// @dev There must always be one governor in the protocol
193    function removeGovernor(address _governor) external override onlyGovernor {
194        // Checking if removing the governor will leave with at least more than one governor
195        uint256 governorListLength = _governorList.length;
196        require(governorListLength > 1, "47");
197        // Removing the governor from the list of governors
198        // We still need to check if the address provided was well in the list
199        uint256 indexMet;
200        for (uint256 i = 0; i < governorListLength - 1; i++) {
201            if (_governorList[i] == _governor) {
202                indexMet = 1;
203                _governorList[i] = _governorList[governorListLength - 1];
204                break;
205            }
206        }
207        require(indexMet == 1 || _governorList[governorListLength - 1] == _governor, "48");
208        _governorList.pop();
209        // Once it has been checked that the given address was a correct address, we can proceed to other changes
210        delete governorMap[_governor];
211        // Maintaining consistency across all contracts
212        for (uint256 i = 0; i < _stablecoinList.length; i++) {
213            // We have checked in this contract that the mentionned `_governor` here was well a governor
214            // There is no need to check this in the underlying contracts where this is going to be updated
215            IStableMaster(_stablecoinList[i]).removeGovernor(_governor);
216        }
217
218        emit GovernorRoleRevoked(_governor);
219    }
220
221    // ============================== GUARDIAN FUNCTIONS ===========================
222
223    /// @notice Changes the guardian address
224    /// @param _newGuardian New guardian address
225    /// @dev Guardian is able to change by itself the address corresponding to its role
226    /// @dev There can only be one guardian address in the protocol
227    /// @dev The guardian address cannot be a governor address
228    function setGuardian(address _newGuardian) external override onlyGuardian zeroCheck(_newGuardian) {
229        require(!governorMap[_newGuardian], "39");
230        require(guardian != _newGuardian, "49");
231        address oldGuardian = guardian;
232        guardian = _newGuardian;
233        for (uint256 i = 0; i < _stablecoinList.length; i++) {
234            IStableMaster(_stablecoinList[i]).setGuardian(_newGuardian, oldGuardian);
235        }
236        emit GuardianRoleChanged(oldGuardian, _newGuardian);
237    }
238
239    /// @notice Revokes the guardian address
240    /// @dev Guardian is able to auto-revoke itself
241    /// @dev There can only be one `guardian` address in the protocol
242    function revokeGuardian() external override onlyGuardian {
243        address oldGuardian = guardian;
244        guardian = address(0);
245        for (uint256 i = 0; i < _stablecoinList.length; i++) {
246            IStableMaster(_stablecoinList[i]).revokeGuardian(oldGuardian);
247        }
248        emit GuardianRoleChanged(oldGuardian, address(0));
249    }
250
251    // ========================= VIEW FUNCTIONS ====================================
252
253    /// @notice Returns the list of all the governor addresses of the protocol
254    /// @return `_governorList`
255    /// @dev This getter is used by `StableMaster` contracts deploying new collateral types
256    /// and initializing them with correct references
257    function governorList() external view override returns (address[] memory) {
258        return _governorList;
259    }
260
261    /// @notice Returns the list of all the `StableMaster` addresses of the protocol
262    /// @return `_stablecoinList`
263    /// @dev This getter is used by the `Core` contract when setting a new `Core`
264    function stablecoinList() external view override returns (address[] memory) {
265        return _stablecoinList;
266    }
267}

JavaScript Tests