Contract Name:
PriceFeedStore
Contract Source Code:
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @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.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
contract PriceFeedStore is Ownable {
address public xOracle;
string public name;
uint256 public tokenIndex;
uint256 public decimals;
// price store
struct PriceData {
uint256 price;
uint256 latestPrice;
uint256 timestamp;
}
mapping(uint256 => PriceData) public pricesData;
uint256 public latestRound;
uint256 public latestTimestamp;
event UpdatePrice(uint256 indexed tokenIndex, uint256 roundId, uint256 price, uint256 latestPrice, uint256 timestamp);
event SetXOracle(address xOracle);
modifier onlyXOracle() {
require(xOracle == msg.sender, "xOracle: forbidden");
_;
}
constructor(address _xOracle, string memory _name, uint256 _tokenIndex, uint256 _decimals) {
require(_xOracle != address(0), "address invalid");
xOracle = _xOracle;
name = _name;
tokenIndex = _tokenIndex;
decimals = _decimals;
}
// ------------------------------
// xOracle setPrice
// ------------------------------
function setPrice(uint256 _price, uint256 _timestamp) external onlyXOracle {
// Sometimes the fulfill request is not in order in a short time.
// So it's possible that the price is not the latest price.
// _price is the fulfilling price, but latestPrice is the newest price at the time.
uint256 latestPrice;
if (_timestamp > latestTimestamp) {
latestPrice = _price;
latestTimestamp = _timestamp;
} else {
latestPrice = pricesData[latestRound].latestPrice;
}
// next round
latestRound++;
// already checked correct tokenIndex in xOracle.setPriceFeedStore
pricesData[latestRound] = PriceData({
price: _price,
latestPrice: latestPrice,
timestamp: block.timestamp
});
emit UpdatePrice(tokenIndex, latestRound, _price, latestPrice, block.timestamp);
}
// ------------------------------
// onlyOwner
// ------------------------------
function setXOracle(address _xOracle) external onlyOwner {
require(_xOracle != address(0), "address invalid");
xOracle = _xOracle;
emit SetXOracle(_xOracle);
}
// ------------------------------
// view function
// ------------------------------
function getLastPrice() external view returns (uint256, uint256, uint256, uint256) {
PriceData memory priceData = pricesData[latestRound];
return (
latestRound,
priceData.price,
priceData.latestPrice,
priceData.timestamp
);
}
function getPrice(uint256 _roundId) external view returns (uint256, uint256, uint256, uint256) {
PriceData memory priceData = pricesData[_roundId];
return (
_roundId,
priceData.price,
priceData.latestPrice,
priceData.timestamp
);
}
}