Venus

1pragma solidity ^0.5.16;
2
3import "./VToken.sol";
4import "./PriceOracle.sol";
5import "./ErrorReporter.sol";
6import "./Exponential.sol";
7import "./VAIControllerStorage.sol";
8import "./VAIUnitroller.sol";
9import "./VAI/VAI.sol";
10
11interface ComptrollerImplInterface {
12    function protocolPaused() external view returns (bool);
13    function mintedVAIs(address account) external view returns (uint);
14    function vaiMintRate() external view returns (uint);
15    function venusVAIRate() external view returns (uint);
16    function venusAccrued(address account) external view returns(uint);
17    function getAssetsIn(address account) external view returns (VToken[] memory);
18    function oracle() external view returns (PriceOracle);
19}
20
21/**
22 * @title Venus's VAI Comptroller Contract
23 * @author Venus
24 */
25contract VAIController is VAIControllerStorageG2, VAIControllerErrorReporter, Exponential {
26
27    /// @notice Emitted when Comptroller is changed
28    event NewComptroller(ComptrollerInterface oldComptroller, ComptrollerInterface newComptroller);
29
30    /**
31     * @notice Event emitted when VAI is minted
32     */
33    event MintVAI(address minter, uint mintVAIAmount);
34
35    /**
36     * @notice Event emitted when VAI is repaid
37     */
38    event RepayVAI(address payer, address borrower, uint repayVAIAmount);
39
40    /// @notice The initial Venus index for a market
41    uint224 public constant venusInitialIndex = 1e36;
42
43    /**
44     * @notice Event emitted when a borrow is liquidated
45     */
46    event LiquidateVAI(address liquidator, address borrower, uint repayAmount, address vTokenCollateral, uint seizeTokens);
47
48    /**
49     * @notice Emitted when treasury guardian is changed
50     */
51    event NewTreasuryGuardian(address oldTreasuryGuardian, address newTreasuryGuardian);
52
53    /**
54     * @notice Emitted when treasury address is changed
55     */
56    event NewTreasuryAddress(address oldTreasuryAddress, address newTreasuryAddress);
57
58    /**
59     * @notice Emitted when treasury percent is changed
60     */
61    event NewTreasuryPercent(uint oldTreasuryPercent, uint newTreasuryPercent);
62
63    /**
64     * @notice Event emitted when VAIs are minted and fee are transferred
65     */
66    event MintFee(address minter, uint feeAmount);
67
68    /*** Main Actions ***/
69    struct MintLocalVars {
70        uint oErr;
71        MathError mathErr;
72        uint mintAmount;
73        uint accountMintVAINew;
74        uint accountMintableVAI;
75    }
76
77    function mintVAI(uint mintVAIAmount) external nonReentrant returns (uint) {
78        if(address(comptroller) != address(0)) {
79            require(mintVAIAmount > 0, "mintVAIAmount cannt be zero");
80
81            require(!ComptrollerImplInterface(address(comptroller)).protocolPaused(), "protocol is paused");
82
83            MintLocalVars memory vars;
84
85            address minter = msg.sender;
86
87            (vars.oErr, vars.accountMintableVAI) = getMintableVAI(minter);
88            if (vars.oErr != uint(Error.NO_ERROR)) {
89                return uint(Error.REJECTION);
90            }
91
92            // check that user have sufficient mintableVAI balance
93            if (mintVAIAmount > vars.accountMintableVAI) {
94                return fail(Error.REJECTION, FailureInfo.VAI_MINT_REJECTION);
95            }
96
97            (vars.mathErr, vars.accountMintVAINew) = addUInt(ComptrollerImplInterface(address(comptroller)).mintedVAIs(minter), mintVAIAmount);
98            require(vars.mathErr == MathError.NO_ERROR, "VAI_MINT_AMOUNT_CALCULATION_FAILED");
99            uint error = comptroller.setMintedVAIOf(minter, vars.accountMintVAINew);
100            if (error != 0 ) {
101                return error;
102            }
103
104            uint feeAmount;
105            uint remainedAmount;
106            vars.mintAmount = mintVAIAmount;
107            if (treasuryPercent != 0) {
108                (vars.mathErr, feeAmount) = mulUInt(vars.mintAmount, treasuryPercent);
109                if (vars.mathErr != MathError.NO_ERROR) {
110                    return failOpaque(Error.MATH_ERROR, FailureInfo.MINT_FEE_CALCULATION_FAILED, uint(vars.mathErr));
111                }
112
113                (vars.mathErr, feeAmount) = divUInt(feeAmount, 1e18);
114                if (vars.mathErr != MathError.NO_ERROR) {
115                    return failOpaque(Error.MATH_ERROR, FailureInfo.MINT_FEE_CALCULATION_FAILED, uint(vars.mathErr));
116                }
117
118                (vars.mathErr, remainedAmount) = subUInt(vars.mintAmount, feeAmount);
119                if (vars.mathErr != MathError.NO_ERROR) {
120                    return failOpaque(Error.MATH_ERROR, FailureInfo.MINT_FEE_CALCULATION_FAILED, uint(vars.mathErr));
121                }
122
123                VAI(getVAIAddress()).mint(treasuryAddress, feeAmount);
124
125                emit MintFee(minter, feeAmount);
126            } else {
127                remainedAmount = vars.mintAmount;
128            }
129
130            VAI(getVAIAddress()).mint(minter, remainedAmount);
131
132            emit MintVAI(minter, remainedAmount);
133
134            return uint(Error.NO_ERROR);
135        }
136    }
137
138    /**
139     * @notice Repay VAI
140     */
141    function repayVAI(uint repayVAIAmount) external nonReentrant returns (uint, uint) {
142        if(address(comptroller) != address(0)) {
143            require(repayVAIAmount > 0, "repayVAIAmount cannt be zero");
144
145            require(!ComptrollerImplInterface(address(comptroller)).protocolPaused(), "protocol is paused");
146
147            address payer = msg.sender;
148
149            return repayVAIFresh(msg.sender, msg.sender, repayVAIAmount);
150        }
151    }
152
153    /**
154     * @notice Repay VAI Internal
155     * @notice Borrowed VAIs are repaid by another user (possibly the borrower).
156     * @param payer the account paying off the VAI
157     * @param borrower the account with the debt being payed off
158     * @param repayAmount the amount of VAI being returned
159     * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount.
160     */
161    function repayVAIFresh(address payer, address borrower, uint repayAmount) internal returns (uint, uint) {
162        uint actualBurnAmount;
163
164        uint vaiBalanceBorrower = ComptrollerImplInterface(address(comptroller)).mintedVAIs(borrower);
165
166        if(vaiBalanceBorrower > repayAmount) {
167            actualBurnAmount = repayAmount;
168        } else {
169            actualBurnAmount = vaiBalanceBorrower;
170        }
171
172        MathError mErr;
173        uint accountVAINew;
174
175        VAI(getVAIAddress()).burn(payer, actualBurnAmount);
176
177        (mErr, accountVAINew) = subUInt(vaiBalanceBorrower, actualBurnAmount);
178        require(mErr == MathError.NO_ERROR, "VAI_BURN_AMOUNT_CALCULATION_FAILED");
179
180        uint error = comptroller.setMintedVAIOf(borrower, accountVAINew);
181        if (error != 0) {
182            return (error, 0);
183        }
184        emit RepayVAI(payer, borrower, actualBurnAmount);
185
186        return (uint(Error.NO_ERROR), actualBurnAmount);
187    }
188
189    /**
190     * @notice The sender liquidates the vai minters collateral.
191     *  The collateral seized is transferred to the liquidator.
192     * @param borrower The borrower of vai to be liquidated
193     * @param vTokenCollateral The market in which to seize collateral from the borrower
194     * @param repayAmount The amount of the underlying borrowed asset to repay
195     * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount.
196     */
197    function liquidateVAI(address borrower, uint repayAmount, VTokenInterface vTokenCollateral) external nonReentrant returns (uint, uint) {
198        require(!ComptrollerImplInterface(address(comptroller)).protocolPaused(), "protocol is paused");
199
200        uint error = vTokenCollateral.accrueInterest();
201        if (error != uint(Error.NO_ERROR)) {
202            // accrueInterest emits logs on errors, but we still want to log the fact that an attempted liquidation failed
203            return (fail(Error(error), FailureInfo.VAI_LIQUIDATE_ACCRUE_COLLATERAL_INTEREST_FAILED), 0);
204        }
205
206        // liquidateVAIFresh emits borrow-specific logs on errors, so we don't need to
207        return liquidateVAIFresh(msg.sender, borrower, repayAmount, vTokenCollateral);
208    }
209

JavaScript Tests