Compound 代币和价格预言

    contract ComptrollerV6Storage is ComptrollerV5Storage {          // https://compound.finance/governance/comp          /// @notice The rate at which comp is distributed to the corresponding borrow market (per block)          mapping(address => uint) public compBorrowSpeeds;          /// @notice The rate at which comp is distributed to the corresponding supply market (per block)          mapping(address => uint) public compSupplySpeeds;      }  

    function mintAllowed(address cToken, address minter, uint mintAmount) external returns (uint) {          // Keep the flywheel moving          updateCompSupplyIndex(cToken);          distributeSupplierComp(cToken, minter);          return uint(Error.NO_ERROR);      }  

    /**     * @notice Accrue COMP to the market by updating the supply index      * @param cToken The market whose supply index to update      * @dev Index is a cumulative sum of the COMP per cToken accrued.      */      function updateCompSupplyIndex(address cToken) internal {          CompMarketState storage supplyState = compSupplyState[cToken];          uint supplySpeed = compSupplySpeeds[cToken];          uint32 blockNumber = safe32(getBlockNumber(), "block number exceeds 32 bits");          uint deltaBlocks = sub_(uint(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});              supplyState.index = safe224(add_(Double({mantissa: supplyState.index}), ratio).mantissa, "new index exceeds 224 bits");              supplyState.block = blockNumber;          } else if (deltaBlocks > 0) {              supplyState.block = blockNumber;          }      }  

    /**     * @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) internal {          // TODO: Don't distribute supplier COMP if the user is not in the supplier market.          // This check should be as gas efficient as possible as distributeSupplierComp is called in many places.          // - We really don't want to call an external contract as that's quite expensive.          CompMarketState storage supplyState = compSupplyState[cToken];          uint supplyIndex = supplyState.index;          uint supplierIndex = compSupplierIndex[cToken][supplier];          // Update supplier's index to the current index since we are distributing accrued COMP          compSupplierIndex[cToken][supplier] = supplyIndex;          if (supplierIndex == 0 && supplyIndex >= compInitialIndex) {              // Covers the case where users supplied tokens before the market's supply state index was set.              // Rewards the user with COMP accrued from the start of when supplier rewards were first              // set for the market.              supplierIndex = compInitialIndex;          }          // Calculate change in the cumulative sum of the COMP per cToken accrued          Double memory deltaIndex = Double({mantissa: sub_(supplyIndex, supplierIndex)});          uint supplierTokens = CToken(cToken).balanceOf(supplier);          // Calculate COMP accrued: cTokenAmount * accruedPerCToken          uint supplierDelta = mul_(supplierTokens, deltaIndex);          uint supplierAccrued = add_(compAccrued[supplier], supplierDelta);          compAccrued[supplier] = supplierAccrued;          emit DistributedSupplierComp(CToken(cToken), supplier, supplierDelta, supplyIndex);      }  

    /**      * @notice This is called by the reporter whenever a new price is posted on-chain       * @dev called by AccessControlledOffchainAggregator       * @param currentAnswer the price       * @return valid bool       */      function validate(uint256/* previousRoundId */,              int256 /* previousAnswer */,              uint256 /* currentRoundId */,              int256 currentAnswer) external override returns (bool valid) {          // NOTE: We don't do any access control on msg.sender here. The access control is done in getTokenConfigByReporter,          // which will REVERT if an unauthorized address is passed.          TokenConfig memory config = getTokenConfigByReporter(msg.sender);          uint256 reportedPrice = convertReportedPrice(config, currentAnswer);          uint256 anchorPrice = calculateAnchorPriceFromEthPrice(config);          PriceData memory priceData = prices[config.symbolHash];          if (priceData.failoverActive) {              require(anchorPrice < 2**248, "Anchor price too large");              prices[config.symbolHash].price = uint248(anchorPrice);              emit PriceUpdated(config.symbolHash, anchorPrice);          } else if (isWithinAnchor(reportedPrice, anchorPrice)) {              require(reportedPrice < 2**248, "Reported price too large");              prices[config.symbolHash].price = uint248(reportedPrice);              emit PriceUpdated(config.symbolHash, reportedPrice);              valid = true;          } else {              emit PriceGuarded(config.symbolHash, reportedPrice, anchorPrice);          }      }  

/**  * @dev Fetches the current eth/usd price from uniswap, with 6 decimals of precision.   *  Conversion factor is 1e18 for eth/usdc market, since we decode uniswap price statically with 18 decimals.   */  function fetchEthAnchorPrice() internal returns (uint) {      return fetchAnchorPrice(ethHash, getTokenConfigBySymbolHash(ethHash), ethBaseUnit);  }/**  * @dev Fetches the current token/usd price from uniswap, with 6 decimals of precision.   * @param conversionFactor 1e18 if seeking the ETH price, and a 6 decimal ETH-USDC price in the case of other assets   */  function fetchAnchorPrice(bytes32 symbolHash, TokenConfig memory config, uint conversionFactor) internal virtual returns (uint) {      (uint nowCumulativePrice, uint oldCumulativePrice, uint oldTimestamp) = pokeWindowValues(config);    // This should be impossible, but better safe than sorry      require(block.timestamp > oldTimestamp, "now must come after before");      uint timeElapsed = block.timestamp - oldTimestamp;    // Calculate uniswap time-weighted average price      // Underflow is a property of the accumulators: https://uniswap.org/audit.html#orgc9b3190      FixedPoint.uq112x112 memory priceAverage = FixedPoint.uq112x112(uint224((nowCumulativePrice - oldCumulativePrice) / timeElapsed));      uint rawUniswapPriceMantissa = priceAverage.decode112with18();      uint unscaledPriceMantissa = mul(rawUniswapPriceMantissa, conversionFactor);      uint anchorPrice;    // Adjust rawUniswapPrice according to the units of the non-ETH asset      // In the case of ETH, we would have to scale by 1e6 / USDC_UNITS, but since baseUnit2 is 1e6 (USDC), it cancels    // In the case of non-ETH tokens      // a. pokeWindowValues already handled uniswap reversed cases, so priceAverage will always be Token/ETH TWAP price.      // b. conversionFactor = ETH price * 1e6      // unscaledPriceMantissa = priceAverage(token/ETH TWAP price) * expScale * conversionFactor      // so ->      // anchorPrice = priceAverage * tokenBaseUnit / ethBaseUnit * ETH_price * 1e6      //             = priceAverage * conversionFactor * tokenBaseUnit / ethBaseUnit      //             = unscaledPriceMantissa / expScale * tokenBaseUnit / ethBaseUnit      anchorPrice = mul(unscaledPriceMantissa, config.baseUnit) / ethBaseUnit / expScale;    emit AnchorPriceUpdated(symbolHash, anchorPrice, oldTimestamp, block.timestamp);    return anchorPrice;  }

接下来，简单看下 Uniswap 询价逻辑首先通过 `fetchEthAnchorPrice()` 从交易对 USDC-WETH[15] 获得按 USDC 计价 (单位 ) 的 WETH 的价格，比如为 4351156768然后通过 `fetchAnchorPrice()` 从交易对 DAI-WETH[16] 获得按 WETH 计价 (单位 ) 的 DAI 的价格，比如为 230097482692738上面两个价格相乘，得到 1001190219118269813150784最后，转换单位，得到按 USDC 计价的 DAI 价格，即上面的 1001190### 代理`UniswapAnchoredView` 自身可能升级，因此会存在新旧合约实例；升级过程中，我们必须保证两个合约的价格预言同步，且经过一段时间验证后，经由社区投票，用新合约代替旧合约，以此完成升级然而，依据 Chainlink 的设计，聚合器只能向一个合约地址发送喂价为了解决这个问题，在 Chainlink 聚合器与 Compound 之间，引入了一层代理合约 `ValidatorProxy`，它将聚合器的报价同时转发给新旧 `UniswapAnchoredView` 合约由于采用的是 报价 (push) 而非 询价 (pull) 的方式，更新价格的成本由 Chainlink 承担，因此 Compound 用户无须额外支付代理层带来的 gas审计报告见 Sigma Prime: Chainlink ValidatorProxy Security Assessment Report[17]代码在另一个仓库中 : smartcontractkit/chainlink[18]

function validate(      uint256 previousRoundId,      int256 previousAnswer,      uint256 currentRoundId,      int256 currentAnswer  ) external override returns (bool)  {      // Send the validate call to the current validator      ValidatorConfiguration memory currentValidator = s_currentValidator;      address currentValidatorAddress = address(currentValidator.target);      require(currentValidatorAddress != address(0), "No validator set");      currentValidatorAddress.call(          abi.encodeWithSelector(          AggregatorValidatorInterface.validate.selector,          previousRoundId,          previousAnswer,          currentRoundId,          currentAnswer          )      );    // If there is a new proposed validator, send the validate call to that validator also      if (currentValidator.hasNewProposal) {          address(s_proposedValidator).call(          abi.encodeWithSelector(              AggregatorValidatorInterface.validate.selector,              previousRoundId,              previousAnswer,              currentRoundId,              currentAnswer          )          );      }      return true;  }