Oracles and Chainlink: Connecting Blockchains to Real-World Data

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

// Problem: Contract cannot access external data
contract BlindContract {
    // This WILL NOT WORK - contracts can't make HTTP requests
    /* function getETHPrice() public returns (uint256) {
        // Impossible without oracle
        return fetch("https://api.coingecko.com/api/v3/simple/price?ids=ethereum");
    } */
    
    // Solution: Use oracle to inject data
    uint256 public lastETHPrice;
    address public oracle;
    
    function updatePrice(uint256 _newPrice) external {
        require(msg.sender == oracle, "Only oracle");
        lastETHPrice = _newPrice;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract PriceConsumer {
    AggregatorV3Interface internal priceFeed;
    
    // Sepolia ETH/USD feed
    constructor() {
        priceFeed = AggregatorV3Interface(0x694AA1769357215DE4FAC081bf1f309aDC325306);
    }
    
    function getLatestPrice() public view returns (uint256) {
        (, int256 price, , , ) = priceFeed.latestRoundData();
        // Price has 8 decimals (e.g., 200000000000 = $2000.00)
        return uint256(price);
    }
    
    function getDecimals() public view returns (uint8) {
        return priceFeed.decimals();  // Usually 8 for USD pairs
    }
    
    function getHistoricalPrice(uint256 _roundId) public view returns (uint256) {
        (, int256 price, , , ) = priceFeed.getRoundData(_roundId);
        return uint256(price);
    }
    
    function getPriceInUSD(uint256 _ethAmount) public view returns (uint256) {
        uint256 ethPrice = getLatestPrice();
        // Convert ETH to USD: amount * price / 10**18 * 10**8 / 10**8
        return (_ethAmount * ethPrice) / 1e18;
    }
}

// Expected output:
// getLatestPrice() -> 200000000000 (ETH at $2000.00)
// getDecimals() -> 8
// getPriceInUSD(1e18) -> 200000000000 ($2000.00 for 1 ETH)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";

contract RandomWinner is VRFConsumerBaseV2 {
    VRFCoordinatorV2Interface COORDINATOR;
    
    uint64 private subscriptionId;
    bytes32 private keyHash = 0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c;
    uint32 private callbackGasLimit = 100000;
    uint16 private requestConfirmations = 3;
    uint32 private numWords = 1;
    
    address[] public players;
    address public recentWinner;
    uint256 public randomResult;
    
    event RequestSent(uint256 requestId);
    event WinnerSelected(address winner);
    
    constructor(uint64 _subscriptionId) VRFConsumerBaseV2(0x8103B0A8A00be2DDC778e6e7eaa21791Cd364625) {
        COORDINATOR = VRFCoordinatorV2Interface(0x8103B0A8A00be2DDC778e6e7eaa21791Cd364625);
        subscriptionId = _subscriptionId;
    }
    
    function enterRaffle() external payable {
        require(msg.value >= 0.01 ether, "Min 0.01 ETH");
        players.push(msg.sender);
    }
    
    function pickWinner() external returns (uint256 requestId) {
        requestId = COORDINATOR.requestRandomWords(
            keyHash,
            subscriptionId,
            requestConfirmations,
            callbackGasLimit,
            numWords
        );
        emit RequestSent(requestId);
    }
    
    function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal override {
        randomResult = randomWords[0];
        uint256 winnerIndex = randomWords[0] % players.length;
        recentWinner = players[winnerIndex];
        
        emit WinnerSelected(recentWinner);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import {FunctionsClient} from "@chainlink/contracts/src/v0.8/functions/v1/FunctionsClient.sol";
import {ConfirmedOwner} from "@chainlink/contracts/src/v0.8/shared/access/ConfirmedOwner.sol";

contract WeatherConsumer is FunctionsClient, ConfirmedOwner {
    using FunctionsRequest for FunctionsRequest.Request;
    
    bytes32 public latestTemp;
    
    event WeatherResponse(bytes32 indexed temp);
    
    constructor(address oracle) FunctionsClient(oracle) ConfirmedOwner(msg.sender) {}
    
    function requestWeatherData() external onlyOwner {
        FunctionsRequest.Request memory req;
        
        // JavaScript source code to fetch weather API
        req.source = `
            const url = "https://api.weather.com/v3/wx/conditions/current";
            const apiKey = secrets.apiKey;
            
            const response = await Functions.makeHttpRequest({
                url: url + "?city=London&format=json",
                headers: { "x-api-key": apiKey }
            });
            
            const temp = response.data.temperature;
            return Functions.encodeUint256(Math.round(temp));
        `;
        
        // Encrypted secrets
        req.secrets = []; // Set via DON hosting
        
        req.args = ["London"];
        
        bytes32 requestId = _sendRequest(
            req.encodeCBOR(),
            subscriptionId,
            callbackGasLimit,
            donId
        );
    }
    
    function fulfillRequest(bytes32 requestId, bytes memory response, bytes memory err) internal override {
        if (err.length > 0) {
            revert(string(err));
        }
        latestTemp = bytes32(response);
        emit WeatherResponse(latestTemp);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract CollateralizedLoan {
    AggregatorV3Interface public priceFeed;
    mapping(address => uint256) public deposits;
    
    uint256 public constant LIQUIDATION_THRESHOLD = 150; // 150%
    uint256 public constant MIN_COLLATERAL_RATIO = 200; // 200%
    
    event Deposited(address indexed user, uint256 amount);
    event Borrowed(address indexed user, uint256 amount);
    event Liquidated(address indexed user);
    
    constructor(address _priceFeed) {
        priceFeed = AggregatorV3Interface(_priceFeed);
    }
    
    function deposit() external payable {
        deposits[msg.sender] += msg.value;
        emit Deposited(msg.sender, msg.value);
    }
    
    function borrow(uint256 _usdAmount) external {
        uint256 ethValue = getUserEthValue(msg.sender);
        uint256 maxBorrow = (ethValue * 100) / MIN_COLLATERAL_RATIO;
        
        require(_usdAmount <= maxBorrow, "Exceeds max borrow");
        // Logic to transfer stablecoin would go here
        emit Borrowed(msg.sender, _usdAmount);
    }
    
    function getUserEthValue(address _user) public view returns (uint256) {
        (, int256 price, , , ) = priceFeed.latestRoundData();
        // price has 8 decimals, deposits is in wei
        return (deposits[_user] * uint256(price)) / 1e8;
    }
    
    function getLiquidationPrice(address _user) public view returns (uint256) {
        (, int256 currentPrice, , , ) = priceFeed.latestRoundData();
        uint256 ethValue = getUserEthValue(_user);
        
        if (ethValue == 0) return 0;
        
        // At what price would the user's position be liquidatable?
        return (uint256(currentPrice) * LIQUIDATION_THRESHOLD) / MIN_COLLATERAL_RATIO;
    }
}