Oracle Contract

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;

interface IOracle {
	struct Response {
		uint256 timestamp;
		uint256 value;
		uint256 requestId;
	}

	function createRequest(uint32 _token) external returns (uint256);

	function createRequests(uint32 _tokens) external returns (uint[] memory);

	function createResponse(uint256 _value, uint256 _requestId) external;

	function deposit(uint256 _amount, address _sender) external;

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

	function getPendingRequests(bool _breakOnProcessed) external view returns (uint256[] memory);

	function getRemainingRequests(address _address) external view returns (uint256);

	function getResponse(uint256 _requestId) external view returns (Response memory);

	function isProcessed(uint256 _requestId) external view returns (bool);

	function pricePerRequest() external view returns (uint256);

	function requestId() external view returns (uint256);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;

import './IOracle.sol';

contract Example {
    IOracle public oracle;
    uint public lastData;

    constructor(IOracle _oracle) {
        oracle = _oracle;
    }

    function retrieveData(string calldata _token) external {
        oracle.createRequest(_token);
    }

    function useData(uint _requestId) external {
        IOracle.Response memory data = oracle.getResponse(_requestId);
        uint timestamp = data.timestamp;
        if (timestamp + 1 days >= block.timestamp) {
            // Do something with the timestamp
        }
        uint value = data.value;
        lastData = value;
    }
}

struct Request {
        uint32 tokenId;
        uint256 timestamp;
        bool processed;
    }

struct Response {
        uint256 timestamp;
        uint256 value;
        uint256 requestId;
    }