Alpha Homora V2

1pragma solidity 0.6.12;
2​
3import 'OpenZeppelin/openzeppelin-contracts@3.4.0/contracts/token/ERC20/IERC20.sol';
4import 'OpenZeppelin/openzeppelin-contracts@3.4.0/contracts/token/ERC20/SafeERC20.sol';
5import 'OpenZeppelin/openzeppelin-contracts@3.4.0/contracts/token/ERC1155/IERC1155.sol';
6import 'OpenZeppelin/openzeppelin-contracts@3.4.0/contracts/math/SafeMath.sol';
7import 'OpenZeppelin/openzeppelin-contracts@3.4.0/contracts/math/Math.sol';
8​
9import './Governable.sol';
10import './utils/ERC1155NaiveReceiver.sol';
11import '../interfaces/IBank.sol';
12import '../interfaces/ICErc20.sol';
13import '../interfaces/IOracle.sol';
14​
15library HomoraSafeMath {
16  using SafeMath for uint;
17​
18  /// @dev Computes round-up division.
19  function ceilDiv(uint a, uint b) internal pure returns (uint) {
20    return a.add(b).sub(1).div(b);
21  }
22}
23​
24contract HomoraCaster {
25  /// @dev Call to the target using the given data.
26  /// @param target The address target to call.
27  /// @param data The data used in the call.
28  function cast(address target, bytes calldata data) external payable {
29    (bool ok, bytes memory returndata) = target.call{value: msg.value}(data);
30    if (!ok) {
31      if (returndata.length > 0) {
32        // The easiest way to bubble the revert reason is using memory via assembly
33        // solhint-disable-next-line no-inline-assembly
34        assembly {
35          let returndata_size := mload(returndata)
36          revert(add(32, returndata), returndata_size)
37        }
38      } else {
39        revert('bad cast call');
40      }
41    }
42  }
43}
44​
45contract HomoraBank is Governable, ERC1155NaiveReceiver, IBank {
46  using SafeMath for uint;
47  using HomoraSafeMath for uint;
48  using SafeERC20 for IERC20;
49​
50  uint private constant _NOT_ENTERED = 1;
51  uint private constant _ENTERED = 2;
52  uint private constant _NO_ID = uint(-1);
53  address private constant _NO_ADDRESS = address(1);
54​
55  struct Bank {
56    bool isListed; // Whether this market exists.
57    uint8 index; // Reverse look up index for this bank.
58    address cToken; // The CToken to draw liquidity from.
59    uint reserve; // The reserve portion allocated to Homora protocol.
60    uint totalDebt; // The last recorded total debt since last action.
61    uint totalShare; // The total debt share count across all open positions.
62  }
63​
64  struct Position {
65    address owner; // The owner of this position.
66    address collToken; // The ERC1155 token used as collateral for this position.
67    uint collId; // The token id used as collateral.
68    uint collateralSize; // The size of collateral token for this position.
69    uint debtMap; // Bitmap of nonzero debt. i^th bit is set iff debt share of i^th bank is nonzero.
70    mapping(address => uint) debtShareOf; // The debt share for each token.
71  }
72​
73  uint public _GENERAL_LOCK; // TEMPORARY: re-entrancy lock guard.
74  uint public _IN_EXEC_LOCK; // TEMPORARY: exec lock guard.
75  uint public override POSITION_ID; // TEMPORARY: position ID currently under execution.
76  address public override SPELL; // TEMPORARY: spell currently under execution.
77​
78  address public caster; // The caster address for untrusted execution.
79  IOracle public oracle; // The oracle address for determining prices.
80  uint public feeBps; // The fee collected as protocol reserve in basis points from interest.
81  uint public override nextPositionId; // Next available position ID, starting from 1 (see initialize).
82​
83  address[] public allBanks; // The list of all listed banks.
84  mapping(address => Bank) public banks; // Mapping from token to bank data.
85  mapping(address => bool) public cTokenInBank; // Mapping from cToken to its existence in bank.
86  mapping(uint => Position) public positions; // Mapping from position ID to position data.
87​
88  bool public allowContractCalls; // The boolean status whether to allow call from contract (false = onlyEOA)
89  mapping(address => bool) public whitelistedTokens; // Mapping from token to whitelist status
90  mapping(address => bool) public whitelistedSpells; // Mapping from spell to whitelist status
91  mapping(address => bool) public whitelistedUsers; // Mapping from user to whitelist status
92​
93  uint public bankStatus; // Each bit stores certain bank status, e.g. borrow allowed, repay allowed
94​
95  /// @dev Ensure that the function is called from EOA when allowContractCalls is set to false and caller is not whitelisted
96  modifier onlyEOAEx() {
97    if (!allowContractCalls && !whitelistedUsers[msg.sender]) {
98      require(msg.sender == tx.origin, 'not eoa');
99    }
100    _;
101  }
102​
103  /// @dev Reentrancy lock guard.
104  modifier lock() {
105    require(_GENERAL_LOCK == _NOT_ENTERED, 'general lock');
106    _GENERAL_LOCK = _ENTERED;
107    _;
108    _GENERAL_LOCK = _NOT_ENTERED;
109  }
110​
111  /// @dev Ensure that the function is called from within the execution scope.
112  modifier inExec() {
113    require(POSITION_ID != _NO_ID, 'not within execution');
114    require(SPELL == msg.sender, 'not from spell');
115    require(_IN_EXEC_LOCK == _NOT_ENTERED, 'in exec lock');
116    _IN_EXEC_LOCK = _ENTERED;
117    _;
118    _IN_EXEC_LOCK = _NOT_ENTERED;
119  }
120​
121  /// @dev Ensure that the interest rate of the given token is accrued.
122  modifier poke(address token) {
123    accrue(token);
124    _;
125  }
126​
127  /// @dev Initialize the bank smart contract, using msg.sender as the first governor.
128  /// @param _oracle The oracle smart contract address.
129  /// @param _feeBps The fee collected to Homora bank.
130  function initialize(IOracle _oracle, uint _feeBps) external initializer {
131    __Governable__init();
132    _GENERAL_LOCK = _NOT_ENTERED;
133    _IN_EXEC_LOCK = _NOT_ENTERED;
134    POSITION_ID = _NO_ID;
135    SPELL = _NO_ADDRESS;
136    caster = address(new HomoraCaster());
137    oracle = _oracle;
138    require(address(_oracle) != address(0), 'bad oracle address');
139    feeBps = _feeBps;
140    nextPositionId = 1;
141    bankStatus = 3; // allow both borrow and repay
142    emit SetOracle(address(_oracle));
143    emit SetFeeBps(_feeBps);
144  }
145​
146  /// @dev Return the current executor (the owner of the current position).
147  function EXECUTOR() external view override returns (address) {
148    uint positionId = POSITION_ID;
149    require(positionId != _NO_ID, 'not under execution');
150    return positions[positionId].owner;
151  }
152​
153  /// @dev Set allowContractCalls
154  /// @param ok The status to set allowContractCalls to (false = onlyEOA)
155  function setAllowContractCalls(bool ok) external onlyGov {
156    allowContractCalls = ok;
157  }
158​
159  /// @dev Set whitelist spell status
160  /// @param spells list of spells to change status
161  /// @param statuses list of statuses to change to
162  function setWhitelistSpells(address[] calldata spells, bool[] calldata statuses)
163    external
164    onlyGov
165  {
166    require(spells.length == statuses.length, 'spells & statuses length mismatched');
167    for (uint idx = 0; idx < spells.length; idx++) {
168      whitelistedSpells[spells[idx]] = statuses[idx];
169    }
170  }
171​
172  /// @dev Set whitelist token status
173  /// @param tokens list of tokens to change status
174  /// @param statuses list of statuses to change to
175  function setWhitelistTokens(address[] calldata tokens, bool[] calldata statuses)
176    external
177    onlyGov
178  {
179    require(tokens.length == statuses.length, 'tokens & statuses length mismatched');
180    for (uint idx = 0; idx < tokens.length; idx++) {
181      if (statuses[idx]) {
182        // check oracle suppport
183        require(support(tokens[idx]), 'oracle not support token');
184      }
185      whitelistedTokens[tokens[idx]] = statuses[idx];
186    }
187  }
188​
189  /// @dev Set whitelist user status
190  /// @param users list of users to change status
191  /// @param statuses list of statuses to change to
192  function setWhitelistUsers(address[] calldata users, bool[] calldata statuses) external onlyGov {
193    require(users.length == statuses.length, 'users & statuses length mismatched');
194    for (uint idx = 0; idx < users.length; idx++) {
195      whitelistedUsers[users[idx]] = statuses[idx];
196    }
197  }
198​
199  /// @dev Check whether the oracle supports the token
200  /// @param token ERC-20 token to check for support
201  function support(address token) public view override returns (bool) {
202    return oracle.support(token);
203  }
204​
205  /// @dev Set bank status
206  /// @param _bankStatus new bank status to change to
207  function setBankStatus(uint _bankStatus) external onlyGov {
208    bankStatus = _bankStatus;
209  }
210​
211  /// @dev Bank borrow status allowed or not
212  /// @notice check last bit of bankStatus
213  function allowBorrowStatus() public view returns (bool) {
214    return (bankStatus & 0x01) > 0;
215  }
216​
217  /// @dev Bank repay status allowed or not
218  /// @notice Check second-to-last bit of bankStatus
219  function allowRepayStatus() public view returns (bool) {
220    return (bankStatus & 0x02) > 0;
221  }
222​
223  /// @dev Trigger interest accrual for the given bank.
224  /// @param token The underlying token to trigger the interest accrual.
225  function accrue(address token) public override {
226    Bank storage bank = banks[token];
227    require(bank.isListed, 'bank not exist');
228    uint totalDebt = bank.totalDebt;
229    uint debt = ICErc20(bank.cToken).borrowBalanceCurrent(address(this));
230    if (debt > totalDebt) {
231      uint fee = debt.sub(totalDebt).mul(feeBps).div(10000);
232      bank.totalDebt = debt;
233      bank.reserve = bank.reserve.add(doBorrow(token, fee));
234    } else if (totalDebt != debt) {
235      // We should never reach here because CREAMv2 does not support *repayBorrowBehalf*
236      // functionality. We set bank.totalDebt = debt nonetheless to ensure consistency. But do
237      // note that if *repayBorrowBehalf* exists, an attacker can maliciously deflate debt
238      // share value and potentially make this contract stop working due to math overflow.
239      bank.totalDebt = debt;
240    }
241  }
242​
243  /// @dev Convenient function to trigger interest accrual for a list of banks.
244  /// @param tokens The list of banks to trigger interest accrual.
245  function accrueAll(address[] memory tokens) external {
246    for (uint idx = 0; idx < tokens.length; idx++) {
247      accrue(tokens[idx]);
248    }
249  }
250​
251  /// @dev Return the borrow balance for given position and token without triggering interest accrual.
252  /// @param positionId The position to query for borrow balance.
253  /// @param token The token to query for borrow balance.
254  function borrowBalanceStored(uint positionId, address token) public view override returns (uint) {
255    uint totalDebt = banks[token].totalDebt;
256    uint totalShare = banks[token].totalShare;
257    uint share = positions[positionId].debtShareOf[token];
258    if (share == 0 || totalDebt == 0) {
259      return 0;
260    } else {
261      return share.mul(totalDebt).ceilDiv(totalShare);
262    }
263  }
264​
265  /// @dev Trigger interest accrual and return the current borrow balance.
266  /// @param positionId The position to query for borrow balance.
267  /// @param token The token to query for borrow balance.
268  function borrowBalanceCurrent(uint positionId, address token) external override returns (uint) {
269    accrue(token);
270    return borrowBalanceStored(positionId, token);
271  }
272​
273  /// @dev Return bank information for the given token.
274  /// @param token The token address to query for bank information.
275  function getBankInfo(address token)
276    external
277    view
278    override
279    returns (
280      bool isListed,
281      address cToken,
282      uint reserve,
283      uint totalDebt,
284      uint totalShare
285    )
286  {
287    Bank storage bank = banks[token];
288    return (bank.isListed, bank.cToken, bank.reserve, bank.totalDebt, bank.totalShare);
289  }
290​
291  /// @dev Return position information for the given position id.
292  /// @param positionId The position id to query for position information.
293  function getPositionInfo(uint positionId)
294    public
295    view
296    override
297    returns (
298      address owner,
299      address collToken,
300      uint collId,
301      uint collateralSize
302    )
303  {
304    Position storage pos = positions[positionId];
305    return (pos.owner, pos.collToken, pos.collId, pos.collateralSize);
306  }

Solidity Contracts

JavaScript Tests