Decentralized Oracle Networks: Chainlink and Beyond 2026

# Conceptual oracle data flow

class OracleNetwork:
    """
    Simplified representation of decentralized oracle network
    """
    
    def __init__(self, network_name):
        self.name = network_name
        self.data_feeds = {}
        self.nodes = []
        self.aggregation_model = "median"  # or mean, trimmed_mean
        
    def add_data_source(self, source_id, source_type, endpoint):
        """
        Register a new data source
        """
        self.data_feeds[source_id] = {
            'type': source_type,
            'endpoint': endpoint,
            'reliability_score': 1.0,
            'response_times': []
        }
        
    def add_node(self, node_id, stake_amount):
        """
        Add oracle node to network
        """
        self.nodes.append({
            'id': node_id,
            'stake': stake_amount,
            'reputation': 100,
            'data_quality_history': []
        })
        
    async def fetch_data(self, data_type, parameters):
        """
        Fetch data from multiple sources and aggregate
        """
        # Gather responses from multiple sources
        responses = []
        
        for source_id, source in self.data_feeds.items():
            if source['type'] == data_type:
                response = await self.query_source(source, parameters)
                responses.append(response)
                
        # Aggregate responses using configured model
        aggregated_value = self.aggregate(responses)
        
        # Update source reliability scores
        self.update_reliability_scores(responses, aggregated_value)
        
        return {
            'value': aggregated_value,
            'sources': len(responses),
            'confidence': self.calculate_confidence(responses),
            'timestamp': block.timestamp
        }
    
    def aggregate(self, responses):
        """
        Aggregate multiple data responses
        """
        if self.aggregation_model == "median":
            sorted_values = sorted([r['value'] for r in responses])
            mid = len(sorted_values) // 2
            if len(sorted_values) % 2 == 0:
                return (sorted_values[mid-1] + sorted_values[mid]) / 2
            return sorted_values[mid]
            
        elif self.aggregation_model == "mean":
            return sum(r['value'] for r in responses) / len(responses)
            
        elif self.aggregation_model == "trimmed_mean":
            sorted_values = sorted([r['value'] for r in responses])
            # Remove top and bottom outliers
            trimmed = sorted_values[1:-1] if len(sorted_values) > 2 else sorted_values
            return sum(trimmed) / len(trimmed)
    
    def calculate_confidence(self, responses):
        """
        Calculate confidence score based on agreement
        """
        values = [r['value'] for r in responses]
        if len(values) < 2:
            return 0.5
            
        mean = sum(values) / len(values)
        variance = sum((x - mean) ** 2 for x in values) / len(values)
        std_dev = variance ** 0.5
        
        # Lower variance = higher confidence
        coefficient_of_variation = std_dev / mean if mean > 0 else float('inf')
        confidence = max(0, min(1, 1 - coefficient_of_variation))
        
        return confidence

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

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

contract ChainlinkPriceConsumer {
    AggregatorV3Interface public priceFeed;
    
    // Token to price feed mapping
    mapping(string => address) public priceFeeds;
    
    constructor() {
        // Initialize price feeds for different token pairs
        priceFeeds["ETH/USD"] = 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419;
        priceFeeds["BTC/USD"] =0xF4030086522a5bEEa4988F8cA5B36dbC97BeE88c;
        priceFeeds["LINK/USD"] =0x2c1d059d1927f1D1632a0bC1a28b3F0d3bC9F75E;
        priceFeeds["EUR/USD"] =0xb49f6c578d12C49b713b3954C4b7CD4d5C5a7de8;
    }
    
    function getLatestPrice(string memory pair) public view returns (int256) {
        AggregatorV3Interface priceFeed = AggregatorV3Interface(
            priceFeeds[pair]
        );
        
        (
            uint80 roundID,
            int256 price,
            uint256 startedAt,
            uint256 timeStamp,
            uint80 answeredInRound
        ) = priceFeed.latestRoundData();
        
        require(price > 0, "Invalid price");
        require(timeStamp > 0, "Round not complete");
        
        return price;
    }
    
    function getEthPrice() public view returns (int256) {
        return getLatestPrice("ETH/USD");
    }
    
    function getBtcPrice() public view returns (int256) {
        return getLatestPrice("BTC/USD");
    }
    
    function getDecimals(string memory pair) public view returns (uint8) {
        AggregatorV3Interface priceFeed = AggregatorV3Interface(
            priceFeeds[pair]
        );
        return priceFeed.decimals();
    }
    
    function getPriceWithConfidence(string memory pair) 
        public 
        view 
        returns (
            int256 price,
            uint256 timestamp,
            uint8 decimals,
            uint256 confidence
        ) 
    {
        AggregatorV3Interface priceFeed = AggregatorV3Interface(
            priceFeeds[pair]
        );
        
        (
            uint80 roundID,
            int256 price,
            uint256 startedAt,
            uint256 timeStamp,
            uint80 answeredInRound
        ) = priceFeed.latestRoundData();
        
        // Get previous round for comparison
        (
            uint80 prevRoundID,
            int256 prevPrice,
            ,
            uint256 prevTimestamp,
            
        ) = priceFeed.getRoundData(answeredInRound > 0 ? answeredInRound - 1 : 0);
        
        // Calculate confidence based on answer freshness and stability
        uint256 age = block.timestamp - timeStamp;
        
        // Lower age = higher confidence
        confidence = age < 1 hours ? 100 : 
                    age < 4 hours ? 80 : 
                    age < 24 hours ? 60 : 40;
        
        return (price, timeStamp, priceFeed.decimals(), confidence);
    }
}

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

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

contract RandomNFTMinter is VRFConsumerBaseV2 {
    VRFCoordinatorV2Interface public vrfCoordinator;
    uint64 public subscriptionId;
    bytes32 public keyHash;
    uint32 public callbackGasLimit = 200000;
    uint16 public requestConfirmations = 3;
    uint32 public numWords = 1;
    
    mapping(uint256 => address) public requestIdToSender;
    mapping(uint256 => uint256[]) public requestIdToRandomWords;
    
    uint256[] public mintedTokenIds;
    
    event RandomnessRequested(uint256 requestId, address requester);
    event RandomnessFulfilled(uint256 requestId, uint256 randomWord);
    
    constructor(
        address _vrfCoordinator,
        uint64 _subscriptionId,
        bytes32 _keyHash
    ) VRFConsumerBaseV2(_vrfCoordinator) {
        vrfCoordinator = VRFCoordinatorV2Interface(_vrfCoordinator);
        subscriptionId = _subscriptionId;
        keyHash = _keyHash;
    }
    
    function requestRandomMint() external returns (uint256 requestId) {
        requestId = vrfCoordinator.requestRandomWords(
            keyHash,
            subscriptionId,
            requestConfirmations,
            callbackGasLimit,
            numWords
        );
        
        requestIdToSender[requestId] = msg.sender;
        emit RandomnessRequested(requestId, msg.sender);
    }
    
    function fulfillRandomWords(
        uint256 requestId,
        uint256[] memory randomWords
    ) internal override {
        address requester = requestIdToSender[requestId];
        
        // Use random word to determine token ID
        uint256 tokenId = randomWords[0] % 10000; // Mint from pool of 10,000
        
        // Store for minting
        mintedTokenIds.push(tokenId);
        requestIdToRandomWords[requestId] = randomWords;
        
        // Mint NFT to requester (implementation depends on NFT contract)
        // _mint(requester, tokenId);
        
        emit RandomnessFulfilled(requestId, randomWords[0]);
    }
    
    function getRequestStatus(uint256 requestId) 
        external 
        view 
        returns (
            address requester,
            bool fulfilled,
            uint256 randomWord
        ) 
    {
        requester = requestIdToSender[requestId];
        fulfilled = requestIdToRandomWords[requestId].length > 0;
        randomWord = fulfilled ? requestIdToRandomWords[requestId][0] : 0;
    }
}

# Oracle security monitoring example

class OracleSecurityMonitor:
    """
    Monitor oracle data for anomalies and manipulation
    """
    
    def __init__(self, oracle_address):
        self.oracle = oracle_address
        self.price_history = []
        self.deviation_threshold = 0.05  # 5% deviation triggers alert
        
    def check_price_deviation(self, new_price):
        """
        Check if new price deviates significantly from history
        """
        if len(self.price_history) < 10:
            self.price_history.append(new_price)
            return False, "Insufficient history"
        
        # Calculate moving average
        recent = self.price_history[-10:]
        moving_avg = sum(recent) / len(recent)
        
        # Calculate deviation
        deviation = abs(new_price - moving_avg) / moving_avg
        
        # Alert if deviation exceeds threshold
        if deviation > self.deviation_threshold:
            return True, f"Price deviation: {deviation*100:.2f}%"
        
        self.price_history.append(new_price)
        return False, "Normal"
    
    def detect_flash_loan_attack(self, prices_before, prices_after):
        """
        Detect potential flash loan price manipulation
        """
        # Flash loans cause large price swings in short time
        max_change = max(abs(p_after - p_before) / p_before 
                        for p_before, p_after 
                        in zip(prices_before, prices_after))
        
        if max_change > 0.2:  # 20% change
            return True, f"Flash loan detected: {max_change*100:.1f}% change"
        
        return False, "Normal"
    
    def monitor_data_sources(self, sources):
        """
        Check reliability of individual data sources
        """
        for source in sources:
            # Check response consistency
            responses = source.get_recent_responses(10)
            
            # Flag sources with high variance
            if len(responses) > 1:
                variance = self.calculate_variance(responses)
                if variance > 0.1:  # 10% variance threshold
                    source.mark_unreliable(f"High variance: {variance}")