Chainlink Oracles: Enhancing Smart Contracts with Real-World Data

Chainlink empowers smart contracts by providing decentralized oracles for real-world data and computations.

### Integrating Chainlink Oracles for Smart Contracts: Price Feeds, Randomness, and Automation
* 💰 To adjust our contract, we want to require that the `message.value` is **greater than or equal to a minimum of five dollars** instead of one whole ether, necessitating a **conversion from ETH to USD using Chainlink oracles**.
* 🔗 Decentralized oracles like Chainlink are essential as blockchains cannot access real-world data directly, presenting the **"smart contract connectivity problem"** where variable data can **disrupt consensus among nodes**.
* 🌐 Chainlink provides a decentralized network of oracles that can aggregate external data, ensuring **reliability and preventing the pitfalls of centralized data sources** that could compromise the smart contract's integrity.
* 📊 Chainlink's data feeds are used extensively in DeFi, powering **over 50 billion dollars**, by collecting price data from various exchanges and delivering it through a reference contract for smart contracts to utilize.
* 🔍 Users can access and explore different price feeds, such as ETH/USD, through Chainlink's platform, which provides **real-time updates** and **multiple data responses** to ensure **accuracy**.
* ⚡ Chainlink also offers **Verifiable Randomness Function (VRF)** to obtain **provably random numbers** for applications like lotteries and gaming, addressing the challenge of **randomness in deterministic blockchain environments**.
* 🔔 Chainlink Keepers enable **decentralized event-driven execution**, allowing smart contracts to perform actions based on specified triggers without requiring a **centralized entity to initiate transactions**.
* 🔧 Lastly, Chainlink Functions allow developers to make any API call in a decentralized manner, promising **enhanced flexibility and reliability** for future smart contract applications, marking a **significant evolution in DeFi capabilities**.

so right now our contract is pretty minimal right we're requiring the message.value is greater than one whole ether but we want to actually require that it's less than some value like let's say we want to have users spend a minimum of five dollars as opposed to

one whole ethereum so let's first specify that five dollars we could do that at the top of our contract we'll say uint256. we um USD equals five and we'll make this public instead of internal we'll update this minimum use

the in the future to make this more gas efficient so what we want to do is we want to do require that our fund function requires that the message.value is greater than let's say greater than or equal to minimum USD however minimum USD is in terms of USD or

dollars and message.value is in terms of eth or way in terms of ethereum so how do we convert the amount of ethereum to its price in dollars this is where oracles and Chainlink comes into play the dollar price of an asset like ethereum is something that we've

assigned to ethereum outside of the blockchain in the real world so in order to get this abstract concept of the price of the Native cryptocurrency of the blockchain working with so we need to use a decentralized Oracle Network or something called an oracle to get this price so before we keep going let's

learn a little bit more about decentralized oracles Chainlink and how they work so that we can understand how to get the price of ethereum into our smart contracts as we've talked about blockchains are deterministic systems which means that they themselves can't actually interact with real world

data and events. They don't know what the value of an Ethereum is, they don't know what random numbers are, they don't know if it's sunny outside, they don't know the temperature, they don't know who's President, they don't know any of this.

information. These blockchains also can't do any external computation. Maybe you have some amazing artificial intelligence model that you want to integrate with a smart contract. Smart contracts by themselves can't do anything with that, as we've mentioned. This is because blockchains are

deterministic by design. This is so that all the nodes can reach consensus. If you start adding variable data or random data or values that return from an API call, different nodes could get different results and they would never be able to reach a consensus. This is known as the

smart contract connectivity problem or the Oracle problem. And this is bad news because we want our smart contracts to be able to replace traditional agreements, and traditional agreements need data, and they need to interact with the real world. So this is where Chainlink and blockchain oracles come into

place. A blockchain Oracle is going to be any device that interacts with the off-chain world to provide external data or computation to smart contracts. However, the whole story doesn't even end there. If we use a centralized Oracle, we are reintroducing a point of failure. We've

done all this work to make our logic layer decentralized, but if we get our data through a centralized node or through a centralized API, we decide we want to make the API call ourselves, we are reintroducing these trust assumptions that we've worked so hard to

get rid of we're essentially ruining the entire purpose of building a smart contract so we don't want to get our data or do external computation through centralized nodes those are bad news Chainlink is the solution here Chainlink is a decentralized oracle network

for bringing data and external computation into our smart contracts as we mentioned before this gives rise to these hybrid smart contracts which combine on-chain and off-chain to make incredibly feature-rich powerful applications Chainlink is a modular decentralized oracle network that can be customized to

deliver any data or do any external computation that you like so for example a lot of people say oh I can just make an HTTPS call to some API and we'll be good to go the blockchain nodes can't make these HTTPS calls because they wouldn't be able to reach

consensus if they called the node at different times or they did something else all the consensus would be broken so instead we need a decentralized network of Chainlink oracles to do this and then in the transaction this network of nodes will return the data to our

smart contracts for us now Chainlink networks can be completely customized to bring any data or any external computation that you want however doing the customization can be a little bit extra work there are a ton of Chainlink features that come out of the box

completely decentralized ready to plug and play into your smart contract applications what are those features the first one is going to be Chainlink data feeds and that's the one we're actually going to be using for application here Chainlink data feeds currently at the

Time of recording, oracles are powering over 50 billion dollars in the DeFi world. The way they work is a network of Chainlink nodes gets data from different exchanges and data providers and brings that data through a network of decentralized Chainlink nodes. The Chainlink nodes use a

median to figure out what the actual price of the asset is and then deliver that in a single transaction to what's called a reference contract, a price feed contract, or a data contract on chain that other smart contracts can use. And then those smart contracts use that

pricing information to power their DeFi application. We can see an example, we can see an example at data.chain.link and you can change networks, you can change price feeds, you can change a whole bunch of different information to see some of the most popular price feeds.

Let's look at ETH/USD for example. On ETH/USD, we can see this whole network of independent Chainlink node operators that are each getting different answers for the price of that USD. They're getting aggregated by the network and then delivered on chain. We can see how

often they're updated. These ones are updated for a 0.5 deviation threshold or a few hour heartbeat, whichever one hits first. We can see when the last update was, you can see the number of Oracle responses, etc. We can see the contract address directly

on chain. We can even look at the contract on Etherscan. We can see some of the history, we can see all the responses of the different oracles, and at the bottom we can see the different users and sponsors keeping this network up, similar to transaction gas. Whenever a

A node operator delivers data to a smart contract. The Chainlink node operators are paid a little bit of oracle gas in the Chainlink token right now. These users of the protocol are sponsoring keeping these feeds up and are paying the oracle gas associated with delivering this data on chain. Here's an

illustration of what the current model of these data feeds looks like: a network of these Chainlink nodes, each reaches out and gets the information about an asset and then signs the data with their own private key in a single transaction. Then, one node will deliver all the data

with all the different signatures to a reference contract. If that node doesn't deliver the data, another node will send it instead. Reputation is incredibly important when you're a Chainlink node operator. If you miss data updates, if you forget to send transactions, you'll probably be quickly kicked off these

networks and have no chance of making any more money in the future. These data feeds are used by some of the largest protocols in the space, such as Synthetics, SushiSwap, Compound, and Aave, with several billion dollars each. We can take a look at an example over at

docs.chain.link. We're going to hit EVM contracts. We're going to scroll down to data feeds, we'll scroll down to the Solidity section, and we can see an example of an entire contract that uses and reads from one of these Chainlink price feeds.

We can even open this up in Remix and work with it in Remix. It looks like this example is reading from a price feed on Chainlink. The reason we're actually going to use a test net to see this work is that there's a set of Chainlink

nodes monitoring the test network just to show you exactly how this works out. Once we get deeper into the course, we'll show you how to actually run tests and work with Chainlink nodes without actually being on a testnet, which will make your development much faster, but I

highly recommend walking through this section along with me so that you can see firsthand how this actually works. So let's go ahead, faucets.chain.link/coven. We're going to switch to the Coven network and we're going to get some Coven ETH.

But remember, look at the network flag and use whatever network is in the documentation. So to get some Coven, we're going to come to the faucet, we're going to turn off Test Link, we'll just stay with ETH. I'm not a robot, and then send request. Once our Coven

Ethereum has reached our wallet, we can go ahead and close and we can take a look in our wallet and see that we do indeed have 0.1 ETH on Coven. Now let's go back to our Remix. We'll compile this contract. We'll go and deploy this on injected

Web3. And again, the reason we're going to use injected Web3 instead of JavaScript VM is that there's no network of Chainlink nodes watching our little fake JavaScript VM. There are a network of Chainlink nodes watching the testnet. So we'll scroll down, we'll switch

contract to the Price Consumer V3 and we'll hit deploy. Then a mass will pop up, and after a brief delay, we can see our price feed consumer down here, and we can hit 'Get the latest price,' which shows us the latest price of Ethereum in terms of USD.

You may be wondering why the number looks so weird. That seems like a really large number for the price of Ethereum in terms of USD, and this is because decimals don't actually work so well in Solidity. We'll get to that in a little bit. There's a decimals flag

associated with this price feed address that tells us how many decimals to include with this price. It's also in the documentation, however I know that this one has eight decimals. So this is saying the value of Ethereum right now is 3262 dollars. It may of course be

different when you go ahead and try this now. There's a number of things that happen in this contract that I'll explain in our fund me example, but if you want to take a look now and see if you can figure out what's going on, I

recommend you do so. Price feeds are one of the most powerful out-of-the-box decentralized features you can use in your smart contract to level them up, especially for a decentralized finance. If you're looking for different addresses of different price feeds, you can check the contract addresses section

of the documentation, choose the network that you want, and then scroll down and then look at some of the different addresses of the different price feeds. For example, this address will give you the price of one inch token in terms of Ethereum. This address will give you the price of

the Apple stock in terms of USD and so on and so forth. The next decentralized application right out of the box is going to be Chainlink VRF or Chainlink Verifiable Randomness Function. Once we do our Lottery example a little bit later, we'll talk about how Randomness

can be manipulated in blockchain. Blockchains are deterministic systems, which by definition means that they can't have randomness. If you can determine what a random number is, it's not really random anymore, is it? So we need a way to get a provably random

number by looking outside of the blockchain, and oracles are perfectly positioned to do exactly that. Chainlink Verifiable Randomness Function is a way to get provably a random number into our smart contract to guarantee fairness and guarantee randomness of applications.

Many protocols like Pool Together, Axie Infinity, Ether Cards, Aavegotchi, and more use Chainlink VRF for lotteries, for randomizing NFTs, for gaming, and for more. We're going to do an example of Chainlink VRF in a later section once we

get to the lottery section. If you want to see if you can play with the randomness yourself right now, I recommend you go into docs.chain.link/evm-chains and scroll down to 'Get a Random Number.' And this will teach you how to get a provably random number into

your applications. The next decentralized out-of-the-box feature of Chainlink is Chainlink Keepers, which is decentralized event-driven execution. As you've seen, in order to kick off some type of transaction, somebody needs to spend the gas and somebody needs to sit

down and hit the 'go' button, or hit the 'transact' button, or hit the 'send' button. This is obviously a centralized vector. If you have a decentralized application that needs to run at specific times or after specific events are triggered, Chainlink Keepers are the solution to

These Chainlink Keepers are Chainlink nodes that listen to a registration contract for different events that you specify to fire. Maybe you say every 10 minutes you want to do something, or once a week do something, or if the price of some asset hits some number, or maybe a

liquidity pool is at a certain level. Whatever event that you want to code, you absolutely can. The Chainlink nodes constantly listen for these triggers to happen and check the different contracts for these triggers. Once a trigger returns true, the Chainlink nodes will

then perform whatever action that you tell the Chainlink nodes to do. We're also not going to go over the Chainlink Keepers examples right now because we're going to get to them in a later module. However, if you want to try them out, go

to docs.chain.link/ethereum, going and go to making compatible contracts and feel free to read the documentation and try it out yourself. The last out-of-the-box feature of Chainlink is the most customizable, but also the hardest to get correct. End-to-end reliability is the

ultimate promise of our smart contracts, and we want and need them to be able to do anything. We want to be able to take any input and get any output. Chainlink Functions is the last decentralized out-of-the-box tool, and it allows you to make any API call in a decentralized

context through a network of Chainlink nodes. We're not going to be going over that at all in this video, but be sure to check out the documentation if that's something that you're interested in. To me, Chainlink Functions is going to be the future of DeFi and smart

contracts and if you're looking to make something novel and if you're looking to make something that's never been done before, I 100% recommend you check out Chainlink Functions later on after this course or whatever you want to do. As a filming, it came out about a month or two

ago and people are just beginning to build amazing things with Chainlink Functions. So be sure to check this out after or during the course. We're going to be using the Chainlink Automation in a later section in this course again. If you want to try these out in Remix on a

real test net, you can go to the documentation and play with them here.

Lesson 4 Part 5 | Introduction to getting Chainlink data - Solidity & Foundry Full Course

Book a smart contract audit here 👇
https://www.cyfrin.io/


Cyfrin Audits

Minimum transaction value and USD conversion in smart contracts

Current contract only requires message.value > 1 ETH; needs a maximum value.

Defining minimum USD value (e.g., $5) within the contract using uint256 USD = 5.

Need to ensure message.value (in ETH) is greater than or equal to minimum USD.

Requires converting ETH to USD, necessitating the use of oracles.

Introduction to decentralized oracles and Chainlink to obtain real-world data.

Limitations of blockchains and the need for oracles

Blockchains are deterministic and cannot interact with real-world data.

Blockchains lack knowledge of real-world information (price of ETH, weather, etc.).

Blockchains cannot perform external computations (e.g., AI model integration).

Deterministic nature prevents consensus with variable data, leading to the 'Oracle problem'.

Oracles bridge the gap between smart contracts and real-world data.

Chainlink as a decentralized oracle network

Centralized oracles introduce single points of failure, undermining decentralization.

Chainlink provides decentralized data and computation for smart contracts.

Chainlink enables hybrid smart contracts combining on-chain and off-chain elements.

Chainlink avoids consensus issues by using a decentralized network of nodes.

Chainlink offers various features, including data feeds, VRF, and Keepers.

Chainlink data feeds power over $50 billion in DeFi, aggregating data from various sources.

Nodes use a median to determine asset prices and deliver them to a reference contract.

Example at data.chain.link shows network of nodes, update frequency, and contract addresses.

Node operators are incentivized with oracle gas in Chainlink tokens.

Nodes sign data with private keys, and data delivery is fault-tolerant.

Practical demonstration using Chainlink on a testnet

Using a testnet to demonstrate Chainlink integration due to the availability of monitoring nodes.

Explanation of using testnet for easier demonstration.

Recommendation to follow along for hands-on experience.

Obtaining Coven ETH from faucets.chain.link/coven.

Deploying contract on injected Web3 for access to Chainlink nodes.

Retrieving the latest ETH/USD price using 'Get the latest price'.

Price feeds are powerful for decentralized finance applications.

Various price feeds available for different assets (e.g., 1INCH/ETH, Apple stock/USD).

Chainlink VRF (Verifiable Randomness Function) for provably random numbers.

Chainlink Keepers for decentralized event-driven execution.

Chainlink Functions for customizable API calls in a decentralized context.