Unleash the Power of Decentralized Oracles with Orally!

                            
                        // fetch price feed
const fetchData = async () => {
  const response = await fetch("https://wth3l-tiaaa-aaaap-aa5uq-cai.icp0.io/get_asset_data_with_proof?pair_id=ICP/USD");
  const data = await response.json();
  console.log(data);
}

fetchData();
                            
// response example                            
{
    "symbol": "ICP/USD",
    "rate": 4902941764,
    "timestamp": 1685442778,
    "decimals": 9,
    "signature": "5d4368547f194ff784d904cc9052108894044bba7588d2447bd13f070128ef6d690e12094b5e3c6c304187587cd6ff8b4d35dfc3ea4b7165f79d2e881b446dd31c"
}
                        
                    

                            
                        // verify price feed in your smart contract logic

import "path-to/IOrallyVerifierOracle.sol";

contract MyContract {
    IOrallyVerifierOracle public orallyVerifier;

    constructor(address _orallyVerifierAddress) {
        orallyVerifier = IOrallyVerifierOracle(_orallyVerifierAddress);
    }

    function executeTransaction(
        string memory _pairId,
        uint256 _price,
        uint256 _decimals,
        uint256 _timestamp,
        bytes memory _signature
    ) public {
        require(
            orallyVerifier.verifyUnpacked(_pairId, _price, _decimals, _timestamp, _signature),
            "Data verification failed"
        );

        // Execute your business logic here...
    }
}
                        
                    

                            
                        // only Pythia's executor could update value

import {OrallyPythiaConsumer} from "../consumers/OrallyPythiaConsumer.sol";

contract PythiaExecutionExample is OrallyPythiaConsumer {
    uint256 public value;

    constructor(
        address _pythiaRegistry
    ) OrallyPythiaConsumer(_pythiaRegistry) {}

    function updateValue(uint256 _value) external onlyExecutor {
        value = _value;
    }
}
                    

                            
                        // Pythia triggers `pickWinner` with random number

import {OrallyPythiaConsumer} from  "../consumers/OrallyPythiaConsumer.sol";

contract RaffleExample is OrallyPythiaConsumer {
    uint256 maxNumberOfTickets;
    uint256 ticketPrice;
    address[] entries;

    constructor(
        address _pythiaRegistry,
        uint256 _maxNumberOfTickets,
        uint256 _ticketPrice
    ) OrallyPythiaConsumer(_pythiaRegistry) {
        maxNumberOfTickets = _maxNumberOfTickets;
        ticketPrice = _ticketPrice;
    }

    function enterRaffle() external payable {
        require(
            entries.length < maxNumberOfTickets,
            "RaffleExample: Raffle is full"
        );
        require(
            msg.value == ticketPrice,
            "RaffleExample: Ticket price is not correct"
        );
        entries.push(msg.sender);
    }

    function pickWinner(uint256 _randomNumber) external onlyExecutor {
        require(
            entries.length == maxNumberOfTickets,
            "RaffleExample: Raffle is not full"
        );
        uint256 winnerIndex = _randomNumber % entries.length;
        payable(entries[winnerIndex]).call{value: address(this).balance}("");
    }
}
                        
                    

                            
                        // price feed contract which Pythia regularly updates by Sybil price feed

import {OrallyPythiaConsumer} from "../consumers/OrallyPythiaConsumer.sol";

interface IFxPriceFeedExample {
    function pair() external view returns (string memory);

    function baseTokenAddr() external view returns (address);

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

contract FxPriceFeedExample is OrallyPythiaConsumer, IFxPriceFeedExample {
    uint256 public rate;
    uint256 public lastUpdate;
    string public pair;
    address public baseTokenAddr;
    uint256 public decimalPlaces;

    constructor(
        address _pythiaRegistry,
        string memory _pair,
        address _baseTokenAddr,
        uint256 _decimalPlaces
    ) OrallyPythiaConsumer(_pythiaRegistry) {
        pair = _pair;
        baseTokenAddr = _baseTokenAddr;
        decimalPlaces = _decimalPlaces;
    }

    function updateRate(
        string memory _pairId,
        uint256 _rate,
        uint256 _decimals,
        uint256 _timestamp
    ) external onlyExecutor {
        rate = (_rate * (10 ** decimalPlaces)) / (10 ** _decimals); // normalise rate
        lastUpdate = _timestamp;
    }

    function updateTime() external view returns (uint256) {
        return lastUpdate;
    }

    function exchangeRate() external view returns (uint256) {
        return rate;
    }
}