Contract Address Details

// SPDX-License-Identifier: MIT
pragma solidity ~0.8.17;

import {UsingFetch} from "./UsingFetch.sol";

error PriceOutdated();
error ZeroValue();

contract FetchFlexOracle is UsingFetch {
    constructor(address payable _fetchAddress) UsingFetch(_fetchAddress) {}

    function latestAnswer() public view returns (int256) {
        bytes memory _plsQueryId = abi.encode(
            "SpotPrice",
            abi.encode("pls", "usd")
        );
        bytes32 _queryId = keccak256(_plsQueryId);

        (bytes memory _value, uint256 _timestampRetrieved) = getDataBefore(
            _queryId,
            block.timestamp - 20 minutes
        );
        if (_timestampRetrieved == 0) {
            revert ZeroValue();
        }
        if (block.timestamp - _timestampRetrieved > 24 hours) {
            revert PriceOutdated();
        }

        uint256 price = abi.decode(_value, (uint256));
        // convert value to chainlink oracle format
        int256 oraclePrice = int256((price * 1e8) / 1e18);
        if (oraclePrice == 0) {
            revert ZeroValue();
        }

        return oraclePrice;
    }
}
        

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

/**
 * @dev EIP2362 Interface for pull oracles
 * https://github.com/tellor-io/EIP-2362
 */
interface IERC2362 {
    /**
     * @dev Exposed function pertaining to EIP standards
     * @param _id bytes32 ID of the query
     * @return int,uint,uint returns the value, timestamp, and status code of query
     */
    function valueFor(
        bytes32 _id
    ) external view returns (int256, uint256, uint256);
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

interface IFetch {
    //Controller
    function addresses(bytes32) external view returns (address);

    function uints(bytes32) external view returns (uint256);

    function burn(uint256 _amount) external;

    function changeDeity(address _newDeity) external;

    function changeOwner(address _newOwner) external;

    function changeUint(bytes32 _target, uint256 _amount) external;

    function migrate() external;

    function mint(address _reciever, uint256 _amount) external;

    function init() external;

    function getAllDisputeVars(
        uint256 _disputeId
    )
        external
        view
        returns (
            bytes32,
            bool,
            bool,
            bool,
            address,
            address,
            address,
            uint256[9] memory,
            int256
        );

    function getDisputeIdByDisputeHash(
        bytes32 _hash
    ) external view returns (uint256);

    function getDisputeUintVars(
        uint256 _disputeId,
        bytes32 _data
    ) external view returns (uint256);

    function getLastNewValueById(
        uint256 _requestId
    ) external view returns (uint256, bool);

    function retrieveData(
        uint256 _requestId,
        uint256 _timestamp
    ) external view returns (uint256);

    function getNewValueCountbyRequestId(
        uint256 _requestId
    ) external view returns (uint256);

    function getAddressVars(bytes32 _data) external view returns (address);

    function getUintVar(bytes32 _data) external view returns (uint256);

    function totalSupply() external view returns (uint256);

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function isMigrated(address _addy) external view returns (bool);

    function allowance(
        address _user,
        address _spender
    ) external view returns (uint256);

    function allowedToTrade(
        address _user,
        uint256 _amount
    ) external view returns (bool);

    function approve(address _spender, uint256 _amount) external returns (bool);

    function approveAndTransferFrom(
        address _from,
        address _to,
        uint256 _amount
    ) external returns (bool);

    function balanceOf(address _user) external view returns (uint256);

    function balanceOfAt(
        address _user,
        uint256 _blockNumber
    ) external view returns (uint256);

    function transfer(
        address _to,
        uint256 _amount
    ) external returns (bool success);

    function transferFrom(
        address _from,
        address _to,
        uint256 _amount
    ) external returns (bool success);

    function depositStake() external;

    function requestStakingWithdraw() external;

    function withdrawStake() external;

    function changeStakingStatus(address _reporter, uint256 _status) external;

    function slashReporter(address _reporter, address _disputer) external;

    function getStakerInfo(
        address _staker
    ) external view returns (uint256, uint256);

    function getTimestampbyRequestIDandIndex(
        uint256 _requestId,
        uint256 _index
    ) external view returns (uint256);

    function getNewCurrentVariables()
        external
        view
        returns (bytes32 _c, uint256[5] memory _r, uint256 _d, uint256 _t);

    function getNewValueCountbyQueryId(
        bytes32 _queryId
    ) external view returns (uint256);

    function getTimestampbyQueryIdandIndex(
        bytes32 _queryId,
        uint256 _index
    ) external view returns (uint256);

    function retrieveData(
        bytes32 _queryId,
        uint256 _timestamp
    ) external view returns (bytes memory);

    //Governance
    enum VoteResult {
        FAILED,
        PASSED,
        INVALID
    }

    function setApprovedFunction(bytes4 _func, bool _val) external;

    function beginDispute(bytes32 _queryId, uint256 _timestamp) external;

    function delegate(address _delegate) external;

    function delegateOfAt(
        address _user,
        uint256 _blockNumber
    ) external view returns (address);

    function executeVote(uint256 _disputeId) external;

    function proposeVote(
        address _contract,
        bytes4 _function,
        bytes calldata _data,
        uint256 _timestamp
    ) external;

    function tallyVotes(uint256 _disputeId) external;

    function governance() external view returns (address);

    function updateMinDisputeFee() external;

    function verify() external pure returns (uint256);

    function vote(
        uint256 _disputeId,
        bool _supports,
        bool _invalidQuery
    ) external;

    function voteFor(
        address[] calldata _addys,
        uint256 _disputeId,
        bool _supports,
        bool _invalidQuery
    ) external;

    function getDelegateInfo(
        address _holder
    ) external view returns (address, uint256);

    function isFunctionApproved(bytes4 _func) external view returns (bool);

    function isApprovedGovernanceContract(
        address _contract
    ) external returns (bool);

    function getVoteRounds(
        bytes32 _hash
    ) external view returns (uint256[] memory);

    function getVoteCount() external view returns (uint256);

    function getVoteInfo(
        uint256 _disputeId
    )
        external
        view
        returns (
            bytes32,
            uint256[9] memory,
            bool[2] memory,
            VoteResult,
            bytes memory,
            bytes4,
            address[2] memory
        );

    function getDisputeInfo(
        uint256 _disputeId
    ) external view returns (uint256, uint256, bytes memory, address);

    function getOpenDisputesOnId(
        bytes32 _queryId
    ) external view returns (uint256);

    function didVote(
        uint256 _disputeId,
        address _voter
    ) external view returns (bool);

    //Oracle
    function getReportTimestampByIndex(
        bytes32 _queryId,
        uint256 _index
    ) external view returns (uint256);

    function getValueByTimestamp(
        bytes32 _queryId,
        uint256 _timestamp
    ) external view returns (bytes memory);

    function getBlockNumberByTimestamp(
        bytes32 _queryId,
        uint256 _timestamp
    ) external view returns (uint256);

    function getReportingLock() external view returns (uint256);

    function getReporterByTimestamp(
        bytes32 _queryId,
        uint256 _timestamp
    ) external view returns (address);

    function reportingLock() external view returns (uint256);

    function removeValue(bytes32 _queryId, uint256 _timestamp) external;

    function getTipsByUser(address _user) external view returns (uint256);

    function tipQuery(
        bytes32 _queryId,
        uint256 _tip,
        bytes memory _queryData
    ) external;

    function submitValue(
        bytes32 _queryId,
        bytes calldata _value,
        uint256 _nonce,
        bytes memory _queryData
    ) external;

    function burnTips() external;

    function changeReportingLock(uint256 _newReportingLock) external;

    function getReportsSubmittedByAddress(
        address _reporter
    ) external view returns (uint256);

    function changeTimeBasedReward(uint256 _newTimeBasedReward) external;

    function getReporterLastTimestamp(
        address _reporter
    ) external view returns (uint256);

    function getTipsById(bytes32 _queryId) external view returns (uint256);

    function getTimeBasedReward() external view returns (uint256);

    function getTimestampCountById(
        bytes32 _queryId
    ) external view returns (uint256);

    function getTimestampIndexByTimestamp(
        bytes32 _queryId,
        uint256 _timestamp
    ) external view returns (uint256);

    function getCurrentReward(
        bytes32 _queryId
    ) external view returns (uint256, uint256);

    function getCurrentValue(
        bytes32 _queryId
    ) external view returns (bytes memory);

    function getDataBefore(
        bytes32 _queryId,
        uint256 _timestamp
    )
        external
        view
        returns (
            bool _ifRetrieve,
            bytes memory _value,
            uint256 _timestampRetrieved
        );

    function getTimeOfLastNewValue() external view returns (uint256);

    function depositStake(uint256 _amount) external;

    function requestStakingWithdraw(uint256 _amount) external;

    //Test functions
    function changeAddressVar(bytes32 _id, address _addy) external;

    //parachute functions
    function killContract() external;

    function migrateFor(address _destination, uint256 _amount) external;

    function rescue51PercentAttack(address _tokenHolder) external;

    function rescueBrokenDataReporting() external;

    function rescueFailedUpdate() external;

    //Fetch 360
    function addStakingRewards(uint256 _amount) external;

    function _sliceUint(
        bytes memory _b
    ) external pure returns (uint256 _number);

    function claimOneTimeTip(
        bytes32 _queryId,
        uint256[] memory _timestamps
    ) external;

    function claimTip(
        bytes32 _feedId,
        bytes32 _queryId,
        uint256[] memory _timestamps
    ) external;

    function fee() external view returns (uint256);

    function feedsWithFunding(uint256) external view returns (bytes32);

    function fundFeed(
        bytes32 _feedId,
        bytes32 _queryId,
        uint256 _amount
    ) external;

    function getCurrentFeeds(
        bytes32 _queryId
    ) external view returns (bytes32[] memory);

    function getCurrentTip(bytes32 _queryId) external view returns (uint256);

    function getDataAfter(
        bytes32 _queryId,
        uint256 _timestamp
    ) external view returns (bytes memory _value, uint256 _timestampRetrieved);

    function getDataFeed(
        bytes32 _feedId
    ) external view returns (Autopay.FeedDetails memory);

    function getFundedFeeds() external view returns (bytes32[] memory);

    function getFundedQueryIds() external view returns (bytes32[] memory);

    function getIndexForDataAfter(
        bytes32 _queryId,
        uint256 _timestamp
    ) external view returns (bool _found, uint256 _index);

    function getIndexForDataBefore(
        bytes32 _queryId,
        uint256 _timestamp
    ) external view returns (bool _found, uint256 _index);

    function getMultipleValuesBefore(
        bytes32 _queryId,
        uint256 _timestamp,
        uint256 _maxAge,
        uint256 _maxCount
    )
        external
        view
        returns (uint256[] memory _values, uint256[] memory _timestamps);

    function getPastTipByIndex(
        bytes32 _queryId,
        uint256 _index
    ) external view returns (Autopay.Tip memory);

    function getPastTipCount(bytes32 _queryId) external view returns (uint256);

    function getPastTips(
        bytes32 _queryId
    ) external view returns (Autopay.Tip[] memory);

    function getQueryIdFromFeedId(
        bytes32 _feedId
    ) external view returns (bytes32);

    function getRewardAmount(
        bytes32 _feedId,
        bytes32 _queryId,
        uint256[] memory _timestamps
    ) external view returns (uint256 _cumulativeReward);

    function getRewardClaimedStatus(
        bytes32 _feedId,
        bytes32 _queryId,
        uint256 _timestamp
    ) external view returns (bool);

    function getTipsByAddress(address _user) external view returns (uint256);

    function isInDispute(
        bytes32 _queryId,
        uint256 _timestamp
    ) external view returns (bool);

    function queryIdFromDataFeedId(bytes32) external view returns (bytes32);

    function queryIdsWithFunding(uint256) external view returns (bytes32);

    function queryIdsWithFundingIndex(bytes32) external view returns (uint256);

    function setupDataFeed(
        bytes32 _queryId,
        uint256 _reward,
        uint256 _startTime,
        uint256 _interval,
        uint256 _window,
        uint256 _priceThreshold,
        uint256 _rewardIncreasePerSecond,
        bytes memory _queryData,
        uint256 _amount
    ) external;

    function fetch() external view returns (address);

    function tip(
        bytes32 _queryId,
        uint256 _amount,
        bytes memory _queryData
    ) external;

    function tips(
        bytes32,
        uint256
    ) external view returns (uint256 amount, uint256 timestamp);

    function token() external view returns (address);

    function userTipsTotal(address) external view returns (uint256);

    function valueFor(
        bytes32 _id
    )
        external
        view
        returns (int256 _value, uint256 _timestamp, uint256 _statusCode);
}

interface Autopay {
    struct FeedDetails {
        uint256 reward;
        uint256 balance;
        uint256 startTime;
        uint256 interval;
        uint256 window;
        uint256 priceThreshold;
        uint256 rewardIncreasePerSecond;
        uint256 feedsWithFundingIndex;
    }

    struct Tip {
        uint256 amount;
        uint256 timestamp;
    }

    function getStakeAmount() external view returns (uint256);

    function stakeAmount() external view returns (uint256);

    function token() external view returns (address);
}
          

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IMappingContract {
    function getFetchID(bytes32 _id) external view returns (bytes32);
}
          

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./IFetch.sol";
import "./IERC2362.sol";
import "./IMappingContract.sol";

/**
 @author Fetch Inc
 @title UsingFetch
 @dev This contract helps smart contracts read data from Fetch
 */
contract UsingFetch is IERC2362 {
    IFetch public fetch;
    IMappingContract public idMappingContract;

    /*Constructor*/
    /**
     * @dev the constructor sets the oracle address in storage
     * @param _fetch is the Fetch Oracle address
     */
    constructor(address payable _fetch) {
        fetch = IFetch(_fetch);
    }

    /*Getters*/
    /**
     * @dev Retrieves the next value for the queryId after the specified timestamp
     * @param _queryId is the queryId to look up the value for
     * @param _timestamp after which to search for next value
     * @return _value the value retrieved
     * @return _timestampRetrieved the value's timestamp
     */
    function getDataAfter(
        bytes32 _queryId,
        uint256 _timestamp
    ) public view returns (bytes memory _value, uint256 _timestampRetrieved) {
        (bool _found, uint256 _index) = getIndexForDataAfter(
            _queryId,
            _timestamp
        );
        if (!_found) {
            return ("", 0);
        }
        _timestampRetrieved = getTimestampbyQueryIdandIndex(_queryId, _index);
        _value = retrieveData(_queryId, _timestampRetrieved);
        return (_value, _timestampRetrieved);
    }

    /**
     * @dev Retrieves the latest value for the queryId before the specified timestamp
     * @param _queryId is the queryId to look up the value for
     * @param _timestamp before which to search for latest value
     * @return _value the value retrieved
     * @return _timestampRetrieved the value's timestamp
     */
    function getDataBefore(
        bytes32 _queryId,
        uint256 _timestamp
    ) public view returns (bytes memory _value, uint256 _timestampRetrieved) {
        (, _value, _timestampRetrieved) = fetch.getDataBefore(
            _queryId,
            _timestamp
        );
    }

    /**
     * @dev Retrieves latest array index of data before the specified timestamp for the queryId
     * @param _queryId is the queryId to look up the index for
     * @param _timestamp is the timestamp before which to search for the latest index
     * @return _found whether the index was found
     * @return _index the latest index found before the specified timestamp
     */
    // slither-disable-next-line calls-loop
    function getIndexForDataAfter(
        bytes32 _queryId,
        uint256 _timestamp
    ) public view returns (bool _found, uint256 _index) {
        uint256 _count = getNewValueCountbyQueryId(_queryId);
        if (_count == 0) return (false, 0);
        _count--;
        bool _search = true; // perform binary search
        uint256 _middle = 0;
        uint256 _start = 0;
        uint256 _end = _count;
        uint256 _timestampRetrieved;
        // checking boundaries to short-circuit the algorithm
        _timestampRetrieved = getTimestampbyQueryIdandIndex(_queryId, _end);
        if (_timestampRetrieved <= _timestamp) return (false, 0);
        _timestampRetrieved = getTimestampbyQueryIdandIndex(_queryId, _start);
        if (_timestampRetrieved > _timestamp) {
            // candidate found, check for disputes
            _search = false;
        }
        // since the value is within our boundaries, do a binary search
        while (_search) {
            _middle = (_end + _start) / 2;
            _timestampRetrieved = getTimestampbyQueryIdandIndex(
                _queryId,
                _middle
            );
            if (_timestampRetrieved > _timestamp) {
                // get immediate previous value
                uint256 _prevTime = getTimestampbyQueryIdandIndex(
                    _queryId,
                    _middle - 1
                );
                if (_prevTime <= _timestamp) {
                    // candidate found, check for disputes
                    _search = false;
                } else {
                    // look from start to middle -1(prev value)
                    _end = _middle - 1;
                }
            } else {
                // get immediate next value
                uint256 _nextTime = getTimestampbyQueryIdandIndex(
                    _queryId,
                    _middle + 1
                );
                if (_nextTime > _timestamp) {
                    // candidate found, check for disputes
                    _search = false;
                    _middle++;
                    _timestampRetrieved = _nextTime;
                } else {
                    // look from middle + 1(next value) to end
                    _start = _middle + 1;
                }
            }
        }
        // candidate found, check for disputed values
        if (!isInDispute(_queryId, _timestampRetrieved)) {
            // _timestampRetrieved is correct
            return (true, _middle);
        } else {
            // iterate forward until we find a non-disputed value
            while (
                isInDispute(_queryId, _timestampRetrieved) && _middle < _count
            ) {
                _middle++;
                _timestampRetrieved = getTimestampbyQueryIdandIndex(
                    _queryId,
                    _middle
                );
            }
            if (
                _middle == _count && isInDispute(_queryId, _timestampRetrieved)
            ) {
                return (false, 0);
            }
            // _timestampRetrieved is correct
            return (true, _middle);
        }
    }

    /**
     * @dev Retrieves latest array index of data before the specified timestamp for the queryId
     * @param _queryId is the queryId to look up the index for
     * @param _timestamp is the timestamp before which to search for the latest index
     * @return _found whether the index was found
     * @return _index the latest index found before the specified timestamp
     */
    // slither-disable-next-line calls-loop
    function getIndexForDataBefore(
        bytes32 _queryId,
        uint256 _timestamp
    ) public view returns (bool _found, uint256 _index) {
        return fetch.getIndexForDataBefore(_queryId, _timestamp);
    }

    /**
     * @dev Retrieves multiple uint256 values before the specified timestamp
     * @param _queryId the unique id of the data query
     * @param _timestamp the timestamp before which to search for values
     * @param _maxAge the maximum number of seconds before the _timestamp to search for values
     * @param _maxCount the maximum number of values to return
     * @return _values the values retrieved, ordered from oldest to newest
     * @return _timestamps the timestamps of the values retrieved
     */
    function getMultipleValuesBefore(
        bytes32 _queryId,
        uint256 _timestamp,
        uint256 _maxAge,
        uint256 _maxCount
    )
        public
        view
        returns (bytes[] memory _values, uint256[] memory _timestamps)
    {
        // get index of first possible value
        (bool _ifRetrieve, uint256 _startIndex) = getIndexForDataAfter(
            _queryId,
            _timestamp - _maxAge
        );
        // no value within range
        if (!_ifRetrieve) {
            return (new bytes[](0), new uint256[](0));
        }
        uint256 _endIndex;
        // get index of last possible value
        (_ifRetrieve, _endIndex) = getIndexForDataBefore(_queryId, _timestamp);
        // no value before _timestamp
        if (!_ifRetrieve) {
            return (new bytes[](0), new uint256[](0));
        }
        uint256 _valCount = 0;
        uint256 _index = 0;
        uint256[] memory _timestampsArrayTemp = new uint256[](_maxCount);
        // generate array of non-disputed timestamps within range
        while (_valCount < _maxCount && _endIndex + 1 - _index > _startIndex) {
            uint256 _timestampRetrieved = getTimestampbyQueryIdandIndex(
                _queryId,
                _endIndex - _index
            );
            if (!isInDispute(_queryId, _timestampRetrieved)) {
                _timestampsArrayTemp[_valCount] = _timestampRetrieved;
                _valCount++;
            }
            _index++;
        }

        bytes[] memory _valuesArray = new bytes[](_valCount);
        uint256[] memory _timestampsArray = new uint256[](_valCount);
        // retrieve values and reverse timestamps order
        for (uint256 _i = 0; _i < _valCount; _i++) {
            _timestampsArray[_i] = _timestampsArrayTemp[_valCount - 1 - _i];
            _valuesArray[_i] = retrieveData(_queryId, _timestampsArray[_i]);
        }
        return (_valuesArray, _timestampsArray);
    }

    /**
     * @dev Counts the number of values that have been submitted for the queryId
     * @param _queryId the id to look up
     * @return uint256 count of the number of values received for the queryId
     */
    function getNewValueCountbyQueryId(
        bytes32 _queryId
    ) public view returns (uint256) {
        return fetch.getNewValueCountbyQueryId(_queryId);
    }

    /**
     * @dev Returns the address of the reporter who submitted a value for a data ID at a specific time
     * @param _queryId is ID of the specific data feed
     * @param _timestamp is the timestamp to find a corresponding reporter for
     * @return address of the reporter who reported the value for the data ID at the given timestamp
     */
    function getReporterByTimestamp(
        bytes32 _queryId,
        uint256 _timestamp
    ) public view returns (address) {
        return fetch.getReporterByTimestamp(_queryId, _timestamp);
    }

    /**
     * @dev Gets the timestamp for the value based on their index
     * @param _queryId is the id to look up
     * @param _index is the value index to look up
     * @return uint256 timestamp
     */
    function getTimestampbyQueryIdandIndex(
        bytes32 _queryId,
        uint256 _index
    ) public view returns (uint256) {
        return fetch.getTimestampbyQueryIdandIndex(_queryId, _index);
    }

    /**
     * @dev Determines whether a value with a given queryId and timestamp has been disputed
     * @param _queryId is the value id to look up
     * @param _timestamp is the timestamp of the value to look up
     * @return bool true if queryId/timestamp is under dispute
     */
    function isInDispute(
        bytes32 _queryId,
        uint256 _timestamp
    ) public view returns (bool) {
        return fetch.isInDispute(_queryId, _timestamp);
    }

    /**
     * @dev Retrieve value from oracle based on queryId/timestamp
     * @param _queryId being requested
     * @param _timestamp to retrieve data/value from
     * @return bytes value for query/timestamp submitted
     */
    function retrieveData(
        bytes32 _queryId,
        uint256 _timestamp
    ) public view returns (bytes memory) {
        return fetch.retrieveData(_queryId, _timestamp);
    }

    /**
     * @dev allows dev to set mapping contract for valueFor (EIP2362)
     * @param _addy address of mapping contract
     */
    function setIdMappingContract(address _addy) external {
        require(address(idMappingContract) == address(0));
        idMappingContract = IMappingContract(_addy);
    }

    /**
     * @dev Retrieve most recent int256 value from oracle based on queryId
     * @param _id being requested
     * @return _value most recent value submitted
     * @return _timestamp timestamp of most recent value
     * @return _statusCode 200 if value found, 404 if not found
     */
    function valueFor(
        bytes32 _id
    )
        external
        view
        override
        returns (int256 _value, uint256 _timestamp, uint256 _statusCode)
    {
        bytes32 _queryId = idMappingContract.getFetchID(_id);
        bytes memory _valueBytes;
        (_valueBytes, _timestamp) = getDataBefore(
            _queryId,
            block.timestamp + 1
        );
        if (_timestamp == 0) {
            return (0, 0, 404);
        }
        uint256 _valueUint = _sliceUint(_valueBytes);
        _value = int256(_valueUint);
        return (_value, _timestamp, 200);
    }

    // Internal functions
    /**
     * @dev Convert bytes to uint256
     * @param _b bytes value to convert to uint256
     * @return _number uint256 converted from bytes
     */
    function _sliceUint(
        bytes memory _b
    ) internal pure returns (uint256 _number) {
        for (uint256 _i = 0; _i < _b.length; _i++) {
            _number = _number * 256 + uint8(_b[_i]);
        }
    }
}