{ "address": "0x9e6be1084d5ACff84f91019C01135d2319e1b190", "abi": [ { "constant": false, "inputs": [ { "internalType": "contract CToken", "name": "cToken", "type": "address" }, { "internalType": "address payable", "name": "account", "type": "address" } ], "name": "cTokenBalances", "outputs": [ { "components": [ { "internalType": "address", "name": "cToken", "type": "address" }, { "internalType": "uint256", "name": "balanceOf", "type": "uint256" }, { "internalType": "uint256", "name": "borrowBalanceCurrent", "type": "uint256" }, { "internalType": "uint256", "name": "balanceOfUnderlying", "type": "uint256" }, { "internalType": "uint256", "name": "tokenBalance", "type": "uint256" }, { "internalType": "uint256", "name": "tokenAllowance", "type": "uint256" }, { "internalType": "bool", "name": "collateralEnabled", "type": "bool" }, { "internalType": "uint256", "name": "collateralBalance", "type": "uint256" }, { "internalType": "uint256", "name": "nativeTokenBalance", "type": "uint256" } ], "internalType": "struct CompoundLens.CTokenBalances", "name": "", "type": "tuple" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "internalType": "contract CToken[]", "name": "cTokens", "type": "address[]" }, { "internalType": "address payable", "name": "account", "type": "address" } ], "name": "cTokenBalancesAll", "outputs": [ { "components": [ { "internalType": "address", "name": "cToken", "type": "address" }, { "internalType": "uint256", "name": "balanceOf", "type": "uint256" }, { "internalType": "uint256", "name": "borrowBalanceCurrent", "type": "uint256" }, { "internalType": "uint256", "name": "balanceOfUnderlying", "type": "uint256" }, { "internalType": "uint256", "name": "tokenBalance", "type": "uint256" }, { "internalType": "uint256", "name": "tokenAllowance", "type": "uint256" }, { "internalType": "bool", "name": "collateralEnabled", "type": "bool" }, { "internalType": "uint256", "name": "collateralBalance", "type": "uint256" }, { "internalType": "uint256", "name": "nativeTokenBalance", "type": "uint256" } ], "internalType": "struct CompoundLens.CTokenBalances[]", "name": "", "type": "tuple[]" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "internalType": "contract CToken", "name": "cToken", "type": "address" } ], "name": "cTokenMetadata", "outputs": [ { "components": [ { "internalType": "address", "name": "cToken", "type": "address" }, { "internalType": "uint256", "name": "exchangeRateCurrent", "type": "uint256" }, { "internalType": "uint256", "name": "supplyRatePerBlock", "type": "uint256" }, { "internalType": "uint256", "name": "borrowRatePerBlock", "type": "uint256" }, { "internalType": "uint256", "name": "reserveFactorMantissa", "type": "uint256" }, { "internalType": "uint256", "name": "totalBorrows", "type": "uint256" }, { "internalType": "uint256", "name": "totalReserves", "type": "uint256" }, { "internalType": "uint256", "name": "totalSupply", "type": "uint256" }, { "internalType": "uint256", "name": "totalCash", "type": "uint256" }, { "internalType": "uint256", "name": "totalCollateralTokens", "type": "uint256" }, { "internalType": "bool", "name": "isListed", "type": "bool" }, { "internalType": "uint256", "name": "collateralFactorMantissa", "type": "uint256" }, { "internalType": "address", "name": "underlyingAssetAddress", "type": "address" }, { "internalType": "uint256", "name": "cTokenDecimals", "type": "uint256" }, { "internalType": "uint256", "name": "underlyingDecimals", "type": "uint256" }, { "internalType": "enum ComptrollerV1Storage.Version", "name": "version", "type": "uint8" }, { "internalType": "uint256", "name": "collateralCap", "type": "uint256" }, { "internalType": "uint256", "name": "underlyingPrice", "type": "uint256" }, { "internalType": "bool", "name": "supplyPaused", "type": "bool" }, { "internalType": "bool", "name": "borrowPaused", "type": "bool" }, { "internalType": "uint256", "name": "supplyCap", "type": "uint256" }, { "internalType": "uint256", "name": "borrowCap", "type": "uint256" } ], "internalType": "struct CompoundLens.CTokenMetadata", "name": "", "type": "tuple" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "internalType": "contract CToken[]", "name": "cTokens", "type": "address[]" } ], "name": "cTokenMetadataAll", "outputs": [ { "components": [ { "internalType": "address", "name": "cToken", "type": "address" }, { "internalType": "uint256", "name": "exchangeRateCurrent", "type": "uint256" }, { "internalType": "uint256", "name": "supplyRatePerBlock", "type": "uint256" }, { "internalType": "uint256", "name": "borrowRatePerBlock", "type": "uint256" }, { "internalType": "uint256", "name": "reserveFactorMantissa", "type": "uint256" }, { "internalType": "uint256", "name": "totalBorrows", "type": "uint256" }, { "internalType": "uint256", "name": "totalReserves", "type": "uint256" }, { "internalType": "uint256", "name": "totalSupply", "type": "uint256" }, { "internalType": "uint256", "name": "totalCash", "type": "uint256" }, { "internalType": "uint256", "name": "totalCollateralTokens", "type": "uint256" }, { "internalType": "bool", "name": "isListed", "type": "bool" }, { "internalType": "uint256", "name": "collateralFactorMantissa", "type": "uint256" }, { "internalType": "address", "name": "underlyingAssetAddress", "type": "address" }, { "internalType": "uint256", "name": "cTokenDecimals", "type": "uint256" }, { "internalType": "uint256", "name": "underlyingDecimals", "type": "uint256" }, { "internalType": "enum ComptrollerV1Storage.Version", "name": "version", "type": "uint8" }, { "internalType": "uint256", "name": "collateralCap", "type": "uint256" }, { "internalType": "uint256", "name": "underlyingPrice", "type": "uint256" }, { "internalType": "bool", "name": "supplyPaused", "type": "bool" }, { "internalType": "bool", "name": "borrowPaused", "type": "bool" }, { "internalType": "uint256", "name": "supplyCap", "type": "uint256" }, { "internalType": "uint256", "name": "borrowCap", "type": "uint256" } ], "internalType": "struct CompoundLens.CTokenMetadata[]", "name": "", "type": "tuple[]" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "internalType": "contract Comptroller", "name": "comptroller", "type": "address" }, { "internalType": "address", "name": "account", "type": "address" } ], "name": "getAccountLimits", "outputs": [ { "components": [ { "internalType": "contract CToken[]", "name": "markets", "type": "address[]" }, { "internalType": "uint256", "name": "liquidity", "type": "uint256" }, { "internalType": "uint256", "name": "shortfall", "type": "uint256" } ], "internalType": "struct CompoundLens.AccountLimits", "name": "", "type": "tuple" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "internalType": "contract CCTokenInterface[]", "name": "cTokens", "type": "address[]" }, { "internalType": "address", "name": "comp", "type": "address" }, { "internalType": "address", "name": "account", "type": "address" } ], "name": "getClaimableCompRewards", "outputs": [ { "internalType": "uint256[]", "name": "", "type": "uint256[]" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "internalType": "contract CSLPInterface[]", "name": "cTokens", "type": "address[]" }, { "internalType": "address", "name": "sushi", "type": "address" }, { "internalType": "address", "name": "account", "type": "address" } ], "name": "getClaimableSushiRewards", "outputs": [ { "internalType": "uint256[]", "name": "", "type": "uint256[]" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" } ], "transactionHash": "0x51b8c80d55541a185fae7b9738ae2bfb380d130d198290a5f0f79220acfa1cbc", "receipt": { "to": null, "from": "0x5D3e4C0FE11e0aE4c32F0FF74B4544C49538AC61", "contractAddress": "0x9e6be1084d5ACff84f91019C01135d2319e1b190", "transactionIndex": 0, "gasUsed": "2348401", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "blockHash": "0xa513c2759fba5456cd903d09be0255b785db758e59b226da1802dfc9cd43774a", "transactionHash": "0x51b8c80d55541a185fae7b9738ae2bfb380d130d198290a5f0f79220acfa1cbc", "logs": [], "blockNumber": 9254481, "cumulativeGasUsed": "2348401", "status": 1, "byzantium": true }, "args": [], "solcInputHash": "7efdb7a89a284f1433367a7aea5d055e", "metadata": "{\"compiler\":{\"version\":\"0.5.16+commit.9c3226ce\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"constant\":false,\"inputs\":[{\"internalType\":\"contract CToken\",\"name\":\"cToken\",\"type\":\"address\"},{\"internalType\":\"address payable\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"cTokenBalances\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"cToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"balanceOf\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"borrowBalanceCurrent\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"balanceOfUnderlying\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tokenBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tokenAllowance\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"collateralEnabled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"collateralBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nativeTokenBalance\",\"type\":\"uint256\"}],\"internalType\":\"struct CompoundLens.CTokenBalances\",\"name\":\"\",\"type\":\"tuple\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"contract CToken[]\",\"name\":\"cTokens\",\"type\":\"address[]\"},{\"internalType\":\"address payable\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"cTokenBalancesAll\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"cToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"balanceOf\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"borrowBalanceCurrent\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"balanceOfUnderlying\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tokenBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tokenAllowance\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"collateralEnabled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"collateralBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nativeTokenBalance\",\"type\":\"uint256\"}],\"internalType\":\"struct CompoundLens.CTokenBalances[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"contract CToken\",\"name\":\"cToken\",\"type\":\"address\"}],\"name\":\"cTokenMetadata\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"cToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"exchangeRateCurrent\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"supplyRatePerBlock\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"borrowRatePerBlock\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"reserveFactorMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalBorrows\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalReserves\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalSupply\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalCash\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalCollateralTokens\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"isListed\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"collateralFactorMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"underlyingAssetAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"cTokenDecimals\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"underlyingDecimals\",\"type\":\"uint256\"},{\"internalType\":\"enum ComptrollerV1Storage.Version\",\"name\":\"version\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"collateralCap\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"underlyingPrice\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"supplyPaused\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"borrowPaused\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"supplyCap\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"borrowCap\",\"type\":\"uint256\"}],\"internalType\":\"struct CompoundLens.CTokenMetadata\",\"name\":\"\",\"type\":\"tuple\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"contract CToken[]\",\"name\":\"cTokens\",\"type\":\"address[]\"}],\"name\":\"cTokenMetadataAll\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"cToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"exchangeRateCurrent\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"supplyRatePerBlock\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"borrowRatePerBlock\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"reserveFactorMantissa\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalBorrows\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalReserves\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalSupply\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalCash\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalCollateralTokens\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"isListed\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"collateralFactorMantissa\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"underlyingAssetAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"cTokenDecimals\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"underlyingDecimals\",\"type\":\"uint256\"},{\"internalType\":\"enum ComptrollerV1Storage.Version\",\"name\":\"version\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"collateralCap\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"underlyingPrice\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"supplyPaused\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"borrowPaused\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"supplyCap\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"borrowCap\",\"type\":\"uint256\"}],\"internalType\":\"struct CompoundLens.CTokenMetadata[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"contract Comptroller\",\"name\":\"comptroller\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getAccountLimits\",\"outputs\":[{\"components\":[{\"internalType\":\"contract CToken[]\",\"name\":\"markets\",\"type\":\"address[]\"},{\"internalType\":\"uint256\",\"name\":\"liquidity\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"shortfall\",\"type\":\"uint256\"}],\"internalType\":\"struct CompoundLens.AccountLimits\",\"name\":\"\",\"type\":\"tuple\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"contract CCTokenInterface[]\",\"name\":\"cTokens\",\"type\":\"address[]\"},{\"internalType\":\"address\",\"name\":\"comp\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getClaimableCompRewards\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"contract CSLPInterface[]\",\"name\":\"cTokens\",\"type\":\"address[]\"},{\"internalType\":\"address\",\"name\":\"sushi\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getClaimableSushiRewards\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"methods\":{}},\"userdoc\":{\"methods\":{}}},\"settings\":{\"compilationTarget\":{\"contracts/Lens/CompoundLens.sol\":\"CompoundLens\"},\"evmVersion\":\"istanbul\",\"libraries\":{\"__CACHE_BREAKER__\":\"0x00000000d41867734bbee4c6863d9255b2b06ac1\"},\"metadata\":{\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"contracts/CErc20.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\nimport \\\"./CToken.sol\\\";\\n\\n/**\\n * @title Compound's CErc20 Contract\\n * @notice CTokens which wrap an EIP-20 underlying\\n * @author Compound\\n */\\ncontract CErc20 is CToken, CErc20Interface {\\n /**\\n * @notice Initialize the new money market\\n * @param underlying_ The address of the underlying asset\\n * @param comptroller_ The address of the Comptroller\\n * @param interestRateModel_ The address of the interest rate model\\n * @param initialExchangeRateMantissa_ The initial exchange rate, scaled by 1e18\\n * @param name_ ERC-20 name of this token\\n * @param symbol_ ERC-20 symbol of this token\\n * @param decimals_ ERC-20 decimal precision of this token\\n */\\n function initialize(\\n address underlying_,\\n ComptrollerInterface comptroller_,\\n InterestRateModel interestRateModel_,\\n uint256 initialExchangeRateMantissa_,\\n string memory name_,\\n string memory symbol_,\\n uint8 decimals_\\n ) public {\\n // CToken initialize does the bulk of the work\\n super.initialize(comptroller_, interestRateModel_, initialExchangeRateMantissa_, name_, symbol_, decimals_);\\n\\n // Set underlying and sanity check it\\n underlying = underlying_;\\n EIP20Interface(underlying).totalSupply();\\n }\\n\\n /*** User Interface ***/\\n\\n /**\\n * @notice Sender supplies assets into the market and receives cTokens in exchange\\n * @dev Accrues interest whether or not the operation succeeds, unless reverted\\n * @param mintAmount The amount of the underlying asset to supply\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function mint(uint256 mintAmount) external returns (uint256) {\\n (uint256 err, ) = mintInternal(mintAmount, false);\\n return err;\\n }\\n\\n /**\\n * @notice Sender redeems cTokens in exchange for the underlying asset\\n * @dev Accrues interest whether or not the operation succeeds, unless reverted\\n * @param redeemTokens The number of cTokens to redeem into underlying\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function redeem(uint256 redeemTokens) external returns (uint256) {\\n return redeemInternal(redeemTokens, false);\\n }\\n\\n /**\\n * @notice Sender redeems cTokens in exchange for a specified amount of underlying asset\\n * @dev Accrues interest whether or not the operation succeeds, unless reverted\\n * @param redeemAmount The amount of underlying to redeem\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256) {\\n return redeemUnderlyingInternal(redeemAmount, false);\\n }\\n\\n /**\\n * @notice Sender borrows assets from the protocol to their own address\\n * @param borrowAmount The amount of the underlying asset to borrow\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function borrow(uint256 borrowAmount) external returns (uint256) {\\n return borrowInternal(borrowAmount, false);\\n }\\n\\n /**\\n * @notice Sender repays their own borrow\\n * @param repayAmount The amount to repay\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function repayBorrow(uint256 repayAmount) external returns (uint256) {\\n (uint256 err, ) = repayBorrowInternal(repayAmount, false);\\n return err;\\n }\\n\\n /**\\n * @notice The sender liquidates the borrowers collateral.\\n * The collateral seized is transferred to the liquidator.\\n * @param borrower The borrower of this cToken to be liquidated\\n * @param repayAmount The amount of the underlying borrowed asset to repay\\n * @param cTokenCollateral The market in which to seize collateral from the borrower\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function liquidateBorrow(\\n address borrower,\\n uint256 repayAmount,\\n CTokenInterface cTokenCollateral\\n ) external returns (uint256) {\\n (uint256 err, ) = liquidateBorrowInternal(borrower, repayAmount, cTokenCollateral, false);\\n return err;\\n }\\n\\n /**\\n * @notice The sender adds to reserves.\\n * @param addAmount The amount fo underlying token to add as reserves\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _addReserves(uint256 addAmount) external returns (uint256) {\\n return _addReservesInternal(addAmount, false);\\n }\\n\\n /*** Safe Token ***/\\n\\n /**\\n * @notice Gets balance of this contract in terms of the underlying\\n * @dev This excludes the value of the current message, if any\\n * @return The quantity of underlying tokens owned by this contract\\n */\\n function getCashPrior() internal view returns (uint256) {\\n EIP20Interface token = EIP20Interface(underlying);\\n return token.balanceOf(address(this));\\n }\\n\\n /**\\n * @dev Similar to EIP20 transfer, except it handles a False result from `transferFrom` and reverts in that case.\\n * This will revert due to insufficient balance or insufficient allowance.\\n * This function returns the actual amount received,\\n * which may be less than `amount` if there is a fee attached to the transfer.\\n *\\n * Note: This wrapper safely handles non-standard ERC-20 tokens that do not return a value.\\n * See here: https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca\\n */\\n function doTransferIn(\\n address from,\\n uint256 amount,\\n bool isNative\\n ) internal returns (uint256) {\\n isNative; // unused\\n\\n EIP20NonStandardInterface token = EIP20NonStandardInterface(underlying);\\n uint256 balanceBefore = EIP20Interface(underlying).balanceOf(address(this));\\n token.transferFrom(from, address(this), amount);\\n\\n bool success;\\n assembly {\\n switch returndatasize()\\n case 0 {\\n // This is a non-standard ERC-20\\n success := not(0) // set success to true\\n }\\n case 32 {\\n // This is a compliant ERC-20\\n returndatacopy(0, 0, 32)\\n success := mload(0) // Set `success = returndata` of external call\\n }\\n default {\\n // This is an excessively non-compliant ERC-20, revert.\\n revert(0, 0)\\n }\\n }\\n require(success, \\\"TOKEN_TRANSFER_IN_FAILED\\\");\\n\\n // Calculate the amount that was *actually* transferred\\n uint256 balanceAfter = EIP20Interface(underlying).balanceOf(address(this));\\n return sub_(balanceAfter, balanceBefore);\\n }\\n\\n /**\\n * @dev Similar to EIP20 transfer, except it handles a False success from `transfer` and returns an explanatory\\n * error code rather than reverting. If caller has not called checked protocol's balance, this may revert due to\\n * insufficient cash held in this contract. If caller has checked protocol's balance prior to this call, and verified\\n * it is >= amount, this should not revert in normal conditions.\\n *\\n * Note: This wrapper safely handles non-standard ERC-20 tokens that do not return a value.\\n * See here: https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca\\n */\\n function doTransferOut(\\n address payable to,\\n uint256 amount,\\n bool isNative\\n ) internal {\\n isNative; // unused\\n\\n EIP20NonStandardInterface token = EIP20NonStandardInterface(underlying);\\n token.transfer(to, amount);\\n\\n bool success;\\n assembly {\\n switch returndatasize()\\n case 0 {\\n // This is a non-standard ERC-20\\n success := not(0) // set success to true\\n }\\n case 32 {\\n // This is a complaint ERC-20\\n returndatacopy(0, 0, 32)\\n success := mload(0) // Set `success = returndata` of external call\\n }\\n default {\\n // This is an excessively non-compliant ERC-20, revert.\\n revert(0, 0)\\n }\\n }\\n require(success, \\\"TOKEN_TRANSFER_OUT_FAILED\\\");\\n }\\n\\n /**\\n * @notice Transfer `tokens` tokens from `src` to `dst` by `spender`\\n * @dev Called by both `transfer` and `transferFrom` internally\\n * @param spender The address of the account performing the transfer\\n * @param src The address of the source account\\n * @param dst The address of the destination account\\n * @param tokens The number of tokens to transfer\\n * @return Whether or not the transfer succeeded\\n */\\n function transferTokens(\\n address spender,\\n address src,\\n address dst,\\n uint256 tokens\\n ) internal returns (uint256) {\\n /* Fail if transfer not allowed */\\n uint256 allowed = comptroller.transferAllowed(address(this), src, dst, tokens);\\n if (allowed != 0) {\\n return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.TRANSFER_COMPTROLLER_REJECTION, allowed);\\n }\\n\\n /* Do not allow self-transfers */\\n if (src == dst) {\\n return fail(Error.BAD_INPUT, FailureInfo.TRANSFER_NOT_ALLOWED);\\n }\\n\\n /* Get the allowance, infinite for the account owner */\\n uint256 startingAllowance = 0;\\n if (spender == src) {\\n startingAllowance = uint256(-1);\\n } else {\\n startingAllowance = transferAllowances[src][spender];\\n }\\n\\n /* Do the calculations, checking for {under,over}flow */\\n accountTokens[src] = sub_(accountTokens[src], tokens);\\n accountTokens[dst] = add_(accountTokens[dst], tokens);\\n\\n /* Eat some of the allowance (if necessary) */\\n if (startingAllowance != uint256(-1)) {\\n transferAllowances[src][spender] = sub_(startingAllowance, tokens);\\n }\\n\\n /* We emit a Transfer event */\\n emit Transfer(src, dst, tokens);\\n\\n // unused function\\n // comptroller.transferVerify(address(this), src, dst, tokens);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Get the account's cToken balances\\n * @param account The address of the account\\n */\\n function getCTokenBalanceInternal(address account) internal view returns (uint256) {\\n return accountTokens[account];\\n }\\n\\n struct MintLocalVars {\\n uint256 exchangeRateMantissa;\\n uint256 mintTokens;\\n uint256 actualMintAmount;\\n }\\n\\n /**\\n * @notice User supplies assets into the market and receives cTokens in exchange\\n * @dev Assumes interest has already been accrued up to the current block\\n * @param minter The address of the account which is supplying the assets\\n * @param mintAmount The amount of the underlying asset to supply\\n * @param isNative The amount is in native or not\\n * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual mint amount.\\n */\\n function mintFresh(\\n address minter,\\n uint256 mintAmount,\\n bool isNative\\n ) internal returns (uint256, uint256) {\\n /* Fail if mint not allowed */\\n uint256 allowed = comptroller.mintAllowed(address(this), minter, mintAmount);\\n if (allowed != 0) {\\n return (failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.MINT_COMPTROLLER_REJECTION, allowed), 0);\\n }\\n\\n /*\\n * Return if mintAmount is zero.\\n * Put behind `mintAllowed` for accuring potential COMP rewards.\\n */\\n if (mintAmount == 0) {\\n return (uint256(Error.NO_ERROR), 0);\\n }\\n\\n /* Verify market's block number equals current block number */\\n if (accrualBlockNumber != getBlockNumber()) {\\n return (fail(Error.MARKET_NOT_FRESH, FailureInfo.MINT_FRESHNESS_CHECK), 0);\\n }\\n\\n MintLocalVars memory vars;\\n\\n vars.exchangeRateMantissa = exchangeRateStoredInternal();\\n\\n /////////////////////////\\n // EFFECTS & INTERACTIONS\\n // (No safe failures beyond this point)\\n\\n /*\\n * We call `doTransferIn` for the minter and the mintAmount.\\n * Note: The cToken must handle variations between ERC-20 and ETH underlying.\\n * `doTransferIn` reverts if anything goes wrong, since we can't be sure if\\n * side-effects occurred. The function returns the amount actually transferred,\\n * in case of a fee. On success, the cToken holds an additional `actualMintAmount`\\n * of cash.\\n */\\n vars.actualMintAmount = doTransferIn(minter, mintAmount, isNative);\\n\\n /*\\n * We get the current exchange rate and calculate the number of cTokens to be minted:\\n * mintTokens = actualMintAmount / exchangeRate\\n */\\n vars.mintTokens = div_ScalarByExpTruncate(vars.actualMintAmount, Exp({mantissa: vars.exchangeRateMantissa}));\\n\\n /*\\n * We calculate the new total supply of cTokens and minter token balance, checking for overflow:\\n * totalSupply = totalSupply + mintTokens\\n * accountTokens[minter] = accountTokens[minter] + mintTokens\\n */\\n totalSupply = add_(totalSupply, vars.mintTokens);\\n accountTokens[minter] = add_(accountTokens[minter], vars.mintTokens);\\n\\n /* We emit a Mint event, and a Transfer event */\\n emit Mint(minter, vars.actualMintAmount, vars.mintTokens);\\n emit Transfer(address(this), minter, vars.mintTokens);\\n\\n /* We call the defense hook */\\n // unused function\\n // comptroller.mintVerify(address(this), minter, vars.actualMintAmount, vars.mintTokens);\\n\\n return (uint256(Error.NO_ERROR), vars.actualMintAmount);\\n }\\n\\n struct RedeemLocalVars {\\n uint256 exchangeRateMantissa;\\n uint256 redeemTokens;\\n uint256 redeemAmount;\\n uint256 totalSupplyNew;\\n uint256 accountTokensNew;\\n }\\n\\n /**\\n * @notice User redeems cTokens in exchange for the underlying asset\\n * @dev Assumes interest has already been accrued up to the current block. Only one of redeemTokensIn or redeemAmountIn may be non-zero and it would do nothing if both are zero.\\n * @param redeemer The address of the account which is redeeming the tokens\\n * @param redeemTokensIn The number of cTokens to redeem into underlying\\n * @param redeemAmountIn The number of underlying tokens to receive from redeeming cTokens\\n * @param isNative The amount is in native or not\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function redeemFresh(\\n address payable redeemer,\\n uint256 redeemTokensIn,\\n uint256 redeemAmountIn,\\n bool isNative\\n ) internal returns (uint256) {\\n require(redeemTokensIn == 0 || redeemAmountIn == 0, \\\"one of redeemTokensIn or redeemAmountIn must be zero\\\");\\n\\n RedeemLocalVars memory vars;\\n\\n /* exchangeRate = invoke Exchange Rate Stored() */\\n vars.exchangeRateMantissa = exchangeRateStoredInternal();\\n\\n /* If redeemTokensIn > 0: */\\n if (redeemTokensIn > 0) {\\n /*\\n * We calculate the exchange rate and the amount of underlying to be redeemed:\\n * redeemTokens = redeemTokensIn\\n * redeemAmount = redeemTokensIn x exchangeRateCurrent\\n */\\n vars.redeemTokens = redeemTokensIn;\\n vars.redeemAmount = mul_ScalarTruncate(Exp({mantissa: vars.exchangeRateMantissa}), redeemTokensIn);\\n } else {\\n /*\\n * We get the current exchange rate and calculate the amount to be redeemed:\\n * redeemTokens = redeemAmountIn / exchangeRate\\n * redeemAmount = redeemAmountIn\\n */\\n vars.redeemTokens = div_ScalarByExpTruncate(redeemAmountIn, Exp({mantissa: vars.exchangeRateMantissa}));\\n vars.redeemAmount = redeemAmountIn;\\n }\\n\\n /* Fail if redeem not allowed */\\n uint256 allowed = comptroller.redeemAllowed(address(this), redeemer, vars.redeemTokens);\\n if (allowed != 0) {\\n return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.REDEEM_COMPTROLLER_REJECTION, allowed);\\n }\\n\\n /*\\n * Return if redeemTokensIn and redeemAmountIn are zero.\\n * Put behind `redeemAllowed` for accuring potential COMP rewards.\\n */\\n if (redeemTokensIn == 0 && redeemAmountIn == 0) {\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /* Verify market's block number equals current block number */\\n if (accrualBlockNumber != getBlockNumber()) {\\n return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDEEM_FRESHNESS_CHECK);\\n }\\n\\n /*\\n * We calculate the new total supply and redeemer balance, checking for underflow:\\n * totalSupplyNew = totalSupply - redeemTokens\\n * accountTokensNew = accountTokens[redeemer] - redeemTokens\\n */\\n vars.totalSupplyNew = sub_(totalSupply, vars.redeemTokens);\\n vars.accountTokensNew = sub_(accountTokens[redeemer], vars.redeemTokens);\\n\\n /* Fail gracefully if protocol has insufficient cash */\\n if (getCashPrior() < vars.redeemAmount) {\\n return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDEEM_TRANSFER_OUT_NOT_POSSIBLE);\\n }\\n\\n /////////////////////////\\n // EFFECTS & INTERACTIONS\\n // (No safe failures beyond this point)\\n\\n /*\\n * We invoke doTransferOut for the redeemer and the redeemAmount.\\n * Note: The cToken must handle variations between ERC-20 and ETH underlying.\\n * On success, the cToken has redeemAmount less of cash.\\n * doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.\\n */\\n doTransferOut(redeemer, vars.redeemAmount, isNative);\\n\\n /* We write previously calculated values into storage */\\n totalSupply = vars.totalSupplyNew;\\n accountTokens[redeemer] = vars.accountTokensNew;\\n\\n /* We emit a Transfer event, and a Redeem event */\\n emit Transfer(redeemer, address(this), vars.redeemTokens);\\n emit Redeem(redeemer, vars.redeemAmount, vars.redeemTokens);\\n\\n /* We call the defense hook */\\n comptroller.redeemVerify(address(this), redeemer, vars.redeemAmount, vars.redeemTokens);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Transfers collateral tokens (this market) to the liquidator.\\n * @dev Called only during an in-kind liquidation, or by liquidateBorrow during the liquidation of another CToken.\\n * Its absolutely critical to use msg.sender as the seizer cToken and not a parameter.\\n * @param seizerToken The contract seizing the collateral (i.e. borrowed cToken)\\n * @param liquidator The account receiving seized collateral\\n * @param borrower The account having collateral seized\\n * @param seizeTokens The number of cTokens to seize\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function seizeInternal(\\n address seizerToken,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) internal returns (uint256) {\\n /* Fail if seize not allowed */\\n uint256 allowed = comptroller.seizeAllowed(address(this), seizerToken, liquidator, borrower, seizeTokens);\\n if (allowed != 0) {\\n return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.LIQUIDATE_SEIZE_COMPTROLLER_REJECTION, allowed);\\n }\\n\\n /*\\n * Return if seizeTokens is zero.\\n * Put behind `seizeAllowed` for accuring potential COMP rewards.\\n */\\n if (seizeTokens == 0) {\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /* Fail if borrower = liquidator */\\n if (borrower == liquidator) {\\n return fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER);\\n }\\n\\n /*\\n * We calculate the new borrower and liquidator token balances, failing on underflow/overflow:\\n * borrowerTokensNew = accountTokens[borrower] - seizeTokens\\n * liquidatorTokensNew = accountTokens[liquidator] + seizeTokens\\n */\\n accountTokens[borrower] = sub_(accountTokens[borrower], seizeTokens);\\n accountTokens[liquidator] = add_(accountTokens[liquidator], seizeTokens);\\n\\n /* Emit a Transfer event */\\n emit Transfer(borrower, liquidator, seizeTokens);\\n\\n /* We call the defense hook */\\n // unused function\\n // comptroller.seizeVerify(address(this), seizerToken, liquidator, borrower, seizeTokens);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n}\\n\",\"keccak256\":\"0x210d4b418f25e7997f087b70dd74ca6b5ffe4947055432c2df3d309fdf04d49f\"},\"contracts/CToken.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\nimport \\\"./ComptrollerInterface.sol\\\";\\nimport \\\"./CTokenInterfaces.sol\\\";\\nimport \\\"./ErrorReporter.sol\\\";\\nimport \\\"./Exponential.sol\\\";\\nimport \\\"./EIP20Interface.sol\\\";\\nimport \\\"./EIP20NonStandardInterface.sol\\\";\\nimport \\\"./InterestRateModel.sol\\\";\\n\\n/**\\n * @title Compound's CToken Contract\\n * @notice Abstract base for CTokens\\n * @author Compound\\n */\\ncontract CToken is CTokenInterface, Exponential, TokenErrorReporter {\\n /**\\n * @notice Initialize the money market\\n * @param comptroller_ The address of the Comptroller\\n * @param interestRateModel_ The address of the interest rate model\\n * @param initialExchangeRateMantissa_ The initial exchange rate, scaled by 1e18\\n * @param name_ EIP-20 name of this token\\n * @param symbol_ EIP-20 symbol of this token\\n * @param decimals_ EIP-20 decimal precision of this token\\n */\\n function initialize(\\n ComptrollerInterface comptroller_,\\n InterestRateModel interestRateModel_,\\n uint256 initialExchangeRateMantissa_,\\n string memory name_,\\n string memory symbol_,\\n uint8 decimals_\\n ) public {\\n require(msg.sender == admin, \\\"only admin may initialize the market\\\");\\n require(accrualBlockNumber == 0 && borrowIndex == 0, \\\"market may only be initialized once\\\");\\n\\n // Set initial exchange rate\\n initialExchangeRateMantissa = initialExchangeRateMantissa_;\\n require(initialExchangeRateMantissa > 0, \\\"initial exchange rate must be greater than zero.\\\");\\n\\n // Set the comptroller\\n uint256 err = _setComptroller(comptroller_);\\n require(err == uint256(Error.NO_ERROR), \\\"setting comptroller failed\\\");\\n\\n // Initialize block number and borrow index (block number mocks depend on comptroller being set)\\n accrualBlockNumber = getBlockNumber();\\n borrowIndex = mantissaOne;\\n\\n // Set the interest rate model (depends on block number / borrow index)\\n err = _setInterestRateModelFresh(interestRateModel_);\\n require(err == uint256(Error.NO_ERROR), \\\"setting interest rate model failed\\\");\\n\\n name = name_;\\n symbol = symbol_;\\n decimals = decimals_;\\n\\n // The counter starts true to prevent changing it from zero to non-zero (i.e. smaller cost/refund)\\n _notEntered = true;\\n }\\n\\n /**\\n * @notice Transfer `amount` tokens from `msg.sender` to `dst`\\n * @param dst The address of the destination account\\n * @param amount The number of tokens to transfer\\n * @return Whether or not the transfer succeeded\\n */\\n function transfer(address dst, uint256 amount) external nonReentrant returns (bool) {\\n return transferTokens(msg.sender, msg.sender, dst, amount) == uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Transfer `amount` tokens from `src` to `dst`\\n * @param src The address of the source account\\n * @param dst The address of the destination account\\n * @param amount The number of tokens to transfer\\n * @return Whether or not the transfer succeeded\\n */\\n function transferFrom(\\n address src,\\n address dst,\\n uint256 amount\\n ) external nonReentrant returns (bool) {\\n return transferTokens(msg.sender, src, dst, amount) == uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Approve `spender` to transfer up to `amount` from `src`\\n * @dev This will overwrite the approval amount for `spender`\\n * and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)\\n * @param spender The address of the account which may transfer tokens\\n * @param amount The number of tokens that are approved (-1 means infinite)\\n * @return Whether or not the approval succeeded\\n */\\n function approve(address spender, uint256 amount) external returns (bool) {\\n address src = msg.sender;\\n transferAllowances[src][spender] = amount;\\n emit Approval(src, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @notice Get the current allowance from `owner` for `spender`\\n * @param owner The address of the account which owns the tokens to be spent\\n * @param spender The address of the account which may transfer tokens\\n * @return The number of tokens allowed to be spent (-1 means infinite)\\n */\\n function allowance(address owner, address spender) external view returns (uint256) {\\n return transferAllowances[owner][spender];\\n }\\n\\n /**\\n * @notice Get the token balance of the `owner`\\n * @param owner The address of the account to query\\n * @return The number of tokens owned by `owner`\\n */\\n function balanceOf(address owner) external view returns (uint256) {\\n return accountTokens[owner];\\n }\\n\\n /**\\n * @notice Get the underlying balance of the `owner`\\n * @dev This also accrues interest in a transaction\\n * @param owner The address of the account to query\\n * @return The amount of underlying owned by `owner`\\n */\\n function balanceOfUnderlying(address owner) external returns (uint256) {\\n Exp memory exchangeRate = Exp({mantissa: exchangeRateCurrent()});\\n return mul_ScalarTruncate(exchangeRate, accountTokens[owner]);\\n }\\n\\n /**\\n * @notice Get a snapshot of the account's balances, and the cached exchange rate\\n * @dev This is used by comptroller to more efficiently perform liquidity checks.\\n * @param account Address of the account to snapshot\\n * @return (possible error, token balance, borrow balance, exchange rate mantissa)\\n */\\n function getAccountSnapshot(address account)\\n external\\n view\\n returns (\\n uint256,\\n uint256,\\n uint256,\\n uint256\\n )\\n {\\n uint256 cTokenBalance = getCTokenBalanceInternal(account);\\n uint256 borrowBalance = borrowBalanceStoredInternal(account);\\n uint256 exchangeRateMantissa = exchangeRateStoredInternal();\\n\\n return (uint256(Error.NO_ERROR), cTokenBalance, borrowBalance, exchangeRateMantissa);\\n }\\n\\n /**\\n * @dev Function to simply retrieve block number\\n * This exists mainly for inheriting test contracts to stub this result.\\n */\\n function getBlockNumber() internal view returns (uint256) {\\n return block.timestamp;\\n }\\n\\n /**\\n * @notice Returns the current per-block borrow interest rate for this cToken\\n * @return The borrow interest rate per block, scaled by 1e18\\n */\\n function borrowRatePerBlock() external view returns (uint256) {\\n return interestRateModel.getBorrowRate(getCashPrior(), totalBorrows, totalReserves);\\n }\\n\\n /**\\n * @notice Returns the current per-block supply interest rate for this cToken\\n * @return The supply interest rate per block, scaled by 1e18\\n */\\n function supplyRatePerBlock() external view returns (uint256) {\\n return interestRateModel.getSupplyRate(getCashPrior(), totalBorrows, totalReserves, reserveFactorMantissa);\\n }\\n\\n /**\\n * @notice Returns the estimated per-block borrow interest rate for this cToken after some change\\n * @return The borrow interest rate per block, scaled by 1e18\\n */\\n function estimateBorrowRatePerBlockAfterChange(uint256 change, bool repay) external view returns (uint256) {\\n uint256 cashPriorNew;\\n uint256 totalBorrowsNew;\\n\\n if (repay) {\\n cashPriorNew = add_(getCashPrior(), change);\\n totalBorrowsNew = sub_(totalBorrows, change);\\n } else {\\n cashPriorNew = sub_(getCashPrior(), change);\\n totalBorrowsNew = add_(totalBorrows, change);\\n }\\n return interestRateModel.getBorrowRate(cashPriorNew, totalBorrowsNew, totalReserves);\\n }\\n\\n /**\\n * @notice Returns the estimated per-block supply interest rate for this cToken after some change\\n * @return The supply interest rate per block, scaled by 1e18\\n */\\n function estimateSupplyRatePerBlockAfterChange(uint256 change, bool repay) external view returns (uint256) {\\n uint256 cashPriorNew;\\n uint256 totalBorrowsNew;\\n\\n if (repay) {\\n cashPriorNew = add_(getCashPrior(), change);\\n totalBorrowsNew = sub_(totalBorrows, change);\\n } else {\\n cashPriorNew = sub_(getCashPrior(), change);\\n totalBorrowsNew = add_(totalBorrows, change);\\n }\\n\\n return interestRateModel.getSupplyRate(cashPriorNew, totalBorrowsNew, totalReserves, reserveFactorMantissa);\\n }\\n\\n /**\\n * @notice Returns the current total borrows plus accrued interest\\n * @return The total borrows with interest\\n */\\n function totalBorrowsCurrent() external nonReentrant returns (uint256) {\\n require(accrueInterest() == uint256(Error.NO_ERROR), \\\"accrue interest failed\\\");\\n return totalBorrows;\\n }\\n\\n /**\\n * @notice Accrue interest to updated borrowIndex and then calculate account's borrow balance using the updated borrowIndex\\n * @param account The address whose balance should be calculated after updating borrowIndex\\n * @return The calculated balance\\n */\\n function borrowBalanceCurrent(address account) external nonReentrant returns (uint256) {\\n require(accrueInterest() == uint256(Error.NO_ERROR), \\\"accrue interest failed\\\");\\n return borrowBalanceStored(account);\\n }\\n\\n /**\\n * @notice Return the borrow balance of account based on stored data\\n * @param account The address whose balance should be calculated\\n * @return The calculated balance\\n */\\n function borrowBalanceStored(address account) public view returns (uint256) {\\n return borrowBalanceStoredInternal(account);\\n }\\n\\n /**\\n * @notice Return the borrow balance of account based on stored data\\n * @param account The address whose balance should be calculated\\n * @return the calculated balance or 0 if error code is non-zero\\n */\\n function borrowBalanceStoredInternal(address account) internal view returns (uint256) {\\n /* Get borrowBalance and borrowIndex */\\n BorrowSnapshot storage borrowSnapshot = accountBorrows[account];\\n\\n /* If borrowBalance = 0 then borrowIndex is likely also 0.\\n * Rather than failing the calculation with a division by 0, we immediately return 0 in this case.\\n */\\n if (borrowSnapshot.principal == 0) {\\n return 0;\\n }\\n\\n /* Calculate new borrow balance using the interest index:\\n * recentBorrowBalance = borrower.borrowBalance * market.borrowIndex / borrower.borrowIndex\\n */\\n uint256 principalTimesIndex = mul_(borrowSnapshot.principal, borrowIndex);\\n uint256 result = div_(principalTimesIndex, borrowSnapshot.interestIndex);\\n return result;\\n }\\n\\n /**\\n * @notice Accrue interest then return the up-to-date exchange rate\\n * @return Calculated exchange rate scaled by 1e18\\n */\\n function exchangeRateCurrent() public nonReentrant returns (uint256) {\\n require(accrueInterest() == uint256(Error.NO_ERROR), \\\"accrue interest failed\\\");\\n return exchangeRateStored();\\n }\\n\\n /**\\n * @notice Calculates the exchange rate from the underlying to the CToken\\n * @dev This function does not accrue interest before calculating the exchange rate\\n * @return Calculated exchange rate scaled by 1e18\\n */\\n function exchangeRateStored() public view returns (uint256) {\\n return exchangeRateStoredInternal();\\n }\\n\\n /**\\n * @notice Calculates the exchange rate from the underlying to the CToken\\n * @dev This function does not accrue interest before calculating the exchange rate\\n * @return calculated exchange rate scaled by 1e18\\n */\\n function exchangeRateStoredInternal() internal view returns (uint256) {\\n uint256 _totalSupply = totalSupply;\\n if (_totalSupply == 0) {\\n /*\\n * If there are no tokens minted:\\n * exchangeRate = initialExchangeRate\\n */\\n return initialExchangeRateMantissa;\\n } else {\\n /*\\n * Otherwise:\\n * exchangeRate = (totalCash + totalBorrows - totalReserves) / totalSupply\\n */\\n uint256 totalCash = getCashPrior();\\n uint256 cashPlusBorrowsMinusReserves = sub_(add_(totalCash, totalBorrows), totalReserves);\\n uint256 exchangeRate = div_(cashPlusBorrowsMinusReserves, Exp({mantissa: _totalSupply}));\\n return exchangeRate;\\n }\\n }\\n\\n /**\\n * @notice Get cash balance of this cToken in the underlying asset\\n * @return The quantity of underlying asset owned by this contract\\n */\\n function getCash() external view returns (uint256) {\\n return getCashPrior();\\n }\\n\\n /**\\n * @notice Applies accrued interest to total borrows and reserves\\n * @dev This calculates interest accrued from the last checkpointed block\\n * up to the current block and writes new checkpoint to storage.\\n */\\n function accrueInterest() public returns (uint256) {\\n /* Remember the initial block number */\\n uint256 currentBlockNumber = getBlockNumber();\\n uint256 accrualBlockNumberPrior = accrualBlockNumber;\\n\\n /* Short-circuit accumulating 0 interest */\\n if (accrualBlockNumberPrior == currentBlockNumber) {\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /* Read the previous values out of storage */\\n uint256 cashPrior = getCashPrior();\\n uint256 borrowsPrior = totalBorrows;\\n uint256 reservesPrior = totalReserves;\\n uint256 borrowIndexPrior = borrowIndex;\\n\\n /* Calculate the current borrow interest rate */\\n uint256 borrowRateMantissa = interestRateModel.getBorrowRate(cashPrior, borrowsPrior, reservesPrior);\\n require(borrowRateMantissa <= borrowRateMaxMantissa, \\\"borrow rate is absurdly high\\\");\\n\\n /* Calculate the number of blocks elapsed since the last accrual */\\n uint256 blockDelta = sub_(currentBlockNumber, accrualBlockNumberPrior);\\n\\n /*\\n * Calculate the interest accumulated into borrows and reserves and the new index:\\n * simpleInterestFactor = borrowRate * blockDelta\\n * interestAccumulated = simpleInterestFactor * totalBorrows\\n * totalBorrowsNew = interestAccumulated + totalBorrows\\n * totalReservesNew = interestAccumulated * reserveFactor + totalReserves\\n * borrowIndexNew = simpleInterestFactor * borrowIndex + borrowIndex\\n */\\n\\n Exp memory simpleInterestFactor = mul_(Exp({mantissa: borrowRateMantissa}), blockDelta);\\n uint256 interestAccumulated = mul_ScalarTruncate(simpleInterestFactor, borrowsPrior);\\n uint256 totalBorrowsNew = add_(interestAccumulated, borrowsPrior);\\n uint256 totalReservesNew = mul_ScalarTruncateAddUInt(\\n Exp({mantissa: reserveFactorMantissa}),\\n interestAccumulated,\\n reservesPrior\\n );\\n uint256 borrowIndexNew = mul_ScalarTruncateAddUInt(simpleInterestFactor, borrowIndexPrior, borrowIndexPrior);\\n\\n /////////////////////////\\n // EFFECTS & INTERACTIONS\\n // (No safe failures beyond this point)\\n\\n /* We write the previously calculated values into storage */\\n accrualBlockNumber = currentBlockNumber;\\n borrowIndex = borrowIndexNew;\\n totalBorrows = totalBorrowsNew;\\n totalReserves = totalReservesNew;\\n\\n /* We emit an AccrueInterest event */\\n emit AccrueInterest(cashPrior, interestAccumulated, borrowIndexNew, totalBorrowsNew);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Sender supplies assets into the market and receives cTokens in exchange\\n * @dev Accrues interest whether or not the operation succeeds, unless reverted\\n * @param mintAmount The amount of the underlying asset to supply\\n * @param isNative The amount is in native or not\\n * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual mint amount.\\n */\\n function mintInternal(uint256 mintAmount, bool isNative) internal nonReentrant returns (uint256, uint256) {\\n uint256 error = accrueInterest();\\n if (error != uint256(Error.NO_ERROR)) {\\n // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed\\n return (fail(Error(error), FailureInfo.MINT_ACCRUE_INTEREST_FAILED), 0);\\n }\\n // mintFresh emits the actual Mint event if successful and logs on errors, so we don't need to\\n return mintFresh(msg.sender, mintAmount, isNative);\\n }\\n\\n /**\\n * @notice Sender redeems cTokens in exchange for the underlying asset\\n * @dev Accrues interest whether or not the operation succeeds, unless reverted\\n * @param redeemTokens The number of cTokens to redeem into underlying\\n * @param isNative The amount is in native or not\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function redeemInternal(uint256 redeemTokens, bool isNative) internal nonReentrant returns (uint256) {\\n uint256 error = accrueInterest();\\n if (error != uint256(Error.NO_ERROR)) {\\n // accrueInterest emits logs on errors, but we still want to log the fact that an attempted redeem failed\\n return fail(Error(error), FailureInfo.REDEEM_ACCRUE_INTEREST_FAILED);\\n }\\n // redeemFresh emits redeem-specific logs on errors, so we don't need to\\n return redeemFresh(msg.sender, redeemTokens, 0, isNative);\\n }\\n\\n /**\\n * @notice Sender redeems cTokens in exchange for a specified amount of underlying asset\\n * @dev Accrues interest whether or not the operation succeeds, unless reverted\\n * @param redeemAmount The amount of underlying to receive from redeeming cTokens\\n * @param isNative The amount is in native or not\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function redeemUnderlyingInternal(uint256 redeemAmount, bool isNative) internal nonReentrant returns (uint256) {\\n uint256 error = accrueInterest();\\n if (error != uint256(Error.NO_ERROR)) {\\n // accrueInterest emits logs on errors, but we still want to log the fact that an attempted redeem failed\\n return fail(Error(error), FailureInfo.REDEEM_ACCRUE_INTEREST_FAILED);\\n }\\n // redeemFresh emits redeem-specific logs on errors, so we don't need to\\n return redeemFresh(msg.sender, 0, redeemAmount, isNative);\\n }\\n\\n /**\\n * @notice Sender borrows assets from the protocol to their own address\\n * @param borrowAmount The amount of the underlying asset to borrow\\n * @param isNative The amount is in native or not\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function borrowInternal(uint256 borrowAmount, bool isNative) internal nonReentrant returns (uint256) {\\n uint256 error = accrueInterest();\\n if (error != uint256(Error.NO_ERROR)) {\\n // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed\\n return fail(Error(error), FailureInfo.BORROW_ACCRUE_INTEREST_FAILED);\\n }\\n // borrowFresh emits borrow-specific logs on errors, so we don't need to\\n return borrowFresh(msg.sender, borrowAmount, isNative);\\n }\\n\\n struct BorrowLocalVars {\\n MathError mathErr;\\n uint256 accountBorrows;\\n uint256 accountBorrowsNew;\\n uint256 totalBorrowsNew;\\n }\\n\\n /**\\n * @notice Users borrow assets from the protocol to their own address\\n * @param borrowAmount The amount of the underlying asset to borrow\\n * @param isNative The amount is in native or not\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function borrowFresh(\\n address payable borrower,\\n uint256 borrowAmount,\\n bool isNative\\n ) internal returns (uint256) {\\n /* Fail if borrow not allowed */\\n uint256 allowed = comptroller.borrowAllowed(address(this), borrower, borrowAmount);\\n if (allowed != 0) {\\n return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.BORROW_COMPTROLLER_REJECTION, allowed);\\n }\\n\\n /*\\n * Return if borrowAmount is zero.\\n * Put behind `borrowAllowed` for accuring potential COMP rewards.\\n */\\n if (borrowAmount == 0) {\\n accountBorrows[borrower].interestIndex = borrowIndex;\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /* Verify market's block number equals current block number */\\n if (accrualBlockNumber != getBlockNumber()) {\\n return fail(Error.MARKET_NOT_FRESH, FailureInfo.BORROW_FRESHNESS_CHECK);\\n }\\n\\n /* Fail gracefully if protocol has insufficient underlying cash */\\n if (getCashPrior() < borrowAmount) {\\n return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.BORROW_CASH_NOT_AVAILABLE);\\n }\\n\\n BorrowLocalVars memory vars;\\n\\n /*\\n * We calculate the new borrower and total borrow balances, failing on overflow:\\n * accountBorrowsNew = accountBorrows + borrowAmount\\n * totalBorrowsNew = totalBorrows + borrowAmount\\n */\\n vars.accountBorrows = borrowBalanceStoredInternal(borrower);\\n vars.accountBorrowsNew = add_(vars.accountBorrows, borrowAmount);\\n vars.totalBorrowsNew = add_(totalBorrows, borrowAmount);\\n\\n /////////////////////////\\n // EFFECTS & INTERACTIONS\\n // (No safe failures beyond this point)\\n\\n /*\\n * We invoke doTransferOut for the borrower and the borrowAmount.\\n * Note: The cToken must handle variations between ERC-20 and ETH underlying.\\n * On success, the cToken borrowAmount less of cash.\\n * doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.\\n */\\n doTransferOut(borrower, borrowAmount, isNative);\\n\\n /* We write the previously calculated values into storage */\\n accountBorrows[borrower].principal = vars.accountBorrowsNew;\\n accountBorrows[borrower].interestIndex = borrowIndex;\\n totalBorrows = vars.totalBorrowsNew;\\n\\n /* We emit a Borrow event */\\n emit Borrow(borrower, borrowAmount, vars.accountBorrowsNew, vars.totalBorrowsNew);\\n\\n /* We call the defense hook */\\n // unused function\\n // comptroller.borrowVerify(address(this), borrower, borrowAmount);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Sender repays their own borrow\\n * @param repayAmount The amount to repay\\n * @param isNative The amount is in native or not\\n * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount.\\n */\\n function repayBorrowInternal(uint256 repayAmount, bool isNative) internal nonReentrant returns (uint256, uint256) {\\n uint256 error = accrueInterest();\\n if (error != uint256(Error.NO_ERROR)) {\\n // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed\\n return (fail(Error(error), FailureInfo.REPAY_BORROW_ACCRUE_INTEREST_FAILED), 0);\\n }\\n // repayBorrowFresh emits repay-borrow-specific logs on errors, so we don't need to\\n return repayBorrowFresh(msg.sender, msg.sender, repayAmount, isNative);\\n }\\n\\n struct RepayBorrowLocalVars {\\n Error err;\\n MathError mathErr;\\n uint256 repayAmount;\\n uint256 borrowerIndex;\\n uint256 accountBorrows;\\n uint256 accountBorrowsNew;\\n uint256 totalBorrowsNew;\\n uint256 actualRepayAmount;\\n }\\n\\n /**\\n * @notice Borrows are repaid by another user (possibly the borrower).\\n * @param payer the account paying off the borrow\\n * @param borrower the account with the debt being payed off\\n * @param repayAmount the amount of undelrying tokens being returned\\n * @param isNative The amount is in native or not\\n * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount.\\n */\\n function repayBorrowFresh(\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n bool isNative\\n ) internal returns (uint256, uint256) {\\n /* Fail if repayBorrow not allowed */\\n uint256 allowed = comptroller.repayBorrowAllowed(address(this), payer, borrower, repayAmount);\\n if (allowed != 0) {\\n return (\\n failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.REPAY_BORROW_COMPTROLLER_REJECTION, allowed),\\n 0\\n );\\n }\\n\\n /*\\n * Return if repayAmount is zero.\\n * Put behind `repayBorrowAllowed` for accuring potential COMP rewards.\\n */\\n if (repayAmount == 0) {\\n accountBorrows[borrower].interestIndex = borrowIndex;\\n return (uint256(Error.NO_ERROR), 0);\\n }\\n\\n /* Verify market's block number equals current block number */\\n if (accrualBlockNumber != getBlockNumber()) {\\n return (fail(Error.MARKET_NOT_FRESH, FailureInfo.REPAY_BORROW_FRESHNESS_CHECK), 0);\\n }\\n\\n RepayBorrowLocalVars memory vars;\\n\\n /* We remember the original borrowerIndex for verification purposes */\\n vars.borrowerIndex = accountBorrows[borrower].interestIndex;\\n\\n /* We fetch the amount the borrower owes, with accumulated interest */\\n vars.accountBorrows = borrowBalanceStoredInternal(borrower);\\n\\n /* If repayAmount == -1, repayAmount = accountBorrows */\\n if (repayAmount == uint256(-1)) {\\n vars.repayAmount = vars.accountBorrows;\\n } else {\\n vars.repayAmount = repayAmount;\\n }\\n\\n /////////////////////////\\n // EFFECTS & INTERACTIONS\\n // (No safe failures beyond this point)\\n\\n /*\\n * We call doTransferIn for the payer and the repayAmount\\n * Note: The cToken must handle variations between ERC-20 and ETH underlying.\\n * On success, the cToken holds an additional repayAmount of cash.\\n * doTransferIn reverts if anything goes wrong, since we can't be sure if side effects occurred.\\n * it returns the amount actually transferred, in case of a fee.\\n */\\n vars.actualRepayAmount = doTransferIn(payer, vars.repayAmount, isNative);\\n\\n /*\\n * We calculate the new borrower and total borrow balances, failing on underflow:\\n * accountBorrowsNew = accountBorrows - actualRepayAmount\\n * totalBorrowsNew = totalBorrows - actualRepayAmount\\n */\\n vars.accountBorrowsNew = sub_(vars.accountBorrows, vars.actualRepayAmount);\\n vars.totalBorrowsNew = sub_(totalBorrows, vars.actualRepayAmount);\\n\\n /* We write the previously calculated values into storage */\\n accountBorrows[borrower].principal = vars.accountBorrowsNew;\\n accountBorrows[borrower].interestIndex = borrowIndex;\\n totalBorrows = vars.totalBorrowsNew;\\n\\n /* We emit a RepayBorrow event */\\n emit RepayBorrow(payer, borrower, vars.actualRepayAmount, vars.accountBorrowsNew, vars.totalBorrowsNew);\\n\\n /* We call the defense hook */\\n // unused function\\n // comptroller.repayBorrowVerify(address(this), payer, borrower, vars.actualRepayAmount, vars.borrowerIndex);\\n\\n return (uint256(Error.NO_ERROR), vars.actualRepayAmount);\\n }\\n\\n /**\\n * @notice The sender liquidates the borrowers collateral.\\n * The collateral seized is transferred to the liquidator.\\n * @param borrower The borrower of this cToken to be liquidated\\n * @param repayAmount The amount of the underlying borrowed asset to repay\\n * @param cTokenCollateral The market in which to seize collateral from the borrower\\n * @param isNative The amount is in native or not\\n * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount.\\n */\\n function liquidateBorrowInternal(\\n address borrower,\\n uint256 repayAmount,\\n CTokenInterface cTokenCollateral,\\n bool isNative\\n ) internal nonReentrant returns (uint256, uint256) {\\n uint256 error = accrueInterest();\\n if (error != uint256(Error.NO_ERROR)) {\\n // accrueInterest emits logs on errors, but we still want to log the fact that an attempted liquidation failed\\n return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_BORROW_INTEREST_FAILED), 0);\\n }\\n\\n error = cTokenCollateral.accrueInterest();\\n if (error != uint256(Error.NO_ERROR)) {\\n // accrueInterest emits logs on errors, but we still want to log the fact that an attempted liquidation failed\\n return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_COLLATERAL_INTEREST_FAILED), 0);\\n }\\n\\n // liquidateBorrowFresh emits borrow-specific logs on errors, so we don't need to\\n return liquidateBorrowFresh(msg.sender, borrower, repayAmount, cTokenCollateral, isNative);\\n }\\n\\n /**\\n * @notice The liquidator liquidates the borrowers collateral.\\n * The collateral seized is transferred to the liquidator.\\n * @param borrower The borrower of this cToken to be liquidated\\n * @param liquidator The address repaying the borrow and seizing collateral\\n * @param cTokenCollateral The market in which to seize collateral from the borrower\\n * @param repayAmount The amount of the underlying borrowed asset to repay\\n * @param isNative The amount is in native or not\\n * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount.\\n */\\n function liquidateBorrowFresh(\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n CTokenInterface cTokenCollateral,\\n bool isNative\\n ) internal returns (uint256, uint256) {\\n /* Fail if liquidate not allowed */\\n uint256 allowed = comptroller.liquidateBorrowAllowed(\\n address(this),\\n address(cTokenCollateral),\\n liquidator,\\n borrower,\\n repayAmount\\n );\\n if (allowed != 0) {\\n return (failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.LIQUIDATE_COMPTROLLER_REJECTION, allowed), 0);\\n }\\n\\n /* Verify market's block number equals current block number */\\n if (accrualBlockNumber != getBlockNumber()) {\\n return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_FRESHNESS_CHECK), 0);\\n }\\n\\n /* Verify cTokenCollateral market's block number equals current block number */\\n if (cTokenCollateral.accrualBlockNumber() != getBlockNumber()) {\\n return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_COLLATERAL_FRESHNESS_CHECK), 0);\\n }\\n\\n /* Fail if borrower = liquidator */\\n if (borrower == liquidator) {\\n return (fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_LIQUIDATOR_IS_BORROWER), 0);\\n }\\n\\n /* Fail if repayAmount = 0 */\\n if (repayAmount == 0) {\\n return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_ZERO), 0);\\n }\\n\\n /* Fail if repayAmount = -1 */\\n if (repayAmount == uint256(-1)) {\\n return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX), 0);\\n }\\n\\n /* Fail if repayBorrow fails */\\n (uint256 repayBorrowError, uint256 actualRepayAmount) = repayBorrowFresh(\\n liquidator,\\n borrower,\\n repayAmount,\\n isNative\\n );\\n if (repayBorrowError != uint256(Error.NO_ERROR)) {\\n return (fail(Error(repayBorrowError), FailureInfo.LIQUIDATE_REPAY_BORROW_FRESH_FAILED), 0);\\n }\\n\\n /////////////////////////\\n // EFFECTS & INTERACTIONS\\n // (No safe failures beyond this point)\\n\\n /* We calculate the number of collateral tokens that will be seized */\\n (uint256 amountSeizeError, uint256 seizeTokens) = comptroller.liquidateCalculateSeizeTokens(\\n address(this),\\n address(cTokenCollateral),\\n actualRepayAmount\\n );\\n require(amountSeizeError == uint256(Error.NO_ERROR), \\\"LIQUIDATE_COMPTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED\\\");\\n\\n /* Revert if borrower collateral token balance < seizeTokens */\\n require(cTokenCollateral.balanceOf(borrower) >= seizeTokens, \\\"LIQUIDATE_SEIZE_TOO_MUCH\\\");\\n\\n // If this is also the collateral, run seizeInternal to avoid re-entrancy, otherwise make an external call\\n uint256 seizeError;\\n if (address(cTokenCollateral) == address(this)) {\\n seizeError = seizeInternal(address(this), liquidator, borrower, seizeTokens);\\n } else {\\n seizeError = cTokenCollateral.seize(liquidator, borrower, seizeTokens);\\n }\\n\\n /* Revert if seize tokens fails (since we cannot be sure of side effects) */\\n require(seizeError == uint256(Error.NO_ERROR), \\\"token seizure failed\\\");\\n\\n /* We emit a LiquidateBorrow event */\\n emit LiquidateBorrow(liquidator, borrower, actualRepayAmount, address(cTokenCollateral), seizeTokens);\\n\\n /* We call the defense hook */\\n // unused function\\n // comptroller.liquidateBorrowVerify(address(this), address(cTokenCollateral), liquidator, borrower, actualRepayAmount, seizeTokens);\\n\\n return (uint256(Error.NO_ERROR), actualRepayAmount);\\n }\\n\\n /**\\n * @notice Transfers collateral tokens (this market) to the liquidator.\\n * @dev Will fail unless called by another cToken during the process of liquidation.\\n * Its absolutely critical to use msg.sender as the borrowed cToken and not a parameter.\\n * @param liquidator The account receiving seized collateral\\n * @param borrower The account having collateral seized\\n * @param seizeTokens The number of cTokens to seize\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function seize(\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external nonReentrant returns (uint256) {\\n return seizeInternal(msg.sender, liquidator, borrower, seizeTokens);\\n }\\n\\n /*** Admin Functions ***/\\n\\n /**\\n * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\\n * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\\n * @param newPendingAdmin New pending admin.\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _setPendingAdmin(address payable newPendingAdmin) external returns (uint256) {\\n // Check caller = admin\\n if (msg.sender != admin) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_ADMIN_OWNER_CHECK);\\n }\\n\\n // Save current value, if any, for inclusion in log\\n address oldPendingAdmin = pendingAdmin;\\n\\n // Store pendingAdmin with value newPendingAdmin\\n pendingAdmin = newPendingAdmin;\\n\\n // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin)\\n emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin\\n * @dev Admin function for pending admin to accept role and update admin\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _acceptAdmin() external returns (uint256) {\\n // Check caller is pendingAdmin and pendingAdmin \\u2260 address(0)\\n if (msg.sender != pendingAdmin || msg.sender == address(0)) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_ADMIN_PENDING_ADMIN_CHECK);\\n }\\n\\n // Save current values for inclusion in log\\n address oldAdmin = admin;\\n address oldPendingAdmin = pendingAdmin;\\n\\n // Store admin with value pendingAdmin\\n admin = pendingAdmin;\\n\\n // Clear the pending value\\n pendingAdmin = address(0);\\n\\n emit NewAdmin(oldAdmin, admin);\\n emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Sets a new comptroller for the market\\n * @dev Admin function to set a new comptroller\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _setComptroller(ComptrollerInterface newComptroller) public returns (uint256) {\\n // Check caller is admin\\n if (msg.sender != admin) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.SET_COMPTROLLER_OWNER_CHECK);\\n }\\n\\n ComptrollerInterface oldComptroller = comptroller;\\n // Ensure invoke comptroller.isComptroller() returns true\\n require(newComptroller.isComptroller(), \\\"marker method returned false\\\");\\n\\n // Set market's comptroller to newComptroller\\n comptroller = newComptroller;\\n\\n // Emit NewComptroller(oldComptroller, newComptroller)\\n emit NewComptroller(oldComptroller, newComptroller);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice accrues interest and sets a new reserve factor for the protocol using _setReserveFactorFresh\\n * @dev Admin function to accrue interest and set a new reserve factor\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _setReserveFactor(uint256 newReserveFactorMantissa) external nonReentrant returns (uint256) {\\n uint256 error = accrueInterest();\\n if (error != uint256(Error.NO_ERROR)) {\\n // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted reserve factor change failed.\\n return fail(Error(error), FailureInfo.SET_RESERVE_FACTOR_ACCRUE_INTEREST_FAILED);\\n }\\n // _setReserveFactorFresh emits reserve-factor-specific logs on errors, so we don't need to.\\n return _setReserveFactorFresh(newReserveFactorMantissa);\\n }\\n\\n /**\\n * @notice Sets a new reserve factor for the protocol (*requires fresh interest accrual)\\n * @dev Admin function to set a new reserve factor\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _setReserveFactorFresh(uint256 newReserveFactorMantissa) internal returns (uint256) {\\n // Check caller is admin\\n if (msg.sender != admin) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.SET_RESERVE_FACTOR_ADMIN_CHECK);\\n }\\n\\n // Verify market's block number equals current block number\\n if (accrualBlockNumber != getBlockNumber()) {\\n return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_RESERVE_FACTOR_FRESH_CHECK);\\n }\\n\\n // Check newReserveFactor \\u2264 maxReserveFactor\\n if (newReserveFactorMantissa > reserveFactorMaxMantissa) {\\n return fail(Error.BAD_INPUT, FailureInfo.SET_RESERVE_FACTOR_BOUNDS_CHECK);\\n }\\n\\n uint256 oldReserveFactorMantissa = reserveFactorMantissa;\\n reserveFactorMantissa = newReserveFactorMantissa;\\n\\n emit NewReserveFactor(oldReserveFactorMantissa, newReserveFactorMantissa);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Accrues interest and reduces reserves by transferring from msg.sender\\n * @param addAmount Amount of addition to reserves\\n * @param isNative The amount is in native or not\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _addReservesInternal(uint256 addAmount, bool isNative) internal nonReentrant returns (uint256) {\\n uint256 error = accrueInterest();\\n if (error != uint256(Error.NO_ERROR)) {\\n // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted reduce reserves failed.\\n return fail(Error(error), FailureInfo.ADD_RESERVES_ACCRUE_INTEREST_FAILED);\\n }\\n\\n // _addReservesFresh emits reserve-addition-specific logs on errors, so we don't need to.\\n (error, ) = _addReservesFresh(addAmount, isNative);\\n return error;\\n }\\n\\n /**\\n * @notice Add reserves by transferring from caller\\n * @dev Requires fresh interest accrual\\n * @param addAmount Amount of addition to reserves\\n * @param isNative The amount is in native or not\\n * @return (uint, uint) An error code (0=success, otherwise a failure (see ErrorReporter.sol for details)) and the actual amount added, net token fees\\n */\\n function _addReservesFresh(uint256 addAmount, bool isNative) internal returns (uint256, uint256) {\\n // totalReserves + actualAddAmount\\n uint256 totalReservesNew;\\n uint256 actualAddAmount;\\n\\n // We fail gracefully unless market's block number equals current block number\\n if (accrualBlockNumber != getBlockNumber()) {\\n return (fail(Error.MARKET_NOT_FRESH, FailureInfo.ADD_RESERVES_FRESH_CHECK), actualAddAmount);\\n }\\n\\n /////////////////////////\\n // EFFECTS & INTERACTIONS\\n // (No safe failures beyond this point)\\n\\n /*\\n * We call doTransferIn for the caller and the addAmount\\n * Note: The cToken must handle variations between ERC-20 and ETH underlying.\\n * On success, the cToken holds an additional addAmount of cash.\\n * doTransferIn reverts if anything goes wrong, since we can't be sure if side effects occurred.\\n * it returns the amount actually transferred, in case of a fee.\\n */\\n\\n actualAddAmount = doTransferIn(msg.sender, addAmount, isNative);\\n\\n totalReservesNew = add_(totalReserves, actualAddAmount);\\n\\n // Store reserves[n+1] = reserves[n] + actualAddAmount\\n totalReserves = totalReservesNew;\\n\\n /* Emit NewReserves(admin, actualAddAmount, reserves[n+1]) */\\n emit ReservesAdded(msg.sender, actualAddAmount, totalReservesNew);\\n\\n /* Return (NO_ERROR, actualAddAmount) */\\n return (uint256(Error.NO_ERROR), actualAddAmount);\\n }\\n\\n /**\\n * @notice Accrues interest and reduces reserves by transferring to admin\\n * @param reduceAmount Amount of reduction to reserves\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _reduceReserves(uint256 reduceAmount) external nonReentrant returns (uint256) {\\n uint256 error = accrueInterest();\\n if (error != uint256(Error.NO_ERROR)) {\\n // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted reduce reserves failed.\\n return fail(Error(error), FailureInfo.REDUCE_RESERVES_ACCRUE_INTEREST_FAILED);\\n }\\n // _reduceReservesFresh emits reserve-reduction-specific logs on errors, so we don't need to.\\n return _reduceReservesFresh(reduceAmount);\\n }\\n\\n /**\\n * @notice Reduces reserves by transferring to admin\\n * @dev Requires fresh interest accrual\\n * @param reduceAmount Amount of reduction to reserves\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _reduceReservesFresh(uint256 reduceAmount) internal returns (uint256) {\\n // totalReserves - reduceAmount\\n uint256 totalReservesNew;\\n\\n // Check caller is admin\\n if (msg.sender != admin) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.REDUCE_RESERVES_ADMIN_CHECK);\\n }\\n\\n // We fail gracefully unless market's block number equals current block number\\n if (accrualBlockNumber != getBlockNumber()) {\\n return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDUCE_RESERVES_FRESH_CHECK);\\n }\\n\\n // Fail gracefully if protocol has insufficient underlying cash\\n if (getCashPrior() < reduceAmount) {\\n return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDUCE_RESERVES_CASH_NOT_AVAILABLE);\\n }\\n\\n // Check reduceAmount \\u2264 reserves[n] (totalReserves)\\n if (reduceAmount > totalReserves) {\\n return fail(Error.BAD_INPUT, FailureInfo.REDUCE_RESERVES_VALIDATION);\\n }\\n\\n /////////////////////////\\n // EFFECTS & INTERACTIONS\\n // (No safe failures beyond this point)\\n\\n totalReservesNew = sub_(totalReserves, reduceAmount);\\n\\n // Store reserves[n+1] = reserves[n] - reduceAmount\\n totalReserves = totalReservesNew;\\n\\n // doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred.\\n // Restrict reducing reserves in native token. Implementations except `CWrappedNative` won't use parameter `isNative`.\\n doTransferOut(admin, reduceAmount, true);\\n\\n emit ReservesReduced(admin, reduceAmount, totalReservesNew);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice accrues interest and updates the interest rate model using _setInterestRateModelFresh\\n * @dev Admin function to accrue interest and update the interest rate model\\n * @param newInterestRateModel the new interest rate model to use\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _setInterestRateModel(InterestRateModel newInterestRateModel) public returns (uint256) {\\n uint256 error = accrueInterest();\\n if (error != uint256(Error.NO_ERROR)) {\\n // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted change of interest rate model failed\\n return fail(Error(error), FailureInfo.SET_INTEREST_RATE_MODEL_ACCRUE_INTEREST_FAILED);\\n }\\n // _setInterestRateModelFresh emits interest-rate-model-update-specific logs on errors, so we don't need to.\\n return _setInterestRateModelFresh(newInterestRateModel);\\n }\\n\\n /**\\n * @notice updates the interest rate model (*requires fresh interest accrual)\\n * @dev Admin function to update the interest rate model\\n * @param newInterestRateModel the new interest rate model to use\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _setInterestRateModelFresh(InterestRateModel newInterestRateModel) internal returns (uint256) {\\n // Used to store old model for use in the event that is emitted on success\\n InterestRateModel oldInterestRateModel;\\n\\n // Check caller is admin\\n if (msg.sender != admin) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.SET_INTEREST_RATE_MODEL_OWNER_CHECK);\\n }\\n\\n // We fail gracefully unless market's block number equals current block number\\n if (accrualBlockNumber != getBlockNumber()) {\\n return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_INTEREST_RATE_MODEL_FRESH_CHECK);\\n }\\n\\n // Track the market's current interest rate model\\n oldInterestRateModel = interestRateModel;\\n\\n // Ensure invoke newInterestRateModel.isInterestRateModel() returns true\\n require(newInterestRateModel.isInterestRateModel(), \\\"marker method returned false\\\");\\n\\n // Set the interest rate model to newInterestRateModel\\n interestRateModel = newInterestRateModel;\\n\\n // Emit NewMarketInterestRateModel(oldInterestRateModel, newInterestRateModel)\\n emit NewMarketInterestRateModel(oldInterestRateModel, newInterestRateModel);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /*** Safe Token ***/\\n\\n /**\\n * @notice Gets balance of this contract in terms of the underlying\\n * @dev This excludes the value of the current message, if any\\n * @return The quantity of underlying owned by this contract\\n */\\n function getCashPrior() internal view returns (uint256);\\n\\n /**\\n * @dev Performs a transfer in, reverting upon failure. Returns the amount actually transferred to the protocol, in case of a fee.\\n * This may revert due to insufficient balance or insufficient allowance.\\n */\\n function doTransferIn(\\n address from,\\n uint256 amount,\\n bool isNative\\n ) internal returns (uint256);\\n\\n /**\\n * @dev Performs a transfer out, ideally returning an explanatory error code upon failure tather than reverting.\\n * If caller has not called checked protocol's balance, may revert due to insufficient cash held in the contract.\\n * If caller has checked protocol's balance, and verified it is >= amount, this should not revert in normal conditions.\\n */\\n function doTransferOut(\\n address payable to,\\n uint256 amount,\\n bool isNative\\n ) internal;\\n\\n /**\\n * @notice Transfer `tokens` tokens from `src` to `dst` by `spender`\\n * @dev Called by both `transfer` and `transferFrom` internally\\n */\\n function transferTokens(\\n address spender,\\n address src,\\n address dst,\\n uint256 tokens\\n ) internal returns (uint256);\\n\\n /**\\n * @notice Get the account's cToken balances\\n */\\n function getCTokenBalanceInternal(address account) internal view returns (uint256);\\n\\n /**\\n * @notice User supplies assets into the market and receives cTokens in exchange\\n * @dev Assumes interest has already been accrued up to the current block\\n */\\n function mintFresh(\\n address minter,\\n uint256 mintAmount,\\n bool isNative\\n ) internal returns (uint256, uint256);\\n\\n /**\\n * @notice User redeems cTokens in exchange for the underlying asset\\n * @dev Assumes interest has already been accrued up to the current block\\n */\\n function redeemFresh(\\n address payable redeemer,\\n uint256 redeemTokensIn,\\n uint256 redeemAmountIn,\\n bool isNative\\n ) internal returns (uint256);\\n\\n /**\\n * @notice Transfers collateral tokens (this market) to the liquidator.\\n * @dev Called only during an in-kind liquidation, or by liquidateBorrow during the liquidation of another CToken.\\n * Its absolutely critical to use msg.sender as the seizer cToken and not a parameter.\\n */\\n function seizeInternal(\\n address seizerToken,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) internal returns (uint256);\\n\\n /*** Reentrancy Guard ***/\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n */\\n modifier nonReentrant() {\\n require(_notEntered, \\\"re-entered\\\");\\n _notEntered = false;\\n _;\\n _notEntered = true; // get a gas-refund post-Istanbul\\n }\\n}\\n\",\"keccak256\":\"0x4f67ad56baaf08d0577c2890f3476e40a7bead5d1ac0e534d63a6f36721ff6f1\"},\"contracts/CTokenInterfaces.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\nimport \\\"./ComptrollerInterface.sol\\\";\\nimport \\\"./InterestRateModel.sol\\\";\\nimport \\\"./ERC3156FlashBorrowerInterface.sol\\\";\\n\\ncontract CTokenStorage {\\n /**\\n * @dev Guard variable for re-entrancy checks\\n */\\n bool internal _notEntered;\\n\\n /**\\n * @notice EIP-20 token name for this token\\n */\\n string public name;\\n\\n /**\\n * @notice EIP-20 token symbol for this token\\n */\\n string public symbol;\\n\\n /**\\n * @notice EIP-20 token decimals for this token\\n */\\n uint8 public decimals;\\n\\n /**\\n * @notice Maximum borrow rate that can ever be applied (.0005% / block)\\n */\\n\\n uint256 internal constant borrowRateMaxMantissa = 0.0005e16;\\n\\n /**\\n * @notice Maximum fraction of interest that can be set aside for reserves\\n */\\n uint256 internal constant reserveFactorMaxMantissa = 1e18;\\n\\n /**\\n * @notice Administrator for this contract\\n */\\n address payable public admin;\\n\\n /**\\n * @notice Pending administrator for this contract\\n */\\n address payable public pendingAdmin;\\n\\n /**\\n * @notice Contract which oversees inter-cToken operations\\n */\\n ComptrollerInterface public comptroller;\\n\\n /**\\n * @notice Model which tells what the current interest rate should be\\n */\\n InterestRateModel public interestRateModel;\\n\\n /**\\n * @notice Initial exchange rate used when minting the first CTokens (used when totalSupply = 0)\\n */\\n uint256 internal initialExchangeRateMantissa;\\n\\n /**\\n * @notice Fraction of interest currently set aside for reserves\\n */\\n uint256 public reserveFactorMantissa;\\n\\n /**\\n * @notice Block number that interest was last accrued at\\n */\\n uint256 public accrualBlockNumber;\\n\\n /**\\n * @notice Accumulator of the total earned interest rate since the opening of the market\\n */\\n uint256 public borrowIndex;\\n\\n /**\\n * @notice Total amount of outstanding borrows of the underlying in this market\\n */\\n uint256 public totalBorrows;\\n\\n /**\\n * @notice Total amount of reserves of the underlying held in this market\\n */\\n uint256 public totalReserves;\\n\\n /**\\n * @notice Total number of tokens in circulation\\n */\\n uint256 public totalSupply;\\n\\n /**\\n * @notice Official record of token balances for each account\\n */\\n mapping(address => uint256) internal accountTokens;\\n\\n /**\\n * @notice Approved token transfer amounts on behalf of others\\n */\\n mapping(address => mapping(address => uint256)) internal transferAllowances;\\n\\n /**\\n * @notice Container for borrow balance information\\n * @member principal Total balance (with accrued interest), after applying the most recent balance-changing action\\n * @member interestIndex Global borrowIndex as of the most recent balance-changing action\\n */\\n struct BorrowSnapshot {\\n uint256 principal;\\n uint256 interestIndex;\\n }\\n\\n /**\\n * @notice Mapping of account addresses to outstanding borrow balances\\n */\\n mapping(address => BorrowSnapshot) internal accountBorrows;\\n}\\n\\ncontract CErc20Storage {\\n /**\\n * @notice Underlying asset for this CToken\\n */\\n address public underlying;\\n\\n /**\\n * @notice Implementation address for this contract\\n */\\n address public implementation;\\n}\\n\\ncontract CSupplyCapStorage {\\n /**\\n * @notice Internal cash counter for this CToken. Should equal underlying.balanceOf(address(this)) for CERC20.\\n */\\n uint256 public internalCash;\\n}\\n\\ncontract CCollateralCapStorage {\\n /**\\n * @notice Total number of tokens used as collateral in circulation.\\n */\\n uint256 public totalCollateralTokens;\\n\\n /**\\n * @notice Record of token balances which could be treated as collateral for each account.\\n * If collateral cap is not set, the value should be equal to accountTokens.\\n */\\n mapping(address => uint256) public accountCollateralTokens;\\n\\n /**\\n * @notice Check if accountCollateralTokens have been initialized.\\n */\\n mapping(address => bool) public isCollateralTokenInit;\\n\\n /**\\n * @notice Collateral cap for this CToken, zero for no cap.\\n */\\n uint256 public collateralCap;\\n}\\n\\n/*** Interface ***/\\n\\ncontract CTokenInterface is CTokenStorage {\\n /**\\n * @notice Indicator that this is a CToken contract (for inspection)\\n */\\n bool public constant isCToken = true;\\n\\n /*** Market Events ***/\\n\\n /**\\n * @notice Event emitted when interest is accrued\\n */\\n event AccrueInterest(uint256 cashPrior, uint256 interestAccumulated, uint256 borrowIndex, uint256 totalBorrows);\\n\\n /**\\n * @notice Event emitted when tokens are minted\\n */\\n event Mint(address minter, uint256 mintAmount, uint256 mintTokens);\\n\\n /**\\n * @notice Event emitted when tokens are redeemed\\n */\\n event Redeem(address redeemer, uint256 redeemAmount, uint256 redeemTokens);\\n\\n /**\\n * @notice Event emitted when underlying is borrowed\\n */\\n event Borrow(address borrower, uint256 borrowAmount, uint256 accountBorrows, uint256 totalBorrows);\\n\\n /**\\n * @notice Event emitted when a borrow is repaid\\n */\\n event RepayBorrow(\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 accountBorrows,\\n uint256 totalBorrows\\n );\\n\\n /**\\n * @notice Event emitted when a borrow is liquidated\\n */\\n event LiquidateBorrow(\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n address cTokenCollateral,\\n uint256 seizeTokens\\n );\\n\\n /*** Admin Events ***/\\n\\n /**\\n * @notice Event emitted when pendingAdmin is changed\\n */\\n event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);\\n\\n /**\\n * @notice Event emitted when pendingAdmin is accepted, which means admin is updated\\n */\\n event NewAdmin(address oldAdmin, address newAdmin);\\n\\n /**\\n * @notice Event emitted when comptroller is changed\\n */\\n event NewComptroller(ComptrollerInterface oldComptroller, ComptrollerInterface newComptroller);\\n\\n /**\\n * @notice Event emitted when interestRateModel is changed\\n */\\n event NewMarketInterestRateModel(InterestRateModel oldInterestRateModel, InterestRateModel newInterestRateModel);\\n\\n /**\\n * @notice Event emitted when the reserve factor is changed\\n */\\n event NewReserveFactor(uint256 oldReserveFactorMantissa, uint256 newReserveFactorMantissa);\\n\\n /**\\n * @notice Event emitted when the reserves are added\\n */\\n event ReservesAdded(address benefactor, uint256 addAmount, uint256 newTotalReserves);\\n\\n /**\\n * @notice Event emitted when the reserves are reduced\\n */\\n event ReservesReduced(address admin, uint256 reduceAmount, uint256 newTotalReserves);\\n\\n /**\\n * @notice EIP20 Transfer event\\n */\\n event Transfer(address indexed from, address indexed to, uint256 amount);\\n\\n /**\\n * @notice EIP20 Approval event\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 amount);\\n\\n /**\\n * @notice Failure event\\n */\\n event Failure(uint256 error, uint256 info, uint256 detail);\\n\\n /*** User Interface ***/\\n\\n function transfer(address dst, uint256 amount) external returns (bool);\\n\\n function transferFrom(\\n address src,\\n address dst,\\n uint256 amount\\n ) external returns (bool);\\n\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n function balanceOf(address owner) external view returns (uint256);\\n\\n function balanceOfUnderlying(address owner) external returns (uint256);\\n\\n function getAccountSnapshot(address account)\\n external\\n view\\n returns (\\n uint256,\\n uint256,\\n uint256,\\n uint256\\n );\\n\\n function borrowRatePerBlock() external view returns (uint256);\\n\\n function supplyRatePerBlock() external view returns (uint256);\\n\\n function totalBorrowsCurrent() external returns (uint256);\\n\\n function borrowBalanceCurrent(address account) external returns (uint256);\\n\\n function borrowBalanceStored(address account) public view returns (uint256);\\n\\n function exchangeRateCurrent() public returns (uint256);\\n\\n function exchangeRateStored() public view returns (uint256);\\n\\n function getCash() external view returns (uint256);\\n\\n function accrueInterest() public returns (uint256);\\n\\n function seize(\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n /*** Admin Functions ***/\\n\\n function _setPendingAdmin(address payable newPendingAdmin) external returns (uint256);\\n\\n function _acceptAdmin() external returns (uint256);\\n\\n function _setComptroller(ComptrollerInterface newComptroller) public returns (uint256);\\n\\n function _setReserveFactor(uint256 newReserveFactorMantissa) external returns (uint256);\\n\\n function _reduceReserves(uint256 reduceAmount) external returns (uint256);\\n\\n function _setInterestRateModel(InterestRateModel newInterestRateModel) public returns (uint256);\\n}\\n\\ncontract CErc20Interface is CErc20Storage {\\n /*** User Interface ***/\\n\\n function mint(uint256 mintAmount) external returns (uint256);\\n\\n function redeem(uint256 redeemTokens) external returns (uint256);\\n\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n\\n function borrow(uint256 borrowAmount) external returns (uint256);\\n\\n function repayBorrow(uint256 repayAmount) external returns (uint256);\\n\\n function liquidateBorrow(\\n address borrower,\\n uint256 repayAmount,\\n CTokenInterface cTokenCollateral\\n ) external returns (uint256);\\n\\n function _addReserves(uint256 addAmount) external returns (uint256);\\n}\\n\\ncontract CWrappedNativeInterface is CErc20Interface {\\n /**\\n * @notice Flash loan fee ratio\\n */\\n uint256 public constant flashFeeBips = 3;\\n\\n /*** Market Events ***/\\n\\n /**\\n * @notice Event emitted when a flashloan occured\\n */\\n event Flashloan(address indexed receiver, uint256 amount, uint256 totalFee, uint256 reservesFee);\\n\\n /*** User Interface ***/\\n\\n function mintNative() external payable returns (uint256);\\n\\n function redeemNative(uint256 redeemTokens) external returns (uint256);\\n\\n function redeemUnderlyingNative(uint256 redeemAmount) external returns (uint256);\\n\\n function borrowNative(uint256 borrowAmount) external returns (uint256);\\n\\n function repayBorrowNative() external payable returns (uint256);\\n\\n function liquidateBorrowNative(address borrower, CTokenInterface cTokenCollateral)\\n external\\n payable\\n returns (uint256);\\n\\n function flashLoan(\\n ERC3156FlashBorrowerInterface receiver,\\n address initiator,\\n uint256 amount,\\n bytes calldata data\\n ) external returns (bool);\\n\\n function _addReservesNative() external payable returns (uint256);\\n}\\n\\ncontract CCapableErc20Interface is CErc20Interface, CSupplyCapStorage {\\n /**\\n * @notice Flash loan fee ratio\\n */\\n uint256 public constant flashFeeBips = 3;\\n\\n /*** Market Events ***/\\n\\n /**\\n * @notice Event emitted when a flashloan occured\\n */\\n event Flashloan(address indexed receiver, uint256 amount, uint256 totalFee, uint256 reservesFee);\\n\\n /*** User Interface ***/\\n\\n function gulp() external;\\n}\\n\\ncontract CCollateralCapErc20Interface is CCapableErc20Interface, CCollateralCapStorage {\\n /*** Admin Events ***/\\n\\n /**\\n * @notice Event emitted when collateral cap is set\\n */\\n event NewCollateralCap(address token, uint256 newCap);\\n\\n /**\\n * @notice Event emitted when user collateral is changed\\n */\\n event UserCollateralChanged(address account, uint256 newCollateralTokens);\\n\\n /*** User Interface ***/\\n\\n function registerCollateral(address account) external returns (uint256);\\n\\n function unregisterCollateral(address account) external;\\n\\n function flashLoan(\\n ERC3156FlashBorrowerInterface receiver,\\n address initiator,\\n uint256 amount,\\n bytes calldata data\\n ) external returns (bool);\\n\\n /*** Admin Functions ***/\\n\\n function _setCollateralCap(uint256 newCollateralCap) external;\\n}\\n\\ncontract CDelegatorInterface {\\n /**\\n * @notice Emitted when implementation is changed\\n */\\n event NewImplementation(address oldImplementation, address newImplementation);\\n\\n /**\\n * @notice Called by the admin to update the implementation of the delegator\\n * @param implementation_ The address of the new implementation for delegation\\n * @param allowResign Flag to indicate whether to call _resignImplementation on the old implementation\\n * @param becomeImplementationData The encoded bytes data to be passed to _becomeImplementation\\n */\\n function _setImplementation(\\n address implementation_,\\n bool allowResign,\\n bytes memory becomeImplementationData\\n ) public;\\n}\\n\\ncontract CDelegateInterface {\\n /**\\n * @notice Called by the delegator on a delegate to initialize it for duty\\n * @dev Should revert if any issues arise which make it unfit for delegation\\n * @param data The encoded bytes data for any initialization\\n */\\n function _becomeImplementation(bytes memory data) public;\\n\\n /**\\n * @notice Called by the delegator on a delegate to forfeit its responsibility\\n */\\n function _resignImplementation() public;\\n}\\n\\n/*** External interface ***/\\n\\n/**\\n * @title Flash loan receiver interface\\n */\\ninterface IFlashloanReceiver {\\n function executeOperation(\\n address sender,\\n address underlying,\\n uint256 amount,\\n uint256 fee,\\n bytes calldata params\\n ) external;\\n}\\n\",\"keccak256\":\"0x64e87b2f810fcbee3ec2b9e2ae3b38ed30ec9739fb3e094aad663aa5c0bb24c0\"},\"contracts/CarefulMath.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\n/**\\n * @title Careful Math\\n * @author Compound\\n * @notice Derived from OpenZeppelin's SafeMath library\\n * https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/math/SafeMath.sol\\n */\\ncontract CarefulMath {\\n /**\\n * @dev Possible error codes that we can return\\n */\\n enum MathError {\\n NO_ERROR,\\n DIVISION_BY_ZERO,\\n INTEGER_OVERFLOW,\\n INTEGER_UNDERFLOW\\n }\\n\\n /**\\n * @dev Multiplies two numbers, returns an error on overflow.\\n */\\n function mulUInt(uint256 a, uint256 b) internal pure returns (MathError, uint256) {\\n if (a == 0) {\\n return (MathError.NO_ERROR, 0);\\n }\\n\\n uint256 c = a * b;\\n\\n if (c / a != b) {\\n return (MathError.INTEGER_OVERFLOW, 0);\\n } else {\\n return (MathError.NO_ERROR, c);\\n }\\n }\\n\\n /**\\n * @dev Integer division of two numbers, truncating the quotient.\\n */\\n function divUInt(uint256 a, uint256 b) internal pure returns (MathError, uint256) {\\n if (b == 0) {\\n return (MathError.DIVISION_BY_ZERO, 0);\\n }\\n\\n return (MathError.NO_ERROR, a / b);\\n }\\n\\n /**\\n * @dev Subtracts two numbers, returns an error on overflow (i.e. if subtrahend is greater than minuend).\\n */\\n function subUInt(uint256 a, uint256 b) internal pure returns (MathError, uint256) {\\n if (b <= a) {\\n return (MathError.NO_ERROR, a - b);\\n } else {\\n return (MathError.INTEGER_UNDERFLOW, 0);\\n }\\n }\\n\\n /**\\n * @dev Adds two numbers, returns an error on overflow.\\n */\\n function addUInt(uint256 a, uint256 b) internal pure returns (MathError, uint256) {\\n uint256 c = a + b;\\n\\n if (c >= a) {\\n return (MathError.NO_ERROR, c);\\n } else {\\n return (MathError.INTEGER_OVERFLOW, 0);\\n }\\n }\\n\\n /**\\n * @dev add a and b and then subtract c\\n */\\n function addThenSubUInt(\\n uint256 a,\\n uint256 b,\\n uint256 c\\n ) internal pure returns (MathError, uint256) {\\n (MathError err0, uint256 sum) = addUInt(a, b);\\n\\n if (err0 != MathError.NO_ERROR) {\\n return (err0, 0);\\n }\\n\\n return subUInt(sum, c);\\n }\\n}\\n\",\"keccak256\":\"0x458de49aa8c70be5b88d92d242caa5f647ee0f74570eda81a9276e969ba94f7f\"},\"contracts/Comptroller.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\nimport \\\"./CToken.sol\\\";\\nimport \\\"./ErrorReporter.sol\\\";\\nimport \\\"./Exponential.sol\\\";\\nimport \\\"./PriceOracle/PriceOracle.sol\\\";\\nimport \\\"./ComptrollerInterface.sol\\\";\\nimport \\\"./ComptrollerStorage.sol\\\";\\nimport \\\"./LiquidityMiningInterface.sol\\\";\\nimport \\\"./Unitroller.sol\\\";\\nimport \\\"./Governance/Comp.sol\\\";\\n\\n/**\\n * @title Compound's Comptroller Contract\\n * @author Compound (modified by Cream)\\n */\\ncontract Comptroller is ComptrollerV1Storage, ComptrollerInterface, ComptrollerErrorReporter, Exponential {\\n /// @notice Emitted when an admin supports a market\\n event MarketListed(CToken cToken);\\n\\n /// @notice Emitted when an admin delists a market\\n event MarketDelisted(CToken cToken);\\n\\n /// @notice Emitted when an account enters a market\\n event MarketEntered(CToken cToken, address account);\\n\\n /// @notice Emitted when an account exits a market\\n event MarketExited(CToken cToken, address account);\\n\\n /// @notice Emitted when close factor is changed by admin\\n event NewCloseFactor(uint256 oldCloseFactorMantissa, uint256 newCloseFactorMantissa);\\n\\n /// @notice Emitted when a collateral factor is changed by admin\\n event NewCollateralFactor(CToken cToken, uint256 oldCollateralFactorMantissa, uint256 newCollateralFactorMantissa);\\n\\n /// @notice Emitted when liquidation incentive is changed by admin\\n event NewLiquidationIncentive(uint256 oldLiquidationIncentiveMantissa, uint256 newLiquidationIncentiveMantissa);\\n\\n /// @notice Emitted when price oracle is changed\\n event NewPriceOracle(PriceOracle oldPriceOracle, PriceOracle newPriceOracle);\\n\\n /// @notice Emitted when pause guardian is changed\\n event NewPauseGuardian(address oldPauseGuardian, address newPauseGuardian);\\n\\n /// @notice Emitted when liquidity mining module is changed\\n event NewLiquidityMining(address oldLiquidityMining, address newLiquidityMining);\\n\\n /// @notice Emitted when an action is paused globally\\n event ActionPaused(string action, bool pauseState);\\n\\n /// @notice Emitted when an action is paused on a market\\n event ActionPaused(CToken cToken, string action, bool pauseState);\\n\\n /// @notice Emitted when a new COMP speed is calculated for a market\\n event CompSpeedUpdated(uint8 rewardType, CToken indexed cToken, uint newSpeed);\\n\\n /// @notice Emitted when COMP is distributed to a supplier\\n event DistributedSupplierComp(uint8 rewardType, CToken indexed cToken, address indexed supplier, uint compDelta, uint compSupplyIndex);\\n\\n /// @notice Emitted when COMP is distributed to a borrower\\n event DistributedBorrowerComp(uint8 rewardType, CToken indexed cToken, address indexed borrower, uint compDelta, uint compBorrowIndex);\\n\\n /// @notice Emitted when COMP is granted by admin\\n event CompGranted(address recipient, uint amount);\\n\\n /// @notice Emitted when borrow cap for a cToken is changed\\n event NewBorrowCap(CToken indexed cToken, uint256 newBorrowCap);\\n\\n /// @notice Emitted when borrow cap guardian is changed\\n event NewBorrowCapGuardian(address oldBorrowCapGuardian, address newBorrowCapGuardian);\\n\\n /// @notice Emitted when supply cap for a cToken is changed\\n event NewSupplyCap(CToken indexed cToken, uint256 newSupplyCap);\\n\\n /// @notice Emitted when supply cap guardian is changed\\n event NewSupplyCapGuardian(address oldSupplyCapGuardian, address newSupplyCapGuardian);\\n\\n /// @notice Emitted when protocol's credit limit has changed\\n event CreditLimitChanged(address protocol, uint256 creditLimit);\\n\\n /// @notice Emitted when cToken version is changed\\n event NewCTokenVersion(CToken cToken, Version oldVersion, Version newVersion);\\n\\n /// @notice The initial COMP index for a market\\n uint224 public constant compInitialIndex = 1e36;\\n\\n // No collateralFactorMantissa may exceed this value\\n uint256 internal constant collateralFactorMaxMantissa = 0.9e18; // 0.9\\n\\n constructor() public {\\n admin = msg.sender;\\n }\\n\\n /*** Assets You Are In ***/\\n\\n /**\\n * @notice Returns the assets an account has entered\\n * @param account The address of the account to pull assets for\\n * @return A dynamic list with the assets the account has entered\\n */\\n function getAssetsIn(address account) external view returns (CToken[] memory) {\\n CToken[] memory assetsIn = accountAssets[account];\\n\\n return assetsIn;\\n }\\n\\n /**\\n * @notice Returns whether the given account is entered in the given asset\\n * @param account The address of the account to check\\n * @param cToken The cToken to check\\n * @return True if the account is in the asset, otherwise false.\\n */\\n function checkMembership(address account, CToken cToken) external view returns (bool) {\\n return markets[address(cToken)].accountMembership[account];\\n }\\n\\n /**\\n * @notice Add assets to be included in account liquidity calculation\\n * @param cTokens The list of addresses of the cToken markets to be enabled\\n * @return Success indicator for whether each corresponding market was entered\\n */\\n function enterMarkets(address[] memory cTokens) public returns (uint256[] memory) {\\n uint256 len = cTokens.length;\\n\\n uint256[] memory results = new uint256[](len);\\n for (uint256 i = 0; i < len; i++) {\\n CToken cToken = CToken(cTokens[i]);\\n\\n results[i] = uint256(addToMarketInternal(cToken, msg.sender));\\n }\\n\\n return results;\\n }\\n\\n /**\\n * @notice Add the market to the borrower's \\\"assets in\\\" for liquidity calculations\\n * @param cToken The market to enter\\n * @param borrower The address of the account to modify\\n * @return Success indicator for whether the market was entered\\n */\\n function addToMarketInternal(CToken cToken, address borrower) internal returns (Error) {\\n Market storage marketToJoin = markets[address(cToken)];\\n\\n if (!marketToJoin.isListed) {\\n // market is not listed, cannot join\\n return Error.MARKET_NOT_LISTED;\\n }\\n\\n if (marketToJoin.version == Version.COLLATERALCAP) {\\n // register collateral for the borrower if the token is CollateralCap version.\\n CCollateralCapErc20Interface(address(cToken)).registerCollateral(borrower);\\n }\\n\\n if (marketToJoin.accountMembership[borrower] == true) {\\n // already joined\\n return Error.NO_ERROR;\\n }\\n\\n // survived the gauntlet, add to list\\n // NOTE: we store these somewhat redundantly as a significant optimization\\n // this avoids having to iterate through the list for the most common use cases\\n // that is, only when we need to perform liquidity checks\\n // and not whenever we want to check if an account is in a particular market\\n marketToJoin.accountMembership[borrower] = true;\\n accountAssets[borrower].push(cToken);\\n\\n emit MarketEntered(cToken, borrower);\\n\\n return Error.NO_ERROR;\\n }\\n\\n /**\\n * @notice Removes asset from sender's account liquidity calculation\\n * @dev Sender must not have an outstanding borrow balance in the asset,\\n * or be providing necessary collateral for an outstanding borrow.\\n * @param cTokenAddress The address of the asset to be removed\\n * @return Whether or not the account successfully exited the market\\n */\\n function exitMarket(address cTokenAddress) external returns (uint256) {\\n CToken cToken = CToken(cTokenAddress);\\n /* Get sender tokensHeld and amountOwed underlying from the cToken */\\n (uint256 oErr, uint256 tokensHeld, uint256 amountOwed, ) = cToken.getAccountSnapshot(msg.sender);\\n require(oErr == 0, \\\"exitMarket: getAccountSnapshot failed\\\"); // semi-opaque error code\\n\\n /* Fail if the sender has a borrow balance */\\n if (amountOwed != 0) {\\n return fail(Error.NONZERO_BORROW_BALANCE, FailureInfo.EXIT_MARKET_BALANCE_OWED);\\n }\\n\\n /* Fail if the sender is not permitted to redeem all of their tokens */\\n uint256 allowed = redeemAllowedInternal(cTokenAddress, msg.sender, tokensHeld);\\n if (allowed != 0) {\\n return failOpaque(Error.REJECTION, FailureInfo.EXIT_MARKET_REJECTION, allowed);\\n }\\n\\n Market storage marketToExit = markets[cTokenAddress];\\n\\n if (marketToExit.version == Version.COLLATERALCAP) {\\n CCollateralCapErc20Interface(cTokenAddress).unregisterCollateral(msg.sender);\\n }\\n\\n /* Return true if the sender is not already \\u2018in\\u2019 the market */\\n if (!marketToExit.accountMembership[msg.sender]) {\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /* Set cToken account membership to false */\\n delete marketToExit.accountMembership[msg.sender];\\n\\n /* Delete cToken from the account\\u2019s list of assets */\\n // load into memory for faster iteration\\n CToken[] memory userAssetList = accountAssets[msg.sender];\\n uint256 len = userAssetList.length;\\n uint256 assetIndex = len;\\n for (uint256 i = 0; i < len; i++) {\\n if (userAssetList[i] == cToken) {\\n assetIndex = i;\\n break;\\n }\\n }\\n\\n // We *must* have found the asset in the list or our redundant data structure is broken\\n assert(assetIndex < len);\\n\\n // copy last item in list to location of item to be removed, reduce length by 1\\n CToken[] storage storedList = accountAssets[msg.sender];\\n if (assetIndex != storedList.length - 1) {\\n storedList[assetIndex] = storedList[storedList.length - 1];\\n }\\n storedList.length--;\\n\\n emit MarketExited(cToken, msg.sender);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Return a specific market is listed or not\\n * @param cTokenAddress The address of the asset to be checked\\n * @return Whether or not the market is listed\\n */\\n function isMarketListed(address cTokenAddress) public view returns (bool) {\\n return markets[cTokenAddress].isListed;\\n }\\n\\n /*** Policy Hooks ***/\\n\\n /**\\n * @notice Checks if the account should be allowed to mint tokens in the given market\\n * @param cToken The market to verify the mint against\\n * @param minter The account which would get the minted tokens\\n * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens\\n * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256) {\\n // Pausing is a very serious situation - we revert to sound the alarms\\n require(!mintGuardianPaused[cToken], \\\"mint is paused\\\");\\n require(!isCreditAccount(minter), \\\"credit account cannot mint\\\");\\n\\n if (!isMarketListed(cToken)) {\\n return uint256(Error.MARKET_NOT_LISTED);\\n }\\n\\n uint256 supplyCap = supplyCaps[cToken];\\n // Supply cap of 0 corresponds to unlimited supplying\\n if (supplyCap != 0) {\\n uint256 totalCash = CToken(cToken).getCash();\\n uint256 totalBorrows = CToken(cToken).totalBorrows();\\n uint256 totalReserves = CToken(cToken).totalReserves();\\n // totalSupplies = totalCash + totalBorrows - totalReserves\\n (MathError mathErr, uint256 totalSupplies) = addThenSubUInt(totalCash, totalBorrows, totalReserves);\\n require(mathErr == MathError.NO_ERROR, \\\"totalSupplies failed\\\");\\n\\n uint256 nextTotalSupplies = add_(totalSupplies, mintAmount);\\n require(nextTotalSupplies < supplyCap, \\\"market supply cap reached\\\");\\n }\\n\\n // Keep the flywheel moving\\n updateAndDistributeSupplierRewardsForToken(cToken, minter);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Validates mint and reverts on rejection. May emit logs.\\n * @param cToken Asset being minted\\n * @param minter The address minting the tokens\\n * @param actualMintAmount The amount of the underlying asset being minted\\n * @param mintTokens The number of tokens being minted\\n */\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 actualMintAmount,\\n uint256 mintTokens\\n ) external {\\n // Shh - currently unused\\n cToken;\\n minter;\\n actualMintAmount;\\n mintTokens;\\n\\n // Shh - we don't ever want this hook to be marked pure\\n if (false) {\\n closeFactorMantissa = closeFactorMantissa;\\n }\\n }\\n\\n /**\\n * @notice Checks if the account should be allowed to redeem tokens in the given market\\n * @param cToken The market to verify the redeem against\\n * @param redeemer The account which would redeem the tokens\\n * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market\\n * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256) {\\n uint256 allowed = redeemAllowedInternal(cToken, redeemer, redeemTokens);\\n if (allowed != uint256(Error.NO_ERROR)) {\\n return allowed;\\n }\\n \\n // Keep the flywheel going\\n updateAndDistributeSupplierRewardsForToken(cToken, redeemer);\\n return uint256(Error.NO_ERROR);\\n\\n }\\n\\n function redeemAllowedInternal(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) internal view returns (uint256) {\\n if (!isMarketListed(cToken)) {\\n return uint256(Error.MARKET_NOT_LISTED);\\n }\\n\\n /* If the redeemer is not 'in' the market, then we can bypass the liquidity check */\\n if (!markets[cToken].accountMembership[redeemer]) {\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /* Otherwise, perform a hypothetical liquidity check to guard against shortfall */\\n (Error err, , uint256 shortfall) = getHypotheticalAccountLiquidityInternal(\\n redeemer,\\n CToken(cToken),\\n redeemTokens,\\n 0\\n );\\n if (err != Error.NO_ERROR) {\\n return uint256(err);\\n }\\n if (shortfall > 0) {\\n return uint256(Error.INSUFFICIENT_LIQUIDITY);\\n }\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Validates redeem and reverts on rejection. May emit logs.\\n * @param cToken Asset being redeemed\\n * @param redeemer The address redeeming the tokens\\n * @param redeemAmount The amount of the underlying asset being redeemed\\n * @param redeemTokens The number of tokens being redeemed\\n */\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external {\\n // Shh - currently unused\\n cToken;\\n redeemer;\\n\\n // Require tokens is zero or amount is also zero\\n if (redeemTokens == 0 && redeemAmount > 0) {\\n revert(\\\"redeemTokens zero\\\");\\n }\\n }\\n\\n /**\\n * @notice Checks if the account should be allowed to borrow the underlying asset of the given market\\n * @param cToken The market to verify the borrow against\\n * @param borrower The account which would borrow the asset\\n * @param borrowAmount The amount of underlying the account would borrow\\n * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256) {\\n // Pausing is a very serious situation - we revert to sound the alarms\\n require(!borrowGuardianPaused[cToken], \\\"borrow is paused\\\");\\n\\n if (!isMarketListed(cToken)) {\\n return uint256(Error.MARKET_NOT_LISTED);\\n }\\n\\n if (!markets[cToken].accountMembership[borrower]) {\\n // only cTokens may call borrowAllowed if borrower not in market\\n require(msg.sender == cToken, \\\"sender must be cToken\\\");\\n\\n // attempt to add borrower to the market\\n Error err = addToMarketInternal(CToken(cToken), borrower);\\n if (err != Error.NO_ERROR) {\\n return uint256(err);\\n }\\n\\n // it should be impossible to break the important invariant\\n assert(markets[cToken].accountMembership[borrower]);\\n }\\n\\n if (oracle.getUnderlyingPrice(CToken(cToken)) == 0) {\\n return uint256(Error.PRICE_ERROR);\\n }\\n\\n uint256 borrowCap = borrowCaps[cToken];\\n // Borrow cap of 0 corresponds to unlimited borrowing\\n if (borrowCap != 0) {\\n uint256 totalBorrows = CToken(cToken).totalBorrows();\\n uint256 nextTotalBorrows = add_(totalBorrows, borrowAmount);\\n require(nextTotalBorrows < borrowCap, \\\"market borrow cap reached\\\");\\n }\\n\\n (Error err, , uint256 shortfall) = getHypotheticalAccountLiquidityInternal(\\n borrower,\\n CToken(cToken),\\n 0,\\n borrowAmount\\n );\\n if (err != Error.NO_ERROR) {\\n return uint256(err);\\n }\\n if (shortfall > 0) {\\n return uint256(Error.INSUFFICIENT_LIQUIDITY);\\n }\\n\\n\\n // Keep the flywheel going\\n Exp memory borrowIndex = Exp({mantissa: CToken(cToken).borrowIndex()});\\n updateAndDistributeBorrowerRewardsForToken(cToken, borrower, borrowIndex);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Validates borrow and reverts on rejection. May emit logs.\\n * @param cToken Asset whose underlying is being borrowed\\n * @param borrower The address borrowing the underlying\\n * @param borrowAmount The amount of the underlying asset requested to borrow\\n */\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external {\\n // Shh - currently unused\\n cToken;\\n borrower;\\n borrowAmount;\\n\\n // Shh - we don't ever want this hook to be marked pure\\n if (false) {\\n closeFactorMantissa = closeFactorMantissa;\\n }\\n }\\n\\n /**\\n * @notice Checks if the account should be allowed to repay a borrow in the given market\\n * @param cToken The market to verify the repay against\\n * @param payer The account which would repay the asset\\n * @param borrower The account which would borrowed the asset\\n * @param repayAmount The amount of the underlying asset the account would repay\\n * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256) {\\n // Shh - currently unused\\n payer;\\n borrower;\\n repayAmount;\\n\\n if (!isMarketListed(cToken)) {\\n return uint256(Error.MARKET_NOT_LISTED);\\n }\\n\\n // Keep the flywheel going\\n Exp memory borrowIndex = Exp({mantissa: CToken(cToken).borrowIndex()});\\n updateAndDistributeBorrowerRewardsForToken(cToken, borrower, borrowIndex);\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Validates repayBorrow and reverts on rejection. May emit logs.\\n * @param cToken Asset being repaid\\n * @param payer The address repaying the borrow\\n * @param borrower The address of the borrower\\n * @param actualRepayAmount The amount of underlying being repaid\\n */\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 actualRepayAmount,\\n uint256 borrowerIndex\\n ) external {\\n // Shh - currently unused\\n cToken;\\n payer;\\n borrower;\\n actualRepayAmount;\\n borrowerIndex;\\n\\n // Shh - we don't ever want this hook to be marked pure\\n if (false) {\\n closeFactorMantissa = closeFactorMantissa;\\n }\\n }\\n\\n /**\\n * @notice Checks if the liquidation should be allowed to occur\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param repayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256) {\\n require(!isCreditAccount(borrower), \\\"cannot liquidate credit account\\\");\\n\\n // Shh - currently unused\\n liquidator;\\n\\n if (!isMarketListed(cTokenBorrowed) || !isMarketListed(cTokenCollateral)) {\\n return uint256(Error.MARKET_NOT_LISTED);\\n }\\n\\n /* The borrower must have shortfall in order to be liquidatable */\\n (Error err, , uint256 shortfall) = getAccountLiquidityInternal(borrower);\\n if (err != Error.NO_ERROR) {\\n return uint256(err);\\n }\\n if (shortfall == 0) {\\n return uint256(Error.INSUFFICIENT_SHORTFALL);\\n }\\n\\n /* The liquidator may not repay more than what is allowed by the closeFactor */\\n uint256 borrowBalance = CToken(cTokenBorrowed).borrowBalanceStored(borrower);\\n uint256 maxClose = mul_ScalarTruncate(Exp({mantissa: closeFactorMantissa}), borrowBalance);\\n if (repayAmount > maxClose) {\\n return uint256(Error.TOO_MUCH_REPAY);\\n }\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Validates liquidateBorrow and reverts on rejection. May emit logs.\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param actualRepayAmount The amount of underlying being repaid\\n */\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 actualRepayAmount,\\n uint256 seizeTokens\\n ) external {\\n // Shh - currently unused\\n cTokenBorrowed;\\n cTokenCollateral;\\n liquidator;\\n borrower;\\n actualRepayAmount;\\n seizeTokens;\\n\\n // Shh - we don't ever want this hook to be marked pure\\n if (false) {\\n closeFactorMantissa = closeFactorMantissa;\\n }\\n }\\n\\n /**\\n * @notice Checks if the seizing of assets should be allowed to occur\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256) {\\n // Pausing is a very serious situation - we revert to sound the alarms\\n require(!seizeGuardianPaused, \\\"seize is paused\\\");\\n require(!isCreditAccount(borrower), \\\"cannot sieze from credit account\\\");\\n\\n // Shh - currently unused\\n liquidator;\\n seizeTokens;\\n\\n if (!isMarketListed(cTokenCollateral) || !isMarketListed(cTokenBorrowed)) {\\n return uint256(Error.MARKET_NOT_LISTED);\\n }\\n\\n if (CToken(cTokenCollateral).comptroller() != CToken(cTokenBorrowed).comptroller()) {\\n return uint256(Error.COMPTROLLER_MISMATCH);\\n }\\n\\n // Keep the flywheel moving\\n updateAndDistributeSupplierRewardsForToken(cTokenCollateral, borrower);\\n updateAndDistributeSupplierRewardsForToken(cTokenCollateral, liquidator);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Validates seize and reverts on rejection. May emit logs.\\n * @param cTokenCollateral Asset which was used as collateral and will be seized\\n * @param cTokenBorrowed Asset which was borrowed by the borrower\\n * @param liquidator The address repaying the borrow and seizing the collateral\\n * @param borrower The address of the borrower\\n * @param seizeTokens The number of collateral tokens to seize\\n */\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external {\\n // Shh - currently unused\\n cTokenCollateral;\\n cTokenBorrowed;\\n liquidator;\\n borrower;\\n seizeTokens;\\n\\n // Shh - we don't ever want this hook to be marked pure\\n if (false) {\\n closeFactorMantissa = closeFactorMantissa;\\n }\\n }\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol)\\n */\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256) {\\n // Pausing is a very serious situation - we revert to sound the alarms\\n require(!transferGuardianPaused, \\\"transfer is paused\\\");\\n require(!isCreditAccount(dst), \\\"cannot transfer to a credit account\\\");\\n\\n // Shh - currently unused\\n dst;\\n\\n // Currently the only consideration is whether or not\\n // the src is allowed to redeem this many tokens\\n uint256 allowed = redeemAllowedInternal(cToken, src, transferTokens);\\n if (allowed != uint(Error.NO_ERROR)) {\\n return allowed;\\n }\\n\\n // Keep the flywheel moving\\n updateAndDistributeSupplierRewardsForToken(cToken, src);\\n updateAndDistributeSupplierRewardsForToken(cToken, dst);\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Validates transfer and reverts on rejection. May emit logs.\\n * @param cToken Asset being transferred\\n * @param src The account which sources the tokens\\n * @param dst The account which receives the tokens\\n * @param transferTokens The number of cTokens to transfer\\n */\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external {\\n // Shh - currently unused\\n cToken;\\n src;\\n dst;\\n transferTokens;\\n\\n // Shh - we don't ever want this hook to be marked pure\\n if (false) {\\n closeFactorMantissa = closeFactorMantissa;\\n }\\n }\\n\\n /**\\n * @notice Checks if the account should be allowed to transfer tokens in the given market\\n * @param cToken The market to verify the transfer against\\n * @param receiver The account which receives the tokens\\n * @param amount The amount of the tokens\\n * @param params The other parameters\\n */\\n\\n function flashloanAllowed(\\n address cToken,\\n address receiver,\\n uint256 amount,\\n bytes calldata params\\n ) external view returns (bool) {\\n return !flashloanGuardianPaused[cToken];\\n }\\n\\n /**\\n * @notice Update CToken's version.\\n * @param cToken Version of the asset being updated\\n * @param newVersion The new version\\n */\\n function updateCTokenVersion(address cToken, Version newVersion) external {\\n require(msg.sender == cToken, \\\"only cToken could update its version\\\");\\n\\n // This function will be called when a new CToken implementation becomes active.\\n // If a new CToken is newly created, this market is not listed yet. The version of\\n // this market will be taken care of when calling `_supportMarket`.\\n if (isMarketListed(cToken)) {\\n Version oldVersion = markets[cToken].version;\\n markets[cToken].version = newVersion;\\n\\n emit NewCTokenVersion(CToken(cToken), oldVersion, newVersion);\\n }\\n }\\n\\n /**\\n * @notice Check if the account is a credit account\\n * @param account The account needs to be checked\\n * @return The account is a credit account or not\\n */\\n function isCreditAccount(address account) public view returns (bool) {\\n return creditLimits[account] > 0;\\n }\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n\\n /**\\n * @dev Local vars for avoiding stack-depth limits in calculating account liquidity.\\n * Note that `cTokenBalance` is the number of cTokens the account owns in the market,\\n * whereas `borrowBalance` is the amount of underlying that the account has borrowed.\\n */\\n struct AccountLiquidityLocalVars {\\n uint256 sumCollateral;\\n uint256 sumBorrowPlusEffects;\\n uint256 cTokenBalance;\\n uint256 borrowBalance;\\n uint256 exchangeRateMantissa;\\n uint256 oraclePriceMantissa;\\n Exp collateralFactor;\\n Exp exchangeRate;\\n Exp oraclePrice;\\n Exp tokensToDenom;\\n }\\n\\n /**\\n * @notice Determine the current account liquidity wrt collateral requirements\\n * @return (possible error code (semi-opaque),\\n account liquidity in excess of collateral requirements,\\n * account shortfall below collateral requirements)\\n */\\n function getAccountLiquidity(address account)\\n public\\n view\\n returns (\\n uint256,\\n uint256,\\n uint256\\n )\\n {\\n (Error err, uint256 liquidity, uint256 shortfall) = getHypotheticalAccountLiquidityInternal(\\n account,\\n CToken(0),\\n 0,\\n 0\\n );\\n\\n return (uint256(err), liquidity, shortfall);\\n }\\n\\n /**\\n * @notice Determine the current account liquidity wrt collateral requirements\\n * @return (possible error code,\\n account liquidity in excess of collateral requirements,\\n * account shortfall below collateral requirements)\\n */\\n function getAccountLiquidityInternal(address account)\\n internal\\n view\\n returns (\\n Error,\\n uint256,\\n uint256\\n )\\n {\\n return getHypotheticalAccountLiquidityInternal(account, CToken(0), 0, 0);\\n }\\n\\n /**\\n * @notice Determine what the account liquidity would be if the given amounts were redeemed/borrowed\\n * @param cTokenModify The market to hypothetically redeem/borrow in\\n * @param account The account to determine liquidity for\\n * @param redeemTokens The number of tokens to hypothetically redeem\\n * @param borrowAmount The amount of underlying to hypothetically borrow\\n * @return (possible error code (semi-opaque),\\n hypothetical account liquidity in excess of collateral requirements,\\n * hypothetical account shortfall below collateral requirements)\\n */\\n function getHypotheticalAccountLiquidity(\\n address account,\\n address cTokenModify,\\n uint256 redeemTokens,\\n uint256 borrowAmount\\n )\\n public\\n view\\n returns (\\n uint256,\\n uint256,\\n uint256\\n )\\n {\\n (Error err, uint256 liquidity, uint256 shortfall) = getHypotheticalAccountLiquidityInternal(\\n account,\\n CToken(cTokenModify),\\n redeemTokens,\\n borrowAmount\\n );\\n return (uint256(err), liquidity, shortfall);\\n }\\n\\n /**\\n * @notice Determine what the account liquidity would be if the given amounts were redeemed/borrowed\\n * @param cTokenModify The market to hypothetically redeem/borrow in\\n * @param account The account to determine liquidity for\\n * @param redeemTokens The number of tokens to hypothetically redeem\\n * @param borrowAmount The amount of underlying to hypothetically borrow\\n * @dev Note that we calculate the exchangeRateStored for each collateral cToken using stored data,\\n * without calculating accumulated interest.\\n * @return (possible error code,\\n hypothetical account liquidity in excess of collateral requirements,\\n * hypothetical account shortfall below collateral requirements)\\n */\\n function getHypotheticalAccountLiquidityInternal(\\n address account,\\n CToken cTokenModify,\\n uint256 redeemTokens,\\n uint256 borrowAmount\\n )\\n internal\\n view\\n returns (\\n Error,\\n uint256,\\n uint256\\n )\\n {\\n // If credit limit is set to MAX, no need to check account liquidity.\\n if (creditLimits[account] == uint256(-1)) {\\n return (Error.NO_ERROR, uint256(-1), 0);\\n }\\n\\n AccountLiquidityLocalVars memory vars; // Holds all our calculation results\\n uint256 oErr;\\n\\n // For each asset the account is in\\n CToken[] memory assets = accountAssets[account];\\n for (uint256 i = 0; i < assets.length; i++) {\\n CToken asset = assets[i];\\n\\n // Read the balances and exchange rate from the cToken\\n (oErr, vars.cTokenBalance, vars.borrowBalance, vars.exchangeRateMantissa) = asset.getAccountSnapshot(\\n account\\n );\\n if (oErr != 0) {\\n // semi-opaque error code, we assume NO_ERROR == 0 is invariant between upgrades\\n return (Error.SNAPSHOT_ERROR, 0, 0);\\n }\\n\\n // Unlike compound protocol, getUnderlyingPrice is relatively expensive because we use ChainLink as our primary price feed.\\n // If user has no supply / borrow balance on this asset, and user is not redeeming / borrowing this asset, skip it.\\n if (vars.cTokenBalance == 0 && vars.borrowBalance == 0 && asset != cTokenModify) {\\n continue;\\n }\\n\\n vars.collateralFactor = Exp({mantissa: markets[address(asset)].collateralFactorMantissa});\\n vars.exchangeRate = Exp({mantissa: vars.exchangeRateMantissa});\\n\\n // Get the normalized price of the asset\\n vars.oraclePriceMantissa = oracle.getUnderlyingPrice(asset);\\n if (vars.oraclePriceMantissa == 0) {\\n return (Error.PRICE_ERROR, 0, 0);\\n }\\n vars.oraclePrice = Exp({mantissa: vars.oraclePriceMantissa});\\n\\n // Pre-compute a conversion factor from tokens -> ether (normalized price value)\\n vars.tokensToDenom = mul_(mul_(vars.collateralFactor, vars.exchangeRate), vars.oraclePrice);\\n\\n // sumCollateral += tokensToDenom * cTokenBalance\\n vars.sumCollateral = mul_ScalarTruncateAddUInt(vars.tokensToDenom, vars.cTokenBalance, vars.sumCollateral);\\n\\n // sumBorrowPlusEffects += oraclePrice * borrowBalance\\n vars.sumBorrowPlusEffects = mul_ScalarTruncateAddUInt(\\n vars.oraclePrice,\\n vars.borrowBalance,\\n vars.sumBorrowPlusEffects\\n );\\n\\n // Calculate effects of interacting with cTokenModify\\n if (asset == cTokenModify) {\\n // redeem effect\\n // sumBorrowPlusEffects += tokensToDenom * redeemTokens\\n vars.sumBorrowPlusEffects = mul_ScalarTruncateAddUInt(\\n vars.tokensToDenom,\\n redeemTokens,\\n vars.sumBorrowPlusEffects\\n );\\n\\n // borrow effect\\n // sumBorrowPlusEffects += oraclePrice * borrowAmount\\n vars.sumBorrowPlusEffects = mul_ScalarTruncateAddUInt(\\n vars.oraclePrice,\\n borrowAmount,\\n vars.sumBorrowPlusEffects\\n );\\n }\\n }\\n\\n // If credit limit is set, no need to consider collateral.\\n if (creditLimits[account] > 0) {\\n vars.sumCollateral = creditLimits[account];\\n }\\n\\n // These are safe, as the underflow condition is checked first\\n if (vars.sumCollateral > vars.sumBorrowPlusEffects) {\\n return (Error.NO_ERROR, vars.sumCollateral - vars.sumBorrowPlusEffects, 0);\\n } else {\\n return (Error.NO_ERROR, 0, vars.sumBorrowPlusEffects - vars.sumCollateral);\\n }\\n }\\n\\n /**\\n * @notice Calculate number of tokens of collateral asset to seize given an underlying amount\\n * @dev Used in liquidation (called in cToken.liquidateBorrowFresh)\\n * @param cTokenBorrowed The address of the borrowed cToken\\n * @param cTokenCollateral The address of the collateral cToken\\n * @param actualRepayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens\\n * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation)\\n */\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 actualRepayAmount\\n ) external view returns (uint256, uint256) {\\n /* Read oracle prices for borrowed and collateral markets */\\n uint256 priceBorrowedMantissa = oracle.getUnderlyingPrice(CToken(cTokenBorrowed));\\n uint256 priceCollateralMantissa = oracle.getUnderlyingPrice(CToken(cTokenCollateral));\\n if (priceBorrowedMantissa == 0 || priceCollateralMantissa == 0) {\\n return (uint256(Error.PRICE_ERROR), 0);\\n }\\n\\n /*\\n * Get the exchange rate and calculate the number of collateral tokens to seize:\\n * seizeAmount = actualRepayAmount * liquidationIncentive * priceBorrowed / priceCollateral\\n * seizeTokens = seizeAmount / exchangeRate\\n * = actualRepayAmount * (liquidationIncentive * priceBorrowed) / (priceCollateral * exchangeRate)\\n */\\n uint256 exchangeRateMantissa = CToken(cTokenCollateral).exchangeRateStored(); // Note: reverts on error\\n Exp memory numerator = mul_(\\n Exp({mantissa: liquidationIncentiveMantissa}),\\n Exp({mantissa: priceBorrowedMantissa})\\n );\\n Exp memory denominator = mul_(Exp({mantissa: priceCollateralMantissa}), Exp({mantissa: exchangeRateMantissa}));\\n Exp memory ratio = div_(numerator, denominator);\\n uint256 seizeTokens = mul_ScalarTruncate(ratio, actualRepayAmount);\\n\\n return (uint256(Error.NO_ERROR), seizeTokens);\\n }\\n\\n /*** Admin Functions ***/\\n\\n /**\\n * @notice Sets a new price oracle for the comptroller\\n * @dev Admin function to set a new price oracle\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _setPriceOracle(PriceOracle newOracle) public returns (uint256) {\\n // Check caller is admin\\n if (msg.sender != admin) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.SET_PRICE_ORACLE_OWNER_CHECK);\\n }\\n\\n // Track the old oracle for the comptroller\\n PriceOracle oldOracle = oracle;\\n\\n // Set comptroller's oracle to newOracle\\n oracle = newOracle;\\n\\n // Emit NewPriceOracle(oldOracle, newOracle)\\n emit NewPriceOracle(oldOracle, newOracle);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Sets the closeFactor used when liquidating borrows\\n * @dev Admin function to set closeFactor\\n * @param newCloseFactorMantissa New close factor, scaled by 1e18\\n * @return uint 0=success, otherwise a failure. (See ErrorReporter for details)\\n */\\n function _setCloseFactor(uint256 newCloseFactorMantissa) external returns (uint256) {\\n // Check caller is admin\\n if (msg.sender != admin) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.SET_CLOSE_FACTOR_OWNER_CHECK);\\n }\\n\\n uint256 oldCloseFactorMantissa = closeFactorMantissa;\\n closeFactorMantissa = newCloseFactorMantissa;\\n emit NewCloseFactor(oldCloseFactorMantissa, closeFactorMantissa);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Sets the collateralFactor for a market\\n * @dev Admin function to set per-market collateralFactor\\n * @param cToken The market to set the factor on\\n * @param newCollateralFactorMantissa The new collateral factor, scaled by 1e18\\n * @return uint 0=success, otherwise a failure. (See ErrorReporter for details)\\n */\\n function _setCollateralFactor(CToken cToken, uint256 newCollateralFactorMantissa) external returns (uint256) {\\n // Check caller is admin\\n if (msg.sender != admin) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.SET_COLLATERAL_FACTOR_OWNER_CHECK);\\n }\\n\\n // Verify market is listed\\n Market storage market = markets[address(cToken)];\\n if (!market.isListed) {\\n return fail(Error.MARKET_NOT_LISTED, FailureInfo.SET_COLLATERAL_FACTOR_NO_EXISTS);\\n }\\n\\n Exp memory newCollateralFactorExp = Exp({mantissa: newCollateralFactorMantissa});\\n\\n // Check collateral factor <= 0.9\\n Exp memory highLimit = Exp({mantissa: collateralFactorMaxMantissa});\\n if (lessThanExp(highLimit, newCollateralFactorExp)) {\\n return fail(Error.INVALID_COLLATERAL_FACTOR, FailureInfo.SET_COLLATERAL_FACTOR_VALIDATION);\\n }\\n\\n // If collateral factor != 0, fail if price == 0\\n if (newCollateralFactorMantissa != 0 && oracle.getUnderlyingPrice(cToken) == 0) {\\n return fail(Error.PRICE_ERROR, FailureInfo.SET_COLLATERAL_FACTOR_WITHOUT_PRICE);\\n }\\n\\n // Set market's collateral factor to new collateral factor, remember old value\\n uint256 oldCollateralFactorMantissa = market.collateralFactorMantissa;\\n market.collateralFactorMantissa = newCollateralFactorMantissa;\\n\\n // Emit event with asset, old collateral factor, and new collateral factor\\n emit NewCollateralFactor(cToken, oldCollateralFactorMantissa, newCollateralFactorMantissa);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Sets liquidationIncentive\\n * @dev Admin function to set liquidationIncentive\\n * @param newLiquidationIncentiveMantissa New liquidationIncentive scaled by 1e18\\n * @return uint 0=success, otherwise a failure. (See ErrorReporter for details)\\n */\\n function _setLiquidationIncentive(uint256 newLiquidationIncentiveMantissa) external returns (uint256) {\\n // Check caller is admin\\n if (msg.sender != admin) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.SET_LIQUIDATION_INCENTIVE_OWNER_CHECK);\\n }\\n\\n // Save current value for use in log\\n uint256 oldLiquidationIncentiveMantissa = liquidationIncentiveMantissa;\\n\\n // Set liquidation incentive to new incentive\\n liquidationIncentiveMantissa = newLiquidationIncentiveMantissa;\\n\\n // Emit event with old incentive, new incentive\\n emit NewLiquidationIncentive(oldLiquidationIncentiveMantissa, newLiquidationIncentiveMantissa);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Add the market to the markets mapping and set it as listed\\n * @dev Admin function to set isListed and add support for the market\\n * @param cToken The address of the market (token) to list\\n * @param version The version of the market (token)\\n * @return uint 0=success, otherwise a failure. (See enum Error for details)\\n */\\n function _supportMarket(CToken cToken, Version version) external returns (uint256) {\\n require(msg.sender == admin, \\\"only admin may support market\\\");\\n require(!isMarketListed(address(cToken)), \\\"market already listed\\\");\\n\\n cToken.isCToken(); // Sanity check to make sure its really a CToken\\n\\n markets[address(cToken)] = Market({isListed: true, collateralFactorMantissa: 0, version: version});\\n\\n _addMarketInternal(address(cToken));\\n\\n emit MarketListed(cToken);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Remove the market from the markets mapping\\n * @param cToken The address of the market (token) to delist\\n */\\n function _delistMarket(CToken cToken) external {\\n require(msg.sender == admin, \\\"only admin may delist market\\\");\\n require(isMarketListed(address(cToken)), \\\"market not listed\\\");\\n require(cToken.totalSupply() == 0, \\\"market not empty\\\");\\n\\n cToken.isCToken(); // Sanity check to make sure its really a CToken\\n\\n delete markets[address(cToken)];\\n\\n for (uint256 i = 0; i < allMarkets.length; i++) {\\n if (allMarkets[i] == cToken) {\\n allMarkets[i] = allMarkets[allMarkets.length - 1];\\n delete allMarkets[allMarkets.length - 1];\\n allMarkets.length--;\\n break;\\n }\\n }\\n\\n emit MarketDelisted(cToken);\\n }\\n\\n function _addMarketInternal(address cToken) internal {\\n for (uint256 i = 0; i < allMarkets.length; i++) {\\n require(allMarkets[i] != CToken(cToken), \\\"market already added\\\");\\n }\\n allMarkets.push(CToken(cToken));\\n }\\n\\n /**\\n * @notice Admin function to change the Supply Cap Guardian\\n * @param newSupplyCapGuardian The address of the new Supply Cap Guardian\\n */\\n function _setSupplyCapGuardian(address newSupplyCapGuardian) external {\\n require(msg.sender == admin, \\\"only admin can set supply cap guardian\\\");\\n\\n // Save current value for inclusion in log\\n address oldSupplyCapGuardian = supplyCapGuardian;\\n\\n // Store supplyCapGuardian with value newSupplyCapGuardian\\n supplyCapGuardian = newSupplyCapGuardian;\\n\\n // Emit NewSupplyCapGuardian(OldSupplyCapGuardian, NewSupplyCapGuardian)\\n emit NewSupplyCapGuardian(oldSupplyCapGuardian, newSupplyCapGuardian);\\n }\\n\\n /**\\n * @notice Set the given supply caps for the given cToken markets. Supplying that brings total supplys to or above supply cap will revert.\\n * @dev Admin or supplyCapGuardian function to set the supply caps. A supply cap of 0 corresponds to unlimited supplying. If the total borrows\\n * already exceeded the cap, it will prevent anyone to borrow.\\n * @param cTokens The addresses of the markets (tokens) to change the supply caps for\\n * @param newSupplyCaps The new supply cap values in underlying to be set. A value of 0 corresponds to unlimited supplying.\\n */\\n function _setMarketSupplyCaps(CToken[] calldata cTokens, uint256[] calldata newSupplyCaps) external {\\n require(\\n msg.sender == admin || msg.sender == supplyCapGuardian,\\n \\\"only admin or supply cap guardian can set supply caps\\\"\\n );\\n\\n uint256 numMarkets = cTokens.length;\\n uint256 numSupplyCaps = newSupplyCaps.length;\\n\\n require(numMarkets != 0 && numMarkets == numSupplyCaps, \\\"invalid input\\\");\\n\\n for (uint256 i = 0; i < numMarkets; i++) {\\n supplyCaps[address(cTokens[i])] = newSupplyCaps[i];\\n emit NewSupplyCap(cTokens[i], newSupplyCaps[i]);\\n }\\n }\\n\\n /**\\n * @notice Set the given borrow caps for the given cToken markets. Borrowing that brings total borrows to or above borrow cap will revert.\\n * @dev Admin or borrowCapGuardian function to set the borrow caps. A borrow cap of 0 corresponds to unlimited borrowing. If the total supplies\\n * already exceeded the cap, it will prevent anyone to mint.\\n * @param cTokens The addresses of the markets (tokens) to change the borrow caps for\\n * @param newBorrowCaps The new borrow cap values in underlying to be set. A value of 0 corresponds to unlimited borrowing.\\n */\\n function _setMarketBorrowCaps(CToken[] calldata cTokens, uint256[] calldata newBorrowCaps) external {\\n require(\\n msg.sender == admin || msg.sender == borrowCapGuardian,\\n \\\"only admin or borrow cap guardian can set borrow caps\\\"\\n );\\n\\n uint256 numMarkets = cTokens.length;\\n uint256 numBorrowCaps = newBorrowCaps.length;\\n\\n require(numMarkets != 0 && numMarkets == numBorrowCaps, \\\"invalid input\\\");\\n\\n for (uint256 i = 0; i < numMarkets; i++) {\\n borrowCaps[address(cTokens[i])] = newBorrowCaps[i];\\n emit NewBorrowCap(cTokens[i], newBorrowCaps[i]);\\n }\\n }\\n\\n /**\\n * @notice Admin function to change the Borrow Cap Guardian\\n * @param newBorrowCapGuardian The address of the new Borrow Cap Guardian\\n */\\n function _setBorrowCapGuardian(address newBorrowCapGuardian) external {\\n require(msg.sender == admin, \\\"only admin can set borrow cap guardian\\\");\\n\\n // Save current value for inclusion in log\\n address oldBorrowCapGuardian = borrowCapGuardian;\\n\\n // Store borrowCapGuardian with value newBorrowCapGuardian\\n borrowCapGuardian = newBorrowCapGuardian;\\n\\n // Emit NewBorrowCapGuardian(OldBorrowCapGuardian, NewBorrowCapGuardian)\\n emit NewBorrowCapGuardian(oldBorrowCapGuardian, newBorrowCapGuardian);\\n }\\n\\n /**\\n * @notice Admin function to change the Pause Guardian\\n * @param newPauseGuardian The address of the new Pause Guardian\\n * @return uint 0=success, otherwise a failure. (See enum Error for details)\\n */\\n function _setPauseGuardian(address newPauseGuardian) public returns (uint256) {\\n if (msg.sender != admin) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.SET_PAUSE_GUARDIAN_OWNER_CHECK);\\n }\\n\\n // Save current value for inclusion in log\\n address oldPauseGuardian = pauseGuardian;\\n\\n // Store pauseGuardian with value newPauseGuardian\\n pauseGuardian = newPauseGuardian;\\n\\n // Emit NewPauseGuardian(OldPauseGuardian, NewPauseGuardian)\\n emit NewPauseGuardian(oldPauseGuardian, pauseGuardian);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Admin function to set the liquidity mining module address\\n * @dev Removing the liquidity mining module address could cause the inconsistency in the LM module.\\n * @param newLiquidityMining The address of the new liquidity mining module\\n */\\n function _setLiquidityMining(address newLiquidityMining) external {\\n require(msg.sender == admin, \\\"only admin can set liquidity mining module\\\");\\n require(LiquidityMiningInterface(newLiquidityMining).comptroller() == address(this), \\\"mismatch comptroller\\\");\\n\\n // Save current value for inclusion in log\\n address oldLiquidityMining = liquidityMining;\\n\\n // Store pauseGuardian with value newLiquidityMining\\n liquidityMining = newLiquidityMining;\\n\\n // Emit NewLiquidityMining(OldLiquidityMining, NewLiquidityMining)\\n emit NewLiquidityMining(oldLiquidityMining, liquidityMining);\\n }\\n\\n function _setMintPaused(CToken cToken, bool state) public returns (bool) {\\n require(isMarketListed(address(cToken)), \\\"cannot pause a market that is not listed\\\");\\n require(msg.sender == pauseGuardian || msg.sender == admin, \\\"only pause guardian and admin can pause\\\");\\n require(msg.sender == admin || state == true, \\\"only admin can unpause\\\");\\n\\n mintGuardianPaused[address(cToken)] = state;\\n emit ActionPaused(cToken, \\\"Mint\\\", state);\\n return state;\\n }\\n\\n function _setBorrowPaused(CToken cToken, bool state) public returns (bool) {\\n require(isMarketListed(address(cToken)), \\\"cannot pause a market that is not listed\\\");\\n require(msg.sender == pauseGuardian || msg.sender == admin, \\\"only pause guardian and admin can pause\\\");\\n require(msg.sender == admin || state == true, \\\"only admin can unpause\\\");\\n\\n borrowGuardianPaused[address(cToken)] = state;\\n emit ActionPaused(cToken, \\\"Borrow\\\", state);\\n return state;\\n }\\n\\n function _setFlashloanPaused(CToken cToken, bool state) public returns (bool) {\\n require(isMarketListed(address(cToken)), \\\"cannot pause a market that is not listed\\\");\\n require(msg.sender == pauseGuardian || msg.sender == admin, \\\"only pause guardian and admin can pause\\\");\\n require(msg.sender == admin || state == true, \\\"only admin can unpause\\\");\\n\\n flashloanGuardianPaused[address(cToken)] = state;\\n emit ActionPaused(cToken, \\\"Flashloan\\\", state);\\n return state;\\n }\\n\\n function _setTransferPaused(bool state) public returns (bool) {\\n require(msg.sender == pauseGuardian || msg.sender == admin, \\\"only pause guardian and admin can pause\\\");\\n require(msg.sender == admin || state == true, \\\"only admin can unpause\\\");\\n\\n transferGuardianPaused = state;\\n emit ActionPaused(\\\"Transfer\\\", state);\\n return state;\\n }\\n\\n function _setSeizePaused(bool state) public returns (bool) {\\n require(msg.sender == pauseGuardian || msg.sender == admin, \\\"only pause guardian and admin can pause\\\");\\n require(msg.sender == admin || state == true, \\\"only admin can unpause\\\");\\n\\n seizeGuardianPaused = state;\\n emit ActionPaused(\\\"Seize\\\", state);\\n return state;\\n }\\n\\n function _become(Unitroller unitroller) public {\\n require(msg.sender == unitroller.admin(), \\\"only unitroller admin can change brains\\\");\\n require(unitroller._acceptImplementation() == 0, \\\"change not authorized\\\");\\n }\\n\\n /**\\n * @notice Sets whitelisted protocol's credit limit\\n * @param protocol The address of the protocol\\n * @param creditLimit The credit limit\\n */\\n function _setCreditLimit(address protocol, uint256 creditLimit) public {\\n require(msg.sender == admin, \\\"only admin can set protocol credit limit\\\");\\n\\n creditLimits[protocol] = creditLimit;\\n emit CreditLimitChanged(protocol, creditLimit);\\n }\\n\\n /**\\n * @notice Checks caller is admin, or this contract is becoming the new implementation\\n */\\n function adminOrInitializing() internal view returns (bool) {\\n return msg.sender == admin || msg.sender == comptrollerImplementation;\\n }\\n\\n /*** JOE Distribution ***/\\n\\n /**\\n * @notice Set JOE/AVAX speed for a single market\\n * @param rewardType 0: JOE, 1: AVAX \\n * @param cToken The market whose speed to update\\n * @param newSpeed New JOE or AVAX speed for market\\n */\\n function setCompSpeedInternal(uint8 rewardType, CToken cToken, uint newSpeed) internal {\\n uint currentCompSpeed = compSpeeds[rewardType][address(cToken)];\\n if (currentCompSpeed != 0) {\\n // note that JOE speed could be set to 0 to halt liquidity rewards for a market\\n Exp memory borrowIndex = Exp({mantissa: cToken.borrowIndex()});\\n updateCompSupplyIndex(rewardType, address(cToken));\\n updateCompBorrowIndex(rewardType, address(cToken), borrowIndex);\\n } else if (newSpeed != 0) {\\n // Add the JOE market\\n Market storage market = markets[address(cToken)];\\n require(market.isListed == true, \\\"joe market is not listed\\\");\\n\\n if (compSupplyState[rewardType][address(cToken)].index == 0 &&\\n compSupplyState[rewardType][address(cToken)].block == 0) {\\n compSupplyState[rewardType][address(cToken)] = CompMarketState({\\n index: compInitialIndex,\\n block: safe32(getBlockNumber(), \\\"block timestamp exceeds 32 bits\\\")\\n });\\n }\\n\\n if (compBorrowState[rewardType][address(cToken)].index == 0 &&\\n compBorrowState[rewardType][address(cToken)].block == 0) {\\n compBorrowState[rewardType][address(cToken)] = CompMarketState({\\n index: compInitialIndex,\\n block: safe32(getBlockNumber(), \\\"block timestamp exceeds 32 bits\\\")\\n });\\n }\\n }\\n\\n if (currentCompSpeed != newSpeed) {\\n compSpeeds[rewardType][address(cToken)] = newSpeed;\\n emit CompSpeedUpdated(rewardType, cToken, newSpeed);\\n }\\n }\\n\\n /**\\n * @notice Accrue JOE to the market by updating the supply index\\n * @param rewardType 0: JOE, 1: AVAX \\n * @param cToken The market whose supply index to update\\n */\\n function updateCompSupplyIndex(uint8 rewardType, address cToken) internal {\\n require(rewardType <= 1, \\\"rewardType is invalid\\\"); \\n CompMarketState storage supplyState = compSupplyState[rewardType][cToken];\\n uint supplySpeed = compSpeeds[rewardType][cToken];\\n uint blockNumber = getBlockNumber();\\n uint deltaBlocks = sub_(blockNumber, uint(supplyState.block));\\n if (deltaBlocks > 0 && supplySpeed > 0) {\\n uint supplyTokens = CToken(cToken).totalSupply();\\n uint compAccrued = mul_(deltaBlocks, supplySpeed);\\n Double memory ratio = supplyTokens > 0 ? fraction(compAccrued, supplyTokens) : Double({mantissa: 0});\\n Double memory index = add_(Double({mantissa: supplyState.index}), ratio);\\n compSupplyState[rewardType][cToken] = CompMarketState({\\n index: safe224(index.mantissa, \\\"new index exceeds 224 bits\\\"),\\n block: safe32(blockNumber, \\\"block timestamp exceeds 32 bits\\\")\\n });\\n } else if (deltaBlocks > 0) {\\n supplyState.block = safe32(blockNumber, \\\"block timestamp exceeds 32 bits\\\");\\n }\\n }\\n\\n /**\\n * @notice Accrue JOE to the market by updating the borrow index\\n * @param rewardType 0: JOE, 1: AVAX \\n * @param cToken The market whose borrow index to update\\n */\\n function updateCompBorrowIndex(uint8 rewardType, address cToken, Exp memory marketBorrowIndex) internal {\\n require(rewardType <= 1, \\\"rewardType is invalid\\\"); \\n CompMarketState storage borrowState = compBorrowState[rewardType][cToken];\\n uint borrowSpeed = compSpeeds[rewardType][cToken];\\n uint blockNumber = getBlockNumber();\\n uint deltaBlocks = sub_(blockNumber, uint(borrowState.block));\\n if (deltaBlocks > 0 && borrowSpeed > 0) {\\n uint borrowAmount = div_(CToken(cToken).totalBorrows(), marketBorrowIndex);\\n uint compAccrued = mul_(deltaBlocks, borrowSpeed);\\n Double memory ratio = borrowAmount > 0 ? fraction(compAccrued, borrowAmount) : Double({mantissa: 0});\\n Double memory index = add_(Double({mantissa: borrowState.index}), ratio);\\n compBorrowState[rewardType][cToken] = CompMarketState({\\n index: safe224(index.mantissa, \\\"new index exceeds 224 bits\\\"),\\n block: safe32(blockNumber, \\\"block timestamp exceeds 32 bits\\\")\\n });\\n } else if (deltaBlocks > 0) {\\n borrowState.block = safe32(blockNumber, \\\"block timestamp exceeds 32 bits\\\");\\n }\\n }\\n\\n /**\\n * @notice Refactored function to calc and rewards accounts supplier rewards\\n * @param cToken The market to verify the mint against\\n * @param supplier The supplier to be rewarded\\n */\\n function updateAndDistributeSupplierRewardsForToken(address cToken, address supplier) internal {\\n for (uint8 rewardType = 0; rewardType <= 1; rewardType++) {\\n updateCompSupplyIndex(rewardType, cToken);\\n distributeSupplierComp(rewardType, cToken, supplier);\\n }\\n }\\n\\n /**\\n * @notice Calculate JOE/AVAX accrued by a supplier and possibly transfer it to them\\n * @param rewardType 0: JOE, 1: AVAX \\n * @param cToken The market in which the supplier is interacting\\n * @param supplier The address of the supplier to distribute JOE to\\n */\\n function distributeSupplierComp(uint8 rewardType, address cToken, address supplier) internal {\\n require(rewardType <= 1, \\\"rewardType is invalid\\\"); \\n CompMarketState storage supplyState = compSupplyState[rewardType][cToken];\\n Double memory supplyIndex = Double({mantissa: supplyState.index});\\n Double memory supplierIndex = Double({mantissa:\\n compSupplierIndex[rewardType][cToken][supplier]});\\n compSupplierIndex[rewardType][cToken][supplier] = supplyIndex.mantissa;\\n\\n if (supplierIndex.mantissa == 0 && supplyIndex.mantissa > 0) {\\n supplierIndex.mantissa = compInitialIndex;\\n }\\n\\n Double memory deltaIndex = sub_(supplyIndex, supplierIndex);\\n uint supplierTokens = CToken(cToken).balanceOf(supplier);\\n uint supplierDelta = mul_(supplierTokens, deltaIndex);\\n uint supplierAccrued = add_(compAccrued[rewardType][supplier], supplierDelta);\\n compAccrued[rewardType][supplier] = supplierAccrued;\\n emit DistributedSupplierComp(rewardType, CToken(cToken), supplier, supplierDelta, supplyIndex.mantissa);\\n }\\n\\n /**\\n * @notice Refactored function to calc and rewards accounts supplier rewards\\n * @param cToken The market to verify the mint against\\n * @param borrower Borrower to be rewarded\\n */\\n function updateAndDistributeBorrowerRewardsForToken(address cToken, address borrower, Exp memory marketBorrowIndex) internal {\\n for (uint8 rewardType = 0; rewardType <= 1; rewardType++) {\\n updateCompBorrowIndex(rewardType, cToken, marketBorrowIndex);\\n distributeBorrowerComp(rewardType, cToken, borrower, marketBorrowIndex);\\n }\\n }\\n\\n /**\\n * @notice Calculate JOE accrued by a borrower and possibly transfer it to them\\n * @dev Borrowers will not begin to accrue until after the first interaction with the protocol.\\n * @param rewardType 0: JOE, 1: AVAX \\n * @param cToken The market in which the borrower is interacting\\n * @param borrower The address of the borrower to distribute JOE to\\n */\\n function distributeBorrowerComp(uint8 rewardType, address cToken, address borrower, Exp memory marketBorrowIndex) internal {\\n require(rewardType <= 1, \\\"rewardType is invalid\\\"); \\n CompMarketState storage borrowState = compBorrowState[rewardType][cToken];\\n Double memory borrowIndex = Double({mantissa: borrowState.index});\\n Double memory borrowerIndex = Double({mantissa:\\n compBorrowerIndex[rewardType][cToken][borrower]});\\n compBorrowerIndex[rewardType][cToken][borrower] = borrowIndex.mantissa;\\n\\n if (borrowerIndex.mantissa > 0) {\\n Double memory deltaIndex = sub_(borrowIndex, borrowerIndex);\\n uint borrowerAmount = div_(CToken(cToken).borrowBalanceStored(borrower), marketBorrowIndex);\\n uint borrowerDelta = mul_(borrowerAmount, deltaIndex);\\n uint borrowerAccrued = add_(compAccrued[rewardType][borrower], borrowerDelta);\\n compAccrued[rewardType][borrower] = borrowerAccrued;\\n emit DistributedBorrowerComp(rewardType, CToken(cToken), borrower, borrowerDelta, borrowIndex.mantissa);\\n }\\n }\\n\\n /**\\n * @notice Claim all the JOE/AVAX accrued by holder in all markets\\n * @param holder The address to claim JOE/AVAX for\\n */\\n function claimComp(uint8 rewardType, address payable holder) public {\\n return claimComp(rewardType, holder, allMarkets);\\n }\\n\\n /**\\n * @notice Claim all the JOE/AVAX accrued by holder in the specified markets\\n * @param holder The address to claim JOE/AVAX for\\n * @param cTokens The list of markets to claim JOE/AVAX in\\n */\\n function claimComp(uint8 rewardType, address payable holder, CToken[] memory cTokens) public {\\n address payable [] memory holders = new address payable[](1);\\n holders[0] = holder;\\n claimComp(rewardType, holders, cTokens, true, true);\\n }\\n\\n /**\\n * @notice Claim all JOE/AVAX accrued by the holders\\n * @param rewardType 0 = JOE, 1 = AVAX\\n * @param holders The addresses to claim JOE/AVAX for\\n * @param cTokens The list of markets to claim JOE/AVAX in\\n * @param borrowers Whether or not to claim JOE/AVAX earned by borrowing\\n * @param suppliers Whether or not to claim JOE/AVAX earned by supplying\\n */\\n function claimComp(uint8 rewardType, address payable[] memory holders, CToken[] memory cTokens, bool borrowers, bool suppliers) public payable {\\n require(rewardType <= 1, \\\"rewardType is invalid\\\");\\n for (uint i = 0; i < cTokens.length; i++) {\\n CToken cToken = cTokens[i];\\n require(markets[address(cToken)].isListed, \\\"market must be listed\\\");\\n if (borrowers == true) {\\n Exp memory borrowIndex = Exp({mantissa: cToken.borrowIndex()});\\n updateCompBorrowIndex(rewardType, address(cToken), borrowIndex);\\n for (uint j = 0; j < holders.length; j++) {\\n distributeBorrowerComp(rewardType, address(cToken), holders[j], borrowIndex);\\n compAccrued[rewardType][holders[j]] = grantRewardInternal(rewardType, holders[j], compAccrued[rewardType][holders[j]]);\\n }\\n }\\n if (suppliers == true) {\\n updateCompSupplyIndex(rewardType, address(cToken));\\n for (uint j = 0; j < holders.length; j++) {\\n distributeSupplierComp(rewardType, address(cToken), holders[j]);\\n compAccrued[rewardType][holders[j]] = grantRewardInternal(rewardType, holders[j], compAccrued[rewardType][holders[j]]);\\n }\\n }\\n }\\n }\\n\\n /**\\n * @notice Transfer JOE/AVAX to the user\\n * @dev Note: If there is not enough JOE/AVAX, we do not perform the transfer all.\\n * @param user The address of the user to transfer JOE/AVAX to\\n * @param amount The amount of JOE/AVAX to (possibly) transfer\\n * @return The amount of JOE/AVAX which was NOT transferred to the user\\n */\\n function grantRewardInternal(uint rewardType, address payable user, uint amount) internal returns (uint) {\\n if (rewardType == 0) {\\n Comp comp = Comp(joeAddress);\\n uint compRemaining = comp.balanceOf(address(this));\\n if (amount > 0 && amount <= compRemaining) {\\n comp.transfer(user, amount);\\n return 0;\\n }\\n } else if (rewardType == 1) {\\n uint avaxRemaining = address(this).balance;\\n if (amount > 0 && amount <= avaxRemaining) {\\n user.transfer(amount);\\n return 0;\\n }\\n }\\n return amount;\\n }\\n\\n /*** Joe Distribution Admin ***/\\n\\n /**\\n * @notice Transfer JOE to the recipient\\n * @dev Note: If there is not enough JOE, we do not perform the transfer all.\\n * @param recipient The address of the recipient to transfer JOE to\\n * @param amount The amount of JOE to (possibly) transfer\\n */\\n function _grantComp(address payable recipient, uint amount) public {\\n require(adminOrInitializing(), \\\"only admin can grant joe\\\");\\n uint amountLeft = grantRewardInternal(0, recipient, amount);\\n require(amountLeft == 0, \\\"insufficient joe for grant\\\");\\n emit CompGranted(recipient, amount);\\n }\\n\\n /**\\n * @notice Set JOE/AVAX speed for a single market\\n * @param rewardType 0 = QI, 1 = AVAX\\n * @param cToken The market whose reward speed to update\\n * @param compSpeed New reward speed for market\\n */\\n function _setCompSpeed(uint8 rewardType, CToken cToken, uint compSpeed) public {\\n require(rewardType <= 1, \\\"rewardType is invalid\\\"); \\n require(adminOrInitializing(), \\\"only admin can set reward speed\\\");\\n setCompSpeedInternal(rewardType, cToken, compSpeed);\\n }\\n\\n /**\\n * @notice Set the JOE token address\\n */\\n function setJoeAddress(address newJoeAddress) public {\\n require(msg.sender == admin);\\n joeAddress = newJoeAddress;\\n }\\n\\n /**\\n * @notice payable function needed to receive AVAX\\n */\\n function () payable external {\\n }\\n\\n /**\\n * @notice Return all of the markets\\n * @dev The automatic getter may be used to access an individual market.\\n * @return The list of market addresses\\n */\\n function getAllMarkets() public view returns (CToken[] memory) {\\n return allMarkets;\\n }\\n\\n function getBlockNumber() public view returns (uint256) {\\n return block.timestamp;\\n }\\n}\\n\",\"keccak256\":\"0xb73dd0e1e7f0d9802cbf63521e1f3416d950ebf823b41bee985f84f16fbe0367\"},\"contracts/ComptrollerInterface.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\nimport \\\"./CToken.sol\\\";\\nimport \\\"./ComptrollerStorage.sol\\\";\\n\\ncontract ComptrollerInterface {\\n /// @notice Indicator that this is a Comptroller contract (for inspection)\\n bool public constant isComptroller = true;\\n\\n /*** Assets You Are In ***/\\n\\n function enterMarkets(address[] calldata cTokens) external returns (uint256[] memory);\\n\\n function exitMarket(address cToken) external returns (uint256);\\n\\n /*** Policy Hooks ***/\\n\\n function mintAllowed(\\n address cToken,\\n address minter,\\n uint256 mintAmount\\n ) external returns (uint256);\\n\\n function mintVerify(\\n address cToken,\\n address minter,\\n uint256 mintAmount,\\n uint256 mintTokens\\n ) external;\\n\\n function redeemAllowed(\\n address cToken,\\n address redeemer,\\n uint256 redeemTokens\\n ) external returns (uint256);\\n\\n function redeemVerify(\\n address cToken,\\n address redeemer,\\n uint256 redeemAmount,\\n uint256 redeemTokens\\n ) external;\\n\\n function borrowAllowed(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external returns (uint256);\\n\\n function borrowVerify(\\n address cToken,\\n address borrower,\\n uint256 borrowAmount\\n ) external;\\n\\n function repayBorrowAllowed(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function repayBorrowVerify(\\n address cToken,\\n address payer,\\n address borrower,\\n uint256 repayAmount,\\n uint256 borrowerIndex\\n ) external;\\n\\n function liquidateBorrowAllowed(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount\\n ) external returns (uint256);\\n\\n function liquidateBorrowVerify(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n address liquidator,\\n address borrower,\\n uint256 repayAmount,\\n uint256 seizeTokens\\n ) external;\\n\\n function seizeAllowed(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external returns (uint256);\\n\\n function seizeVerify(\\n address cTokenCollateral,\\n address cTokenBorrowed,\\n address liquidator,\\n address borrower,\\n uint256 seizeTokens\\n ) external;\\n\\n function transferAllowed(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external returns (uint256);\\n\\n function transferVerify(\\n address cToken,\\n address src,\\n address dst,\\n uint256 transferTokens\\n ) external;\\n\\n /*** Liquidity/Liquidation Calculations ***/\\n\\n function liquidateCalculateSeizeTokens(\\n address cTokenBorrowed,\\n address cTokenCollateral,\\n uint256 repayAmount\\n ) external view returns (uint256, uint256);\\n}\\n\\ninterface ComptrollerInterfaceExtension {\\n function checkMembership(address account, CToken cToken) external view returns (bool);\\n\\n function updateCTokenVersion(address cToken, ComptrollerV1Storage.Version version) external;\\n\\n function flashloanAllowed(\\n address cToken,\\n address receiver,\\n uint256 amount,\\n bytes calldata params\\n ) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xf0d6ccceedab5506e6e66686b2a5063081eac187cc68bab30c6f573de3408909\"},\"contracts/ComptrollerStorage.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\nimport \\\"./CToken.sol\\\";\\nimport \\\"./PriceOracle/PriceOracle.sol\\\";\\n\\ncontract UnitrollerAdminStorage {\\n /**\\n * @notice Administrator for this contract\\n */\\n address public admin;\\n\\n /**\\n * @notice Pending administrator for this contract\\n */\\n address public pendingAdmin;\\n\\n /**\\n * @notice Active brains of Unitroller\\n */\\n address public comptrollerImplementation;\\n\\n /**\\n * @notice Pending brains of Unitroller\\n */\\n address public pendingComptrollerImplementation;\\n}\\n\\ncontract ComptrollerV1Storage is UnitrollerAdminStorage {\\n /**\\n * @notice Oracle which gives the price of any given asset\\n */\\n PriceOracle public oracle;\\n\\n /**\\n * @notice Multiplier used to calculate the maximum repayAmount when liquidating a borrow\\n */\\n uint256 public closeFactorMantissa;\\n\\n /**\\n * @notice Multiplier representing the discount on collateral that a liquidator receives\\n */\\n uint256 public liquidationIncentiveMantissa;\\n\\n /**\\n * @notice Per-account mapping of \\\"assets you are in\\\"\\n */\\n mapping(address => CToken[]) public accountAssets;\\n\\n enum Version {\\n VANILLA,\\n COLLATERALCAP,\\n WRAPPEDNATIVE\\n }\\n\\n struct Market {\\n /// @notice Whether or not this market is listed\\n bool isListed;\\n /**\\n * @notice Multiplier representing the most one can borrow against their collateral in this market.\\n * For instance, 0.9 to allow borrowing 90% of collateral value.\\n * Must be between 0 and 1, and stored as a mantissa.\\n */\\n uint256 collateralFactorMantissa;\\n /// @notice Per-market mapping of \\\"accounts in this asset\\\"\\n mapping(address => bool) accountMembership;\\n /// @notice CToken version\\n Version version;\\n }\\n\\n /**\\n * @notice Official mapping of cTokens -> Market metadata\\n * @dev Used e.g. to determine if a market is supported\\n */\\n mapping(address => Market) public markets;\\n\\n /**\\n * @notice The Pause Guardian can pause certain actions as a safety mechanism.\\n * Actions which allow users to remove their own assets cannot be paused.\\n * Liquidation / seizing / transfer can only be paused globally, not by market.\\n */\\n address public pauseGuardian;\\n bool public _mintGuardianPaused;\\n bool public _borrowGuardianPaused;\\n bool public transferGuardianPaused;\\n bool public seizeGuardianPaused;\\n mapping(address => bool) public mintGuardianPaused;\\n mapping(address => bool) public borrowGuardianPaused;\\n\\n struct CompMarketState {\\n /// @notice The market's last updated compBorrowIndex or compSupplyIndex\\n uint224 index;\\n /// @notice The block number the index was last updated at\\n uint32 block;\\n }\\n\\n /// @notice A list of all markets\\n CToken[] public allMarkets;\\n\\n /// @notice The portion of compRate that each market currently receives\\n mapping(uint8 => mapping(address => uint256)) public compSpeeds;\\n\\n /// @notice The COMP market supply state for each market\\n mapping(uint8 => mapping(address => CompMarketState)) public compSupplyState;\\n\\n /// @notice The COMP market borrow state for each market\\n mapping(uint8 => mapping(address => CompMarketState)) public compBorrowState;\\n\\n /// @notice The COMP borrow index for each market for each supplier as of the last time they accrued COMP\\n mapping(uint8 => mapping(address => mapping(address => uint256))) public compSupplierIndex;\\n\\n /// @notice The COMP borrow index for each market for each borrower as of the last time they accrued COMP\\n mapping(uint8 => mapping(address => mapping(address => uint256))) public compBorrowerIndex;\\n\\n /// @notice The COMP accrued but not yet transferred to each user\\n mapping(uint8 => mapping(address => uint256)) public compAccrued;\\n\\n // @notice The borrowCapGuardian can set borrowCaps to any number for any market. Lowering the borrow cap could disable borrowing on the given market.\\n address public borrowCapGuardian;\\n\\n // @notice Borrow caps enforced by borrowAllowed for each cToken address. Defaults to zero which corresponds to unlimited borrowing.\\n mapping(address => uint256) public borrowCaps;\\n\\n // @notice The supplyCapGuardian can set supplyCaps to any number for any market. Lowering the supply cap could disable supplying to the given market.\\n address public supplyCapGuardian;\\n\\n // @notice Supply caps enforced by mintAllowed for each cToken address. Defaults to zero which corresponds to unlimited supplying.\\n mapping(address => uint256) public supplyCaps;\\n\\n // @notice creditLimits allowed specific protocols to borrow and repay without collateral.\\n mapping(address => uint256) public creditLimits;\\n\\n // @notice flashloanGuardianPaused can pause flash loan as a safety mechanism.\\n mapping(address => bool) public flashloanGuardianPaused;\\n\\n /// @notice liquidityMining the liquidity mining module that handles the LM rewards distribution.\\n address public liquidityMining;\\n\\n /// @notice JOE token contract address\\n address public joeAddress;\\n\\n}\\n\",\"keccak256\":\"0x3425c8a221d0a68180d12fd267c343e67128b5ba7454ecb54152ad5de658ac0f\"},\"contracts/EIP20Interface.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\n/**\\n * @title ERC 20 Token Standard Interface\\n * https://eips.ethereum.org/EIPS/eip-20\\n */\\ninterface EIP20Interface {\\n function name() external view returns (string memory);\\n\\n function symbol() external view returns (string memory);\\n\\n function decimals() external view returns (uint8);\\n\\n /**\\n * @notice Get the total number of tokens in circulation\\n * @return The supply of tokens\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @notice Gets the balance of the specified address\\n * @param owner The address from which the balance will be retrieved\\n * @return The balance\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n /**\\n * @notice Transfer `amount` tokens from `msg.sender` to `dst`\\n * @param dst The address of the destination account\\n * @param amount The number of tokens to transfer\\n * @return Whether or not the transfer succeeded\\n */\\n function transfer(address dst, uint256 amount) external returns (bool success);\\n\\n /**\\n * @notice Transfer `amount` tokens from `src` to `dst`\\n * @param src The address of the source account\\n * @param dst The address of the destination account\\n * @param amount The number of tokens to transfer\\n * @return Whether or not the transfer succeeded\\n */\\n function transferFrom(\\n address src,\\n address dst,\\n uint256 amount\\n ) external returns (bool success);\\n\\n /**\\n * @notice Approve `spender` to transfer up to `amount` from `src`\\n * @dev This will overwrite the approval amount for `spender`\\n * and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)\\n * @param spender The address of the account which may transfer tokens\\n * @param amount The number of tokens that are approved (-1 means infinite)\\n * @return Whether or not the approval succeeded\\n */\\n function approve(address spender, uint256 amount) external returns (bool success);\\n\\n /**\\n * @notice Get the current allowance from `owner` for `spender`\\n * @param owner The address of the account which owns the tokens to be spent\\n * @param spender The address of the account which may transfer tokens\\n * @return The number of tokens allowed to be spent (-1 means infinite)\\n */\\n function allowance(address owner, address spender) external view returns (uint256 remaining);\\n\\n event Transfer(address indexed from, address indexed to, uint256 amount);\\n event Approval(address indexed owner, address indexed spender, uint256 amount);\\n}\\n\",\"keccak256\":\"0xf0c362ddd4ebdde949af559b3d37b6c2b666773fbdc81ed864493ffa9c381bd9\"},\"contracts/EIP20NonStandardInterface.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\n/**\\n * @title EIP20NonStandardInterface\\n * @dev Version of ERC20 with no return values for `transfer` and `transferFrom`\\n * See https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca\\n */\\ninterface EIP20NonStandardInterface {\\n /**\\n * @notice Get the total number of tokens in circulation\\n * @return The supply of tokens\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @notice Gets the balance of the specified address\\n * @param owner The address from which the balance will be retrieved\\n * @return The balance\\n */\\n function balanceOf(address owner) external view returns (uint256 balance);\\n\\n ///\\n /// !!!!!!!!!!!!!!\\n /// !!! NOTICE !!! `transfer` does not return a value, in violation of the ERC-20 specification\\n /// !!!!!!!!!!!!!!\\n ///\\n\\n /**\\n * @notice Transfer `amount` tokens from `msg.sender` to `dst`\\n * @param dst The address of the destination account\\n * @param amount The number of tokens to transfer\\n */\\n function transfer(address dst, uint256 amount) external;\\n\\n ///\\n /// !!!!!!!!!!!!!!\\n /// !!! NOTICE !!! `transferFrom` does not return a value, in violation of the ERC-20 specification\\n /// !!!!!!!!!!!!!!\\n ///\\n\\n /**\\n * @notice Transfer `amount` tokens from `src` to `dst`\\n * @param src The address of the source account\\n * @param dst The address of the destination account\\n * @param amount The number of tokens to transfer\\n */\\n function transferFrom(\\n address src,\\n address dst,\\n uint256 amount\\n ) external;\\n\\n /**\\n * @notice Approve `spender` to transfer up to `amount` from `src`\\n * @dev This will overwrite the approval amount for `spender`\\n * and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)\\n * @param spender The address of the account which may transfer tokens\\n * @param amount The number of tokens that are approved\\n * @return Whether or not the approval succeeded\\n */\\n function approve(address spender, uint256 amount) external returns (bool success);\\n\\n /**\\n * @notice Get the current allowance from `owner` for `spender`\\n * @param owner The address of the account which owns the tokens to be spent\\n * @param spender The address of the account which may transfer tokens\\n * @return The number of tokens allowed to be spent\\n */\\n function allowance(address owner, address spender) external view returns (uint256 remaining);\\n\\n event Transfer(address indexed from, address indexed to, uint256 amount);\\n event Approval(address indexed owner, address indexed spender, uint256 amount);\\n}\\n\",\"keccak256\":\"0x5046e86e5a524462517a0fc0dda5630b8cc9440f7d918c226cb8b44b1d037367\"},\"contracts/ERC3156FlashBorrowerInterface.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\ninterface ERC3156FlashBorrowerInterface {\\n /**\\n * @dev Receive a flash loan.\\n * @param initiator The initiator of the loan.\\n * @param token The loan currency.\\n * @param amount The amount of tokens lent.\\n * @param fee The additional amount of tokens to repay.\\n * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n * @return The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\\n */\\n function onFlashLoan(\\n address initiator,\\n address token,\\n uint256 amount,\\n uint256 fee,\\n bytes calldata data\\n ) external returns (bytes32);\\n}\\n\",\"keccak256\":\"0x999423c3ee943cf759d3187e9f1f6cbd4b8455fe0f7736f8c5b2987ef9c899f2\"},\"contracts/ErrorReporter.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\ncontract ComptrollerErrorReporter {\\n enum Error {\\n NO_ERROR,\\n UNAUTHORIZED,\\n COMPTROLLER_MISMATCH,\\n INSUFFICIENT_SHORTFALL,\\n INSUFFICIENT_LIQUIDITY,\\n INVALID_CLOSE_FACTOR,\\n INVALID_COLLATERAL_FACTOR,\\n INVALID_LIQUIDATION_INCENTIVE,\\n MARKET_NOT_ENTERED, // no longer possible\\n MARKET_NOT_LISTED,\\n MARKET_ALREADY_LISTED,\\n MATH_ERROR,\\n NONZERO_BORROW_BALANCE,\\n PRICE_ERROR,\\n REJECTION,\\n SNAPSHOT_ERROR,\\n TOO_MANY_ASSETS,\\n TOO_MUCH_REPAY\\n }\\n\\n enum FailureInfo {\\n ACCEPT_ADMIN_PENDING_ADMIN_CHECK,\\n ACCEPT_PENDING_IMPLEMENTATION_ADDRESS_CHECK,\\n EXIT_MARKET_BALANCE_OWED,\\n EXIT_MARKET_REJECTION,\\n SET_CLOSE_FACTOR_OWNER_CHECK,\\n SET_CLOSE_FACTOR_VALIDATION,\\n SET_COLLATERAL_FACTOR_OWNER_CHECK,\\n SET_COLLATERAL_FACTOR_NO_EXISTS,\\n SET_COLLATERAL_FACTOR_VALIDATION,\\n SET_COLLATERAL_FACTOR_WITHOUT_PRICE,\\n SET_IMPLEMENTATION_OWNER_CHECK,\\n SET_LIQUIDATION_INCENTIVE_OWNER_CHECK,\\n SET_LIQUIDATION_INCENTIVE_VALIDATION,\\n SET_MAX_ASSETS_OWNER_CHECK,\\n SET_PENDING_ADMIN_OWNER_CHECK,\\n SET_PENDING_IMPLEMENTATION_OWNER_CHECK,\\n SET_PRICE_ORACLE_OWNER_CHECK,\\n SUPPORT_MARKET_EXISTS,\\n SUPPORT_MARKET_OWNER_CHECK,\\n SET_PAUSE_GUARDIAN_OWNER_CHECK\\n }\\n\\n /**\\n * @dev `error` corresponds to enum Error; `info` corresponds to enum FailureInfo, and `detail` is an arbitrary\\n * contract-specific code that enables us to report opaque error codes from upgradeable contracts.\\n **/\\n event Failure(uint256 error, uint256 info, uint256 detail);\\n\\n /**\\n * @dev use this when reporting a known error from the money market or a non-upgradeable collaborator\\n */\\n function fail(Error err, FailureInfo info) internal returns (uint256) {\\n emit Failure(uint256(err), uint256(info), 0);\\n\\n return uint256(err);\\n }\\n\\n /**\\n * @dev use this when reporting an opaque error from an upgradeable collaborator contract\\n */\\n function failOpaque(\\n Error err,\\n FailureInfo info,\\n uint256 opaqueError\\n ) internal returns (uint256) {\\n emit Failure(uint256(err), uint256(info), opaqueError);\\n\\n return uint256(err);\\n }\\n}\\n\\ncontract TokenErrorReporter {\\n enum Error {\\n NO_ERROR,\\n UNAUTHORIZED,\\n BAD_INPUT,\\n COMPTROLLER_REJECTION,\\n COMPTROLLER_CALCULATION_ERROR,\\n INTEREST_RATE_MODEL_ERROR,\\n INVALID_ACCOUNT_PAIR,\\n INVALID_CLOSE_AMOUNT_REQUESTED,\\n INVALID_COLLATERAL_FACTOR,\\n MATH_ERROR,\\n MARKET_NOT_FRESH,\\n MARKET_NOT_LISTED,\\n TOKEN_INSUFFICIENT_ALLOWANCE,\\n TOKEN_INSUFFICIENT_BALANCE,\\n TOKEN_INSUFFICIENT_CASH,\\n TOKEN_TRANSFER_IN_FAILED,\\n TOKEN_TRANSFER_OUT_FAILED\\n }\\n\\n /*\\n * Note: FailureInfo (but not Error) is kept in alphabetical order\\n * This is because FailureInfo grows significantly faster, and\\n * the order of Error has some meaning, while the order of FailureInfo\\n * is entirely arbitrary.\\n */\\n enum FailureInfo {\\n ACCEPT_ADMIN_PENDING_ADMIN_CHECK,\\n ACCRUE_INTEREST_BORROW_RATE_CALCULATION_FAILED,\\n BORROW_ACCRUE_INTEREST_FAILED,\\n BORROW_CASH_NOT_AVAILABLE,\\n BORROW_FRESHNESS_CHECK,\\n BORROW_MARKET_NOT_LISTED,\\n BORROW_COMPTROLLER_REJECTION,\\n LIQUIDATE_ACCRUE_BORROW_INTEREST_FAILED,\\n LIQUIDATE_ACCRUE_COLLATERAL_INTEREST_FAILED,\\n LIQUIDATE_COLLATERAL_FRESHNESS_CHECK,\\n LIQUIDATE_COMPTROLLER_REJECTION,\\n LIQUIDATE_COMPTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED,\\n LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX,\\n LIQUIDATE_CLOSE_AMOUNT_IS_ZERO,\\n LIQUIDATE_FRESHNESS_CHECK,\\n LIQUIDATE_LIQUIDATOR_IS_BORROWER,\\n LIQUIDATE_REPAY_BORROW_FRESH_FAILED,\\n LIQUIDATE_SEIZE_COMPTROLLER_REJECTION,\\n LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER,\\n LIQUIDATE_SEIZE_TOO_MUCH,\\n MINT_ACCRUE_INTEREST_FAILED,\\n MINT_COMPTROLLER_REJECTION,\\n MINT_FRESHNESS_CHECK,\\n MINT_TRANSFER_IN_FAILED,\\n MINT_TRANSFER_IN_NOT_POSSIBLE,\\n REDEEM_ACCRUE_INTEREST_FAILED,\\n REDEEM_COMPTROLLER_REJECTION,\\n REDEEM_FRESHNESS_CHECK,\\n REDEEM_TRANSFER_OUT_NOT_POSSIBLE,\\n REDUCE_RESERVES_ACCRUE_INTEREST_FAILED,\\n REDUCE_RESERVES_ADMIN_CHECK,\\n REDUCE_RESERVES_CASH_NOT_AVAILABLE,\\n REDUCE_RESERVES_FRESH_CHECK,\\n REDUCE_RESERVES_VALIDATION,\\n REPAY_BORROW_ACCRUE_INTEREST_FAILED,\\n REPAY_BORROW_COMPTROLLER_REJECTION,\\n REPAY_BORROW_FRESHNESS_CHECK,\\n REPAY_BORROW_TRANSFER_IN_NOT_POSSIBLE,\\n SET_COLLATERAL_FACTOR_OWNER_CHECK,\\n SET_COLLATERAL_FACTOR_VALIDATION,\\n SET_COMPTROLLER_OWNER_CHECK,\\n SET_INTEREST_RATE_MODEL_ACCRUE_INTEREST_FAILED,\\n SET_INTEREST_RATE_MODEL_FRESH_CHECK,\\n SET_INTEREST_RATE_MODEL_OWNER_CHECK,\\n SET_MAX_ASSETS_OWNER_CHECK,\\n SET_ORACLE_MARKET_NOT_LISTED,\\n SET_PENDING_ADMIN_OWNER_CHECK,\\n SET_RESERVE_FACTOR_ACCRUE_INTEREST_FAILED,\\n SET_RESERVE_FACTOR_ADMIN_CHECK,\\n SET_RESERVE_FACTOR_FRESH_CHECK,\\n SET_RESERVE_FACTOR_BOUNDS_CHECK,\\n TRANSFER_COMPTROLLER_REJECTION,\\n TRANSFER_NOT_ALLOWED,\\n ADD_RESERVES_ACCRUE_INTEREST_FAILED,\\n ADD_RESERVES_FRESH_CHECK,\\n ADD_RESERVES_TRANSFER_IN_NOT_POSSIBLE\\n }\\n\\n /**\\n * @dev `error` corresponds to enum Error; `info` corresponds to enum FailureInfo, and `detail` is an arbitrary\\n * contract-specific code that enables us to report opaque error codes from upgradeable contracts.\\n **/\\n event Failure(uint256 error, uint256 info, uint256 detail);\\n\\n /**\\n * @dev use this when reporting a known error from the money market or a non-upgradeable collaborator\\n */\\n function fail(Error err, FailureInfo info) internal returns (uint256) {\\n emit Failure(uint256(err), uint256(info), 0);\\n\\n return uint256(err);\\n }\\n\\n /**\\n * @dev use this when reporting an opaque error from an upgradeable collaborator contract\\n */\\n function failOpaque(\\n Error err,\\n FailureInfo info,\\n uint256 opaqueError\\n ) internal returns (uint256) {\\n emit Failure(uint256(err), uint256(info), opaqueError);\\n\\n return uint256(err);\\n }\\n}\\n\",\"keccak256\":\"0x83e0ec825df37a55dbc7ff92676922d1bc137680224902bcbca5b9332c970f79\"},\"contracts/Exponential.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\nimport \\\"./CarefulMath.sol\\\";\\n\\n/**\\n * @title Exponential module for storing fixed-precision decimals\\n * @author Compound\\n * @notice Exp is a struct which stores decimals with a fixed precision of 18 decimal places.\\n * Thus, if we wanted to store the 5.1, mantissa would store 5.1e18. That is:\\n * `Exp({mantissa: 5100000000000000000})`.\\n */\\ncontract Exponential is CarefulMath {\\n uint256 constant expScale = 1e18;\\n uint256 constant doubleScale = 1e36;\\n uint256 constant halfExpScale = expScale / 2;\\n uint256 constant mantissaOne = expScale;\\n\\n struct Exp {\\n uint256 mantissa;\\n }\\n\\n struct Double {\\n uint256 mantissa;\\n }\\n\\n /**\\n * @dev Creates an exponential from numerator and denominator values.\\n * Note: Returns an error if (`num` * 10e18) > MAX_INT,\\n * or if `denom` is zero.\\n */\\n function getExp(uint256 num, uint256 denom) internal pure returns (MathError, Exp memory) {\\n (MathError err0, uint256 scaledNumerator) = mulUInt(num, expScale);\\n if (err0 != MathError.NO_ERROR) {\\n return (err0, Exp({mantissa: 0}));\\n }\\n\\n (MathError err1, uint256 rational) = divUInt(scaledNumerator, denom);\\n if (err1 != MathError.NO_ERROR) {\\n return (err1, Exp({mantissa: 0}));\\n }\\n\\n return (MathError.NO_ERROR, Exp({mantissa: rational}));\\n }\\n\\n /**\\n * @dev Adds two exponentials, returning a new exponential.\\n */\\n function addExp(Exp memory a, Exp memory b) internal pure returns (MathError, Exp memory) {\\n (MathError error, uint256 result) = addUInt(a.mantissa, b.mantissa);\\n\\n return (error, Exp({mantissa: result}));\\n }\\n\\n /**\\n * @dev Subtracts two exponentials, returning a new exponential.\\n */\\n function subExp(Exp memory a, Exp memory b) internal pure returns (MathError, Exp memory) {\\n (MathError error, uint256 result) = subUInt(a.mantissa, b.mantissa);\\n\\n return (error, Exp({mantissa: result}));\\n }\\n\\n /**\\n * @dev Multiply an Exp by a scalar, returning a new Exp.\\n */\\n function mulScalar(Exp memory a, uint256 scalar) internal pure returns (MathError, Exp memory) {\\n (MathError err0, uint256 scaledMantissa) = mulUInt(a.mantissa, scalar);\\n if (err0 != MathError.NO_ERROR) {\\n return (err0, Exp({mantissa: 0}));\\n }\\n\\n return (MathError.NO_ERROR, Exp({mantissa: scaledMantissa}));\\n }\\n\\n /**\\n * @dev Multiply an Exp by a scalar, then truncate to return an unsigned integer.\\n */\\n function mulScalarTruncate(Exp memory a, uint256 scalar) internal pure returns (MathError, uint256) {\\n (MathError err, Exp memory product) = mulScalar(a, scalar);\\n if (err != MathError.NO_ERROR) {\\n return (err, 0);\\n }\\n\\n return (MathError.NO_ERROR, truncate(product));\\n }\\n\\n /**\\n * @dev Multiply an Exp by a scalar, truncate, then add an to an unsigned integer, returning an unsigned integer.\\n */\\n function mulScalarTruncateAddUInt(\\n Exp memory a,\\n uint256 scalar,\\n uint256 addend\\n ) internal pure returns (MathError, uint256) {\\n (MathError err, Exp memory product) = mulScalar(a, scalar);\\n if (err != MathError.NO_ERROR) {\\n return (err, 0);\\n }\\n\\n return addUInt(truncate(product), addend);\\n }\\n\\n /**\\n * @dev Multiply an Exp by a scalar, then truncate to return an unsigned integer.\\n */\\n function mul_ScalarTruncate(Exp memory a, uint256 scalar) internal pure returns (uint256) {\\n Exp memory product = mul_(a, scalar);\\n return truncate(product);\\n }\\n\\n /**\\n * @dev Multiply an Exp by a scalar, truncate, then add an to an unsigned integer, returning an unsigned integer.\\n */\\n function mul_ScalarTruncateAddUInt(\\n Exp memory a,\\n uint256 scalar,\\n uint256 addend\\n ) internal pure returns (uint256) {\\n Exp memory product = mul_(a, scalar);\\n return add_(truncate(product), addend);\\n }\\n\\n /**\\n * @dev Divide an Exp by a scalar, returning a new Exp.\\n */\\n function divScalar(Exp memory a, uint256 scalar) internal pure returns (MathError, Exp memory) {\\n (MathError err0, uint256 descaledMantissa) = divUInt(a.mantissa, scalar);\\n if (err0 != MathError.NO_ERROR) {\\n return (err0, Exp({mantissa: 0}));\\n }\\n\\n return (MathError.NO_ERROR, Exp({mantissa: descaledMantissa}));\\n }\\n\\n /**\\n * @dev Divide a scalar by an Exp, returning a new Exp.\\n */\\n function divScalarByExp(uint256 scalar, Exp memory divisor) internal pure returns (MathError, Exp memory) {\\n /*\\n We are doing this as:\\n getExp(mulUInt(expScale, scalar), divisor.mantissa)\\n\\n How it works:\\n Exp = a / b;\\n Scalar = s;\\n `s / (a / b)` = `b * s / a` and since for an Exp `a = mantissa, b = expScale`\\n */\\n (MathError err0, uint256 numerator) = mulUInt(expScale, scalar);\\n if (err0 != MathError.NO_ERROR) {\\n return (err0, Exp({mantissa: 0}));\\n }\\n return getExp(numerator, divisor.mantissa);\\n }\\n\\n /**\\n * @dev Divide a scalar by an Exp, then truncate to return an unsigned integer.\\n */\\n function divScalarByExpTruncate(uint256 scalar, Exp memory divisor) internal pure returns (MathError, uint256) {\\n (MathError err, Exp memory fraction) = divScalarByExp(scalar, divisor);\\n if (err != MathError.NO_ERROR) {\\n return (err, 0);\\n }\\n\\n return (MathError.NO_ERROR, truncate(fraction));\\n }\\n\\n /**\\n * @dev Divide a scalar by an Exp, returning a new Exp.\\n */\\n function div_ScalarByExp(uint256 scalar, Exp memory divisor) internal pure returns (Exp memory) {\\n /*\\n We are doing this as:\\n getExp(mulUInt(expScale, scalar), divisor.mantissa)\\n\\n How it works:\\n Exp = a / b;\\n Scalar = s;\\n `s / (a / b)` = `b * s / a` and since for an Exp `a = mantissa, b = expScale`\\n */\\n uint256 numerator = mul_(expScale, scalar);\\n return Exp({mantissa: div_(numerator, divisor)});\\n }\\n\\n /**\\n * @dev Divide a scalar by an Exp, then truncate to return an unsigned integer.\\n */\\n function div_ScalarByExpTruncate(uint256 scalar, Exp memory divisor) internal pure returns (uint256) {\\n Exp memory fraction = div_ScalarByExp(scalar, divisor);\\n return truncate(fraction);\\n }\\n\\n /**\\n * @dev Multiplies two exponentials, returning a new exponential.\\n */\\n function mulExp(Exp memory a, Exp memory b) internal pure returns (MathError, Exp memory) {\\n (MathError err0, uint256 doubleScaledProduct) = mulUInt(a.mantissa, b.mantissa);\\n if (err0 != MathError.NO_ERROR) {\\n return (err0, Exp({mantissa: 0}));\\n }\\n\\n // We add half the scale before dividing so that we get rounding instead of truncation.\\n // See \\\"Listing 6\\\" and text above it at https://accu.org/index.php/journals/1717\\n // Without this change, a result like 6.6...e-19 will be truncated to 0 instead of being rounded to 1e-18.\\n (MathError err1, uint256 doubleScaledProductWithHalfScale) = addUInt(halfExpScale, doubleScaledProduct);\\n if (err1 != MathError.NO_ERROR) {\\n return (err1, Exp({mantissa: 0}));\\n }\\n\\n (MathError err2, uint256 product) = divUInt(doubleScaledProductWithHalfScale, expScale);\\n // The only error `div` can return is MathError.DIVISION_BY_ZERO but we control `expScale` and it is not zero.\\n assert(err2 == MathError.NO_ERROR);\\n\\n return (MathError.NO_ERROR, Exp({mantissa: product}));\\n }\\n\\n /**\\n * @dev Multiplies two exponentials given their mantissas, returning a new exponential.\\n */\\n function mulExp(uint256 a, uint256 b) internal pure returns (MathError, Exp memory) {\\n return mulExp(Exp({mantissa: a}), Exp({mantissa: b}));\\n }\\n\\n /**\\n * @dev Multiplies three exponentials, returning a new exponential.\\n */\\n function mulExp3(\\n Exp memory a,\\n Exp memory b,\\n Exp memory c\\n ) internal pure returns (MathError, Exp memory) {\\n (MathError err, Exp memory ab) = mulExp(a, b);\\n if (err != MathError.NO_ERROR) {\\n return (err, ab);\\n }\\n return mulExp(ab, c);\\n }\\n\\n /**\\n * @dev Divides two exponentials, returning a new exponential.\\n * (a/scale) / (b/scale) = (a/scale) * (scale/b) = a/b,\\n * which we can scale as an Exp by calling getExp(a.mantissa, b.mantissa)\\n */\\n function divExp(Exp memory a, Exp memory b) internal pure returns (MathError, Exp memory) {\\n return getExp(a.mantissa, b.mantissa);\\n }\\n\\n /**\\n * @dev Truncates the given exp to a whole number value.\\n * For example, truncate(Exp{mantissa: 15 * expScale}) = 15\\n */\\n function truncate(Exp memory exp) internal pure returns (uint256) {\\n // Note: We are not using careful math here as we're performing a division that cannot fail\\n return exp.mantissa / expScale;\\n }\\n\\n /**\\n * @dev Checks if first Exp is less than second Exp.\\n */\\n function lessThanExp(Exp memory left, Exp memory right) internal pure returns (bool) {\\n return left.mantissa < right.mantissa;\\n }\\n\\n /**\\n * @dev Checks if left Exp <= right Exp.\\n */\\n function lessThanOrEqualExp(Exp memory left, Exp memory right) internal pure returns (bool) {\\n return left.mantissa <= right.mantissa;\\n }\\n\\n /**\\n * @dev returns true if Exp is exactly zero\\n */\\n function isZeroExp(Exp memory value) internal pure returns (bool) {\\n return value.mantissa == 0;\\n }\\n\\n function safe224(uint256 n, string memory errorMessage) internal pure returns (uint224) {\\n require(n < 2**224, errorMessage);\\n return uint224(n);\\n }\\n\\n function safe32(uint256 n, string memory errorMessage) internal pure returns (uint32) {\\n require(n < 2**32, errorMessage);\\n return uint32(n);\\n }\\n\\n function add_(Exp memory a, Exp memory b) internal pure returns (Exp memory) {\\n return Exp({mantissa: add_(a.mantissa, b.mantissa)});\\n }\\n\\n function add_(Double memory a, Double memory b) internal pure returns (Double memory) {\\n return Double({mantissa: add_(a.mantissa, b.mantissa)});\\n }\\n\\n function add_(uint256 a, uint256 b) internal pure returns (uint256) {\\n return add_(a, b, \\\"addition overflow\\\");\\n }\\n\\n function add_(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ) internal pure returns (uint256) {\\n uint256 c = a + b;\\n require(c >= a, errorMessage);\\n return c;\\n }\\n\\n function sub_(Exp memory a, Exp memory b) internal pure returns (Exp memory) {\\n return Exp({mantissa: sub_(a.mantissa, b.mantissa)});\\n }\\n\\n function sub_(Double memory a, Double memory b) internal pure returns (Double memory) {\\n return Double({mantissa: sub_(a.mantissa, b.mantissa)});\\n }\\n\\n function sub_(uint256 a, uint256 b) internal pure returns (uint256) {\\n return sub_(a, b, \\\"subtraction underflow\\\");\\n }\\n\\n function sub_(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ) internal pure returns (uint256) {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n\\n function mul_(Exp memory a, Exp memory b) internal pure returns (Exp memory) {\\n return Exp({mantissa: mul_(a.mantissa, b.mantissa) / expScale});\\n }\\n\\n function mul_(Exp memory a, uint256 b) internal pure returns (Exp memory) {\\n return Exp({mantissa: mul_(a.mantissa, b)});\\n }\\n\\n function mul_(uint256 a, Exp memory b) internal pure returns (uint256) {\\n return mul_(a, b.mantissa) / expScale;\\n }\\n\\n function mul_(Double memory a, Double memory b) internal pure returns (Double memory) {\\n return Double({mantissa: mul_(a.mantissa, b.mantissa) / doubleScale});\\n }\\n\\n function mul_(Double memory a, uint256 b) internal pure returns (Double memory) {\\n return Double({mantissa: mul_(a.mantissa, b)});\\n }\\n\\n function mul_(uint256 a, Double memory b) internal pure returns (uint256) {\\n return mul_(a, b.mantissa) / doubleScale;\\n }\\n\\n function mul_(uint256 a, uint256 b) internal pure returns (uint256) {\\n return mul_(a, b, \\\"multiplication overflow\\\");\\n }\\n\\n function mul_(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ) internal pure returns (uint256) {\\n if (a == 0 || b == 0) {\\n return 0;\\n }\\n uint256 c = a * b;\\n require(c / a == b, errorMessage);\\n return c;\\n }\\n\\n function div_(Exp memory a, Exp memory b) internal pure returns (Exp memory) {\\n return Exp({mantissa: div_(mul_(a.mantissa, expScale), b.mantissa)});\\n }\\n\\n function div_(Exp memory a, uint256 b) internal pure returns (Exp memory) {\\n return Exp({mantissa: div_(a.mantissa, b)});\\n }\\n\\n function div_(uint256 a, Exp memory b) internal pure returns (uint256) {\\n return div_(mul_(a, expScale), b.mantissa);\\n }\\n\\n function div_(Double memory a, Double memory b) internal pure returns (Double memory) {\\n return Double({mantissa: div_(mul_(a.mantissa, doubleScale), b.mantissa)});\\n }\\n\\n function div_(Double memory a, uint256 b) internal pure returns (Double memory) {\\n return Double({mantissa: div_(a.mantissa, b)});\\n }\\n\\n function div_(uint256 a, Double memory b) internal pure returns (uint256) {\\n return div_(mul_(a, doubleScale), b.mantissa);\\n }\\n\\n function div_(uint256 a, uint256 b) internal pure returns (uint256) {\\n return div_(a, b, \\\"divide by zero\\\");\\n }\\n\\n function div_(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ) internal pure returns (uint256) {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n\\n function fraction(uint256 a, uint256 b) internal pure returns (Double memory) {\\n return Double({mantissa: div_(mul_(a, doubleScale), b)});\\n }\\n\\n // implementation from https://github.com/Uniswap/uniswap-lib/commit/99f3f28770640ba1bb1ff460ac7c5292fb8291a0\\n // original implementation: https://github.com/abdk-consulting/abdk-libraries-solidity/blob/master/ABDKMath64x64.sol#L687\\n function sqrt(uint256 x) internal pure returns (uint256) {\\n if (x == 0) return 0;\\n uint256 xx = x;\\n uint256 r = 1;\\n\\n if (xx >= 0x100000000000000000000000000000000) {\\n xx >>= 128;\\n r <<= 64;\\n }\\n if (xx >= 0x10000000000000000) {\\n xx >>= 64;\\n r <<= 32;\\n }\\n if (xx >= 0x100000000) {\\n xx >>= 32;\\n r <<= 16;\\n }\\n if (xx >= 0x10000) {\\n xx >>= 16;\\n r <<= 8;\\n }\\n if (xx >= 0x100) {\\n xx >>= 8;\\n r <<= 4;\\n }\\n if (xx >= 0x10) {\\n xx >>= 4;\\n r <<= 2;\\n }\\n if (xx >= 0x8) {\\n r <<= 1;\\n }\\n\\n r = (r + x / r) >> 1;\\n r = (r + x / r) >> 1;\\n r = (r + x / r) >> 1;\\n r = (r + x / r) >> 1;\\n r = (r + x / r) >> 1;\\n r = (r + x / r) >> 1;\\n r = (r + x / r) >> 1; // Seven iterations should be enough\\n uint256 r1 = x / r;\\n return (r < r1 ? r : r1);\\n }\\n}\\n\",\"keccak256\":\"0xf8507369462982bc2fb7200d9039467851b3403afdc637adbee4b629b1927e0f\"},\"contracts/Governance/Comp.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\npragma experimental ABIEncoderV2;\\n\\ncontract Comp {\\n /// @notice EIP-20 token name for this token\\n string public constant name = \\\"Cream\\\";\\n\\n /// @notice EIP-20 token symbol for this token\\n string public constant symbol = \\\"CREAM\\\";\\n\\n /// @notice EIP-20 token decimals for this token\\n uint8 public constant decimals = 18;\\n\\n /// @notice Total number of tokens in circulation\\n uint256 public constant totalSupply = 9000000e18; // 9 million Comp\\n\\n /// @notice Allowance amounts on behalf of others\\n mapping(address => mapping(address => uint96)) internal allowances;\\n\\n /// @notice Official record of token balances for each account\\n mapping(address => uint96) internal balances;\\n\\n /// @notice A record of each accounts delegate\\n mapping(address => address) public delegates;\\n\\n /// @notice A checkpoint for marking number of votes from a given block\\n struct Checkpoint {\\n uint32 fromBlock;\\n uint96 votes;\\n }\\n\\n /// @notice A record of votes checkpoints for each account, by index\\n mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;\\n\\n /// @notice The number of checkpoints for each account\\n mapping(address => uint32) public numCheckpoints;\\n\\n /// @notice The EIP-712 typehash for the contract's domain\\n bytes32 public constant DOMAIN_TYPEHASH =\\n keccak256(\\\"EIP712Domain(string name,uint256 chainId,address verifyingContract)\\\");\\n\\n /// @notice The EIP-712 typehash for the delegation struct used by the contract\\n bytes32 public constant DELEGATION_TYPEHASH =\\n keccak256(\\\"Delegation(address delegatee,uint256 nonce,uint256 expiry)\\\");\\n\\n /// @notice A record of states for signing / validating signatures\\n mapping(address => uint256) public nonces;\\n\\n /// @notice An event thats emitted when an account changes its delegate\\n event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);\\n\\n /// @notice An event thats emitted when a delegate account's vote balance changes\\n event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);\\n\\n /// @notice The standard EIP-20 transfer event\\n event Transfer(address indexed from, address indexed to, uint256 amount);\\n\\n /// @notice The standard EIP-20 approval event\\n event Approval(address indexed owner, address indexed spender, uint256 amount);\\n\\n /**\\n * @notice Construct a new Comp token\\n * @param account The initial account to grant all the tokens\\n */\\n constructor(address account) public {\\n balances[account] = uint96(totalSupply);\\n emit Transfer(address(0), account, totalSupply);\\n }\\n\\n /**\\n * @notice Get the number of tokens `spender` is approved to spend on behalf of `account`\\n * @param account The address of the account holding the funds\\n * @param spender The address of the account spending the funds\\n * @return The number of tokens approved\\n */\\n function allowance(address account, address spender) external view returns (uint256) {\\n return allowances[account][spender];\\n }\\n\\n /**\\n * @notice Approve `spender` to transfer up to `amount` from `src`\\n * @dev This will overwrite the approval amount for `spender`\\n * and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)\\n * @param spender The address of the account which may transfer tokens\\n * @param rawAmount The number of tokens that are approved (2^256-1 means infinite)\\n * @return Whether or not the approval succeeded\\n */\\n function approve(address spender, uint256 rawAmount) external returns (bool) {\\n uint96 amount;\\n if (rawAmount == uint256(-1)) {\\n amount = uint96(-1);\\n } else {\\n amount = safe96(rawAmount, \\\"Comp::approve: amount exceeds 96 bits\\\");\\n }\\n\\n allowances[msg.sender][spender] = amount;\\n\\n emit Approval(msg.sender, spender, amount);\\n return true;\\n }\\n\\n /**\\n * @notice Get the number of tokens held by the `account`\\n * @param account The address of the account to get the balance of\\n * @return The number of tokens held\\n */\\n function balanceOf(address account) external view returns (uint256) {\\n return balances[account];\\n }\\n\\n /**\\n * @notice Transfer `amount` tokens from `msg.sender` to `dst`\\n * @param dst The address of the destination account\\n * @param rawAmount The number of tokens to transfer\\n * @return Whether or not the transfer succeeded\\n */\\n function transfer(address dst, uint256 rawAmount) external returns (bool) {\\n uint96 amount = safe96(rawAmount, \\\"Comp::transfer: amount exceeds 96 bits\\\");\\n _transferTokens(msg.sender, dst, amount);\\n return true;\\n }\\n\\n /**\\n * @notice Transfer `amount` tokens from `src` to `dst`\\n * @param src The address of the source account\\n * @param dst The address of the destination account\\n * @param rawAmount The number of tokens to transfer\\n * @return Whether or not the transfer succeeded\\n */\\n function transferFrom(\\n address src,\\n address dst,\\n uint256 rawAmount\\n ) external returns (bool) {\\n address spender = msg.sender;\\n uint96 spenderAllowance = allowances[src][spender];\\n uint96 amount = safe96(rawAmount, \\\"Comp::approve: amount exceeds 96 bits\\\");\\n\\n if (spender != src && spenderAllowance != uint96(-1)) {\\n uint96 newAllowance = sub96(\\n spenderAllowance,\\n amount,\\n \\\"Comp::transferFrom: transfer amount exceeds spender allowance\\\"\\n );\\n allowances[src][spender] = newAllowance;\\n\\n emit Approval(src, spender, newAllowance);\\n }\\n\\n _transferTokens(src, dst, amount);\\n return true;\\n }\\n\\n /**\\n * @notice Delegate votes from `msg.sender` to `delegatee`\\n * @param delegatee The address to delegate votes to\\n */\\n function delegate(address delegatee) public {\\n return _delegate(msg.sender, delegatee);\\n }\\n\\n /**\\n * @notice Delegates votes from signatory to `delegatee`\\n * @param delegatee The address to delegate votes to\\n * @param nonce The contract state required to match the signature\\n * @param expiry The time at which to expire the signature\\n * @param v The recovery byte of the signature\\n * @param r Half of the ECDSA signature pair\\n * @param s Half of the ECDSA signature pair\\n */\\n function delegateBySig(\\n address delegatee,\\n uint256 nonce,\\n uint256 expiry,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) public {\\n bytes32 domainSeparator = keccak256(\\n abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this))\\n );\\n bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));\\n bytes32 digest = keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, structHash));\\n address signatory = ecrecover(digest, v, r, s);\\n require(signatory != address(0), \\\"Comp::delegateBySig: invalid signature\\\");\\n require(nonce == nonces[signatory]++, \\\"Comp::delegateBySig: invalid nonce\\\");\\n require(now <= expiry, \\\"Comp::delegateBySig: signature expired\\\");\\n return _delegate(signatory, delegatee);\\n }\\n\\n /**\\n * @notice Gets the current votes balance for `account`\\n * @param account The address to get votes balance\\n * @return The number of current votes for `account`\\n */\\n function getCurrentVotes(address account) external view returns (uint96) {\\n uint32 nCheckpoints = numCheckpoints[account];\\n return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;\\n }\\n\\n /**\\n * @notice Determine the prior number of votes for an account as of a block number\\n * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.\\n * @param account The address of the account to check\\n * @param blockNumber The block number to get the vote balance at\\n * @return The number of votes the account had as of the given block\\n */\\n function getPriorVotes(address account, uint256 blockNumber) public view returns (uint96) {\\n require(blockNumber < block.number, \\\"Comp::getPriorVotes: not yet determined\\\");\\n\\n uint32 nCheckpoints = numCheckpoints[account];\\n if (nCheckpoints == 0) {\\n return 0;\\n }\\n\\n // First check most recent balance\\n if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {\\n return checkpoints[account][nCheckpoints - 1].votes;\\n }\\n\\n // Next check implicit zero balance\\n if (checkpoints[account][0].fromBlock > blockNumber) {\\n return 0;\\n }\\n\\n uint32 lower = 0;\\n uint32 upper = nCheckpoints - 1;\\n while (upper > lower) {\\n uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow\\n Checkpoint memory cp = checkpoints[account][center];\\n if (cp.fromBlock == blockNumber) {\\n return cp.votes;\\n } else if (cp.fromBlock < blockNumber) {\\n lower = center;\\n } else {\\n upper = center - 1;\\n }\\n }\\n return checkpoints[account][lower].votes;\\n }\\n\\n function _delegate(address delegator, address delegatee) internal {\\n address currentDelegate = delegates[delegator];\\n uint96 delegatorBalance = balances[delegator];\\n delegates[delegator] = delegatee;\\n\\n emit DelegateChanged(delegator, currentDelegate, delegatee);\\n\\n _moveDelegates(currentDelegate, delegatee, delegatorBalance);\\n }\\n\\n function _transferTokens(\\n address src,\\n address dst,\\n uint96 amount\\n ) internal {\\n require(src != address(0), \\\"Comp::_transferTokens: cannot transfer from the zero address\\\");\\n require(dst != address(0), \\\"Comp::_transferTokens: cannot transfer to the zero address\\\");\\n\\n balances[src] = sub96(balances[src], amount, \\\"Comp::_transferTokens: transfer amount exceeds balance\\\");\\n balances[dst] = add96(balances[dst], amount, \\\"Comp::_transferTokens: transfer amount overflows\\\");\\n emit Transfer(src, dst, amount);\\n\\n _moveDelegates(delegates[src], delegates[dst], amount);\\n }\\n\\n function _moveDelegates(\\n address srcRep,\\n address dstRep,\\n uint96 amount\\n ) internal {\\n if (srcRep != dstRep && amount > 0) {\\n if (srcRep != address(0)) {\\n uint32 srcRepNum = numCheckpoints[srcRep];\\n uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;\\n uint96 srcRepNew = sub96(srcRepOld, amount, \\\"Comp::_moveVotes: vote amount underflows\\\");\\n _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);\\n }\\n\\n if (dstRep != address(0)) {\\n uint32 dstRepNum = numCheckpoints[dstRep];\\n uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;\\n uint96 dstRepNew = add96(dstRepOld, amount, \\\"Comp::_moveVotes: vote amount overflows\\\");\\n _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);\\n }\\n }\\n }\\n\\n function _writeCheckpoint(\\n address delegatee,\\n uint32 nCheckpoints,\\n uint96 oldVotes,\\n uint96 newVotes\\n ) internal {\\n uint32 blockNumber = safe32(block.number, \\\"Comp::_writeCheckpoint: block number exceeds 32 bits\\\");\\n\\n if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {\\n checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;\\n } else {\\n checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);\\n numCheckpoints[delegatee] = nCheckpoints + 1;\\n }\\n\\n emit DelegateVotesChanged(delegatee, oldVotes, newVotes);\\n }\\n\\n function safe32(uint256 n, string memory errorMessage) internal pure returns (uint32) {\\n require(n < 2**32, errorMessage);\\n return uint32(n);\\n }\\n\\n function safe96(uint256 n, string memory errorMessage) internal pure returns (uint96) {\\n require(n < 2**96, errorMessage);\\n return uint96(n);\\n }\\n\\n function add96(\\n uint96 a,\\n uint96 b,\\n string memory errorMessage\\n ) internal pure returns (uint96) {\\n uint96 c = a + b;\\n require(c >= a, errorMessage);\\n return c;\\n }\\n\\n function sub96(\\n uint96 a,\\n uint96 b,\\n string memory errorMessage\\n ) internal pure returns (uint96) {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n\\n function getChainId() internal pure returns (uint256) {\\n uint256 chainId;\\n assembly {\\n chainId := chainid()\\n }\\n return chainId;\\n }\\n}\\n\",\"keccak256\":\"0xc83879303201c5a7c3ba6d17491347579386ee513f8c96b5265af5fca7b40a5c\"},\"contracts/InterestRateModel.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\n/**\\n * @title Compound's InterestRateModel Interface\\n * @author Compound\\n */\\ncontract InterestRateModel {\\n /// @notice Indicator that this is an InterestRateModel contract (for inspection)\\n bool public constant isInterestRateModel = true;\\n\\n /**\\n * @notice Calculates the current borrow interest rate per block\\n * @param cash The total amount of cash the market has\\n * @param borrows The total amount of borrows the market has outstanding\\n * @param reserves The total amnount of reserves the market has\\n * @return The borrow rate per block (as a percentage, and scaled by 1e18)\\n */\\n function getBorrowRate(\\n uint256 cash,\\n uint256 borrows,\\n uint256 reserves\\n ) external view returns (uint256);\\n\\n /**\\n * @notice Calculates the current supply interest rate per block\\n * @param cash The total amount of cash the market has\\n * @param borrows The total amount of borrows the market has outstanding\\n * @param reserves The total amnount of reserves the market has\\n * @param reserveFactorMantissa The current reserve factor the market has\\n * @return The supply rate per block (as a percentage, and scaled by 1e18)\\n */\\n function getSupplyRate(\\n uint256 cash,\\n uint256 borrows,\\n uint256 reserves,\\n uint256 reserveFactorMantissa\\n ) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x739209ad7d99f78436ac0c66eeadab58519398c6edc94033c93ba04e8fd9efe6\"},\"contracts/Lens/CompoundLens.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\npragma experimental ABIEncoderV2;\\n\\nimport \\\"../CErc20.sol\\\";\\nimport \\\"../Comptroller.sol\\\";\\nimport \\\"../CToken.sol\\\";\\nimport \\\"../PriceOracle/PriceOracle.sol\\\";\\nimport \\\"../EIP20Interface.sol\\\";\\nimport \\\"../Exponential.sol\\\";\\n\\ninterface CSLPInterface {\\n function claimSushi(address) external returns (uint256);\\n}\\n\\ninterface CCTokenInterface {\\n function claimComp(address) external returns (uint256);\\n}\\n\\ncontract CompoundLens is Exponential {\\n struct CTokenMetadata {\\n address cToken;\\n uint256 exchangeRateCurrent;\\n uint256 supplyRatePerBlock;\\n uint256 borrowRatePerBlock;\\n uint256 reserveFactorMantissa;\\n uint256 totalBorrows;\\n uint256 totalReserves;\\n uint256 totalSupply;\\n uint256 totalCash;\\n uint256 totalCollateralTokens;\\n bool isListed;\\n uint256 collateralFactorMantissa;\\n address underlyingAssetAddress;\\n uint256 cTokenDecimals;\\n uint256 underlyingDecimals;\\n ComptrollerV1Storage.Version version;\\n uint256 collateralCap;\\n uint256 underlyingPrice;\\n bool supplyPaused;\\n bool borrowPaused;\\n uint256 supplyCap;\\n uint256 borrowCap;\\n }\\n\\n function cTokenMetadataInternal(\\n CToken cToken,\\n Comptroller comptroller,\\n PriceOracle priceOracle\\n ) internal returns (CTokenMetadata memory) {\\n uint256 exchangeRateCurrent = cToken.exchangeRateCurrent();\\n (bool isListed, uint256 collateralFactorMantissa, ComptrollerV1Storage.Version version) = comptroller.markets(\\n address(cToken)\\n );\\n address underlyingAssetAddress;\\n uint256 underlyingDecimals;\\n uint256 collateralCap;\\n uint256 totalCollateralTokens;\\n\\n if (compareStrings(cToken.symbol(), \\\"crFTM\\\")) {\\n underlyingAssetAddress = address(0);\\n underlyingDecimals = 18;\\n } else {\\n CErc20 cErc20 = CErc20(address(cToken));\\n underlyingAssetAddress = cErc20.underlying();\\n underlyingDecimals = EIP20Interface(cErc20.underlying()).decimals();\\n }\\n\\n if (version == ComptrollerV1Storage.Version.COLLATERALCAP) {\\n collateralCap = CCollateralCapErc20Interface(address(cToken)).collateralCap();\\n totalCollateralTokens = CCollateralCapErc20Interface(address(cToken)).totalCollateralTokens();\\n }\\n\\n return\\n CTokenMetadata({\\n cToken: address(cToken),\\n exchangeRateCurrent: exchangeRateCurrent,\\n supplyRatePerBlock: cToken.supplyRatePerBlock(),\\n borrowRatePerBlock: cToken.borrowRatePerBlock(),\\n reserveFactorMantissa: cToken.reserveFactorMantissa(),\\n totalBorrows: cToken.totalBorrows(),\\n totalReserves: cToken.totalReserves(),\\n totalSupply: cToken.totalSupply(),\\n totalCash: cToken.getCash(),\\n totalCollateralTokens: totalCollateralTokens,\\n isListed: isListed,\\n collateralFactorMantissa: collateralFactorMantissa,\\n underlyingAssetAddress: underlyingAssetAddress,\\n cTokenDecimals: cToken.decimals(),\\n underlyingDecimals: underlyingDecimals,\\n version: version,\\n collateralCap: collateralCap,\\n underlyingPrice: priceOracle.getUnderlyingPrice(cToken),\\n supplyPaused: comptroller.mintGuardianPaused(address(cToken)),\\n borrowPaused: comptroller.borrowGuardianPaused(address(cToken)),\\n supplyCap: comptroller.supplyCaps(address(cToken)),\\n borrowCap: comptroller.borrowCaps(address(cToken))\\n });\\n }\\n\\n function cTokenMetadata(CToken cToken) public returns (CTokenMetadata memory) {\\n address comptrollerAddress = address(cToken.comptroller()); \\n address payable payableComptrollerAddress = address(uint160(comptrollerAddress));\\n Comptroller comptroller = Comptroller(payableComptrollerAddress);\\n PriceOracle priceOracle = comptroller.oracle();\\n return cTokenMetadataInternal(cToken, comptroller, priceOracle);\\n }\\n\\n function cTokenMetadataAll(CToken[] calldata cTokens) external returns (CTokenMetadata[] memory) {\\n uint256 cTokenCount = cTokens.length;\\n require(cTokenCount > 0, \\\"invalid input\\\");\\n CTokenMetadata[] memory res = new CTokenMetadata[](cTokenCount);\\n address comptrollerAddress = address(cTokens[0].comptroller()); \\n address payable payableComptrollerAddress = address(uint160(comptrollerAddress));\\n Comptroller comptroller = Comptroller(payableComptrollerAddress);\\n PriceOracle priceOracle = comptroller.oracle();\\n for (uint256 i = 0; i < cTokenCount; i++) {\\n require(address(comptroller) == address(cTokens[i].comptroller()), \\\"mismatch comptroller\\\");\\n res[i] = cTokenMetadataInternal(cTokens[i], comptroller, priceOracle);\\n }\\n return res;\\n }\\n\\n struct CTokenBalances {\\n address cToken;\\n uint256 balanceOf;\\n uint256 borrowBalanceCurrent;\\n uint256 balanceOfUnderlying;\\n uint256 tokenBalance;\\n uint256 tokenAllowance;\\n bool collateralEnabled;\\n uint256 collateralBalance;\\n uint256 nativeTokenBalance;\\n }\\n\\n function cTokenBalances(CToken cToken, address payable account) public returns (CTokenBalances memory) {\\n address comptrollerAddress = address(cToken.comptroller());\\n address payable payableComptrollerAddress = address(uint160(comptrollerAddress));\\n bool collateralEnabled = Comptroller(payableComptrollerAddress).checkMembership(account, cToken);\\n uint256 tokenBalance;\\n uint256 tokenAllowance;\\n uint256 collateralBalance;\\n\\n if (compareStrings(cToken.symbol(), \\\"crFTM\\\")) {\\n tokenBalance = account.balance;\\n tokenAllowance = account.balance;\\n } else {\\n CErc20 cErc20 = CErc20(address(cToken));\\n EIP20Interface underlying = EIP20Interface(cErc20.underlying());\\n tokenBalance = underlying.balanceOf(account);\\n tokenAllowance = underlying.allowance(account, address(cToken));\\n }\\n\\n if (collateralEnabled) {\\n (, collateralBalance, , ) = cToken.getAccountSnapshot(account);\\n }\\n\\n return\\n CTokenBalances({\\n cToken: address(cToken),\\n balanceOf: cToken.balanceOf(account),\\n borrowBalanceCurrent: cToken.borrowBalanceCurrent(account),\\n balanceOfUnderlying: cToken.balanceOfUnderlying(account),\\n tokenBalance: tokenBalance,\\n tokenAllowance: tokenAllowance,\\n collateralEnabled: collateralEnabled,\\n collateralBalance: collateralBalance,\\n nativeTokenBalance: account.balance\\n });\\n }\\n\\n function cTokenBalancesAll(CToken[] calldata cTokens, address payable account)\\n external\\n returns (CTokenBalances[] memory)\\n {\\n uint256 cTokenCount = cTokens.length;\\n CTokenBalances[] memory res = new CTokenBalances[](cTokenCount);\\n for (uint256 i = 0; i < cTokenCount; i++) {\\n res[i] = cTokenBalances(cTokens[i], account);\\n }\\n return res;\\n }\\n\\n struct AccountLimits {\\n CToken[] markets;\\n uint256 liquidity;\\n uint256 shortfall;\\n }\\n\\n function getAccountLimits(Comptroller comptroller, address account) public returns (AccountLimits memory) {\\n (uint256 errorCode, uint256 liquidity, uint256 shortfall) = comptroller.getAccountLiquidity(account);\\n require(errorCode == 0);\\n\\n return AccountLimits({markets: comptroller.getAssetsIn(account), liquidity: liquidity, shortfall: shortfall});\\n }\\n\\n function getClaimableSushiRewards(\\n CSLPInterface[] calldata cTokens,\\n address sushi,\\n address account\\n ) external returns (uint256[] memory) {\\n uint256 cTokenCount = cTokens.length;\\n uint256[] memory rewards = new uint256[](cTokenCount);\\n for (uint256 i = 0; i < cTokenCount; i++) {\\n uint256 balanceBefore = EIP20Interface(sushi).balanceOf(account);\\n cTokens[i].claimSushi(account);\\n uint256 balanceAfter = EIP20Interface(sushi).balanceOf(account);\\n rewards[i] = sub_(balanceAfter, balanceBefore);\\n }\\n return rewards;\\n }\\n\\n function getClaimableCompRewards(\\n CCTokenInterface[] calldata cTokens,\\n address comp,\\n address account\\n ) external returns (uint256[] memory) {\\n uint256 cTokenCount = cTokens.length;\\n uint256[] memory rewards = new uint256[](cTokenCount);\\n for (uint256 i = 0; i < cTokenCount; i++) {\\n uint256 balanceBefore = EIP20Interface(comp).balanceOf(account);\\n cTokens[i].claimComp(account);\\n uint256 balanceAfter = EIP20Interface(comp).balanceOf(account);\\n rewards[i] = sub_(balanceAfter, balanceBefore);\\n }\\n return rewards;\\n }\\n\\n function compareStrings(string memory a, string memory b) internal pure returns (bool) {\\n return (keccak256(abi.encodePacked((a))) == keccak256(abi.encodePacked((b))));\\n }\\n}\\n\",\"keccak256\":\"0xd47b18fc5e8a9fe8aa30db4aa1f1f8460cd9b1660cbfb78309bb663b8ebf79ef\"},\"contracts/LiquidityMiningInterface.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\ncontract LiquidityMiningInterface {\\n function comptroller() external view returns (address);\\n\\n function updateSupplyIndex(address cToken, address[] calldata accounts) external;\\n\\n function updateBorrowIndex(address cToken, address[] calldata accounts) external;\\n}\\n\",\"keccak256\":\"0x122c58329f098059394dbc7263900f092eab0067c1b7c7a680c0db600d5df7cc\"},\"contracts/PriceOracle/PriceOracle.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\nimport \\\"../CToken.sol\\\";\\n\\ncontract PriceOracle {\\n /**\\n * @notice Get the underlying price of a cToken asset\\n * @param cToken The cToken to get the underlying price of\\n * @return The underlying asset price mantissa (scaled by 1e18).\\n * Zero means the price is unavailable.\\n */\\n function getUnderlyingPrice(CToken cToken) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xc72c2be6584f9c5590dd089a174cf760f9e1146606224ee86b9196a46255c514\"},\"contracts/Unitroller.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.5.16;\\n\\nimport \\\"./ErrorReporter.sol\\\";\\nimport \\\"./ComptrollerStorage.sol\\\";\\n\\n/**\\n * @title ComptrollerCore\\n * @dev Storage for the comptroller is at this address, while execution is delegated to the `comptrollerImplementation`.\\n * CTokens should reference this contract as their comptroller.\\n */\\ncontract Unitroller is UnitrollerAdminStorage, ComptrollerErrorReporter {\\n /**\\n * @notice Emitted when pendingComptrollerImplementation is changed\\n */\\n event NewPendingImplementation(address oldPendingImplementation, address newPendingImplementation);\\n\\n /**\\n * @notice Emitted when pendingComptrollerImplementation is accepted, which means comptroller implementation is updated\\n */\\n event NewImplementation(address oldImplementation, address newImplementation);\\n\\n /**\\n * @notice Emitted when pendingAdmin is changed\\n */\\n event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);\\n\\n /**\\n * @notice Emitted when pendingAdmin is accepted, which means admin is updated\\n */\\n event NewAdmin(address oldAdmin, address newAdmin);\\n\\n constructor() public {\\n // Set admin to caller\\n admin = msg.sender;\\n }\\n\\n /*** Admin Functions ***/\\n function _setPendingImplementation(address newPendingImplementation) public returns (uint256) {\\n if (msg.sender != admin) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_IMPLEMENTATION_OWNER_CHECK);\\n }\\n\\n address oldPendingImplementation = pendingComptrollerImplementation;\\n\\n pendingComptrollerImplementation = newPendingImplementation;\\n\\n emit NewPendingImplementation(oldPendingImplementation, pendingComptrollerImplementation);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Accepts new implementation of comptroller. msg.sender must be pendingImplementation\\n * @dev Admin function for new implementation to accept it's role as implementation\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _acceptImplementation() public returns (uint256) {\\n // Check caller is pendingImplementation and pendingImplementation \\u2260 address(0)\\n if (msg.sender != pendingComptrollerImplementation || pendingComptrollerImplementation == address(0)) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_PENDING_IMPLEMENTATION_ADDRESS_CHECK);\\n }\\n\\n // Save current values for inclusion in log\\n address oldImplementation = comptrollerImplementation;\\n address oldPendingImplementation = pendingComptrollerImplementation;\\n\\n comptrollerImplementation = pendingComptrollerImplementation;\\n\\n pendingComptrollerImplementation = address(0);\\n\\n emit NewImplementation(oldImplementation, comptrollerImplementation);\\n emit NewPendingImplementation(oldPendingImplementation, pendingComptrollerImplementation);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\\n * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.\\n * @param newPendingAdmin New pending admin.\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _setPendingAdmin(address newPendingAdmin) public returns (uint256) {\\n // Check caller = admin\\n if (msg.sender != admin) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_ADMIN_OWNER_CHECK);\\n }\\n\\n // Save current value, if any, for inclusion in log\\n address oldPendingAdmin = pendingAdmin;\\n\\n // Store pendingAdmin with value newPendingAdmin\\n pendingAdmin = newPendingAdmin;\\n\\n // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin)\\n emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin\\n * @dev Admin function for pending admin to accept role and update admin\\n * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details)\\n */\\n function _acceptAdmin() public returns (uint256) {\\n // Check caller is pendingAdmin and pendingAdmin \\u2260 address(0)\\n if (msg.sender != pendingAdmin || msg.sender == address(0)) {\\n return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_ADMIN_PENDING_ADMIN_CHECK);\\n }\\n\\n // Save current values for inclusion in log\\n address oldAdmin = admin;\\n address oldPendingAdmin = pendingAdmin;\\n\\n // Store admin with value pendingAdmin\\n admin = pendingAdmin;\\n\\n // Clear the pending value\\n pendingAdmin = address(0);\\n\\n emit NewAdmin(oldAdmin, admin);\\n emit NewPendingAdmin(oldPendingAdmin, pendingAdmin);\\n\\n return uint256(Error.NO_ERROR);\\n }\\n\\n /**\\n * @dev Delegates execution to an implementation contract.\\n * It returns to the external caller whatever the implementation returns\\n * or forwards reverts.\\n */\\n function() external payable {\\n // delegate all other functions to current implementation\\n (bool success, ) = comptrollerImplementation.delegatecall(msg.data);\\n\\n assembly {\\n let free_mem_ptr := mload(0x40)\\n returndatacopy(free_mem_ptr, 0, returndatasize)\\n\\n switch success\\n case 0 {\\n revert(free_mem_ptr, returndatasize)\\n }\\n default {\\n return(free_mem_ptr, returndatasize)\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x7a6cc035c2e35f387a345c2b6738d30ff98ba6d3606b385d857a4d0f5e418d66\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "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", "devdoc": { "methods": {} }, "userdoc": { "methods": {} }, "storageLayout": { "storage": [], "types": null } }