Lesson 13 Allowed Tokens, wait(1) bug and calling array from contract

[Niferu]

Hello,

I have 3 questions in this discussion:

1. When we are testing allowed tokens I have figured out that 3 tokens are always allowed somehow even if we do not run addAllowedTokens function, those tokens are dapp_token(the one we deploy), weth_token(deployed by mock) and dai_token(deployed by mock). If we run addAllowedTokens with dapp_token address our allowedTokens array will now have 4 items in it, where first and last one will be the same address. So my question here is how is that array filled with deployed dapp_token and mocks without running addAllowedTokens function?

2. I like to see what values are everywhere so in my tests I always print asserted values. In my test I wanted to print allowedTokens length using something like len(token_farm.allowedTokens()), but it doesn't work and I could only print 1 element from this array but couldn't print it's length. I have found workaround for it by creating below function in TokenFarm contract, but is there a simpler way to check array length from contract in python?

  function arrayLengthGetter() public view returns (uint, uint) {
      uint first_array = stakers.length;
      uint second_array = allowedTokens.length;
      return (first_array, second_array);
  }

Then in our python code we can call it like below:

stakers_len, tokens_len = token_farm.arrayLengthGetter()
print(f'Stakers Array Length: {stakers_len}, Allowed Tokens Array Length {tokens_len}')

3. My last question is what actually causing that wait(1) error in below test as I have added tx.wait(1) after only one transaction we are performing there, so there should be no that error below:
   
   I have found workaround for it and if I add time.sleep(1) at the end of test it won't throw that massive string of text error, but still I have no idea why that `tx.wait(1)' doesnt work in this test as it is working for rest of my tests...
   Test code:

def test_token_is_allowed():
    """
        We are testing below functions here:
        * addAllowedTokens
        * tokenIsAllowed
        * allowedTokens
        * arrayLengthGetter
    """
    # Arrange
    if network.show_active() not in LOCAL_BLOCKCHAIN_ENVIRONMENTS:
        pytest.skip("Only for local testing")
    account = get_account()
    non_owner = get_account(index = 1)
    token_farm, dapp_token = deploy_token_farm_and_dapp_token()
    not_allowed = token_farm.tokenIsAllowed(config["networks"]["goerli"]["weth_token"])
    # Act
    tx_add = token_farm.addAllowedTokens(dapp_token.address, {"from": account})
    tx_add.wait(1)
    allowed_token = token_farm.tokenIsAllowed(dapp_token.address)
    print(f'Allowed Tokens: {allowed_token}')
    
    stakers_len, tokens_len = token_farm.arrayLengthGetter()
    print(f'Stakers Array Length: {stakers_len}, Allowed Tokens Array Length {tokens_len}')
    # Assert
    assert token_farm.allowedTokens(0) == dapp_token.address
    assert not_allowed == False
    assert allowed_token == True
    with pytest.raises(exceptions.VirtualMachineError):
        token_farm.addAllowedTokens(dapp_token.address, {"from": non_owner})
    # Below will prevent stream of text error popping (tx.wait(1) didnt work here not sure why)
    time.sleep(1)

[cromewar]

Hello @Neftyr

1. The reason is because we do that at deployment here:

The logic here is that you will use that token anyways, so we add then at deployment to the allowed ones.

2. In solidity no, you should use a getter function like you did, however you can access solidity variables in python (brownie) as they were function so you can create something like this:

 array = TokenFarm.allowedTokens()
 len(array)

3. I'll need more info on this, please run the test with -s flag, like this:

brownie test -s -k testname

And post the output here.

I hope this info might help, cheers.

[Niferu]

Hello @cromewar

1. Regarding 1st question totally forgot about that deploy we included that there, sorry for that and thanks a lot for clarification.

2. I was trying to access that array in multiple ways (including your way) to get it's length but your code for this is throwing error as below:

array = TokenFarm.allowedTokens()
 len(array)

or
array = token_farm.allowedTokens() # As token_farm is deployed TokenFarm contract 
len(array)

FAILED tests/unit/test_token_farm.py::test_token_is_allowed - ValueError: allowedTokens Sequence has incorrect length, expected 1 but got 0

That is why I have created that getter function, as I couldnt get it without additional function.

3. Regarding this point using single test is not throwing error, so brownie test -s -k test_token_is_allowed will be ok and as below:
   

But using brownie test -s will cause this:

and it is going even further...

I had same error with previous tests included in this one but adding that .wait(1) block was working correct until adding test_token_is_allowed() test and here only time.sleep(1) works, not sure why.

[cromewar]

My bad, when you have an array you can access them with brownie, but just to a specific value on it, so is complaining about you not giving the index you want to access. After more research, the only form to get the length of the array with a getter function as you already did.

Regarding to the test error, this is really interesting never seen a problem like that before.. seems like the time.sleep helps to wait until the connection with the RPC client is correct (which makes no sense as the RPC client for local testing should be instantaneous), I cloned the lesson repo and run some test and everything seems to be working fine for me so in order to know more about this could you handle me more info?

1. The python version you are using (3.8 is the best one for brownie right now).
2. The complete code of the test script.
3. not a request but just a recommendation, do not use pipx, is better to install brownie using regular pip.

[Niferu]

Hello @cromewar

1. Currently I have 2 versions of python, I'm using 3.10.6 but got installed 3.9.13 also. And it is working perfect for me so far.
2. Here is my whole code with prints and comments:

from brownie import network, exceptions, config
from scripts.helpful_scripts import DECIMALS, LOCAL_BLOCKCHAIN_ENVIRONMENTS, INITIAL_PRICE_FEED_VALUE, get_account, get_contract
from scripts.deploy import KEPT_BALANCE, deploy_token_farm_and_dapp_token
import pytest, time

# We are testing all functions from TokenFarm.sol


def test_set_price_feed_contract():
    """
        We are testing below functions here:
        * setPriceFeedContract
    """
    # Arrange
    if network.show_active() not in LOCAL_BLOCKCHAIN_ENVIRONMENTS:
        pytest.skip("Only for local testing")
    account = get_account()
    non_owner = get_account(index = 1)
    price_feed_address = get_contract("dai_usd_price_feed")
    token_farm, dapp_token = deploy_token_farm_and_dapp_token()
    # Act
    set_tx = token_farm.setPriceFeedContract(dapp_token.address, price_feed_address, {"from": account})
    set_tx.wait(1)
    print(f'set_tx: {set_tx}')
    print(f'DappToken address: {token_farm.tokenPriceFeedMapping(dapp_token.address)}')
    feed_tx = token_farm.tokenPriceFeedMapping(dapp_token.address)
    print(f'feed_tx: {feed_tx}')
    # Assert
    assert feed_tx == price_feed_address
    with pytest.raises(exceptions.VirtualMachineError):
        token_farm.setPriceFeedContract(dapp_token.address, price_feed_address, {"from": non_owner})


# Below "amount_staked" will be taken from "conftest.py", which is fixture for tests in python (More info in Obsidian BlockChain tab)
def test_stake_tokens(amount_staked):
    """
        We are testing below functions here:
        * stakeTokens
        * updateUniqueTokensStaked
        * stakers
    """
    # Arrange
    if network.show_active() not in LOCAL_BLOCKCHAIN_ENVIRONMENTS:
        pytest.skip("Only for local testing")
    account = get_account()
    token_farm, dapp_token = deploy_token_farm_and_dapp_token()
    user_staking_balance_before = token_farm.stakingBalance(dapp_token, account.address)
    tokens_staked_before = token_farm.uniqueTokensStaked(account.address)
    # stakers_before = token_farm.stakers(0) -> this will throw error as it does not exist before calling "stakeTokens" function, as "stakers" array is empty
    
    # Act
    # When approving we actually allow some tokens amount to be throw into any kind of transaction, in this case "staking"
    ap_tx = dapp_token.approve(token_farm.address, amount_staked, {"from": account})
    ap_tx.wait(1)
    st_tx = token_farm.stakeTokens(amount_staked, dapp_token, {"from": account})
    st_tx.wait(1)
 
    user_staking_balance_after = token_farm.stakingBalance(dapp_token, account.address)
    print(f'Before Stake {user_staking_balance_before}, After Stake {user_staking_balance_after}')
    tokens_staked_after = token_farm.uniqueTokensStaked(account.address)
    print(f'Before Token Update {tokens_staked_before}, After Token Update {tokens_staked_after}')
    stakers_after = token_farm.stakers(0)
    print(f"Staker's Before {None}, Staker's After {stakers_after}")
    # Assert
    assert user_staking_balance_after == amount_staked
    assert tokens_staked_before == 0
    assert tokens_staked_after == 1
    assert stakers_after == account.address
    # Below will allow us to use those data in our other tests
    return token_farm, dapp_token


def test_issue_tokens(amount_staked):
    """
        We are testing below functions here:
        * issueTokens
    """
    # Arrange
    # We are staking 1 dapp_token == in price to 1 ETH
    # soo... we should get 2,000 dapp tokens in reward
    # since the price of eth is $2,000 (It is taken from MockV3Aggregator from helpful_scripts, where initial value is set to $2000)
    if network.show_active() not in LOCAL_BLOCKCHAIN_ENVIRONMENTS:
        pytest.skip("Only for local testing")
    account = get_account()
    non_owner = get_account(index = 1)
    token_farm, dapp_token = test_stake_tokens(amount_staked)
    # Below "balanceOf" function is from ERC20 contract
    starting_balance = dapp_token.balanceOf(account.address)
    
    # Act
    tx = token_farm.issueTokens({"from": account})
    tx.wait(1)
    ending_balance = dapp_token.balanceOf(account.address)
    print(f'Starting Balance: {starting_balance}, Ending Balance: {ending_balance}')
    # Assert
    # We have to divide INITIAL_PRICE_FEED_VALUE on 10 as we are rewarding user only 10% staked amount
    assert ending_balance == starting_balance + (INITIAL_PRICE_FEED_VALUE / 10)
    with pytest.raises(exceptions.VirtualMachineError):
        token_farm.issueTokens({"from": non_owner})


def test_token_is_allowed():
    """
        We are testing below functions here:
        * addAllowedTokens
        * tokenIsAllowed
        * allowedTokens
        * arrayLengthGetter
    """
    # Arrange
    if network.show_active() not in LOCAL_BLOCKCHAIN_ENVIRONMENTS:
        pytest.skip("Only for local testing")
    account = get_account()
    non_owner = get_account(index = 1)
    token_farm, dapp_token = deploy_token_farm_and_dapp_token()
    not_allowed = token_farm.tokenIsAllowed(config["networks"]["goerli"]["weth_token"])
    # Act
    tx_add = token_farm.addAllowedTokens(dapp_token.address, {"from": account})
    tx_add.wait(1)

    allowed_token = token_farm.tokenIsAllowed(dapp_token.address)
    print(f'Allowed Tokens: {allowed_token}')
    
    stakers_len, tokens_len = token_farm.arrayLengthGetter()
    """
        To get array length from Contract we have to create function, which returns it in Contract!

        Tokens, which are allowed since start are those, which Mock's we are deploying, although
        we are deploying "dapp_token" by ourself's, so allowed tokens are: dapp_token, weth_token(mock) and dai_token(mock)
        once we run "addAllowedTokens" function we will add dapp_token again at the end of array, so there will be 4 items
    """
    print(f'Stakers Array Length: {stakers_len}, Allowed Tokens Array Length {tokens_len}')
    # Assert
    assert token_farm.allowedTokens(0) == dapp_token.address
    assert not_allowed == False
    assert allowed_token == True
    with pytest.raises(exceptions.VirtualMachineError):
        token_farm.addAllowedTokens(dapp_token.address, {"from": non_owner})
    # Below will prevent stream of text error popping (tx.wait(1) didnt work here not sure why)
    #time.sleep(1)

I have also added 2 another tests as below and interesting is that if you add this code below to code above and perform brownie test -s there will be no stream of text error (from timing) even if there is not tx.wait(1) after every single transaction in last test... So no idea why is that as it is very strange and illogical that only above code run throws error.

def test_unStakeTokens(amount_staked):
    """
        We are testing below functions here:
        * unStakeTokens
    """
    if network.show_active() not in LOCAL_BLOCKCHAIN_ENVIRONMENTS:
        pytest.skip("Only for local testing")
    account = get_account()
    token_farm, dapp_token = test_stake_tokens(amount_staked)
    user_staking_balance_before = token_farm.stakingBalance(dapp_token, account.address)
    tokens_staked_before = token_farm.uniqueTokensStaked(account.address)
    stakers_len_before, tokens_len = token_farm.arrayLengthGetter()
    # Act
    st_tx = token_farm.unStakeTokens(dapp_token.address, {"from": account})
    st_tx.wait(1)

    print("After unStake: ----------------------------------------------------------------------------------")
    print(f'Kept Balance: {KEPT_BALANCE}')
    user_staking_balance_after = token_farm.stakingBalance(dapp_token, account.address)
    print(f'Before unStake Balance {user_staking_balance_before}, After unStake Balance {user_staking_balance_after}')
    tokens_staked_after = token_farm.uniqueTokensStaked(account.address)
    print(f'Before unStake Tokens Amount: {tokens_staked_before}, After unStake Tokens Amount: {tokens_staked_after}')
    stakers_len_after, tokens_len = token_farm.arrayLengthGetter()
    print(f'Stakers Array Length Before unStake: {stakers_len_before}, Stakers Array Length After unStake: {stakers_len_after}')
    # Assert
    assert dapp_token.balanceOf(account.address) == KEPT_BALANCE
    assert user_staking_balance_after == user_staking_balance_before - amount_staked
    assert tokens_staked_before == 1
    assert tokens_staked_after == 0
    assert stakers_len_before == 1
    assert stakers_len_after == 0


def test_get_user_total_value_with_different_tokens(amount_staked, random_erc20, dai_token):
    """
        We are testing below functions here:
        * getUserTotalValue
        * getUserSingleTokenValue
        * getTokenValue
    """
    if network.show_active() not in LOCAL_BLOCKCHAIN_ENVIRONMENTS:
        pytest.skip("Only for local testing")
    account = get_account()
    token_farm, dapp_token = test_stake_tokens(amount_staked)
    print("After Staking --------------------------------------------------------------")

    # Staking random_erc20 token
    token_farm.addAllowedTokens(random_erc20.address, {"from": account})
    token_farm.setPriceFeedContract(random_erc20.address, get_contract("eth_usd_price_feed"), {"from": account})
    random_erc20_stake_amount = amount_staked * 2
    random_erc20.approve(token_farm.address, random_erc20_stake_amount, {"from": account})
    token_farm.stakeTokens(random_erc20_stake_amount, random_erc20.address, {"from": account})

    # Staking dai_token
    token_farm.addAllowedTokens(dai_token.address, {"from": account})
    token_farm.setPriceFeedContract(dai_token.address, get_contract("dai_usd_price_feed"), {"from": account})
    dai_token_stake_amount = amount_staked * 3
    dai_token.approve(token_farm.address, dai_token_stake_amount, {"from": account})
    token_farm.stakeTokens(dai_token_stake_amount, dai_token.address, {"from": account})

    # getTokenValue (price, decimals)
    dapp_price, dapp_decimals = token_farm.getTokenValue(dapp_token.address)
    rerc20_price, rerc20_decimals = token_farm.getTokenValue(random_erc20.address)
    dai_price, dai_decimals = token_farm.getTokenValue(dai_token.address)
    print(f'Dapp Token Price: {dapp_price}, Token Decimals: {dapp_decimals}')
    print(f'Random_ERC20 Token Price: {rerc20_price}, Token Decimals: {rerc20_decimals}')
    print(f'DAI Token Price: {dai_price}, Token Decimals: {dai_decimals}')

    # getUserSingleTokenValue (single STAKED token balance)
    dapp_token_val = token_farm.getUserSingleTokenValue(account.address, dapp_token)
    rerc20_token_val = token_farm.getUserSingleTokenValue(account.address, random_erc20)
    dai_token_val = token_farm.getUserSingleTokenValue(account.address, dai_token)
    print(f'Dapp Token Value: {dapp_token_val}')
    print(f'Random_ERC20 Token Value: {rerc20_token_val}')
    print(f'DAI Token Value: {dai_token_val}')

    # getUserTotalValue (total STAKED all tokens value)
    total_tokens_val = token_farm.getUserTotalValue(account.address)
    print(f'Total Tokens Value: {total_tokens_val}')

    assert token_farm.getTokenValue(dapp_token.address) == (INITIAL_PRICE_FEED_VALUE, DECIMALS)
    # Below are 2 options as if we run whole test there will be additionaly (3 * amount_staked) of dapp_token from different accounts
    assert total_tokens_val == INITIAL_PRICE_FEED_VALUE * 9 # While Running `brownie test -s`
    #assert total_tokens_val == INITIAL_PRICE_FEED_VALUE * 6 # While Running `brownie test -s -k`

3. I had a lot of trouble installing brownie at all and making it's syntax formatting correct (I have even mentioned that in my question in this repository where you was helping me also). I could install it with pipx only as solution because pip didn't work at all, so I won't be able to change it now as I don't want to waste time figuring out what's the problem with pip and so far it works good for me.

This discussion as you have probably noticed it's not about problems that blocks me from continuing course at all but its more like getting more knowledge and understanding as I found solutions/workarounds for all of above mentioned "errors", so if you have no time you can close this as you have answered on my most problematic question regarding that array filling with approved contracts (which was dumb question anyway coz i missed deploy.py haha).