Comparar texto

Encontre a diferença entre dois arquivos de texto

Editor live

Recolher inalteradas

Sem quebra de linha

Layout

Nível de detalhe

Realce de sintaxe

Diffchecker Desktop A maneira mais segura de usar o Diffchecker. Obtenha o aplicativo Diffchecker Desktop: seus diffs nunca saem do seu computador!Obter Desktop

TombBasedOracles

Criado há 4 anosO diff nunca expira

30 remoções

Linhas
Total
Removido

Caracteres
Total
Removido

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

105 linhas

31 adições

Linhas
Total
Adicionado

Caracteres
Total
Adicionado

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

104 linhas

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/math/SafeMath.sol";

import "@openzeppelin/contracts/utils/math/SafeMath.sol";

import "./lib/Babylonian.sol";

import "./lib/FixedPoint.sol";

import "./lib/UniswapV2OracleLibrary.sol";

import "./utils/Epoch.sol";

import "./interfaces/IUniswapV2Pair.sol";

______ __ _______

__________ .___ ___________.__

/_ __/___ ____ ___ / /_ / ____(_)___ ____ _____ ________

\______ \_____ ______ ____ __| _/ \_ _____/|__| ____ _____ ____ ____ ____

/ / / __ \/ __ `__ \/ __ \ / /_ / / __ \/ __ `/ __ \/ ___/ _ \

| | _/\__ \ / ___/_/ __ \ / __ | | __) | | / \ \__ \ / \ _/ ___\_/ __ \

/ / / /_/ / / / / / / /_/ / / __/ / / / / / /_/ / / / / /__/ __/

| | \ / __ \_ \___ \ \ ___/ / /_/ | | \ | || | \ / __ \_| | \\ \___\ ___/

/_/ \____/_/ /_/ /_/_.___/ /_/ /_/_/ /_/\__,_/_/ /_/\___/\___/

|______ /(____ //____ > \___ >\____ | \___ / |__||___| /(____ /|___| / \___ >\___ >

\/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/

http://tomb.finance

// fixed window oracle that recomputes the average price for the entire period once every period

// note that the price average is only guaranteed to be over at least 1 period, but may be over a longer period

contract Oracle is Epoch {

using FixedPoint for *;

using SafeMath for uint256;

/* ========== STATE VARIABLES ========== */

// uniswap

address public token0;

address public token1;

IUniswapV2Pair public pair;

// oracle

uint32 public blockTimestampLast;

uint256 public price0CumulativeLast;

uint256 public price1CumulativeLast;

FixedPoint.uq112x112 public price0Average;

FixedPoint.uq112x112 public price1Average;

/* ========== CONSTRUCTOR ========== */

constructor(

IUniswapV2Pair _pair,

uint256 _period,

uint256 _startTime

) public Epoch(_period, _startTime, 0) {

) Epoch(_period, _startTime, 0) {

pair = _pair;

token0 = pair.token0();

token1 = pair.token1();

price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)

price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)

uint112 reserve0;

uint112 reserve1;

(reserve0, reserve1, blockTimestampLast) = pair.getReserves();

require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair

}

/* ========== MUTABLE FUNCTIONS ========== */

/** @dev Updates 1-day EMA price from Uniswap. */

function update() external checkEpoch {

(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));

uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired

if (timeElapsed == 0) {

// prevent divided by zero

return;

}

// overflow is desired, casting never truncates

// cumulative price is in (uq112x112 price * seconds) units so we simply wrap it after division by time elapsed

price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));

price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));

price0CumulativeLast = price0Cumulative;

price1CumulativeLast = price1Cumulative;

blockTimestampLast = blockTimestamp;

emit Updated(price0Cumulative, price1Cumulative);

}

// note this will always return 0 before update has been called successfully for the first time.

function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {

if (_token == token0) {

amountOut = price0Average.mul(_amountIn).decode144();

} else {

require(_token == token1, "Oracle: INVALID_TOKEN");

amountOut = price1Average.mul(_amountIn).decode144();

}

function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {

(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));

uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired

if (_token == token0) {

_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();

} else if (_token == token1) {

_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();

}

event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);

}

Diferenças salvas

Texto original

Abrir arquivo

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

import "@openzeppelin/contracts/math/SafeMath.sol";

import "./lib/Babylonian.sol";
import "./lib/FixedPoint.sol";
import "./lib/UniswapV2OracleLibrary.sol";
import "./utils/Epoch.sol";
import "./interfaces/IUniswapV2Pair.sol";

/*
  ______                __       _______
 /_  __/___  ____ ___  / /_     / ____(_)___  ____ _____  ________
  / / / __ \/ __ `__ \/ __ \   / /_  / / __ \/ __ `/ __ \/ ___/ _ \
 / / / /_/ / / / / / / /_/ /  / __/ / / / / / /_/ / / / / /__/  __/
/_/  \____/_/ /_/ /_/_.___/  /_/   /_/_/ /_/\__,_/_/ /_/\___/\___/

http://tomb.finance
*/
// fixed window oracle that recomputes the average price for the entire period once every period
// note that the price average is only guaranteed to be over at least 1 period, but may be over a longer period
contract Oracle is Epoch {
    using FixedPoint for *;
    using SafeMath for uint256;

/* ========== STATE VARIABLES ========== */

// uniswap
    address public token0;
    address public token1;
    IUniswapV2Pair public pair;

// oracle
    uint32 public blockTimestampLast;
    uint256 public price0CumulativeLast;
    uint256 public price1CumulativeLast;
    FixedPoint.uq112x112 public price0Average;
    FixedPoint.uq112x112 public price1Average;

/* ========== CONSTRUCTOR ========== */

constructor(
        IUniswapV2Pair _pair,
        uint256 _period,
        uint256 _startTime
    ) public Epoch(_period, _startTime, 0) {
        pair = _pair;
        token0 = pair.token0();
        token1 = pair.token1();
        price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
        price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
        uint112 reserve0;
        uint112 reserve1;
        (reserve0, reserve1, blockTimestampLast) = pair.getReserves();
        require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
    }

/* ========== MUTABLE FUNCTIONS ========== */

/** @dev Updates 1-day EMA price from Uniswap.  */
    function update() external checkEpoch {
        (uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
        uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired

if (timeElapsed == 0) {
            // prevent divided by zero
            return;
        }

// overflow is desired, casting never truncates
        // cumulative price is in (uq112x112 price * seconds) units so we simply wrap it after division by time elapsed
        price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
        price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));

price0CumulativeLast = price0Cumulative;
        price1CumulativeLast = price1Cumulative;
        blockTimestampLast = blockTimestamp;

emit Updated(price0Cumulative, price1Cumulative);
    }

// note this will always return 0 before update has been called successfully for the first time.
    function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
        if (_token == token0) {
            amountOut = price0Average.mul(_amountIn).decode144();
        } else {
            require(_token == token1, "Oracle: INVALID_TOKEN");
            amountOut = price1Average.mul(_amountIn).decode144();
        }
    }

event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}

Texto alterado

Abrir arquivo

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/math/SafeMath.sol";

import "./lib/Babylonian.sol";
import "./lib/FixedPoint.sol";
import "./lib/UniswapV2OracleLibrary.sol";
import "./utils/Epoch.sol";
import "./interfaces/IUniswapV2Pair.sol";

/*
__________                             .___   ___________.__
\______   \_____     ______  ____    __| _/   \_   _____/|__|  ____  _____     ____    ____   ____
 |    |  _/\__  \   /  ___/_/ __ \  / __ |     |    __)  |  | /    \ \__  \   /    \ _/ ___\_/ __ \
 |    |   \ / __ \_ \___ \ \  ___/ / /_/ |     |     \   |  ||   |  \ / __ \_|   |  \\  \___\  ___/
 |______  /(____  //____  > \___  >\____ |     \___  /   |__||___|  /(____  /|___|  / \___  >\___  >
        \/      \/      \/      \/      \/         \/             \/      \/      \/      \/     \/
*/
// fixed window oracle that recomputes the average price for the entire period once every period
// note that the price average is only guaranteed to be over at least 1 period, but may be over a longer period
contract Oracle is Epoch {
    using FixedPoint for *;
    using SafeMath for uint256;

/* ========== STATE VARIABLES ========== */

// uniswap
    address public token0;
    address public token1;
    IUniswapV2Pair public pair;

/* ========== CONSTRUCTOR ========== */

constructor(
        IUniswapV2Pair _pair,
        uint256 _period,
        uint256 _startTime
    ) Epoch(_period, _startTime, 0) {
        pair = _pair;
        token0 = pair.token0();
        token1 = pair.token1();
        price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
        price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
        uint112 reserve0;
        uint112 reserve1;
        (reserve0, reserve1, blockTimestampLast) = pair.getReserves();
        require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
    }

/* ========== MUTABLE FUNCTIONS ========== */

if (timeElapsed == 0) {
            // prevent divided by zero
            return;
        }

price0CumulativeLast = price0Cumulative;
        price1CumulativeLast = price1Cumulative;
        blockTimestampLast = blockTimestamp;

emit Updated(price0Cumulative, price1Cumulative);
    }

event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}