Comparar texto

Encontre a diferença entre dois arquivos de texto

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Ferramentas

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

aave-oracle

Created 2 years agoDiff never expires

Lines
Total
Removed

Words
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

122 lines

Lines
Total
Added

Words
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

128 lines

// SPDX-License-Identifier: agpl-3.0

pragma solidity 0.6.12;

import {Ownable} from '../dependencies/openzeppelin/contracts/Ownable.sol';

import {IERC20} from '../dependencies/openzeppelin/contracts/IERC20.sol';

import {IPriceOracleGetter} from '../interfaces/IPriceOracleGetter.sol';

import {IChainlinkAggregator} from '../interfaces/IChainlinkAggregator.sol';

import {SafeERC20} from '../dependencies/openzeppelin/contracts/SafeERC20.sol';

/// @title AaveOracle

/// @author Aave

/// @notice Proxy smart contract to get the price of an asset from a price source, with Chainlink Aggregator

/// smart contracts as primary option

/// - If the returned price by a Chainlink aggregator is <= 0, the call is forwarded to a fallbackOracle

/// - Owned by the Aave governance system, allowed to add sources for assets, replace them

/// and change the fallbackOracle

contract AaveOracle is IPriceOracleGetter, Ownable {

using SafeERC20 for IERC20;

event WethSet(address indexed weth);

event BaseCurrencySet(address indexed baseCurrency, uint256 baseCurrencyUnit);

event AssetSourceUpdated(address indexed asset, address indexed source);

event FallbackOracleUpdated(address indexed fallbackOracle);

mapping(address => IChainlinkAggregator) private assetsSources;

IPriceOracleGetter private _fallbackOracle;

address public immutable WETH;

address public immutable BASE_CURRENCY;

uint256 public immutable BASE_CURRENCY_UNIT;

/// @notice Constructor

/// @param assets The addresses of the assets

/// @param sources The address of the source of each asset

/// @param fallbackOracle The address of the fallback oracle to use if the data of an

/// aggregator is not consistent

/// @param baseCurrency the base currency used for the price quotes. If USD is used, base currency is 0x0

/// @param baseCurrencyUnit the unit of the base currency

constructor(

address[] memory assets,

address[] memory sources,

address fallbackOracle,

address weth

address baseCurrency,

uint256 baseCurrencyUnit

) public {

_setFallbackOracle(fallbackOracle);

_setAssetsSources(assets, sources);

WETH = weth;

BASE_CURRENCY = baseCurrency;

emit WethSet(weth);

BASE_CURRENCY_UNIT = baseCurrencyUnit;

emit BaseCurrencySet(baseCurrency, baseCurrencyUnit);

}

/// @notice External function called by the Aave governance to set or replace sources of assets

/// @param assets The addresses of the assets

/// @param sources The address of the source of each asset

function setAssetSources(address[] calldata assets, address[] calldata sources)

external

onlyOwner

{

_setAssetsSources(assets, sources);

}

/// @notice Sets the fallbackOracle

/// - Callable only by the Aave governance

/// @param fallbackOracle The address of the fallbackOracle

function setFallbackOracle(address fallbackOracle) external onlyOwner {

_setFallbackOracle(fallbackOracle);

}

/// @notice Internal function to set the sources for each asset

/// @param assets The addresses of the assets

/// @param sources The address of the source of each asset

function _setAssetsSources(address[] memory assets, address[] memory sources) internal {

require(assets.length == sources.length, 'INCONSISTENT_PARAMS_LENGTH');

for (uint256 i = 0; i < assets.length; i++) {

assetsSources[assets[i]] = IChainlinkAggregator(sources[i]);

emit AssetSourceUpdated(assets[i], sources[i]);

}

/// @notice Internal function to set the fallbackOracle

/// @param fallbackOracle The address of the fallbackOracle

function _setFallbackOracle(address fallbackOracle) internal {

_fallbackOracle = IPriceOracleGetter(fallbackOracle);

emit FallbackOracleUpdated(fallbackOracle);

}

/// @notice Gets an asset price by address

/// @param asset The asset address

function getAssetPrice(address asset) public override view returns (uint256) {

function getAssetPrice(address asset) public view override returns (uint256) {

IChainlinkAggregator source = assetsSources[asset];

if (asset == WETH) {

if (asset == BASE_CURRENCY) {

return 1 ether;

return BASE_CURRENCY_UNIT;

} else if (address(source) == address(0)) {

return _fallbackOracle.getAssetPrice(asset);

} else {

int256 price = IChainlinkAggregator(source).latestAnswer();

if (price > 0) {

return uint256(price);

} else {

return _fallbackOracle.getAssetPrice(asset);

}

/// @notice Gets a list of prices from a list of assets addresses

/// @param assets The list of assets addresses

function getAssetsPrices(address[] calldata assets) external view returns (uint256[] memory) {

uint256[] memory prices = new uint256[](assets.length);

for (uint256 i = 0; i < assets.length; i++) {

prices[i] = getAssetPrice(assets[i]);

}

return prices;

}

/// @notice Gets the address of the source for an asset address

/// @param asset The address of the asset

/// @return address The address of the source

function getSourceOfAsset(address asset) external view returns (address) {

return address(assetsSources[asset]);

}

/// @notice Gets the address of the fallback oracle

/// @return address The addres of the fallback oracle

function getFallbackOracle() external view returns (address) {

return address(_fallbackOracle);

}

Diffs salvos

Texto original

Abrir arquivo

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;

import {Ownable} from '../dependencies/openzeppelin/contracts/Ownable.sol';
import {IERC20} from '../dependencies/openzeppelin/contracts/IERC20.sol';

import {IPriceOracleGetter} from '../interfaces/IPriceOracleGetter.sol';
import {IChainlinkAggregator} from '../interfaces/IChainlinkAggregator.sol';
import {SafeERC20} from '../dependencies/openzeppelin/contracts/SafeERC20.sol';

/// @title AaveOracle
/// @author Aave
/// @notice Proxy smart contract to get the price of an asset from a price source, with Chainlink Aggregator
///         smart contracts as primary option
/// - If the returned price by a Chainlink aggregator is <= 0, the call is forwarded to a fallbackOracle
/// - Owned by the Aave governance system, allowed to add sources for assets, replace them
///   and change the fallbackOracle
contract AaveOracle is IPriceOracleGetter, Ownable {
  using SafeERC20 for IERC20;

event WethSet(address indexed weth);
  event AssetSourceUpdated(address indexed asset, address indexed source);
  event FallbackOracleUpdated(address indexed fallbackOracle);

mapping(address => IChainlinkAggregator) private assetsSources;
  IPriceOracleGetter private _fallbackOracle;
  address public immutable WETH;

/// @notice Constructor
  /// @param assets The addresses of the assets
  /// @param sources The address of the source of each asset
  /// @param fallbackOracle The address of the fallback oracle to use if the data of an
  ///        aggregator is not consistent
  constructor(
    address[] memory assets,
    address[] memory sources,
    address fallbackOracle,
    address weth
  ) public {
    _setFallbackOracle(fallbackOracle);
    _setAssetsSources(assets, sources);
    WETH = weth;
    emit WethSet(weth);
  }

/// @notice External function called by the Aave governance to set or replace sources of assets
  /// @param assets The addresses of the assets
  /// @param sources The address of the source of each asset
  function setAssetSources(address[] calldata assets, address[] calldata sources)
    external
    onlyOwner
  {
    _setAssetsSources(assets, sources);
  }

/// @notice Sets the fallbackOracle
  /// - Callable only by the Aave governance
  /// @param fallbackOracle The address of the fallbackOracle
  function setFallbackOracle(address fallbackOracle) external onlyOwner {
    _setFallbackOracle(fallbackOracle);
  }

/// @notice Internal function to set the sources for each asset
  /// @param assets The addresses of the assets
  /// @param sources The address of the source of each asset
  function _setAssetsSources(address[] memory assets, address[] memory sources) internal {
    require(assets.length == sources.length, 'INCONSISTENT_PARAMS_LENGTH');
    for (uint256 i = 0; i < assets.length; i++) {
      assetsSources[assets[i]] = IChainlinkAggregator(sources[i]);
      emit AssetSourceUpdated(assets[i], sources[i]);
    }
  }

/// @notice Internal function to set the fallbackOracle
  /// @param fallbackOracle The address of the fallbackOracle
  function _setFallbackOracle(address fallbackOracle) internal {
    _fallbackOracle = IPriceOracleGetter(fallbackOracle);
    emit FallbackOracleUpdated(fallbackOracle);
  }

/// @notice Gets an asset price by address
  /// @param asset The asset address
  function getAssetPrice(address asset) public override view returns (uint256) {
    IChainlinkAggregator source = assetsSources[asset];

if (asset == WETH) {
      return 1 ether;
    } else if (address(source) == address(0)) {
      return _fallbackOracle.getAssetPrice(asset);
    } else {
      int256 price = IChainlinkAggregator(source).latestAnswer();
      if (price > 0) {
        return uint256(price);
      } else {
        return _fallbackOracle.getAssetPrice(asset);
      }
    }
  }

/// @notice Gets a list of prices from a list of assets addresses
  /// @param assets The list of assets addresses
  function getAssetsPrices(address[] calldata assets) external view returns (uint256[] memory) {
    uint256[] memory prices = new uint256[](assets.length);
    for (uint256 i = 0; i < assets.length; i++) {
      prices[i] = getAssetPrice(assets[i]);
    }
    return prices;
  }

/// @notice Gets the address of the source for an asset address
  /// @param asset The address of the asset
  /// @return address The address of the source
  function getSourceOfAsset(address asset) external view returns (address) {
    return address(assetsSources[asset]);
  }

/// @notice Gets the address of the fallback oracle
  /// @return address The addres of the fallback oracle
  function getFallbackOracle() external view returns (address) {
    return address(_fallbackOracle);
  }
}

Texto alterado

Abrir arquivo

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.12;

import {Ownable} from '../dependencies/openzeppelin/contracts/Ownable.sol';
import {IERC20} from '../dependencies/openzeppelin/contracts/IERC20.sol';

event BaseCurrencySet(address indexed baseCurrency, uint256 baseCurrencyUnit);
  event AssetSourceUpdated(address indexed asset, address indexed source);
  event FallbackOracleUpdated(address indexed fallbackOracle);

mapping(address => IChainlinkAggregator) private assetsSources;
  IPriceOracleGetter private _fallbackOracle;
  address public immutable BASE_CURRENCY;
  uint256 public immutable BASE_CURRENCY_UNIT;

/// @notice Constructor
  /// @param assets The addresses of the assets
  /// @param sources The address of the source of each asset
  /// @param fallbackOracle The address of the fallback oracle to use if the data of an
  ///        aggregator is not consistent
  /// @param baseCurrency the base currency used for the price quotes. If USD is used, base currency is 0x0
  /// @param baseCurrencyUnit the unit of the base currency
  constructor(
    address[] memory assets,
    address[] memory sources,
    address fallbackOracle,
    address baseCurrency,
    uint256 baseCurrencyUnit
  ) public {
    _setFallbackOracle(fallbackOracle);
    _setAssetsSources(assets, sources);
    BASE_CURRENCY = baseCurrency;
    BASE_CURRENCY_UNIT = baseCurrencyUnit;
    emit BaseCurrencySet(baseCurrency, baseCurrencyUnit);
  }

/// @notice Gets an asset price by address
  /// @param asset The asset address
  function getAssetPrice(address asset) public view override returns (uint256) {
    IChainlinkAggregator source = assetsSources[asset];

if (asset == BASE_CURRENCY) {
      return BASE_CURRENCY_UNIT;
    } else if (address(source) == address(0)) {
      return _fallbackOracle.getAssetPrice(asset);
    } else {
      int256 price = IChainlinkAggregator(source).latestAnswer();
      if (price > 0) {
        return uint256(price);
      } else {
        return _fallbackOracle.getAssetPrice(asset);
      }
    }
  }