Oracle Integration: Chainlink and Price Feeds

Oracles connect blockchains to external data sources.

Why Oracles?

Blockchains are isolated - they can't access:

• Price Data: Crypto, stock, commodity prices
• Random Numbers: True randomness
• Weather Data: For insurance contracts
• Sports Results: For betting contracts
• API Data: Any external API

Oracle Architecture

Components

1. Data Source: External API, database, etc.
2. Oracle Node: Fetches and signs data
3. Aggregator: Combines multiple oracle responses
4. Smart Contract: Consumes oracle data

Chainlink Architecture

RUST
Copy
// Simplified Chainlink price feed
struct PriceFeed {
    aggregator: Address,
    decimals: u8,
    description: String,
}

struct PriceData {
    price: i128,
    updated_at: u64,
    round_id: u64,
}

impl PriceFeed {
    fn latest_round_data(&self) -> PriceData {
        // Fetch from Chainlink aggregator
        // Returns: price, timestamp, round_id
    }
    
    fn get_price(&self) -> Result<u64, String> {
        let data = self.latest_round_data();
        
        // Check staleness (price too old)
        let current_time = current_timestamp();
        if current_time - data.updated_at > 3600 {
            return Err(String::from("Price data too stale"));
        }
        
        Ok(data.price as u64)
    }
}

Chainlink Price Feeds

Supported Feeds

• Crypto: BTC/USD, ETH/USD, etc.
• Forex: EUR/USD, GBP/USD, etc.
• Commodities: Gold, Oil, etc.
• Stocks: S&P 500, etc.

Implementation

RUST
Copy
// Chainlink price feed consumer
struct PriceConsumer {
    price_feed: PriceFeed,
    min_update_interval: u64,
    last_update: u64,
    cached_price: Option<u64>,
}

impl PriceConsumer {
    fn new(price_feed: PriceFeed) -> Self {
        PriceConsumer {
            price_feed,
            min_update_interval: 3600, // 1 hour
            last_update: 0,
            cached_price: None,
        }
    }
    
    fn get_latest_price(&mut self) -> Result<u64, String> {
        let current_time = current_timestamp();
        
        // Use cache if recent
        if let Some(price) = self.cached_price {
            if current_time - self.last_update < self.min_update_interval {
                return Ok(price);
            }
        }
        
        // Fetch new price
        let price = self.price_feed.get_price()?;
        self.cached_price = Some(price);
        self.last_update = current_time;
        
        Ok(price)
    }
}

Verifiable Random Function (VRF)

VRF provides provably random numbers.

Use Cases

• Gaming: Random outcomes
• NFTs: Random traits
• Lotteries: Fair selection
• Governance: Random sampling

Implementation

RUST
Copy
struct VRFRequest {
    key_hash: Vec<u8>,
    seed: u64,
    callback_contract: Address,
    callback_function: Vec<u8>,
}

struct VRFResponse {
    randomness: Vec<u8>,
    proof: Vec<u8>,
}

impl VRFRequest {
    fn request_randomness(&self) -> Result<u64, String> {
        // Request randomness from Chainlink VRF
        // Returns request ID
    }
    
    fn fulfill_randomness(&self, response: VRFResponse) -> Result<u64, String> {
        // Verify proof
        if !self.verify_proof(&response) {
            return Err(String::from("Invalid VRF proof"));
        }
        
        // Extract random number
        let random = u64::from_be_bytes(
            response.randomness[..8].try_into().unwrap()
        );
        
        Ok(random)
    }
    
    fn verify_proof(&self, response: &VRFResponse) -> bool {
        // Verify cryptographic proof
        // In real implementation: use Chainlink's verification
        true
    }
}

Custom Oracle Implementation

RUST
Copy
struct OracleNode {
    node_id: String,
    data_sources: Vec<String>,
    reputation: u64,
}

struct OracleAggregator {
    nodes: Vec<OracleNode>,
    min_confirmations: usize,
}

impl OracleAggregator {
    fn new(min_confirmations: usize) -> Self {
        OracleAggregator {
            nodes: Vec::new(),
            min_confirmations,
        }
    }
    
    fn add_node(&mut self, node: OracleNode) {
        self.nodes.push(node);
    }
    
    fn get_price(&self, symbol: &str) -> Result<u64, String> {
        // Collect responses from multiple nodes
        let mut prices = Vec::new();
        
        for node in &self.nodes {
            if let Ok(price) = node.fetch_price(symbol) {
                prices.push(price);
            }
        }
        
        if prices.len() < self.min_confirmations {
            return Err(String::from("Insufficient oracle responses"));
        }
        
        // Aggregate: median or weighted average
        prices.sort();
        let median = prices[prices.len() / 2];
        
        Ok(median)
    }
}

Security Considerations

Oracle Manipulation

• Single Point of Failure: One oracle can be wrong
• Solution: Use multiple oracles, aggregate

Stale Data

• Problem: Old prices can be exploited
• Solution: Check timestamps, reject stale data

Price Deviation

• Problem: One oracle reports wrong price
• Solution: Compare with multiple sources, reject outliers

Best Practices

1. Multiple Sources: Use multiple oracles
2. Aggregation: Median or weighted average
3. Staleness Checks: Reject old data
4. Outlier Detection: Reject extreme values
5. Circuit Breakers: Pause on anomalies

Real-World Examples

• Chainlink: Most popular oracle network
• Band Protocol: Alternative oracle solution
• UMA: Optimistic oracle
• API3: Decentralized APIs

Use Cases

• DeFi: Price feeds for lending, AMMs
• Insurance: Weather, flight data
• Gaming: Random numbers
• Prediction Markets: Event outcomes