Kine Protocol

1contract Controller is ControllerStorage, KineControllerInterface, Exponential, ControllerErrorReporter {
2    /// @notice Emitted when an admin supports a market
3    event MarketListed(KToken kToken);
4​
5    /// @notice Emitted when an account enters a market
6    event MarketEntered(KToken kToken, address account);
7​
8    /// @notice Emitted when an account exits a market
9    event MarketExited(KToken kToken, address account);
10​
11    /// @notice Emitted when close factor is changed by admin
12    event NewCloseFactor(uint oldCloseFactorMantissa, uint newCloseFactorMantissa);
13​
14    /// @notice Emitted when a collateral factor is changed by admin
15    event NewCollateralFactor(KToken kToken, uint oldCollateralFactorMantissa, uint newCollateralFactorMantissa);
16​
17    /// @notice Emitted when liquidation incentive is changed by admin
18    event NewLiquidationIncentive(uint oldLiquidationIncentiveMantissa, uint newLiquidationIncentiveMantissa);
19​
20    /// @notice Emitted when redemption params is changed by admin
21    event NewRedemptionInitialPunishment(uint oldRedemptionInitialPunishmentMantissa, uint newRedemptionInitialPunishmentMantissa);
22​
23    /// @notice Emitted when price oracle is changed
24    event NewPriceOracle(KineOracleInterface oldPriceOracle, KineOracleInterface newPriceOracle);
25​
26    /// @notice Emitted when pause guardian is changed
27    event NewPauseGuardian(address oldPauseGuardian, address newPauseGuardian);
28​
29    /// @notice Emitted when an action is paused globally
30    event ActionPaused(string action, bool pauseState);
31​
32    /// @notice Emitted when an action is paused on a market
33    event ActionPaused(KToken kToken, string action, bool pauseState);
34​
35    /// @notice Emitted when borrow cap for a kToken is changed
36    event NewBorrowCap(KToken indexed kToken, uint newBorrowCap);
37​
38    /// @notice Emitted when supply cap for a kToken is changed
39    event NewSupplyCap(KToken indexed kToken, uint newSupplyCap);
40​
41    /// @notice Emitted when borrow/supply cap guardian is changed
42    event NewCapGuardian(address oldCapGuardian, address newCapGuardian);
43​
44    // closeFactorMantissa must be strictly greater than this value
45    uint internal constant closeFactorMinMantissa = 0.05e18; // 0.05
46​
47    // closeFactorMantissa must not exceed this value
48    uint internal constant closeFactorMaxMantissa = 0.9e18; // 0.9
49​
50    // liquidationIncentiveMantissa must be no less than this value
51    uint internal constant liquidationIncentiveMinMantissa = 1.0e18; // 1.0
52​
53    // liquidationIncentiveMantissa must be no greater than this value
54    uint internal constant liquidationIncentiveMaxMantissa = 1.5e18; // 1.5
55​
56    // No collateralFactorMantissa may exceed this value
57    uint internal constant collateralFactorMaxMantissa = 0.9e18; // 0.9
58​
59    constructor() public {
60        admin = msg.sender;
61    }
62​
63    modifier onlyAdmin() {
64        require(msg.sender == admin, "only admin can call this function");
65        _;
66    }
67​
68    /*** Assets You Are In ***/
69​
70    /**
71     * @notice Returns the assets an account has entered
72     * @param account The address of the account to pull assets for
73     * @return A dynamic list with the assets the account has entered
74     */
75    function getAssetsIn(address account) external view returns (KToken[] memory) {
76        KToken[] memory assetsIn = accountAssets[account];
77​
78        return assetsIn;
79    }
80​
81    /**
82     * @notice Returns whether the given account is entered in the given asset
83     * @param account The address of the account to check
84     * @param kToken The kToken to check
85     * @return True if the account is in the asset, otherwise false.
86     */
87    function checkMembership(address account, KToken kToken) external view returns (bool) {
88        return markets[address(kToken)].accountMembership[account];
89    }
90​
91    /**
92     * @notice Add assets to be included in account liquidity calculation
93     * @param kTokens The list of addresses of the kToken markets to be enabled
94     * @dev will revert if any market entering failed
95     */
96    function enterMarkets(address[] memory kTokens) public {
97        uint len = kTokens.length;
98        for (uint i = 0; i < len; i++) {
99            KToken kToken = KToken(kTokens[i]);
100            addToMarketInternal(kToken, msg.sender);
101        }
102    }
103​
104    /**
105     * @notice Add the market to the borrower's "assets in" for liquidity calculations
106     * @param kToken The market to enter
107     * @param borrower The address of the account to modify
108     */
109    function addToMarketInternal(KToken kToken, address borrower) internal {
110        Market storage marketToJoin = markets[address(kToken)];
111​
112        require(marketToJoin.isListed, MARKET_NOT_LISTED);
113​
114        if (marketToJoin.accountMembership[borrower] == true) {
115            // already joined
116            return;
117        }
118​
119        // survived the gauntlet, add to list
120        // NOTE: we store these somewhat redundantly as a significant optimization
121        //  this avoids having to iterate through the list for the most common use cases
122        /  that is, only when we need to perform liquidity checks
123        /  and not whenever we want to check if an account is in a particular market
124        marketToJoin.accountMembership[borrower] = true;
125        accountAssets[borrower].push(kToken);
126​
127        emit MarketEntered(kToken, borrower);
128    }
129​
130    /**
131     * @notice Removes asset from sender's account liquidity calculation
132     * @dev Sender must not have an outstanding borrow balance in the asset,
133     *  or be providing necessary collateral for an outstanding borrow.
134     * @param kTokenAddress The address of the asset to be removed
135     */
136    function exitMarket(address kTokenAddress) external {
137        KToken kToken = KToken(kTokenAddress);
138        /* Get sender tokensHeld and amountOwed underlying from the kToken */
139        (uint tokensHeld, uint amountOwed) = kToken.getAccountSnapshot(msg.sender);
140​
141        /* Fail if the sender has a borrow balance */
142        require(amountOwed == 0, EXIT_MARKET_BALANCE_OWED);
143​
144        /* Fail if the sender is not permitted to redeem all of their tokens */
145        (bool allowed,) = redeemAllowedInternal(kTokenAddress, msg.sender, tokensHeld);
146        require(allowed, EXIT_MARKET_REJECTION);
147​
148        Market storage marketToExit = markets[address(kToken)];
149​
150        /* Succeed true if the sender is not already ‘in’ the market */
151        if (!marketToExit.accountMembership[msg.sender]) {
152            return;
153        }
154​
155        /* Set kToken account membership to false */
156        delete marketToExit.accountMembership[msg.sender];
157​
158        /* Delete kToken from the account’s list of assets */
159        // load into memory for faster iteration
160        KToken[] memory userAssetList = accountAssets[msg.sender];
161        uint len = userAssetList.length;
162        uint assetIndex = len;
163        for (uint i = 0; i < len; i++) {
164            if (userAssetList[i] == kToken) {
165                assetIndex = i;
166                break;
167            }
168        }
169​
170        // We *must* have found the asset in the list or our redundant data structure is broken
171        require(assetIndex < len, "accountAssets array broken");
172​
173        // copy last item in list to location of item to be removed, reduce length by 1
174        KToken[] storage storedList = accountAssets[msg.sender];
175        if (assetIndex != storedList.length - 1) {
176            storedList[assetIndex] = storedList[storedList.length - 1];
177        }
178        storedList.length--;
179​
180        emit MarketExited(kToken, msg.sender);
181    }
182​

Solidity Contracts

JavaScript Tests