Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
Comptroller
Compiler Version
v0.5.17+commit.d19bba13
Contract Source Code (Solidity Multiple files format)
pragma solidity ^0.5.16; import "./CToken.sol"; import "./ErrorReporter.sol"; import "./Exponential.sol"; import "./PriceOracle.sol"; import "./ComptrollerInterface.sol"; import "./ComptrollerStorage.sol"; import "./Unitroller.sol"; import "./Comp.sol"; /** * @title Compound's Comptroller Contract * @author Compound */ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerErrorReporter, Exponential { /// @notice Emitted when an admin supports a market event MarketListed(CToken cToken); /// @notice Emitted when an account enters a market event MarketEntered(CToken cToken, address account); /// @notice Emitted when an account exits a market event MarketExited(CToken cToken, address account); /// @notice Emitted when close factor is changed by admin event NewCloseFactor(uint oldCloseFactorMantissa, uint newCloseFactorMantissa); /// @notice Emitted when a collateral factor is changed by admin event NewCollateralFactor(CToken cToken, uint oldCollateralFactorMantissa, uint newCollateralFactorMantissa); /// @notice Emitted when liquidation incentive is changed by admin event NewLiquidationIncentive(uint oldLiquidationIncentiveMantissa, uint newLiquidationIncentiveMantissa); /// @notice Emitted when maxAssets is changed by admin event NewMaxAssets(uint oldMaxAssets, uint newMaxAssets); /// @notice Emitted when price oracle is changed event NewPriceOracle(PriceOracle oldPriceOracle, PriceOracle newPriceOracle); /// @notice Emitted when pause guardian is changed event NewPauseGuardian(address oldPauseGuardian, address newPauseGuardian); /// @notice Emitted when an action is paused globally event ActionPaused(string action, bool pauseState); /// @notice Emitted when an action is paused on a market event ActionPaused(CToken cToken, string action, bool pauseState); /// @notice Emitted when market comped status is changed event MarketComped(CToken cToken, bool isComped); /// @notice Emitted when COMP rate is changed event NewCompRate(uint oldCompRate, uint newCompRate); /// @notice Emitted when a new COMP speed is calculated for a market event CompSpeedUpdated(CToken indexed cToken, uint newSpeed); /// @notice Emitted when COMP is distributed to a supplier event DistributedSupplierComp(CToken indexed cToken, address indexed supplier, uint compDelta, uint compSupplyIndex); /// @notice Emitted when COMP is distributed to a borrower event DistributedBorrowerComp(CToken indexed cToken, address indexed borrower, uint compDelta, uint compBorrowIndex); /// @notice The threshold above which the flywheel transfers COMP, in wei uint public constant compClaimThreshold = 0.001e18; /// @notice The initial COMP index for a market uint224 public constant compInitialIndex = 1e36; // closeFactorMantissa must be strictly greater than this value uint internal constant closeFactorMinMantissa = 0.05e18; // 0.05 // closeFactorMantissa must not exceed this value uint internal constant closeFactorMaxMantissa = 0.9e18; // 0.9 // No collateralFactorMantissa may exceed this value uint internal constant collateralFactorMaxMantissa = 0.9e18; // 0.9 // liquidationIncentiveMantissa must be no less than this value uint internal constant liquidationIncentiveMinMantissa = 1.0e18; // 1.0 // liquidationIncentiveMantissa must be no greater than this value uint internal constant liquidationIncentiveMaxMantissa = 1.5e18; // 1.5 constructor() public { admin = msg.sender; } /*** Assets You Are In ***/ /** * @notice Returns the assets an account has entered * @param account The address of the account to pull assets for * @return A dynamic list with the assets the account has entered */ function getAssetsIn(address account) external view returns (CToken[] memory) { CToken[] memory assetsIn = accountAssets[account]; return assetsIn; } /** * @notice Returns whether the given account is entered in the given asset * @param account The address of the account to check * @param cToken The cToken to check * @return True if the account is in the asset, otherwise false. */ function checkMembership(address account, CToken cToken) external view returns (bool) { return markets[address(cToken)].accountMembership[account]; } /** * @notice Add assets to be included in account liquidity calculation * @param cTokens The list of addresses of the cToken markets to be enabled * @return Success indicator for whether each corresponding market was entered */ function enterMarkets(address[] memory cTokens) public returns (uint[] memory) { uint len = cTokens.length; uint[] memory results = new uint[](len); for (uint i = 0; i < len; i++) { CToken cToken = CToken(cTokens[i]); results[i] = uint(addToMarketInternal(cToken, msg.sender)); } return results; } /** * @notice Add the market to the borrower's "assets in" for liquidity calculations * @param cToken The market to enter * @param borrower The address of the account to modify * @return Success indicator for whether the market was entered */ function addToMarketInternal(CToken cToken, address borrower) internal returns (Error) { Market storage marketToJoin = markets[address(cToken)]; if (!marketToJoin.isListed) { // market is not listed, cannot join return Error.MARKET_NOT_LISTED; } if (marketToJoin.accountMembership[borrower] == true) { // already joined return Error.NO_ERROR; } if (accountAssets[borrower].length >= maxAssets) { // no space, cannot join return Error.TOO_MANY_ASSETS; } // survived the gauntlet, add to list // NOTE: we store these somewhat redundantly as a significant optimization // this avoids having to iterate through the list for the most common use cases // that is, only when we need to perform liquidity checks // and not whenever we want to check if an account is in a particular market marketToJoin.accountMembership[borrower] = true; accountAssets[borrower].push(cToken); emit MarketEntered(cToken, borrower); return Error.NO_ERROR; } /** * @notice Removes asset from sender's account liquidity calculation * @dev Sender must not have an outstanding borrow balance in the asset, * or be providing necessary collateral for an outstanding borrow. * @param cTokenAddress The address of the asset to be removed * @return Whether or not the account successfully exited the market */ function exitMarket(address cTokenAddress) external returns (uint) { CToken cToken = CToken(cTokenAddress); /* Get sender tokensHeld and amountOwed underlying from the cToken */ (uint oErr, uint tokensHeld, uint amountOwed, ) = cToken.getAccountSnapshot(msg.sender); require(oErr == 0, "exitMarket: getAccountSnapshot failed"); // semi-opaque error code /* Fail if the sender has a borrow balance */ if (amountOwed != 0) { return fail(Error.NONZERO_BORROW_BALANCE, FailureInfo.EXIT_MARKET_BALANCE_OWED); } /* Fail if the sender is not permitted to redeem all of their tokens */ uint allowed = redeemAllowedInternal(cTokenAddress, msg.sender, tokensHeld); if (allowed != 0) { return failOpaque(Error.REJECTION, FailureInfo.EXIT_MARKET_REJECTION, allowed); } Market storage marketToExit = markets[address(cToken)]; /* Return true if the sender is not already ‘in’ the market */ if (!marketToExit.accountMembership[msg.sender]) { return uint(Error.NO_ERROR); } /* Set cToken account membership to false */ delete marketToExit.accountMembership[msg.sender]; /* Delete cToken from the account’s list of assets */ // load into memory for faster iteration CToken[] memory userAssetList = accountAssets[msg.sender]; uint len = userAssetList.length; uint assetIndex = len; for (uint i = 0; i < len; i++) { if (userAssetList[i] == cToken) { assetIndex = i; break; } } // We *must* have found the asset in the list or our redundant data structure is broken assert(assetIndex < len); // copy last item in list to location of item to be removed, reduce length by 1 CToken[] storage storedList = accountAssets[msg.sender]; storedList[assetIndex] = storedList[storedList.length - 1]; storedList.length--; emit MarketExited(cToken, msg.sender); return uint(Error.NO_ERROR); } /*** Policy Hooks ***/ /** * @notice Checks if the account should be allowed to mint tokens in the given market * @param cToken The market to verify the mint against * @param minter The account which would get the minted tokens * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol) */ function mintAllowed(address cToken, address minter, uint mintAmount) external returns (uint) { // Pausing is a very serious situation - we revert to sound the alarms require(!mintGuardianPaused[cToken], "mint is paused"); // Shh - currently unused minter; mintAmount; if (!markets[cToken].isListed) { return uint(Error.MARKET_NOT_LISTED); } // Keep the flywheel moving updateCompSupplyIndex(cToken); distributeSupplierComp(cToken, minter, false); return uint(Error.NO_ERROR); } /** * @notice Validates mint and reverts on rejection. May emit logs. * @param cToken Asset being minted * @param minter The address minting the tokens * @param actualMintAmount The amount of the underlying asset being minted * @param mintTokens The number of tokens being minted */ function mintVerify(address cToken, address minter, uint actualMintAmount, uint mintTokens) external { // Shh - currently unused cToken; minter; actualMintAmount; mintTokens; // Shh - we don't ever want this hook to be marked pure if (false) { maxAssets = maxAssets; } } /** * @notice Checks if the account should be allowed to redeem tokens in the given market * @param cToken The market to verify the redeem against * @param redeemer The account which would redeem the tokens * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol) */ function redeemAllowed(address cToken, address redeemer, uint redeemTokens) external returns (uint) { uint allowed = redeemAllowedInternal(cToken, redeemer, redeemTokens); if (allowed != uint(Error.NO_ERROR)) { return allowed; } // Keep the flywheel moving updateCompSupplyIndex(cToken); distributeSupplierComp(cToken, redeemer, false); return uint(Error.NO_ERROR); } function redeemAllowedInternal(address cToken, address redeemer, uint redeemTokens) internal view returns (uint) { if (!markets[cToken].isListed) { return uint(Error.MARKET_NOT_LISTED); } /* If the redeemer is not 'in' the market, then we can bypass the liquidity check */ if (!markets[cToken].accountMembership[redeemer]) { return uint(Error.NO_ERROR); } /* Otherwise, perform a hypothetical liquidity check to guard against shortfall */ (Error err, , uint shortfall) = getHypotheticalAccountLiquidityInternal(redeemer, CToken(cToken), redeemTokens, 0); if (err != Error.NO_ERROR) { return uint(err); } if (shortfall > 0) { return uint(Error.INSUFFICIENT_LIQUIDITY); } return uint(Error.NO_ERROR); } /** * @notice Validates redeem and reverts on rejection. May emit logs. * @param cToken Asset being redeemed * @param redeemer The address redeeming the tokens * @param redeemAmount The amount of the underlying asset being redeemed * @param redeemTokens The number of tokens being redeemed */ function redeemVerify(address cToken, address redeemer, uint redeemAmount, uint redeemTokens) external { // Shh - currently unused cToken; redeemer; // Require tokens is zero or amount is also zero if (redeemTokens == 0 && redeemAmount > 0) { revert("redeemTokens zero"); } } /** * @notice Checks if the account should be allowed to borrow the underlying asset of the given market * @param cToken The market to verify the borrow against * @param borrower The account which would borrow the asset * @param borrowAmount The amount of underlying the account would borrow * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol) */ function borrowAllowed(address cToken, address borrower, uint borrowAmount) external returns (uint) { // Pausing is a very serious situation - we revert to sound the alarms require(!borrowGuardianPaused[cToken], "borrow is paused"); if (!markets[cToken].isListed) { return uint(Error.MARKET_NOT_LISTED); } if (!markets[cToken].accountMembership[borrower]) { // only cTokens may call borrowAllowed if borrower not in market require(msg.sender == cToken, "sender must be cToken"); // attempt to add borrower to the market Error err = addToMarketInternal(CToken(msg.sender), borrower); if (err != Error.NO_ERROR) { return uint(err); } // it should be impossible to break the important invariant assert(markets[cToken].accountMembership[borrower]); } if (oracle.getUnderlyingPrice(CToken(cToken)) == 0) { return uint(Error.PRICE_ERROR); } (Error err, , uint shortfall) = getHypotheticalAccountLiquidityInternal(borrower, CToken(cToken), 0, borrowAmount); if (err != Error.NO_ERROR) { return uint(err); } if (shortfall > 0) { return uint(Error.INSUFFICIENT_LIQUIDITY); } // Keep the flywheel moving Exp memory borrowIndex = Exp({mantissa: CToken(cToken).borrowIndex()}); updateCompBorrowIndex(cToken, borrowIndex); distributeBorrowerComp(cToken, borrower, borrowIndex, false); return uint(Error.NO_ERROR); } /** * @notice Validates borrow and reverts on rejection. May emit logs. * @param cToken Asset whose underlying is being borrowed * @param borrower The address borrowing the underlying * @param borrowAmount The amount of the underlying asset requested to borrow */ function borrowVerify(address cToken, address borrower, uint borrowAmount) external { // Shh - currently unused cToken; borrower; borrowAmount; // Shh - we don't ever want this hook to be marked pure if (false) { maxAssets = maxAssets; } } /** * @notice Checks if the account should be allowed to repay a borrow in the given market * @param cToken The market to verify the repay against * @param payer The account which would repay the asset * @param borrower The account which would borrowed the asset * @param repayAmount The amount of the underlying asset the account would repay * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol) */ function repayBorrowAllowed( address cToken, address payer, address borrower, uint repayAmount) external returns (uint) { // Shh - currently unused payer; borrower; repayAmount; if (!markets[cToken].isListed) { return uint(Error.MARKET_NOT_LISTED); } // Keep the flywheel moving Exp memory borrowIndex = Exp({mantissa: CToken(cToken).borrowIndex()}); updateCompBorrowIndex(cToken, borrowIndex); distributeBorrowerComp(cToken, borrower, borrowIndex, false); return uint(Error.NO_ERROR); } /** * @notice Validates repayBorrow and reverts on rejection. May emit logs. * @param cToken Asset being repaid * @param payer The address repaying the borrow * @param borrower The address of the borrower * @param actualRepayAmount The amount of underlying being repaid */ function repayBorrowVerify( address cToken, address payer, address borrower, uint actualRepayAmount, uint borrowerIndex) external { // Shh - currently unused cToken; payer; borrower; actualRepayAmount; borrowerIndex; // Shh - we don't ever want this hook to be marked pure if (false) { maxAssets = maxAssets; } } /** * @notice Checks if the liquidation should be allowed to occur * @param cTokenBorrowed Asset which was borrowed by the borrower * @param cTokenCollateral Asset which was used as collateral and will be seized * @param liquidator The address repaying the borrow and seizing the collateral * @param borrower The address of the borrower * @param repayAmount The amount of underlying being repaid */ function liquidateBorrowAllowed( address cTokenBorrowed, address cTokenCollateral, address liquidator, address borrower, uint repayAmount) external returns (uint) { // Shh - currently unused liquidator; if (!markets[cTokenBorrowed].isListed || !markets[cTokenCollateral].isListed) { return uint(Error.MARKET_NOT_LISTED); } /* The borrower must have shortfall in order to be liquidatable */ (Error err, , uint shortfall) = getAccountLiquidityInternal(borrower); if (err != Error.NO_ERROR) { return uint(err); } if (shortfall == 0) { return uint(Error.INSUFFICIENT_SHORTFALL); } /* The liquidator may not repay more than what is allowed by the closeFactor */ uint borrowBalance = CToken(cTokenBorrowed).borrowBalanceStored(borrower); (MathError mathErr, uint maxClose) = mulScalarTruncate(Exp({mantissa: closeFactorMantissa}), borrowBalance); if (mathErr != MathError.NO_ERROR) { return uint(Error.MATH_ERROR); } if (repayAmount > maxClose) { return uint(Error.TOO_MUCH_REPAY); } return uint(Error.NO_ERROR); } /** * @notice Validates liquidateBorrow and reverts on rejection. May emit logs. * @param cTokenBorrowed Asset which was borrowed by the borrower * @param cTokenCollateral Asset which was used as collateral and will be seized * @param liquidator The address repaying the borrow and seizing the collateral * @param borrower The address of the borrower * @param actualRepayAmount The amount of underlying being repaid */ function liquidateBorrowVerify( address cTokenBorrowed, address cTokenCollateral, address liquidator, address borrower, uint actualRepayAmount, uint seizeTokens) external { // Shh - currently unused cTokenBorrowed; cTokenCollateral; liquidator; borrower; actualRepayAmount; seizeTokens; // Shh - we don't ever want this hook to be marked pure if (false) { maxAssets = maxAssets; } } /** * @notice Checks if the seizing of assets should be allowed to occur * @param cTokenCollateral Asset which was used as collateral and will be seized * @param cTokenBorrowed Asset which was borrowed by the borrower * @param liquidator The address repaying the borrow and seizing the collateral * @param borrower The address of the borrower * @param seizeTokens The number of collateral tokens to seize */ function seizeAllowed( address cTokenCollateral, address cTokenBorrowed, address liquidator, address borrower, uint seizeTokens) external returns (uint) { // Pausing is a very serious situation - we revert to sound the alarms require(!seizeGuardianPaused, "seize is paused"); // Shh - currently unused seizeTokens; if (!markets[cTokenCollateral].isListed || !markets[cTokenBorrowed].isListed) { return uint(Error.MARKET_NOT_LISTED); } if (CToken(cTokenCollateral).comptroller() != CToken(cTokenBorrowed).comptroller()) { return uint(Error.COMPTROLLER_MISMATCH); } // Keep the flywheel moving updateCompSupplyIndex(cTokenCollateral); distributeSupplierComp(cTokenCollateral, borrower, false); distributeSupplierComp(cTokenCollateral, liquidator, false); return uint(Error.NO_ERROR); } /** * @notice Validates seize and reverts on rejection. May emit logs. * @param cTokenCollateral Asset which was used as collateral and will be seized * @param cTokenBorrowed Asset which was borrowed by the borrower * @param liquidator The address repaying the borrow and seizing the collateral * @param borrower The address of the borrower * @param seizeTokens The number of collateral tokens to seize */ function seizeVerify( address cTokenCollateral, address cTokenBorrowed, address liquidator, address borrower, uint seizeTokens) external { // Shh - currently unused cTokenCollateral; cTokenBorrowed; liquidator; borrower; seizeTokens; // Shh - we don't ever want this hook to be marked pure if (false) { maxAssets = maxAssets; } } /** * @notice Checks if the account should be allowed to transfer tokens in the given market * @param cToken The market to verify the transfer against * @param src The account which sources the tokens * @param dst The account which receives the tokens * @param transferTokens The number of cTokens to transfer * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol) */ function transferAllowed(address cToken, address src, address dst, uint transferTokens) external returns (uint) { // Pausing is a very serious situation - we revert to sound the alarms require(!transferGuardianPaused, "transfer is paused"); // Currently the only consideration is whether or not // the src is allowed to redeem this many tokens uint allowed = redeemAllowedInternal(cToken, src, transferTokens); if (allowed != uint(Error.NO_ERROR)) { return allowed; } // Keep the flywheel moving updateCompSupplyIndex(cToken); distributeSupplierComp(cToken, src, false); distributeSupplierComp(cToken, dst, false); return uint(Error.NO_ERROR); } /** * @notice Validates transfer and reverts on rejection. May emit logs. * @param cToken Asset being transferred * @param src The account which sources the tokens * @param dst The account which receives the tokens * @param transferTokens The number of cTokens to transfer */ function transferVerify(address cToken, address src, address dst, uint transferTokens) external { // Shh - currently unused cToken; src; dst; transferTokens; // Shh - we don't ever want this hook to be marked pure if (false) { maxAssets = maxAssets; } } /*** Liquidity/Liquidation Calculations ***/ /** * @dev Local vars for avoiding stack-depth limits in calculating account liquidity. * Note that `cTokenBalance` is the number of cTokens the account owns in the market, * whereas `borrowBalance` is the amount of underlying that the account has borrowed. */ struct AccountLiquidityLocalVars { uint sumCollateral; uint sumBorrowPlusEffects; uint cTokenBalance; uint borrowBalance; uint exchangeRateMantissa; uint oraclePriceMantissa; Exp collateralFactor; Exp exchangeRate; Exp oraclePrice; Exp tokensToDenom; } /** * @notice Determine the current account liquidity wrt collateral requirements * @return (possible error code (semi-opaque), account liquidity in excess of collateral requirements, * account shortfall below collateral requirements) */ function getAccountLiquidity(address account) public view returns (uint, uint, uint) { (Error err, uint liquidity, uint shortfall) = getHypotheticalAccountLiquidityInternal(account, CToken(0), 0, 0); return (uint(err), liquidity, shortfall); } /** * @notice Determine the current account liquidity wrt collateral requirements * @return (possible error code, account liquidity in excess of collateral requirements, * account shortfall below collateral requirements) */ function getAccountLiquidityInternal(address account) internal view returns (Error, uint, uint) { return getHypotheticalAccountLiquidityInternal(account, CToken(0), 0, 0); } /** * @notice Determine what the account liquidity would be if the given amounts were redeemed/borrowed * @param cTokenModify The market to hypothetically redeem/borrow in * @param account The account to determine liquidity for * @param redeemTokens The number of tokens to hypothetically redeem * @param borrowAmount The amount of underlying to hypothetically borrow * @return (possible error code (semi-opaque), hypothetical account liquidity in excess of collateral requirements, * hypothetical account shortfall below collateral requirements) */ function getHypotheticalAccountLiquidity( address account, address cTokenModify, uint redeemTokens, uint borrowAmount) public view returns (uint, uint, uint) { (Error err, uint liquidity, uint shortfall) = getHypotheticalAccountLiquidityInternal(account, CToken(cTokenModify), redeemTokens, borrowAmount); return (uint(err), liquidity, shortfall); } /** * @notice Determine what the account liquidity would be if the given amounts were redeemed/borrowed * @param cTokenModify The market to hypothetically redeem/borrow in * @param account The account to determine liquidity for * @param redeemTokens The number of tokens to hypothetically redeem * @param borrowAmount The amount of underlying to hypothetically borrow * @dev Note that we calculate the exchangeRateStored for each collateral cToken using stored data, * without calculating accumulated interest. * @return (possible error code, hypothetical account liquidity in excess of collateral requirements, * hypothetical account shortfall below collateral requirements) */ function getHypotheticalAccountLiquidityInternal( address account, CToken cTokenModify, uint redeemTokens, uint borrowAmount) internal view returns (Error, uint, uint) { AccountLiquidityLocalVars memory vars; // Holds all our calculation results uint oErr; MathError mErr; // For each asset the account is in CToken[] memory assets = accountAssets[account]; for (uint i = 0; i < assets.length; i++) { CToken asset = assets[i]; // Read the balances and exchange rate from the cToken (oErr, vars.cTokenBalance, vars.borrowBalance, vars.exchangeRateMantissa) = asset.getAccountSnapshot(account); if (oErr != 0) { // semi-opaque error code, we assume NO_ERROR == 0 is invariant between upgrades return (Error.SNAPSHOT_ERROR, 0, 0); } vars.collateralFactor = Exp({mantissa: markets[address(asset)].collateralFactorMantissa}); vars.exchangeRate = Exp({mantissa: vars.exchangeRateMantissa}); // Get the normalized price of the asset vars.oraclePriceMantissa = oracle.getUnderlyingPrice(asset); if (vars.oraclePriceMantissa == 0) { return (Error.PRICE_ERROR, 0, 0); } vars.oraclePrice = Exp({mantissa: vars.oraclePriceMantissa}); // Pre-compute a conversion factor from tokens -> ether (normalized price value) (mErr, vars.tokensToDenom) = mulExp3(vars.collateralFactor, vars.exchangeRate, vars.oraclePrice); if (mErr != MathError.NO_ERROR) { return (Error.MATH_ERROR, 0, 0); } // sumCollateral += tokensToDenom * cTokenBalance (mErr, vars.sumCollateral) = mulScalarTruncateAddUInt(vars.tokensToDenom, vars.cTokenBalance, vars.sumCollateral); if (mErr != MathError.NO_ERROR) { return (Error.MATH_ERROR, 0, 0); } // sumBorrowPlusEffects += oraclePrice * borrowBalance (mErr, vars.sumBorrowPlusEffects) = mulScalarTruncateAddUInt(vars.oraclePrice, vars.borrowBalance, vars.sumBorrowPlusEffects); if (mErr != MathError.NO_ERROR) { return (Error.MATH_ERROR, 0, 0); } // Calculate effects of interacting with cTokenModify if (asset == cTokenModify) { // redeem effect // sumBorrowPlusEffects += tokensToDenom * redeemTokens (mErr, vars.sumBorrowPlusEffects) = mulScalarTruncateAddUInt(vars.tokensToDenom, redeemTokens, vars.sumBorrowPlusEffects); if (mErr != MathError.NO_ERROR) { return (Error.MATH_ERROR, 0, 0); } // borrow effect // sumBorrowPlusEffects += oraclePrice * borrowAmount (mErr, vars.sumBorrowPlusEffects) = mulScalarTruncateAddUInt(vars.oraclePrice, borrowAmount, vars.sumBorrowPlusEffects); if (mErr != MathError.NO_ERROR) { return (Error.MATH_ERROR, 0, 0); } } } // These are safe, as the underflow condition is checked first if (vars.sumCollateral > vars.sumBorrowPlusEffects) { return (Error.NO_ERROR, vars.sumCollateral - vars.sumBorrowPlusEffects, 0); } else { return (Error.NO_ERROR, 0, vars.sumBorrowPlusEffects - vars.sumCollateral); } } /** * @notice Calculate number of tokens of collateral asset to seize given an underlying amount * @dev Used in liquidation (called in cToken.liquidateBorrowFresh) * @param cTokenBorrowed The address of the borrowed cToken * @param cTokenCollateral The address of the collateral cToken * @param actualRepayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation) */ function liquidateCalculateSeizeTokens(address cTokenBorrowed, address cTokenCollateral, uint actualRepayAmount) external view returns (uint, uint) { /* Read oracle prices for borrowed and collateral markets */ uint priceBorrowedMantissa = oracle.getUnderlyingPrice(CToken(cTokenBorrowed)); uint priceCollateralMantissa = oracle.getUnderlyingPrice(CToken(cTokenCollateral)); if (priceBorrowedMantissa == 0 || priceCollateralMantissa == 0) { return (uint(Error.PRICE_ERROR), 0); } /* * Get the exchange rate and calculate the number of collateral tokens to seize: * seizeAmount = actualRepayAmount * liquidationIncentive * priceBorrowed / priceCollateral * seizeTokens = seizeAmount / exchangeRate * = actualRepayAmount * (liquidationIncentive * priceBorrowed) / (priceCollateral * exchangeRate) */ uint exchangeRateMantissa = CToken(cTokenCollateral).exchangeRateStored(); // Note: reverts on error uint seizeTokens; Exp memory numerator; Exp memory denominator; Exp memory ratio; MathError mathErr; (mathErr, numerator) = mulExp(liquidationIncentiveMantissa, priceBorrowedMantissa); if (mathErr != MathError.NO_ERROR) { return (uint(Error.MATH_ERROR), 0); } (mathErr, denominator) = mulExp(priceCollateralMantissa, exchangeRateMantissa); if (mathErr != MathError.NO_ERROR) { return (uint(Error.MATH_ERROR), 0); } (mathErr, ratio) = divExp(numerator, denominator); if (mathErr != MathError.NO_ERROR) { return (uint(Error.MATH_ERROR), 0); } (mathErr, seizeTokens) = mulScalarTruncate(ratio, actualRepayAmount); if (mathErr != MathError.NO_ERROR) { return (uint(Error.MATH_ERROR), 0); } return (uint(Error.NO_ERROR), seizeTokens); } /*** Admin Functions ***/ /** * @notice Sets a new price oracle for the comptroller * @dev Admin function to set a new price oracle * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setPriceOracle(PriceOracle newOracle) public returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_PRICE_ORACLE_OWNER_CHECK); } // Track the old oracle for the comptroller PriceOracle oldOracle = oracle; // Set comptroller's oracle to newOracle oracle = newOracle; // Emit NewPriceOracle(oldOracle, newOracle) emit NewPriceOracle(oldOracle, newOracle); return uint(Error.NO_ERROR); } /** * @notice Sets the closeFactor used when liquidating borrows * @dev Admin function to set closeFactor * @param newCloseFactorMantissa New close factor, scaled by 1e18 * @return uint 0=success, otherwise a failure. (See ErrorReporter for details) */ function _setCloseFactor(uint newCloseFactorMantissa) external returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_CLOSE_FACTOR_OWNER_CHECK); } Exp memory newCloseFactorExp = Exp({mantissa: newCloseFactorMantissa}); Exp memory lowLimit = Exp({mantissa: closeFactorMinMantissa}); if (lessThanOrEqualExp(newCloseFactorExp, lowLimit)) { return fail(Error.INVALID_CLOSE_FACTOR, FailureInfo.SET_CLOSE_FACTOR_VALIDATION); } Exp memory highLimit = Exp({mantissa: closeFactorMaxMantissa}); if (lessThanExp(highLimit, newCloseFactorExp)) { return fail(Error.INVALID_CLOSE_FACTOR, FailureInfo.SET_CLOSE_FACTOR_VALIDATION); } uint oldCloseFactorMantissa = closeFactorMantissa; closeFactorMantissa = newCloseFactorMantissa; emit NewCloseFactor(oldCloseFactorMantissa, closeFactorMantissa); return uint(Error.NO_ERROR); } /** * @notice Sets the collateralFactor for a market * @dev Admin function to set per-market collateralFactor * @param cToken The market to set the factor on * @param newCollateralFactorMantissa The new collateral factor, scaled by 1e18 * @return uint 0=success, otherwise a failure. (See ErrorReporter for details) */ function _setCollateralFactor(CToken cToken, uint newCollateralFactorMantissa) external returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_COLLATERAL_FACTOR_OWNER_CHECK); } // Verify market is listed Market storage market = markets[address(cToken)]; if (!market.isListed) { return fail(Error.MARKET_NOT_LISTED, FailureInfo.SET_COLLATERAL_FACTOR_NO_EXISTS); } Exp memory newCollateralFactorExp = Exp({mantissa: newCollateralFactorMantissa}); // Check collateral factor <= 0.9 Exp memory highLimit = Exp({mantissa: collateralFactorMaxMantissa}); if (lessThanExp(highLimit, newCollateralFactorExp)) { return fail(Error.INVALID_COLLATERAL_FACTOR, FailureInfo.SET_COLLATERAL_FACTOR_VALIDATION); } // If collateral factor != 0, fail if price == 0 if (newCollateralFactorMantissa != 0 && oracle.getUnderlyingPrice(cToken) == 0) { return fail(Error.PRICE_ERROR, FailureInfo.SET_COLLATERAL_FACTOR_WITHOUT_PRICE); } // Set market's collateral factor to new collateral factor, remember old value uint oldCollateralFactorMantissa = market.collateralFactorMantissa; market.collateralFactorMantissa = newCollateralFactorMantissa; // Emit event with asset, old collateral factor, and new collateral factor emit NewCollateralFactor(cToken, oldCollateralFactorMantissa, newCollateralFactorMantissa); return uint(Error.NO_ERROR); } /** * @notice Sets maxAssets which controls how many markets can be entered * @dev Admin function to set maxAssets * @param newMaxAssets New max assets * @return uint 0=success, otherwise a failure. (See ErrorReporter for details) */ function _setMaxAssets(uint newMaxAssets) external returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_MAX_ASSETS_OWNER_CHECK); } uint oldMaxAssets = maxAssets; maxAssets = newMaxAssets; emit NewMaxAssets(oldMaxAssets, newMaxAssets); return uint(Error.NO_ERROR); } /** * @notice Sets liquidationIncentive * @dev Admin function to set liquidationIncentive * @param newLiquidationIncentiveMantissa New liquidationIncentive scaled by 1e18 * @return uint 0=success, otherwise a failure. (See ErrorReporter for details) */ function _setLiquidationIncentive(uint newLiquidationIncentiveMantissa) external returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_LIQUIDATION_INCENTIVE_OWNER_CHECK); } // Check de-scaled min <= newLiquidationIncentive <= max Exp memory newLiquidationIncentive = Exp({mantissa: newLiquidationIncentiveMantissa}); Exp memory minLiquidationIncentive = Exp({mantissa: liquidationIncentiveMinMantissa}); if (lessThanExp(newLiquidationIncentive, minLiquidationIncentive)) { return fail(Error.INVALID_LIQUIDATION_INCENTIVE, FailureInfo.SET_LIQUIDATION_INCENTIVE_VALIDATION); } Exp memory maxLiquidationIncentive = Exp({mantissa: liquidationIncentiveMaxMantissa}); if (lessThanExp(maxLiquidationIncentive, newLiquidationIncentive)) { return fail(Error.INVALID_LIQUIDATION_INCENTIVE, FailureInfo.SET_LIQUIDATION_INCENTIVE_VALIDATION); } // Save current value for use in log uint oldLiquidationIncentiveMantissa = liquidationIncentiveMantissa; // Set liquidation incentive to new incentive liquidationIncentiveMantissa = newLiquidationIncentiveMantissa; // Emit event with old incentive, new incentive emit NewLiquidationIncentive(oldLiquidationIncentiveMantissa, newLiquidationIncentiveMantissa); return uint(Error.NO_ERROR); } /** * @notice Add the market to the markets mapping and set it as listed * @dev Admin function to set isListed and add support for the market * @param cToken The address of the market (token) to list * @return uint 0=success, otherwise a failure. (See enum Error for details) */ function _supportMarket(CToken cToken) external returns (uint) { if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SUPPORT_MARKET_OWNER_CHECK); } if (markets[address(cToken)].isListed) { return fail(Error.MARKET_ALREADY_LISTED, FailureInfo.SUPPORT_MARKET_EXISTS); } cToken.isCToken(); // Sanity check to make sure its really a CToken markets[address(cToken)] = Market({isListed: true, isComped: false, collateralFactorMantissa: 0}); _addMarketInternal(address(cToken)); emit MarketListed(cToken); return uint(Error.NO_ERROR); } function _addMarketInternal(address cToken) internal { for (uint i = 0; i < allMarkets.length; i ++) { require(allMarkets[i] != CToken(cToken), "market already added"); } allMarkets.push(CToken(cToken)); } /** * @notice Admin function to change the Pause Guardian * @param newPauseGuardian The address of the new Pause Guardian * @return uint 0=success, otherwise a failure. (See enum Error for details) */ function _setPauseGuardian(address newPauseGuardian) public returns (uint) { if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_PAUSE_GUARDIAN_OWNER_CHECK); } // Save current value for inclusion in log address oldPauseGuardian = pauseGuardian; // Store pauseGuardian with value newPauseGuardian pauseGuardian = newPauseGuardian; // Emit NewPauseGuardian(OldPauseGuardian, NewPauseGuardian) emit NewPauseGuardian(oldPauseGuardian, pauseGuardian); return uint(Error.NO_ERROR); } function _setMintPaused(CToken cToken, bool state) public returns (bool) { require(markets[address(cToken)].isListed, "cannot pause a market that is not listed"); require(msg.sender == pauseGuardian || msg.sender == admin, "only pause guardian and admin can pause"); require(msg.sender == admin || state == true, "only admin can unpause"); mintGuardianPaused[address(cToken)] = state; emit ActionPaused(cToken, "Mint", state); return state; } function _setBorrowPaused(CToken cToken, bool state) public returns (bool) { require(markets[address(cToken)].isListed, "cannot pause a market that is not listed"); require(msg.sender == pauseGuardian || msg.sender == admin, "only pause guardian and admin can pause"); require(msg.sender == admin || state == true, "only admin can unpause"); borrowGuardianPaused[address(cToken)] = state; emit ActionPaused(cToken, "Borrow", state); return state; } function _setTransferPaused(bool state) public returns (bool) { require(msg.sender == pauseGuardian || msg.sender == admin, "only pause guardian and admin can pause"); require(msg.sender == admin || state == true, "only admin can unpause"); transferGuardianPaused = state; emit ActionPaused("Transfer", state); return state; } function _setSeizePaused(bool state) public returns (bool) { require(msg.sender == pauseGuardian || msg.sender == admin, "only pause guardian and admin can pause"); require(msg.sender == admin || state == true, "only admin can unpause"); seizeGuardianPaused = state; emit ActionPaused("Seize", state); return state; } function _become(Unitroller unitroller) public { require(msg.sender == unitroller.admin(), "only unitroller admin can change brains"); require(unitroller._acceptImplementation() == 0, "change not authorized"); } /** * @notice Checks caller is admin, or this contract is becoming the new implementation */ function adminOrInitializing() internal view returns (bool) { return msg.sender == admin || msg.sender == comptrollerImplementation; } /*** Comp Distribution ***/ /** * @notice Recalculate and update COMP speeds for all COMP markets */ function refreshCompSpeeds() public { require(msg.sender == tx.origin, "only externally owned accounts may refresh speeds"); refreshCompSpeedsInternal(); } function refreshCompSpeedsInternal() internal { CToken[] memory allMarkets_ = allMarkets; for (uint i = 0; i < allMarkets_.length; i++) { CToken cToken = allMarkets_[i]; Exp memory borrowIndex = Exp({mantissa: cToken.borrowIndex()}); updateCompSupplyIndex(address(cToken)); updateCompBorrowIndex(address(cToken), borrowIndex); } Exp memory totalUtility = Exp({mantissa: 0}); Exp[] memory utilities = new Exp[](allMarkets_.length); for (uint i = 0; i < allMarkets_.length; i++) { CToken cToken = allMarkets_[i]; if (markets[address(cToken)].isComped) { Exp memory assetPrice = Exp({mantissa: oracle.getUnderlyingPrice(cToken)}); Exp memory utility = mul_(assetPrice, cToken.totalBorrows()); utilities[i] = utility; totalUtility = add_(totalUtility, utility); } } for (uint i = 0; i < allMarkets_.length; i++) { CToken cToken = allMarkets[i]; uint newSpeed = totalUtility.mantissa > 0 ? mul_(compRate, div_(utilities[i], totalUtility)) : 0; compSpeeds[address(cToken)] = newSpeed; emit CompSpeedUpdated(cToken, newSpeed); } } /** * @notice Accrue COMP to the market by updating the supply index * @param cToken The market whose supply index to update */ function updateCompSupplyIndex(address cToken) internal { CompMarketState storage supplyState = compSupplyState[cToken]; uint supplySpeed = compSpeeds[cToken]; uint blockNumber = getBlockNumber(); uint deltaBlocks = sub_(blockNumber, uint(supplyState.block)); if (deltaBlocks > 0 && supplySpeed > 0) { uint supplyTokens = CToken(cToken).totalSupply(); uint compAccrued = mul_(deltaBlocks, supplySpeed); Double memory ratio = supplyTokens > 0 ? fraction(compAccrued, supplyTokens) : Double({mantissa: 0}); Double memory index = add_(Double({mantissa: supplyState.index}), ratio); compSupplyState[cToken] = CompMarketState({ index: safe224(index.mantissa, "new index exceeds 224 bits"), block: safe32(blockNumber, "block number exceeds 32 bits") }); } else if (deltaBlocks > 0) { supplyState.block = safe32(blockNumber, "block number exceeds 32 bits"); } } /** * @notice Accrue COMP to the market by updating the borrow index * @param cToken The market whose borrow index to update */ function updateCompBorrowIndex(address cToken, Exp memory marketBorrowIndex) internal { CompMarketState storage borrowState = compBorrowState[cToken]; uint borrowSpeed = compSpeeds[cToken]; uint blockNumber = getBlockNumber(); uint deltaBlocks = sub_(blockNumber, uint(borrowState.block)); if (deltaBlocks > 0 && borrowSpeed > 0) { uint borrowAmount = div_(CToken(cToken).totalBorrows(), marketBorrowIndex); uint compAccrued = mul_(deltaBlocks, borrowSpeed); Double memory ratio = borrowAmount > 0 ? fraction(compAccrued, borrowAmount) : Double({mantissa: 0}); Double memory index = add_(Double({mantissa: borrowState.index}), ratio); compBorrowState[cToken] = CompMarketState({ index: safe224(index.mantissa, "new index exceeds 224 bits"), block: safe32(blockNumber, "block number exceeds 32 bits") }); } else if (deltaBlocks > 0) { borrowState.block = safe32(blockNumber, "block number exceeds 32 bits"); } } /** * @notice Calculate COMP accrued by a supplier and possibly transfer it to them * @param cToken The market in which the supplier is interacting * @param supplier The address of the supplier to distribute COMP to */ function distributeSupplierComp(address cToken, address supplier, bool distributeAll) internal { CompMarketState storage supplyState = compSupplyState[cToken]; Double memory supplyIndex = Double({mantissa: supplyState.index}); Double memory supplierIndex = Double({mantissa: compSupplierIndex[cToken][supplier]}); compSupplierIndex[cToken][supplier] = supplyIndex.mantissa; if (supplierIndex.mantissa == 0 && supplyIndex.mantissa > 0) { supplierIndex.mantissa = compInitialIndex; } Double memory deltaIndex = sub_(supplyIndex, supplierIndex); uint supplierTokens = CToken(cToken).balanceOf(supplier); uint supplierDelta = mul_(supplierTokens, deltaIndex); uint supplierAccrued = add_(compAccrued[supplier], supplierDelta); compAccrued[supplier] = transferComp(supplier, supplierAccrued, distributeAll ? 0 : compClaimThreshold); emit DistributedSupplierComp(CToken(cToken), supplier, supplierDelta, supplyIndex.mantissa); } /** * @notice Calculate COMP accrued by a borrower and possibly transfer it to them * @dev Borrowers will not begin to accrue until after the first interaction with the protocol. * @param cToken The market in which the borrower is interacting * @param borrower The address of the borrower to distribute COMP to */ function distributeBorrowerComp(address cToken, address borrower, Exp memory marketBorrowIndex, bool distributeAll) internal { CompMarketState storage borrowState = compBorrowState[cToken]; Double memory borrowIndex = Double({mantissa: borrowState.index}); Double memory borrowerIndex = Double({mantissa: compBorrowerIndex[cToken][borrower]}); compBorrowerIndex[cToken][borrower] = borrowIndex.mantissa; if (borrowerIndex.mantissa > 0) { Double memory deltaIndex = sub_(borrowIndex, borrowerIndex); uint borrowerAmount = div_(CToken(cToken).borrowBalanceStored(borrower), marketBorrowIndex); uint borrowerDelta = mul_(borrowerAmount, deltaIndex); uint borrowerAccrued = add_(compAccrued[borrower], borrowerDelta); compAccrued[borrower] = transferComp(borrower, borrowerAccrued, distributeAll ? 0 : compClaimThreshold); emit DistributedBorrowerComp(CToken(cToken), borrower, borrowerDelta, borrowIndex.mantissa); } } /** * @notice Transfer COMP to the user, if they are above the threshold * @dev Note: If there is not enough COMP, we do not perform the transfer all. * @param user The address of the user to transfer COMP to * @param userAccrued The amount of COMP to (possibly) transfer * @return The amount of COMP which was NOT transferred to the user */ function transferComp(address user, uint userAccrued, uint threshold) internal returns (uint) { if (userAccrued >= threshold && userAccrued > 0) { Comp comp = Comp(getCompAddress()); uint compRemaining = comp.balanceOf(address(this)); if (userAccrued <= compRemaining) { comp.transfer(user, userAccrued); return 0; } } return userAccrued; } /** * @notice Claim all the comp accrued by holder in all markets * @param holder The address to claim COMP for */ function claimComp(address holder) public { return claimComp(holder, allMarkets); } /** * @notice Claim all the comp accrued by holder in the specified markets * @param holder The address to claim COMP for * @param cTokens The list of markets to claim COMP in */ function claimComp(address holder, CToken[] memory cTokens) public { address[] memory holders = new address[](1); holders[0] = holder; claimComp(holders, cTokens, true, true); } /** * @notice Claim all comp accrued by the holders * @param holders The addresses to claim COMP for * @param cTokens The list of markets to claim COMP in * @param borrowers Whether or not to claim COMP earned by borrowing * @param suppliers Whether or not to claim COMP earned by supplying */ function claimComp(address[] memory holders, CToken[] memory cTokens, bool borrowers, bool suppliers) public { for (uint i = 0; i < cTokens.length; i++) { CToken cToken = cTokens[i]; require(markets[address(cToken)].isListed, "market must be listed"); if (borrowers == true) { Exp memory borrowIndex = Exp({mantissa: cToken.borrowIndex()}); updateCompBorrowIndex(address(cToken), borrowIndex); for (uint j = 0; j < holders.length; j++) { distributeBorrowerComp(address(cToken), holders[j], borrowIndex, true); } } if (suppliers == true) { updateCompSupplyIndex(address(cToken)); for (uint j = 0; j < holders.length; j++) { distributeSupplierComp(address(cToken), holders[j], true); } } } } /*** Comp Distribution Admin ***/ /** * @notice Set the amount of COMP distributed per block * @param compRate_ The amount of COMP wei per block to distribute */ function _setCompRate(uint compRate_) public { require(adminOrInitializing(), "only admin can change comp rate"); uint oldRate = compRate; compRate = compRate_; emit NewCompRate(oldRate, compRate_); refreshCompSpeedsInternal(); } /** * @notice Add markets to compMarkets, allowing them to earn COMP in the flywheel * @param cTokens The addresses of the markets to add */ function _addCompMarkets(address[] memory cTokens) public { require(adminOrInitializing(), "only admin can add comp market"); for (uint i = 0; i < cTokens.length; i++) { _addCompMarketInternal(cTokens[i]); } refreshCompSpeedsInternal(); } function _addCompMarketInternal(address cToken) internal { Market storage market = markets[cToken]; require(market.isListed == true, "comp market is not listed"); require(market.isComped == false, "comp market already added"); market.isComped = true; emit MarketComped(CToken(cToken), true); if (compSupplyState[cToken].index == 0 && compSupplyState[cToken].block == 0) { compSupplyState[cToken] = CompMarketState({ index: compInitialIndex, block: safe32(getBlockNumber(), "block number exceeds 32 bits") }); } if (compBorrowState[cToken].index == 0 && compBorrowState[cToken].block == 0) { compBorrowState[cToken] = CompMarketState({ index: compInitialIndex, block: safe32(getBlockNumber(), "block number exceeds 32 bits") }); } } /** * @notice Remove a market from compMarkets, preventing it from earning COMP in the flywheel * @param cToken The address of the market to drop */ function _dropCompMarket(address cToken) public { require(msg.sender == admin, "only admin can drop comp market"); Market storage market = markets[cToken]; require(market.isComped == true, "market is not a comp market"); market.isComped = false; emit MarketComped(CToken(cToken), false); refreshCompSpeedsInternal(); } /** * @notice Return all of the markets * @dev The automatic getter may be used to access an individual market. * @return The list of market addresses */ function getAllMarkets() public view returns (CToken[] memory) { return allMarkets; } function getBlockNumber() public view returns (uint) { return block.number; } /** * @notice Return the address of the COMP token * @return The address of COMP */ function getCompAddress() public view returns (address) { return 0x2ba592F78dB6436527729929AAf6c908497cB200; } }
pragma solidity ^0.5.16; /** * @title Careful Math * @author Compound * @notice Derived from OpenZeppelin's SafeMath library * https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/math/SafeMath.sol */ contract CarefulMath { /** * @dev Possible error codes that we can return */ enum MathError { NO_ERROR, DIVISION_BY_ZERO, INTEGER_OVERFLOW, INTEGER_UNDERFLOW } /** * @dev Multiplies two numbers, returns an error on overflow. */ function mulUInt(uint a, uint b) internal pure returns (MathError, uint) { if (a == 0) { return (MathError.NO_ERROR, 0); } uint c = a * b; if (c / a != b) { return (MathError.INTEGER_OVERFLOW, 0); } else { return (MathError.NO_ERROR, c); } } /** * @dev Integer division of two numbers, truncating the quotient. */ function divUInt(uint a, uint b) internal pure returns (MathError, uint) { if (b == 0) { return (MathError.DIVISION_BY_ZERO, 0); } return (MathError.NO_ERROR, a / b); } /** * @dev Subtracts two numbers, returns an error on overflow (i.e. if subtrahend is greater than minuend). */ function subUInt(uint a, uint b) internal pure returns (MathError, uint) { if (b <= a) { return (MathError.NO_ERROR, a - b); } else { return (MathError.INTEGER_UNDERFLOW, 0); } } /** * @dev Adds two numbers, returns an error on overflow. */ function addUInt(uint a, uint b) internal pure returns (MathError, uint) { uint c = a + b; if (c >= a) { return (MathError.NO_ERROR, c); } else { return (MathError.INTEGER_OVERFLOW, 0); } } /** * @dev add a and b and then subtract c */ function addThenSubUInt(uint a, uint b, uint c) internal pure returns (MathError, uint) { (MathError err0, uint sum) = addUInt(a, b); if (err0 != MathError.NO_ERROR) { return (err0, 0); } return subUInt(sum, c); } }
pragma solidity ^0.5.16; pragma experimental ABIEncoderV2; contract Comp { /// @notice EIP-20 token name for this token string public constant name = "Cream"; /// @notice EIP-20 token symbol for this token string public constant symbol = "CREAM"; /// @notice EIP-20 token decimals for this token uint8 public constant decimals = 18; /// @notice Total number of tokens in circulation uint public constant totalSupply = 9000000e18; // 9 million Comp /// @notice Allowance amounts on behalf of others mapping (address => mapping (address => uint96)) internal allowances; /// @notice Official record of token balances for each account mapping (address => uint96) internal balances; /// @notice A record of each accounts delegate mapping (address => address) public delegates; /// @notice A checkpoint for marking number of votes from a given block struct Checkpoint { uint32 fromBlock; uint96 votes; } /// @notice A record of votes checkpoints for each account, by index mapping (address => mapping (uint32 => Checkpoint)) public checkpoints; /// @notice The number of checkpoints for each account mapping (address => uint32) public numCheckpoints; /// @notice The EIP-712 typehash for the contract's domain bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)"); /// @notice The EIP-712 typehash for the delegation struct used by the contract bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)"); /// @notice A record of states for signing / validating signatures mapping (address => uint) public nonces; /// @notice An event thats emitted when an account changes its delegate event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate); /// @notice An event thats emitted when a delegate account's vote balance changes event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance); /// @notice The standard EIP-20 transfer event event Transfer(address indexed from, address indexed to, uint256 amount); /// @notice The standard EIP-20 approval event event Approval(address indexed owner, address indexed spender, uint256 amount); /** * @notice Construct a new Comp token * @param account The initial account to grant all the tokens */ constructor(address account) public { balances[account] = uint96(totalSupply); emit Transfer(address(0), account, totalSupply); } /** * @notice Get the number of tokens `spender` is approved to spend on behalf of `account` * @param account The address of the account holding the funds * @param spender The address of the account spending the funds * @return The number of tokens approved */ function allowance(address account, address spender) external view returns (uint) { return allowances[account][spender]; } /** * @notice Approve `spender` to transfer up to `amount` from `src` * @dev This will overwrite the approval amount for `spender` * and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve) * @param spender The address of the account which may transfer tokens * @param rawAmount The number of tokens that are approved (2^256-1 means infinite) * @return Whether or not the approval succeeded */ function approve(address spender, uint rawAmount) external returns (bool) { uint96 amount; if (rawAmount == uint(-1)) { amount = uint96(-1); } else { amount = safe96(rawAmount, "Comp::approve: amount exceeds 96 bits"); } allowances[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } /** * @notice Get the number of tokens held by the `account` * @param account The address of the account to get the balance of * @return The number of tokens held */ function balanceOf(address account) external view returns (uint) { return balances[account]; } /** * @notice Transfer `amount` tokens from `msg.sender` to `dst` * @param dst The address of the destination account * @param rawAmount The number of tokens to transfer * @return Whether or not the transfer succeeded */ function transfer(address dst, uint rawAmount) external returns (bool) { uint96 amount = safe96(rawAmount, "Comp::transfer: amount exceeds 96 bits"); _transferTokens(msg.sender, dst, amount); return true; } /** * @notice Transfer `amount` tokens from `src` to `dst` * @param src The address of the source account * @param dst The address of the destination account * @param rawAmount The number of tokens to transfer * @return Whether or not the transfer succeeded */ function transferFrom(address src, address dst, uint rawAmount) external returns (bool) { address spender = msg.sender; uint96 spenderAllowance = allowances[src][spender]; uint96 amount = safe96(rawAmount, "Comp::approve: amount exceeds 96 bits"); if (spender != src && spenderAllowance != uint96(-1)) { uint96 newAllowance = sub96(spenderAllowance, amount, "Comp::transferFrom: transfer amount exceeds spender allowance"); allowances[src][spender] = newAllowance; emit Approval(src, spender, newAllowance); } _transferTokens(src, dst, amount); return true; } /** * @notice Delegate votes from `msg.sender` to `delegatee` * @param delegatee The address to delegate votes to */ function delegate(address delegatee) public { return _delegate(msg.sender, delegatee); } /** * @notice Delegates votes from signatory to `delegatee` * @param delegatee The address to delegate votes to * @param nonce The contract state required to match the signature * @param expiry The time at which to expire the signature * @param v The recovery byte of the signature * @param r Half of the ECDSA signature pair * @param s Half of the ECDSA signature pair */ function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public { bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this))); bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry)); bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); address signatory = ecrecover(digest, v, r, s); require(signatory != address(0), "Comp::delegateBySig: invalid signature"); require(nonce == nonces[signatory]++, "Comp::delegateBySig: invalid nonce"); require(now <= expiry, "Comp::delegateBySig: signature expired"); return _delegate(signatory, delegatee); } /** * @notice Gets the current votes balance for `account` * @param account The address to get votes balance * @return The number of current votes for `account` */ function getCurrentVotes(address account) external view returns (uint96) { uint32 nCheckpoints = numCheckpoints[account]; return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0; } /** * @notice Determine the prior number of votes for an account as of a block number * @dev Block number must be a finalized block or else this function will revert to prevent misinformation. * @param account The address of the account to check * @param blockNumber The block number to get the vote balance at * @return The number of votes the account had as of the given block */ function getPriorVotes(address account, uint blockNumber) public view returns (uint96) { require(blockNumber < block.number, "Comp::getPriorVotes: not yet determined"); uint32 nCheckpoints = numCheckpoints[account]; if (nCheckpoints == 0) { return 0; } // First check most recent balance if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) { return checkpoints[account][nCheckpoints - 1].votes; } // Next check implicit zero balance if (checkpoints[account][0].fromBlock > blockNumber) { return 0; } uint32 lower = 0; uint32 upper = nCheckpoints - 1; while (upper > lower) { uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow Checkpoint memory cp = checkpoints[account][center]; if (cp.fromBlock == blockNumber) { return cp.votes; } else if (cp.fromBlock < blockNumber) { lower = center; } else { upper = center - 1; } } return checkpoints[account][lower].votes; } function _delegate(address delegator, address delegatee) internal { address currentDelegate = delegates[delegator]; uint96 delegatorBalance = balances[delegator]; delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveDelegates(currentDelegate, delegatee, delegatorBalance); } function _transferTokens(address src, address dst, uint96 amount) internal { require(src != address(0), "Comp::_transferTokens: cannot transfer from the zero address"); require(dst != address(0), "Comp::_transferTokens: cannot transfer to the zero address"); balances[src] = sub96(balances[src], amount, "Comp::_transferTokens: transfer amount exceeds balance"); balances[dst] = add96(balances[dst], amount, "Comp::_transferTokens: transfer amount overflows"); emit Transfer(src, dst, amount); _moveDelegates(delegates[src], delegates[dst], amount); } function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal { if (srcRep != dstRep && amount > 0) { if (srcRep != address(0)) { uint32 srcRepNum = numCheckpoints[srcRep]; uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0; uint96 srcRepNew = sub96(srcRepOld, amount, "Comp::_moveVotes: vote amount underflows"); _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew); } if (dstRep != address(0)) { uint32 dstRepNum = numCheckpoints[dstRep]; uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0; uint96 dstRepNew = add96(dstRepOld, amount, "Comp::_moveVotes: vote amount overflows"); _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew); } } } function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal { uint32 blockNumber = safe32(block.number, "Comp::_writeCheckpoint: block number exceeds 32 bits"); if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) { checkpoints[delegatee][nCheckpoints - 1].votes = newVotes; } else { checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes); numCheckpoints[delegatee] = nCheckpoints + 1; } emit DelegateVotesChanged(delegatee, oldVotes, newVotes); } function safe32(uint n, string memory errorMessage) internal pure returns (uint32) { require(n < 2**32, errorMessage); return uint32(n); } function safe96(uint n, string memory errorMessage) internal pure returns (uint96) { require(n < 2**96, errorMessage); return uint96(n); } function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) { uint96 c = a + b; require(c >= a, errorMessage); return c; } function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) { require(b <= a, errorMessage); return a - b; } function getChainId() internal pure returns (uint) { uint256 chainId; assembly { chainId := chainid() } return chainId; } }
pragma solidity ^0.5.16; contract ComptrollerInterface { /// @notice Indicator that this is a Comptroller contract (for inspection) bool public constant isComptroller = true; /*** Assets You Are In ***/ function enterMarkets(address[] calldata cTokens) external returns (uint[] memory); function exitMarket(address cToken) external returns (uint); /*** Policy Hooks ***/ function mintAllowed(address cToken, address minter, uint mintAmount) external returns (uint); function mintVerify(address cToken, address minter, uint mintAmount, uint mintTokens) external; function redeemAllowed(address cToken, address redeemer, uint redeemTokens) external returns (uint); function redeemVerify(address cToken, address redeemer, uint redeemAmount, uint redeemTokens) external; function borrowAllowed(address cToken, address borrower, uint borrowAmount) external returns (uint); function borrowVerify(address cToken, address borrower, uint borrowAmount) external; function repayBorrowAllowed( address cToken, address payer, address borrower, uint repayAmount) external returns (uint); function repayBorrowVerify( address cToken, address payer, address borrower, uint repayAmount, uint borrowerIndex) external; function liquidateBorrowAllowed( address cTokenBorrowed, address cTokenCollateral, address liquidator, address borrower, uint repayAmount) external returns (uint); function liquidateBorrowVerify( address cTokenBorrowed, address cTokenCollateral, address liquidator, address borrower, uint repayAmount, uint seizeTokens) external; function seizeAllowed( address cTokenCollateral, address cTokenBorrowed, address liquidator, address borrower, uint seizeTokens) external returns (uint); function seizeVerify( address cTokenCollateral, address cTokenBorrowed, address liquidator, address borrower, uint seizeTokens) external; function transferAllowed(address cToken, address src, address dst, uint transferTokens) external returns (uint); function transferVerify(address cToken, address src, address dst, uint transferTokens) external; /*** Liquidity/Liquidation Calculations ***/ function liquidateCalculateSeizeTokens( address cTokenBorrowed, address cTokenCollateral, uint repayAmount) external view returns (uint, uint); }
pragma solidity ^0.5.16; import "./CToken.sol"; import "./PriceOracle.sol"; contract UnitrollerAdminStorage { /** * @notice Administrator for this contract */ address public admin; /** * @notice Pending administrator for this contract */ address public pendingAdmin; /** * @notice Active brains of Unitroller */ address public comptrollerImplementation; /** * @notice Pending brains of Unitroller */ address public pendingComptrollerImplementation; } contract ComptrollerV1Storage is UnitrollerAdminStorage { /** * @notice Oracle which gives the price of any given asset */ PriceOracle public oracle; /** * @notice Multiplier used to calculate the maximum repayAmount when liquidating a borrow */ uint public closeFactorMantissa; /** * @notice Multiplier representing the discount on collateral that a liquidator receives */ uint public liquidationIncentiveMantissa; /** * @notice Max number of assets a single account can participate in (borrow or use as collateral) */ uint public maxAssets; /** * @notice Per-account mapping of "assets you are in", capped by maxAssets */ mapping(address => CToken[]) public accountAssets; } contract ComptrollerV2Storage is ComptrollerV1Storage { struct Market { /// @notice Whether or not this market is listed bool isListed; /** * @notice Multiplier representing the most one can borrow against their collateral in this market. * For instance, 0.9 to allow borrowing 90% of collateral value. * Must be between 0 and 1, and stored as a mantissa. */ uint collateralFactorMantissa; /// @notice Per-market mapping of "accounts in this asset" mapping(address => bool) accountMembership; /// @notice Whether or not this market receives COMP bool isComped; } /** * @notice Official mapping of cTokens -> Market metadata * @dev Used e.g. to determine if a market is supported */ mapping(address => Market) public markets; /** * @notice The Pause Guardian can pause certain actions as a safety mechanism. * Actions which allow users to remove their own assets cannot be paused. * Liquidation / seizing / transfer can only be paused globally, not by market. */ address public pauseGuardian; bool public _mintGuardianPaused; bool public _borrowGuardianPaused; bool public transferGuardianPaused; bool public seizeGuardianPaused; mapping(address => bool) public mintGuardianPaused; mapping(address => bool) public borrowGuardianPaused; } contract ComptrollerV3Storage is ComptrollerV2Storage { struct CompMarketState { /// @notice The market's last updated compBorrowIndex or compSupplyIndex uint224 index; /// @notice The block number the index was last updated at uint32 block; } /// @notice A list of all markets CToken[] public allMarkets; /// @notice The rate at which the flywheel distributes COMP, per block uint public compRate; /// @notice The portion of compRate that each market currently receives mapping(address => uint) public compSpeeds; /// @notice The COMP market supply state for each market mapping(address => CompMarketState) public compSupplyState; /// @notice The COMP market borrow state for each market mapping(address => CompMarketState) public compBorrowState; /// @notice The COMP borrow index for each market for each supplier as of the last time they accrued COMP mapping(address => mapping(address => uint)) public compSupplierIndex; /// @notice The COMP borrow index for each market for each borrower as of the last time they accrued COMP mapping(address => mapping(address => uint)) public compBorrowerIndex; /// @notice The COMP accrued but not yet transferred to each user mapping(address => uint) public compAccrued; }
pragma solidity ^0.5.16; import "./ComptrollerInterface.sol"; import "./CTokenInterfaces.sol"; import "./ErrorReporter.sol"; import "./Exponential.sol"; import "./EIP20Interface.sol"; import "./EIP20NonStandardInterface.sol"; import "./InterestRateModel.sol"; /** * @title Compound's CToken Contract * @notice Abstract base for CTokens * @author Compound */ contract CToken is CTokenInterface, Exponential, TokenErrorReporter { /** * @notice Initialize the money market * @param comptroller_ The address of the Comptroller * @param interestRateModel_ The address of the interest rate model * @param initialExchangeRateMantissa_ The initial exchange rate, scaled by 1e18 * @param name_ EIP-20 name of this token * @param symbol_ EIP-20 symbol of this token * @param decimals_ EIP-20 decimal precision of this token */ function initialize(ComptrollerInterface comptroller_, InterestRateModel interestRateModel_, uint initialExchangeRateMantissa_, string memory name_, string memory symbol_, uint8 decimals_) public { require(msg.sender == admin, "only admin may initialize the market"); require(accrualBlockNumber == 0 && borrowIndex == 0, "market may only be initialized once"); // Set initial exchange rate initialExchangeRateMantissa = initialExchangeRateMantissa_; require(initialExchangeRateMantissa > 0, "initial exchange rate must be greater than zero."); // Set the comptroller uint err = _setComptroller(comptroller_); require(err == uint(Error.NO_ERROR), "setting comptroller failed"); // Initialize block number and borrow index (block number mocks depend on comptroller being set) accrualBlockNumber = getBlockNumber(); borrowIndex = mantissaOne; // Set the interest rate model (depends on block number / borrow index) err = _setInterestRateModelFresh(interestRateModel_); require(err == uint(Error.NO_ERROR), "setting interest rate model failed"); name = name_; symbol = symbol_; decimals = decimals_; // The counter starts true to prevent changing it from zero to non-zero (i.e. smaller cost/refund) _notEntered = true; } /** * @notice Transfer `tokens` tokens from `src` to `dst` by `spender` * @dev Called by both `transfer` and `transferFrom` internally * @param spender The address of the account performing the transfer * @param src The address of the source account * @param dst The address of the destination account * @param tokens The number of tokens to transfer * @return Whether or not the transfer succeeded */ function transferTokens(address spender, address src, address dst, uint tokens) internal returns (uint) { /* Fail if transfer not allowed */ uint allowed = comptroller.transferAllowed(address(this), src, dst, tokens); if (allowed != 0) { return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.TRANSFER_COMPTROLLER_REJECTION, allowed); } /* Do not allow self-transfers */ if (src == dst) { return fail(Error.BAD_INPUT, FailureInfo.TRANSFER_NOT_ALLOWED); } /* Get the allowance, infinite for the account owner */ uint startingAllowance = 0; if (spender == src) { startingAllowance = uint(-1); } else { startingAllowance = transferAllowances[src][spender]; } /* Do the calculations, checking for {under,over}flow */ MathError mathErr; uint allowanceNew; uint srcTokensNew; uint dstTokensNew; (mathErr, allowanceNew) = subUInt(startingAllowance, tokens); if (mathErr != MathError.NO_ERROR) { return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ALLOWED); } (mathErr, srcTokensNew) = subUInt(accountTokens[src], tokens); if (mathErr != MathError.NO_ERROR) { return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ENOUGH); } (mathErr, dstTokensNew) = addUInt(accountTokens[dst], tokens); if (mathErr != MathError.NO_ERROR) { return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_TOO_MUCH); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) accountTokens[src] = srcTokensNew; accountTokens[dst] = dstTokensNew; /* Eat some of the allowance (if necessary) */ if (startingAllowance != uint(-1)) { transferAllowances[src][spender] = allowanceNew; } /* We emit a Transfer event */ emit Transfer(src, dst, tokens); comptroller.transferVerify(address(this), src, dst, tokens); return uint(Error.NO_ERROR); } /** * @notice Transfer `amount` tokens from `msg.sender` to `dst` * @param dst The address of the destination account * @param amount The number of tokens to transfer * @return Whether or not the transfer succeeded */ function transfer(address dst, uint256 amount) external nonReentrant returns (bool) { return transferTokens(msg.sender, msg.sender, dst, amount) == uint(Error.NO_ERROR); } /** * @notice Transfer `amount` tokens from `src` to `dst` * @param src The address of the source account * @param dst The address of the destination account * @param amount The number of tokens to transfer * @return Whether or not the transfer succeeded */ function transferFrom(address src, address dst, uint256 amount) external nonReentrant returns (bool) { return transferTokens(msg.sender, src, dst, amount) == uint(Error.NO_ERROR); } /** * @notice Approve `spender` to transfer up to `amount` from `src` * @dev This will overwrite the approval amount for `spender` * and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve) * @param spender The address of the account which may transfer tokens * @param amount The number of tokens that are approved (-1 means infinite) * @return Whether or not the approval succeeded */ function approve(address spender, uint256 amount) external returns (bool) { address src = msg.sender; transferAllowances[src][spender] = amount; emit Approval(src, spender, amount); return true; } /** * @notice Get the current allowance from `owner` for `spender` * @param owner The address of the account which owns the tokens to be spent * @param spender The address of the account which may transfer tokens * @return The number of tokens allowed to be spent (-1 means infinite) */ function allowance(address owner, address spender) external view returns (uint256) { return transferAllowances[owner][spender]; } /** * @notice Get the token balance of the `owner` * @param owner The address of the account to query * @return The number of tokens owned by `owner` */ function balanceOf(address owner) external view returns (uint256) { return accountTokens[owner]; } /** * @notice Get the underlying balance of the `owner` * @dev This also accrues interest in a transaction * @param owner The address of the account to query * @return The amount of underlying owned by `owner` */ function balanceOfUnderlying(address owner) external returns (uint) { Exp memory exchangeRate = Exp({mantissa: exchangeRateCurrent()}); (MathError mErr, uint balance) = mulScalarTruncate(exchangeRate, accountTokens[owner]); require(mErr == MathError.NO_ERROR, "balance could not be calculated"); return balance; } /** * @notice Get a snapshot of the account's balances, and the cached exchange rate * @dev This is used by comptroller to more efficiently perform liquidity checks. * @param account Address of the account to snapshot * @return (possible error, token balance, borrow balance, exchange rate mantissa) */ function getAccountSnapshot(address account) external view returns (uint, uint, uint, uint) { uint cTokenBalance = accountTokens[account]; uint borrowBalance; uint exchangeRateMantissa; MathError mErr; (mErr, borrowBalance) = borrowBalanceStoredInternal(account); if (mErr != MathError.NO_ERROR) { return (uint(Error.MATH_ERROR), 0, 0, 0); } (mErr, exchangeRateMantissa) = exchangeRateStoredInternal(); if (mErr != MathError.NO_ERROR) { return (uint(Error.MATH_ERROR), 0, 0, 0); } return (uint(Error.NO_ERROR), cTokenBalance, borrowBalance, exchangeRateMantissa); } /** * @dev Function to simply retrieve block number * This exists mainly for inheriting test contracts to stub this result. */ function getBlockNumber() internal view returns (uint) { return block.number; } /** * @notice Returns the current per-block borrow interest rate for this cToken * @return The borrow interest rate per block, scaled by 1e18 */ function borrowRatePerBlock() external view returns (uint) { return interestRateModel.getBorrowRate(getCashPrior(), totalBorrows, totalReserves); } /** * @notice Returns the current per-block supply interest rate for this cToken * @return The supply interest rate per block, scaled by 1e18 */ function supplyRatePerBlock() external view returns (uint) { return interestRateModel.getSupplyRate(getCashPrior(), totalBorrows, totalReserves, reserveFactorMantissa); } /** * @notice Returns the current total borrows plus accrued interest * @return The total borrows with interest */ function totalBorrowsCurrent() external nonReentrant returns (uint) { require(accrueInterest() == uint(Error.NO_ERROR), "accrue interest failed"); return totalBorrows; } /** * @notice Accrue interest to updated borrowIndex and then calculate account's borrow balance using the updated borrowIndex * @param account The address whose balance should be calculated after updating borrowIndex * @return The calculated balance */ function borrowBalanceCurrent(address account) external nonReentrant returns (uint) { require(accrueInterest() == uint(Error.NO_ERROR), "accrue interest failed"); return borrowBalanceStored(account); } /** * @notice Return the borrow balance of account based on stored data * @param account The address whose balance should be calculated * @return The calculated balance */ function borrowBalanceStored(address account) public view returns (uint) { (MathError err, uint result) = borrowBalanceStoredInternal(account); require(err == MathError.NO_ERROR, "borrowBalanceStored: borrowBalanceStoredInternal failed"); return result; } /** * @notice Return the borrow balance of account based on stored data * @param account The address whose balance should be calculated * @return (error code, the calculated balance or 0 if error code is non-zero) */ function borrowBalanceStoredInternal(address account) internal view returns (MathError, uint) { /* Note: we do not assert that the market is up to date */ MathError mathErr; uint principalTimesIndex; uint result; /* Get borrowBalance and borrowIndex */ BorrowSnapshot storage borrowSnapshot = accountBorrows[account]; /* If borrowBalance = 0 then borrowIndex is likely also 0. * Rather than failing the calculation with a division by 0, we immediately return 0 in this case. */ if (borrowSnapshot.principal == 0) { return (MathError.NO_ERROR, 0); } /* Calculate new borrow balance using the interest index: * recentBorrowBalance = borrower.borrowBalance * market.borrowIndex / borrower.borrowIndex */ (mathErr, principalTimesIndex) = mulUInt(borrowSnapshot.principal, borrowIndex); if (mathErr != MathError.NO_ERROR) { return (mathErr, 0); } (mathErr, result) = divUInt(principalTimesIndex, borrowSnapshot.interestIndex); if (mathErr != MathError.NO_ERROR) { return (mathErr, 0); } return (MathError.NO_ERROR, result); } /** * @notice Accrue interest then return the up-to-date exchange rate * @return Calculated exchange rate scaled by 1e18 */ function exchangeRateCurrent() public nonReentrant returns (uint) { require(accrueInterest() == uint(Error.NO_ERROR), "accrue interest failed"); return exchangeRateStored(); } /** * @notice Calculates the exchange rate from the underlying to the CToken * @dev This function does not accrue interest before calculating the exchange rate * @return Calculated exchange rate scaled by 1e18 */ function exchangeRateStored() public view returns (uint) { (MathError err, uint result) = exchangeRateStoredInternal(); require(err == MathError.NO_ERROR, "exchangeRateStored: exchangeRateStoredInternal failed"); return result; } /** * @notice Calculates the exchange rate from the underlying to the CToken * @dev This function does not accrue interest before calculating the exchange rate * @return (error code, calculated exchange rate scaled by 1e18) */ function exchangeRateStoredInternal() internal view returns (MathError, uint) { uint _totalSupply = totalSupply; if (_totalSupply == 0) { /* * If there are no tokens minted: * exchangeRate = initialExchangeRate */ return (MathError.NO_ERROR, initialExchangeRateMantissa); } else { /* * Otherwise: * exchangeRate = (totalCash + totalBorrows - totalReserves) / totalSupply */ uint totalCash = getCashPrior(); uint cashPlusBorrowsMinusReserves; Exp memory exchangeRate; MathError mathErr; (mathErr, cashPlusBorrowsMinusReserves) = addThenSubUInt(totalCash, totalBorrows, totalReserves); if (mathErr != MathError.NO_ERROR) { return (mathErr, 0); } (mathErr, exchangeRate) = getExp(cashPlusBorrowsMinusReserves, _totalSupply); if (mathErr != MathError.NO_ERROR) { return (mathErr, 0); } return (MathError.NO_ERROR, exchangeRate.mantissa); } } /** * @notice Get cash balance of this cToken in the underlying asset * @return The quantity of underlying asset owned by this contract */ function getCash() external view returns (uint) { return getCashPrior(); } /** * @notice Applies accrued interest to total borrows and reserves * @dev This calculates interest accrued from the last checkpointed block * up to the current block and writes new checkpoint to storage. */ function accrueInterest() public returns (uint) { /* Remember the initial block number */ uint currentBlockNumber = getBlockNumber(); uint accrualBlockNumberPrior = accrualBlockNumber; /* Short-circuit accumulating 0 interest */ if (accrualBlockNumberPrior == currentBlockNumber) { return uint(Error.NO_ERROR); } /* Read the previous values out of storage */ uint cashPrior = getCashPrior(); uint borrowsPrior = totalBorrows; uint reservesPrior = totalReserves; uint borrowIndexPrior = borrowIndex; /* Calculate the current borrow interest rate */ uint borrowRateMantissa = interestRateModel.getBorrowRate(cashPrior, borrowsPrior, reservesPrior); require(borrowRateMantissa <= borrowRateMaxMantissa, "borrow rate is absurdly high"); /* Calculate the number of blocks elapsed since the last accrual */ (MathError mathErr, uint blockDelta) = subUInt(currentBlockNumber, accrualBlockNumberPrior); require(mathErr == MathError.NO_ERROR, "could not calculate block delta"); /* * Calculate the interest accumulated into borrows and reserves and the new index: * simpleInterestFactor = borrowRate * blockDelta * interestAccumulated = simpleInterestFactor * totalBorrows * totalBorrowsNew = interestAccumulated + totalBorrows * totalReservesNew = interestAccumulated * reserveFactor + totalReserves * borrowIndexNew = simpleInterestFactor * borrowIndex + borrowIndex */ Exp memory simpleInterestFactor; uint interestAccumulated; uint totalBorrowsNew; uint totalReservesNew; uint borrowIndexNew; (mathErr, simpleInterestFactor) = mulScalar(Exp({mantissa: borrowRateMantissa}), blockDelta); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_SIMPLE_INTEREST_FACTOR_CALCULATION_FAILED, uint(mathErr)); } (mathErr, interestAccumulated) = mulScalarTruncate(simpleInterestFactor, borrowsPrior); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_ACCUMULATED_INTEREST_CALCULATION_FAILED, uint(mathErr)); } (mathErr, totalBorrowsNew) = addUInt(interestAccumulated, borrowsPrior); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_BORROWS_CALCULATION_FAILED, uint(mathErr)); } (mathErr, totalReservesNew) = mulScalarTruncateAddUInt(Exp({mantissa: reserveFactorMantissa}), interestAccumulated, reservesPrior); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_RESERVES_CALCULATION_FAILED, uint(mathErr)); } (mathErr, borrowIndexNew) = mulScalarTruncateAddUInt(simpleInterestFactor, borrowIndexPrior, borrowIndexPrior); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_BORROW_INDEX_CALCULATION_FAILED, uint(mathErr)); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* We write the previously calculated values into storage */ accrualBlockNumber = currentBlockNumber; borrowIndex = borrowIndexNew; totalBorrows = totalBorrowsNew; totalReserves = totalReservesNew; /* We emit an AccrueInterest event */ emit AccrueInterest(cashPrior, interestAccumulated, borrowIndexNew, totalBorrowsNew); return uint(Error.NO_ERROR); } /** * @notice Sender supplies assets into the market and receives cTokens in exchange * @dev Accrues interest whether or not the operation succeeds, unless reverted * @param mintAmount The amount of the underlying asset to supply * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual mint amount. */ function mintInternal(uint mintAmount) internal nonReentrant returns (uint, uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed return (fail(Error(error), FailureInfo.MINT_ACCRUE_INTEREST_FAILED), 0); } // mintFresh emits the actual Mint event if successful and logs on errors, so we don't need to return mintFresh(msg.sender, mintAmount); } struct MintLocalVars { Error err; MathError mathErr; uint exchangeRateMantissa; uint mintTokens; uint totalSupplyNew; uint accountTokensNew; uint actualMintAmount; } /** * @notice User supplies assets into the market and receives cTokens in exchange * @dev Assumes interest has already been accrued up to the current block * @param minter The address of the account which is supplying the assets * @param mintAmount The amount of the underlying asset to supply * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual mint amount. */ function mintFresh(address minter, uint mintAmount) internal returns (uint, uint) { /* Fail if mint not allowed */ uint allowed = comptroller.mintAllowed(address(this), minter, mintAmount); if (allowed != 0) { return (failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.MINT_COMPTROLLER_REJECTION, allowed), 0); } /* Verify market's block number equals current block number */ if (accrualBlockNumber != getBlockNumber()) { return (fail(Error.MARKET_NOT_FRESH, FailureInfo.MINT_FRESHNESS_CHECK), 0); } MintLocalVars memory vars; (vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal(); if (vars.mathErr != MathError.NO_ERROR) { return (failOpaque(Error.MATH_ERROR, FailureInfo.MINT_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr)), 0); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* * We call `doTransferIn` for the minter and the mintAmount. * Note: The cToken must handle variations between ERC-20 and ETH underlying. * `doTransferIn` reverts if anything goes wrong, since we can't be sure if * side-effects occurred. The function returns the amount actually transferred, * in case of a fee. On success, the cToken holds an additional `actualMintAmount` * of cash. */ vars.actualMintAmount = doTransferIn(minter, mintAmount); /* * We get the current exchange rate and calculate the number of cTokens to be minted: * mintTokens = actualMintAmount / exchangeRate */ (vars.mathErr, vars.mintTokens) = divScalarByExpTruncate(vars.actualMintAmount, Exp({mantissa: vars.exchangeRateMantissa})); require(vars.mathErr == MathError.NO_ERROR, "MINT_EXCHANGE_CALCULATION_FAILED"); /* * We calculate the new total supply of cTokens and minter token balance, checking for overflow: * totalSupplyNew = totalSupply + mintTokens * accountTokensNew = accountTokens[minter] + mintTokens */ (vars.mathErr, vars.totalSupplyNew) = addUInt(totalSupply, vars.mintTokens); require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_TOTAL_SUPPLY_CALCULATION_FAILED"); (vars.mathErr, vars.accountTokensNew) = addUInt(accountTokens[minter], vars.mintTokens); require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED"); /* We write previously calculated values into storage */ totalSupply = vars.totalSupplyNew; accountTokens[minter] = vars.accountTokensNew; /* We emit a Mint event, and a Transfer event */ emit Mint(minter, vars.actualMintAmount, vars.mintTokens); emit Transfer(address(this), minter, vars.mintTokens); /* We call the defense hook */ comptroller.mintVerify(address(this), minter, vars.actualMintAmount, vars.mintTokens); return (uint(Error.NO_ERROR), vars.actualMintAmount); } /** * @notice Sender redeems cTokens in exchange for the underlying asset * @dev Accrues interest whether or not the operation succeeds, unless reverted * @param redeemTokens The number of cTokens to redeem into underlying * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function redeemInternal(uint redeemTokens) internal nonReentrant returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted redeem failed return fail(Error(error), FailureInfo.REDEEM_ACCRUE_INTEREST_FAILED); } // redeemFresh emits redeem-specific logs on errors, so we don't need to return redeemFresh(msg.sender, redeemTokens, 0); } /** * @notice Sender redeems cTokens in exchange for a specified amount of underlying asset * @dev Accrues interest whether or not the operation succeeds, unless reverted * @param redeemAmount The amount of underlying to receive from redeeming cTokens * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function redeemUnderlyingInternal(uint redeemAmount) internal nonReentrant returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted redeem failed return fail(Error(error), FailureInfo.REDEEM_ACCRUE_INTEREST_FAILED); } // redeemFresh emits redeem-specific logs on errors, so we don't need to return redeemFresh(msg.sender, 0, redeemAmount); } struct RedeemLocalVars { Error err; MathError mathErr; uint exchangeRateMantissa; uint redeemTokens; uint redeemAmount; uint totalSupplyNew; uint accountTokensNew; } /** * @notice User redeems cTokens in exchange for the underlying asset * @dev Assumes interest has already been accrued up to the current block * @param redeemer The address of the account which is redeeming the tokens * @param redeemTokensIn The number of cTokens to redeem into underlying (only one of redeemTokensIn or redeemAmountIn may be non-zero) * @param redeemAmountIn The number of underlying tokens to receive from redeeming cTokens (only one of redeemTokensIn or redeemAmountIn may be non-zero) * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal returns (uint) { require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero"); RedeemLocalVars memory vars; /* exchangeRate = invoke Exchange Rate Stored() */ (vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal(); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr)); } /* If redeemTokensIn > 0: */ if (redeemTokensIn > 0) { /* * We calculate the exchange rate and the amount of underlying to be redeemed: * redeemTokens = redeemTokensIn * redeemAmount = redeemTokensIn x exchangeRateCurrent */ vars.redeemTokens = redeemTokensIn; (vars.mathErr, vars.redeemAmount) = mulScalarTruncate(Exp({mantissa: vars.exchangeRateMantissa}), redeemTokensIn); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, uint(vars.mathErr)); } } else { /* * We get the current exchange rate and calculate the amount to be redeemed: * redeemTokens = redeemAmountIn / exchangeRate * redeemAmount = redeemAmountIn */ (vars.mathErr, vars.redeemTokens) = divScalarByExpTruncate(redeemAmountIn, Exp({mantissa: vars.exchangeRateMantissa})); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, uint(vars.mathErr)); } vars.redeemAmount = redeemAmountIn; } /* Fail if redeem not allowed */ uint allowed = comptroller.redeemAllowed(address(this), redeemer, vars.redeemTokens); if (allowed != 0) { return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.REDEEM_COMPTROLLER_REJECTION, allowed); } /* Verify market's block number equals current block number */ if (accrualBlockNumber != getBlockNumber()) { return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDEEM_FRESHNESS_CHECK); } /* * We calculate the new total supply and redeemer balance, checking for underflow: * totalSupplyNew = totalSupply - redeemTokens * accountTokensNew = accountTokens[redeemer] - redeemTokens */ (vars.mathErr, vars.totalSupplyNew) = subUInt(totalSupply, vars.redeemTokens); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, uint(vars.mathErr)); } (vars.mathErr, vars.accountTokensNew) = subUInt(accountTokens[redeemer], vars.redeemTokens); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)); } /* Fail gracefully if protocol has insufficient cash */ if (getCashPrior() < vars.redeemAmount) { return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDEEM_TRANSFER_OUT_NOT_POSSIBLE); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* * We invoke doTransferOut for the redeemer and the redeemAmount. * Note: The cToken must handle variations between ERC-20 and ETH underlying. * On success, the cToken has redeemAmount less of cash. * doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred. */ doTransferOut(redeemer, vars.redeemAmount); /* We write previously calculated values into storage */ totalSupply = vars.totalSupplyNew; accountTokens[redeemer] = vars.accountTokensNew; /* We emit a Transfer event, and a Redeem event */ emit Transfer(redeemer, address(this), vars.redeemTokens); emit Redeem(redeemer, vars.redeemAmount, vars.redeemTokens); /* We call the defense hook */ comptroller.redeemVerify(address(this), redeemer, vars.redeemAmount, vars.redeemTokens); return uint(Error.NO_ERROR); } /** * @notice Sender borrows assets from the protocol to their own address * @param borrowAmount The amount of the underlying asset to borrow * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function borrowInternal(uint borrowAmount) internal nonReentrant returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed return fail(Error(error), FailureInfo.BORROW_ACCRUE_INTEREST_FAILED); } // borrowFresh emits borrow-specific logs on errors, so we don't need to return borrowFresh(msg.sender, borrowAmount); } struct BorrowLocalVars { MathError mathErr; uint accountBorrows; uint accountBorrowsNew; uint totalBorrowsNew; } /** * @notice Users borrow assets from the protocol to their own address * @param borrowAmount The amount of the underlying asset to borrow * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function borrowFresh(address payable borrower, uint borrowAmount) internal returns (uint) { /* Fail if borrow not allowed */ uint allowed = comptroller.borrowAllowed(address(this), borrower, borrowAmount); if (allowed != 0) { return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.BORROW_COMPTROLLER_REJECTION, allowed); } /* Verify market's block number equals current block number */ if (accrualBlockNumber != getBlockNumber()) { return fail(Error.MARKET_NOT_FRESH, FailureInfo.BORROW_FRESHNESS_CHECK); } /* Fail gracefully if protocol has insufficient underlying cash */ if (getCashPrior() < borrowAmount) { return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.BORROW_CASH_NOT_AVAILABLE); } BorrowLocalVars memory vars; /* * We calculate the new borrower and total borrow balances, failing on overflow: * accountBorrowsNew = accountBorrows + borrowAmount * totalBorrowsNew = totalBorrows + borrowAmount */ (vars.mathErr, vars.accountBorrows) = borrowBalanceStoredInternal(borrower); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)); } (vars.mathErr, vars.accountBorrowsNew) = addUInt(vars.accountBorrows, borrowAmount); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)); } (vars.mathErr, vars.totalBorrowsNew) = addUInt(totalBorrows, borrowAmount); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* * We invoke doTransferOut for the borrower and the borrowAmount. * Note: The cToken must handle variations between ERC-20 and ETH underlying. * On success, the cToken borrowAmount less of cash. * doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred. */ doTransferOut(borrower, borrowAmount); /* We write the previously calculated values into storage */ accountBorrows[borrower].principal = vars.accountBorrowsNew; accountBorrows[borrower].interestIndex = borrowIndex; totalBorrows = vars.totalBorrowsNew; /* We emit a Borrow event */ emit Borrow(borrower, borrowAmount, vars.accountBorrowsNew, vars.totalBorrowsNew); /* We call the defense hook */ comptroller.borrowVerify(address(this), borrower, borrowAmount); return uint(Error.NO_ERROR); } /** * @notice Sender repays their own borrow * @param repayAmount The amount to repay * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount. */ function repayBorrowInternal(uint repayAmount) internal nonReentrant returns (uint, uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed return (fail(Error(error), FailureInfo.REPAY_BORROW_ACCRUE_INTEREST_FAILED), 0); } // repayBorrowFresh emits repay-borrow-specific logs on errors, so we don't need to return repayBorrowFresh(msg.sender, msg.sender, repayAmount); } /** * @notice Sender repays a borrow belonging to borrower * @param borrower the account with the debt being payed off * @param repayAmount The amount to repay * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount. */ function repayBorrowBehalfInternal(address borrower, uint repayAmount) internal nonReentrant returns (uint, uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed return (fail(Error(error), FailureInfo.REPAY_BEHALF_ACCRUE_INTEREST_FAILED), 0); } // repayBorrowFresh emits repay-borrow-specific logs on errors, so we don't need to return repayBorrowFresh(msg.sender, borrower, repayAmount); } struct RepayBorrowLocalVars { Error err; MathError mathErr; uint repayAmount; uint borrowerIndex; uint accountBorrows; uint accountBorrowsNew; uint totalBorrowsNew; uint actualRepayAmount; } /** * @notice Borrows are repaid by another user (possibly the borrower). * @param payer the account paying off the borrow * @param borrower the account with the debt being payed off * @param repayAmount the amount of undelrying tokens being returned * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount. */ function repayBorrowFresh(address payer, address borrower, uint repayAmount) internal returns (uint, uint) { /* Fail if repayBorrow not allowed */ uint allowed = comptroller.repayBorrowAllowed(address(this), payer, borrower, repayAmount); if (allowed != 0) { return (failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.REPAY_BORROW_COMPTROLLER_REJECTION, allowed), 0); } /* Verify market's block number equals current block number */ if (accrualBlockNumber != getBlockNumber()) { return (fail(Error.MARKET_NOT_FRESH, FailureInfo.REPAY_BORROW_FRESHNESS_CHECK), 0); } RepayBorrowLocalVars memory vars; /* We remember the original borrowerIndex for verification purposes */ vars.borrowerIndex = accountBorrows[borrower].interestIndex; /* We fetch the amount the borrower owes, with accumulated interest */ (vars.mathErr, vars.accountBorrows) = borrowBalanceStoredInternal(borrower); if (vars.mathErr != MathError.NO_ERROR) { return (failOpaque(Error.MATH_ERROR, FailureInfo.REPAY_BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)), 0); } /* If repayAmount == -1, repayAmount = accountBorrows */ if (repayAmount == uint(-1)) { vars.repayAmount = vars.accountBorrows; } else { vars.repayAmount = repayAmount; } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* * We call doTransferIn for the payer and the repayAmount * Note: The cToken must handle variations between ERC-20 and ETH underlying. * On success, the cToken holds an additional repayAmount of cash. * doTransferIn reverts if anything goes wrong, since we can't be sure if side effects occurred. * it returns the amount actually transferred, in case of a fee. */ vars.actualRepayAmount = doTransferIn(payer, vars.repayAmount); /* * We calculate the new borrower and total borrow balances, failing on underflow: * accountBorrowsNew = accountBorrows - actualRepayAmount * totalBorrowsNew = totalBorrows - actualRepayAmount */ (vars.mathErr, vars.accountBorrowsNew) = subUInt(vars.accountBorrows, vars.actualRepayAmount); require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED"); (vars.mathErr, vars.totalBorrowsNew) = subUInt(totalBorrows, vars.actualRepayAmount); require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED"); /* We write the previously calculated values into storage */ accountBorrows[borrower].principal = vars.accountBorrowsNew; accountBorrows[borrower].interestIndex = borrowIndex; totalBorrows = vars.totalBorrowsNew; /* We emit a RepayBorrow event */ emit RepayBorrow(payer, borrower, vars.actualRepayAmount, vars.accountBorrowsNew, vars.totalBorrowsNew); /* We call the defense hook */ comptroller.repayBorrowVerify(address(this), payer, borrower, vars.actualRepayAmount, vars.borrowerIndex); return (uint(Error.NO_ERROR), vars.actualRepayAmount); } /** * @notice The sender liquidates the borrowers collateral. * The collateral seized is transferred to the liquidator. * @param borrower The borrower of this cToken to be liquidated * @param cTokenCollateral The market in which to seize collateral from the borrower * @param repayAmount The amount of the underlying borrowed asset to repay * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount. */ function liquidateBorrowInternal(address borrower, uint repayAmount, CTokenInterface cTokenCollateral) internal nonReentrant returns (uint, uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted liquidation failed return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_BORROW_INTEREST_FAILED), 0); } error = cTokenCollateral.accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted liquidation failed return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_COLLATERAL_INTEREST_FAILED), 0); } // liquidateBorrowFresh emits borrow-specific logs on errors, so we don't need to return liquidateBorrowFresh(msg.sender, borrower, repayAmount, cTokenCollateral); } /** * @notice The liquidator liquidates the borrowers collateral. * The collateral seized is transferred to the liquidator. * @param borrower The borrower of this cToken to be liquidated * @param liquidator The address repaying the borrow and seizing collateral * @param cTokenCollateral The market in which to seize collateral from the borrower * @param repayAmount The amount of the underlying borrowed asset to repay * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount. */ function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, CTokenInterface cTokenCollateral) internal returns (uint, uint) { /* Fail if liquidate not allowed */ uint allowed = comptroller.liquidateBorrowAllowed(address(this), address(cTokenCollateral), liquidator, borrower, repayAmount); if (allowed != 0) { return (failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.LIQUIDATE_COMPTROLLER_REJECTION, allowed), 0); } /* Verify market's block number equals current block number */ if (accrualBlockNumber != getBlockNumber()) { return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_FRESHNESS_CHECK), 0); } /* Verify cTokenCollateral market's block number equals current block number */ if (cTokenCollateral.accrualBlockNumber() != getBlockNumber()) { return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_COLLATERAL_FRESHNESS_CHECK), 0); } /* Fail if borrower = liquidator */ if (borrower == liquidator) { return (fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_LIQUIDATOR_IS_BORROWER), 0); } /* Fail if repayAmount = 0 */ if (repayAmount == 0) { return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_ZERO), 0); } /* Fail if repayAmount = -1 */ if (repayAmount == uint(-1)) { return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX), 0); } /* Fail if repayBorrow fails */ (uint repayBorrowError, uint actualRepayAmount) = repayBorrowFresh(liquidator, borrower, repayAmount); if (repayBorrowError != uint(Error.NO_ERROR)) { return (fail(Error(repayBorrowError), FailureInfo.LIQUIDATE_REPAY_BORROW_FRESH_FAILED), 0); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* We calculate the number of collateral tokens that will be seized */ (uint amountSeizeError, uint seizeTokens) = comptroller.liquidateCalculateSeizeTokens(address(this), address(cTokenCollateral), actualRepayAmount); require(amountSeizeError == uint(Error.NO_ERROR), "LIQUIDATE_COMPTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED"); /* Revert if borrower collateral token balance < seizeTokens */ require(cTokenCollateral.balanceOf(borrower) >= seizeTokens, "LIQUIDATE_SEIZE_TOO_MUCH"); // If this is also the collateral, run seizeInternal to avoid re-entrancy, otherwise make an external call uint seizeError; if (address(cTokenCollateral) == address(this)) { seizeError = seizeInternal(address(this), liquidator, borrower, seizeTokens); } else { seizeError = cTokenCollateral.seize(liquidator, borrower, seizeTokens); } /* Revert if seize tokens fails (since we cannot be sure of side effects) */ require(seizeError == uint(Error.NO_ERROR), "token seizure failed"); /* We emit a LiquidateBorrow event */ emit LiquidateBorrow(liquidator, borrower, actualRepayAmount, address(cTokenCollateral), seizeTokens); /* We call the defense hook */ comptroller.liquidateBorrowVerify(address(this), address(cTokenCollateral), liquidator, borrower, actualRepayAmount, seizeTokens); return (uint(Error.NO_ERROR), actualRepayAmount); } /** * @notice Transfers collateral tokens (this market) to the liquidator. * @dev Will fail unless called by another cToken during the process of liquidation. * Its absolutely critical to use msg.sender as the borrowed cToken and not a parameter. * @param liquidator The account receiving seized collateral * @param borrower The account having collateral seized * @param seizeTokens The number of cTokens to seize * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function seize(address liquidator, address borrower, uint seizeTokens) external nonReentrant returns (uint) { return seizeInternal(msg.sender, liquidator, borrower, seizeTokens); } /** * @notice Transfers collateral tokens (this market) to the liquidator. * @dev Called only during an in-kind liquidation, or by liquidateBorrow during the liquidation of another CToken. * Its absolutely critical to use msg.sender as the seizer cToken and not a parameter. * @param seizerToken The contract seizing the collateral (i.e. borrowed cToken) * @param liquidator The account receiving seized collateral * @param borrower The account having collateral seized * @param seizeTokens The number of cTokens to seize * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function seizeInternal(address seizerToken, address liquidator, address borrower, uint seizeTokens) internal returns (uint) { /* Fail if seize not allowed */ uint allowed = comptroller.seizeAllowed(address(this), seizerToken, liquidator, borrower, seizeTokens); if (allowed != 0) { return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.LIQUIDATE_SEIZE_COMPTROLLER_REJECTION, allowed); } /* Fail if borrower = liquidator */ if (borrower == liquidator) { return fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER); } MathError mathErr; uint borrowerTokensNew; uint liquidatorTokensNew; /* * We calculate the new borrower and liquidator token balances, failing on underflow/overflow: * borrowerTokensNew = accountTokens[borrower] - seizeTokens * liquidatorTokensNew = accountTokens[liquidator] + seizeTokens */ (mathErr, borrowerTokensNew) = subUInt(accountTokens[borrower], seizeTokens); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_DECREMENT_FAILED, uint(mathErr)); } (mathErr, liquidatorTokensNew) = addUInt(accountTokens[liquidator], seizeTokens); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_INCREMENT_FAILED, uint(mathErr)); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* We write the previously calculated values into storage */ accountTokens[borrower] = borrowerTokensNew; accountTokens[liquidator] = liquidatorTokensNew; /* Emit a Transfer event */ emit Transfer(borrower, liquidator, seizeTokens); /* We call the defense hook */ comptroller.seizeVerify(address(this), seizerToken, liquidator, borrower, seizeTokens); return uint(Error.NO_ERROR); } /*** Admin Functions ***/ /** * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer. * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer. * @param newPendingAdmin New pending admin. * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setPendingAdmin(address payable newPendingAdmin) external returns (uint) { // Check caller = admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_ADMIN_OWNER_CHECK); } // Save current value, if any, for inclusion in log address oldPendingAdmin = pendingAdmin; // Store pendingAdmin with value newPendingAdmin pendingAdmin = newPendingAdmin; // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin) emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin); return uint(Error.NO_ERROR); } /** * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin * @dev Admin function for pending admin to accept role and update admin * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _acceptAdmin() external returns (uint) { // Check caller is pendingAdmin and pendingAdmin ≠ address(0) if (msg.sender != pendingAdmin || msg.sender == address(0)) { return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_ADMIN_PENDING_ADMIN_CHECK); } // Save current values for inclusion in log address oldAdmin = admin; address oldPendingAdmin = pendingAdmin; // Store admin with value pendingAdmin admin = pendingAdmin; // Clear the pending value pendingAdmin = address(0); emit NewAdmin(oldAdmin, admin); emit NewPendingAdmin(oldPendingAdmin, pendingAdmin); return uint(Error.NO_ERROR); } /** * @notice Sets a new comptroller for the market * @dev Admin function to set a new comptroller * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setComptroller(ComptrollerInterface newComptroller) public returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_COMPTROLLER_OWNER_CHECK); } ComptrollerInterface oldComptroller = comptroller; // Ensure invoke comptroller.isComptroller() returns true require(newComptroller.isComptroller(), "marker method returned false"); // Set market's comptroller to newComptroller comptroller = newComptroller; // Emit NewComptroller(oldComptroller, newComptroller) emit NewComptroller(oldComptroller, newComptroller); return uint(Error.NO_ERROR); } /** * @notice accrues interest and sets a new reserve factor for the protocol using _setReserveFactorFresh * @dev Admin function to accrue interest and set a new reserve factor * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setReserveFactor(uint newReserveFactorMantissa) external nonReentrant returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted reserve factor change failed. return fail(Error(error), FailureInfo.SET_RESERVE_FACTOR_ACCRUE_INTEREST_FAILED); } // _setReserveFactorFresh emits reserve-factor-specific logs on errors, so we don't need to. return _setReserveFactorFresh(newReserveFactorMantissa); } /** * @notice Sets a new reserve factor for the protocol (*requires fresh interest accrual) * @dev Admin function to set a new reserve factor * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setReserveFactorFresh(uint newReserveFactorMantissa) internal returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_RESERVE_FACTOR_ADMIN_CHECK); } // Verify market's block number equals current block number if (accrualBlockNumber != getBlockNumber()) { return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_RESERVE_FACTOR_FRESH_CHECK); } // Check newReserveFactor ≤ maxReserveFactor if (newReserveFactorMantissa > reserveFactorMaxMantissa) { return fail(Error.BAD_INPUT, FailureInfo.SET_RESERVE_FACTOR_BOUNDS_CHECK); } uint oldReserveFactorMantissa = reserveFactorMantissa; reserveFactorMantissa = newReserveFactorMantissa; emit NewReserveFactor(oldReserveFactorMantissa, newReserveFactorMantissa); return uint(Error.NO_ERROR); } /** * @notice Accrues interest and reduces reserves by transferring from msg.sender * @param addAmount Amount of addition to reserves * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _addReservesInternal(uint addAmount) internal nonReentrant returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted reduce reserves failed. return fail(Error(error), FailureInfo.ADD_RESERVES_ACCRUE_INTEREST_FAILED); } // _addReservesFresh emits reserve-addition-specific logs on errors, so we don't need to. (error, ) = _addReservesFresh(addAmount); return error; } /** * @notice Add reserves by transferring from caller * @dev Requires fresh interest accrual * @param addAmount Amount of addition to reserves * @return (uint, uint) An error code (0=success, otherwise a failure (see ErrorReporter.sol for details)) and the actual amount added, net token fees */ function _addReservesFresh(uint addAmount) internal returns (uint, uint) { // totalReserves + actualAddAmount uint totalReservesNew; uint actualAddAmount; // We fail gracefully unless market's block number equals current block number if (accrualBlockNumber != getBlockNumber()) { return (fail(Error.MARKET_NOT_FRESH, FailureInfo.ADD_RESERVES_FRESH_CHECK), actualAddAmount); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* * We call doTransferIn for the caller and the addAmount * Note: The cToken must handle variations between ERC-20 and ETH underlying. * On success, the cToken holds an additional addAmount of cash. * doTransferIn reverts if anything goes wrong, since we can't be sure if side effects occurred. * it returns the amount actually transferred, in case of a fee. */ actualAddAmount = doTransferIn(msg.sender, addAmount); totalReservesNew = totalReserves + actualAddAmount; /* Revert on overflow */ require(totalReservesNew >= totalReserves, "add reserves unexpected overflow"); // Store reserves[n+1] = reserves[n] + actualAddAmount totalReserves = totalReservesNew; /* Emit NewReserves(admin, actualAddAmount, reserves[n+1]) */ emit ReservesAdded(msg.sender, actualAddAmount, totalReservesNew); /* Return (NO_ERROR, actualAddAmount) */ return (uint(Error.NO_ERROR), actualAddAmount); } /** * @notice Accrues interest and reduces reserves by transferring to admin * @param reduceAmount Amount of reduction to reserves * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _reduceReserves(uint reduceAmount) external nonReentrant returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted reduce reserves failed. return fail(Error(error), FailureInfo.REDUCE_RESERVES_ACCRUE_INTEREST_FAILED); } // _reduceReservesFresh emits reserve-reduction-specific logs on errors, so we don't need to. return _reduceReservesFresh(reduceAmount); } /** * @notice Reduces reserves by transferring to admin * @dev Requires fresh interest accrual * @param reduceAmount Amount of reduction to reserves * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _reduceReservesFresh(uint reduceAmount) internal returns (uint) { // totalReserves - reduceAmount uint totalReservesNew; // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.REDUCE_RESERVES_ADMIN_CHECK); } // We fail gracefully unless market's block number equals current block number if (accrualBlockNumber != getBlockNumber()) { return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDUCE_RESERVES_FRESH_CHECK); } // Fail gracefully if protocol has insufficient underlying cash if (getCashPrior() < reduceAmount) { return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDUCE_RESERVES_CASH_NOT_AVAILABLE); } // Check reduceAmount ≤ reserves[n] (totalReserves) if (reduceAmount > totalReserves) { return fail(Error.BAD_INPUT, FailureInfo.REDUCE_RESERVES_VALIDATION); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) totalReservesNew = totalReserves - reduceAmount; // We checked reduceAmount <= totalReserves above, so this should never revert. require(totalReservesNew <= totalReserves, "reduce reserves unexpected underflow"); // Store reserves[n+1] = reserves[n] - reduceAmount totalReserves = totalReservesNew; // doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred. doTransferOut(admin, reduceAmount); emit ReservesReduced(admin, reduceAmount, totalReservesNew); return uint(Error.NO_ERROR); } /** * @notice accrues interest and updates the interest rate model using _setInterestRateModelFresh * @dev Admin function to accrue interest and update the interest rate model * @param newInterestRateModel the new interest rate model to use * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setInterestRateModel(InterestRateModel newInterestRateModel) public returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // 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 return fail(Error(error), FailureInfo.SET_INTEREST_RATE_MODEL_ACCRUE_INTEREST_FAILED); } // _setInterestRateModelFresh emits interest-rate-model-update-specific logs on errors, so we don't need to. return _setInterestRateModelFresh(newInterestRateModel); } /** * @notice updates the interest rate model (*requires fresh interest accrual) * @dev Admin function to update the interest rate model * @param newInterestRateModel the new interest rate model to use * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setInterestRateModelFresh(InterestRateModel newInterestRateModel) internal returns (uint) { // Used to store old model for use in the event that is emitted on success InterestRateModel oldInterestRateModel; // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_INTEREST_RATE_MODEL_OWNER_CHECK); } // We fail gracefully unless market's block number equals current block number if (accrualBlockNumber != getBlockNumber()) { return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_INTEREST_RATE_MODEL_FRESH_CHECK); } // Track the market's current interest rate model oldInterestRateModel = interestRateModel; // Ensure invoke newInterestRateModel.isInterestRateModel() returns true require(newInterestRateModel.isInterestRateModel(), "marker method returned false"); // Set the interest rate model to newInterestRateModel interestRateModel = newInterestRateModel; // Emit NewMarketInterestRateModel(oldInterestRateModel, newInterestRateModel) emit NewMarketInterestRateModel(oldInterestRateModel, newInterestRateModel); return uint(Error.NO_ERROR); } /*** Safe Token ***/ /** * @notice Gets balance of this contract in terms of the underlying * @dev This excludes the value of the current message, if any * @return The quantity of underlying owned by this contract */ function getCashPrior() internal view returns (uint); /** * @dev Performs a transfer in, reverting upon failure. Returns the amount actually transferred to the protocol, in case of a fee. * This may revert due to insufficient balance or insufficient allowance. */ function doTransferIn(address from, uint amount) internal returns (uint); /** * @dev Performs a transfer out, ideally returning an explanatory error code upon failure tather than reverting. * If caller has not called checked protocol's balance, may revert due to insufficient cash held in the contract. * If caller has checked protocol's balance, and verified it is >= amount, this should not revert in normal conditions. */ function doTransferOut(address payable to, uint amount) internal; /*** Reentrancy Guard ***/ /** * @dev Prevents a contract from calling itself, directly or indirectly. */ modifier nonReentrant() { require(_notEntered, "re-entered"); _notEntered = false; _; _notEntered = true; // get a gas-refund post-Istanbul } }
pragma solidity ^0.5.16; import "./ComptrollerInterface.sol"; import "./InterestRateModel.sol"; contract CTokenStorage { /** * @dev Guard variable for re-entrancy checks */ bool internal _notEntered; /** * @notice EIP-20 token name for this token */ string public name; /** * @notice EIP-20 token symbol for this token */ string public symbol; /** * @notice EIP-20 token decimals for this token */ uint8 public decimals; /** * @notice Maximum borrow rate that can ever be applied (.0005% / block) */ uint internal constant borrowRateMaxMantissa = 0.0005e16; /** * @notice Maximum fraction of interest that can be set aside for reserves */ uint internal constant reserveFactorMaxMantissa = 1e18; /** * @notice Administrator for this contract */ address payable public admin; /** * @notice Pending administrator for this contract */ address payable public pendingAdmin; /** * @notice Contract which oversees inter-cToken operations */ ComptrollerInterface public comptroller; /** * @notice Model which tells what the current interest rate should be */ InterestRateModel public interestRateModel; /** * @notice Initial exchange rate used when minting the first CTokens (used when totalSupply = 0) */ uint internal initialExchangeRateMantissa; /** * @notice Fraction of interest currently set aside for reserves */ uint public reserveFactorMantissa; /** * @notice Block number that interest was last accrued at */ uint public accrualBlockNumber; /** * @notice Accumulator of the total earned interest rate since the opening of the market */ uint public borrowIndex; /** * @notice Total amount of outstanding borrows of the underlying in this market */ uint public totalBorrows; /** * @notice Total amount of reserves of the underlying held in this market */ uint public totalReserves; /** * @notice Total number of tokens in circulation */ uint public totalSupply; /** * @notice Official record of token balances for each account */ mapping (address => uint) internal accountTokens; /** * @notice Approved token transfer amounts on behalf of others */ mapping (address => mapping (address => uint)) internal transferAllowances; /** * @notice Container for borrow balance information * @member principal Total balance (with accrued interest), after applying the most recent balance-changing action * @member interestIndex Global borrowIndex as of the most recent balance-changing action */ struct BorrowSnapshot { uint principal; uint interestIndex; } /** * @notice Mapping of account addresses to outstanding borrow balances */ mapping(address => BorrowSnapshot) internal accountBorrows; } contract CTokenInterface is CTokenStorage { /** * @notice Indicator that this is a CToken contract (for inspection) */ bool public constant isCToken = true; /*** Market Events ***/ /** * @notice Event emitted when interest is accrued */ event AccrueInterest(uint cashPrior, uint interestAccumulated, uint borrowIndex, uint totalBorrows); /** * @notice Event emitted when tokens are minted */ event Mint(address minter, uint mintAmount, uint mintTokens); /** * @notice Event emitted when tokens are redeemed */ event Redeem(address redeemer, uint redeemAmount, uint redeemTokens); /** * @notice Event emitted when underlying is borrowed */ event Borrow(address borrower, uint borrowAmount, uint accountBorrows, uint totalBorrows); /** * @notice Event emitted when a borrow is repaid */ event RepayBorrow(address payer, address borrower, uint repayAmount, uint accountBorrows, uint totalBorrows); /** * @notice Event emitted when a borrow is liquidated */ event LiquidateBorrow(address liquidator, address borrower, uint repayAmount, address cTokenCollateral, uint seizeTokens); /*** Admin Events ***/ /** * @notice Event emitted when pendingAdmin is changed */ event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin); /** * @notice Event emitted when pendingAdmin is accepted, which means admin is updated */ event NewAdmin(address oldAdmin, address newAdmin); /** * @notice Event emitted when comptroller is changed */ event NewComptroller(ComptrollerInterface oldComptroller, ComptrollerInterface newComptroller); /** * @notice Event emitted when interestRateModel is changed */ event NewMarketInterestRateModel(InterestRateModel oldInterestRateModel, InterestRateModel newInterestRateModel); /** * @notice Event emitted when the reserve factor is changed */ event NewReserveFactor(uint oldReserveFactorMantissa, uint newReserveFactorMantissa); /** * @notice Event emitted when the reserves are added */ event ReservesAdded(address benefactor, uint addAmount, uint newTotalReserves); /** * @notice Event emitted when the reserves are reduced */ event ReservesReduced(address admin, uint reduceAmount, uint newTotalReserves); /** * @notice EIP20 Transfer event */ event Transfer(address indexed from, address indexed to, uint amount); /** * @notice EIP20 Approval event */ event Approval(address indexed owner, address indexed spender, uint amount); /** * @notice Failure event */ event Failure(uint error, uint info, uint detail); /*** User Interface ***/ function transfer(address dst, uint amount) external returns (bool); function transferFrom(address src, address dst, uint amount) external returns (bool); function approve(address spender, uint amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint); function balanceOf(address owner) external view returns (uint); function balanceOfUnderlying(address owner) external returns (uint); function getAccountSnapshot(address account) external view returns (uint, uint, uint, uint); function borrowRatePerBlock() external view returns (uint); function supplyRatePerBlock() external view returns (uint); function totalBorrowsCurrent() external returns (uint); function borrowBalanceCurrent(address account) external returns (uint); function borrowBalanceStored(address account) public view returns (uint); function exchangeRateCurrent() public returns (uint); function exchangeRateStored() public view returns (uint); function getCash() external view returns (uint); function accrueInterest() public returns (uint); function seize(address liquidator, address borrower, uint seizeTokens) external returns (uint); /*** Admin Functions ***/ function _setPendingAdmin(address payable newPendingAdmin) external returns (uint); function _acceptAdmin() external returns (uint); function _setComptroller(ComptrollerInterface newComptroller) public returns (uint); function _setReserveFactor(uint newReserveFactorMantissa) external returns (uint); function _reduceReserves(uint reduceAmount) external returns (uint); function _setInterestRateModel(InterestRateModel newInterestRateModel) public returns (uint); } contract CErc20Storage { /** * @notice Underlying asset for this CToken */ address public underlying; } contract CErc20Interface is CErc20Storage { /*** User Interface ***/ function mint(uint mintAmount) external returns (uint); function redeem(uint redeemTokens) external returns (uint); function redeemUnderlying(uint redeemAmount) external returns (uint); function borrow(uint borrowAmount) external returns (uint); function repayBorrow(uint repayAmount) external returns (uint); function repayBorrowBehalf(address borrower, uint repayAmount) external returns (uint); function liquidateBorrow(address borrower, uint repayAmount, CTokenInterface cTokenCollateral) external returns (uint); /*** Admin Functions ***/ function _addReserves(uint addAmount) external returns (uint); } contract CDelegationStorage { /** * @notice Implementation address for this contract */ address public implementation; } contract CDelegatorInterface is CDelegationStorage { /** * @notice Emitted when implementation is changed */ event NewImplementation(address oldImplementation, address newImplementation); /** * @notice Called by the admin to update the implementation of the delegator * @param implementation_ The address of the new implementation for delegation * @param allowResign Flag to indicate whether to call _resignImplementation on the old implementation * @param becomeImplementationData The encoded bytes data to be passed to _becomeImplementation */ function _setImplementation(address implementation_, bool allowResign, bytes memory becomeImplementationData) public; } contract CDelegateInterface is CDelegationStorage { /** * @notice Called by the delegator on a delegate to initialize it for duty * @dev Should revert if any issues arise which make it unfit for delegation * @param data The encoded bytes data for any initialization */ function _becomeImplementation(bytes memory data) public; /** * @notice Called by the delegator on a delegate to forfeit its responsibility */ function _resignImplementation() public; }
pragma solidity ^0.5.16; /** * @title ERC 20 Token Standard Interface * https://eips.ethereum.org/EIPS/eip-20 */ interface EIP20Interface { function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); /** * @notice Get the total number of tokens in circulation * @return The supply of tokens */ function totalSupply() external view returns (uint256); /** * @notice Gets the balance of the specified address * @param owner The address from which the balance will be retrieved * @return The balance */ function balanceOf(address owner) external view returns (uint256 balance); /** * @notice Transfer `amount` tokens from `msg.sender` to `dst` * @param dst The address of the destination account * @param amount The number of tokens to transfer * @return Whether or not the transfer succeeded */ function transfer(address dst, uint256 amount) external returns (bool success); /** * @notice Transfer `amount` tokens from `src` to `dst` * @param src The address of the source account * @param dst The address of the destination account * @param amount The number of tokens to transfer * @return Whether or not the transfer succeeded */ function transferFrom(address src, address dst, uint256 amount) external returns (bool success); /** * @notice Approve `spender` to transfer up to `amount` from `src` * @dev This will overwrite the approval amount for `spender` * and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve) * @param spender The address of the account which may transfer tokens * @param amount The number of tokens that are approved (-1 means infinite) * @return Whether or not the approval succeeded */ function approve(address spender, uint256 amount) external returns (bool success); /** * @notice Get the current allowance from `owner` for `spender` * @param owner The address of the account which owns the tokens to be spent * @param spender The address of the account which may transfer tokens * @return The number of tokens allowed to be spent (-1 means infinite) */ function allowance(address owner, address spender) external view returns (uint256 remaining); event Transfer(address indexed from, address indexed to, uint256 amount); event Approval(address indexed owner, address indexed spender, uint256 amount); }
pragma solidity ^0.5.16; /** * @title EIP20NonStandardInterface * @dev Version of ERC20 with no return values for `transfer` and `transferFrom` * See https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca */ interface EIP20NonStandardInterface { /** * @notice Get the total number of tokens in circulation * @return The supply of tokens */ function totalSupply() external view returns (uint256); /** * @notice Gets the balance of the specified address * @param owner The address from which the balance will be retrieved * @return The balance */ function balanceOf(address owner) external view returns (uint256 balance); /// /// !!!!!!!!!!!!!! /// !!! NOTICE !!! `transfer` does not return a value, in violation of the ERC-20 specification /// !!!!!!!!!!!!!! /// /** * @notice Transfer `amount` tokens from `msg.sender` to `dst` * @param dst The address of the destination account * @param amount The number of tokens to transfer */ function transfer(address dst, uint256 amount) external; /// /// !!!!!!!!!!!!!! /// !!! NOTICE !!! `transferFrom` does not return a value, in violation of the ERC-20 specification /// !!!!!!!!!!!!!! /// /** * @notice Transfer `amount` tokens from `src` to `dst` * @param src The address of the source account * @param dst The address of the destination account * @param amount The number of tokens to transfer */ function transferFrom(address src, address dst, uint256 amount) external; /** * @notice Approve `spender` to transfer up to `amount` from `src` * @dev This will overwrite the approval amount for `spender` * and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve) * @param spender The address of the account which may transfer tokens * @param amount The number of tokens that are approved * @return Whether or not the approval succeeded */ function approve(address spender, uint256 amount) external returns (bool success); /** * @notice Get the current allowance from `owner` for `spender` * @param owner The address of the account which owns the tokens to be spent * @param spender The address of the account which may transfer tokens * @return The number of tokens allowed to be spent */ function allowance(address owner, address spender) external view returns (uint256 remaining); event Transfer(address indexed from, address indexed to, uint256 amount); event Approval(address indexed owner, address indexed spender, uint256 amount); }
pragma solidity ^0.5.16; contract ComptrollerErrorReporter { enum Error { NO_ERROR, UNAUTHORIZED, COMPTROLLER_MISMATCH, INSUFFICIENT_SHORTFALL, INSUFFICIENT_LIQUIDITY, INVALID_CLOSE_FACTOR, INVALID_COLLATERAL_FACTOR, INVALID_LIQUIDATION_INCENTIVE, MARKET_NOT_ENTERED, // no longer possible MARKET_NOT_LISTED, MARKET_ALREADY_LISTED, MATH_ERROR, NONZERO_BORROW_BALANCE, PRICE_ERROR, REJECTION, SNAPSHOT_ERROR, TOO_MANY_ASSETS, TOO_MUCH_REPAY } enum FailureInfo { ACCEPT_ADMIN_PENDING_ADMIN_CHECK, ACCEPT_PENDING_IMPLEMENTATION_ADDRESS_CHECK, EXIT_MARKET_BALANCE_OWED, EXIT_MARKET_REJECTION, SET_CLOSE_FACTOR_OWNER_CHECK, SET_CLOSE_FACTOR_VALIDATION, SET_COLLATERAL_FACTOR_OWNER_CHECK, SET_COLLATERAL_FACTOR_NO_EXISTS, SET_COLLATERAL_FACTOR_VALIDATION, SET_COLLATERAL_FACTOR_WITHOUT_PRICE, SET_IMPLEMENTATION_OWNER_CHECK, SET_LIQUIDATION_INCENTIVE_OWNER_CHECK, SET_LIQUIDATION_INCENTIVE_VALIDATION, SET_MAX_ASSETS_OWNER_CHECK, SET_PENDING_ADMIN_OWNER_CHECK, SET_PENDING_IMPLEMENTATION_OWNER_CHECK, SET_PRICE_ORACLE_OWNER_CHECK, SUPPORT_MARKET_EXISTS, SUPPORT_MARKET_OWNER_CHECK, SET_PAUSE_GUARDIAN_OWNER_CHECK } /** * @dev `error` corresponds to enum Error; `info` corresponds to enum FailureInfo, and `detail` is an arbitrary * contract-specific code that enables us to report opaque error codes from upgradeable contracts. **/ event Failure(uint error, uint info, uint detail); /** * @dev use this when reporting a known error from the money market or a non-upgradeable collaborator */ function fail(Error err, FailureInfo info) internal returns (uint) { emit Failure(uint(err), uint(info), 0); return uint(err); } /** * @dev use this when reporting an opaque error from an upgradeable collaborator contract */ function failOpaque(Error err, FailureInfo info, uint opaqueError) internal returns (uint) { emit Failure(uint(err), uint(info), opaqueError); return uint(err); } } contract TokenErrorReporter { enum Error { NO_ERROR, UNAUTHORIZED, BAD_INPUT, COMPTROLLER_REJECTION, COMPTROLLER_CALCULATION_ERROR, INTEREST_RATE_MODEL_ERROR, INVALID_ACCOUNT_PAIR, INVALID_CLOSE_AMOUNT_REQUESTED, INVALID_COLLATERAL_FACTOR, MATH_ERROR, MARKET_NOT_FRESH, MARKET_NOT_LISTED, TOKEN_INSUFFICIENT_ALLOWANCE, TOKEN_INSUFFICIENT_BALANCE, TOKEN_INSUFFICIENT_CASH, TOKEN_TRANSFER_IN_FAILED, TOKEN_TRANSFER_OUT_FAILED } /* * Note: FailureInfo (but not Error) is kept in alphabetical order * This is because FailureInfo grows significantly faster, and * the order of Error has some meaning, while the order of FailureInfo * is entirely arbitrary. */ enum FailureInfo { ACCEPT_ADMIN_PENDING_ADMIN_CHECK, ACCRUE_INTEREST_ACCUMULATED_INTEREST_CALCULATION_FAILED, ACCRUE_INTEREST_BORROW_RATE_CALCULATION_FAILED, ACCRUE_INTEREST_NEW_BORROW_INDEX_CALCULATION_FAILED, ACCRUE_INTEREST_NEW_TOTAL_BORROWS_CALCULATION_FAILED, ACCRUE_INTEREST_NEW_TOTAL_RESERVES_CALCULATION_FAILED, ACCRUE_INTEREST_SIMPLE_INTEREST_FACTOR_CALCULATION_FAILED, BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, BORROW_ACCRUE_INTEREST_FAILED, BORROW_CASH_NOT_AVAILABLE, BORROW_FRESHNESS_CHECK, BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED, BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED, BORROW_MARKET_NOT_LISTED, BORROW_COMPTROLLER_REJECTION, LIQUIDATE_ACCRUE_BORROW_INTEREST_FAILED, LIQUIDATE_ACCRUE_COLLATERAL_INTEREST_FAILED, LIQUIDATE_COLLATERAL_FRESHNESS_CHECK, LIQUIDATE_COMPTROLLER_REJECTION, LIQUIDATE_COMPTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED, LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX, LIQUIDATE_CLOSE_AMOUNT_IS_ZERO, LIQUIDATE_FRESHNESS_CHECK, LIQUIDATE_LIQUIDATOR_IS_BORROWER, LIQUIDATE_REPAY_BORROW_FRESH_FAILED, LIQUIDATE_SEIZE_BALANCE_INCREMENT_FAILED, LIQUIDATE_SEIZE_BALANCE_DECREMENT_FAILED, LIQUIDATE_SEIZE_COMPTROLLER_REJECTION, LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER, LIQUIDATE_SEIZE_TOO_MUCH, MINT_ACCRUE_INTEREST_FAILED, MINT_COMPTROLLER_REJECTION, MINT_EXCHANGE_CALCULATION_FAILED, MINT_EXCHANGE_RATE_READ_FAILED, MINT_FRESHNESS_CHECK, MINT_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, MINT_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, MINT_TRANSFER_IN_FAILED, MINT_TRANSFER_IN_NOT_POSSIBLE, REDEEM_ACCRUE_INTEREST_FAILED, REDEEM_COMPTROLLER_REJECTION, REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, REDEEM_EXCHANGE_RATE_READ_FAILED, REDEEM_FRESHNESS_CHECK, REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, REDEEM_TRANSFER_OUT_NOT_POSSIBLE, REDUCE_RESERVES_ACCRUE_INTEREST_FAILED, REDUCE_RESERVES_ADMIN_CHECK, REDUCE_RESERVES_CASH_NOT_AVAILABLE, REDUCE_RESERVES_FRESH_CHECK, REDUCE_RESERVES_VALIDATION, REPAY_BEHALF_ACCRUE_INTEREST_FAILED, REPAY_BORROW_ACCRUE_INTEREST_FAILED, REPAY_BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, REPAY_BORROW_COMPTROLLER_REJECTION, REPAY_BORROW_FRESHNESS_CHECK, REPAY_BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED, REPAY_BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED, REPAY_BORROW_TRANSFER_IN_NOT_POSSIBLE, SET_COLLATERAL_FACTOR_OWNER_CHECK, SET_COLLATERAL_FACTOR_VALIDATION, SET_COMPTROLLER_OWNER_CHECK, SET_INTEREST_RATE_MODEL_ACCRUE_INTEREST_FAILED, SET_INTEREST_RATE_MODEL_FRESH_CHECK, SET_INTEREST_RATE_MODEL_OWNER_CHECK, SET_MAX_ASSETS_OWNER_CHECK, SET_ORACLE_MARKET_NOT_LISTED, SET_PENDING_ADMIN_OWNER_CHECK, SET_RESERVE_FACTOR_ACCRUE_INTEREST_FAILED, SET_RESERVE_FACTOR_ADMIN_CHECK, SET_RESERVE_FACTOR_FRESH_CHECK, SET_RESERVE_FACTOR_BOUNDS_CHECK, TRANSFER_COMPTROLLER_REJECTION, TRANSFER_NOT_ALLOWED, TRANSFER_NOT_ENOUGH, TRANSFER_TOO_MUCH, ADD_RESERVES_ACCRUE_INTEREST_FAILED, ADD_RESERVES_FRESH_CHECK, ADD_RESERVES_TRANSFER_IN_NOT_POSSIBLE } /** * @dev `error` corresponds to enum Error; `info` corresponds to enum FailureInfo, and `detail` is an arbitrary * contract-specific code that enables us to report opaque error codes from upgradeable contracts. **/ event Failure(uint error, uint info, uint detail); /** * @dev use this when reporting a known error from the money market or a non-upgradeable collaborator */ function fail(Error err, FailureInfo info) internal returns (uint) { emit Failure(uint(err), uint(info), 0); return uint(err); } /** * @dev use this when reporting an opaque error from an upgradeable collaborator contract */ function failOpaque(Error err, FailureInfo info, uint opaqueError) internal returns (uint) { emit Failure(uint(err), uint(info), opaqueError); return uint(err); } }
pragma solidity ^0.5.16; import "./CarefulMath.sol"; /** * @title Exponential module for storing fixed-precision decimals * @author Compound * @notice Exp is a struct which stores decimals with a fixed precision of 18 decimal places. * Thus, if we wanted to store the 5.1, mantissa would store 5.1e18. That is: * `Exp({mantissa: 5100000000000000000})`. */ contract Exponential is CarefulMath { uint constant expScale = 1e18; uint constant doubleScale = 1e36; uint constant halfExpScale = expScale/2; uint constant mantissaOne = expScale; struct Exp { uint mantissa; } struct Double { uint mantissa; } /** * @dev Creates an exponential from numerator and denominator values. * Note: Returns an error if (`num` * 10e18) > MAX_INT, * or if `denom` is zero. */ function getExp(uint num, uint denom) pure internal returns (MathError, Exp memory) { (MathError err0, uint scaledNumerator) = mulUInt(num, expScale); if (err0 != MathError.NO_ERROR) { return (err0, Exp({mantissa: 0})); } (MathError err1, uint rational) = divUInt(scaledNumerator, denom); if (err1 != MathError.NO_ERROR) { return (err1, Exp({mantissa: 0})); } return (MathError.NO_ERROR, Exp({mantissa: rational})); } /** * @dev Adds two exponentials, returning a new exponential. */ function addExp(Exp memory a, Exp memory b) pure internal returns (MathError, Exp memory) { (MathError error, uint result) = addUInt(a.mantissa, b.mantissa); return (error, Exp({mantissa: result})); } /** * @dev Subtracts two exponentials, returning a new exponential. */ function subExp(Exp memory a, Exp memory b) pure internal returns (MathError, Exp memory) { (MathError error, uint result) = subUInt(a.mantissa, b.mantissa); return (error, Exp({mantissa: result})); } /** * @dev Multiply an Exp by a scalar, returning a new Exp. */ function mulScalar(Exp memory a, uint scalar) pure internal returns (MathError, Exp memory) { (MathError err0, uint scaledMantissa) = mulUInt(a.mantissa, scalar); if (err0 != MathError.NO_ERROR) { return (err0, Exp({mantissa: 0})); } return (MathError.NO_ERROR, Exp({mantissa: scaledMantissa})); } /** * @dev Multiply an Exp by a scalar, then truncate to return an unsigned integer. */ function mulScalarTruncate(Exp memory a, uint scalar) pure internal returns (MathError, uint) { (MathError err, Exp memory product) = mulScalar(a, scalar); if (err != MathError.NO_ERROR) { return (err, 0); } return (MathError.NO_ERROR, truncate(product)); } /** * @dev Multiply an Exp by a scalar, truncate, then add an to an unsigned integer, returning an unsigned integer. */ function mulScalarTruncateAddUInt(Exp memory a, uint scalar, uint addend) pure internal returns (MathError, uint) { (MathError err, Exp memory product) = mulScalar(a, scalar); if (err != MathError.NO_ERROR) { return (err, 0); } return addUInt(truncate(product), addend); } /** * @dev Divide an Exp by a scalar, returning a new Exp. */ function divScalar(Exp memory a, uint scalar) pure internal returns (MathError, Exp memory) { (MathError err0, uint descaledMantissa) = divUInt(a.mantissa, scalar); if (err0 != MathError.NO_ERROR) { return (err0, Exp({mantissa: 0})); } return (MathError.NO_ERROR, Exp({mantissa: descaledMantissa})); } /** * @dev Divide a scalar by an Exp, returning a new Exp. */ function divScalarByExp(uint scalar, Exp memory divisor) pure internal returns (MathError, Exp memory) { /* We are doing this as: getExp(mulUInt(expScale, scalar), divisor.mantissa) How it works: Exp = a / b; Scalar = s; `s / (a / b)` = `b * s / a` and since for an Exp `a = mantissa, b = expScale` */ (MathError err0, uint numerator) = mulUInt(expScale, scalar); if (err0 != MathError.NO_ERROR) { return (err0, Exp({mantissa: 0})); } return getExp(numerator, divisor.mantissa); } /** * @dev Divide a scalar by an Exp, then truncate to return an unsigned integer. */ function divScalarByExpTruncate(uint scalar, Exp memory divisor) pure internal returns (MathError, uint) { (MathError err, Exp memory fraction) = divScalarByExp(scalar, divisor); if (err != MathError.NO_ERROR) { return (err, 0); } return (MathError.NO_ERROR, truncate(fraction)); } /** * @dev Multiplies two exponentials, returning a new exponential. */ function mulExp(Exp memory a, Exp memory b) pure internal returns (MathError, Exp memory) { (MathError err0, uint doubleScaledProduct) = mulUInt(a.mantissa, b.mantissa); if (err0 != MathError.NO_ERROR) { return (err0, Exp({mantissa: 0})); } // We add half the scale before dividing so that we get rounding instead of truncation. // See "Listing 6" and text above it at https://accu.org/index.php/journals/1717 // Without this change, a result like 6.6...e-19 will be truncated to 0 instead of being rounded to 1e-18. (MathError err1, uint doubleScaledProductWithHalfScale) = addUInt(halfExpScale, doubleScaledProduct); if (err1 != MathError.NO_ERROR) { return (err1, Exp({mantissa: 0})); } (MathError err2, uint product) = divUInt(doubleScaledProductWithHalfScale, expScale); // The only error `div` can return is MathError.DIVISION_BY_ZERO but we control `expScale` and it is not zero. assert(err2 == MathError.NO_ERROR); return (MathError.NO_ERROR, Exp({mantissa: product})); } /** * @dev Multiplies two exponentials given their mantissas, returning a new exponential. */ function mulExp(uint a, uint b) pure internal returns (MathError, Exp memory) { return mulExp(Exp({mantissa: a}), Exp({mantissa: b})); } /** * @dev Multiplies three exponentials, returning a new exponential. */ function mulExp3(Exp memory a, Exp memory b, Exp memory c) pure internal returns (MathError, Exp memory) { (MathError err, Exp memory ab) = mulExp(a, b); if (err != MathError.NO_ERROR) { return (err, ab); } return mulExp(ab, c); } /** * @dev Divides two exponentials, returning a new exponential. * (a/scale) / (b/scale) = (a/scale) * (scale/b) = a/b, * which we can scale as an Exp by calling getExp(a.mantissa, b.mantissa) */ function divExp(Exp memory a, Exp memory b) pure internal returns (MathError, Exp memory) { return getExp(a.mantissa, b.mantissa); } /** * @dev Truncates the given exp to a whole number value. * For example, truncate(Exp{mantissa: 15 * expScale}) = 15 */ function truncate(Exp memory exp) pure internal returns (uint) { // Note: We are not using careful math here as we're performing a division that cannot fail return exp.mantissa / expScale; } /** * @dev Checks if first Exp is less than second Exp. */ function lessThanExp(Exp memory left, Exp memory right) pure internal returns (bool) { return left.mantissa < right.mantissa; } /** * @dev Checks if left Exp <= right Exp. */ function lessThanOrEqualExp(Exp memory left, Exp memory right) pure internal returns (bool) { return left.mantissa <= right.mantissa; } /** * @dev Checks if left Exp > right Exp. */ function greaterThanExp(Exp memory left, Exp memory right) pure internal returns (bool) { return left.mantissa > right.mantissa; } /** * @dev returns true if Exp is exactly zero */ function isZeroExp(Exp memory value) pure internal returns (bool) { return value.mantissa == 0; } function safe224(uint n, string memory errorMessage) pure internal returns (uint224) { require(n < 2**224, errorMessage); return uint224(n); } function safe32(uint n, string memory errorMessage) pure internal returns (uint32) { require(n < 2**32, errorMessage); return uint32(n); } function add_(Exp memory a, Exp memory b) pure internal returns (Exp memory) { return Exp({mantissa: add_(a.mantissa, b.mantissa)}); } function add_(Double memory a, Double memory b) pure internal returns (Double memory) { return Double({mantissa: add_(a.mantissa, b.mantissa)}); } function add_(uint a, uint b) pure internal returns (uint) { return add_(a, b, "addition overflow"); } function add_(uint a, uint b, string memory errorMessage) pure internal returns (uint) { uint c = a + b; require(c >= a, errorMessage); return c; } function sub_(Exp memory a, Exp memory b) pure internal returns (Exp memory) { return Exp({mantissa: sub_(a.mantissa, b.mantissa)}); } function sub_(Double memory a, Double memory b) pure internal returns (Double memory) { return Double({mantissa: sub_(a.mantissa, b.mantissa)}); } function sub_(uint a, uint b) pure internal returns (uint) { return sub_(a, b, "subtraction underflow"); } function sub_(uint a, uint b, string memory errorMessage) pure internal returns (uint) { require(b <= a, errorMessage); return a - b; } function mul_(Exp memory a, Exp memory b) pure internal returns (Exp memory) { return Exp({mantissa: mul_(a.mantissa, b.mantissa) / expScale}); } function mul_(Exp memory a, uint b) pure internal returns (Exp memory) { return Exp({mantissa: mul_(a.mantissa, b)}); } function mul_(uint a, Exp memory b) pure internal returns (uint) { return mul_(a, b.mantissa) / expScale; } function mul_(Double memory a, Double memory b) pure internal returns (Double memory) { return Double({mantissa: mul_(a.mantissa, b.mantissa) / doubleScale}); } function mul_(Double memory a, uint b) pure internal returns (Double memory) { return Double({mantissa: mul_(a.mantissa, b)}); } function mul_(uint a, Double memory b) pure internal returns (uint) { return mul_(a, b.mantissa) / doubleScale; } function mul_(uint a, uint b) pure internal returns (uint) { return mul_(a, b, "multiplication overflow"); } function mul_(uint a, uint b, string memory errorMessage) pure internal returns (uint) { if (a == 0 || b == 0) { return 0; } uint c = a * b; require(c / a == b, errorMessage); return c; } function div_(Exp memory a, Exp memory b) pure internal returns (Exp memory) { return Exp({mantissa: div_(mul_(a.mantissa, expScale), b.mantissa)}); } function div_(Exp memory a, uint b) pure internal returns (Exp memory) { return Exp({mantissa: div_(a.mantissa, b)}); } function div_(uint a, Exp memory b) pure internal returns (uint) { return div_(mul_(a, expScale), b.mantissa); } function div_(Double memory a, Double memory b) pure internal returns (Double memory) { return Double({mantissa: div_(mul_(a.mantissa, doubleScale), b.mantissa)}); } function div_(Double memory a, uint b) pure internal returns (Double memory) { return Double({mantissa: div_(a.mantissa, b)}); } function div_(uint a, Double memory b) pure internal returns (uint) { return div_(mul_(a, doubleScale), b.mantissa); } function div_(uint a, uint b) pure internal returns (uint) { return div_(a, b, "divide by zero"); } function div_(uint a, uint b, string memory errorMessage) pure internal returns (uint) { require(b > 0, errorMessage); return a / b; } function fraction(uint a, uint b) pure internal returns (Double memory) { return Double({mantissa: div_(mul_(a, doubleScale), b)}); } }
pragma solidity ^0.5.16; /** * @title Compound's InterestRateModel Interface * @author Compound */ contract InterestRateModel { /// @notice Indicator that this is an InterestRateModel contract (for inspection) bool public constant isInterestRateModel = true; /** * @notice Calculates the current borrow interest rate per block * @param cash The total amount of cash the market has * @param borrows The total amount of borrows the market has outstanding * @param reserves The total amnount of reserves the market has * @return The borrow rate per block (as a percentage, and scaled by 1e18) */ function getBorrowRate(uint cash, uint borrows, uint reserves) external view returns (uint); /** * @notice Calculates the current supply interest rate per block * @param cash The total amount of cash the market has * @param borrows The total amount of borrows the market has outstanding * @param reserves The total amnount of reserves the market has * @param reserveFactorMantissa The current reserve factor the market has * @return The supply rate per block (as a percentage, and scaled by 1e18) */ function getSupplyRate(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) external view returns (uint); }
pragma solidity ^0.5.16; import "./CToken.sol"; contract PriceOracle { /// @notice Indicator that this is a PriceOracle contract (for inspection) bool public constant isPriceOracle = true; /** * @notice Get the underlying price of a cToken asset * @param cToken The cToken to get the underlying price of * @return The underlying asset price mantissa (scaled by 1e18). * Zero means the price is unavailable. */ function getUnderlyingPrice(CToken cToken) external view returns (uint); }
pragma solidity ^0.5.16; import "./ErrorReporter.sol"; import "./ComptrollerStorage.sol"; /** * @title ComptrollerCore * @dev Storage for the comptroller is at this address, while execution is delegated to the `comptrollerImplementation`. * CTokens should reference this contract as their comptroller. */ contract Unitroller is UnitrollerAdminStorage, ComptrollerErrorReporter { /** * @notice Emitted when pendingComptrollerImplementation is changed */ event NewPendingImplementation(address oldPendingImplementation, address newPendingImplementation); /** * @notice Emitted when pendingComptrollerImplementation is accepted, which means comptroller implementation is updated */ event NewImplementation(address oldImplementation, address newImplementation); /** * @notice Emitted when pendingAdmin is changed */ event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin); /** * @notice Emitted when pendingAdmin is accepted, which means admin is updated */ event NewAdmin(address oldAdmin, address newAdmin); constructor() public { // Set admin to caller admin = msg.sender; } /*** Admin Functions ***/ function _setPendingImplementation(address newPendingImplementation) public returns (uint) { if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_IMPLEMENTATION_OWNER_CHECK); } address oldPendingImplementation = pendingComptrollerImplementation; pendingComptrollerImplementation = newPendingImplementation; emit NewPendingImplementation(oldPendingImplementation, pendingComptrollerImplementation); return uint(Error.NO_ERROR); } /** * @notice Accepts new implementation of comptroller. msg.sender must be pendingImplementation * @dev Admin function for new implementation to accept it's role as implementation * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _acceptImplementation() public returns (uint) { // Check caller is pendingImplementation and pendingImplementation ≠ address(0) if (msg.sender != pendingComptrollerImplementation || pendingComptrollerImplementation == address(0)) { return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_PENDING_IMPLEMENTATION_ADDRESS_CHECK); } // Save current values for inclusion in log address oldImplementation = comptrollerImplementation; address oldPendingImplementation = pendingComptrollerImplementation; comptrollerImplementation = pendingComptrollerImplementation; pendingComptrollerImplementation = address(0); emit NewImplementation(oldImplementation, comptrollerImplementation); emit NewPendingImplementation(oldPendingImplementation, pendingComptrollerImplementation); return uint(Error.NO_ERROR); } /** * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer. * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer. * @param newPendingAdmin New pending admin. * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setPendingAdmin(address newPendingAdmin) public returns (uint) { // Check caller = admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_ADMIN_OWNER_CHECK); } // Save current value, if any, for inclusion in log address oldPendingAdmin = pendingAdmin; // Store pendingAdmin with value newPendingAdmin pendingAdmin = newPendingAdmin; // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin) emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin); return uint(Error.NO_ERROR); } /** * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin * @dev Admin function for pending admin to accept role and update admin * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _acceptAdmin() public returns (uint) { // Check caller is pendingAdmin and pendingAdmin ≠ address(0) if (msg.sender != pendingAdmin || msg.sender == address(0)) { return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_ADMIN_PENDING_ADMIN_CHECK); } // Save current values for inclusion in log address oldAdmin = admin; address oldPendingAdmin = pendingAdmin; // Store admin with value pendingAdmin admin = pendingAdmin; // Clear the pending value pendingAdmin = address(0); emit NewAdmin(oldAdmin, admin); emit NewPendingAdmin(oldPendingAdmin, pendingAdmin); return uint(Error.NO_ERROR); } /** * @dev Delegates execution to an implementation contract. * It returns to the external caller whatever the implementation returns * or forwards reverts. */ function () payable external { // delegate all other functions to current implementation (bool success, ) = comptrollerImplementation.delegatecall(msg.data); assembly { let free_mem_ptr := mload(0x40) returndatacopy(free_mem_ptr, 0, returndatasize) switch success case 0 { revert(free_mem_ptr, returndatasize) } default { return(free_mem_ptr, returndatasize) } } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"action","type":"string"},{"indexed":false,"internalType":"bool","name":"pauseState","type":"bool"}],"name":"ActionPaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":false,"internalType":"string","name":"action","type":"string"},{"indexed":false,"internalType":"bool","name":"pauseState","type":"bool"}],"name":"ActionPaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"newSpeed","type":"uint256"}],"name":"CompSpeedUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":true,"internalType":"address","name":"borrower","type":"address"},{"indexed":false,"internalType":"uint256","name":"compDelta","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"compBorrowIndex","type":"uint256"}],"name":"DistributedBorrowerComp","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":true,"internalType":"address","name":"supplier","type":"address"},{"indexed":false,"internalType":"uint256","name":"compDelta","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"compSupplyIndex","type":"uint256"}],"name":"DistributedSupplierComp","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"error","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"info","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"detail","type":"uint256"}],"name":"Failure","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":false,"internalType":"bool","name":"isComped","type":"bool"}],"name":"MarketComped","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"MarketEntered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"MarketExited","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract CToken","name":"cToken","type":"address"}],"name":"MarketListed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldCloseFactorMantissa","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newCloseFactorMantissa","type":"uint256"}],"name":"NewCloseFactor","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"oldCollateralFactorMantissa","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newCollateralFactorMantissa","type":"uint256"}],"name":"NewCollateralFactor","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldCompRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newCompRate","type":"uint256"}],"name":"NewCompRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldLiquidationIncentiveMantissa","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newLiquidationIncentiveMantissa","type":"uint256"}],"name":"NewLiquidationIncentive","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldMaxAssets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newMaxAssets","type":"uint256"}],"name":"NewMaxAssets","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldPauseGuardian","type":"address"},{"indexed":false,"internalType":"address","name":"newPauseGuardian","type":"address"}],"name":"NewPauseGuardian","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract PriceOracle","name":"oldPriceOracle","type":"address"},{"indexed":false,"internalType":"contract PriceOracle","name":"newPriceOracle","type":"address"}],"name":"NewPriceOracle","type":"event"},{"constant":false,"inputs":[{"internalType":"address[]","name":"cTokens","type":"address[]"}],"name":"_addCompMarkets","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract Unitroller","name":"unitroller","type":"address"}],"name":"_become","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"_borrowGuardianPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"}],"name":"_dropCompMarket","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"_mintGuardianPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"contract CToken","name":"cToken","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"_setBorrowPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newCloseFactorMantissa","type":"uint256"}],"name":"_setCloseFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract CToken","name":"cToken","type":"address"},{"internalType":"uint256","name":"newCollateralFactorMantissa","type":"uint256"}],"name":"_setCollateralFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"compRate_","type":"uint256"}],"name":"_setCompRate","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newLiquidationIncentiveMantissa","type":"uint256"}],"name":"_setLiquidationIncentive","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newMaxAssets","type":"uint256"}],"name":"_setMaxAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract CToken","name":"cToken","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"_setMintPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newPauseGuardian","type":"address"}],"name":"_setPauseGuardian","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract PriceOracle","name":"newOracle","type":"address"}],"name":"_setPriceOracle","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bool","name":"state","type":"bool"}],"name":"_setSeizePaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bool","name":"state","type":"bool"}],"name":"_setTransferPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract CToken","name":"cToken","type":"address"}],"name":"_supportMarket","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"accountAssets","outputs":[{"internalType":"contract CToken","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"allMarkets","outputs":[{"internalType":"contract CToken","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"borrowAmount","type":"uint256"}],"name":"borrowAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"borrowGuardianPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"borrowAmount","type":"uint256"}],"name":"borrowVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"contract CToken","name":"cToken","type":"address"}],"name":"checkMembership","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"contract CToken[]","name":"cTokens","type":"address[]"}],"name":"claimComp","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"holders","type":"address[]"},{"internalType":"contract CToken[]","name":"cTokens","type":"address[]"},{"internalType":"bool","name":"borrowers","type":"bool"},{"internalType":"bool","name":"suppliers","type":"bool"}],"name":"claimComp","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"holder","type":"address"}],"name":"claimComp","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"closeFactorMantissa","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"compAccrued","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"compBorrowState","outputs":[{"internalType":"uint224","name":"index","type":"uint224"},{"internalType":"uint32","name":"block","type":"uint32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"compBorrowerIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"compClaimThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"compInitialIndex","outputs":[{"internalType":"uint224","name":"","type":"uint224"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"compRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"compSpeeds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"compSupplierIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"compSupplyState","outputs":[{"internalType":"uint224","name":"index","type":"uint224"},{"internalType":"uint32","name":"block","type":"uint32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"comptrollerImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"cTokens","type":"address[]"}],"name":"enterMarkets","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cTokenAddress","type":"address"}],"name":"exitMarket","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getAccountLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getAllMarkets","outputs":[{"internalType":"contract CToken[]","name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getAssetsIn","outputs":[{"internalType":"contract CToken[]","name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getBlockNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getCompAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"cTokenModify","type":"address"},{"internalType":"uint256","name":"redeemTokens","type":"uint256"},{"internalType":"uint256","name":"borrowAmount","type":"uint256"}],"name":"getHypotheticalAccountLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isComptroller","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cTokenBorrowed","type":"address"},{"internalType":"address","name":"cTokenCollateral","type":"address"},{"internalType":"address","name":"liquidator","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"repayAmount","type":"uint256"}],"name":"liquidateBorrowAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cTokenBorrowed","type":"address"},{"internalType":"address","name":"cTokenCollateral","type":"address"},{"internalType":"address","name":"liquidator","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"actualRepayAmount","type":"uint256"},{"internalType":"uint256","name":"seizeTokens","type":"uint256"}],"name":"liquidateBorrowVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"cTokenBorrowed","type":"address"},{"internalType":"address","name":"cTokenCollateral","type":"address"},{"internalType":"uint256","name":"actualRepayAmount","type":"uint256"}],"name":"liquidateCalculateSeizeTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"liquidationIncentiveMantissa","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"markets","outputs":[{"internalType":"bool","name":"isListed","type":"bool"},{"internalType":"uint256","name":"collateralFactorMantissa","type":"uint256"},{"internalType":"bool","name":"isComped","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"maxAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"minter","type":"address"},{"internalType":"uint256","name":"mintAmount","type":"uint256"}],"name":"mintAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"mintGuardianPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"minter","type":"address"},{"internalType":"uint256","name":"actualMintAmount","type":"uint256"},{"internalType":"uint256","name":"mintTokens","type":"uint256"}],"name":"mintVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"oracle","outputs":[{"internalType":"contract PriceOracle","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"pauseGuardian","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"pendingAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"pendingComptrollerImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"redeemer","type":"address"},{"internalType":"uint256","name":"redeemTokens","type":"uint256"}],"name":"redeemAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"redeemer","type":"address"},{"internalType":"uint256","name":"redeemAmount","type":"uint256"},{"internalType":"uint256","name":"redeemTokens","type":"uint256"}],"name":"redeemVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"refreshCompSpeeds","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"repayAmount","type":"uint256"}],"name":"repayBorrowAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"actualRepayAmount","type":"uint256"},{"internalType":"uint256","name":"borrowerIndex","type":"uint256"}],"name":"repayBorrowVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cTokenCollateral","type":"address"},{"internalType":"address","name":"cTokenBorrowed","type":"address"},{"internalType":"address","name":"liquidator","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"seizeTokens","type":"uint256"}],"name":"seizeAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"seizeGuardianPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cTokenCollateral","type":"address"},{"internalType":"address","name":"cTokenBorrowed","type":"address"},{"internalType":"address","name":"liquidator","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"seizeTokens","type":"uint256"}],"name":"seizeVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"src","type":"address"},{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"transferTokens","type":"uint256"}],"name":"transferAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"transferGuardianPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"src","type":"address"},{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"transferTokens","type":"uint256"}],"name":"transferVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
326:57050:4:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;326:57050:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;141:41:5;;;:::i;:::-;;;;;;;;;;;;;;;;;;43182:501:4;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;43182:501:4;;;;;;;;;;:::i;52899:205::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;52899:205:4;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;52899:205:4;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;52899:205:4;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;52899:205:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;52899:205:4;;-1:-1:-1;52899:205:4;;-1:-1:-1;;;;;52899:205:4:i;:::-;;44434:231;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44434:231:4;-1:-1:-1;;;;;44434:231:4;;:::i;3265:42:6:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3265:42:6;-1:-1:-1;;;;;3265:42:6;;:::i;:::-;;;;;;;;;;;;;;;;17272:441:4;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;17272:441:4;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;16333:626::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;16333:626:4;;;;;;;;;;;;;;;;;;;;;;:::i;2426:28:6:-;;;:::i;:::-;;;;-1:-1:-1;;;;;2426:28:6;;;;;;;;;;;;;;273:27;;;:::i;44066:362:4:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44066:362:4;;;;:::i;35182:1029::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;35182:1029:4;;:::i;56394:373::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;56394:373:4;-1:-1:-1;;;;;56394:373:4;;:::i;42681:495::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;42681:495:4;;;;;;;;;;:::i;2460:31:6:-;;;:::i;10421:351:4:-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;10421:351:4;;;;;;;;;;;;;;;;;;;;;;:::i;57054:89::-;;;:::i;19881:527::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;19881:527:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;952:40:6:-;;;:::i;45050:175:4:-;;;:::i;26923:401::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;26923:401:4;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;9512:586;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;9512:586:4;;;;;;;;;;;;;;;;;:::i;39152:1476::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;39152:1476:4;;:::i;12845:340::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;12845:340:4;;;;;;;;;;;;;;;;;;;;;;:::i;3054:26:6:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3054:26:6;;:::i;34333:556:4:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;34333:556:4;-1:-1:-1;;;;;34333:556:4;;:::i;15534:312::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;15534:312:4;;;;;;;;;;;;;;;;;:::i;25570:264::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;25570:264:4;-1:-1:-1;;;;;25570:264:4;;:::i;42083:592::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;42083:592:4;-1:-1:-1;;;;;42083:592:4;;:::i;18157:1260::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;18157:1260:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;53438:933::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;53438:933:4;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;53438:933:4;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;53438:933:4;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;53438:933:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;53438:933:4;;;;;;;;-1:-1:-1;53438:933:4;;-1:-1:-1;;;;;5:28;;2:2;;;46:1;43;36:12;2:2;53438:933:4;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;53438:933:4;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;53438:933:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;53438:933:4;;-1:-1:-1;;;;53438:933:4;;;;;-1:-1:-1;53438:933:4;;;;;;:::i;54563:275::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;54563:275:4;;:::i;24264:334::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;24264:334:4;;;;;;;;;;;;;;;;;;;;;;:::i;3375:58:6:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3375:58:6;-1:-1:-1;;;;;3375:58:6;;:::i;:::-;;;;-1:-1:-1;;;;;3375:58:6;;;;;;;;;;;;;;;;;;;;;;2669:52;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2669:52:6;-1:-1:-1;;;;;2669:52:6;;:::i;22272:458:4:-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;22272:458:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;2613:50:6:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2613:50:6;-1:-1:-1;;;;;2613:50:6;;:::i;2732::4:-;;;:::i;663:25:6:-;;;:::i;2536:34::-;;;:::i;3501:58::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3501:58:6;-1:-1:-1;;;;;3501:58:6;;:::i;2114:41::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2114:41:6;-1:-1:-1;;;;;2114:41:6;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43689:371:4;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;43689:371:4;;;;:::i;4323:161::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;4323:161:4;;;;;;;;;;:::i;1117:21:6:-;;;:::i;57252:122:4:-;;;:::i;40947:654::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;40947:654:4;-1:-1:-1;;;;;40947:654:4;;:::i;2841:47::-;;;:::i;:::-;;;;-1:-1:-1;;;;;2841:47:4;;;;;;;;;;;;;;3162:20:6;;;:::i;3884:170:4:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3884:170:4;-1:-1:-1;;;;;3884:170:4;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;3884:170:4;;;;;;;;;;;;;;;;;2576:31:6;;;:::i;56951:97:4:-;;;:::i;3676:69:6:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;3676:69:6;;;;;;;;;;:::i;364:40::-;;;:::i;23187:761:4:-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;23187:761:4;;;;;;;;;;;;;;;;;;;;;;:::i;4743:368::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;4743:368:4;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;4743:368:4;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;4743:368:4;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;4743:368:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;4743:368:4;;-1:-1:-1;4743:368:4;;-1:-1:-1;;;;;4743:368:4:i;32128:1949::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;32128:1949:4;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;3862:69:6;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;3862:69:6;;;;;;;;;;:::i;4008:43::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4008:43:6;-1:-1:-1;;;;;4008:43:6;;:::i;55004:288:4:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;55004:288:4;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;55004:288:4;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;55004:288:4;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;55004:288:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;55004:288:4;;-1:-1:-1;55004:288:4;;-1:-1:-1;;;;;55004:288:4:i;20861:960::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;20861:960:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;38456:403::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;38456:403:4;;:::i;13617:1618::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;13617:1618:4;;;;;;;;;;;;;;;;;:::i;1240:49:6:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;1240:49:6;;;;;;;;:::i;469:47::-;;;:::i;36576:1606:4:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;36576:1606:4;;;;;;;;:::i;2497:33:6:-;;;:::i;805:31::-;;;:::i;52595:95:4:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;52595:95:4;-1:-1:-1;;;;;52595:95:4;;:::i;11214:441::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;11214:441:4;;;;;;;;;;;;;;;;;:::i;6917:2127::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;6917:2127:4;-1:-1:-1;;;;;6917:2127:4;;:::i;177:20:6:-;;;:::i;141:41:5:-;178:4;141:41;:::o;43182:501:4:-;-1:-1:-1;;;;;43275:24:4;;43251:4;43275:24;;;:7;:24;;;;;:33;;;43267:86;;;;-1:-1:-1;;;43267:86:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43385:13;;-1:-1:-1;;;;;43385:13:4;43371:10;:27;;:50;;-1:-1:-1;43416:5:4;;-1:-1:-1;;;;;43416:5:4;43402:10;:19;43371:50;43363:102;;;;-1:-1:-1;;;43363:102:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43497:5;;-1:-1:-1;;;;;43497:5:4;43483:10;:19;;:36;;-1:-1:-1;43515:4:4;43506:13;;;;43483:36;43475:71;;;;;-1:-1:-1;;;43475:71:4;;;;;;;;;;;;-1:-1:-1;;;43475:71:4;;;;;;;;;;;;;;;-1:-1:-1;;;;;43557:37:4;;;;;;:20;:37;;;;;;;;;:45;;;;;-1:-1:-1;;43557:45:4;;;;;;;;43617:37;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;43617:37:4;;;;;;;;;;;;;;-1:-1:-1;43671:5:4;43182:501;;;;;:::o;52899:205::-;53003:16;;;53017:1;53003:16;;;;;;;;;52976:24;;53003:16;;;;;;105:10:-1;53003:16:4;88:34:-1;136:17;;-1:-1;53003:16:4;52976:43;;53042:6;53029:7;53037:1;53029:10;;;;;;;;;;;;;:19;-1:-1:-1;;;;;53029:19:4;;;-1:-1:-1;;;;;53029:19:4;;;;;53058:39;53068:7;53077;53086:4;53092;53058:9;:39::i;:::-;52899:205;;;:::o;44434:231::-;44513:10;-1:-1:-1;;;;;44513:16:4;;:18;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;44513:18:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;44513:18:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44513:18:4;-1:-1:-1;;;;;44499:32:4;:10;:32;44491:84;;;;-1:-1:-1;;;44491:84:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44593:10;-1:-1:-1;;;;;44593:32:4;;:34;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;44593:34:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;44593:34:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44593:34:4;:39;44585:73;;;;;-1:-1:-1;;;44585:73:4;;;;;;;;;;;;-1:-1:-1;;;44585:73:4;;;;;;;;;;;;;;;44434:231;:::o;3265:42:6:-;;;;;;;;;;;;;:::o;17272:441:4:-;;;;;;:::o;16333:626::-;-1:-1:-1;;;;;16589:15:4;;16479:4;16589:15;;;:7;:15;;;;;:24;;;16584:92;;-1:-1:-1;16641:23:4;16629:36;;16584:92;16722:22;;:::i;:::-;16747:45;;;;;;;;16769:6;-1:-1:-1;;;;;16762:26:4;;:28;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;16762:28:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;16762:28:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;16762:28:4;16747:45;;16722:70;-1:-1:-1;16802:42:4;16824:6;16722:70;16802:21;:42::i;:::-;16854:60;16877:6;16885:8;16895:11;16908:5;16854:22;:60::i;:::-;16937:14;16925:27;;;16333:626;;;;;;;:::o;2426:28:6:-;;;-1:-1:-1;;;;;2426:28:6;;:::o;273:27::-;;;-1:-1:-1;;;;;273:27:6;;:::o;44066:362:4:-;44157:13;;44119:4;;-1:-1:-1;;;;;44157:13:4;44143:10;:27;;:50;;-1:-1:-1;44188:5:4;;-1:-1:-1;;;;;44188:5:4;44174:10;:19;44143:50;44135:102;;;;-1:-1:-1;;;44135:102:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44269:5;;-1:-1:-1;;;;;44269:5:4;44255:10;:19;;:36;;-1:-1:-1;44287:4:4;44278:13;;;;44255:36;44247:71;;;;;-1:-1:-1;;;44247:71:4;;;;;;;;;;;;-1:-1:-1;;;44247:71:4;;;;;;;;;;;;;;;44329:19;:27;;;;;-1:-1:-1;;;44329:27:4;;-1:-1:-1;;;;44329:27:4;;;;;;;;;;44371:28;;;;;;;;;;;;;;;;;;-1:-1:-1;;;44371:28:4;;;;;;;;;;;;;;-1:-1:-1;44416:5:4;44066:362;;;;:::o;35182:1029::-;35254:4;35321:5;;-1:-1:-1;;;;;35321:5:4;35307:10;:19;35303:123;;35349:66;35354:18;35374:40;35349:4;:66::i;:::-;35342:73;;;;35303:123;35436:28;;:::i;:::-;-1:-1:-1;35467:39:4;;;;;;;;;;;;35516:19;;:::i;:::-;-1:-1:-1;35538:39:4;;;;;;;;;3011:7;35538:39;;35591:47;35610:17;35538:39;35591:18;:47::i;:::-;35587:158;;;35661:73;35666:26;35694:39;35661:4;:73::i;:::-;35654:80;;;;;;35587:158;35755:20;;:::i;:::-;-1:-1:-1;35778:39:4;;;;;;;;;3135:6;35778:39;;35831:41;35778:39;35854:17;35831:11;:41::i;:::-;35827:152;;;35895:73;35900:26;35928:39;35895:4;:73::i;:::-;35888:80;;;;;;;35827:152;36019:19;;;36048:44;;;;36107:59;;;;;;;;;;;;;;;;;;;;;;;;;36189:14;36184:20;36177:27;35182:1029;-1:-1:-1;;;;;;35182:1029:4:o;56394:373::-;56474:5;;-1:-1:-1;;;;;56474:5:4;56460:10;:19;56452:63;;;;;-1:-1:-1;;;56452:63:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;56550:15:4;;56526:21;56550:15;;;:7;:15;;;;;56583;;;;;;:23;;:15;:23;56575:63;;;;;-1:-1:-1;;;56575:63:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;56649:15;;;:23;;-1:-1:-1;;56649:23:4;;;56687:35;;;-1:-1:-1;;;;;56687:35:4;;;;56667:5;56687:35;;;;;;;;;;;;;;;;;56733:27;:25;:27::i;:::-;56394:373;;:::o;42681:495::-;-1:-1:-1;;;;;42772:24:4;;42748:4;42772:24;;;:7;:24;;;;;:33;;;42764:86;;;;-1:-1:-1;;;42764:86:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42882:13;;-1:-1:-1;;;;;42882:13:4;42868:10;:27;;:50;;-1:-1:-1;42913:5:4;;-1:-1:-1;;;;;42913:5:4;42899:10;:19;42868:50;42860:102;;;;-1:-1:-1;;;42860:102:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42994:5;;-1:-1:-1;;;;;42994:5:4;42980:10;:19;;:36;;-1:-1:-1;43012:4:4;43003:13;;;;42980:36;42972:71;;;;;-1:-1:-1;;;42972:71:4;;;;;;;;;;;;-1:-1:-1;;;42972:71:4;;;;;;;;;;;;;;;-1:-1:-1;;;;;43054:35:4;;;;;;:18;:35;;;;;;;;;:43;;;;;-1:-1:-1;;43054:43:4;;;;;;;;43112:35;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;43112:35:4;;;;;;;;;;;;;;-1:-1:-1;43164:5:4;42681:495;-1:-1:-1;42681:495:4:o;2460:31:6:-;;;-1:-1:-1;;;2460:31:6;;;;;:::o;10421:351:4:-;;;;;:::o;57054:89::-;57124:12;57054:89;;:::o;19881:527::-;;;;;;;:::o;952:40:6:-;;;;:::o;45050:175:4:-;45104:10;45118:9;45104:23;45096:85;;;;-1:-1:-1;;;45096:85:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45191:27;:25;:27::i;:::-;45050:175::o;26923:401::-;27095:4;27101;27107;27124:9;27135:14;27151;27169:98;27209:7;27225:12;27240;27254;27169:39;:98::i;:::-;27123:144;;;;;;27290:3;27285:9;;;;;;;;27277:40;-1:-1:-1;27296:9:4;;-1:-1:-1;27307:9:4;-1:-1:-1;;26923:401:4;;;;;;;;;:::o;9512:586::-;-1:-1:-1;;;;;9704:26:4;;9600:4;9704:26;;;:18;:26;;;;;;;;9703:27;9695:54;;;;;-1:-1:-1;;;9695:54:4;;;;;;;;;;;;-1:-1:-1;;;9695:54:4;;;;;;;;;;;;;;;-1:-1:-1;;;;;9836:15:4;;;;;;:7;:15;;;;;:24;;;9831:92;;9888:23;9883:29;9876:36;;;;9831:92;9969:29;9991:6;9969:21;:29::i;:::-;10008:45;10031:6;10039;10047:5;10008:22;:45::i;:::-;10076:14;10071:20;10064:27;;9512:586;;;;;;:::o;39152:1476::-;39242:4;39309:5;;-1:-1:-1;;;;;39309:5:4;39295:10;:19;39291:132;;39337:75;39342:18;39362:49;39337:4;:75::i;39291:132::-;39498:34;;:::i;:::-;-1:-1:-1;39535:48:4;;;;;;;;;;;;39593:34;;:::i;:::-;-1:-1:-1;39630:48:4;;;;;;;;;3410:6;39630:48;;39692:61;39704:23;39630:48;39692:11;:61::i;:::-;39688:190;;;39776:91;39781:35;39818:48;39776:4;:91::i;39688:190::-;39888:34;;:::i;:::-;-1:-1:-1;39925:48:4;;;;;;;;;3558:6;39925:48;;39987:61;39925:48;40024:23;39987:11;:61::i;:::-;39983:190;;;40071:91;40076:35;40113:48;40071:4;:91::i;39983:190::-;40267:28;;;40360:62;;;;40494:89;;;;;;;;;;;;;;;;;;;;;;;;;40606:14;40601:20;;12845:340;13088:17;;:37;;;;;13124:1;13109:12;:16;13088:37;13084:95;;;13141:27;;;-1:-1:-1;;;13141:27:4;;;;;;;;;;;;-1:-1:-1;;;13141:27:4;;;;;;;;;;;;;;3054:26:6;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;3054:26:6;;-1:-1:-1;3054:26:6;:::o;34333:556:4:-;34397:4;34464:5;;-1:-1:-1;;;;;34464:5:4;34450:10;:19;34446:123;;34492:66;34497:18;34517:40;34492:4;:66::i;34446:123::-;34655:6;;;-1:-1:-1;;;;;34721:18:4;;;-1:-1:-1;;;;;;34721:18:4;;;;;;;34808:36;;;34655:6;;;;34808:36;;;;;;;;;;;;;;;;;;;;;;;34867:14;34855:27;34333:556;-1:-1:-1;;;34333:556:4:o;15534:312::-;15783:57;;25570:264;25637:4;25643;25649;25666:9;25677:14;25693;25711:65;25751:7;25767:1;25771;25774;25711:39;:65::i;:::-;25665:111;;;;;;25800:3;25795:9;;;;;;;;25787:40;25806:9;;-1:-1:-1;25806:9:4;-1:-1:-1;25570:264:4;-1:-1:-1;;;25570:264:4:o;42083:592::-;42152:4;42186:5;;-1:-1:-1;;;;;42186:5:4;42172:10;:19;42168:125;;42214:68;42219:18;42239:42;42214:4;:68::i;42168:125::-;42381:13;;;-1:-1:-1;;;;;42464:32:4;;;-1:-1:-1;;;;;;42464:32:4;;;;;;;42581:49;;;42381:13;;;42581:49;;;42616:13;;;;42581:49;;;;;;;;;;;;;;;;42653:14;42648:20;;18157:1260;-1:-1:-1;;;;;18430:23:4;;18354:4;18430:23;;;:7;:23;;;;;:32;;;18429:33;;:72;;-1:-1:-1;;;;;;18467:25:4;;;;;;:7;:25;;;;;:34;;;18466:35;18429:72;18425:139;;;18529:23;18524:29;18517:36;;;;18425:139;18650:9;18663:14;18681:37;18709:8;18681:27;:37::i;:::-;18649:69;;-1:-1:-1;18649:69:4;;-1:-1:-1;18739:14:4;;-1:-1:-1;18732:3:4;:21;;;;;;;;;18728:68;;18781:3;18776:9;;;;;;;;18769:16;;;;;;18728:68;18809:14;18805:86;;18851:28;18846:34;;18805:86;18989:18;19017:14;-1:-1:-1;;;;;19010:42:4;;19053:8;19010:52;;;;;;;;;;;;;-1:-1:-1;;;;;19010:52:4;-1:-1:-1;;;;;19010:52:4;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19010:52:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19010:52:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;19010:52:4;19127:36;;;19010:52;19127:36;;;;;19142:19;;19127:36;;19010:52;;-1:-1:-1;19073:17:4;;;;19109:70;;19010:52;19109:17;:70::i;:::-;19072:107;;-1:-1:-1;19072:107:4;-1:-1:-1;19204:18:4;19193:7;:29;;;;;;;;;19189:89;;19250:16;19245:22;19238:29;;;;;;;;;19189:89;19305:8;19291:11;:22;19287:86;;;19341:20;19336:26;;19287:86;19395:14;19383:27;;;;;;;18157:1260;;;;;;;;:::o;53438:933::-;53562:6;53557:808;53578:7;:14;53574:1;:18;53557:808;;;53613:13;53629:7;53637:1;53629:10;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;53661:24:4;;;;;;:7;:24;;;;;;;:33;53629:10;;-1:-1:-1;53661:33:4;;53653:67;;;;;-1:-1:-1;;;53653:67:4;;;;;;;;;;;;-1:-1:-1;;;53653:67:4;;;;;;;;;;;;;;;53751:4;53738:17;;;;53734:357;;;53775:22;;:::i;:::-;53800:37;;;;;;;;53815:6;-1:-1:-1;;;;;53815:18:4;;:20;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53815:20:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;53815:20:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;53815:20:4;53800:37;;53775:62;-1:-1:-1;53855:51:4;53885:6;53775:62;53855:21;:51::i;:::-;53929:6;53924:153;53945:7;:14;53941:1;:18;53924:153;;;53988:70;54019:6;54028:7;54036:1;54028:10;;;;;;;;;;;;;;54040:11;54053:4;53988:22;:70::i;:::-;53961:3;;53924:153;;;;53734:357;;54121:4;54108:17;;;;54104:251;;;54145:38;54175:6;54145:21;:38::i;:::-;54206:6;54201:140;54222:7;:14;54218:1;:18;54201:140;;;54265:57;54296:6;54305:7;54313:1;54305:10;;;;;;;;;;;;;;54317:4;54265:22;:57::i;:::-;54238:3;;54201:140;;;;54104:251;-1:-1:-1;53594:3:4;;53557:808;;54563:275;54626:21;:19;:21::i;:::-;54618:65;;;;;-1:-1:-1;;;54618:65:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;54709:8;;;54727:20;;;;54762:31;;;;;;;;;;;;;;;;;;;;;;;;;54804:27;:25;:27::i;3375:58:6:-;;;;;;;;;;;;-1:-1:-1;;;;;3375:58:6;;;-1:-1:-1;;;3375:58:6;;;;;:::o;2669:52::-;;;;;;;;;;;;;;;:::o;2613:50::-;;;;;;;;;;;;;;;:::o;2732::4:-;2774:8;2732:50;:::o;663:25:6:-;;;-1:-1:-1;;;;;663:25:6;;:::o;2536:34::-;;;-1:-1:-1;;;2536:34:6;;;;;:::o;3501:58::-;;;;;;;;;;;;-1:-1:-1;;;;;3501:58:6;;;-1:-1:-1;;;3501:58:6;;;;;:::o;2114:41::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;43689:371:4:-;43783:13;;43745:4;;-1:-1:-1;;;;;43783:13:4;43769:10;:27;;:50;;-1:-1:-1;43814:5:4;;-1:-1:-1;;;;;43814:5:4;43800:10;:19;43769:50;43761:102;;;;-1:-1:-1;;;43761:102:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43895:5;;-1:-1:-1;;;;;43895:5:4;43881:10;:19;;:36;;-1:-1:-1;43913:4:4;43904:13;;;;43881:36;43873:71;;;;;-1:-1:-1;;;43873:71:4;;;;;;;;;;;;-1:-1:-1;;;43873:71:4;;;;;;;;;;;;;;;43955:22;:30;;;;;-1:-1:-1;;;43955:30:4;;-1:-1:-1;;;;43955:30:4;;;;;;;;;;44000:31;;;;;;;;;;;;;;;;;;-1:-1:-1;;;44000:31:4;;;;;;;;;;;;;;-1:-1:-1;44048:5:4;43689:371::o;4323:161::-;-1:-1:-1;;;;;4426:24:4;;;4403:4;4426:24;;;:7;:24;;;;;;;;:51;;;;;:42;;;;:51;;;;;;4323:161;;;;:::o;1117:21:6:-;;;;:::o;57252:122:4:-;57325:42;57252:122;:::o;40947:654::-;41004:4;41038:5;;-1:-1:-1;;;;;41038:5:4;41024:10;:19;41020:121;;41066:64;41071:18;41091:38;41066:4;:64::i;41020:121::-;-1:-1:-1;;;;;41155:24:4;;;;;;:7;:24;;;;;:33;;;41151:139;;;41211:68;41216:27;41245:33;41211:4;:68::i;41151:139::-;41300:6;-1:-1:-1;;;;;41300:15:4;;:17;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;41300:17:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;41300:17:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;41404:70:4;;;;;;;;41422:4;41404:70;;;-1:-1:-1;41300:17:4;41404:70;;;;;;;;;;;;-1:-1:-1;;;;;41377:24:4;;;;:7;:24;;;;;;;:97;;;;;;;-1:-1:-1;;41377:97:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41485:35;41393:6;41485:18;:35::i;:::-;41536:20;;;-1:-1:-1;;;;;41536:20:4;;;;;;;;;;;;;;;41579:14;41567:27;40947:654;-1:-1:-1;;40947:654:4:o;2841:47::-;2884:4;2841:47;:::o;3162:20:6:-;;;;:::o;3884:170:4:-;3945:15;3972:24;3999:13;:22;4013:7;-1:-1:-1;;;;;3999:22:4;-1:-1:-1;;;;;3999:22:4;;;;;;;;;;;;3972:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;3972:49:4;;;;;;;;;;;;;;;;-1:-1:-1;3972:49:4;;3884:170;-1:-1:-1;;;;;;;3884:170:4:o;2576:31:6:-;;;-1:-1:-1;;;2576:31:6;;;;;:::o;56951:97:4:-;56997:15;57031:10;57024:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;57024:17:4;;;;;;;;;;;;;;;;;;;;;;;56951:97;:::o;3676:69:6:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;364:40::-;;;-1:-1:-1;;;;;364:40:6;;:::o;23187:761:4:-;23397:22;;23293:4;;-1:-1:-1;;;23397:22:4;;;;23396:23;23388:54;;;;;-1:-1:-1;;;23388:54:4;;;;;;;;;;;;-1:-1:-1;;;23388:54:4;;;;;;;;;;;;;;;23573:12;23588:50;23610:6;23618:3;23623:14;23588:21;:50::i;:::-;23573:65;-1:-1:-1;23652:31:4;;23648:76;;23706:7;-1:-1:-1;23699:14:4;;23648:76;23770:29;23792:6;23770:21;:29::i;:::-;23809:42;23832:6;23840:3;23845:5;23809:22;:42::i;:::-;23861;23884:6;23892:3;23897:5;23861:22;:42::i;4743:368::-;4807:13;4832:8;4843:7;:14;4832:25;;4868:21;4903:3;4892:15;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;4892:15:4;-1:-1:-1;4868:39:4;-1:-1:-1;4922:6:4;4917:163;4938:3;4934:1;:7;4917:163;;;4962:13;4985:7;4993:1;4985:10;;;;;;;;;;;;;;4962:34;;5029:39;5049:6;5057:10;5029:19;:39::i;:::-;5024:45;;;;;;;;5011:7;5019:1;5011:10;;;;;;;;;;;;;;;;;:58;-1:-1:-1;4943:3:4;;4917:163;;;-1:-1:-1;5097:7:4;4743:368;-1:-1:-1;;;4743:368:4:o;32128:1949::-;32384:6;;;:49;;;-1:-1:-1;;;32384:49:4;;-1:-1:-1;;;;;32384:49:4;;;;;;;;;;;;32264:4;;;;;;32384:6;;;:25;;:49;;;;;;;;;;;;;;;:6;:49;;;5:2:-1;;;;30:1;27;20:12;5:2;32384:49:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;32384:49:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;32384:49:4;32474:6;;;:51;;;-1:-1:-1;;;32474:51:4;;-1:-1:-1;;;;;32474:51:4;;;;;;;;;;;;32384:49;;-1:-1:-1;32443:28:4;;32474:6;;;;;:25;;:51;;;;;32384:49;;32474:51;;;;;;;;:6;:51;;;5:2:-1;;;;30:1;27;20:12;5:2;32474:51:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;32474:51:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;32474:51:4;;-1:-1:-1;32539:26:4;;;:58;;-1:-1:-1;32569:28:4;;32539:58;32535:124;;;32626:17;32613:35;-1:-1:-1;32646:1:4;;-1:-1:-1;32613:35:4;;-1:-1:-1;;32613:35:4;32535:124;33044:25;33079:16;-1:-1:-1;;;;;33072:43:4;;:45;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;33072:45:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;33072:45:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;33072:45:4;;-1:-1:-1;33153:16:4;33179:20;;:::i;:::-;33209:22;;:::i;:::-;33241:16;;:::i;:::-;33267:17;33318:59;33325:28;;33355:21;33318:6;:59::i;:::-;33295:82;-1:-1:-1;33295:82:4;-1:-1:-1;33402:18:4;33391:7;:29;;;;;;;;;33387:94;;33449:16;33444:22;33436:34;-1:-1:-1;33468:1:4;;-1:-1:-1;33436:34:4;;-1:-1:-1;;;;;;;;33436:34:4;33387:94;33516:53;33523:23;33548:20;33516:6;:53::i;:::-;33491:78;-1:-1:-1;33491:78:4;-1:-1:-1;33594:18:4;33583:7;:29;;;;;;;;;33579:94;;33641:16;33636:22;;33579:94;33702:30;33709:9;33720:11;33702:6;:30::i;:::-;33683:49;-1:-1:-1;33683:49:4;-1:-1:-1;33757:18:4;33746:7;:29;;;;;;;;;33742:94;;33804:16;33799:22;;33742:94;33871:43;33889:5;33896:17;33871;:43::i;:::-;33846:68;-1:-1:-1;33846:68:4;-1:-1:-1;33939:18:4;33928:7;:29;;;;;;;;;33924:94;;33986:16;33981:22;;33924:94;34041:14;34028:42;-1:-1:-1;34058:11:4;;-1:-1:-1;;;;;;;;32128:1949:4;;;;;;;:::o;3862:69:6:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;4008:43::-;;;;;;;;;;;;;:::o;55004:288:4:-;55080:21;:19;:21::i;:::-;55072:64;;;;;-1:-1:-1;;;55072:64:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;55152:6;55147:101;55168:7;:14;55164:1;:18;55147:101;;;55203:34;55226:7;55234:1;55226:10;;;;;;;;;;;;;;55203:22;:34::i;:::-;55184:3;;55147:101;;;;55258:27;:25;:27::i;20861:960::-;21152:19;;21048:4;;-1:-1:-1;;;21152:19:4;;;;21151:20;21143:48;;;;;-1:-1:-1;;;21143:48:4;;;;;;;;;;;;-1:-1:-1;;;21143:48:4;;;;;;;;;;;;;;;-1:-1:-1;;;;;21263:25:4;;;;;;:7;:25;;;;;:34;;;21262:35;;:72;;-1:-1:-1;;;;;;21302:23:4;;;;;;:7;:23;;;;;:32;;;21301:33;21262:72;21258:139;;;21362:23;21357:29;;21258:139;21460:14;-1:-1:-1;;;;;21453:34:4;;:36;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;21453:36:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;21453:36:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;21453:36:4;21411:38;;;-1:-1:-1;;;21411:38:4;;;;-1:-1:-1;;;;;21411:78:4;;;;:36;;;;;:38;;;;;21453:36;;21411:38;;;;;;;:36;:38;;;5:2:-1;;;;30:1;27;20:12;5:2;21411:38:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;21411:38:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;21411:38:4;-1:-1:-1;;;;;21411:78:4;;21407:148;;21517:26;21512:32;;21407:148;21601:39;21623:16;21601:21;:39::i;:::-;21650:57;21673:16;21691:8;21701:5;21650:22;:57::i;:::-;21717:59;21740:16;21758:10;21770:5;21717:22;:59::i;:::-;21799:14;21787:27;20861:960;-1:-1:-1;;;;;;20861:960:4:o;38456:403::-;38516:4;38583:5;;-1:-1:-1;;;;;38583:5:4;38569:10;:19;38565:121;;38611:64;38616:18;38636:38;38611:4;:64::i;38565:121::-;38716:9;;;38735:24;;;;38774:40;;;;;;;;;;;;;;;;;;;;;;;;;38837:14;38832:20;;13617:1618;-1:-1:-1;;;;;13815:28:4;;13711:4;13815:28;;;:20;:28;;;;;;;;13814:29;13806:58;;;;;-1:-1:-1;;;13806:58:4;;;;;;;;;;;;-1:-1:-1;;;13806:58:4;;;;;;;;;;;;;;;-1:-1:-1;;;;;13880:15:4;;;;;;:7;:15;;;;;:24;;;13875:92;;13932:23;13927:29;;13875:92;-1:-1:-1;;;;;13982:15:4;;;;;;;:7;:15;;;;;;;;:43;;;;;:33;;;;:43;;;;;;13977:562;;14126:10;-1:-1:-1;;;;;14126:20:4;;;14118:54;;;;;-1:-1:-1;;;14118:54:4;;;;;;;;;;;;-1:-1:-1;;;14118:54:4;;;;;;;;;;;;;;;14240:9;14252:49;14279:10;14292:8;14252:19;:49::i;:::-;14240:61;-1:-1:-1;14326:14:4;14319:3;:21;;;;;;;;;14315:76;;14372:3;14367:9;;;;;;;;14360:16;;;;;14315:76;-1:-1:-1;;;;;14484:15:4;;;;;;;:7;:15;;;;;;;;:43;;;;;:33;;;;:43;;;;;;14477:51;;;;13977:562;;14553:6;;;:41;;;-1:-1:-1;;;14553:41:4;;-1:-1:-1;;;;;14553:41:4;;;;;;;;;;;;:6;;;;;:25;;:41;;;;;;;;;;;;;;;:6;:41;;;5:2:-1;;;;30:1;27;20:12;5:2;14553:41:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;14553:41:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;14553:41:4;14549:107;;14627:17;14622:23;;14549:107;14667:9;14680:14;14698:82;14738:8;14755:6;14764:1;14767:12;14698:39;:82::i;:::-;14666:114;;-1:-1:-1;14666:114:4;;-1:-1:-1;14801:14:4;;-1:-1:-1;14794:3:4;:21;;;;;;;;;14790:68;;14843:3;14838:9;;;;;;;;14831:16;;;;;;14790:68;14871:13;;14867:85;;14912:28;14907:34;;14867:85;14998:22;;:::i;:::-;15023:45;;;;;;;;15045:6;-1:-1:-1;;;;;15038:26:4;;:28;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15038:28:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;15038:28:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;15038:28:4;15023:45;;14998:70;-1:-1:-1;15078:42:4;15100:6;14998:70;15078:21;:42::i;:::-;15130:60;15153:6;15161:8;15171:11;15184:5;15130:22;:60::i;:::-;15213:14;15201:27;13617:1618;-1:-1:-1;;;;;;;13617:1618:4:o;1240:49:6:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1240:49:6;;-1:-1:-1;1240:49:6;;-1:-1:-1;1240:49:6:o;469:47::-;;;-1:-1:-1;;;;;469:47:6;;:::o;36576:1606:4:-;36673:4;36740:5;;-1:-1:-1;;;;;36740:5:4;36726:10;:19;36722:128;;36768:71;36773:18;36793:45;36768:4;:71::i;:::-;36761:78;;;;36722:128;-1:-1:-1;;;;;36919:24:4;;36895:21;36919:24;;;:7;:24;;;;;36958:15;;;;36953:128;;36996:74;37001:23;37026:43;36996:4;:74::i;:::-;36989:81;;;;;36953:128;37091:33;;:::i;:::-;-1:-1:-1;37127:44:4;;;;;;;;;;;;37224:20;;:::i;:::-;-1:-1:-1;37247:44:4;;;;;;;;;3265:6;37247:44;;37305:46;37247:44;37328:22;37305:11;:46::i;:::-;37301:167;;;37374:83;37379:31;37412:44;37374:4;:83::i;:::-;37367:90;;;;;;;37301:167;37539:32;;;;;:74;;-1:-1:-1;37575:6:4;;;:33;;;-1:-1:-1;;;37575:33:4;;-1:-1:-1;;;;;37575:33:4;;;;;;;;;;;;:6;;;;;:25;;:33;;;;;;;;;;;;;;;:6;:33;;;5:2:-1;;;;30:1;27;20:12;5:2;37575:33:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;37575:33:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;37575:33:4;:38;37539:74;37535:184;;;37636:72;37641:17;37660:47;37636:4;:72::i;37535:184::-;37851:31;;;;;37892:61;;;;38052:85;;;-1:-1:-1;;;;;38052:85:4;;;;;;;;;;;;;;;;;;;;;;;;;;;38160:14;38148:27;36576:1606;-1:-1:-1;;;;;;;36576:1606:4:o;2497:33:6:-;;;-1:-1:-1;;;2497:33:6;;;;;:::o;805:31::-;;;;:::o;52595:95:4:-;52654:29;52664:6;52672:10;52654:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;52654:29:4;;;;;;;;;;;;;;;;;;;;;:9;:29::i;11214:441::-;11308:4;11324:12;11339:53;11361:6;11369:8;11379:12;11339:21;:53::i;:::-;11324:68;-1:-1:-1;11406:31:4;;11402:76;;11460:7;-1:-1:-1;11453:14:4;;11402:76;11524:29;11546:6;11524:21;:29::i;:::-;11563:47;11586:6;11594:8;11604:5;11563:22;:47::i;:::-;11633:14;11621:27;11214:441;-1:-1:-1;;;;;11214:441:4:o;6917:2127::-;6978:4;6994:13;7017;6994:37;;7120:9;7131:15;7148;7169:6;-1:-1:-1;;;;;7169:25:4;;7195:10;7169:37;;;;;;;;;;;;;-1:-1:-1;;;;;7169:37:4;-1:-1:-1;;;;;7169:37:4;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;7169:37:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;7169:37:4;;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;7169:37:4;;;;;;;;;;;;;-1:-1:-1;7169:37:4;;-1:-1:-1;7169:37:4;-1:-1:-1;7224:9:4;;7216:59;;;;-1:-1:-1;;;7216:59:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7370:15;;7366:125;;7408:72;7413:28;7443:36;7408:4;:72::i;:::-;7401:79;;;;;;;;7366:125;7581:12;7596:60;7618:13;7633:10;7645;7596:21;:60::i;:::-;7581:75;-1:-1:-1;7670:12:4;;7666:121;;7705:71;7716:15;7733:33;7768:7;7705:10;:71::i;:::-;7698:78;;;;;;;;;7666:121;-1:-1:-1;;;;;7827:24:4;;7797:27;7827:24;;;:7;:24;;;;;;;;7973:10;7942:42;;:30;;;:42;;;;;;;;;7937:101;;8012:14;8000:27;;;;;;;;;;7937:101;8139:10;8108:42;;;;:30;;;:42;;;;;;;;8101:49;;-1:-1:-1;;8101:49:4;;;8306:13;:25;;;;;;8274:57;;;;;;;;;;;;;;;;;:29;;:57;;;8306:25;8274:57;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;8274:57:4;;;;;;;;;;;;;;;;-1:-1:-1;;8352:20:4;;8274:57;;-1:-1:-1;8352:20:4;;-1:-1:-1;8341:8:4;;-1:-1:-1;;8413:157:4;8434:3;8430:1;:7;8413:157;;;8482:6;-1:-1:-1;;;;;8462:26:4;:13;8476:1;8462:16;;;;;;;;;;;;;;-1:-1:-1;;;;;8462:26:4;;8458:102;;;8521:1;8508:14;;8540:5;;8458:102;8439:3;;8413:157;;;;8696:3;8683:10;:16;8676:24;;;;8843:10;8799:27;8829:25;;;:13;:25;;;;;8900:17;;8829:25;;-1:-1:-1;;8900:21:4;;;8889:33;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;8889:33:4;8864:10;8875;8864:22;;;;;;;;;;;;;;;;;:58;;-1:-1:-1;;;;;;8864:58:4;-1:-1:-1;;;;;8864:58:4;;;;;;;;;;8932:19;;;;-1:-1:-1;;8932:19:4;;;:::i;:::-;-1:-1:-1;8967:32:4;;;-1:-1:-1;;;;;8967:32:4;;;;8988:10;8967:32;;;;;;;;;;;;;;;;;9022:14;9010:27;6917:2127;-1:-1:-1;;;;;;;;;;;;6917:2127:4:o;177:20:6:-;;;-1:-1:-1;;;;;177:20:6;;:::o;47865:1086:4:-;-1:-1:-1;;;;;47999:23:4;;47961:35;47999:23;;;:15;:23;;;;;;;;48051:10;:18;;;;;;47999:23;;48098:16;:14;:16::i;:::-;48166:17;;48079:35;;-1:-1:-1;48124:16:4;;48143:42;;48079:35;;-1:-1:-1;;;48166:17:4;;;;48143:4;:42::i;:::-;48124:61;;48213:1;48199:11;:15;:34;;;;;48232:1;48218:11;:15;48199:34;48195:750;;;48249:17;48269:54;48281:6;-1:-1:-1;;;;;48274:27:4;;:29;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48274:29:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48274:29:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;48274:29:4;48305:17;48269:4;:54::i;:::-;48249:74;;48337:16;48356:30;48361:11;48374;48356:4;:30::i;:::-;48337:49;;48400:19;;:::i;:::-;48437:1;48422:12;:16;:78;;48479:21;;;;;;;;48497:1;48479:21;;;48422:78;;;48441:35;48450:11;48463:12;48441:8;:35::i;:::-;48400:100;;48514:19;;:::i;:::-;48541:37;;;;;;;;;48559:17;;-1:-1:-1;;;;;48559:17:4;48541:37;;48536:50;;48580:5;48536:4;:50::i;:::-;48514:72;;48626:185;;;;;;;;48667:53;48675:5;:14;;;48667:53;;;;;;;;;;;;;;;;;:7;:53::i;:::-;-1:-1:-1;;;;;48626:185:4;;;;;48745:51;48752:11;48745:51;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;48745:51:4;;;:6;:51::i;:::-;48626:185;;;;;;;-1:-1:-1;;;;;48600:23:4;;;;;;:15;:23;;;;;;;;:211;;;;;;;;;;;;-1:-1:-1;;;48600:211:4;-1:-1:-1;;;;;48600:211:4;;;-1:-1:-1;;;;;;48600:211:4;;;;;;;;;;;;;;-1:-1:-1;48195:750:4;;-1:-1:-1;;;48195:750:4;;48832:15;;48828:117;;48883:51;48890:11;48883:51;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;48883:51:4;;;:6;:51::i;:::-;48863:71;;;;;;;-1:-1:-1;;;48863:71:4;-1:-1:-1;;;;;48863:71:4;;;;;;47865:1086;;;;;;:::o;50585:1040::-;-1:-1:-1;;;;;50758:23:4;;50720:35;50758:23;;;:15;:23;;;;;50791:25;;:::i;:::-;-1:-1:-1;50819:37:4;;;;;;;;;50837:17;;-1:-1:-1;;;;;50837:17:4;50819:37;;50866:27;;:::i;:::-;-1:-1:-1;50896:55:4;;;;;;;;;-1:-1:-1;;;;;50914:25:4;;;-1:-1:-1;50914:25:4;;;:17;:25;;;;;:35;;;;;;;;;;;;;;50896:55;;50999:20;;50961:35;;;;;;:58;;;;51034:22;;:26;51030:589;;51076:24;;:::i;:::-;51103:32;51108:11;51121:13;51103:4;:32::i;:::-;51076:59;;51149:19;51171:69;51183:6;-1:-1:-1;;;;;51176:34:4;;51211:8;51176:44;;;;;;;;;;;;;-1:-1:-1;;;;;51176:44:4;-1:-1:-1;;;;;51176:44:4;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51176:44:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;51176:44:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51176:44:4;51222:17;51171:4;:69::i;:::-;51149:91;;51254:18;51275:32;51280:14;51296:10;51275:4;:32::i;:::-;-1:-1:-1;;;;;51349:21:4;;51321:20;51349:21;;;:11;:21;;;;;;51254:53;;-1:-1:-1;51321:20:4;51344:42;;51254:53;51344:4;:42::i;:::-;51321:65;;51424:79;51437:8;51447:15;51464:13;:38;;2774:8;51464:38;;;51480:1;51464:38;51424:12;:79::i;:::-;-1:-1:-1;;;;;51400:21:4;;;;;;;:11;:21;;;;;;;;;:103;;;;51587:20;;51522:86;;;;;;;;;;;51400:21;;51522:86;;;;;;;;;;;;;;;51030:589;;;;;50585:1040;;;;;;;:::o;1855:149:9:-;1916:4;1937:33;1950:3;1945:9;;;;;;;;1961:4;1956:10;;;;;;;;1937:33;;;;;;;;;;;;;1968:1;1937:33;;;;;;;;;;;;;1993:3;1988:9;;;;;;;7723:147:10;7849:14;7832:13;;:31;;;7723:147::o;7517:139::-;7635:14;7619:13;;:30;;7517:139::o;45231:1298:4:-;45287:27;45317:10;45287:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;45287:40:4;;;;;;;;;;;;;;;;-1:-1:-1;45287:40:4;;-1:-1:-1;45343:6:4;;-1:-1:-1;;;;45338:294:4;45359:11;:18;45355:1;:22;45338:294;;;45398:13;45414:11;45426:1;45414:14;;;;;;;;;;;;;;45398:30;;45442:22;;:::i;:::-;45467:37;;;;;;;;45482:6;-1:-1:-1;;;;;45482:18:4;;:20;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45482:20:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45482:20:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45482:20:4;45467:37;;45442:62;-1:-1:-1;45518:38:4;45548:6;45518:21;:38::i;:::-;45570:51;45600:6;45609:11;45570:21;:51::i;:::-;-1:-1:-1;;45379:3:4;;45338:294;;;;45642:23;;:::i;:::-;45668:18;;;;;;;;45683:1;45668:18;;;45642:44;;45696:22;45731:11;:18;45721:29;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;45696:54:4;-1:-1:-1;45765:6:4;45760:438;45781:11;:18;45777:1;:22;45760:438;;;45820:13;45836:11;45848:1;45836:14;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;45868:24:4;;;;;;:7;:24;;;;;;;:33;;;45836:14;;-1:-1:-1;45868:33:4;;45864:324;;;45921:21;;:::i;:::-;45945:50;;;;;;;;;;45960:6;;-1:-1:-1;;;45960:33:4;;;-1:-1:-1;;;;;45960:33:4;;;;;;;;;45945:50;;;;45960:6;;;:25;;:33;;;;;45945:50;45960:33;;;;;;:6;:33;;;5:2:-1;;;;30:1;27;20:12;5:2;45960:33:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45960:33:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45960:33:4;45945:50;;45921:74;-1:-1:-1;46013:18:4;;:::i;:::-;46034:39;46039:10;46051:6;-1:-1:-1;;;;;46051:19:4;;:21;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;46051:21:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;46051:21:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46051:21:4;46034:4;:39::i;:::-;46013:60;;46106:7;46091:9;46101:1;46091:12;;;;;;;;;;;;;:22;;;;46146:27;46151:12;46165:7;46146:4;:27::i;:::-;46131:42;;45864:324;;;-1:-1:-1;45801:3:4;;45760:438;;;-1:-1:-1;46213:6:4;46208:315;46229:11;:18;46225:1;:22;46208:315;;;46268:13;46284:10;46295:1;46284:13;;;;;;;;;;;;;;;;;46327:21;;-1:-1:-1;;;;;46284:13:4;;;;-1:-1:-1;46327:80:4;;46406:1;46327:80;;;46355:48;46360:8;;46370:32;46375:9;46385:1;46375:12;;;;;;;;;;;;;;46389;46370:4;:32::i;:::-;46355:4;:48::i;:::-;-1:-1:-1;;;;;46421:27:4;;;;;;:10;:27;;;;;;;;;:38;;;46478:34;;;;;;;46311:96;;-1:-1:-1;46421:27:4;;46478:34;;;;;;;;;;;-1:-1:-1;;46249:3:4;;46208:315;;28089:3511;28270:5;28277:4;28283;28300:37;;:::i;:::-;-1:-1:-1;;;;;28497:22:4;;28384:9;28497:22;;;:13;:22;;;;;;;;28472:47;;;;;;;;;;;;;;;;;28384:9;;28472:22;;:47;28497:22;28472:47;;;28497:22;28472:47;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;28472:47:4;;;;;;;;;;;;;;;;-1:-1:-1;28472:47:4;;-1:-1:-1;28534:6:4;;-1:-1:-1;;;;28529:2728:4;28550:6;:13;28546:1;:17;28529:2728;;;28584:12;28599:6;28606:1;28599:9;;;;;;;;;;;;;;28584:24;;28766:5;-1:-1:-1;;;;;28766:24:4;;28791:7;28766:33;;;;;;;;;;;;;-1:-1:-1;;;;;28766:33:4;-1:-1:-1;;;;;28766:33:4;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;28766:33:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;28766:33:4;;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;28766:33:4;;;;;;;;;;;;;;;;;28737:25;;28690:109;28717:18;;;28690:109;;;;28697:18;;;28690:109;;;;28766:33;-1:-1:-1;28817:9:4;;28813:164;;-1:-1:-1;28935:20:4;;-1:-1:-1;28957:1:4;;-1:-1:-1;28957:1:4;;-1:-1:-1;28927:35:4;;-1:-1:-1;;;;;28927:35:4;28813:164;29014:65;;;;;;;;;-1:-1:-1;;;;;29029:23:4;;;-1:-1:-1;29029:23:4;;;:7;:23;;;;;:48;;;29014:65;;28990:21;;;:89;;;;29113:42;;;;;;;-1:-1:-1;;;29128:25:4;29113:42;;29093:17;;;:62;29250:6;;;:32;;-1:-1:-1;;;29250:32:4;;;;;;;;;;;:6;;;:25;;:32;;;;;29014:65;29250:32;;;;;:6;:32;;;5:2:-1;;;;30:1;27;20:12;5:2;29250:32:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;29250:32:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;29250:32:4;29223:24;;;:59;;;29296:100;;-1:-1:-1;29357:17:4;;-1:-1:-1;29376:1:4;;-1:-1:-1;29376:1:4;;-1:-1:-1;29349:32:4;;-1:-1:-1;;;;;29349:32:4;29296:100;29428:41;;;;;;;;;29443:24;;;;29428:41;;29409:16;;;:60;;;29614:21;;;;29637:17;;;;29606:67;;:7;:67::i;:::-;29584:18;;;29577:96;;-1:-1:-1;29699:18:4;29691:4;:26;;;;;;;;;29687:96;;-1:-1:-1;29745:16:4;;-1:-1:-1;29763:1:4;;-1:-1:-1;29763:1:4;;-1:-1:-1;29737:31:4;;-1:-1:-1;;;;;29737:31:4;29687:96;29888:84;29913:4;:18;;;29933:4;:18;;;29953:4;:18;;;29888:24;:84::i;:::-;29859:113;;;-1:-1:-1;29866:18:4;29990:4;:26;;;;;;;;;29986:96;;-1:-1:-1;30044:16:4;;-1:-1:-1;30062:1:4;;-1:-1:-1;30062:1:4;;-1:-1:-1;30036:31:4;;-1:-1:-1;;;;;30036:31:4;29986:96;30199:89;30224:4;:16;;;30242:4;:18;;;30262:4;:25;;;30199:24;:89::i;:::-;30170:25;;;30163:125;;-1:-1:-1;30314:18:4;30306:4;:26;;;;;;;;;30302:96;;-1:-1:-1;30360:16:4;;-1:-1:-1;30378:1:4;;-1:-1:-1;30378:1:4;;-1:-1:-1;30352:31:4;;-1:-1:-1;;;;;30352:31:4;30302:96;30491:12;-1:-1:-1;;;;;30482:21:4;:5;-1:-1:-1;;;;;30482:21:4;;30478:769;;;30664:85;30689:4;:18;;;30709:12;30723:4;:25;;;30664:24;:85::i;:::-;30635:25;;;30628:121;;-1:-1:-1;30779:18:4;30771:4;:26;;;;;;;;;30767:104;;-1:-1:-1;30829:16:4;;-1:-1:-1;30847:1:4;;-1:-1:-1;30847:1:4;;-1:-1:-1;30821:31:4;;-1:-1:-1;;;;;30821:31:4;30767:104;31028:83;31053:4;:16;;;31071:12;31085:4;:25;;;31028:24;:83::i;:::-;30999:25;;;30992:119;;-1:-1:-1;31141:18:4;31133:4;:26;;;;;;;;;31129:104;;-1:-1:-1;31191:16:4;;-1:-1:-1;31209:1:4;;-1:-1:-1;31209:1:4;;-1:-1:-1;31183:31:4;;-1:-1:-1;;;;;31183:31:4;31129:104;-1:-1:-1;28565:3:4;;28529:2728;;;-1:-1:-1;31363:25:4;;;;31342:18;;:46;31338:256;;;-1:-1:-1;;;31449:25:4;;;;31428:18;;31412:14;;-1:-1:-1;31428:46:4;;-1:-1:-1;31412:14:4;;-1:-1:-1;31404:74:4;;31338:256;-1:-1:-1;;31564:18:4;;31536:25;;;;;31517:14;;-1:-1:-1;31517:14:4;;-1:-1:-1;31536:46:4;;;;;-1:-1:-1;31509:74:4;;-1:-1:-1;31509:74:4;46682:1030;-1:-1:-1;;;;;46786:23:4;;46748:35;46786:23;;;:15;:23;;;;;;;;46838:10;:18;;;;;;46786:23;;46885:16;:14;:16::i;:::-;46953:17;;46866:35;;-1:-1:-1;46911:16:4;;46930:42;;46866:35;;-1:-1:-1;;;46953:17:4;;;;46930:4;:42::i;:::-;46911:61;;47000:1;46986:11;:15;:34;;;;;47019:1;47005:11;:15;46986:34;46982:724;;;47036:17;47063:6;-1:-1:-1;;;;;47056:26:4;;:28;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47056:28:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;47056:28:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47056:28:4;;-1:-1:-1;47098:16:4;47117:30;47122:11;47135;47117:4;:30::i;:::-;47098:49;;47161:19;;:::i;:::-;47198:1;47183:12;:16;:78;;47240:21;;;;;;;;47258:1;47240:21;;;47183:78;;;47202:35;47211:11;47224:12;47202:8;:35::i;:::-;47161:100;;47275:19;;:::i;:::-;47302:37;;;;;;;;;47320:17;;-1:-1:-1;;;;;47320:17:4;47302:37;;47297:50;;47341:5;47297:4;:50::i;:::-;47275:72;;47387:185;;;;;;;;47428:53;47436:5;:14;;;47428:53;;;;;;;;;;;;;;;;;:7;:53::i;:::-;-1:-1:-1;;;;;47387:185:4;;;;;47506:51;47513:11;47506:51;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;47506:51:4;;;:6;:51::i;:::-;47387:185;;;;;;;-1:-1:-1;;;;;47361:23:4;;;;;;:15;:23;;;;;;;;:211;;;;;;;;;;;;-1:-1:-1;;;47361:211:4;-1:-1:-1;;;;;47361:211:4;;;-1:-1:-1;;;;;;47361:211:4;;;;;;;;;;;;;;-1:-1:-1;46982:724:4;;-1:-1:-1;;;46982:724:4;;47593:15;;47589:117;;47644:51;47651:11;47644:51;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;47644:51:4;;;:6;:51::i;:::-;47624:71;;;;;;;-1:-1:-1;;;47624:71:4;-1:-1:-1;;;;;47624:71:4;;;;;;46682:1030;;;;;:::o;49200:1036::-;-1:-1:-1;;;;;49343:23:4;;49305:35;49343:23;;;:15;:23;;;;;49376:25;;:::i;:::-;-1:-1:-1;49404:37:4;;;;;;;;;49422:17;;-1:-1:-1;;;;;49422:17:4;49404:37;;49451:27;;:::i;:::-;-1:-1:-1;49481:55:4;;;;;;;;;-1:-1:-1;;;;;49499:25:4;;;-1:-1:-1;49499:25:4;;;:17;:25;;;;;:35;;;;;;;;;;;;;;49481:55;;49584:20;;49546:35;;;;;;:58;;;;49619:22;;:27;:55;;;;-1:-1:-1;49650:20:4;;:24;;49619:55;49615:127;;;2884:4;49690:41;;49615:127;49752:24;;:::i;:::-;49779:32;49784:11;49797:13;49779:4;:32::i;:::-;49752:59;;49821:19;49850:6;-1:-1:-1;;;;;49843:24:4;;49868:8;49843:34;;;;;;;;;;;;;-1:-1:-1;;;;;49843:34:4;-1:-1:-1;;;;;49843:34:4;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49843:34:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49843:34:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;49843:34:4;;-1:-1:-1;49887:18:4;49908:32;49843:34;49929:10;49908:4;:32::i;:::-;-1:-1:-1;;;;;49978:21:4;;49950:20;49978:21;;;:11;:21;;;;;;49887:53;;-1:-1:-1;49950:20:4;49973:42;;49887:53;49973:4;:42::i;:::-;49950:65;;50049:79;50062:8;50072:15;50089:13;:38;;2774:8;50089:38;;50049:79;-1:-1:-1;;;;;50025:21:4;;;;;;;:11;:21;;;;;;;;;:103;;;;50208:20;;50143:86;;;;;;;;;;;50025:21;;50143:86;;;;;;;;;;;;;;;49200:1036;;;;;;;;;;:::o;26113:185::-;26190:5;26197:4;26203;26226:65;26266:7;26282:1;26286;26289;26226:39;:65::i;:::-;26219:72;;;;;;26113:185;;;;;:::o;2536:306:10:-;2613:9;2624:4;2641:13;2656:18;;:::i;:::-;2678:20;2688:1;2691:6;2678:9;:20::i;:::-;2640:58;;-1:-1:-1;2640:58:10;-1:-1:-1;2719:18:10;2712:3;:25;;;;;;;;;2708:71;;-1:-1:-1;2761:3:10;-1:-1:-1;2766:1:10;;-1:-1:-1;2753:15:10;;2708:71;2797:18;2817:17;2826:7;2817:8;:17::i;:::-;2789:46;;;;;;2536:306;;;;;;:::o;44778:146:4:-;44832:4;44869:5;;-1:-1:-1;;;;;44869:5:4;44855:10;:19;;:62;;-1:-1:-1;44892:25:4;;-1:-1:-1;;;;;44892:25:4;44878:10;:39;44855:62;44848:69;;44778:146;:::o;41607:245::-;41675:6;41670:135;41691:10;:17;41687:21;;41670:135;;;41762:6;-1:-1:-1;;;;;41738:31:4;:10;41749:1;41738:13;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;41738:13:4;:31;;41730:64;;;;;-1:-1:-1;;;41730:64:4;;;;;;;;;;;;-1:-1:-1;;;41730:64:4;;;;;;;;;;;;;;;41710:4;;41670:135;;;-1:-1:-1;41814:10:4;27::-1;;39:1;23:18;;45:23;;-1:-1;41814:31:4;;;;;;;;-1:-1:-1;;;;;;41814:31:4;-1:-1:-1;;;;;41814:31:4;;;;;;;;;;41607:245::o;11661:851::-;-1:-1:-1;;;;;11789:15:4;;11768:4;11789:15;;;:7;:15;;;;;:24;;;11784:92;;11841:23;11836:29;;11784:92;-1:-1:-1;;;;;11984:15:4;;;;;;;:7;:15;;;;;;;;:43;;;;;:33;;;;:43;;;;;;11979:102;;12055:14;12050:20;;11979:102;12183:9;12196:14;12214:82;12254:8;12271:6;12280:12;12294:1;12214:39;:82::i;:::-;12182:114;;-1:-1:-1;12182:114:4;;-1:-1:-1;12317:14:4;;-1:-1:-1;12310:3:4;:21;;;;;;;;;12306:68;;12359:3;12354:9;;;;;;;12306:68;12387:13;;12383:85;;12428:28;12423:34;;5389:1144;-1:-1:-1;;;;;5516:24:4;;5469:5;5516:24;;;:7;:24;;;;;5556:21;;;;5551:132;;5649:23;5642:30;;;;;5551:132;-1:-1:-1;;;;;5697:40:4;;;;;;:30;;;:40;;;;;;;;:48;;:40;:48;5693:130;;;5798:14;5791:21;;;;;5693:130;5871:9;;-1:-1:-1;;;;;5837:23:4;;;;;;:13;:23;;;;;:30;:43;5833:140;;5941:21;5934:28;;;;;5833:140;-1:-1:-1;;;;;6354:40:4;;;;;;;:30;;;:40;;;;;;;;:47;;-1:-1:-1;;6354:47:4;6397:4;6354:47;;;;;;6411:13;:23;;;;;27:10:-1;;23:18;;;45:23;;6411:36:4;;;;;;;;;;;;;;-1:-1:-1;;;;;;6411:36:4;;;;;;;6463:31;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6512:14:4;;5389:1144;-1:-1:-1;;;5389:1144:4:o;6180:148:10:-;6235:9;6246:10;;:::i;:::-;6275:46;6282:18;;;;;;;;6297:1;6282:18;;;6302;;;;;;;;6317:1;6302:18;;;6275:6;:46::i;:::-;6268:53;;;;6180:148;;;;;:::o;6932:144::-;6999:9;7010:10;;:::i;:::-;7046;;7058;;7039:30;;7046:10;7039:6;:30::i;55298:922:4:-;-1:-1:-1;;;;;55389:15:4;;55365:21;55389:15;;;:7;:15;;;;;55422;;;;:23;;:15;:23;55414:61;;;;;-1:-1:-1;;;55414:61:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;55493:15;;;;;;:24;55485:62;;;;;-1:-1:-1;;;55485:62:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;55558:15;;;:22;;-1:-1:-1;;55558:22:4;55576:4;55558:22;;;;;;55595:34;;;-1:-1:-1;;;;;55595:34:4;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;55644:23:4;;;;;;:15;:23;;;;;:29;-1:-1:-1;;;;;55644:29:4;:34;:72;;;;-1:-1:-1;;;;;;55682:23:4;;;;;;:15;:23;;;;;:29;-1:-1:-1;;;55682:29:4;;;;:34;55644:72;55640:282;;;55758:153;;;;;;;;2884:4;-1:-1:-1;;;;;55758:153:4;;;;;55840:56;55847:16;:14;:16::i;:::-;55840:56;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;55840:56:4;;;:6;:56::i;:::-;55758:153;;;;;;;-1:-1:-1;;;;;55732:23:4;;;;;;:15;:23;;;;;;;;:179;;;;;;;;;;;;-1:-1:-1;;;55732:179:4;-1:-1:-1;;;;;55732:179:4;;;-1:-1:-1;;;;;;55732:179:4;;;;;;;;;;;;;;55640:282;-1:-1:-1;;;;;55936:23:4;;;;;;:15;:23;;;;;:29;-1:-1:-1;;;;;55936:29:4;:34;:72;;;;-1:-1:-1;;;;;;55974:23:4;;;;;;:15;:23;;;;;:29;-1:-1:-1;;;55974:29:4;;;;:34;55936:72;55932:282;;;56050:153;;;;;;;;2884:4;-1:-1:-1;;;;;56050:153:4;;;;;56132:56;56139:16;:14;:16::i;56132:56::-;56050:153;;;;;;;-1:-1:-1;;;;;56024:23:4;;;;;;:15;:23;;;;;;;;:179;;;;;;;;;;;;-1:-1:-1;;;56024:179:4;-1:-1:-1;;;;;56024:179:4;;;-1:-1:-1;;;;;;56024:179:4;;;;;;;;;;;;;;55298:922;;:::o;2122:183:9:-;2207:4;2228:43;2241:3;2236:9;;;;;;;;2252:4;2247:10;;;;;;;;2228:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;2294:3;2289:9;;;;;;;9528:118:10;9581:4;9604:35;9609:1;9612;9604:35;;;;;;;;;;;;;-1:-1:-1;;;9604:35:10;;;:4;:35::i;11373:124::-;11432:4;11455:35;11460:17;11465:1;447:4;11460;:17::i;:::-;11479:10;;11455:4;:35::i;10693:120::-;10746:4;10769:37;10774:1;10777;10769:37;;;;;;;;;;;;;;;;;:4;:37::i;12245:145::-;12302:13;;:::i;:::-;12334:49;;;;;;;;12352:29;12357:20;12362:1;485:4;12357;:20::i;:::-;12379:1;12352:4;:29::i;:::-;12334:49;;12327:56;12245:145;-1:-1:-1;;;12245:145:10:o;8747:158::-;8818:13;;:::i;:::-;8850:48;;;;;;;;8868:28;8873:1;:10;;;8885:1;:10;;;8868:4;:28::i;8263:162::-;8339:7;8378:12;-1:-1:-1;;;8366:10:10;;8358:33;;;;-1:-1:-1;;;8358:33:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;8358:33:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8416:1:10;;8263:162;-1:-1:-1;;8263:162:10:o;8431:158::-;8506:6;8543:12;-1:-1:-1;;;8532:9:10;;8524:32;;;;-1:-1:-1;;;8524:32:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;9364:158:10;9435:13;;:::i;:::-;9467:48;;;;;;;;9485:28;9490:1;:10;;;9502:1;:10;;;9485:4;:28::i;10562:125::-;10624:4;485;10647:19;10652:1;10655;:10;;;10647:4;:19::i;:::-;:33;;;;;;;10562:125;-1:-1:-1;;;10562:125:10:o;8911:114::-;8964:4;8987:31;8992:1;8995;8987:31;;;;;;;;;;;;;-1:-1:-1;;;8987:31:10;;;:4;:31::i;52007:448:4:-;52095:4;52130:9;52115:11;:24;;:43;;;;;52157:1;52143:11;:15;52115:43;52111:310;;;52174:9;52191:16;:14;:16::i;:::-;52243:29;;;-1:-1:-1;;;52243:29:4;;52266:4;52243:29;;;;;;52174:34;;-1:-1:-1;52222:18:4;;-1:-1:-1;;;;;52243:14:4;;;;;:29;;;;;;;;;;;;;;:14;:29;;;5:2:-1;;;;30:1;27;20:12;5:2;52243:29:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;52243:29:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;52243:29:4;;-1:-1:-1;52290:28:4;;;52286:125;;52338:4;-1:-1:-1;;;;;52338:13:4;;52352:4;52358:11;52338:32;;;;;;;;;;;;;-1:-1:-1;;;;;52338:32:4;-1:-1:-1;;;;;52338:32:4;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;52338:32:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;52338:32:4;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;52395:1:4;;-1:-1:-1;52388:8:4;;-1:-1:-1;;;52388:8:4;52286:125;52111:310;;;-1:-1:-1;52437:11:4;;52007:448;-1:-1:-1;;52007:448:4:o;9976:131:10:-;10035:10;;:::i;:::-;10064:36;;;;;;;;10079:19;10084:1;:10;;;10096:1;10079:4;:19::i;11068:162::-;11133:10;;:::i;:::-;11162:61;;;;;;;;11177:44;11182:26;11187:1;:10;;;447:4;11182;:26::i;:::-;11210:10;;11177:4;:44::i;10113:119::-;10172:4;447;10195:19;10200:1;10203;:10;;;10195:4;:19::i;6422:278::-;6504:9;6515:10;;:::i;:::-;6538:13;6553;;:::i;:::-;6570:12;6577:1;6580;6570:6;:12::i;:::-;6537:45;;-1:-1:-1;6537:45:10;-1:-1:-1;6603:18:10;6596:3;:25;;;;;;;;;6592:72;;6645:3;;-1:-1:-1;6650:2:10;-1:-1:-1;6637:16:10;;6592:72;6680:13;6687:2;6691:1;6680:6;:13::i;:::-;6673:20;;;;;;6422:278;;;;;;:::o;2982:321::-;3079:9;3090:4;3107:13;3122:18;;:::i;:::-;3144:20;3154:1;3157:6;3144:9;:20::i;:::-;3106:58;;-1:-1:-1;3106:58:10;-1:-1:-1;3185:18:10;3178:3;:25;;;;;;;;;3174:71;;-1:-1:-1;3227:3:10;-1:-1:-1;3232:1:10;;-1:-1:-1;3219:15:10;;3174:71;3262:34;3270:17;3279:7;3270:8;:17::i;:::-;3289:6;3262:7;:34::i;2082:346::-;2151:9;2162:10;;:::i;:::-;2185:14;2201:19;2224:27;2232:1;:10;;;2244:6;2224:7;:27::i;:::-;2184:67;;-1:-1:-1;2184:67:10;-1:-1:-1;2273:18:10;2265:4;:26;;;;;;;;;2261:90;;-1:-1:-1;2321:18:10;;;;;;;;;-1:-1:-1;2321:18:10;;2315:4;;-1:-1:-1;2321:18:10;-1:-1:-1;2307:33:10;;2261:90;2389:31;;;;;;;;;;;;-1:-1:-1;;2389:31:10;;-1:-1:-1;2082:346:10;-1:-1:-1;;;;2082:346:10:o;7228:210::-;7408:12;447:4;7408:23;;;7228:210::o;4950:1116::-;5017:9;5028:10;;:::i;:::-;5052:14;5068:24;5096:31;5104:1;:10;;;5116:1;:10;;;5096:7;:31::i;:::-;5051:76;;-1:-1:-1;5051:76:10;-1:-1:-1;5149:18:10;5141:4;:26;;;;;;;;;5137:90;;-1:-1:-1;5197:18:10;;;;;;;;;-1:-1:-1;5197:18:10;;5191:4;;-1:-1:-1;5197:18:10;-1:-1:-1;5183:33:10;;5137:90;5539:14;;5596:42;524:10;5618:19;5596:7;:42::i;:::-;5538:100;;-1:-1:-1;5538:100:10;-1:-1:-1;5660:18:10;5652:4;:26;;;;;;;;;5648:90;;-1:-1:-1;5708:18:10;;;;;;;;;-1:-1:-1;5708:18:10;;5702:4;;-1:-1:-1;5708:18:10;-1:-1:-1;5694:33:10;;-1:-1:-1;;5694:33:10;5648:90;5749:14;5765:12;5781:51;5789:32;447:4;5781:7;:51::i;:::-;5748:84;;-1:-1:-1;5748:84:10;-1:-1:-1;5976:18:10;5968:4;:26;;;;;;;;;5961:34;;;;6034:24;;;;;;;;;;;;-1:-1:-1;;6034:24:10;;-1:-1:-1;4950:1116:10;-1:-1:-1;;;;;;;;4950:1116:10:o;876:503::-;937:9;948:10;;:::i;:::-;971:14;987:20;1011:22;1019:3;447:4;1011:7;:22::i;:::-;970:63;;-1:-1:-1;970:63:10;-1:-1:-1;1055:18:10;1047:4;:26;;;;;;;;;1043:90;;-1:-1:-1;1103:18:10;;;;;;;;;-1:-1:-1;1103:18:10;;1097:4;;-1:-1:-1;1103:18:10;-1:-1:-1;1089:33:10;;1043:90;1144:14;1160:13;1177:31;1185:15;1202:5;1177:7;:31::i;:::-;1143:65;;-1:-1:-1;1143:65:10;-1:-1:-1;1230:18:10;1222:4;:26;;;;;;;;;1218:90;;-1:-1:-1;1278:18:10;;;;;;;;;-1:-1:-1;1278:18:10;;1272:4;;-1:-1:-1;1278:18:10;-1:-1:-1;1264:33:10;;-1:-1:-1;;1264:33:10;1218:90;1346:25;;;;;;;;;;;;-1:-1:-1;;1346:25:10;;-1:-1:-1;876:503:10;-1:-1:-1;;;;;;876:503:10:o;9652:155::-;9733:4;9765:12;9757:6;;;;9749:29;;;;-1:-1:-1;;;9749:29:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;9749:29:10;-1:-1:-1;;;9795:5:10;;;9652:155::o;11968:111::-;12021:4;12044:28;12049:1;12052;12044:28;;;;;;;;;;;;;-1:-1:-1;;;12044:28:10;;;:4;:28::i;10819:243::-;10900:4;10920:6;;;:16;;-1:-1:-1;10930:6:10;;10920:16;10916:55;;;-1:-1:-1;10959:1:10;10952:8;;10916:55;10989:5;;;10993:1;10989;:5;:1;11012:5;;;;;:10;11024:12;11004:33;;;;;-1:-1:-1;;;11004:33:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;11004:33:10;-1:-1:-1;11054:1:10;10819:243;-1:-1:-1;;;;10819:243:10:o;9031:175::-;9112:4;9137:5;;;9168:12;9160:6;;;;9152:29;;;;-1:-1:-1;;;9152:29:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;1613:250:2;1669:9;;1705:5;;;1725:6;;;1721:136;;1755:18;;-1:-1:-1;1775:1:2;-1:-1:-1;1747:30:2;;1721:136;-1:-1:-1;1816:26:2;;-1:-1:-1;1844:1:2;;-1:-1:-1;1808:38:2;;543:331;599:9;;630:6;626:67;;-1:-1:-1;660:18:2;;-1:-1:-1;660:18:2;652:30;;626:67;712:5;;;716:1;712;:5;:1;732:5;;;;;:10;728:140;;-1:-1:-1;766:26:2;;-1:-1:-1;794:1:2;;-1:-1:-1;758:38:2;;728:140;835:18;;-1:-1:-1;855:1:2;-1:-1:-1;827:30:2;;964:209;1020:9;;1051:6;1047:75;;-1:-1:-1;1081:26:2;;-1:-1:-1;1109:1:2;1073:38;;1047:75;1140:18;1164:1;1160;:5;;;;;;1132:34;;;;964:209;;;;;:::o;12085:154:10:-;12166:4;12197:12;12190:5;12182:28;;;;-1:-1:-1;;;12182:28:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;12182:28:10;;12231:1;12227;:5;;;;;;;12085:154;-1:-1:-1;;;;12085:154:10:o;326:57050:4:-;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;
Swarm Source
bzzr://6d142c7fa5105ebf9cd213013303ecff3f361f01a4260871e994c09252b6967c
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 27 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.