Compound 的潜在风险和改进

    // compound-protocol/contracts/Comptroller.sol      function borrowAllowed(address cToken, address borrower, uint borrowAmount) external returns (uint) {          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]);          }      }      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;          }          // 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;      }  

    // compound-protocol/contracts/Comptroller.sol      function getHypotheticalAccountLiquidityInternal(          address account,          CToken cTokenModify,          uint redeemTokens,          uint borrowAmount) internal view returns (Error, uint, uint) {          // For each asset the account is in          CToken[] memory assets = accountAssets[account];          for (uint i = 0; i < assets.length; i  ) {              CToken asset = assets[i];              // Too Long Not Listed.              // ...          }      }  

    // compound-protocol/contracts/CToken.sol      function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, CTokenInterface cTokenCollateral) internal returns (uint, uint) {          /* 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);          }          /* 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);          }          return (uint(Error.NO_ERROR), actualRepayAmount);      }  

    // https://github.com/smartcontractkit/open-oracle/blob/master/contracts/Uniswap/UniswapAnchoredView.sol      function priceInternal(TokenConfig memory config) internal view returns (uint) {          if (config.priceSource == PriceSource.REPORTER) return prices[config.symbolHash].price;          // config.fixedPrice holds a fixed-point number with scaling factor 10**6 for FIXED_USD          if (config.priceSource == PriceSource.FIXED_USD) return config.fixedPrice;          if (config.priceSource == PriceSource.FIXED_ETH) {              uint usdPerEth = prices[ethHash].price;              require(usdPerEth > 0, "ETH price not set, cannot convert to dollars");              // config.fixedPrice holds a fixed-point number with scaling factor 10**18 for FIXED_ETH              return mul(usdPerEth, config.fixedPrice) / ethBaseUnit;          }      }  

    // compound-protocol/contracts/Comptroller.sol      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;          // For each asset the account is in          CToken[] memory assets = accountAssets[account];          for (uint i = 0; i < assets.length; i  ) {              CToken asset = assets[i];              vars.collateralFactor = Exp({mantissa: markets[address(asset)].collateralFactorMantissa});              // Pre-compute a conversion factor from tokens -> ether (normalized price value)              vars.tokensToDenom = mul_(mul_(vars.collateralFactor, vars.exchangeRate), vars.oraclePrice);              // sumCollateral  = tokensToDenom * cTokenBalance              vars.sumCollateral = mul_ScalarTruncateAddUInt(vars.tokensToDenom, vars.cTokenBalance, vars.sumCollateral);          }      }