Comparar texto

Encuentra la diferencia entre dos archivos de texto

Visualización

Vista

Editor liveOcultar espacios en blancoOcultar sin cambiosSin ajuste de línea

Nivel de detalle

Sintaxis

Procesamiento

Diffchecker Desktop La forma más segura de usar Diffchecker. ¡Obtén la app de Diffchecker Desktop: tus diffs nunca salen de tu computadora!Obtener Desktop

Curve oracles

Creado hace 5 añosEl diff nunca expira

21 eliminaciones

Líneas
Total
Eliminado

Caracteres
Total
Eliminado

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

99 líneas

19 adiciones

Líneas
Total
Añadido

Caracteres
Total
Añadido

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

94 líneas

// SPDX-License-Identifier: UNLICENSED

pragma solidity 0.6.12;

import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";

import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";

import "../external/compound/PriceOracle.sol";

import "../external/compound/CToken.sol";

import "../external/compound/CErc20.sol";

import "../external/curve/ICurveRegistry.sol";

import "../external/curve/ICurveFactoryRegistry.sol";

import "../external/curve/ICurvePool.sol";

import "./BasePriceOracle.sol";

/**

* @title CurveLpTokenPriceOracle

* @title CurveFactoryLpTokenPriceOracle

* @author David Lucid <david@rari.capital> (https://github.com/davidlucid)

* @notice CurveLpTokenPriceOracle is a price oracle for Curve LP tokens (using the sender as a root oracle).

* @notice CurveFactoryLpTokenPriceOracle is a price oracle for Curve LP tokens (using the sender as a root oracle).

* @dev Implements the `PriceOracle` interface used by Fuse pools (and Compound v2).

contract CurveLpTokenPriceOracle is PriceOracle, BasePriceOracle {

contract CurveFactoryLpTokenPriceOracle is PriceOracle, BasePriceOracle {

using SafeMathUpgradeable for uint256;

/**

* @notice Get the LP token price price for an underlying token address.

* @param underlying The underlying token address for which to get the price (set to zero address for ETH).

* @return Price denominated in ETH (scaled by 1e18).

function price(address underlying) external override view returns (uint) {

return _price(underlying);

}

/**

* @notice Returns the price in ETH of the token underlying `cToken`.

* @dev Implements the `PriceOracle` interface for Fuse pools (and Compound v2).

* @return Price in ETH of the token underlying `cToken`, scaled by `10 ** (36 - underlyingDecimals)`.

function getUnderlyingPrice(CToken cToken) external override view returns (uint) {

address underlying = CErc20(address(cToken)).underlying();

// Comptroller needs prices to be scaled by 1e(36 - decimals)

// Since `_price` returns prices scaled by 18 decimals, we must scale them by 1e(36 - 18 - decimals)

return _price(underlying).mul(1e18).div(10 ** uint256(ERC20Upgradeable(underlying).decimals()));

}

/**

* @dev Fetches the fair LP token/ETH price from Curve, with 18 decimals of precision.

* Source: https://github.com/AlphaFinanceLab/homora-v2/blob/master/contracts/oracle/CurveOracle.sol

* @param lpToken The LP token contract address for price retrieval.

* @param pool pool LP token

function _price(address lpToken) internal view returns (uint) {

function _price(address pool) internal view returns (uint) {

address pool = poolOf[lpToken];

address[] memory tokens = underlyingTokens[pool];

require(pool != address(0), "LP token is not registered.");

require(tokens.length != 0, "LP token is not registered.");

address[] memory tokens = underlyingTokens[lpToken];

uint256 minPx = uint256(-1);

uint256 n = tokens.length;

for (uint256 i = 0; i < n; i++) {

address ulToken = tokens[i];

uint256 tokenPx = BasePriceOracle(msg.sender).price(ulToken);

if (tokenPx < minPx) minPx = tokenPx;

}

require(minPx != uint256(-1), "No minimum underlying token price found.");

return minPx.mul(ICurvePool(pool).get_virtual_price()).div(1e18); // Use min underlying token prices

}

/**

* @dev The Curve registry.

ICurveRegistry public constant registry = ICurveRegistry(0x7D86446dDb609eD0F5f8684AcF30380a356b2B4c);

ICurveFactoryRegistry public constant registry = ICurveFactoryRegistry(0xB9fC157394Af804a3578134A6585C0dc9cc990d4);

/**

* @dev Maps Curve LP token addresses to underlying token addresses.

mapping(address => address[]) public underlyingTokens;

/**

* @dev Maps Curve LP token addresses to pool addresses.

mapping(address => address) public poolOf;

/**

* @dev Register the pool given LP token address and set the pool info.

* Source: https://github.com/AlphaFinanceLab/homora-v2/blob/master/contracts/oracle/CurveOracle.sol

* @param lpToken LP token to find the corresponding pool.

* @param pool pool LP token

function registerPool(address lpToken) external {

function registerPool(address pool) external {

address pool = poolOf[lpToken];

require(pool == address(0), "This LP token is already registered.");

pool = registry.get_pool_from_lp_token(lpToken);

require(pool != address(0), "No corresponding pool found for this LP token in the Curve registry.");

poolOf[lpToken] = pool;

uint n = registry.get_n_coins(pool);

address[8] memory tokens = registry.get_coins(pool);

require(n != 0, "n");

for (uint256 i = 0; i < n; i++) underlyingTokens[lpToken].push(tokens[i]);

address[4] memory tokens = registry.get_coins(pool);

for (uint256 i = 0; i < n; i++) underlyingTokens[pool].push(tokens[i]);

}

Diferencias guardadas

Texto original

Abrir archivo

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;

import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";

import "../external/compound/PriceOracle.sol";
import "../external/compound/CToken.sol";
import "../external/compound/CErc20.sol";

import "../external/curve/ICurveRegistry.sol";
import "../external/curve/ICurvePool.sol";

import "./BasePriceOracle.sol";

/**
 * @title CurveLpTokenPriceOracle
 * @author David Lucid <david@rari.capital> (https://github.com/davidlucid)
 * @notice CurveLpTokenPriceOracle is a price oracle for Curve LP tokens (using the sender as a root oracle).
 * @dev Implements the `PriceOracle` interface used by Fuse pools (and Compound v2).
 */
contract CurveLpTokenPriceOracle is PriceOracle, BasePriceOracle {
    using SafeMathUpgradeable for uint256;

/**
     * @notice Get the LP token price price for an underlying token address.
     * @param underlying The underlying token address for which to get the price (set to zero address for ETH).
     * @return Price denominated in ETH (scaled by 1e18).
     */
    function price(address underlying) external override view returns (uint) {
        return _price(underlying);
    }

/**
     * @notice Returns the price in ETH of the token underlying `cToken`.
     * @dev Implements the `PriceOracle` interface for Fuse pools (and Compound v2).
     * @return Price in ETH of the token underlying `cToken`, scaled by `10 ** (36 - underlyingDecimals)`.
     */
    function getUnderlyingPrice(CToken cToken) external override view returns (uint) {
        address underlying = CErc20(address(cToken)).underlying();
        // Comptroller needs prices to be scaled by 1e(36 - decimals)
        // Since `_price` returns prices scaled by 18 decimals, we must scale them by 1e(36 - 18 - decimals)
        return _price(underlying).mul(1e18).div(10 ** uint256(ERC20Upgradeable(underlying).decimals()));
    }

/**
     * @dev Fetches the fair LP token/ETH price from Curve, with 18 decimals of precision.
     * Source: https://github.com/AlphaFinanceLab/homora-v2/blob/master/contracts/oracle/CurveOracle.sol
     * @param lpToken The LP token contract address for price retrieval.
     */
    function _price(address lpToken) internal view returns (uint) {
        address pool = poolOf[lpToken];
        require(pool != address(0), "LP token is not registered.");
        address[] memory tokens = underlyingTokens[lpToken];
        uint256 minPx = uint256(-1);
        uint256 n = tokens.length;

for (uint256 i = 0; i < n; i++) {
            address ulToken = tokens[i];
            uint256 tokenPx = BasePriceOracle(msg.sender).price(ulToken);
            if (tokenPx < minPx) minPx = tokenPx;
        }

require(minPx != uint256(-1), "No minimum underlying token price found.");      
        return minPx.mul(ICurvePool(pool).get_virtual_price()).div(1e18); // Use min underlying token prices
    }

/**
     * @dev The Curve registry.
     */
    ICurveRegistry public constant registry = ICurveRegistry(0x7D86446dDb609eD0F5f8684AcF30380a356b2B4c);

/**
     * @dev Maps Curve LP token addresses to underlying token addresses.
     */
    mapping(address => address[]) public underlyingTokens;

/**
     * @dev Maps Curve LP token addresses to pool addresses.
     */
    mapping(address => address) public poolOf;

/**
     * @dev Register the pool given LP token address and set the pool info.
     * Source: https://github.com/AlphaFinanceLab/homora-v2/blob/master/contracts/oracle/CurveOracle.sol
     * @param lpToken LP token to find the corresponding pool.
     */
    function registerPool(address lpToken) external {
        address pool = poolOf[lpToken];
        require(pool == address(0), "This LP token is already registered.");
        pool = registry.get_pool_from_lp_token(lpToken);
        require(pool != address(0), "No corresponding pool found for this LP token in the Curve registry.");
        poolOf[lpToken] = pool;
        uint n = registry.get_n_coins(pool);
        address[8] memory tokens = registry.get_coins(pool);
        for (uint256 i = 0; i < n; i++) underlyingTokens[lpToken].push(tokens[i]);
    }
}

Texto modificado

Abrir archivo

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;

import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";

import "../external/compound/PriceOracle.sol";
import "../external/compound/CToken.sol";
import "../external/compound/CErc20.sol";

import "../external/curve/ICurveFactoryRegistry.sol";
import "../external/curve/ICurvePool.sol";

import "./BasePriceOracle.sol";

/**
 * @title CurveFactoryLpTokenPriceOracle
 * @author David Lucid <david@rari.capital> (https://github.com/davidlucid)
 * @notice CurveFactoryLpTokenPriceOracle is a price oracle for Curve LP tokens (using the sender as a root oracle).
 * @dev Implements the `PriceOracle` interface used by Fuse pools (and Compound v2).
 */
contract CurveFactoryLpTokenPriceOracle is PriceOracle, BasePriceOracle {
    using SafeMathUpgradeable for uint256;

/**
     * @dev Fetches the fair LP token/ETH price from Curve, with 18 decimals of precision.
     * Source: https://github.com/AlphaFinanceLab/homora-v2/blob/master/contracts/oracle/CurveOracle.sol
     * @param pool pool LP token
     */
    function _price(address pool) internal view returns (uint) {
        address[] memory tokens = underlyingTokens[pool];
        require(tokens.length != 0, "LP token is not registered.");
        uint256 minPx = uint256(-1);
        uint256 n = tokens.length;

require(minPx != uint256(-1), "No minimum underlying token price found.");      
        return minPx.mul(ICurvePool(pool).get_virtual_price()).div(1e18); // Use min underlying token prices
    }

/**
     * @dev The Curve registry.
     */
    ICurveFactoryRegistry public constant registry = ICurveFactoryRegistry(0xB9fC157394Af804a3578134A6585C0dc9cc990d4);

/**
     * @dev Maps Curve LP token addresses to underlying token addresses.
     */
    mapping(address => address[]) public underlyingTokens;

/**
     * @dev Maps Curve LP token addresses to pool addresses.
     */
    mapping(address => address) public poolOf;

/**
     * @dev Register the pool given LP token address and set the pool info.
     * Source: https://github.com/AlphaFinanceLab/homora-v2/blob/master/contracts/oracle/CurveOracle.sol
     * @param pool pool LP token
     */
    function registerPool(address pool) external {
        uint n = registry.get_n_coins(pool);
        require(n != 0, "n");
        address[4] memory tokens = registry.get_coins(pool);
        for (uint256 i = 0; i < n; i++) underlyingTokens[pool].push(tokens[i]);
    }
}