import re
import random
from tests import marks, mailserver_ams, mailserver_gc, mailserver_hk, used_fleet, common_password,\
    pair_code, unique_password
from tests.users import user_mainnet, chat_users, recovery_users, transaction_senders, basic_user,\
    wallet_users, ens_user_message_sender, ens_user
from tests.base_test_case import SingleDeviceTestCase
from views.sign_in_view import SignInView
import support.api.web3_api as w3


@marks.medium
class TestChatManagement(SingleDeviceTestCase):

    @marks.testrail_id(6243)
    def test_keycard_can_recover_keycard_account_offline_and_add_watch_only_acc(self):
        sign_in = SignInView(self.driver)
        sign_in.toggle_airplane_mode()

        sign_in.just_fyi('Recover multiaccount offline')
        sign_in.accept_tos_checkbox.enable()
        sign_in.get_started_button.click_until_presence_of_element(sign_in.access_key_button)
        sign_in.access_key_button.click()
        sign_in.recover_with_keycard_button.click()
        keycard_view = sign_in.begin_recovery_button.click()
        keycard_view.connect_pairing_card_button.click()
        keycard_view.pair_code_input.set_value(pair_code)
        keycard_view.confirm()
        keycard_view.enter_default_pin()
        sign_in.maybe_later_button.click_until_presence_of_element(sign_in.lets_go_button)
        sign_in.lets_go_button.click_until_absense_of_element(sign_in.lets_go_button)
        sign_in.home_button.wait_for_visibility_of_element(30)
        wallet_view = sign_in.wallet_button.click()

        sign_in.just_fyi('Relogin offline')
        self.driver.close_app()
        self.driver.launch_app()
        sign_in.sign_in(keycard=True)
        if not sign_in.home_button.is_element_displayed(10):
            self.driver.fail('Keycard user is not logged in')

        sign_in.just_fyi('Turn off airplane mode and turn on cellular network')
        sign_in.toggle_airplane_mode()
        sign_in.toggle_mobile_data()
        sign_in.element_by_text_part('Stop syncing').wait_and_click(60)
        sign_in.wallet_button.click()
        if not wallet_view.element_by_text_part('XEENUS').is_element_displayed():
            self.errors.append('Token balance is not fetched while on cellular network!')

        wallet_view.just_fyi('Add watch-only account when on cellular network')
        wallet_view.add_account_button.click()
        wallet_view.add_watch_only_address_button.click()
        wallet_view.enter_address_input.send_keys(basic_user['address'])
        account_name = 'watch-only'
        wallet_view.account_name_input.send_keys(account_name)
        wallet_view.add_account_generate_account_button.click()
        account_button = wallet_view.get_account_by_name(account_name)
        if not account_button.is_element_displayed():
            self.driver.fail('Account was not added')

        wallet_view.just_fyi('Check that balance is changed after go back to WI-FI')
        sign_in.toggle_mobile_data()
        for asset in ('YEENUS', 'STT'):
            wallet_view.asset_by_name(asset).scroll_to_element()
            wallet_view.wait_balance_is_changed(asset, wait_time=60)

        wallet_view.just_fyi('Delete watch-only account')
        wallet_view.get_account_by_name(account_name).click()
        wallet_view.get_account_options_by_name(account_name).click()
        wallet_view.account_settings_button.click()
        wallet_view.delete_account_button.click()
        wallet_view.yes_button.click()
        if wallet_view.get_account_by_name(account_name).is_element_displayed(20):
            self.errors.append('Account was not deleted')

        self.errors.verify_no_errors()

    @marks.testrail_id(6292)
    def test_keycard_send_funds_between_accounts_set_max_in_multiaccount_instance(self):
        sign_in_view = SignInView(self.driver).create_user(keycard=True)
        wallet = sign_in_view.wallet_button.click()
        status_account_address = wallet.get_wallet_address()[2:]
        self.network_api.get_donate(status_account_address, external_faucet=True)
        wallet.wait_balance_is_changed()
        account_name = 'subaccount'
        wallet.add_account(account_name, keycard=True)
        wallet.get_account_by_name(account_name).click()
        wallet.get_account_options_by_name(account_name).click()
        wallet.account_settings_button.click()
        wallet.swipe_up()

        wallet.just_fyi("Checking that delete account and importing account are not available on keycard")
        if wallet.delete_account_button.is_element_displayed(10):
            self.errors.append('Delete account option is shown on added account "On Status Tree"!')
        wallet.wallet_button.double_click()
        wallet.add_account_button.click()
        if wallet.enter_a_seed_phrase_button.is_element_displayed():
            self.errors.append('Importing account option is available on keycard!')
        wallet.click_system_back_button()

        wallet.just_fyi("Send transaction to new account")
        transaction_amount = '0.006'
        initial_balance = self.network_api.get_balance(status_account_address)
        wallet.send_transaction(account_name=account_name, amount=transaction_amount, keycard=True)
        self.network_api.wait_for_confirmation_of_transaction(status_account_address, transaction_amount)
        self.network_api.verify_balance_is_updated(str(initial_balance), status_account_address)

        wallet.just_fyi("Verifying previously sent transaction in new account")
        wallet.get_account_by_name(account_name).click()
        wallet.send_transaction_button.click()
        wallet.close_send_transaction_view_button.click()
        balance_after_receiving_tx = float(wallet.get_asset_amount_by_name('ETH'))
        expected_balance = self.network_api.get_rounded_balance(balance_after_receiving_tx, transaction_amount)
        if balance_after_receiving_tx != expected_balance:
            self.driver.fail('New account balance %s does not match expected %s after receiving a transaction' % (
                balance_after_receiving_tx, transaction_amount))

        wallet.just_fyi("Sending eth from new account to main account")
        updated_balance = self.network_api.get_balance(status_account_address)
        transaction_amount_1 = round(float(transaction_amount) * 0.2, 11)
        wallet.wait_balance_is_changed()
        wallet.get_account_by_name(account_name).click()
        send_transaction = wallet.send_transaction(from_main_wallet=False, account_name=wallet.status_account_name,
                                                   amount=transaction_amount_1, keycard=True)
        wallet.close_button.click()
        sub_account_address = wallet.get_wallet_address(account_name)[2:]
        self.network_api.wait_for_confirmation_of_transaction(sub_account_address, transaction_amount_1)
        wallet.find_transaction_in_history(amount=format(float(transaction_amount_1), '.11f').rstrip('0'))

        wallet.just_fyi("Check transactions on subaccount")
        self.network_api.verify_balance_is_updated(updated_balance, status_account_address)

        wallet.just_fyi("Verify total ETH on main wallet view")
        self.network_api.wait_for_confirmation_of_transaction(status_account_address, transaction_amount_1)
        self.network_api.verify_balance_is_updated((updated_balance + transaction_amount_1), status_account_address)
        wallet.close_button.click()
        balance_of_sub_account = float(self.network_api.get_balance(sub_account_address)) / 1000000000000000000
        balance_of_status_account = float(self.network_api.get_balance(status_account_address)) / 1000000000000000000
        wallet.scan_tokens()
        total_eth_from_two_accounts = float(wallet.get_asset_amount_by_name('ETH'))
        expected_balance = self.network_api.get_rounded_balance(total_eth_from_two_accounts,
                                                                (balance_of_status_account + balance_of_sub_account))

        if total_eth_from_two_accounts != expected_balance:
            self.driver.fail('Total wallet balance %s != of Status account (%s) + SubAccount (%s)' % (
                total_eth_from_two_accounts, balance_of_status_account, balance_of_sub_account))

        wallet.just_fyi("Check that can set max and send transaction with max amount from subaccount")
        wallet.get_account_by_name(account_name).click()
        wallet.send_transaction_button.click()
        send_transaction.set_max_button.click()
        set_amount = float(send_transaction.amount_edit_box.text)
        if set_amount == 0.0 or set_amount >= balance_of_sub_account:
            self.driver.fail('Value after setting up max amount is set to %s' % str(set_amount))
        send_transaction.confirm()
        send_transaction.chose_recipient_button.click()
        send_transaction.accounts_button.click()
        send_transaction.element_by_text(wallet.status_account_name).click()
        send_transaction.sign_transaction_button.click()
        send_transaction.sign_transaction(keycard=True)
        wallet.element_by_text('Assets').click()
        wallet.wait_balance_is_equal_expected_amount(asset='ETH', expected_balance=0, main_screen=False)

    @marks.testrail_id(5742)
    def test_keycard_onboarding_interruption_creating_flow(self):
        sign_in = SignInView(self.driver)

        sign_in.just_fyi('Cancel on PIN code setup stage')
        sign_in.accept_tos_checkbox.enable()
        sign_in.get_started_button.click()
        sign_in.generate_key_button.click()
        username = sign_in.first_username_on_choose_chat_name.text
        sign_in.next_button.click()
        keycard_flow = sign_in.keycard_storage_button.click()
        keycard_flow.next_button.click()
        keycard_flow.begin_setup_button.click()
        keycard_flow.connect_card_button.wait_and_click()
        keycard_flow.enter_another_pin()
        keycard_flow.cancel_button.click()

        sign_in.just_fyi('Cancel from Confirm seed phrase: initialized + 1 pairing slot is used')
        keycard_flow.begin_setup_button.click()
        keycard_flow.enter_default_pin()
        keycard_flow.enter_default_pin()
        seed_phrase = keycard_flow.get_seed_phrase()
        keycard_flow.confirm_button.click()
        keycard_flow.yes_button.click()
        keycard_flow.cancel_button.click()
        if not keycard_flow.element_by_text_part('Back up seed phrase').is_element_displayed():
            self.driver.fail('On canceling setup from Confirm seed phrase was not redirected to expected screen')

        sign_in.just_fyi('Cancel from Back Up seed phrase: initialized + 1 pairing slot is used')
        keycard_flow.cancel_button.click()
        keycard_flow.begin_setup_button.click()
        keycard_flow.element_by_translation_id("back-up-seed-phrase").wait_for_element(10)
        new_seed_phrase = keycard_flow.get_seed_phrase()
        if new_seed_phrase != seed_phrase:
            self.errors.append('Another seed phrase is shown after cancelling setup during Back up seed phrase')
        keycard_flow.backup_seed_phrase()
        keycard_flow.enter_default_pin()
        for element in sign_in.maybe_later_button, sign_in.lets_go_button:
            element.wait_for_visibility_of_element(30)
            element.click()
        sign_in.profile_button.wait_for_visibility_of_element(30)

        sign_in.just_fyi('Check username and relogin')
        profile = sign_in.get_profile_view()
        public_key, real_username = profile.get_public_key_and_username(return_username=True)
        if real_username != username:
            self.errors.append('Username was changed after interruption of creating account')
        profile.logout()
        home = sign_in.sign_in(keycard=True)
        if not home.wallet_button.is_element_displayed(10):
            self.errors.append("Failed to login to Keycard account")
        self.errors.verify_no_errors()

    @marks.testrail_id(6246)
    def test_keycard_onboarding_interruption_access_key_flow(self):
        sign_in = SignInView(self.driver)
        sign_in.accept_tos_checkbox.enable()
        sign_in.get_started_button.click()

        sign_in.access_key_button.click()
        sign_in.enter_seed_phrase_button.click()
        sign_in.seedphrase_input.click()
        sign_in.seedphrase_input.set_value(basic_user['passphrase'])
        sign_in.next_button.click()
        sign_in.reencrypt_your_key_button.click()
        keycard_flow = sign_in.keycard_storage_button.click()

        sign_in.just_fyi('Cancel on PIN code setup stage')
        keycard_flow.next_button.click()
        keycard_flow.begin_setup_button.click()
        keycard_flow.connect_card_button.wait_and_click()
        keycard_flow.enter_another_pin()
        keycard_flow.cancel_button.click()

        sign_in.just_fyi('Finish setup and relogin')
        keycard_flow.begin_setup_button.click()
        keycard_flow.enter_default_pin()
        keycard_flow.enter_default_pin()
        for element in sign_in.maybe_later_button, sign_in.lets_go_button:
            element.wait_for_visibility_of_element(30)
            element.click()
        sign_in.profile_button.wait_for_visibility_of_element(30)
        public_key, default_username = sign_in.get_public_key_and_username(return_username=True)
        profile_view = sign_in.get_profile_view()
        if public_key != basic_user['public_key']:
            self.errors.append('Public key %s does not match expected' % public_key)
        if default_username != basic_user['username']:
            self.errors.append('Default username %s does not match expected' % default_username)
        profile_view.logout()
        home = sign_in.sign_in(keycard=True)
        if not home.wallet_button.is_element_displayed(10):
            self.errors.append("Failed to login to Keycard account")
        self.errors.verify_no_errors()

    @marks.testrail_id(695851)
    def test_keycard_frozen_card_flows(self):
        sign_in = SignInView(self.driver)
        seed = basic_user['passphrase']
        home = sign_in.recover_access(passphrase=seed, keycard=True)
        profile = home.profile_button.click()
        profile.keycard_button.scroll_and_click()

        home.just_fyi('Set new PUK')
        keycard = profile.change_puk_button.click()
        keycard.enter_default_pin()
        [keycard.enter_default_puk() for _ in range(2)]
        keycard.ok_button.click()

        home.just_fyi("Checking reset with PUK when logged in")
        keycard = profile.change_pin_button.click()
        keycard.enter_another_pin()
        keycard.wait_for_element_starts_with_text('2 attempts left', 30)
        keycard.enter_another_pin()
        keycard.element_by_text_part('one attempt').wait_for_element(30)
        keycard.enter_another_pin()
        if not home.element_by_translation_id("keycard-is-frozen-title").is_element_displayed(30):
            self.driver.fail("No popup about frozen keycard is shown!")
        home.element_by_translation_id("keycard-is-frozen-reset").click()
        keycard.enter_another_pin()
        home.element_by_text_part('2/2').wait_for_element(20)
        keycard.enter_another_pin()
        home.element_by_translation_id("enter-puk-code").click()
        keycard.enter_default_puk()
        home.element_by_translation_id("keycard-access-reset").wait_for_element(20)
        home.profile_button.double_click()
        profile.logout()

        home.just_fyi("Checking reset with PUK when logged out")
        keycard.enter_default_pin()
        keycard.wait_for_element_starts_with_text('2 attempts left', 30)
        keycard.enter_default_pin()
        keycard.element_by_text_part('one attempt').wait_for_element(30)
        keycard.enter_default_pin()
        if not home.element_by_translation_id("keycard-is-frozen-title").is_element_displayed():
            self.driver.fail("No popup about frozen keycard is shown!")
        home.element_by_translation_id("keycard-is-frozen-reset").click()
        keycard.enter_another_pin()
        home.element_by_text_part('2/2').wait_for_element(20)
        keycard.enter_another_pin()
        home.element_by_translation_id("enter-puk-code").click()
        keycard.enter_default_puk()
        home.element_by_translation_id("keycard-access-reset").wait_for_element(20)
        home.element_by_translation_id("open").click()

        home.just_fyi("Checking reset with seed when logged in")
        profile = home.profile_button.click()
        profile.keycard_button.scroll_and_click()
        profile.change_pin_button.click()
        keycard.enter_default_pin()
        keycard.wait_for_element_starts_with_text('2 attempts left', 30)
        keycard.enter_default_pin()
        keycard.element_by_text_part('one attempt').wait_for_element(30)
        keycard.enter_default_pin()
        if not home.element_by_translation_id("keycard-is-frozen-title").is_element_displayed():
            self.driver.fail("No popup about frozen keycard is shown!")
        home.element_by_translation_id("dismiss").click()
        profile.profile_button.double_click()
        profile.keycard_button.scroll_and_click()
        profile.change_pin_button.click()
        keycard.enter_default_pin()
        if not home.element_by_translation_id("keycard-is-frozen-title").is_element_displayed(30):
            self.driver.fail("No reset card flow is shown for frozen card")
        home.element_by_translation_id("keycard-is-frozen-factory-reset").click()
        sign_in.seedphrase_input.set_value(transaction_senders['A']['passphrase'])
        sign_in.next_button.click()
        if not home.element_by_translation_id("seed-key-uid-mismatch").is_element_displayed():
            self.driver.fail("No popup about mismatch in seed phrase is shown!")
        home.element_by_translation_id("try-again").click()
        sign_in.seedphrase_input.clear()
        sign_in.seedphrase_input.set_value(seed)
        sign_in.next_button.click()
        keycard.begin_setup_button.click()
        keycard.yes_button.click()
        keycard.enter_default_pin()
        home.element_by_translation_id("intro-wizard-title5").wait_for_element(20)
        keycard.enter_default_pin()
        home.element_by_translation_id("keycard-access-reset").wait_for_element(30)
        home.ok_button.click()
        profile.profile_button.double_click()
        profile.logout()

        home.just_fyi("Checking reset with seed when logged out")
        keycard.enter_another_pin()
        keycard.wait_for_element_starts_with_text('2 attempts left', 30)
        keycard.enter_another_pin()
        keycard.element_by_text_part('one attempt').wait_for_element(30)
        keycard.enter_another_pin()
        if not home.element_by_translation_id("keycard-is-frozen-title").is_element_displayed():
            self.driver.fail("No popup about frozen keycard is shown!")

        sign_in.element_by_translation_id("keycard-is-frozen-factory-reset").click()
        sign_in.seedphrase_input.set_value(seed)
        sign_in.next_button.click()
        keycard.begin_setup_button.click()
        keycard.yes_button.click()
        keycard.enter_default_pin()
        home.element_by_translation_id("intro-wizard-title5").wait_for_element(20)
        keycard.enter_default_pin()
        home.element_by_translation_id("keycard-access-reset").wait_for_element(30)
        home.ok_button.click()
        keycard.enter_default_pin()
        home.home_button.wait_for_element(30)

    @marks.testrail_id(695852)
    def test_keycard_blocked_card_lost_or_frozen_flows(self):
        sign_in = SignInView(self.driver)
        seed = basic_user['passphrase']
        home = sign_in.recover_access(passphrase=seed, keycard=True)
        profile = home.profile_button.click()
        profile.keycard_button.scroll_and_click()

        home.just_fyi("Checking blocked card screen when entering 3 times invalid PIN + 5 times invalid PUK")
        keycard = profile.change_pin_button.click()
        keycard.enter_another_pin()
        keycard.wait_for_element_starts_with_text('2 attempts left', 30)
        keycard.enter_another_pin()
        keycard.element_by_text_part('one attempt').wait_for_element(30)
        keycard.enter_another_pin()
        if not home.element_by_translation_id("keycard-is-frozen-title").is_element_displayed():
            self.driver.fail("No popup about frozen keycard is shown!")
        home.element_by_translation_id("keycard-is-frozen-reset").click()
        keycard.enter_another_pin()
        home.element_by_text_part('2/2').wait_for_element(20)
        keycard.enter_another_pin()
        home.element_by_translation_id("enter-puk-code").click()

        for i in range(1, 4):
            keycard.enter_default_puk()
            sign_in.wait_for_element_starts_with_text('%s attempts left' % str(5 - i))
            i += 1
        keycard.enter_default_puk()
        sign_in.element_by_text_part('one attempt').wait_for_element(30)
        keycard.enter_default_puk()
        keycard.element_by_translation_id("keycard-is-blocked-title").wait_for_element(30)
        keycard.close_button.click()
        if not keycard.element_by_translation_id("keycard-blocked").is_element_displayed():
            self.errors.append("In keycard settings there is no info that card is blocked")
        keycard.navigate_up_button.click()
        profile.logout()

        home.just_fyi("Check blocked card when user is logged out and use lost or frozen to restore access")
        keycard.enter_another_pin()
        keycard.element_by_translation_id("keycard-is-blocked-title").wait_for_element(30)
        keycard.element_by_translation_id("keycard-recover").click()
        keycard.yes_button.click()
        sign_in.seedphrase_input.set_value(seed)
        sign_in.next_button.click()
        keycard.begin_setup_button.click()
        keycard.yes_button.click()
        keycard.enter_default_pin()
        home.element_by_translation_id("intro-wizard-title5").wait_for_element(20)
        keycard.enter_default_pin()
        home.element_by_translation_id("keycard-access-reset").wait_for_element(30)
        home.ok_button.click()
        keycard.enter_default_pin()
        home.home_button.wait_for_element(30)

        self.errors.verify_no_errors()

    @marks.testrail_id(6330)
    def test_wallet_send_tx_token_set_max(self):
        sender = transaction_senders['ETH_STT_2']
        receiver = transaction_senders['ETH_1']
        sign_in = SignInView(self.driver)
        home_1 = sign_in.recover_access(sender['passphrase'])
        wallet = home_1.wallet_button.click()
        wallet.wait_balance_is_changed('STT')

        home_1.just_fyi("Sending token amount to account who will use Set Max option for token")
        amount = wallet.get_unique_amount()
        wallet.send_transaction(asset_name='STT', amount=amount, recipient=receiver['address'])
        self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount, token=True)
        wallet.wallet_button.double_click()

        home_1.just_fyi('Add account restored from seed phrase')
        account_name = 'subaccount'
        wallet.add_account_button.click()
        wallet.enter_a_seed_phrase_button.click()
        wallet.enter_your_password_input.send_keys(common_password)
        wallet.enter_seed_phrase_input.set_value(receiver['passphrase'])
        wallet.account_name_input.send_keys(account_name)
        wallet.add_account_generate_account_button.click()
        account_button = wallet.get_account_by_name(account_name)
        account_button.click()
        wallet.wait_balance_is_changed('STT', navigate_to_home=False)

        home_1.just_fyi("Send all tokens via Set Max option")
        send_transaction = wallet.send_transaction_button.click()
        send_transaction.select_asset_button.click()
        asset_name = 'STT'
        asset_button = send_transaction.asset_by_name(asset_name)
        send_transaction.select_asset_button.click_until_presence_of_element(
            send_transaction.eth_asset_in_select_asset_bottom_sheet_button)
        asset_button.click()
        send_transaction.set_max_button.click()
        send_transaction.set_recipient_address(sender['address'])
        send_transaction.sign_transaction_button.click()
        send_transaction.sign_transaction()
        wallet.close_button.click()
        wallet.wallet_button.double_click()
        wallet.get_account_by_name(account_name).click()
        wallet.wait_balance_is_equal_expected_amount(asset='STT', expected_balance=0, main_screen=False)

    @marks.testrail_id(5358)
    def test_wallet_backup_recovery_phrase_warning_from_wallet(self):
        sign_in = SignInView(self.driver)
        sign_in.create_user()
        wallet = sign_in.wallet_button.click()
        if wallet.backup_recovery_phrase_warning_text.is_element_present():
            self.driver.fail("'Back up your seed phrase' warning is shown on Wallet while no funds are present")
        address = wallet.get_wallet_address()
        self.network_api.get_donate(address[2:], external_faucet=True, wait_time=200)
        wallet.close_button.click()
        wallet.wait_balance_is_changed(scan_tokens=True)
        if not wallet.backup_recovery_phrase_warning_text.is_element_present(30):
            self.driver.fail("'Back up your seed phrase' warning is not shown on Wallet with funds")
        profile = wallet.get_profile_view()
        wallet.backup_recovery_phrase_warning_text.click()
        profile.backup_recovery_phrase()

    @marks.testrail_id(5437)
    def test_wallet_validation_amount_errors(self):
        sender = wallet_users['C']
        sign_in = SignInView(self.driver)

        errors = {'send_transaction_screen': {
            'too_precise': 'Amount is too precise. Max number of decimals is 8.',
            'insufficient_funds': 'Insufficient funds'
        },
            'sending_screen': {
                'Amount': 'Insufficient funds',
                'Network fee': 'Not enough ETH for gas'
            },
        }
        warning = 'Warning %s is not shown on %s'

        sign_in.recover_access(sender['passphrase'])
        wallet = sign_in.wallet_button.click()
        wallet.wait_balance_is_changed('YEENUS')
        wallet.accounts_status_account.click()

        screen = 'send transaction screen from wallet'
        sign_in.just_fyi('Checking %s on %s' % (errors['send_transaction_screen']['too_precise'], screen))
        initial_amount_adi = wallet.get_asset_amount_by_name('YEENUS')
        send_transaction = wallet.send_transaction_button.click()
        adi_button = send_transaction.asset_by_name('YEENUS')
        send_transaction.select_asset_button.click_until_presence_of_element(
            send_transaction.eth_asset_in_select_asset_bottom_sheet_button)
        adi_button.click()
        send_transaction.amount_edit_box.click()
        amount = '0.000%s' % str(random.randint(100000, 999999)) + '1'
        send_transaction.amount_edit_box.set_value(amount)
        if not send_transaction.element_by_text(
                errors['send_transaction_screen']['too_precise']).is_element_displayed():
            self.errors.append(warning % (errors['send_transaction_screen']['too_precise'], screen))

        sign_in.just_fyi('Checking %s on %s' % (errors['send_transaction_screen']['insufficient_funds'], screen))
        send_transaction.amount_edit_box.clear()
        send_transaction.amount_edit_box.set_value(str(initial_amount_adi) + '1')
        if not send_transaction.element_by_text(
                errors['send_transaction_screen']['insufficient_funds']).is_element_displayed():
            self.errors.append(warning % (errors['send_transaction_screen']['insufficient_funds'], screen))
        wallet.close_send_transaction_view_button.click()
        wallet.close_button.click()

        screen = 'sending screen from wallet'
        sign_in.just_fyi('Checking %s on %s' % (errors['sending_screen']['Network fee'], screen))
        account_name = 'new'
        wallet.add_account(account_name)
        wallet.get_account_by_name(account_name).click()
        wallet.send_transaction_button.click()
        send_transaction.amount_edit_box.set_value('0')
        send_transaction.set_recipient_address(ens_user_message_sender['ens'])
        send_transaction.next_button.click()
        wallet.ok_got_it_button.wait_and_click(30)
        if not send_transaction.validation_error_element.is_element_displayed(10):
            self.errors.append('Validation icon is not shown when testing %s on %s' % (errors['sending_screen']['Network fee'], screen))
        if not wallet.element_by_translation_id("tx-fail-description2").is_element_displayed():
            self.errors.append("No warning about failing tx is shown!")
        send_transaction.cancel_button.click()

        screen = 'sending screen from DApp'
        sign_in.just_fyi('Checking %s on %s' % (errors['sending_screen']['Network fee'], screen))
        home = wallet.home_button.click()
        dapp = sign_in.dapp_tab_button.click()
        dapp.select_account_button.click()
        dapp.select_account_by_name(account_name).wait_for_element(30)
        dapp.select_account_by_name(account_name).click()
        status_test_dapp = home.open_status_test_dapp()
        status_test_dapp.wait_for_d_aap_to_load()
        status_test_dapp.transactions_button.click_until_presence_of_element(
            status_test_dapp.send_two_tx_in_batch_button)
        status_test_dapp.send_two_tx_in_batch_button.click()
        if not send_transaction.validation_error_element.is_element_displayed(10):
            self.errors.append(warning % (errors['sending_screen']['Network fee'], screen))
        self.errors.verify_no_errors()

    @marks.testrail_id(695855)
    def test_wallet_custom_gas_settings_send_tx(self):
        sender = transaction_senders['ETH_7']
        sign_in = SignInView(self.driver)
        sign_in.recover_access(sender['passphrase'])
        wallet = sign_in.wallet_button.click()
        wallet.wait_balance_is_changed()
        wallet.accounts_status_account.click()

        send_transaction = wallet.send_transaction_button.click()
        amount = '0.000%s' % str(random.randint(100000, 999999)) + '1'
        self.value = send_transaction.amount_edit_box.set_value(amount)
        send_transaction.set_recipient_address(ens_user_message_sender['ens'])
        send_transaction.next_button.click()
        wallet.ok_got_it_button.wait_and_click(30)
        send_transaction.network_fee_button.click()
        send_transaction = wallet.get_send_transaction_view()
        fee_fields = (send_transaction.per_gas_tip_limit_input, send_transaction.per_gas_price_limit_input)
        [default_tip, default_price] = [field.text for field in fee_fields]
        default_limit = '21000'

        wallet.just_fyi("Check basic validation")
        values = {
            send_transaction.gas_limit_input:
                {
                    'default': default_limit,
                    'value': '22000',
                    '20999': 'wallet-send-min-units',
                    '@!': 'invalid-number',
                },
            send_transaction.per_gas_tip_limit_input:
                {
                    'default': default_tip,
                    'value': '2.5',
                    'aaaa': 'invalid-number',
                },
            send_transaction.per_gas_price_limit_input:
                {
                    'default': default_price,
                    'value': str(round(float(default_price)+3, 9)),
                    '-2': 'invalid-number',
                }
        }
        for field in values:
            for key in values[field]:
                if key != 'default' and key != 'value':
                    field.clear()
                    field.send_keys(key)
                    if not send_transaction.element_by_translation_id(values[field][key]).is_element_displayed(10):
                        self.errors.append("%s is not shown for %s" % (values[field][key], field.accessibility_id))
                    field.clear()
                    field.set_value(values[field]['value'])

        wallet.just_fyi("Set custom fee and check that it will be applied")
        send_transaction.save_fee_button.scroll_and_click()
        if wallet.element_by_translation_id("change-tip").is_element_displayed():
            wallet.element_by_translation_id("continue-anyway").click()
        send_transaction.sign_transaction()
        self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount, confirmations=3)
        transaction = wallet.find_transaction_in_history(amount=amount, return_hash=True)
        expected_params = {
            'fee_cap': values[send_transaction.per_gas_price_limit_input]['value'],
            'tip_cap': '2.5',
            'gas_limit': '22000'
        }
        actual_params = self.network_api.get_custom_fee_tx_params(transaction)
        if actual_params != expected_params:
            self.errors.append('Real params %s for tx do not match expected %s' % (str(actual_params), str(expected_params)))

        wallet.just_fyi('Verify custom fee data on tx screen')
        wallet.swipe_up()
        for key in expected_params:
            if key != 'fee_cap':
                if not wallet.element_by_text_part(expected_params[key]).is_element_displayed():
                    self.errors.append("Custom tx param %s is not shown on tx history screen" % key)

        wallet.just_fyi("Check below fee popup on mainnet")
        profile = wallet.profile_button.click()
        profile.switch_network()
        sign_in.wallet_button.click()
        wallet.accounts_status_account.click()

        send_transaction = wallet.send_transaction_button.click_until_presence_of_element(send_transaction.amount_edit_box)
        send_transaction.amount_edit_box.set_value(0)
        send_transaction.set_recipient_address(ens_user_message_sender['ens'])
        send_transaction.next_button.click()
        wallet.element_by_translation_id("network-fee").click()
        if not wallet.element_by_translation_id("tx-fail-description2").is_element_displayed():
            self.errors.append("Tx is likely to fail is not shown!")
        if send_transaction.network_fee_button.is_element_displayed():
            self.errors.append("Still can set tx fee when balance is not enough")

        ##  TODO: should be moved to another test after 8f52b9b63ccd9a52b7fe37ab4f89a2e7b6721fcd
        # send_transaction = wallet.get_send_transaction_view()
        # send_transaction.gas_limit_input.clear()
        # send_transaction.gas_limit_input.set_value(default_limit)
        # send_transaction.per_gas_price_limit_input.clear()
        # send_transaction.per_gas_price_limit_input.click()
        # send_transaction.per_gas_price_limit_input.send_keys('1')
        # if not wallet.element_by_translation_id("below-base-fee").is_element_displayed(10):
        #     self.errors.append("Fee is below error is not shown")
        # send_transaction.save_fee_button.scroll_and_click()
        # if not wallet.element_by_translation_id("change-tip").is_element_displayed():
        #     self.errors.append("Popup about changing fee error is not shown")
        # wallet.element_by_translation_id("continue-anyway").click()
        # if not send_transaction.element_by_text_part('0.000021 ETH').is_element_displayed():
        #     self.driver.fail("Custom fee is not applied!")
        self.errors.verify_no_errors()

    @marks.testrail_id(702360)
    def test_collectibles_mainnet_set_as_profile_image(self):
        wallet_users['D'] = dict()
        wallet_users['D'][
            'passphrase'] = "art base select follow harsh capable upper monkey report gun actor rib"
        wallet_users['D']['username'] = "Upbeat Diligent Jaguar"
        wallet_users['D']['address'] = "0xb51fe9F539E611Be5871b40baeBE5c4fe3E33020"
        wallet_users['D'][
            'public_key'] = "0x04c50fe17e2832e0927ea3248afd9056f88af8bac6233bd2b81d123fa" \
                            "5882d729b1341e40ebe60331f8a42386fb2ebd4fa11f592ad8d4cf3b824d8e51a03216185"
        wallet_users['D']['collectibles'] = {
            'CryptoKitties': '1',
            'Status Sticker Pack V2': '1'
        }
        user = wallet_users['D']
        sign_in = SignInView(self.driver)
        home = sign_in.recover_access(user['passphrase'])

        home.just_fyi('Check that collectibles amount is shown on Mainnet')
        profile = home.profile_button.click()
        profile.switch_network('Mainnet with upstream RPC')
        wallet = profile.wallet_button.click()
        wallet.accounts_status_account.click()
        wallet.collectibles_button.click()
        wallet.element_by_translation_id("display-collectibles").scroll_and_click()
        for asset in user['collectibles']:
            wallet.get_collectibles_amount(asset).scroll_to_element()
            if wallet.get_collectibles_amount(asset).text != user['collectibles'][asset]:
                self.errors.append(
                    '%s %s is not shown in Collectibles for Mainnet!' % (user['collectibles'][asset], asset))

        wallet.just_fyi('Check that you can open collectible to view')
        nft, nft_name = 'CryptoKitties', 'Miss Purrfect'
        wallet.get_collectibles_amount().click()
        if not wallet.nft_asset_button.is_element_displayed(60):
            self.driver.fail("No card is not shown for %s after opening it from collectibles!" % nft)
        wallet.nft_asset_button.click()
        wallet.set_collectible_as_profile_photo_button.scroll_and_click()

        wallet.just_fyi('Check that you can set collectible as profile photo')
        web_view = wallet.get_base_web_view()
        wallet.view_collectible_on_opensea_button.click_until_presence_of_element(
            web_view.browser_previous_page_button)
        web_view.wait_for_d_aap_to_load()
        if not web_view.element_by_text(nft_name).is_element_displayed(30):
            self.errors.append("Collectible can't be opened when tapping 'View on OpenSea' via NFT page")
        wallet.wallet_button.click()

        wallet.just_fyi('Check that collectibles are not shown when sending assets from wallet')
        send_transaction = wallet.send_transaction_button.click()
        send_transaction.select_asset_button.click()
        if send_transaction.asset_by_name(nft).is_element_displayed():
            self.errors.append('Collectibles can be sent from wallet')
        wallet.close_send_transaction_view_button.double_click()

        wallet.just_fyi("Check that custom image from collectible is set as profile photo")
        wallet.profile_button.double_click()
        if not profile.profile_picture.is_element_image_similar_to_template('collectible_pic_2.png'):
            self.errors.append("Collectible image is not set as profile image")
        self.errors.verify_no_errors()

    @marks.testrail_id(695890)
    def test_profile_use_another_fleets_balance_bsc_xdai_advanced_set_nonce(self):
        user = user_mainnet
        sign_in = SignInView(self.driver)
        home = sign_in.recover_access(user['passphrase'])

        home.just_fyi("Check that can enable all toggles and still login successfully")
        profile = home.profile_button.click()
        profile.advanced_button.click()
        profile.transaction_management_enabled_toggle.click()
        profile.webview_debug_toggle.click()
        profile.waku_bloom_toggle.scroll_and_click()
        sign_in.sign_in()

        home.just_fyi("Check tx management")
        wallet = home.wallet_button.click()
        send_tx = wallet.send_transaction_from_main_screen.click()
        from views.send_transaction_view import SendTransactionView
        send_tx = SendTransactionView(self.driver)
        send_tx.amount_edit_box.set_value('0')
        send_tx.set_recipient_address(transaction_senders['ETH_7']['address'])
        send_tx.next_button.click()
        send_tx.set_up_wallet_when_sending_tx()
        send_tx.advanced_button.click()
        send_tx.nonce_input.set_value('0')
        send_tx.nonce_save_button.click()
        error_text = send_tx.sign_transaction(error=True)
        if error_text != 'nonce too low':
            self.errors.append("%s is not expected error when signing tx with custom nonce" % error_text)

        home.just_fyi("Check balance on mainnet")
        profile = home.profile_button.click()
        profile.switch_network()
        wallet = home.wallet_button.click()
        wallet.scan_tokens()
        [wallet.wait_balance_is_equal_expected_amount(asset, value) for asset, value in user['mainnet'].items()]
        # TODO: blocked due to 695890
        # home.just_fyi("Check balance on xDai and default network fee")
        # profile = home.profile_button.click()
        # profile.switch_network('xDai Chain')
        # home.wallet_button.click()
        # wallet.element_by_text(user['xdai']).wait_for_element(30)

        home.just_fyi("Check balance on BSC and default network fee")
        profile = home.profile_button.click()
        profile.switch_network('BSC Network')
        home.wallet_button.click()
        wallet.element_by_text(user['bsc']).wait_for_element(30)

        self.errors.verify_no_errors()

    @marks.testrail_id(6219)
    def test_profile_set_primary_ens_custom_domain(self):
        home = SignInView(self.driver).recover_access(ens_user['passphrase'])
        ens_second, ens_main = ens_user['ens_upgrade'], ens_user['ens']

        home.just_fyi('add 2 ENS names in Profile')
        profile = home.profile_button.click()
        dapp = profile.connect_existing_ens(ens_main)

        profile.element_by_translation_id("ens-add-username").wait_and_click()
        dapp.ens_name_input.set_value(ens_second)
        dapp.check_ens_name.click_until_presence_of_element(dapp.element_by_translation_id("ens-got-it"))
        dapp.element_by_translation_id("ens-got-it").wait_and_click()

        home.just_fyi('check that by default %s ENS is set' % ens_main)
        dapp.element_by_translation_id("ens-primary-username").click()
        message_to_check = 'Your messages are displayed to others with'
        if not dapp.element_by_text('%s\n@%s' % (message_to_check, ens_main)).is_element_displayed():
            self.errors.append('%s ENS username is not set as primary by default' % ens_main)

        home.just_fyi('check view in chat settings ENS from other domain: %s after set new primary ENS' % ens_second)
        dapp.set_primary_ens_username(ens_second).click()
        if profile.username_in_ens_chat_settings_text.text != '@' + ens_second:
            self.errors.append('ENS username %s is not shown in ENS username Chat Settings after enabling' % ens_second)
        self.errors.verify_no_errors()

    @marks.testrail_id(5453)
    def test_profile_privacy_policy_terms_of_use_node_version_need_help(self):
        signin = SignInView(self.driver)
        no_link_found_error_msg = 'Could not find privacy policy link at'
        no_link_open_error_msg = 'Could not open our privacy policy from'
        no_link_tos_error_msg = 'Could not open Terms of Use from'

        signin.just_fyi("Checking privacy policy and TOS links")
        if not signin.privacy_policy_link.is_element_present():
            self.errors.append('%s Sign in view!' % no_link_found_error_msg)
        if not signin.terms_of_use_link.is_element_displayed():
            self.driver.fail("No Terms of Use link on Sign in view!")

        home = signin.create_user()
        profile = home.profile_button.click()
        profile.about_button.click()
        profile.privacy_policy_button.click()
        from views.web_views.base_web_view import BaseWebView
        web_page = BaseWebView(self.driver)
        if not web_page.policy_summary.is_element_displayed():
            self.errors.append('%s Profile about view!' % no_link_open_error_msg)
        web_page.click_system_back_button()

        profile.terms_of_use_button.click()
        web_page.wait_for_d_aap_to_load()
        web_page.swipe_by_custom_coordinates(0.5, 0.8, 0.5, 0.4)
        if not web_page.terms_of_use_summary.is_element_displayed(30):
            self.errors.append('%s Profile about view!' % no_link_tos_error_msg)
        web_page.click_system_back_button()

        signin.just_fyi("Checking that version match expected format and can be copied")
        app_version = profile.app_version_text.text
        node_version = profile.node_version_text.text
        if not re.search(r'\d[.]\d{1,2}[.]\d{1,2}\s[(]\d*[)]', app_version):
            self.errors.append("App version %s didn't match expected format" % app_version)
        if not re.search(r'StatusIM/v.*/android-\d{3}/go\d[.]\d+', node_version):
            self.errors.append("Node version %s didn't match expected format" % node_version)
        profile.app_version_text.click()
        profile.home_button.double_click()
        chat = home.join_public_chat(home.get_random_chat_name())
        message_input = chat.chat_message_input
        message_input.paste_text_from_clipboard()
        if message_input.text != app_version:
            self.errors.append('Version number was not copied to clipboard')

        signin.just_fyi("Checking Need help section")
        home.profile_button.double_click()
        profile.help_button.click()
        web_page = profile.faq_button.click()
        web_page.open_in_webview()
        web_page.wait_for_d_aap_to_load()
        if not profile.element_by_text_part("F.A.Q").is_element_displayed(30):
            self.errors.append("FAQ is not shown")
        profile.click_system_back_button()
        profile.submit_bug_button.click()

        signin.just_fyi("Checking bug submitting form")
        profile.bug_description_edit_box.set_value('1234')
        profile.bug_submit_button.click()
        if not profile.element_by_translation_id("bug-report-too-short-description").is_element_displayed():
            self.errors.append("Can submit big with too short description!")
        profile.bug_description_edit_box.clear()
        [field.set_value("Something wrong happened!!") for field in
         (profile.bug_description_edit_box, profile.bug_steps_edit_box)]
        profile.bug_submit_button.click()
        if not profile.element_by_text_part("Welcome to Gmail").is_element_displayed(30):
            self.errors.append("Mail client is not opened when submitting bug")
        profile.click_system_back_button(2)

        signin.just_fyi("Checking request feature")
        profile.request_a_feature_button.click()
        if not profile.element_by_text("#support").is_element_displayed(30):
            self.errors.append("Support channel is not suggested for requesting a feature")
        self.errors.verify_no_errors()

    @marks.testrail_id(5766)
    def test_profile_use_pinned_history_node_from_list(self):
        home = SignInView(self.driver).create_user()
        profile = home.profile_button.click()
        home.profile_button.click()

        home.just_fyi('pin history node')
        profile.sync_settings_button.click()
        node_gc, node_ams, node_hk = [profile.return_mailserver_name(history_node_name, used_fleet) for
                                      history_node_name in (mailserver_gc, mailserver_ams, mailserver_hk)]
        h_node = node_ams
        profile.mail_server_button.click()
        profile.mail_server_auto_selection_button.click()
        profile.mail_server_by_name(h_node).click()
        profile.confirm_button.click()
        if profile.element_by_translation_id("mailserver-error-title").is_element_displayed(10):
            h_node = node_hk
            profile.element_by_translation_id("mailserver-pick-another", uppercase=True).click()
            profile.mail_server_by_name(h_node).click()
            profile.confirm_button.click()
            if profile.element_by_translation_id("mailserver-error-title").is_element_displayed(10):
                self.driver.fail("Couldn't connect to any history node")

        profile.just_fyi('check that history node is pinned')
        profile.close_button.click()
        if not profile.element_by_text(h_node).is_element_displayed():
            self.errors.append('"%s" history node is not pinned' % h_node)
        profile.home_button.click()

        profile.just_fyi('Relogin and check that settings are preserved')
        home.relogin()
        home.profile_button.click()
        profile.sync_settings_button.click()
        if not profile.element_by_text(h_node).is_element_displayed():
            self.errors.append('"%s" history node is not pinned' % h_node)

        self.errors.verify_no_errors()

    @marks.testrail_id(6318)
    def test_profile_delete_several_multiaccounts(self):
        sign_in = SignInView(self.driver)
        sign_in.create_user()
        delete_alert_warning = sign_in.get_translation_by_key("delete-profile-warning")
        profile = sign_in.profile_button.click()
        profile.logout()
        if sign_in.ok_button.is_element_displayed():
            sign_in.ok_button.click()
        sign_in.navigate_up_button.click()
        sign_in.your_keys_more_icon.click()
        sign_in.generate_new_key_button.click()
        sign_in.next_button.click()
        sign_in.next_button.click()
        sign_in.create_password_input.set_value(common_password)
        sign_in.next_button.click()
        sign_in.confirm_your_password_input.set_value(common_password)
        sign_in.next_button.click()
        sign_in.maybe_later_button.click_until_presence_of_element(sign_in.lets_go_button)
        sign_in.lets_go_button.click()

        sign_in.just_fyi('Delete 2nd multiaccount')
        public_key, username = sign_in.get_public_key_and_username(return_username=True)
        profile.privacy_and_security_button.click()
        profile.delete_my_profile_button.scroll_and_click()
        for text in (username, delete_alert_warning):
            if not profile.element_by_text(text).is_element_displayed():
                self.errors.append('Required %s is not shown when deleting multiaccount' % text)
        profile.delete_profile_button.click()
        if profile.element_by_translation_id("profile-deleted-title").is_element_displayed():
            self.driver.fail('Profile is deleted without confirmation with password')
        profile.delete_my_profile_password_input.set_value(common_password)
        profile.delete_profile_button.click_until_presence_of_element(
            profile.element_by_translation_id("profile-deleted-title"))
        profile.ok_button.click()

        sign_in.just_fyi('Delete last multiaccount')
        sign_in.sign_in()
        sign_in.profile_button.click()
        profile.privacy_and_security_button.click()
        profile.delete_my_profile_button.scroll_and_click()
        profile.delete_my_profile_password_input.set_value(common_password)
        profile.delete_profile_button.click()
        profile.ok_button.click()
        if not sign_in.get_started_button.is_element_displayed(20):
            self.errors.append('No redirected to carousel view after deleting last multiaccount')
        self.errors.verify_no_errors()

    @marks.testrail_id(6213)
    def test_contacts_unblock_user_is_not_added_back_to_contacts(self):
        home = SignInView(self.driver).create_user()
        chat = home.add_contact(basic_user["public_key"], add_in_contacts=False)

        chat.just_fyi('Block user not added as contact from chat view')
        chat.chat_options.click()
        chat.view_profile_button.click()
        chat.block_contact()
        chat.get_back_to_home_view()

        chat.just_fyi('Unblock user not added as contact from chat view')
        profile = home.profile_button.click()
        profile.contacts_button.click()
        profile.blocked_users_button.click()
        profile.element_by_text(basic_user["username"]).click()
        chat.unblock_contact_button.click()

        profile.just_fyi('Navigating to contact list and check that user is not in list')
        profile.close_button.click()
        profile.navigate_up_button.click()
        if profile.element_by_text(basic_user["username"]).is_element_displayed():
            self.driver.fail("Unblocked user not added previously in contact list added in contacts!")

    @marks.testrail_id(5721)
    def test_group_chat_cant_add_more_twenty_participants(self):
        user_20_contacts = dict()
        user_20_contacts[
            'passphrase'] = "length depend bottom mom kitchen solar deposit emerge junior horse midnight grunt"

        sign_in = SignInView(self.driver)
        home = sign_in.recover_access(user_20_contacts['passphrase'])

        users = [chat_users['A'],
                 chat_users['B'],
                 transaction_senders['ETH_8'],
                 transaction_senders['ETH_1'],
                 transaction_senders['ETH_2'],
                 transaction_senders['ETH_7'],
                 transaction_senders['ETH_STT_3'],
                 transaction_senders['ETH_STT_ADI_1'],
                 transaction_senders['C'],
                 transaction_senders['F'],
                 transaction_senders['G'],
                 transaction_senders['H'],
                 transaction_senders['I'],
                 transaction_senders['M'],
                 transaction_senders['N'],
                 transaction_senders['Q'],
                 transaction_senders['R'],
                 transaction_senders['S'],
                 transaction_senders['T'],
                 transaction_senders['U']]
        usernames = []

        for user in users:
            usernames.append(user['username'])
        profile = home.profile_button.click()
        profile.element_by_text('20').wait_for_visibility_of_element(120)
        home.home_button.double_click()

        home.just_fyi('Create group chat with max amount of users')
        chat = home.create_group_chat(usernames, 'some_group_chat')

        home.just_fyi('Verify that can not add more users via group info')
        chat.get_back_to_home_view()
        home.get_chat('some_group_chat').click()
        chat.chat_options.click()
        group_info_view = chat.group_info.click()
        if group_info_view.add_members.is_element_displayed():
            self.errors.append('Add members button is displayed when max users are added in chat')
        if not group_info_view.element_by_text_part('20 members').is_element_displayed():
            self.errors.append('Amount of users is not shown on Group info screen')

        self.errors.verify_no_errors()

    @marks.testrail_id(5455)
    def test_restore_multiaccounts_with_certain_seed_phrase(self):
        sign_in = SignInView(self.driver)
        for phrase, account in recovery_users.items():
            home_view = sign_in.recover_access(passphrase=phrase, password=unique_password)
            wallet_view = home_view.wallet_button.click()
            address = wallet_view.get_wallet_address()
            if address != account:
                self.errors.append('Restored wallet address "%s" does not match expected "%s"' % (address, account))
            profile = home_view.profile_button.click()
            profile.privacy_and_security_button.click()
            profile.delete_my_profile_button.scroll_and_click()
            profile.delete_my_profile_password_input.set_value(unique_password)
            profile.delete_profile_button.click()
            profile.ok_button.click()
        self.errors.verify_no_errors()

    @marks.testrail_id(702167)
    def test_ens_dapp_purchase(self):
        sign_in = SignInView(self.driver)
        self.home = sign_in.create_user()
        self.ens_name = 'purchased%s' % self.home.get_random_chat_name()
        self.wallet = self.home.wallet_button.click()
        self.address = self.wallet.get_wallet_address()
        self.chat_key = self.home.get_public_key_and_username()

        self.wallet.just_fyi("Get required donate")
        w3.donate_testnet_eth(self.address, amount=0.1, inscrease_default_gas_price=10)
        self.home.wallet_button.click()
        self.wallet.wait_balance_is_changed()
        w3.donate_testnet_token('STT', address=self.address, amount=10, inscrease_default_gas_price=10)
        self.wallet.wait_balance_is_changed('STT', scan_tokens=True)

        self.wallet.just_fyi("Purchase ENS")
        self.profile = self.home.profile_button.click()
        self.profile.ens_usernames_button.wait_and_click()
        self.dapp = self.home.get_dapp_view()
        self.dapp.get_started_ens.click()
        self.dapp.ens_name_input.set_value(self.ens_name)
        self.dapp.check_ens_name.click_until_presence_of_element(self.dapp.register_ens_button)
        self.dapp.agree_on_terms_ens.scroll_and_click()
        if not self.dapp.element_by_text(self.chat_key).is_element_displayed():
            self.error.append("No chat key for user is shown when register requested chat key")
        self.dapp.register_ens_button.click()
        self.send_tx = self.home.get_send_transaction_view()
        self.send_tx.sign_transaction()
        if not self.dapp.element_by_text('Nice! You own %s.stateofus.eth once the transaction is complete.' % self.ens_name).is_element_displayed(60):
            self.error.append("ENS name %s is not purchasing" % self.ens_name)
        self.dapp.ens_got_it.click()
        if self.dapp.registration_in_progress.is_element_displayed(10):
            self.dapp.registration_in_progress.wait_for_invisibility_of_element(400)
        self.dapp.element_by_text(self.ens_name).click()
        for text in ("10 SNT, deposit unlocked", self.chat_key, self.address.lower()):
            if not self.dapp.element_by_text(text).is_element_displayed(10):
                self.errors.append("%s is not displayed after ENS purchasing" % text)

        self.wallet.just_fyi("Send leftovers")
        self.wallet.wallet_button.double_click()
        address = self.wallet.get_wallet_address()
        send_transaction = self.wallet.send_transaction_button.click()
        send_transaction.set_max_button.click()
        send_transaction.confirm()
        send_transaction.chose_recipient_button.click()
        send_transaction.set_recipient_address(w3.ACCOUNT_ADDRESS)
        send_transaction.sign_transaction_button.click()
        send_transaction.sign_transaction()

        self.wallet.just_fyi("Verify purchased ENS")
        self.home.home_button.click()
        self.home.plus_button.click_until_presence_of_element(self.home.start_new_chat_button)
        chat = self.home.start_new_chat_button.click()
        chat.public_key_edit_box.click()
        chat.public_key_edit_box.send_keys(self.ens_name)
        if not self.home.element_by_translation_id("can-not-add-yourself").is_element_displayed(20):
            self.errors.append(
                "Public key in not resolved correctly from %s ENS name on stateofus!" % self.ens_name)
        self.home.get_back_to_home_view()
        self.wallet.wallet_button.double_click()
        self.wallet.send_transaction_from_main_screen.click_until_presence_of_element(send_transaction.chose_recipient_button)
        send_transaction.chose_recipient_button.scroll_and_click()
        send_transaction.set_recipient_address(self.ens_name)
        if not send_transaction.element_by_text_part(send_transaction.get_formatted_recipient_address(address)).is_element_displayed(5):
            self.errors.append("Wallet address in not resolved correctly from %s ENS name on stateofus!" % self.ens_name)

        self.errors.verify_no_errors()

    @marks.testrail_id(6300)
    @marks.skip
    # TODO: waiting mode (rechecked 23.11.21, valid)
    def test_webview_security(self):
        home_view = SignInView(self.driver).create_user()
        daap_view = home_view.dapp_tab_button.click()

        browsing_view = daap_view.open_url('https://simpledapp.status.im/webviewtest/url-spoof-ssl.html')
        browsing_view.url_edit_box_lock_icon.click()
        if not browsing_view.element_by_translation_id("browser-not-secure").is_element_displayed():
            self.errors.append("Broken certificate displayed as secure connection \n")

        browsing_view.cross_icon.click()
        daap_view.open_url('https://simpledapp.status.im/webviewtest/webviewtest.html')
        browsing_view.element_by_text_part('204').click()
        if browsing_view.element_by_text_part('google.com').is_element_displayed():
            self.errors.append("URL changed on attempt to redirect to no-content page \n")

        browsing_view.cross_icon.click()
        daap_view.open_url('https://simpledapp.status.im/webviewtest/webviewtest.html')
        browsing_view.element_by_text_part('XSS check').click()
        browsing_view.open_in_status_button.click()
        if browsing_view.element_by_text_part('simpledapp.status.im').is_element_displayed():
            self.errors.append("XSS attemp succedded \n")
            browsing_view.ok_button.click()

        browsing_view.cross_icon.click()
        daap_view.open_url('https://simpledapp.status.im/webviewtest/url-blank.html')
        if daap_view.edit_url_editbox.text == '':
            self.errors.append("Blank URL value. Must show the actual URL \n")

        browsing_view.cross_icon.click()
        daap_view.open_url('https://simpledapp.status.im/webviewtest/port-timeout.html')
        # wait up  ~2.5 mins for port time out
        if daap_view.element_by_text_part('example.com').is_element_displayed(150):
            self.errors.append("URL spoof due to port timeout \n")

        self.errors.verify_no_errors()