feat(core): misc features add (OneKeyHQ#286)

1. the passphrase input on device supports edit before commit.
2. mnemonics support edits if make mistake in input process
3. fingerprint unlock error tips in pin input screen

Author: somebodyLi

core/src/apps/common/passphrase.py

@@ -64,7 +64,8 @@ async def _request_on_host(ctx: wire.Context) -> str:
     if ack.passphrase:
         from trezor.ui.layouts import require_confirm_passphrase
 
-        await require_confirm_passphrase(ctx, ack.passphrase)
+        if not await require_confirm_passphrase(ctx, ack.passphrase):
+            raise wire.ActionCancelled("Passphrase cancelled")
 
     return ack.passphrase
 

core/src/apps/common/signverify.py

@@ -1,3 +1,4 @@
+import gc
 from typing import TYPE_CHECKING
 from ubinascii import hexlify
 
@@ -32,10 +33,22 @@ def is_non_printable(message: str) -> bool:
 
 
 def decode_message(message: bytes) -> str:
+    message_len = len(message)
+
+    def to_hex(message: bytes) -> str:
+        hex_message = hexlify(message).decode()
+        if message_len > 1024:
+            return hex_message
+        else:
+            return "0x" + hex_message
+
     try:
-        decoded_message = bytes(message).decode()
+        if message_len > 1024:
+            gc.collect()
+        decoded_message = message.decode()
         if is_non_printable(decoded_message):
-            return f"0x{hexlify(message).decode()}"
+            return to_hex(message)
         return decoded_message
     except UnicodeError:
-        return f"0x{hexlify(message).decode()}"
+        gc.collect()
+        return to_hex(message)

core/src/apps/management/recovery_device/homescreen.py

@@ -10,6 +10,7 @@
 from trezor.lvglui.i18n import gettext as _, keys as i18n_keys
 from trezor.messages import Success
 from trezor.ui.layouts import show_onekey_app_guide, show_popup, show_success
+from trezor.ui.layouts.lvgl.recovery import request_word
 
 from apps.base import set_homescreen
 from apps.common import mnemonic
@@ -104,24 +105,26 @@ async def _continue_recovery_process(
         await _request_share_first_screen(ctx, word_count)
 
     secret = None
+    words = None
     while secret is None:
-        if is_first_step:
-            # If we are starting recovery, ask for word count first...
-            if not word_count:
-                word_count = await _request_word_count(ctx, dry_run)
-            # ...and only then show the starting screen with word count.
-            await _request_share_first_screen(ctx, word_count)
-        assert word_count is not None
-
-        # ask for mnemonic words one by one
-        try:
-            words = await layout.request_mnemonic(ctx, word_count, backup_type)
-        except wire.ActionCancelled:
-            continue
-
-        # if they were invalid or some checks failed we continue and request them again
         if not words:
-            continue
+            if is_first_step:
+                # If we are starting recovery, ask for word count first...
+                if not word_count:
+                    word_count = await _request_word_count(ctx, dry_run)
+                # ...and only then show the starting screen with word count.
+                await _request_share_first_screen(ctx, word_count)
+            assert word_count is not None
+
+            # ask for mnemonic words one by one
+            try:
+                words = await layout.request_mnemonic(ctx, word_count, backup_type)
+            except wire.ActionCancelled:
+                continue
+
+            # if they were invalid or some checks failed we continue and request them again
+            if not words:
+                continue
 
         try:
             secret, backup_type = await _process_words(ctx, words)
@@ -130,7 +133,27 @@ async def _continue_recovery_process(
             # that the first step is complete.
             is_first_step = False
         except MnemonicError:
-            await layout.show_invalid_mnemonic(ctx, word_count)
+            words_list = words.split(" ")
+            while True:
+                result = await layout.show_invalid_mnemonic(ctx, words_list)
+                if result is not None:
+                    assert word_count is not None
+                    try:
+                        word = await request_word(
+                            ctx,
+                            result,
+                            word_count,
+                            is_slip39=backup_types.is_slip39_word_count(word_count),
+                        )
+                    except wire.ActionCancelled:
+                        continue
+                    else:
+                        words_list[result] = word
+                        words = " ".join(words_list)
+                        break
+                else:
+                    words = None
+                    break
 
     assert backup_type is not None
     if dry_run:

core/src/apps/management/recovery_device/layout.py

@@ -153,18 +153,17 @@ async def show_dry_run_different_type(ctx: wire.GenericContext) -> None:
     )
 
 
-async def show_invalid_mnemonic(ctx: wire.GenericContext, word_count: int) -> None:
-    if backup_types.is_slip39_word_count(word_count):
+async def show_invalid_mnemonic(
+    ctx: wire.GenericContext, mnemonics: list[str]
+) -> None | int:
+    if backup_types.is_slip39_word_count(len(mnemonics)):
         pass
     else:
-        await show_warning(
-            ctx,
-            "warning_invalid_seed",
-            _(i18n_keys.SUBTITLE__DEVICE_RECOVER_INVALID_RECOVERY_PHRASE),
-            header=_(i18n_keys.TITLE__INVALID_RECOVERY_PHRASE),
-            icon="A:/res/danger.png",
-            btn_yes_bg_color=lv_colors.ONEKEY_BLACK,
-        )
+        from trezor.lvglui.scrs.recovery_device import InvalidMnemonic
+
+        screen = InvalidMnemonic(mnemonics)
+
+        return await ctx.wait(screen.request())
 
 
 async def show_share_already_added(ctx: wire.GenericContext) -> None:

core/src/apps/neo/get_address.py

@@ -33,7 +33,7 @@ async def get_address(
             ctx,
             address=address,
             address_n=path,
-            network="Neo",
+            network="Neo N3",
         )
 
     return NeoAddress(address=address, public_key=pub_key_bytes)

core/src/apps/neo/helpers.py

@@ -45,7 +45,7 @@ def make_digest(raw_tx: bytes, network_magic: int = NETWORK_MAINNET) -> bytes:
 
 def retrieve_network(network_magic: int) -> tuple[str, bool]:
     if is_mainnet(network_magic):
-        return "Neo", True
+        return "Neo N3", True
     elif is_testnet(network_magic):
         return "Neo Testnet", True
     else:

core/src/apps/sui/sign_message.py

@@ -24,14 +24,13 @@ async def sign_message(
     address = sui_address_from_pubkey(pub_key_bytes)
 
     len_bytes = uleb_encode(len(msg.message))
-    intentMessage = PERSONALMESSAGE_INTENT_BYTES + len_bytes + msg.message
-
+    hasher = blake2b(outlen=32)
+    hasher.update(PERSONALMESSAGE_INTENT_BYTES)
+    hasher.update(len_bytes)
+    hasher.update(msg.message)
     from trezor.ui.layouts import confirm_signverify
 
     ctx.primary_color, ctx.icon_path = lv.color_hex(PRIMARY_COLOR), ICON
     await confirm_signverify(ctx, "Sui", decode_message(msg.message), address, False)
-
-    signature = ed25519.sign(
-        node.private_key(), blake2b(data=intentMessage, outlen=32).digest()
-    )
+    signature = ed25519.sign(node.private_key(), hasher.digest())
     return SuiMessageSignature(signature=signature, address=address)

core/src/apps/sui/sign_tx.py

@@ -1,3 +1,5 @@
+import gc
+
 from trezor import wire
 from trezor.crypto.curve import ed25519
 from trezor.crypto.hashlib import blake2b
@@ -30,7 +32,7 @@ async def sign_tx(ctx: wire.Context, msg: SuiSignTx, keychain: Keychain) -> SuiS
 
         data_total = msg.data_length
         data = bytearray()
-        data += msg.data_initial_chunk
+        data.extend(msg.data_initial_chunk)
         data_left = data_total - len(msg.data_initial_chunk)
 
         hash_fn = blake2b(outlen=32)
@@ -39,10 +41,10 @@ async def sign_tx(ctx: wire.Context, msg: SuiSignTx, keychain: Keychain) -> SuiS
             resp = await send_request_chunk(ctx, data_left)
             data_left -= len(resp.data_chunk)
             hash_fn.update(resp.data_chunk)
-            data += resp.data_chunk
+            data.extend(resp.data_chunk)
 
         hash = hash_fn.digest()
-        await confirm_blind_sign_common(ctx, address, bytes(data))
+        await confirm_blind_sign_common(ctx, address, data)
     else:
         intent = msg.raw_tx[:3]
         if INTENT_BYTES != intent:
@@ -57,6 +59,8 @@ async def sign_tx(ctx: wire.Context, msg: SuiSignTx, keychain: Keychain) -> SuiS
 
 
 async def send_request_chunk(ctx: wire.Context, data_left: int) -> SuiTxAck:
+    gc.collect()
+
     req = SuiTxRequest()
     if data_left <= 1024:
         req.data_length = data_left

core/src/trezor/lvglui/scrs/address.py

@@ -318,7 +318,7 @@
         {
             "msg_type": MessageType.NeoGetAddress,
             "symbol": " NEO",
-            "name": "Neo",
+            "name": "Neo N3",
             "msg_class": "NeoGetAddress",
             "index_pos": -1,
             "base_path": [0x80000000 + 44, 0x80000000 + 888, 0x80000000 + 0, 0, 0],

core/src/trezor/lvglui/scrs/components/button.py

@@ -70,6 +70,15 @@ def enable(
         self.add_style(StyleWrapper().bg_color(bg_color).text_color(text_color), 0)
         self.add_flag(lv.btn.FLAG.CLICKABLE)
 
+    def enable_no_bg_mode(self):
+        self.add_style(StyleWrapper().bg_color(lv_colors.BLACK), 0)
+        self.add_style(
+            StyleWrapper().bg_color(lv_colors.ONEKEY_BLACK).bg_opa(),
+            lv.PART.MAIN | lv.STATE.PRESSED,
+        )
+        self.clear_flag(lv.obj.FLAG.CLICKABLE)
+        self.click_mask.add_flag(lv.obj.FLAG.CLICKABLE)
+
 
 class ListItemBtn(lv.btn):
     def __init__(