// File: contracts/src/v0.6/vendor/SafeMathChainlink.sol pragma solidity ^0.6.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 SafeMathChainlink { /** * @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"); uint256 c = a - b; return c; } /** * @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) { // 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-solidity/pull/522 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. Reverts 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) { // Solidity only automatically asserts when dividing by 0 require(b > 0, "SafeMath: division by zero"); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts 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; } } // File: contracts/src/v0.6/interfaces/AggregatorV3Interface.sol pragma solidity ^0.6.0; interface AggregatorV3Interface { function decimals() external view returns ( uint8 ); function description() external view returns ( string memory ); function version() external view returns ( uint256 ); // getRoundData and latestRoundData should both raise "No data present" // if they do not have data to report, instead of returning unset values // which could be misinterpreted as actual reported values. function getRoundData( uint80 _roundId ) external view returns ( uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound ); function latestRoundData() external view returns ( uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound ); } // File: contracts/src/v0.6/vendor/Ownable.sol pragma solidity ^0.6.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be aplied to your functions to restrict their use to * the owner. * * This contract has been modified to remove the revokeOwnership function */ contract Ownable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { _owner = msg.sender; emit OwnershipTransferred(address(0), _owner); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(isOwner(), "Ownable: caller is not the owner"); _; } /** * @dev Returns true if the caller is the current owner. */ function isOwner() public view returns (bool) { return msg.sender == _owner; } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). */ function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // File: contracts/src/v0.6/ShadowAggregator.sol pragma solidity 0.6.6; /** * @title The Prepaid Aggregator contract * @notice Handles aggregating data pushed in from off-chain. Oracles' submissions are gathered in * rounds, with each round aggregating the submissions for each oracle into a * single answer. The latest aggregated answer is exposed as well as historical * answers and their updated at timestamp. */ contract ShadowAggregator is AggregatorV3Interface, Ownable { using SafeMathChainlink for uint256; enum Role{Unset, Transmitter, Signer} struct Round { int256 answer; uint256 startedAt; uint256 updatedAt; uint80 answeredInRound; } struct Oracle { uint16 index; Role role; } AggregatorV3Interface public aggregator; uint8 private dcls; string private desc; address public originAggregator; uint256 constant private MAX_ORACLE_COUNT = 31; uint80 constant private ROUND_MAX = 2**80-1; uint40 internal latestEpochAndRound; uint80 public latestRoundId; bytes16 public configDigest; uint32 public configCount; mapping(uint80 => Round) internal rounds; mapping(address => Oracle) public oracles; address[] private signers; address[] private transmitters; event SubmissionReceived( int256 indexed submission, uint80 indexed round, address indexed oracle ); constructor( address _origin, uint8 _decimals, string memory _description ) public { originAggregator = _origin; dcls = _decimals; desc = _description; } function decimals() external override view returns (uint8) { AggregatorV3Interface aggr = aggregator; if (address(aggr) != address(0)) { return aggr.decimals(); } return dcls; } function description() external override view returns (string memory) { AggregatorV3Interface aggr = aggregator; if (address(aggr) != address(0)) { return aggr.description(); } return desc; } function version() external override view returns (uint256) { AggregatorV3Interface aggr = aggregator; if (address(aggr) != address(0)) { return aggr.version(); } return 4; } function setConfigCount(uint32 _count) external onlyOwner { configCount = _count; } function setAggregator(AggregatorV3Interface _aggregator) external onlyOwner { aggregator = _aggregator; } /** * @notice sets offchain reporting protocol configuration incl. participating oracles * @param _signers addresses with which oracles sign the reports * @param _transmitters addresses oracles use to transmit the reports * @param _threshold number of faulty oracles the system can tolerate * @param _encodedConfigVersion version number for offchainEncoding schema * @param _encoded encoded off-chain oracle configuration */ function setConfig( address[] calldata _signers, address[] calldata _transmitters, uint8 _threshold, uint64 _encodedConfigVersion, bytes calldata _encoded ) external onlyOwner() { while (signers.length != 0) { // remove any old signer/transmitter addresses uint lastIdx = signers.length - 1; address signer = signers[lastIdx]; address transmitter = transmitters[lastIdx]; delete oracles[signer]; delete oracles[transmitter]; signers.pop(); transmitters.pop(); } for (uint i = 0; i < _signers.length; i++) { // add new signer/transmitter addresses require( oracles[_signers[i]].role == Role.Unset, "repeated signer address" ); oracles[_signers[i]] = Oracle(uint8(i), Role.Signer); require( oracles[_transmitters[i]].role == Role.Unset, "repeated transmitter address" ); oracles[_transmitters[i]] = Oracle(uint8(i), Role.Transmitter); signers.push(_signers[i]); transmitters.push(_transmitters[i]); } configCount += 1; configDigest = configDigestFromConfigData( originAggregator, configCount, _signers, _transmitters, _threshold, _encodedConfigVersion, _encoded ); latestEpochAndRound = 0; } function configDigestFromConfigData( address _contractAddress, uint64 _configCount, address[] memory _signers, address[] memory _transmitters, uint8 _threshold, uint64 _encodedConfigVersion, bytes memory _encodedConfig ) internal pure returns (bytes16) { return bytes16(keccak256(abi.encode(_contractAddress, _configCount, _signers, _transmitters, _threshold, _encodedConfigVersion, _encodedConfig ))); } /** * @notice called by oracles when they have witnessed a need to update * @param _report is the observations * @param _rs is the r of oracles * @param _ss is the s of oracles * @param _rawVs is the v of oracles */ function submit( bytes calldata _report, bytes32[] calldata _rs, bytes32[] calldata _ss, bytes32 _rawVs ) external { require(_rs.length == _ss.length, "signatures out of registration"); require(_rs.length <= MAX_ORACLE_COUNT, "too many signatures"); { bytes32 h = keccak256(_report); bool[MAX_ORACLE_COUNT] memory signed; Oracle memory oracle; for (uint i = 0; i < _rs.length; i++) { address signer = ecrecover(h, uint8(_rawVs[i])+27, _rs[i], _ss[i]); oracle = oracles[signer]; require(oracle.role == Role.Signer, "not an active oracle"); require(!signed[oracle.index], "non-unique signature"); signed[oracle.index] = true; } } (bytes32 rawReportContext, bytes32 rawObservers, int192[] memory observations) = abi.decode(_report, (bytes32, bytes32, int192[])); require(bytes16(rawReportContext << 88) == configDigest, "config digest mismatch"); uint40 epochAndRound = uint40(uint256(rawReportContext)); require(latestEpochAndRound < epochAndRound, "stale report"); bytes memory observers = new bytes(observations.length); { bool[MAX_ORACLE_COUNT] memory seen; for (uint8 i = 0; i < observations.length; i++) { uint8 observerIdx = uint8(rawObservers[i]); require(!seen[observerIdx], "duplicate observer index"); seen[observerIdx] = true; observers[i] = rawObservers[i]; } } for (uint8 i = 0; i < observations.length - 1; i++) { bool inOrder = observations[i] <= observations[i+1]; require(inOrder, "observations not sorted"); } int192 median = observations[observations.length/2]; uint80 rid = latestRoundId + 1; rounds[rid].answer = median; rounds[rid].startedAt = block.timestamp; rounds[rid].updatedAt = block.timestamp; rounds[rid].answeredInRound = rid; latestRoundId = rid; latestEpochAndRound = epochAndRound; } function oracleCount() public view returns (uint8) { return uint8(signers.length); } function getOracles() external view returns (address[] memory) { return signers; } function getRoundData(uint80 _roundId) public view virtual override returns ( uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound ) { AggregatorV3Interface aggr = aggregator; if (address(aggr) != address(0)) { return aggr.getRoundData(_roundId); } Round memory r = rounds[uint64(_roundId)]; require(r.answeredInRound > 0 && _roundId <= ROUND_MAX, "No data present"); return ( _roundId, r.answer, r.startedAt, r.updatedAt, r.answeredInRound ); } function latestRoundData() public view virtual override returns ( uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound ) { AggregatorV3Interface aggr = aggregator; if (address(aggr) != address(0)) { return aggr.latestRoundData(); } return getRoundData(latestRoundId); } }