Le problème des oracles

Welcome! In Web3, DApps often need information that isn't stored directly on the blockchain. This is called off-chain data.

Think of things like current stock prices, real-time weather reports, or the outcome of a sports game. This data exists in the 'real world' outside the blockchain's network.

Blockchains are designed to be isolated and self-contained environments. This is crucial for their security and reliability.

Every node in the network must agree on the exact state of the blockchain. If a smart contract could directly fetch external data, different nodes might get different results, breaking consensus.

The Oracle Problem refers to the challenge of securely and reliably bringing external, off-chain data onto a blockchain.

Smart contracts, by design, cannot directly 'see' or 'fetch' data from the internet. They operate in a deterministic, closed system.

Why can't a smart contract just make an API call like a regular web application?

• Determinism: All transactions must produce the same result across all nodes. An external API call might return different data at different times.
• Security: Directly calling external sources introduces vulnerabilities and potential attack vectors.
• Consensus: How would all nodes verify that the external data was indeed what the API returned?

Many powerful DApps need real-world data to function. Without a way to get this data, their utility is severely limited.

Imagine a decentralized finance (DeFi) lending platform that needs current asset prices, or an insurance DApp based on real-world events like weather or flight delays.

If a DApp relies on a single source to provide external data, that source becomes a centralized point of failure.

This undermines the core principle of decentralization. The data provider could be malicious, hacked, or simply go offline, jeopardizing the entire DApp.

To solve the Oracle Problem, we introduce oracles. An oracle is a third-party service that finds and verifies real-world data, then sends it to a smart contract.

It acts as a secure bridge, allowing smart contracts to interact with the outside world without breaking their deterministic nature.

While oracles solve the 'access' problem, they introduce a new challenge: how do we trust the oracle itself?

The data provided by an oracle must be accurate, tamper-proof, and available. If the oracle provides bad data, the smart contract will execute based on that bad data.

Consider a simple decentralized betting DApp:

• Users bet on the outcome of a football match.
• The smart contract needs to know the final score.
• It cannot directly access ESPN or other sports sites.
• An oracle is essential to feed the final score to the contract, enabling payouts.

Which of the following is the primary reason smart contracts cannot directly access real-world data like a traditional web application?

You've learned about the critical Oracle Problem in Web3 development:

• Blockchains are isolated and deterministic.
• Smart contracts can't directly access off-chain data.
• Many DApps need real-world data to function.
• Oracles act as bridges, but introduce new trust challenges.

Next, we'll explore how decentralized oracle networks like Chainlink provide solutions to this problem!