Confronta il testo

Trova la differenza tra due file di testo

Editor live

Comprimi invariate

Senza a capo

Layout

Livello di dettaglio

Evidenziazione sintassi

Diffchecker Desktop Il modo più sicuro per usare Diffchecker. Ottieni l'app Diffchecker Desktop: i tuoi diff non lasciano mai il tuo computer!Ottieni Desktop

TombBasedOracles

Creato 4 anni faIl diff non scade mai

30 rimozioni

Linee
Totale
Rimosso

Caratteri
Totale
Rimosso

Per continuare a utilizzare questa funzione, aggiorna a Diffchecker Pro Visualizza prezzi

105 linee

31 aggiunte

Linee
Totale
Aggiunto

Caratteri
Totale
Aggiunto

Per continuare a utilizzare questa funzione, aggiorna a Diffchecker Pro Visualizza prezzi

104 linee

// 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);

}

Diff salvati

Testo originale

Apri file

// 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);
}

Testo modificato

Apri file

// 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);
}