Whizzy 💭

Chainlink

4 min read

Chainlink is the most widely used decentralized oracle network. If you haven’t read about oracles and the oracle problem yet, start there — this post covers how Chainlink solves it in practice.

In one line: Chainlink provides reliable real-world data to smart contracts by sourcing it from multiple independent operators and penalizing liars.

How It Works

Let’s say a DeFi lending protocol needs the current price of ETH to decide if someone’s loan should be liquidated. Here’s what happens:

sequenceDiagram
    participant SC as Smart Contract
    participant CL as Chainlink Network
    participant N1 as Node 1
    participant N2 as Node 2
    participant N3 as Node 3

    SC->>CL: I need the price of ETH
    CL->>N1: Fetch ETH price
    CL->>N2: Fetch ETH price
    CL->>N3: Fetch ETH price
    N1->>CL: $3,000
    N2->>CL: $3,002
    N3->>CL: $100,000 🤥
    Note over CL: Outlier detected!<br/>Discard $100,000<br/>Average the rest
    CL->>SC: ETH = $3,001 ✅
    Note over N3: Node 3 loses staked<br/>LINK tokens 🔥

Step by Step

  1. Smart contract requests data — “I need ETH/USD price”
  2. Chainlink selects node operators — Multiple independent operators are chosen based on their reputation (track record of accuracy) and stake (LINK tokens they’ve deposited as collateral)
  3. Each node fetches independently — Every node goes to its own data sources (different APIs, exchanges, etc.) and reports back
  4. Aggregation — Results are compared. If most nodes report ~100,000, the outlier is discarded. The remaining values are averaged
  5. Delivery — The validated price is sent to the smart contract
  6. Rewards and penalties — Honest nodes earn LINK tokens. Dishonest or inaccurate nodes lose their staked LINK

The Reputation System

Chainlink tracks every node’s history. Over time, nodes build a reputation:

flowchart TD
    A["Node operator joins<br/>Stakes LINK tokens as deposit"] --> B["Gets selected for data requests"]
    B --> C{"Provides accurate data?"}
    C -->|"Yes, consistently"| D["Reputation increases ⬆️<br/>Gets more requests<br/>Earns more LINK"]
    C -->|"No, inaccurate"| E["Reputation drops ⬇️<br/>Loses staked LINK<br/>Gets fewer requests"]
    E --> F["Eventually kicked out<br/>if consistently bad"]

Think of it like Uber ratings for data providers. Bad ratings = fewer rides = eventually deactivated.

Why Not Just Use a Normal API?

Fair question. Here’s the difference:

Normal API:

  • One server, one operator
  • If it goes down → no data
  • If it gets hacked → wrong data
  • You have to trust the operator

Chainlink:

  • Multiple independent operators across the globe
  • If some go down → others still provide data
  • If some get hacked → outliers get discarded
  • Lying costs real money (slashing)

It’s the difference between asking one friend for the cricket score vs asking 20 random people and going with what most of them say.

LINK is Chainlink’s native token. It serves two purposes:

  1. Payment — Smart contracts pay LINK to node operators for providing data
  2. Collateral — Node operators stake LINK as a security deposit. If they provide bad data, they lose it

This creates a direct financial incentive: providing accurate data = earn LINK. Providing bad data = lose LINK. The math always favors honesty.

Real-World Use Case

Here’s a complete example — crop insurance:

flowchart TD
    A["🌾 Farmer buys insurance<br/>Deposits funds into smart contract"] --> B["📋 Contract condition:<br/>If rainfall < 50mm this month,<br/>pay out insurance"]
    B --> C["🔮 Chainlink oracle network<br/>Multiple nodes check weather APIs"]
    C --> D{"Rainfall this month?"}
    D -->|"< 50mm (drought)"| E["💰 Smart contract automatically<br/>pays the farmer"]
    D -->|"> 50mm (enough rain)"| F["No payout needed<br/>Contract continues"]

No claims adjustor. No paperwork. No “we’ll get back to you in 6-8 weeks.” The farmer gets paid because the code and the data say so.

External Resources

Graph View

Backlinks