Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.7.6;
pragma abicoder v2;

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

import "./IYieldOraclelizable.sol";
import "./IYieldOracle.sol";

// a modified version of https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/examples/ExampleSlidingWindowOracle.sol
// sliding window oracle that uses observations collected over a window to provide moving yield averages in the past
// `windowSize` with a precision of `windowSize / granularity`
contract YieldOracle is IYieldOracle {
    using SafeMath for uint256;

    IYieldOraclelizable public cumulator;

    struct Observation {
        uint256 timestamp;
        uint256 yieldCumulative;
    }

    // the desired amount of time over which the moving average should be computed, e.g. 24 hours
    uint256 public immutable windowSize;

    // the number of observations stored for each pair, i.e. how many price observations are stored for the window.
    // as granularity increases from 1, more frequent updates are needed, but moving averages become more precise.
    // averages are computed over intervals with sizes in the range:
    //   [windowSize - (windowSize / granularity) * 2, windowSize]
    // e.g. if the window size is 24 hours, and the granularity is 24, the oracle will return the average price for
    //   the period:
    //   [now - [22 hours, 24 hours], now]
    uint8 public immutable granularity;

    // this is redundant with granularity and windowSize, but stored for gas savings & informational purposes.
    uint256 public immutable periodSize;

    // list of yield observations
    Observation[] public yieldObservations;

    constructor(
        address cumulator_,
        uint256 windowSize_,
        uint8 granularity_
    ) {
        require(granularity_ > 1, "YO: GRANULARITY");
        require(
            (periodSize = windowSize_ / granularity_) * granularity_ ==
                windowSize_,
            "YO: WINDOW_NOT_EVENLY_DIVISIBLE"
        );
        windowSize = windowSize_;
        granularity = granularity_;
        cumulator = IYieldOraclelizable(cumulator_);

        for (uint256 i = yieldObservations.length; i < granularity_; i++) {
            yieldObservations.push();
        }
    }

    // returns the index of the observation corresponding to the given timestamp
    function observationIndexOf(uint256 timestamp_)
        public
        view
        returns (uint8 index)
    {
        uint256 epochPeriod = timestamp_ / periodSize;
        return uint8(epochPeriod % granularity);
    }

    // returns the observation from the oldest epoch (at the beginning of the window) relative to the current time
    function getFirstObservationInWindow()
        private
        view
        returns (Observation storage firstObservation)
    {
        uint8 observationIndex = observationIndexOf(block.timestamp);
        // no overflow issue. if observationIndex + 1 overflows, result is still zero.
        uint8 firstObservationIndex = (observationIndex + 1) % granularity;
        firstObservation = yieldObservations[firstObservationIndex];
    }

    // update the cumulative price for the observation at the current timestamp. each observation is updated at most
    // once per epoch period.
    function update() external virtual override {
        // get the observation for the current period
        uint8 observationIndex = observationIndexOf(block.timestamp);
        Observation storage observation = yieldObservations[observationIndex];

        // we only want to commit updates once per period (i.e. windowSize / granularity)
        uint256 timeElapsed = block.timestamp - observation.timestamp;
        if (timeElapsed > periodSize) {
            (uint256 yieldCumulative) = cumulator.cumulatives();
            observation.timestamp = block.timestamp;
            observation.yieldCumulative = yieldCumulative;
        }
    }

    // given the cumulative yields of the start and end of a period, and the length of the period (timeElapsed in seconds), compute the average
    // yield and extrapolate it for forInterval (seconds) in terms of how much amount out is received for the amount in
    function computeAmountOut(
        uint256 yieldCumulativeStart_,
        uint256 yieldCumulativeEnd_,
        uint256 timeElapsed_,
        uint256 forInterval_
    ) private pure returns (uint256 yieldAverage) {
        // ((yieldCumulativeEnd_ - yieldCumulativeStart_) * forInterval_) / timeElapsed_;
        return yieldCumulativeEnd_.sub(yieldCumulativeStart_).mul(forInterval_).div(timeElapsed_);
    }

    // returns the amount out corresponding to the amount in for a given token using the moving average over the time
    // range [now - [windowSize, windowSize - periodSize * 2], now]
    // update must have been called for the bucket corresponding to timestamp `now - windowSize`
    function consult(uint256 forInterval)
        external
        override
        virtual
        returns (uint256 yieldForInterval)
    {
        Observation storage firstObservation = getFirstObservationInWindow();

        uint256 timeElapsed = block.timestamp - firstObservation.timestamp;

        if (!(timeElapsed <= windowSize)) {
            // originally:
            // require(
            //     timeElapsed <= windowSize,
            //     "YO: MISSING_HISTORICAL_OBSERVATION"
            // );
            // if the oracle is falling behind, it reports 0 yield => there's no incentive to buy sBOND
            return 0;
        }

        if (!(timeElapsed >= windowSize - periodSize * 2)) {
            // originally:
            // should never happen.
            // require(
            //     timeElapsed >= windowSize - periodSize * 2,
            //     "YO: UNEXPECTED_TIME_ELAPSED"
            // );
            // if the oracle is in an odd state, it reports 0 yield => there's no incentive to buy sBOND
            return 0;
        }

        (uint256 yieldCumulative) = cumulator.cumulatives();

        return
            computeAmountOut(
                firstObservation.yieldCumulative,
                yieldCumulative,
                timeElapsed,
                forInterval
            );
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.7.6;
pragma abicoder v2;

interface IYieldOraclelizable {
    // accumulates/updates internal state and returns cumulatives 
    // oracle should call this when updating
    function cumulatives()
      external
    returns(uint256 cumulativeYield);

}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.7.6;
pragma abicoder v2;

interface IYieldOracle {
    function update() external;

    function consult(uint256 forInterval) external returns (uint256 amountOut);
}

{
  "optimizer": {
    "enabled": true,
    "runs": 9999
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"cumulator_","type":"address"},{"internalType":"uint256","name":"windowSize_","type":"uint256"},{"internalType":"uint8","name":"granularity_","type":"uint8"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"forInterval","type":"uint256"}],"name":"consult","outputs":[{"internalType":"uint256","name":"yieldForInterval","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cumulator","outputs":[{"internalType":"contract IYieldOraclelizable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"granularity","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"timestamp_","type":"uint256"}],"name":"observationIndexOf","outputs":[{"internalType":"uint8","name":"index","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"update","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"windowSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"yieldObservations","outputs":[{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"uint256","name":"yieldCumulative","type":"uint256"}],"stateMutability":"view","type":"function"}]

60e060405234801561001057600080fd5b5060405161099138038061099183398101604081905261002f91610102565b60018160ff161161005b5760405162461bcd60e51b815260040161005290610154565b60405180910390fd5b8160ff821680828161006957fe5b0460c0819052021461008d5760405162461bcd60e51b81526004016100529061017d565b608082905260f881901b7fff000000000000000000000000000000000000000000000000000000000000001660a052600080546001600160a01b0319166001600160a01b0385161790556001545b8160ff168110156100f95760018054810181556000819052016100db565b505050506101b4565b600080600060608486031215610116578283fd5b83516001600160a01b038116811461012c578384fd5b60208501516040860151919450925060ff81168114610149578182fd5b809150509250925092565b6020808252600f908201526e594f3a204752414e554c415249545960881b604082015260600190565b6020808252601f908201527f594f3a2057494e444f575f4e4f545f4556454e4c595f444956495349424c4500604082015260600190565b60805160a05160f81c60c05161078b610206600039806101e352806103555280610432528061049252508061015e528061045e52806104c65250806101b0528061020752806102fb525061078b6000f3fe608060405234801561001057600080fd5b50600436106100885760003560e01c80638a14117a1161005b5780638a14117a14610101578063a2e6204514610109578063dbaad32f14610113578063e4463eb21461012657610088565b80630a7245611461008d578063556f0dc7146100b75780635900760a146100cc57806361e25d83146100e1575b600080fd5b6100a061009b3660046106be565b61012e565b6040516100ae929190610718565b60405180910390f35b6100bf61015c565b6040516100ae9190610726565b6100d4610180565b6040516100ae91906106ee565b6100f46100ef3660046106be565b61019c565b6040516100ae919061070f565b6100f46102f9565b61011161031d565b005b6100bf6101213660046106be565b61042d565b6100f4610490565b6001818154811061013e57600080fd5b60009182526020909120600290910201805460019091015490915082565b7f000000000000000000000000000000000000000000000000000000000000000081565b60005473ffffffffffffffffffffffffffffffffffffffff1681565b6000806101a76104b4565b805490915042037f00000000000000000000000000000000000000000000000000000000000000008111156101e1576000925050506102f4565b7f00000000000000000000000000000000000000000000000000000000000000006002027f000000000000000000000000000000000000000000000000000000000000000003811015610239576000925050506102f4565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ddaf429d6040518163ffffffff1660e01b8152600401602060405180830381600087803b1580156102a457600080fd5b505af11580156102b8573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906102dc91906106d6565b90506102ee836001015482848861051e565b93505050505b919050565b7f000000000000000000000000000000000000000000000000000000000000000081565b60006103284261042d565b9050600060018260ff168154811061033c57fe5b60009182526020909120600290910201805490915042037f00000000000000000000000000000000000000000000000000000000000000008111156104285760008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ddaf429d6040518163ffffffff1660e01b8152600401602060405180830381600087803b1580156103e657600080fd5b505af11580156103fa573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061041e91906106d6565b4284556001840155505b505050565b6000807f0000000000000000000000000000000000000000000000000000000000000000838161045957fe5b0490507f000000000000000000000000000000000000000000000000000000000000000060ff16818161048857fe5b069392505050565b7f000000000000000000000000000000000000000000000000000000000000000081565b6000806104c04261042d565b905060007f000000000000000000000000000000000000000000000000000000000000000060ff168260010160ff16816104f657fe5b06905060018160ff168154811061050957fe5b90600052602060002090600202019250505090565b600061053e8361053884610532888a610547565b906105c3565b9061063d565b95945050505050565b6000828211156105b857604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601e60248201527f536166654d6174683a207375627472616374696f6e206f766572666c6f770000604482015290519081900360640190fd5b508082035b92915050565b6000826105d2575060006105bd565b828202828482816105df57fe5b0414610636576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260218152602001806107356021913960400191505060405180910390fd5b9392505050565b60008082116106ad57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601a60248201527f536166654d6174683a206469766973696f6e206279207a65726f000000000000604482015290519081900360640190fd5b8183816106b657fe5b049392505050565b6000602082840312156106cf578081fd5b5035919050565b6000602082840312156106e7578081fd5b5051919050565b73ffffffffffffffffffffffffffffffffffffffff91909116815260200190565b90815260200190565b918252602082015260400190565b60ff9190911681526020019056fe536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f77a264697066735822122026a0027915dc3c4678874acb333b4a60c1f9da265571404ec7a5574dd684a1ff64736f6c6343000706003300000000000000000000000026984a19e3c6fc8d3e8ff124cd72d71f6b603ff3000000000000000000000000000000000000000000000000000000000003f4800000000000000000000000000000000000000000000000000000000000000004

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

00000000000000000000000026984a19e3c6fc8d3e8ff124cd72d71f6b603ff3000000000000000000000000000000000000000000000000000000000003f4800000000000000000000000000000000000000000000000000000000000000004

-----Decoded View---------------
Arg [0] : cumulator_ (address): 0x26984a19e3C6FC8D3e8Ff124CD72D71f6B603Ff3
Arg [1] : windowSize_ (uint256): 259200
Arg [2] : granularity_ (uint8): 4

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000026984a19e3c6fc8d3e8ff124cd72d71f6b603ff3
Arg [1] : 000000000000000000000000000000000000000000000000000000000003f480
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000004