Lesson 7: adding 18 zeros to 2600$ without getting filthy rich, ETH exchange rate calculations for dummies (like me)

[n4n0b1t3]

One thing in advance. I thought for a while about sharing this article at all. Most of you will probably grab your head and say, 'that's logical'. For me, it wasn't and I had to chew through it step by step to understand how we came to this conclusion. This article is for all of you who, like me, are baffled that you can add 18 zeros to a 2600$ value without getting filthy rich.

This article is about the function getEntranceFee() which appears a few times in the Youtube course "Solidity, Blockchain, and Smart Contract Course - Beginner to Expert Python Tutorial" by Patrick Collins. The GitHub repository can be found here: https://github.com/smartcontractkit/full-blockchain-solidity-course-py

I have a habit in lessons like this when I already understand the basics, of developing the code of a lesson myself before it is explained. This helps me to see which parts I haven't understood yet, and it helps me to improve my memory of the syntax. In the process, I keep coming across parts of the code where it makes sense for me to write down each step in prose before writing a line of code. In this article, I go into the calculation that is necessary to determine whether the transferred value in WEI corresponds to the given price in USD.

Planning

When will this function be used?
A player enters the lottery by sending the entrance fee in WEI.

What is my objective?
Return the minimum amount in WEI the player needs to pay in order to participate.

What is the high-level process?

1. get the entrance fee in USD
2. get the current exchange rate.
3. Calculate and return the entrance fee in WEI.

Step one is easy: The entrance fee is set by me in the constructor as a static variable.

set up the data feed to get the current exchange rate.

Where to find the address for the Ethereum Data Feeds?
https://docs.chain.link/docs/ethereum-addresses/

/**
 * Network: Rinkeby
 * Base: ETH/USD
 * Base address: 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419
 * Decimals: 8
 */

What value will be returned, let's get a feel for it.

brownie console --network mainnet-fork
>>> address = "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419"
>>> oracle = Contract.from_explorer(address)
>>> oracle.latestAnswer()
269782000000

OK, today is the 24. February 2022, how does 269782000000 relate to the current ETH / USD exchange rate?
What kind of value even is this? It is not USD, it is not WEI ...

The importance of decimals.

When you copy the data feed address, you will find the information of DEC in the column next to it, for this data feed a DEC value of 8 is displayed. Here is my understanding: It tells me how many decimal places this number has, in other words: In our case with 8 decimals I find the position of the decimal point by counting from the last digit of the returned value 8 digits backward.

So this gives me 2697.82000000
https://coinmarketcap.com/currencies/ethereum/ gives me $2,682.11 per one Ethereum. Nice, this is pretty close considering the enormous fluctuation of cryptocurrencies.

using the exchange rate

Before we continue let's make an everyday comparison. Say I am on a business trip in Shanghai and I want to buy a nice Huawei Phone. At the time of writing 1 EUR = 7.11161 CNY (Chinese Yen). The phone is priced at 2100 CNY. I would just need to divide the CNY price by the exchange rate and arrive at the price in EUR.
2100 / 7.11161 = 295,29 EUR.

The only difference in our calculation is that I have to use WEI and I am just not used to dealing with large numbers.

Adding a lot of zeros

Let's assume our lottery ticket price would be 120 USD. According to our example above we would simply have to divide it by the exchange rate to arrive at the price in ETH. However, our exchange rate and our ticket price are currently not comparable, one is in USD and one is our strange exchange rate return value from chainlink.

Let's lift them both to the same level so we can start using them. Here is a short explanation of the logic behind it.
Like one dollar can be divided by 100 cents, one Ethereum can be divided by a Quintillion WEI. The scientific notation would be 1e18, so a 1 followed by 18 zeros. So if you have on one side of the equation a value in ETH and on the other side a value in USD and want to convert ETH to WEI, you need to do this on both sides so the equation stays the same.

ETH 1 = 2682 USD
WEI 1e18 = USD-WEI 2682 * 1e18

We notice that the large number USD-WEI is the equivalent of 2682 USD.

Let's do this in solidity.
First, we get the exchange rate thingy with the 8 decimals from our chainlink oracle price feed, named here ethUsdPriceFeed.
(, int256 price, , , ) = ethUsdPriceFeed.latestRoundData();

Let's check this out in the brownie console:

$ brownie console --network mainnet-fork
>>> address = "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419"
>>> oracle = Contract.from_explorer(address)
Fetching source of 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419 from api.etherscan.io...
>>> oracle.latestRoundData()
(92233720368547778133, 269782000000, 1645817279, 1645817279, 92233720368547778133)

As you can see, the second value in the list returned is our desired exchange rate. Solidity allows us to extract only this value with the syntax seen above. So with the first solidity line, we get in the variable price which contains our rate thingy with the 8 decimals.

• Price has now a value of 269782000000.

Let's produce from this price our exchange rate.
uint256 exchangeRate= uint256(price) * 10**10;

We are adding here 10 zeros to the price increasing the 8 existing decimals to 18 thus becoming the comparable USD-WEI equivalent. This becomes now our usable exchange rate.

• ExchangeRate has now the value of 2697820000000000000000.
  Remember this is neither WEI, nor USD, nor ETH, this is something else we created but which is comparable to WEI.

The next line of code is combining two things
In the constructor the value entryFeeInUSD is initiated like so:
entryFeeInUsdWei = 120 * (10**18);

In our getEntranceFee() function the following calculation appears.
uint256 entryFeeInWEI = (entryFeeInUsdWei * 10**18) / exchangeRate;

Here is the reasoning:

  ETH  x              USD 120
 ----------  =  --------------
  ETH 1               USD 2698

The calculated value x relates to 1 ETH like the entrance fee of 120 USD to our exchange rate of 2698 USD. Converting ETH to WEI and USD to a USD-WEI equivalent.

  WEI  x                  USD-WEI 120e18
 --------------  =  -----------------------
  WEI 1e18             USD-WEI  2698e18

This equals

         120e18 * 1e18 WEI
 x =  ----------------------
                 2698e18

To double-check this, I find it quite convenient to use the brownie console for calculations like so:

>>> int((120e18*1e18)/2698e18)
44477390659747968
>>>

The result 44477390659747968 can be converted to ETH with https://eth-converter.com/ and the Ethereum equivalent can be checked at any marketplace, for example, coinbase https://www.coinbase.com/converter/eth/usd
At the time of writing 0,044 ETH is exactly 120 USD.

just for fun, here are the large numbers:

         120.000.000.000.000.000.000 * 1.000.000.000.000.000.000 WEI
 x =  --------------------------------------------------------------------
                 2698.000.000.000.000.000.000

The final code

    function getEntranceFee() public view returns (uint256) {
        (, int256 price, , , ) = ethUsdPriceFeed.latestRoundData();
        uint256 adjustedPrice = uint256(price) * 10**10; // 18 decimals
        // $50, $2,000 / ETH
        // 50/2,000
        // 50 * 100000 / 2000
        uint256 costToEnter = (usdEntryFee * 10**18) / adjustedPrice;
        return costToEnter;
    }

python examples

Here are some test snippets I used while writing this article. I find it interesting how complicated some steps are when what you want to achieve is so straightforward. Keep in mind that the price feed was fluctuating during the writing, and the values are not always the same use above.

from brownie import Wei
Wei("2472.23226886 ether")
2472232268860000000000

Let's try to convert the 8 decimal USD 247223226886 into a 18 decimal USD-WEI equivalent.
The first thing I tried was:
247223226886 * 10e10
It is 10 to the power of 10 and not 18 because the chainlink return value already has 8 of the 18 decimals. Get it?

Lets use python to calculate this:
>>> 247223226886e10    
2.47223226886e+21
Meh! This is unusable.

Let's try this with Decimal

>>> usdwei = 247223226886 * 10e10
>>> from decimal import Decimal
>>> value = Decimal(usdwei)
>>> value
Decimal('24722322688599998332928')

WTF?

more googling ...

>>> from decimal import Decimal
>>> value = Decimal("247223226886") * Decimal(10 ** 10)   
>>> print(value)
2472232268860000000000

[cromewar]

Hello @n4n0b1t3 Wow you really went deep on this, I would like to add some anotations.

1. For those who get troubles using all the * 10 ** 18... you could also use e notation like this:

assert(1 wei == 1);
assert(1 szabo == 1e12);
assert(1 finney == 1e15);
assert(1 ether == 1e18);
assert(2 ether == 2000 fenny);

2. On python you can always import web3 and use:
   `Web3.toWei(amount, "ether")

3. The decimals are a pain in the *** I know, as solidity does not support decimal numbers is tricky to get used to this way of handling decimal points.

[n4n0b1t3]

Yeah, I figured that paying 100 EUR or 1000 EUR makes a difference, even if there are 17 or 18 zeros added :-) So before just copy&paste some code it's good practice to validate it. This quick check went further than I have planned. Besides, my intuition doesn't help much here, I had to check if the following statement is true.

>>> 1e18==10**18                   
True