now in order for us to figure out if the amount of ethereum sent with a transaction is greater than or equal to our minimum USD of five dollars we need to convert the amount of ethereum into its value in dollars so how we're going to do that well the first thing that

we're going to need to do is we're going to need to get the price of ethereum or Avalanche or polygon or whatever native blockchain token that we're working with so let's create a function to do that we'll create a function get price and

this function is just going to get the price of ethereum in terms of USD and then we're also going to create a function called get conversion rate which is going to convert a value to its converted value based off of the price for now we're going to make them

both public functions so we can play with them test them and do whatever we want with them to get the price of ethereum we're going to use the chain link data feed and we go through the documentation to get that information so in the documentation I'm going to scroll

down using data feeds I've got an example here right in solidity and if you wanted to like I said you could easily open this up in remix now you can see this example in the documentation what's actually going on when working with a chain link price feed

was a contract out there at an address and we're going to call this latest round data function on that contract gives us a whole bunch of data but we really only care about the price so we're going to want to do the same thing we want to reach out to that contract

that's currently storing and having the price updated so since we want to reach out to and work with the contract we're going to need two things right what are those two things when we need the address and we need the ABI the address of the contract is going to be really

easy we can get the address by going to the chain link documentation and let's go up to this price feed addresses section we'll scroll down we want to be on ethereum okay great let's look for a sepolia looks like it's way down here

and all right awesome e2sd great there's an e2sd price feed so now that we have the address how do we get the ABI well before with simple storage we imported the entire contract from the top and we compiled and we got the ABI like that we

could do that here but that's kind of a lot of code and we don't actually care about what the whole contract looks like we only really want to know what the functions are so we can call that latest round data function remember if we're on

remix and we go down to the compilation details the ABI is really just this list of functions that we can call on a contract the ABI itself doesn't actually need to include any of the logic it just needs to say hey these are the functions you can interact with and here they're

inputs and here's whether or not they're payable and here's whether or not their view functions etc like I said though this kind of is a white lie you can also use a functional selector or some other ways but we're just going to ignore that

for now, how can we get the ABI? There's a concept in Solidity known as the interface. If we go to the Chainlink GitHub, we go to Smart Contract Kit Chainlink, we can see a lot of different contracts in the Chainlink repository. We go to contracts/src. This might look

a little bit different based off of when you're looking at it. V 0.8 interfaces, and we go to Aggregator V3 Interface. If we scroll down, we can actually see a whole bunch of function declarations, but none of them are actually implemented. It's just function, the name of the

function, some stuff, external viewable, but then just the semicolon and nothing inside of them. This is what's known as an interface. If you compile this, this will actually give us that ABI because it defines all the different functions that you can call on a contract. It just doesn't have any of

the logic. Again, we don't really even need to know what the functions do. We just need to know how to interact with the contract, and if a contract is deployed, it'll have that logic in its deployment. So what we can do is we can copy this

whole thing, scroll all the way to the bottom, hit the copy button and paste it in on Remix. Now hold on though, if you're following along, you don't have to copy paste it in here with me because I'm going to teach you something in just

a minute that makes this a little bit easier. This pasted code alert comes up. We're running Solidity code, so this is going to be okay since we're only working on testnets here. We're going to be okay that we don't have to worry

about the paste code alert if you want to take a second to read it please do but we're going to paste this code in here just like we did before with simple storage for now you don't have to follow along I'm about to show you an easier

way just follow along and watch now that we have this interface aggregator V3 interface we can use this interface to make API calls because now we have the address and we have the API and we can even compile this and it'll compile fine so we can say aggregator V3 interface at

address this and the combination of these two give us whatever code is at this address with all the functions from the aggregator V3 interface and just to test this out we can do something simple like dot version since if we scroll up looks like there is indeed a version

function put a little semicolon at the end so let's actually go ahead and actually copy this line give it its own function called get version this will have this public view returns what is the version of your return a unit 56 however return a unit 256 paste that line in

here aggregator V3 interface at its address dot version we'll say return all of that now I'm going to go ahead and deploy this to the Sepolia testnet just to show you what this would actually look like however I'm going to recommend

you don't do that for now just know that this will work this way you won't have to wait forever for your transactions to go through on the testnet so to do this I'm going to go ahead and scroll up to the top go to injected Metamask change

the contract from aggregator V3 interface to fund me I'm going to go ahead and hit deploy my MetaMask is going to pop up I'm going to go ahead and hit confirm and we're going to scroll down and now we have a big blue

button called get version which I'm going to go ahead and click and we can see we get a four return because at this contract address on the blockchain it has the functionality for get version return for and for the rest of this lesson I'm going to be showing you guys

and testing this on an actual testnet however I recommend that you don't test all of these as I go along just watch me do them because again waiting for transactions on a testnet can be really annoying sometimes the testnet might be having issues because again it's

people running them out of the goodness of their heart so for this lesson just follow along write the code with me and then maybe at the end deploy everything so this is a really easy way and a common way that people use to interact with other contracts outside of their

projects they get the interface of that contract using the interface keyword they compile it and the compiler actually gives us an API and then you just wrap an address around with that interface keyword and you can call any function at that address and this is one of these things as we work with more and

more it'll start to make more sense in the beginning it might be a little hard to grasp but just bear with me for now the more we do it the better you'll get don't get discouraged take a deep breath and exhale and let's keep coding

Lesson 4 Part 7 | Interfaces - Solidity & Foundry Full Course

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


Cyfrin Audits

Need to convert Ethereum amount to USD to check if it meets the minimum USD value.

Create a function 'getPrice' to get the price of Ethereum (or other tokens) in USD.

Create a function 'getConversionRate' to convert a value based on the price.

Use Chainlink data feed to get the price of Ethereum.

Chainlink price feed uses a contract with a 'latestRoundData' function.

Need the contract address and ABI to interact with the contract.

Get the address from Chainlink documentation.

Find the Sepolia network's ETH/USD price feed address.

Obtain the ABI; importing the whole contract is unnecessary.

ABI is a list of functions callable on a contract.

ABI doesn't need contract logic, only function declarations.

Use Solidity interface from Chainlink GitHub to get the ABI.

Interface contains function declarations without implementation.

Compiling the interface provides the ABI.

Using the ABI and Address to Interact with Contract

Copy the interface code and paste it into Remix.

Use `AggregatorV3Interface` with the address to interact with the contract.

Create a `getVersion` function to retrieve the contract version.

Deployment and Testing on Sepolia Testnet

Deploy the contract to Sepolia (demonstration purposes).

Call the `getVersion` function after deployment.

The returned value demonstrates successful contract interaction.

Recommend watching the deployment rather than performing it yourself due to potential testnet delays.

This method is common for interacting with external contracts.

The interface keyword provides an ABI, allowing interaction with the contract at a specific address.

Encourage perseverance and continued learning.

Lesson 4 Part 7 | Interfaces - Solidity & Foundry Full Course

Scripts