ETH Price: $3,537.01 (-1.06%)
Gas: 22 Gwei

Contract

0x86cAAE275d44BA32CC813415bacFbEA68E1C4443
 

Overview

ETH Balance

0 ETH

Eth Value

$0.00

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Value
Update135136752021-10-29 18:36:33881 days ago1635532593IN
0x86cAAE27...68E1C4443
0 ETH0.02290534206
Update135090012021-10-29 0:38:34882 days ago1635467914IN
0x86cAAE27...68E1C4443
0 ETH0.02301653207
Update135041452021-10-28 6:38:06883 days ago1635403086IN
0x86cAAE27...68E1C4443
0 ETH0.02348484201
Update134994342021-10-27 12:38:30883 days ago1635338310IN
0x86cAAE27...68E1C4443
0 ETH0.01830416146
Update134946272021-10-26 18:37:17884 days ago1635273437IN
0x86cAAE27...68E1C4443
0 ETH0.03297257263
Update134898472021-10-26 0:37:47885 days ago1635208667IN
0x86cAAE27...68E1C4443
0 ETH0.01679971134
Update134850062021-10-25 6:38:04886 days ago1635143884IN
0x86cAAE27...68E1C4443
0 ETH0.01516989121
Update134802502021-10-24 12:37:51886 days ago1635079071IN
0x86cAAE27...68E1C4443
0 ETH0.0089013471
Update134754772021-10-23 18:38:26887 days ago1635014306IN
0x86cAAE27...68E1C4443
0 ETH0.0109072787
Update134707232021-10-23 0:37:33888 days ago1634949453IN
0x86cAAE27...68E1C4443
0 ETH0.009904379
Update134658722021-10-22 6:38:26889 days ago1634884706IN
0x86cAAE27...68E1C4443
0 ETH0.009904379
Update134610782021-10-21 12:41:47889 days ago1634820107IN
0x86cAAE27...68E1C4443
0 ETH0.0106565385
Update134562562021-10-20 18:37:42890 days ago1634755062IN
0x86cAAE27...68E1C4443
0 ETH0.01266247101
Update134514482021-10-20 0:38:16891 days ago1634690296IN
0x86cAAE27...68E1C4443
0 ETH0.01278784102
Update134466292021-10-19 6:37:35892 days ago1634625455IN
0x86cAAE27...68E1C4443
0 ETH0.0090267172
Update134418422021-10-18 12:37:10892 days ago1634560630IN
0x86cAAE27...68E1C4443
0 ETH0.01817879145
Update134370812021-10-17 18:37:58893 days ago1634495878IN
0x86cAAE27...68E1C4443
0 ETH0.01416692113
Update134323202021-10-17 0:39:51894 days ago1634431191IN
0x86cAAE27...68E1C4443
0 ETH0.0104057983
Update134274422021-10-16 6:37:33895 days ago1634366253IN
0x86cAAE27...68E1C4443
0 ETH0.0112833990
Update134226882021-10-15 12:37:48895 days ago1634301468IN
0x86cAAE27...68E1C4443
0 ETH0.01755194140
Update134179472021-10-14 18:36:48896 days ago1634236608IN
0x86cAAE27...68E1C4443
0 ETH0.02068621165
Update134132372021-10-14 0:38:58897 days ago1634171938IN
0x86cAAE27...68E1C4443
0 ETH0.015546124
Update134084952021-10-13 6:38:12898 days ago1634107092IN
0x86cAAE27...68E1C4443
0 ETH0.01391618111
Update134036682021-10-12 12:37:10898 days ago1634042230IN
0x86cAAE27...68E1C4443
0 ETH0.0112833990
Update133989332021-10-11 18:39:14899 days ago1633977554IN
0x86cAAE27...68E1C4443
0 ETH0.01880565150
View all transactions

View more zero value Internal Transactions in Advanced View mode

Advanced mode:
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
YieldOracle

Compiler Version
v0.7.6+commit.7338295f

Optimization Enabled:
Yes with 9999 runs

Other Settings:
default evmVersion
File 1 of 4 : YieldOracle.sol
// 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
            );
    }
}

File 3 of 4 : SafeMath.sol
// 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;
    }
}

File 4 of 4 : IYieldOraclelizable.sol
// 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);

}

File 5 of 4 : IYieldOracle.sol
// 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);
}

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

Contract Security Audit

Contract ABI

[{"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"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000cee88909be73d07d557ef2648ab60f7c8c90ac9f000000000000000000000000000000000000000000000000000000000003f4800000000000000000000000000000000000000000000000000000000000000004

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

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


Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Txn Hash Block Value Eth2 PubKey Valid
View All Deposits
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.