Lession 7: Lottery, test : test_get_entrance_fee, not getting correct values.

[nikola-bozin]

Hello, i am not getting correct values for test_get_entrance_fee function, thus my asserts always fail.
This is part of the code:

    entrance_fee = lot.getEntranceFee()
    expected_entrance_fee = Web3.toWei(0.025, "ether")
    expected_entrance_fee2 = 25000000000000000
    print(entrance_fee)
    print(expected_entrance_fee)
    print(expected_entrance_fee2)
    assert entrance_fee == expected_entrance_fee

===================================
Printed values:

25000000000000000000
25000000000000000
25000000000000000

so obviously: lot.getEntranceFee() returns 10**3 more bigger value than expected.
Checking the getEntranceFee() function this is the implementation:

 function getEntranceFee() public view returns (uint256)
 {
        (, int256 prize, , , ) = eth_to_usd_price_fee.latestRoundData();
        uint256 adjustedPrize = uint256(prize) * 10**10;
        USDentryFee = 50 * 10**18;
        uint256 costToEnter = (USDentryFee * 10**18) / adjustedPrize;
        return costToEnter;
  }

Which is almost the same as code on github. I am not sure where im making mistake. Any Help?

[cromewar]

That's strange as I just tested this and the number of decimals should be the same, look at his example:

As you can see the number of digits is 17:

So it should work fine, could you double check if you are adding extra zeros on any part of your code?

[H4LITUS]

Can you please double check the initial_answer and decimals for your aggregator mock? The values should be as follows:
initial_answer = 200000000000
decimals = 8

[H4LITUS]

I'll try my best to explain this.

The initial_value is basically the price of ETH in USD,
Let's say 1 ETH = 2000.12345678 USD
We know that solidity doesn't support floating numbers, so to cater this we use DECIMALS. To represent the above mentioned price of eth/usd in solidity, we will define it as
uint256 PRICE = 200012345678 and unit256 DECIMALS = 8
With DECIMALS=8, we can tell that the last 8 values are after the decimal point

Secondly, we know that the standard used by solidity is WEI and 1 ETH = 10**18 WEI, so to make the eth/usd conversion easier in solidity, we multiply the price further by 10**10 in getEntranceFee() function so that both ETH and USD have the same decimal points i.e 18.

I hope you got it. Let me know if you need further clarification :)

[nikola-bozin]

Well, that did help!
But just to be sure, if lets say ethereum price changes and : 1 ETH = 2000.123 USD

Does that mean that i have to update my contract and make transaction that will change DECIMALS to 3? Since we "hard-coded" it to be 8, or should we use the Aggregator's decimals function and say uint8 DECIMALS = AggregatorV3Interface.decimals();
Since obviously we wont google ethereum price every time and than update our contract accordingly...
I hope you understand what im having hard time with...

[H4LITUS]

Mock Aggregator Contract

1. The price and decimals are both provided by the Aggregator
2. In the above example, we deploy an Aggregator smart contract on our local blockchain, and pass the parameters PRICE=200000000000 and DECIMALS=8 to the constructor.
3. So now whenever we retrieve the price and decimals, we get a fixed value since the price doesn't get updated for this mock aggregator.

Aggregator Contract on main-net and test-net

1. The price of ETH/USD here is updated in real time by the oracle, and DECIMALS=8 is fixed as it's a constant value (Keep in mind that the decimals can be different for each aggregator contract)
2. If the price changes to 1 ETH = 2000.123, the aggregator will return, PRICE = 200012300000 and DECIMALS=8
3. The price returned by the aggregator contract will always be updated and as per the defined decimals, so the calculations in our smart contract will remain the same
4. You can check the ETH/USD price on etherscan to get a more clear picture

[nikola-bozin]

Mock Aggregator Contract

1. The price and decimals are both provided by the Aggregator
2. In the above example, we deploy an Aggregator smart contract on our local blockchain, and pass the parameters PRICE=200000000000 and DECIMALS=8 to the constructor.
3. So now whenever we retrieve the price and decimals, we get a fixed value since the price doesn't get updated for this mock aggregator.

Aggregator Contract on main-net and test-net

1. The price of ETH/USD here is updated in real time by the oracle, and DECIMALS=8 is fixed as it's a constant value (Keep in mind that the decimals can be different for each aggregator contract)
2. If the price changes to 1 ETH = 2000.123, the aggregator will return, PRICE = 200012300000 and DECIMALS=8
3. The price returned by the aggregator contract will always be updated and as per the defined decimals, so the calculations in our smart contract will remain the same
4. You can check the ETH/USD price on etherscan to get a more clear picture

Well.. i can say things are clearer now! Thanks H4LITUS!

[H4LITUS]

I'm glad I could help