Working with Oracle

pragma solidity ^0.7.0;

import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/math/SafeMath.sol";

contract Oracle {
    function requestPrice(string memory symbol) public view returns (uint price);
}

contract CryptoPrice {
    using SafeMath for uint;

    Oracle oracle;

    constructor(address _oracle) public {
        oracle = Oracle(_oracle);
    }

    function requestPrice(string memory symbol) public view returns (uint price) {
        return oracle.requestPrice(symbol);
    }
}

pragma solidity ^0.7.0;

import "https://github.com/OpenZeppelin/openzeppelin-solidity/contracts/math/SafeMath.sol";

contract Oracle {
    function requestPrice(string memory symbol) public view returns (uint price);
}

contract CryptoBet {
    using SafeMath for uint;

    Oracle oracle;
    mapping(string => uint) public betPrices;

    constructor(address _oracle) public {
        oracle = Oracle(_oracle);
    }

    function placeBet(string memory symbol, uint amount, uint timestamp) public payable {
        betPrices[symbol] = oracle.requestPrice(symbol);
        require(now <= timestamp, "Bet resolution time has already passed.");
        require(amount <= msg.value, "Bet amount must be equal to or greater than the value sent.");
        require(amount > 0, "Bet amount must be greater than 0.");

        uint currentPrice = oracle.requestPrice(symbol);
        if (currentPrice > betPrices[symbol]) {
            // bet was correct, send amount to winner
            msg.sender.transfer(amount);
        } else if (currentPrice < betPrices[symbol]) {
            // bet was incorrect, send amount to contract owner
            address(owner).transfer(amount);
        }
        // bet was a tie, do nothing
    }
}

First, we need to define the event in our contract:

event NewTemperature(uint temperature);

Next, we will create a function that will be called by the oracle service to trigger the event:

function updateTemperature(uint _temperature) public {
    emit NewTemperature(_temperature);
}

To retrieve the temperature data from the oracle service, we will use the oraclize_query function. Here is an example of how to use it to get the current temperature in New York City:

oraclize_query("URL", "json(http://api.openweathermap.org/data/2.5/weather?q=New%20York,us).main.temp");

We can then parse the temperature data and call the updateTemperature function to trigger the event:

function __callback(bytes32 _queryId, string _result) public {
    uint temperature = parseInt(_result, 0);
    updateTemperature(temperature);
}

First, we will define a struct to represent a bet and an array to store all the bets:

struct Bet {
    uint amount;
    uint teamA;
    uint teamB;
}

Bet[] public bets;

Next, we will create a function for users to place their bets:

function placeBet(uint _amount, uint _teamA, uint _teamB) public payable {
    require(msg.value == _amount, "Incorrect bet amount");
    bets.push(Bet(_amount, _teamA, _teamB));
}

To retrieve the final score from the oracle service, we can use the oraclize_query function in a similar way as in the previous exercise. Once we have the final score, we can iterate through the bets array and pay out the winners:

function __callback(bytes32 _queryId, string _result) public {
    uint scoreA = parseInt(_result, 0);
    uint scoreB = parseInt(_result, 1);

    for (uint i = 0; i < bets.length; i++) {
        if (scoreA > scoreB && bets[i].teamA > bets[i].teamB) {
            msg.sender.transfer(bets[i].amount);
        } else if (scoreA < scoreB && bets[i].teamA < bets[i].teamB) {
            msg.sender.transfer(bets[i].amount);
        }
    }
}

pragma solidity ^0.6.0;

import "https://github.com/oraclize/ethereum-api/solidity/contracts/oraclizeAPI.sol";

// contract to get current temperature in Fahrenheit for a given city
contract TemperatureOracle {
    // variable to store the current temperature in Fahrenheit
    uint temperature;

    // event to be emitted when the temperature is updated
    event TemperatureUpdate(uint temperature);

    // constructor to set the oracle address
    constructor() public {
        oraclize_setProof(proofType_TLSNotary | proofStorage_IPFS);
    }

    // function to get the current temperature in Fahrenheit for a given city
    function getTemperature(string memory city) public {
        // call the oracle to get the current temperature in Fahrenheit for the given city
        oraclize_query(60, "URL", "json(https://api.openweathermap.org/data/2.5/weather?q=" + city + "&units=imperial).main.temp");
    }

    // callback function to handle the response from the oracle
    function __callback(bytes32 queryId, string memory result, bytes memory proof) public {
        // parse the result string to extract the temperature in Fahrenheit
        temperature = uint(parseInt(result));

        // emit the TemperatureUpdate event
        emit TemperatureUpdate(temperature);
    }
}