diff --git a/.gitignore b/.gitignore
index 419522adec..866763f413 100644
--- a/.gitignore
+++ b/.gitignore
@@ -165,3 +165,7 @@ trace.edn
 
 /app/
 project.clj
+
+##appium
+test/appium/report/
+result.xml
\ No newline at end of file
diff --git a/test/appium/requirements.txt b/test/appium/requirements.txt
index 9634dfcd0c..c2e44cdcd5 100644
--- a/test/appium/requirements.txt
+++ b/test/appium/requirements.txt
@@ -4,7 +4,7 @@ apipkg==1.5
 Appium-Python-Client==1.0.2
 async-timeout==3.0.1
 certifi==2020.11.8
-chardet==3.0.4
+chardet==4.0.0
 cycler==0.10.0
 cytoolz==0.11.0
 emoji==0.5.0
@@ -37,7 +37,7 @@ python-dateutil==2.8.1
 pytz==2020.4
 PyYAML==5.4
 repoze.lru==0.7
-requests==2.25.0
+requests==2.25.1
 rlp==1.2.0
 sauceclient==1.0.0
 scrypt==0.8.17
diff --git a/test/appium/support/api/network_api.py b/test/appium/support/api/network_api.py
index e3e502d3e7..db0e3e3886 100644
--- a/test/appium/support/api/network_api.py
+++ b/test/appium/support/api/network_api.py
@@ -17,8 +17,8 @@ class NetworkApi(object):
         self.faucet_url = 'https://faucet-ropsten.status.im/donate'
         self.faucet_backup_address = w3.account_address
         self.headers = {
-        'User-Agent':"Mozilla\/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit\
-        /537.36 (KHTML, like Gecko) Chrome\/77.0.3865.90 Safari\/537.36", }
+        'User-Agent':"Mozilla\\5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit\\537.36 (KHTML, like Gecko) Chrome\\7"
+                     "7.0.3865.90 Safari\\537.36", }
         self.chat_bot_url = 'http://offsite.chat:8099'
         self.api_key = environ.get('ETHERSCAN_API_KEY')
 
diff --git a/test/appium/support/api/web3_api.py b/test/appium/support/api/web3_api.py
index 63986f298f..0215f16a07 100644
--- a/test/appium/support/api/web3_api.py
+++ b/test/appium/support/api/web3_api.py
@@ -27,7 +27,7 @@ class Account(object):
         return w3.eth.getBalance(self.account_address)
 
     def send_eth(self, to_address, eth_value, gas_price_increment=0):
-        signed_txn = w3.eth.account.signTransaction(dict(
+        signed_txn = w3.eth.account.sign_transaction(dict(
             nonce=self.nonce,
             gasPrice=w3.eth.gasPrice + gas_price_increment * 1000000000,
             gas=21000,
diff --git a/test/appium/tests/atomic/account_management/test_create_account.py b/test/appium/tests/atomic/account_management/test_create_account.py
index 36b1bdada5..046f0d9506 100644
--- a/test/appium/tests/atomic/account_management/test_create_account.py
+++ b/test/appium/tests/atomic/account_management/test_create_account.py
@@ -133,9 +133,9 @@ class TestCreateAccount(SingleDeviceTestCase):
     @marks.testrail_id(5363)
     @marks.high
     def test_pass_phrase_validation(self):
-        signin_view = SignInView(self.driver)
-        signin_view.get_started_button.click_until_presence_of_element(signin_view.access_key_button)
-        signin_view.access_key_button.click()
+        sign_in = SignInView(self.driver)
+        sign_in.get_started_button.click_until_presence_of_element(sign_in.access_key_button)
+        sign_in.access_key_button.click()
         validations = [
             {
                 'case': 'empty value',
@@ -160,52 +160,52 @@ class TestCreateAccount(SingleDeviceTestCase):
             },
         ]
 
-        signin_view.just_fyi("check that seed phrase is required (can't be empty)")
-        signin_view.enter_seed_phrase_button.click()
-        signin_view.next_button.click()
-        if signin_view.reencrypt_your_key_button.is_element_displayed():
+        sign_in.just_fyi("check that seed phrase is required (can't be empty)")
+        sign_in.enter_seed_phrase_button.click()
+        sign_in.next_button.click()
+        if sign_in.reencrypt_your_key_button.is_element_displayed():
             self.errors.append("Possible to create account with empty seed phrase")
 
-        signin_view = SignInView(self.driver, skip_popups=False)
+        sign_in = SignInView(self.driver, skip_popups=False)
         for validation in validations:
-            signin_view.just_fyi("Checking %s" % validation.get('case'))
+            sign_in.just_fyi("Checking %s" % validation.get('case'))
             phrase, msg, words_count, popup = validation.get('phrase'), \
                                             validation.get('validation message'), \
                                             validation.get('words count'),\
                                             validation.get('popup')
-            if signin_view.access_key_button.is_element_displayed():
-                signin_view.access_key_button.click()
-            if signin_view.enter_seed_phrase_button.is_element_displayed():
-                signin_view.enter_seed_phrase_button.click()
+            if sign_in.access_key_button.is_element_displayed():
+                sign_in.access_key_button.click()
+            if sign_in.enter_seed_phrase_button.is_element_displayed():
+                sign_in.enter_seed_phrase_button.click()
 
-            signin_view.seedphrase_input.set_value(phrase)
+            sign_in.seedphrase_input.set_value(phrase)
 
             if msg:
-                if not signin_view.element_by_text(msg).is_element_displayed():
+                if not sign_in.element_by_text(msg).is_element_displayed():
                     self.errors.append('"{}" message is not shown'.format(msg))
 
-            signin_view.just_fyi('check that words count is shown')
+            sign_in.just_fyi('check that words count is shown')
             if words_count:
-                if not signin_view.element_by_text('%s word' % words_count):
+                if not sign_in.element_by_text('%s word' % words_count):
                     self.errors.append('"%s word" is not shown ' % words_count)
             else:
-                if not signin_view.element_by_text('%s words' % words_count):
+                if not sign_in.element_by_text('%s words' % words_count):
                     self.errors.append('"%s words" is not shown ' % words_count)
 
-            signin_view.just_fyi('check that "Next" is disabled unless we use allowed count of words')
+            sign_in.just_fyi('check that "Next" is disabled unless we use allowed count of words')
             if words_count != 12 or 15 or 18 or 21 or 24:
-                signin_view.next_button.click()
-                if signin_view.reencrypt_your_key_button.is_element_displayed():
+                sign_in.next_button.click()
+                if sign_in.reencrypt_your_key_button.is_element_displayed():
                     self.errors.append("Possible to create account with wrong count (%s) of words" % words_count)
 
-            signin_view.just_fyi('check behavior for popup "Custom seed phrase"')
+            sign_in.just_fyi('check behavior for popup "Custom seed phrase"')
             if popup:
 
-                if not signin_view.element_by_translation_id("custom-seed-phrase").is_element_displayed():
+                if not sign_in.element_by_translation_id("custom-seed-phrase").is_element_displayed():
                     self.errors.append("Popup about custom seed phrase is not shown")
-                signin_view.cancel_custom_seed_phrase_button.click()
+                sign_in.cancel_custom_seed_phrase_button.click()
 
-            signin_view.click_system_back_button()
+            sign_in.click_system_back_button()
 
         self.errors.verify_no_errors()
 
diff --git a/test/appium/tests/atomic/chats/test_commands.py b/test/appium/tests/atomic/chats/test_commands.py
index 7538b71a8b..3db328badf 100644
--- a/test/appium/tests/atomic/chats/test_commands.py
+++ b/test/appium/tests/atomic/chats/test_commands.py
@@ -1,4 +1,3 @@
-from _pytest.outcomes import Failed
 import time
 
 from tests import marks
@@ -11,7 +10,7 @@ from views.sign_in_view import SignInView
 class TestCommandsMultipleDevices(MultipleDeviceTestCase):
     @marks.testrail_id(6253)
     @marks.critical
-    def test_send_eth_in_1_1_chat(self):
+    def test_send_eth_in_1_1_chat_transaction_push(self):
         sender = transaction_senders['A']
         self.create_drivers(2)
         device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
@@ -30,69 +29,70 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
 
         chat_1 = home_1.add_contact(recipient_public_key)
         amount = chat_1.get_unique_amount()
+        account_name = wallet_1.status_account_name
 
         home_1.just_fyi('Send %s ETH in 1-1 chat and check it for sender and receiver: Address requested' % amount)
         chat_1.commands_button.click()
         send_transaction = chat_1.send_command.click()
-        if not send_transaction.get_username_in_transaction_bottom_sheet_button(recipient_username).is_element_displayed():
-            self.driver.fail('%s is not shown in "Send Transaction" bottom sheet' % recipient_username)
         send_transaction.get_username_in_transaction_bottom_sheet_button(recipient_username).click()
         if send_transaction.scan_qr_code_button.is_element_displayed():
-            self.driver.fail('Recipient is editable in bottom sheet when send ETH from 1-1 chat')
+            self.drivers[0].fail('Recipient is editable in bottom sheet when send ETH from 1-1 chat')
         send_transaction.amount_edit_box.set_value(amount)
         send_transaction.confirm()
         send_transaction.sign_transaction_button.click()
-        chat_1_sender_message = chat_1.chat_element_by_text('↑ Outgoing transaction')
-        if not chat_1_sender_message.is_element_displayed():
-            self.driver.fail('No message is shown after sending ETH in 1-1 chat for sender')
-        chat_1_sender_message.transaction_status.wait_for_element_text('Address requested')
+        sender_message = chat_1.get_outgoing_transaction(account_name)
+        if not sender_message.is_element_displayed():
+            self.drivers[0].fail('No message is shown after sending ETH in 1-1 chat for sender')
+        sender_message.transaction_status.wait_for_element_text(sender_message.address_requested)
 
         chat_2 = home_2.get_chat(sender['username']).click()
-        chat_2_receiver_message = chat_2.chat_element_by_text('↓ Incoming transaction')
-        timestamp_sender = chat_1_sender_message.timestamp_message.text
-        if not chat_2_receiver_message.is_element_displayed():
-            self.driver.fail('No message about incoming transaction in 1-1 chat is shown for receiver')
-        chat_2_receiver_message.transaction_status.wait_for_element_text('Address requested')
+        receiver_message = chat_2.get_incoming_transaction(account_name)
+        timestamp_sender = sender_message.timestamp_message.text
+        if not receiver_message.is_element_displayed():
+            self.drivers[0].fail('No message about incoming transaction in 1-1 chat is shown for receiver')
+        receiver_message.transaction_status.wait_for_element_text(receiver_message.address_requested)
 
         home_2.just_fyi('Accept and share address for sender and receiver')
-        for text in ('Accept and share address', 'Decline'):
-            if not chat_2_receiver_message.contains_text(text):
-                self.driver.fail("Transaction message doesn't contain required option %s" % text)
-        select_account_bottom_sheet = chat_2_receiver_message.accept_and_share_address.click()
-        if not select_account_bottom_sheet.get_account_in_select_account_bottom_sheet_button(wallet_1.status_account_name).is_element_displayed():
+        for option in (receiver_message.decline_transaction, receiver_message.accept_and_share_address):
+            if not option.is_element_displayed():
+                self.drivers[0].fail("Required options accept or share are not shown")
+
+        select_account_bottom_sheet = receiver_message.accept_and_share_address.click()
+        if not select_account_bottom_sheet.get_account_in_select_account_bottom_sheet_button(account_name).is_element_displayed():
             self.errors.append('Not expected value in "From" in "Select account": "Status" is expected')
         select_account_bottom_sheet.select_button.click()
-        chat_2_receiver_message.transaction_status.wait_for_element_text("Shared '%s'" %
-                                                                         home_1.status_account_name)
-        chat_1_sender_message.transaction_status.wait_for_element_text('Address request accepted')
+        receiver_message.transaction_status.wait_for_element_text(receiver_message.shared_account)
+        sender_message.transaction_status.wait_for_element_text(sender_message.address_request_accepted)
 
         home_1.just_fyi("Sign and send transaction and check that timestamp on message is updated")
-        time.sleep(40)
-        send_message = chat_1_sender_message.sign_and_send.click()
-        send_message.next_button.click()
-        send_message.sign_transaction(default_gas_price=False)
-        updated_timestamp_sender = chat_1_sender_message.timestamp_message.text
+        time.sleep(20)
+        send_bottom_sheet = sender_message.sign_and_send.click()
+        send_bottom_sheet.next_button.click()
+        send_bottom_sheet.sign_transaction(default_gas_price=False)
+        updated_timestamp_sender = sender_message.timestamp_message.text
         if updated_timestamp_sender == timestamp_sender:
             self.errors.append("Timestamp of message is not updated after signing transaction")
-
+        sender_message.transaction_status.wait_for_element_text(sender_message.pending)
         chat_1.wallet_button.click()
-        wallet_1.accounts_status_account.click()
-        transactions_view = wallet_1.transaction_history_button.click()
-        transactions_view.transactions_table.find_transaction(amount=amount)
+        wallet_1.find_transaction_in_history(amount=amount)
 
-        for wallet in wallet_1, wallet_2:
-            wallet.put_app_to_background()
+        [wallet.put_app_to_background() for wallet in (wallet_1, wallet_2)]
         self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount)
         device_1.open_notification_bar()
         device_1.element_by_text_part('You sent %s ETH' % amount).click()
         if not wallet_1.transaction_history_button.is_element_displayed():
             self.errors.append('Was not redirected to transaction history after tapping on PN')
-
         wallet_1.home_button.click(desired_view="chat")
-        home_1.just_fyi("Check 'Confirmed' state for sender and receiver")
-        wallet_2.status_in_background_button.click()
-        [message.transaction_status.wait_for_element_text('Confirmed') for message in (chat_1_sender_message, chat_2_receiver_message)]
-        # TODO: should be added PNs for receiver agter getting more stable feature
+
+        home_1.just_fyi("Check 'Confirmed' state for sender and receiver(use pull-to-refresh to update history)")
+        chat_2.status_in_background_button.click()
+        chat_2.wallet_button.click()
+        wallet_2.find_transaction_in_history(amount=amount)
+        wallet_2.home_button.click(desired_view="chat")
+        [message.transaction_status.wait_for_element_text(message.confirmed, 60) for message in
+         (sender_message, receiver_message)]
+
+        #TODO: should be added PNs for receiver after getting more stable feature
         self.errors.verify_no_errors()
 
     @marks.testrail_id(6263)
@@ -101,17 +101,16 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
         sender = transaction_senders['C']
         self.create_drivers(2)
         device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
+        asset_name = 'STT'
+        amount = device_1.get_unique_amount()
 
         device_1.just_fyi('Grab user data for transactions and public chat, set up wallets')
         home_1 = device_1.create_user()
         recipient_public_key, recipient_username = home_1.get_public_key_and_username(return_username=True)
         wallet_1 = home_1.wallet_button.click()
         wallet_1.set_up_wallet()
-        recipient_address = wallet_1.get_wallet_address()
-        wallet_1.back_button.click()
-        wallet_1.select_asset('STT')
+        wallet_1.select_asset(asset_name)
         wallet_1.home_button.click()
-
         home_2 = device_2.recover_access(passphrase=sender['passphrase'])
         wallet_2 = home_2.wallet_button.click()
         wallet_2.set_up_wallet()
@@ -120,13 +119,9 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
         device_2.just_fyi('Add recipient to contact and send 1 message')
         chat_2 = home_2.add_contact(recipient_public_key)
         chat_2.send_message("Hey there!")
-        amount = chat_2.get_unique_amount()
-        asset_name = 'STT'
         profile_2 = wallet_2.profile_button.click()
         profile_2.logout()
-        chat_element = home_1.get_chat(sender['username'])
-        chat_element.wait_for_visibility_of_element(30)
-        chat_1 = chat_element.click()
+        chat_1 = home_1.get_chat(sender['username']).click()
 
         home_1.just_fyi('Request %s STT in 1-1 chat and check it is visible for sender and receiver' % amount)
         chat_1.commands_button.click()
@@ -137,47 +132,50 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
         request_transaction.select_asset_button.click_until_presence_of_element(asset_button)
         asset_button.click()
         request_transaction.request_transaction_button.click()
-        chat_1_request_message = chat_1.chat_element_by_text('↓ Incoming transaction')
+        chat_1_request_message = chat_1.get_incoming_transaction()
         if not chat_1_request_message.is_element_displayed():
-            self.driver.fail('No incoming transaction in 1-1 chat is shown for recipient after requesting STT')
+            self.drivers[0].fail('No incoming transaction in 1-1 chat is shown for recipient after requesting STT')
 
         home_2.just_fyi('Check that transaction message is fetched from offline and sign transaction')
         device_2.sign_in()
         home_2.connection_status.wait_for_invisibility_of_element(30)
         home_2.get_chat(recipient_username).click()
-        chat_2_sender_message = chat_2.chat_element_by_text('↑ Outgoing transaction')
+        chat_2_sender_message = chat_2.get_outgoing_transaction()
         if not chat_2_sender_message.is_element_displayed():
-                self.driver.fail('No outgoing transaction in 1-1 chat is shown for sender after requesting STT')
-        chat_2_sender_message.transaction_status.wait_for_element_text('Address received')
+            self.drivers[0].fail('No outgoing transaction in 1-1 chat is shown for sender after requesting STT')
+        chat_2_sender_message.transaction_status.wait_for_element_text(chat_2_sender_message.address_received)
         send_message = chat_2_sender_message.sign_and_send.click()
         send_message.next_button.click()
         send_message.sign_transaction(default_gas_price=False)
+        chat_2_sender_message.transaction_status.wait_for_element_text(chat_2_sender_message.pending)
 
         home_2.just_fyi('Check that transaction message is updated with new status after offline')
         chat_2.toggle_airplane_mode()
         self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount, confirmations=15, token=True)
         chat_2.toggle_airplane_mode()
         chat_2.connection_status.wait_for_invisibility_of_element(30)
-        [message.transaction_status.wait_for_element_text('Confirmed') for message in
+        [message.transaction_status.wait_for_element_text(message.confirmed) for message in
          (chat_2_sender_message, chat_1_request_message)]
         self.errors.verify_no_errors()
 
     @marks.testrail_id(6265)
     @marks.critical
     def test_decline_transactions_in_1_1_chat_push_notification_changing_state(self):
-        recipient = transaction_recipients['B']
         sender = transaction_senders['B']
         self.create_drivers(2)
         device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
         home_1 = device_1.recover_access(passphrase=sender['passphrase'], enable_notifications=True)
-        home_2 = device_2.recover_access(passphrase=recipient['passphrase'])
+        home_2 = device_2.create_user()
+        profile_2 = home_2.profile_button.click()
+        recipient_chat_key = profile_2.get_public_key_and_username()
         wallet_1, wallet_2 = home_1.wallet_button.click(), home_2.wallet_button.click()
         for wallet in wallet_1, wallet_2:
             wallet.set_up_wallet()
             wallet.home_button.click()
 
-        chat_1 = home_1.add_contact(recipient['public_key'])
+        chat_1 = home_1.add_contact(recipient_chat_key)
         amount = chat_1.get_unique_amount()
+        chat_1.send_message('To start conversation')
 
         home_1.just_fyi('Decline transaction before sharing address and check that state is changed')
         chat_1.commands_button.click()
@@ -185,20 +183,18 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
         send_transaction.amount_edit_box.set_value(amount)
         send_transaction.confirm()
         send_transaction.sign_transaction_button.click()
-        chat_1_sender_message = chat_1.chat_element_by_text('↑ Outgoing transaction')
+        chat_1_sender_message = chat_1.get_outgoing_transaction()
         home_1.click_system_home_button()
 
-        from views.chat_view import ChatView
-        chat = ChatView(self.drivers[1])
-        chat_2 = home_2.get_chat(sender['username']).click_until_presence_of_element(chat.chat_message_input)
-        chat_2_receiver_message = chat_2.chat_element_by_text('↓ Incoming transaction')
+        chat_2 = home_2.get_chat(sender['username']).click()
+        chat_2_receiver_message = chat_2.get_incoming_transaction()
         chat_2_receiver_message.decline_transaction.click()
         home_1.open_notification_bar()
         home_1.element_by_text_part('Request address for transaction declined').wait_and_click()
-        for message in chat_1_sender_message, chat_2_receiver_message:
-            if not message.contains_text('Transaction declined', 20):
-                self.errors.append('Message status is not updated to  "Transaction declined" for transaction before '
-                                   'sharing address')
+
+        [message.transaction_status.wait_for_element_text(message.declined) for message in
+         (chat_1_sender_message, chat_2_receiver_message)]
+
 
         home_1.just_fyi('Decline transaction request and check that state is changed')
         request_amount = chat_1.get_unique_amount()
@@ -206,12 +202,11 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
         request_transaction.amount_edit_box.set_value(request_amount)
         request_transaction.confirm()
         request_transaction.request_transaction_button.click()
-        chat_1_request_message = chat_1.chat_element_by_text('↓ Incoming transaction')
-        chat_2_sender_message = chat_2.chat_element_by_text('↑ Outgoing transaction')
+        chat_1_request_message = chat_1.get_incoming_transaction()
+        chat_2_sender_message = chat_2.get_outgoing_transaction()
         chat_2_sender_message.decline_transaction.click()
-        for message in chat_2_sender_message, chat_1_request_message:
-            if not message.contains_text('Transaction declined', 20):
-                self.errors.append('Message status is not updated to  "Transaction declined" for transaction request')
+        [message.transaction_status.wait_for_element_text(message.declined) for message in
+         (chat_2_sender_message, chat_1_request_message)]
 
         self.errors.verify_no_errors()
 
@@ -237,14 +232,14 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
         request_transaction.amount_edit_box.set_value(amount)
         request_transaction.confirm()
         request_transaction.request_transaction_button.click()
-        chat_2_request_message = chat_2.chat_element_by_text('↓ Incoming transaction')
+        chat_2_request_message = chat_2.get_incoming_transaction()
 
         chat_2_request_message.long_press_element()
         if chat_2.reply_message_button.is_element_displayed():
             self.errors.append('Reply is available on long-tap on Incoming transaction message!')
 
         chat_1 = home_1.get_chat(device_2_username).click()
-        chat_1_sender_message = chat_1.chat_element_by_text('↑ Outgoing transaction')
+        chat_1_sender_message = chat_1.get_outgoing_transaction()
         chat_1_sender_message.long_press_element()
         if chat_1.reply_message_button.is_element_displayed():
             self.errors.append('Reply is available on long-tap on Outgoing transaction message!')
@@ -252,7 +247,14 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
         send_message.next_button.click()
         send_message.sign_transaction()
         self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount, confirmations=15)
-        chat_1_sender_message.transaction_status.wait_for_element_text('Confirmed')
+        chat_1_sender_message.transaction_status.wait_for_element_text(chat_1_sender_message.confirmed)
+        wallet_2 = chat_2.wallet_button.click()
+        wallet_2.set_up_wallet()
+        wallet_2.accounts_status_account.click()
+        wallet_2.swipe_down()
+        wallet_2.home_button.click(desired_view="chat")
+        if chat_2_request_message.transaction_status == chat_1_sender_message.confirmed:
+            self.errors.append("Transaction is shown as confirmed on mainnet, but was sent on ropsten!")
         self.errors.verify_no_errors()
 
 @marks.transaction
@@ -277,6 +279,6 @@ class TestCommandsSingleDevices(SingleDeviceTestCase):
         send_transaction = SendTransactionView(self.driver)
         send_transaction.ok_got_it_button.click()
         send_transaction.sign_transaction(default_gas_price=False)
-        chat_sender_message = chat.chat_element_by_text('↑ Outgoing transaction')
+        chat_sender_message = chat.get_outgoing_transaction()
         self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount, confirmations=15)
-        chat_sender_message.transaction_status.wait_for_element_text('Confirmed')
+        chat_sender_message.transaction_status.wait_for_element_text(chat_sender_message.confirmed)
diff --git a/test/appium/tests/atomic/chats/test_group_chat.py b/test/appium/tests/atomic/chats/test_group_chat.py
index 2e8664d198..a57e93af2b 100644
--- a/test/appium/tests/atomic/chats/test_group_chat.py
+++ b/test/appium/tests/atomic/chats/test_group_chat.py
@@ -21,7 +21,7 @@ class TestGroupChatMultipleDevice(MultipleDeviceTestCase):
 
         device_1_home.just_fyi('Check default placeholder when trying to create group chat without contacts')
         device_1_home.new_group_chat_button.click()
-        if not device_1_home.element_by_text('Invite friends').is_element_displayed():
+        if not device_1_home.element_by_translation_id("invite-friends").is_element_displayed():
              self.errors.append("No placeholder is shown when there are no contacts")
         device_1_home.get_back_to_home_view()
 
@@ -35,6 +35,7 @@ class TestGroupChatMultipleDevice(MultipleDeviceTestCase):
         create_system_message = device_1_chat.create_system_message(device_1_username, chat_name)
         invite_system_message = device_1_chat.invite_system_message(device_1_username, device_2_username)
         join_system_message = device_1_chat.join_system_message(device_2_username)
+        invited_to_join = device_1_chat.invited_to_join_system_message(device_1_username, chat_name)
         create_for_admin_system_message = device_1_chat.create_for_admin_system_message(chat_name)
         for message in [create_for_admin_system_message, create_system_message, invite_system_message]:
             if not device_1_chat.chat_element_by_text(message):
@@ -47,8 +48,7 @@ class TestGroupChatMultipleDevice(MultipleDeviceTestCase):
         for element in device_2_chat.join_chat_button, device_2_chat.decline_invitation_button:
             if not element.is_element_displayed():
                 self.drivers[0].fail('"Join Chat" or "Decline" is not shown for member of group chat')
-        for message in ['%s invited you to join the group %s' % (device_1_username, chat_name),
-                        create_system_message, invite_system_message]:
+        for message in [invited_to_join, create_system_message, invite_system_message]:
             if not device_2_chat.chat_element_by_text(message):
                 self.errors.append('%s system message is not shown' % message)
 
@@ -100,7 +100,7 @@ class TestGroupChatMultipleDevice(MultipleDeviceTestCase):
         devices_home[2].toggle_airplane_mode()
         devices_home[2].connection_status.wait_for_invisibility_of_element(60)
         if not devices_home[2].get_chat(chat_name).is_element_displayed():
-            self.driver[0].fail('Invite to group chat was not fetched from offline')
+            self.drivers[0].fail('Invite to group chat was not fetched from offline')
         devices_chat[2] = devices_home[2].get_chat(chat_name).click()
         if not devices_chat[2].element_by_text(invite_system_message).is_element_displayed():
             self.errors.append('Message about adding first chat member is not shown for new added member')
diff --git a/test/appium/tests/atomic/chats/test_keycard_commands.py b/test/appium/tests/atomic/chats/test_keycard_commands.py
index f97072b9db..0a4d4fa2ad 100644
--- a/test/appium/tests/atomic/chats/test_keycard_commands.py
+++ b/test/appium/tests/atomic/chats/test_keycard_commands.py
@@ -24,61 +24,62 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
 
         chat_1 = home_1.add_contact(recipient_public_key)
         amount = chat_1.get_unique_amount()
+        account_name = wallet_1.status_account_name
 
         home_1.just_fyi('Send %s ETH in 1-1 chat and check it for sender and receiver: Address requested' % amount)
-        chat_1.commands_button.click_until_presence_of_element(chat_1.send_command)
+        chat_1.commands_button.click()
         send_transaction = chat_1.send_command.click()
-        if not send_transaction.get_username_in_transaction_bottom_sheet_button(recipient_username).is_element_displayed():
-            self.driver.fail('%s is not shown in "Send Transaction" bottom sheet' % recipient_username)
         send_transaction.get_username_in_transaction_bottom_sheet_button(recipient_username).click()
         if send_transaction.scan_qr_code_button.is_element_displayed():
-            self.driver.fail('Recipient is editable in bootom sheet when send ETH from 1-1 chat')
+            self.drivers[0].fail('Recipient is editable in bottom sheet when send ETH from 1-1 chat')
         send_transaction.amount_edit_box.set_value(amount)
         send_transaction.confirm()
         send_transaction.sign_transaction_button.click()
-        chat_1_sender_message = chat_1.chat_element_by_text('↑ Outgoing transaction')
-        if not chat_1_sender_message.is_element_displayed():
-            self.driver.fail('No message is shown after sending ETH in 1-1 chat for sender')
-        chat_1_sender_message.transaction_status.wait_for_element_text('Address requested')
+        sender_message = chat_1.get_outgoing_transaction()
+        if not sender_message.is_element_displayed():
+            self.drivers[0].fail('No message is shown after sending ETH in 1-1 chat for sender')
+        sender_message.transaction_status.wait_for_element_text(sender_message.address_requested)
 
         chat_2 = home_2.get_chat(sender['username']).click()
-        chat_2_receiver_message = chat_2.chat_element_by_text('↓ Incoming transaction')
-        timestamp_sender = chat_1_sender_message.timestamp_message.text
-        if not chat_2_receiver_message.is_element_displayed():
-            self.driver.fail('No message about incoming transaction in 1-1 chat is shown for receiver')
-        chat_2_receiver_message.transaction_status.wait_for_element_text('Address requested')
+        receiver_message = chat_2.get_incoming_transaction()
+        timestamp_sender = sender_message.timestamp_message.text
+        if not receiver_message.is_element_displayed():
+            self.drivers[0].fail('No message about incoming transaction in 1-1 chat is shown for receiver')
+        receiver_message.transaction_status.wait_for_element_text(receiver_message.address_requested)
 
         home_2.just_fyi('Accept and share address for sender and receiver')
-        for text in ('Accept and share address', 'Decline'):
-            if not chat_2_receiver_message.contains_text(text):
-                self.driver.fail("Transaction message doesn't contain required option %s" % text)
-        select_account_bottom_sheet = chat_2_receiver_message.accept_and_share_address.click()
-        if not select_account_bottom_sheet.get_account_in_select_account_bottom_sheet_button(wallet_1.status_account_name).is_element_displayed():
+        for option in (receiver_message.decline_transaction, receiver_message.accept_and_share_address):
+            if not option.is_element_displayed():
+                self.drivers[0].fail("Required options accept or share are not shown")
+
+        select_account_bottom_sheet = receiver_message.accept_and_share_address.click()
+        if not select_account_bottom_sheet.get_account_in_select_account_bottom_sheet_button(account_name).is_element_displayed():
             self.errors.append('Not expected value in "From" in "Select account": "Status" is expected')
         select_account_bottom_sheet.select_button.click()
-        chat_2_receiver_message.transaction_status.wait_for_element_text("Shared '%s'" % home_1.status_account_name)
-        chat_1_sender_message.transaction_status.wait_for_element_text('Address request accepted')
+        receiver_message.transaction_status.wait_for_element_text(receiver_message.shared_account)
+        sender_message.transaction_status.wait_for_element_text(sender_message.address_request_accepted)
 
         home_1.just_fyi("Sign and send transaction and check that timestamp on message is updated")
-        time.sleep(40)
-        send_message = chat_1_sender_message.sign_and_send.click()
+        time.sleep(20)
+        send_message = sender_message.sign_and_send.click()
         send_message.next_button.click()
         send_message.sign_transaction(keycard=True, default_gas_price=False)
-        chat_1_sender_message.transaction_status.wait_for_element_text('Pending')
-        updated_timestamp_sender = chat_1_sender_message.timestamp_message.text
+        sender_message.transaction_status.wait_for_element_text(sender_message.pending)
+        updated_timestamp_sender = sender_message.timestamp_message.text
         if updated_timestamp_sender == timestamp_sender:
             self.errors.append("Timestamp of message is not updated after signing transaction")
 
         chat_1.wallet_button.click()
-        wallet_1.accounts_status_account.click()
-        transactions_view = wallet_1.transaction_history_button.click()
-        transactions_view.transactions_table.find_transaction(amount=amount)
+        wallet_1.find_transaction_in_history(amount=amount)
         self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount)
         wallet_1.home_button.click(desired_view='chat')
 
-        home_1.just_fyi("Check 'Confirmed' state for sender and receiver")
-        [message.transaction_status.wait_for_element_text('Confirmed') for message in
-         (chat_1_sender_message, chat_2_receiver_message)]
+        home_1.just_fyi("Check 'Confirmed' state for sender and receiver(use pull-to-refresh to update history)")
+        chat_2.wallet_button.click()
+        wallet_2.find_transaction_in_history(amount=amount)
+        wallet_2.home_button.click(desired_view="chat")
+        [message.transaction_status.wait_for_element_text(message.confirmed, 60) for message in
+         (sender_message, receiver_message)]
 
         self.errors.verify_no_errors()
 
@@ -92,11 +93,11 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
         device_1.just_fyi('Grab user data for transactions and public chat, set up wallets')
         home_1 = device_1.create_user(keycard=True)
         recipient_public_key, recipient_username = home_1.get_public_key_and_username(return_username=True)
+        amount = device_1.get_unique_amount()
+        asset_name = 'STT'
         wallet_1 = home_1.wallet_button.click()
         wallet_1.set_up_wallet()
-        recipient_address = wallet_1.get_wallet_address()
-        wallet_1.back_button.click()
-        wallet_1.select_asset('STT')
+        wallet_1.select_asset(asset_name)
         wallet_1.home_button.click()
 
         home_2 = device_2.recover_access(passphrase=sender['passphrase'], keycard=True, enable_notifications=True)
@@ -107,8 +108,7 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
         device_2.just_fyi('Add recipient to contact and send 1 message')
         chat_2 = home_2.add_contact(recipient_public_key)
         chat_2.send_message("Hey there!")
-        amount = chat_2.get_unique_amount()
-        asset_name = 'STT'
+
         profile_2 = wallet_2.profile_button.click()
         profile_2.airplane_mode_button.click()
         device_2.home_button.click()
@@ -126,9 +126,9 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
         request_transaction.select_asset_button.click_until_presence_of_element(asset_button)
         asset_button.click()
         request_transaction.request_transaction_button.click()
-        chat_1_request_message = chat_1.chat_element_by_text('↓ Incoming transaction')
+        chat_1_request_message = chat_1.get_incoming_transaction()
         if not chat_1_request_message.is_element_displayed():
-            self.driver.fail('No incoming transaction in 1-1 chat is shown for recipient after requesting STT')
+            self.drivers[0].fail('No incoming transaction in 1-1 chat is shown for recipient after requesting STT')
 
         home_2.just_fyi('Check that transaction message is fetched from offline and sign transaction')
         profile_2.airplane_mode_button.click()
@@ -137,10 +137,10 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
         if not device_2.element_by_text(transaction_request_pn).is_element_displayed(60):
             self.errors.append("Push notification is not received after going back from offline")
         device_2.element_by_text(transaction_request_pn).click()
-        chat_2_sender_message = chat_2.chat_element_by_text('↑ Outgoing transaction')
+        chat_2_sender_message = chat_2.get_outgoing_transaction()
         if not chat_2_sender_message.is_element_displayed():
                 self.driver.fail('No outgoing transaction in 1-1 chat is shown for sender after requesting STT')
-        chat_2_sender_message.transaction_status.wait_for_element_text('Address received')
+        chat_2_sender_message.transaction_status.wait_for_element_text(chat_2_sender_message.address_received)
         send_message = chat_2_sender_message.sign_and_send.click()
         send_message.next_button.click()
         send_message.sign_transaction(keycard=True, default_gas_price=False)
@@ -150,7 +150,8 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
         self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount, token=True)
         chat_2.toggle_airplane_mode()
         chat_2.connection_status.wait_for_invisibility_of_element(60)
-        [message.transaction_status.wait_for_element_text('Confirmed') for message in (chat_2_sender_message, chat_1_request_message)]
+        [message.transaction_status.wait_for_element_text(message.confirmed) for message in
+         (chat_2_sender_message, chat_1_request_message)]
         self.errors.verify_no_errors()
 
 
@@ -175,6 +176,6 @@ class TestCommandsSingleDevices(SingleDeviceTestCase):
         from views.send_transaction_view import SendTransactionView
         send_transaction = SendTransactionView(self.driver)
         send_transaction.sign_transaction(keycard=True)
-        chat_sender_message = chat.chat_element_by_text('↑ Outgoing transaction')
+        chat_sender_message = chat.get_outgoing_transaction()
         self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount, confirmations=15)
-        chat_sender_message.transaction_status.wait_for_element_text('Confirmed')
+        chat_sender_message.transaction_status.wait_for_element_text(chat_sender_message.confirmed)
diff --git a/test/appium/tests/atomic/transactions/test_keycard_wallet.py b/test/appium/tests/atomic/transactions/test_keycard_wallet.py
index 8f1f990b31..fd1d8d2948 100644
--- a/test/appium/tests/atomic/transactions/test_keycard_wallet.py
+++ b/test/appium/tests/atomic/transactions/test_keycard_wallet.py
@@ -26,10 +26,9 @@ class TestTransactionWalletSingleDevice(SingleDeviceTestCase):
         self.network_api.find_transaction_by_unique_amount(sender['address'], transaction_amount)
 
         wallet_view.just_fyi('Check that transaction is appeared in transaction history')
-        transactions_view = wallet_view.transaction_history_button.click()
-        transactions_view.transactions_table.find_transaction(amount=transaction_amount)
+        wallet_view.find_transaction_in_history(amount=transaction_amount)
 
-        transactions_view.just_fyi('Check logcat for sensitive data')
+        wallet_view.just_fyi('Check logcat for sensitive data')
         values_in_logcat = wallet_view.find_values_in_logcat(pin=pin, puk=puk, password=pair_code)
         if values_in_logcat:
             self.driver.fail(values_in_logcat)
@@ -68,9 +67,7 @@ class TestTransactionWalletSingleDevice(SingleDeviceTestCase):
 
         sign_in_view.toggle_airplane_mode()
         wallet_view.wait_balance_is_changed('STT', initial_amount_STT)
-        wallet_view.accounts_status_account.click()
-        transactions_view = wallet_view.transaction_history_button.click()
-        transactions_view.transactions_table.find_transaction(amount=sending_amount, asset='STT')
+        wallet_view.find_transaction_in_history(amount=sending_amount, asset='STT')
 
     @marks.testrail_id(6291)
     @marks.critical
@@ -143,6 +140,7 @@ class TestTransactionWalletSingleDevice(SingleDeviceTestCase):
         updated_balance = self.network_api.get_balance(status_account_address)
         transaction_amount_1 = round(float(transaction_amount) * 0.1, 11)
         wallet_view.wait_balance_is_changed()
+        wallet_view.get_account_by_name(account_name).click()
         send_transaction = wallet_view.send_transaction(account_name=wallet_view.status_account_name,
                                                         amount=transaction_amount_1,
                                                         keycard=True,
@@ -150,11 +148,13 @@ class TestTransactionWalletSingleDevice(SingleDeviceTestCase):
         send_transaction.back_button.click()
         sub_account_address = wallet_view.get_wallet_address(account_name)[2:]
         self.network_api.wait_for_confirmation_of_transaction(sub_account_address, transaction_amount_1)
-        transactions_view = wallet_view.transaction_history_button.click()
+        wallet_view.find_transaction_in_history(amount=transaction_amount)
+        wallet_view.find_transaction_in_history(amount=format(float(transaction_amount_1),'.11f').rstrip('0'))
+        #transactions_view = wallet_view.transaction_history_button.click()
 
         wallet_view.just_fyi("Check transactions on subaccount")
-        transactions_view.transactions_table.find_transaction(amount=transaction_amount)
-        transactions_view.transactions_table.find_transaction(amount=format(float(transaction_amount_1),'.11f').rstrip('0'))
+        #transactions_view.transactions_table.find_transaction(amount=transaction_amount)
+        #transactions_view.transactions_table.find_transaction(amount=format(float(transaction_amount_1),'.11f').rstrip('0'))
         self.network_api.verify_balance_is_updated(updated_balance, status_account_address)
 
         wallet_view.just_fyi("Verify total ETH on main wallet view")
diff --git a/test/appium/tests/atomic/transactions/test_wallet.py b/test/appium/tests/atomic/transactions/test_wallet.py
index 66cb7dd0e7..81b45f6bb6 100644
--- a/test/appium/tests/atomic/transactions/test_wallet.py
+++ b/test/appium/tests/atomic/transactions/test_wallet.py
@@ -29,8 +29,7 @@ class TestTransactionWalletSingleDevice(SingleDeviceTestCase):
                                      sender_password=unique_password )
 
         wallet_view.just_fyi('Check that transaction is appeared in transaction history')
-        transactions_view = wallet_view.transaction_history_button.click()
-        transactions_view.transactions_table.find_transaction(amount=transaction_amount)
+        wallet_view.find_transaction_in_history(amount=transaction_amount)
 
         wallet_view.just_fyi('Check logcat for sensitive data')
         values_in_logcat = wallet_view.find_values_in_logcat(password=unique_password)
@@ -96,10 +95,7 @@ class TestTransactionWalletSingleDevice(SingleDeviceTestCase):
 
         sign_in_view.just_fyi('Check that transaction is appeared in transaction history')
         wallet_view.wait_balance_is_changed('STT', initial_amount_STT)
-        if not wallet_view.transaction_history_button.is_element_displayed():
-            wallet_view.accounts_status_account.click()
-        transactions_view = wallet_view.transaction_history_button.click()
-        transactions_view.transactions_table.find_transaction(amount=sending_amount, asset='STT')
+        wallet_view.find_transaction_in_history(amount=sending_amount, asset='STT')
 
     @marks.testrail_id(5461)
     @marks.medium
@@ -248,7 +244,6 @@ class TestTransactionWalletSingleDevice(SingleDeviceTestCase):
         wallet_view = sign_in_view.wallet_button.click()
         wallet_view.set_up_wallet()
         status_account_address = wallet_view.get_wallet_address()[2:]
-       # wallet_view.back_button.click()
         self.network_api.get_donate(status_account_address, external_faucet=True)
         wallet_view.wait_balance_is_changed()
         account_name = 'subaccount'
@@ -285,11 +280,10 @@ class TestTransactionWalletSingleDevice(SingleDeviceTestCase):
         sub_account_address = wallet_view.get_wallet_address(account_name)[2:]
         self.network_api.wait_for_confirmation_of_transaction(status_account_address, transaction_amount)
         self.network_api.verify_balance_is_updated(updated_balance, status_account_address)
-        transactions_view = wallet_view.transaction_history_button.click()
+        wallet_view.find_transaction_in_history(amount=transaction_amount)
+        wallet_view.find_transaction_in_history(amount=format(float(transaction_amount_1),'.11f').rstrip('0'))
 
         wallet_view.just_fyi("Check transactions on subaccount")
-        transactions_view.transactions_table.find_transaction(amount=transaction_amount)
-        transactions_view.transactions_table.find_transaction(amount=format(float(transaction_amount_1),'.11f').rstrip('0'))
         self.network_api.verify_balance_is_updated(updated_balance, status_account_address)
 
         wallet_view.just_fyi("Verify total ETH on main wallet view")
@@ -435,9 +429,9 @@ class TestTransactionWalletSingleDevice(SingleDeviceTestCase):
                         self.errors.append(
                             'Expected error %s is not shown' % error)
                 if send_transaction_view.back_button.is_element_displayed():
-                    send_transaction_view.back_button.click()
+                    send_transaction_view.back_button.wait_and_click()
                 else:
-                    wallet_view.cancel_button.click()
+                    wallet_view.cancel_button.wait_and_click()
 
         self.errors.verify_no_errors()
 
diff --git a/test/appium/views/base_element.py b/test/appium/views/base_element.py
index ba9256e525..fd499a74b9 100644
--- a/test/appium/views/base_element.py
+++ b/test/appium/views/base_element.py
@@ -116,6 +116,20 @@ class BaseElement(object):
             raise TimeoutException("Device %s: %s by %s:* `%s`  is still visible on the screen after %s seconds" % (
                 self.driver.number, self.name, self.by, self.locator, seconds)) from None
 
+    def wait_for_element_text(self, text, wait_time=30):
+        counter = 0
+        self.driver.info("*Wait for text element %s to be equal to %s*" % (self.name, text))
+        while True:
+            if counter >= wait_time:
+                self.driver.fail(
+                    "'%s' is not equal to expected '%s' in %s sec" % (self.find_element().text, text, wait_time))
+            elif self.find_element().text != text:
+                counter += 10
+                time.sleep(10)
+            else:
+                self.driver.info('*Element %s text is equal to %s*' % (self.name, text))
+                return
+
     def scroll_to_element(self, depth: int = 9, direction='down'):
         self.driver.info('*Scrolling %s to %s*' % (direction, self.name))
         for _ in range(depth):
@@ -276,19 +290,6 @@ class Text(BaseElement):
         self.driver.info('*%s is %s*' % (self.name, text))
         return text
 
-    def wait_for_element_text(self, text, wait_time=30):
-        counter = 0
-        self.driver.info("*Wait for text element %s to be equal to %s*" % (self.name, text))
-        while True:
-            if counter >= wait_time:
-                self.driver.fail(
-                    "'%s' is not equal to expected '%s' in %s sec" % (self.find_element().text, text, wait_time))
-            elif self.find_element().text != text:
-                counter += 10
-                time.sleep(10)
-            else:
-                self.driver.info('*Element %s text is equal to %s*' % (self.name, text))
-                return
 
 
 class Button(BaseElement):
diff --git a/test/appium/views/chat_view.py b/test/appium/views/chat_view.py
index 9d9741472c..1ded6329a5 100644
--- a/test/appium/views/chat_view.py
+++ b/test/appium/views/chat_view.py
@@ -106,10 +106,6 @@ class ChatElementByText(Text):
             except NoSuchElementException:
                 ChatView(self.driver).reconnect()
 
-    def click_on_text(self):
-        self.locator = "%s/ancestor::android.view.ViewGroup[@content-desc='chat-item']/android.view.ViewGroup" % self.message_locator
-        self.click()
-
     @property
     def image_in_reply(self):
         class ImageInReply(BaseElement):
@@ -148,72 +144,11 @@ class ChatElementByText(Text):
 
         return Username(self.driver, self.locator)
 
-    @property
-    def send_request_button(self):
-        class SendRequestButton(Button):
-            def __init__(self, driver, parent_locator: str):
-                super().__init__(driver, prefix=parent_locator, translation_id="command-button-send")
-
-        self.button = SendRequestButton(self.driver, self.locator)
-        return self.button
-
-    @property
-    def transaction_status(self):
-        class TransactionStatus(Text):
-            def __init__(self, driver, parent_locator: str):
-                super().__init__(driver, prefix=parent_locator, xpath="/*[1]/*[1]/*[5]/android.widget.TextView")
-
-        return TransactionStatus(self.driver, self.locator)
-
     def contains_text(self, text, wait_time=5) -> bool:
         element = Text(self.driver, prefix=self.locator,
                        xpath="//android.view.ViewGroup//android.widget.TextView[contains(@text,'%s')]" % text)
         return element.is_element_displayed(wait_time)
 
-    @property
-    def accept_and_share_address(self):
-        class AcceptAndShareAddress(Button):
-            def __init__(self, driver, parent_locator):
-                super().__init__(driver, prefix=parent_locator, translation_id="accept-and-share-address")
-
-            def navigate(self):
-                from views.send_transaction_view import SendTransactionView
-                return SendTransactionView(self.driver)
-
-            def click(self):
-                self.wait_for_element().click()
-                return self.navigate()
-
-        return AcceptAndShareAddress(self.driver, self.locator)
-
-    @property
-    def decline_transaction(self):
-        class DeclineTransaction(Button):
-            def __init__(self, driver, parent_locator):
-                super().__init__(driver, prefix=parent_locator, translation_id="decline")
-
-            def click(self):
-                self.wait_for_element().click()
-                return self.navigate()
-
-        return DeclineTransaction(self.driver, self.locator)
-
-    @property
-    def sign_and_send(self):
-        class SignAndSend(Button):
-            def __init__(self, driver, parent_locator):
-                super().__init__(driver, prefix=parent_locator, translation_id="sign-and-send")
-
-            def navigate(self):
-                from views.send_transaction_view import SendTransactionView
-                return SendTransactionView(self.driver)
-
-            def click(self):
-                self.wait_for_element().click()
-                return self.navigate()
-
-        return SignAndSend(self.driver, self.locator)
-
     @property
     def replied_message_text(self):
         class RepliedMessageText(Text):
@@ -266,6 +201,7 @@ class UsernameOptions(Button):
         self.wait_for_element().click()
         return self.navigate()
 
+
 class UsernameCheckbox(Button):
     def __init__(self, driver, username):
         self.username = username
@@ -277,6 +213,7 @@ class UsernameCheckbox(Button):
         except NoSuchElementException:
                 self.scroll_to_element(direction='up', depth=20).click()
 
+
 class GroupChatInfoView(BaseView):
     def __init__(self, driver):
         super().__init__(driver)
@@ -292,6 +229,84 @@ class GroupChatInfoView(BaseView):
     def get_user_from_group_info(self, username: str):
         return Text(self.driver, xpath="//*[@text='%s']" % username)
 
+
+class TransactionMessage(ChatElementByText):
+    def __init__(self, driver, text:str):
+        super().__init__(driver, text=text)
+        # Common statuses for incoming and outgoing transactions
+        self.address_requested = self.get_translation_by_key("address-requested")
+        self.confirmed = self.get_translation_by_key("status-confirmed")
+        self.pending = self.get_translation_by_key("pending")
+        self.declined = self.get_translation_by_key("transaction-declined")
+
+    @property
+    def transaction_status(self):
+        class TransactionStatus(SilentButton):
+            def __init__(self, driver, parent_locator: str):
+                super().__init__(driver, prefix=parent_locator, xpath="/*[1]/*[1]/*[5]/android.widget.TextView")
+
+        return TransactionStatus(self.driver, self.locator)
+
+    @property
+    def decline_transaction(self):
+        class DeclineTransaction(Button):
+            def __init__(self, driver, parent_locator):
+                super().__init__(driver, prefix=parent_locator, translation_id="decline")
+
+            def click(self):
+                self.wait_for_element().click()
+                return self.navigate()
+
+        return DeclineTransaction(self.driver, self.locator)
+
+
+class OutgoingTransaction(TransactionMessage):
+    def __init__(self, driver, account_name: str):
+        super().__init__(driver, text="↑ Outgoing transaction")
+        self.account_name = account_name
+        self.address_request_accepted = self.get_translation_by_key("address-request-accepted")
+        self.address_received = self.get_translation_by_key("address-received")
+
+    @property
+    def sign_and_send(self):
+        class SignAndSend(Button):
+            def __init__(self, driver, parent_locator):
+                super().__init__(driver, prefix=parent_locator, translation_id="sign-and-send")
+
+            def navigate(self):
+                from views.send_transaction_view import SendTransactionView
+                return SendTransactionView(self.driver)
+
+            def click(self):
+                self.wait_for_element().click()
+                return self.navigate()
+
+        return SignAndSend(self.driver, self.locator)
+
+
+class IncomingTransaction(TransactionMessage):
+    def __init__(self, driver, account_name: str):
+        super().__init__(driver, text="↓ Incoming transaction")
+        self.account_name = account_name
+        self.shared_account = "Shared '%s'" % account_name
+
+    @property
+    def accept_and_share_address(self):
+        class AcceptAndShareAddress(Button):
+            def __init__(self, driver, parent_locator):
+                super().__init__(driver, prefix=parent_locator, translation_id="accept-and-share-address")
+
+            def navigate(self):
+                from views.send_transaction_view import SendTransactionView
+                return SendTransactionView(self.driver)
+
+            def click(self):
+                self.wait_for_element().click()
+                return self.navigate()
+
+        return AcceptAndShareAddress(self.driver, self.locator)
+
+
 class ChatView(BaseView):
     def __init__(self, driver):
         super().__init__(driver)
@@ -400,6 +415,17 @@ class ChatView(BaseView):
         self.timeline_open_images_panel_button = Button(self.driver, accessibility_id="open-images-panel-button")
         self.timeline_send_my_status_button = Button(self.driver, accessibility_id="send-my-status-button")
 
+    def get_outgoing_transaction(self, account=None):
+        if account is None:
+            account = self.status_account_name
+        return OutgoingTransaction(self.driver, account)
+
+    def get_incoming_transaction(self, account=None):
+        if account is None:
+            account = self.status_account_name
+        return IncomingTransaction(self.driver, account)
+
+
     def delete_chat(self):
         self.driver.info("**Delete chat via options**")
         self.chat_options.click()
@@ -616,6 +642,10 @@ class ChatView(BaseView):
     def invite_system_message(admin, invited_user):
         return '%s has invited %s' % (admin, invited_user)
 
+    @staticmethod
+    def invited_to_join_system_message(username, chat_name):
+        return '%s invited you to join the group %s' % (username, chat_name)
+
     @staticmethod
     def join_system_message(username):
         return '%s joined the group' % username
diff --git a/test/appium/views/home_view.py b/test/appium/views/home_view.py
index 39a0c6d6f3..13d9739b90 100644
--- a/test/appium/views/home_view.py
+++ b/test/appium/views/home_view.py
@@ -86,6 +86,7 @@ class HomeView(BaseView):
 
     def get_chat(self, username):
         self.driver.info("**Looking for chat '%s'**" % username)
+        ChatElement(self.driver, username[:25]).wait_for_element(30)
         return ChatElement(self.driver, username[:25])
 
     def get_username_below_start_new_chat_button(self, username_part):
@@ -94,11 +95,11 @@ class HomeView(BaseView):
     def add_contact(self, public_key, add_in_contacts=True, nickname=''):
         self.driver.info("**Starting 1-1 chat, add in contacts:%s**" % str(add_in_contacts))
         self.plus_button.click_until_presence_of_element(self.start_new_chat_button)
-        contacts_view = self.start_new_chat_button.click()
-        contacts_view.public_key_edit_box.click()
-        contacts_view.public_key_edit_box.send_keys(public_key)
+        chat = self.start_new_chat_button.click()
+        chat.public_key_edit_box.click()
+        chat.public_key_edit_box.send_keys(public_key)
         one_to_one_chat = self.get_chat_view()
-        contacts_view.confirm_until_presence_of_element(one_to_one_chat.chat_message_input)
+        chat.confirm_until_presence_of_element(one_to_one_chat.chat_message_input)
         if add_in_contacts:
             one_to_one_chat.add_to_contacts.click()
         if nickname:
diff --git a/test/appium/views/send_transaction_view.py b/test/appium/views/send_transaction_view.py
index 8ebce5d085..bf187a5ae5 100644
--- a/test/appium/views/send_transaction_view.py
+++ b/test/appium/views/send_transaction_view.py
@@ -135,7 +135,7 @@ class SendTransactionView(BaseView):
         self.done_button.click_until_absense_of_element(self.done_button)
 
     def sign_transaction(self, sender_password: str = common_password, keycard=False, default_gas_price=True):
-        self.driver.info("**Signing transaction (keycard:%s, default_gas_price:%s)" % (str(keycard), str(default_gas_price)))
+        self.driver.info("**Signing transaction (keycard:%s, default_gas_price:%s)**" % (str(keycard), str(default_gas_price)))
         if not default_gas_price:
             self.network_fee_button.click()
             default_gas_price = self.gas_price_input.text
@@ -152,11 +152,11 @@ class SendTransactionView(BaseView):
         self.ok_button.wait_for_element(120)
         if self.element_by_text_part('Transaction failed').is_element_displayed():
             self.driver.fail('Transaction failed')
-        self.driver.info("**Transaction is signed!")
+        self.driver.info("**Transaction is signed!**")
         self.ok_button.click()
 
     def get_transaction_fee_total(self):
-        self.driver.info("**Getting transaction fee")
+        self.driver.info("**Getting transaction fee**")
         self.network_fee_button.click_until_presence_of_element(self.gas_limit_input)
         fee_value = self.transaction_fee_total_value.text.split()[0]
         self.update_fee_button.click()
@@ -167,18 +167,18 @@ class SendTransactionView(BaseView):
         return address[:6] + '…' + address[-4:]
 
     def get_username_in_transaction_bottom_sheet_button(self, username_part):
-        self.driver.info("**Getting username by '%s' in transaction fee bottom sheet" % username_part)
+        self.driver.info("**Getting username by '%s' in transaction fee bottom sheet**" % username_part)
         return SilentButton(self.driver, xpath="//*[@content-desc='amount-input']/..//*[starts-with(@text,'%s')]" % username_part)
 
     def get_account_in_select_account_bottom_sheet_button(self, account_name):
-        self.driver.info("**Getting account by '%s' in transaction fee bottom sheet" % account_name)
+        self.driver.info("**Getting account by '%s' in transaction fee bottom sheet**" % account_name)
         return SilentButton(self.driver, translation_id="select-account", suffix="/..//*[starts-with(@text,'%s')]" % account_name)
 
     def get_validation_icon(self, field='Network fee'):
         return ValidationErrorOnSendTransaction(self.driver, field)
 
     def get_values_from_send_transaction_bottom_sheet(self, gas=False):
-        self.driver.info("**Getting values from send transaction bottom sheet")
+        self.driver.info("**Getting values from send transaction bottom sheet**")
         data = {
             'amount': self.amount_edit_box.text,
             'asset': self.asset_text.text,
@@ -193,7 +193,7 @@ class SendTransactionView(BaseView):
         return data
 
     def add_to_favorites(self, name):
-        self.driver.info("**Adding '%s' to favorite recipients" % name)
+        self.driver.info("**Adding '%s' to favorite recipients**" % name)
         self.recipient_add_to_favorites.click()
         self.new_favorite_name_input.set_value(name)
         self.new_favorite_add_favorite.click()
\ No newline at end of file
diff --git a/test/appium/views/transactions_view.py b/test/appium/views/transactions_view.py
index 0e2b6a0370..29a96ec8a8 100644
--- a/test/appium/views/transactions_view.py
+++ b/test/appium/views/transactions_view.py
@@ -84,7 +84,6 @@ class TransactionTable(BaseElement):
         return self.TransactionElement.by_amount(self.driver, amount=amount.replace(',', '.'), asset=asset)
 
     def find_transaction(self, amount: str, asset='ETH') -> TransactionElement:
-        self.driver.info('**Finding %s %s transaction**' % (amount, asset))
         element = self.transaction_by_amount(amount=amount, asset=asset)
         for i in range(9):
             try:
diff --git a/test/appium/views/wallet_view.py b/test/appium/views/wallet_view.py
index 960afa1d8a..033bf7d753 100644
--- a/test/appium/views/wallet_view.py
+++ b/test/appium/views/wallet_view.py
@@ -160,14 +160,15 @@ class WalletView(BaseView):
         counter = 0
         while True:
             if counter >= wait_time:
-                self.driver.fail('Balance is not changed during %s seconds!' % wait_time)
+                self.driver.fail('Balance %s %s is not changed during %s seconds!' % (asset, initial_balance,wait_time))
             elif self.asset_by_name(asset).is_element_present() and self.get_asset_amount_by_name(asset) == initial_balance:
                 if not self.transaction_history_button.is_element_displayed():
                     self.wallet_account_by_name(self.status_account_name).click()
-                self.swipe_up()
+                if (counter/60).is_integer():
+                    self.driver.swipe(500, 500, 500, 1000)
+                    self.driver.info("*Refreshing transaction history*")
                 counter += 10
                 time.sleep(10)
-                [self.wallet_button.click() for _ in range(2)]
                 self.driver.info('*Waiting %ss for %s updated balance*' % (counter,asset))
             elif not self.asset_by_name(asset).is_element_present(10):
                 counter += 10
@@ -178,7 +179,7 @@ class WalletView(BaseView):
                 self.driver.info('*Waiting %s seconds for %s to display asset*' % (counter, asset))
             else:
                 self.driver.info('**Balance is updated!**')
-                self.accounts_status_account.scroll_to_element(direction='up')
+                self.wallet_button.double_click()
                 return self
 
     def get_sign_in_phrase(self):
@@ -283,6 +284,16 @@ class WalletView(BaseView):
                                                    sender_password=kwargs.get('sender_password', common_password))
         return send_transaction_view
 
+    def find_transaction_in_history(self, amount, asset='ETH', account_name=None):
+        if account_name == None:
+            account_name = self.status_account_name
+        self.driver.info('**Finding %s %s transaction for %s**' % (amount, asset, account_name))
+        if not self.transaction_history_button.is_element_displayed():
+            self.get_account_by_name(account_name).click()
+            self.transaction_history_button.wait_for_element()
+        transactions_view = self.transaction_history_button.click()
+        return transactions_view.transactions_table.find_transaction(amount=amount, asset=asset)
+
     def set_currency(self, desired_currency='EUR'):
         self.driver.info("**Setting '%s' currency**" % desired_currency)
         self.multiaccount_more_options.click_until_presence_of_element(self.set_currency_button)