feat(core): update number input screen

- add time-handling functions
- add option to show time units
- add hold functionality to increment/decrement buttons
- add new device-menu actions

core/embed/rust/librust_qstr.h

@@ -94,8 +94,10 @@ static void _librust_qstrs(void) {
   MP_QSTR_authenticate__confirm_template;
   MP_QSTR_authenticate__header;
   MP_QSTR_auto_lock__change_template;
+  MP_QSTR_auto_lock__description;
   MP_QSTR_auto_lock__title;
   MP_QSTR_auto_lock__turned_on;
+  MP_QSTR_auto_lock_delay;
   MP_QSTR_backlight_fade;
   MP_QSTR_backlight_set;
   MP_QSTR_backup__can_back_up_anytime;
@@ -248,6 +250,7 @@ static void _librust_qstrs(void) {
   MP_QSTR_device_name__title;
   MP_QSTR_disable_animation;
   MP_QSTR_disconnect;
+  MP_QSTR_duration_ms;
   MP_QSTR_encode;
   MP_QSTR_encoded_length;
   MP_QSTR_entropy__send;
@@ -352,10 +355,12 @@ static void _librust_qstrs(void) {
   MP_QSTR_max_count;
   MP_QSTR_max_feerate;
   MP_QSTR_max_len;
+  MP_QSTR_max_ms;
   MP_QSTR_max_rounds;
   MP_QSTR_menu_title;
   MP_QSTR_message;
   MP_QSTR_min_count;
+  MP_QSTR_min_ms;
   MP_QSTR_misc__decrypt_value;
   MP_QSTR_misc__enable_labeling;
   MP_QSTR_misc__encrypt_value;
@@ -428,6 +433,7 @@ static void _librust_qstrs(void) {
   MP_QSTR_pin__turn_on;
   MP_QSTR_pin__wrong_pin;
   MP_QSTR_plurals__contains_x_keys;
+  MP_QSTR_plurals__lock_after_x_days;
   MP_QSTR_plurals__lock_after_x_hours;
   MP_QSTR_plurals__lock_after_x_milliseconds;
   MP_QSTR_plurals__lock_after_x_minutes;
@@ -513,6 +519,7 @@ static void _librust_qstrs(void) {
   MP_QSTR_remaining_shares;
   MP_QSTR_request_bip39;
   MP_QSTR_request_complete_repaint;
+  MP_QSTR_request_duration;
   MP_QSTR_request_number;
   MP_QSTR_request_passphrase;
   MP_QSTR_request_pin;

core/embed/rust/src/time.rs

@@ -6,6 +6,9 @@ use core::{
 use crate::trezorhal::time;
 
 const MILLIS_PER_SEC: u32 = 1000;
+const MILLIS_PER_MINUTE: u32 = MILLIS_PER_SEC * 60;
+const MILLIS_PER_HOUR: u32 = MILLIS_PER_MINUTE * 60;
+const MILLIS_PER_DAY: u32 = MILLIS_PER_HOUR * 24;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
 pub struct Duration {
@@ -20,15 +23,45 @@ impl Duration {
     }
 
     pub const fn from_secs(secs: u32) -> Self {
-        Self {
-            millis: secs * MILLIS_PER_SEC,
-        }
+        // Check for potential overflow
+        debug_assert!(secs < u32::MAX / MILLIS_PER_SEC);
+        Self::from_millis(secs * MILLIS_PER_SEC)
+    }
+
+    pub const fn from_mins(mins: u32) -> Self {
+        // Check for potential overflow
+        debug_assert!(mins < u32::MAX / MILLIS_PER_MINUTE);
+        Self::from_millis(mins * MILLIS_PER_MINUTE)
+    }
+
+    pub const fn from_hours(hours: u32) -> Self {
+        // Check for potential overflow
+        debug_assert!(hours < u32::MAX / MILLIS_PER_HOUR);
+        Self::from_millis(hours * MILLIS_PER_HOUR)
+    }
+    pub const fn from_days(days: u32) -> Self {
+        // Check for potential overflow
+        debug_assert!(days < u32::MAX / MILLIS_PER_DAY);
+        Self::from_millis(days * MILLIS_PER_DAY)
     }
 
     pub fn to_millis(self) -> u32 {
         self.millis
     }
 
+    pub fn to_secs(self) -> u32 {
+        self.millis / MILLIS_PER_SEC
+    }
+    pub fn to_mins(self) -> u32 {
+        self.millis / MILLIS_PER_MINUTE
+    }
+    pub fn to_hours(self) -> u32 {
+        self.millis / MILLIS_PER_HOUR
+    }
+    pub fn to_days(self) -> u32 {
+        self.millis / MILLIS_PER_DAY
+    }
+
     pub fn checked_add(self, rhs: Self) -> Option<Self> {
         self.millis.checked_add(rhs.millis).map(Self::from_millis)
     }
@@ -36,6 +69,74 @@ impl Duration {
     pub fn checked_sub(self, rhs: Self) -> Option<Self> {
         self.millis.checked_sub(rhs.millis).map(Self::from_millis)
     }
+
+    /// Returns a new Duration containing only the largest complete time unit
+    /// (days, hours, minutes, or seconds)
+    ///
+    /// Examples:
+    /// - 1 day, 3 hours → 1 day
+    /// - 3 hours, 45 minutes → 3 hours
+    /// - 59 seconds → 59 seconds
+    pub fn crop_to_largest_unit(self) -> Self {
+        if self.millis >= MILLIS_PER_DAY {
+            Duration::from_days(self.to_days())
+        } else if self.millis >= MILLIS_PER_HOUR {
+            Duration::from_hours(self.to_hours())
+        } else if self.millis >= MILLIS_PER_MINUTE {
+            Duration::from_mins(self.to_mins())
+        } else {
+            Duration::from_secs(self.to_secs())
+        }
+    }
+
+    /// Increment by one unit based on the current magnitude
+    ///
+    /// Examples:
+    /// - 59s → 1m (moves to the next unit when crossing a boundary)
+    /// - 1m → 2m
+    /// - 23h → 1d
+    ///
+    /// Returns None if addition would overflow
+    pub fn increment_unit(self) -> Option<Self> {
+        let base = self.crop_to_largest_unit();
+
+        let step = if base.millis < MILLIS_PER_MINUTE {
+            Duration::from_secs(1)
+        } else if base.millis < MILLIS_PER_HOUR {
+            Duration::from_mins(1)
+        } else if base.millis < MILLIS_PER_DAY {
+            Duration::from_hours(1)
+        } else {
+            Duration::from_days(1)
+        };
+
+        base.checked_add(step)
+    }
+
+    /// Decrement by one unit based on the current magnitude
+    ///
+    /// Examples:
+    /// - 1m → 59s (moves to the previous unit at boundaries)
+    /// - 2m → 1m
+    /// - 1h → 59m
+    /// - 1d → 23h
+    ///
+    /// Returns None if subtraction would result in negative duration
+    pub fn decrement_unit(self) -> Option<Self> {
+        let base = self.crop_to_largest_unit();
+
+        let step = if base.millis <= MILLIS_PER_MINUTE {
+            Duration::from_secs(1)
+        } else if base.millis <= MILLIS_PER_HOUR {
+            Duration::from_mins(1)
+        } else if base.millis <= MILLIS_PER_DAY {
+            Duration::from_hours(1)
+        } else {
+            Duration::from_days(1)
+        };
+
+        base.checked_sub(step)
+    }
 }
 
 impl Mul<f32> for Duration {
@@ -280,4 +381,67 @@ mod tests {
         assert!(!sw.is_running_within(Duration::from_millis(5)));
         assert!(!sw.is_running_within(Duration::from_millis(10000)));
     }
+
+    #[test]
+    fn test_crop_to_largest_unit() {
+        assert_eq!(
+            Duration::from_secs(59).crop_to_largest_unit(),
+            Duration::from_secs(59)
+        );
+        assert_eq!(
+            Duration::from_secs(60).crop_to_largest_unit(),
+            Duration::from_mins(1)
+        );
+        assert_eq!(
+            Duration::from_secs(61).crop_to_largest_unit(),
+            Duration::from_mins(1)
+        );
+        assert_eq!(
+            Duration::from_secs(3600).crop_to_largest_unit(),
+            Duration::from_hours(1)
+        );
+        assert_eq!(
+            Duration::from_secs(86399).crop_to_largest_unit(),
+            Duration::from_hours(23)
+        );
+    }
+
+    #[test]
+    fn test_increment_decrement_unit() {
+        // Increment
+        assert_eq!(
+            unwrap!(Duration::from_secs(59).increment_unit()),
+            Duration::from_mins(1)
+        );
+        assert_eq!(
+            unwrap!(Duration::from_mins(1).increment_unit()),
+            Duration::from_mins(2)
+        );
+        assert_eq!(
+            unwrap!(Duration::from_secs(61).increment_unit()),
+            Duration::from_mins(2)
+        );
+        assert_eq!(
+            unwrap!(Duration::from_days(3).increment_unit()),
+            Duration::from_days(4)
+        );
+
+        // Decrement
+        assert_eq!(
+            unwrap!(Duration::from_mins(1).decrement_unit()),
+            Duration::from_secs(59)
+        );
+        assert_eq!(
+            unwrap!(Duration::from_secs(61).decrement_unit()),
+            Duration::from_secs(59)
+        );
+        assert_eq!(
+            unwrap!(Duration::from_mins(3).decrement_unit()),
+            Duration::from_mins(2)
+        );
+        assert_eq!(
+            unwrap!(Duration::from_hours(1).decrement_unit()),
+            Duration::from_mins(59)
+        );
+    }
 }

core/embed/rust/src/translations/generated/translated_string.rs

@@ -27,7 +27,7 @@ pub enum TranslatedString {
     authenticate__confirm_template = 13,  // "Allow connected computer to confirm your {0} is genuine?"
     authenticate__header = 14,  // "Authenticate device"
     auto_lock__change_template = 15,  // "Auto-lock Trezor after {0} of inactivity?"
-    auto_lock__title = 16,  // "Auto-lock delay"
+    auto_lock__title = 16,  // {"Bolt": "Auto-lock delay", "Caesar": "Auto-lock delay", "Delizia": "Auto-lock delay", "Eckhart": "Auto-lock"}
     backup__can_back_up_anytime = 17,  // "You can back up your Trezor once, at any time."
     backup__it_should_be_backed_up = 18,  // {"Bolt": "You should back up your new wallet right now.", "Caesar": "You should back up your new wallet right now.", "Delizia": "You should back up your new wallet right now.", "Eckhart": "Back up your new wallet now."}
     backup__it_should_be_backed_up_now = 19,  // "It should be backed up now!"
@@ -1438,7 +1438,14 @@ impl TranslatedString {
             (Self::authenticate__confirm_template, "Allow connected computer to confirm your {0} is genuine?"),
             (Self::authenticate__header, "Authenticate device"),
             (Self::auto_lock__change_template, "Auto-lock Trezor after {0} of inactivity?"),
+            #[cfg(feature = "layout_bolt")]
             (Self::auto_lock__title, "Auto-lock delay"),
+            #[cfg(feature = "layout_caesar")]
+            (Self::auto_lock__title, "Auto-lock delay"),
+            #[cfg(feature = "layout_delizia")]
+            (Self::auto_lock__title, "Auto-lock delay"),
+            #[cfg(feature = "layout_eckhart")]
+            (Self::auto_lock__title, "Auto-lock"),
             (Self::backup__can_back_up_anytime, "You can back up your Trezor once, at any time."),
             (Self::backup__it_should_be_backed_up, "You should back up your new wallet right now."),
             (Self::backup__it_should_be_backed_up_now, "It should be backed up now!"),
@@ -2856,6 +2863,7 @@ impl TranslatedString {
         (Qstr::MP_QSTR_authenticate__confirm_template, Self::authenticate__confirm_template),
         (Qstr::MP_QSTR_authenticate__header, Self::authenticate__header),
         (Qstr::MP_QSTR_auto_lock__change_template, Self::auto_lock__change_template),
+        (Qstr::MP_QSTR_auto_lock__description, Self::auto_lock__description),
         (Qstr::MP_QSTR_auto_lock__title, Self::auto_lock__title),
         (Qstr::MP_QSTR_auto_lock__turned_on, Self::auto_lock__turned_on),
         (Qstr::MP_QSTR_backup__can_back_up_anytime, Self::backup__can_back_up_anytime),
@@ -3674,6 +3682,7 @@ impl TranslatedString {
         (Qstr::MP_QSTR_pin__turn_on, Self::pin__turn_on),
         (Qstr::MP_QSTR_pin__wrong_pin, Self::pin__wrong_pin),
         (Qstr::MP_QSTR_plurals__contains_x_keys, Self::plurals__contains_x_keys),
+        (Qstr::MP_QSTR_plurals__lock_after_x_days, Self::plurals__lock_after_x_days),
         (Qstr::MP_QSTR_plurals__lock_after_x_hours, Self::plurals__lock_after_x_hours),
         (Qstr::MP_QSTR_plurals__lock_after_x_milliseconds, Self::plurals__lock_after_x_milliseconds),
         (Qstr::MP_QSTR_plurals__lock_after_x_minutes, Self::plurals__lock_after_x_minutes),

core/embed/rust/src/ui/api/firmware_micropython.rs

@@ -653,6 +653,23 @@ extern "C" fn new_request_number(n_args: usize, args: *const Obj, kwargs: *mut M
     unsafe { util::try_with_args_and_kwargs(n_args, args, kwargs, block) }
 }
 
+extern "C" fn new_request_duration(n_args: usize, args: *const Obj, kwargs: *mut Map) -> Obj {
+    let block = move |_args: &[Obj], kwargs: &Map| {
+        let title: TString = kwargs.get(Qstr::MP_QSTR_title)?.try_into()?;
+        let duration_ms: u32 = kwargs.get(Qstr::MP_QSTR_duration_ms)?.try_into()?;
+        let min_ms: u32 = kwargs.get(Qstr::MP_QSTR_min_ms)?.try_into()?;
+        let max_ms: u32 = kwargs.get(Qstr::MP_QSTR_max_ms)?.try_into()?;
+        let description: Option<TString> = kwargs
+            .get(Qstr::MP_QSTR_description)
+            .unwrap_or_else(|_| Obj::const_none())
+            .try_into_option()?;
+
+        let layout = ModelUI::request_duration(title, duration_ms, min_ms, max_ms, description)?;
+        Ok(LayoutObj::new_root(layout)?.into())
+    };
+    unsafe { util::try_with_args_and_kwargs(n_args, args, kwargs, block) }
+}
+
 extern "C" fn new_request_pin(n_args: usize, args: *const Obj, kwargs: *mut Map) -> Obj {
     let block = move |_args: &[Obj], kwargs: &Map| {
         let prompt: TString = kwargs.get(Qstr::MP_QSTR_prompt)?.try_into()?;
@@ -828,12 +845,15 @@ extern "C" fn new_show_device_menu(n_args: usize, args: *const Obj, kwargs: *mut
         let device_name: TString = kwargs.get(Qstr::MP_QSTR_device_name)?.try_into()?;
         let paired_devices: Obj = kwargs.get(Qstr::MP_QSTR_paired_devices)?;
         let paired_devices: Vec<TString, 1> = util::iter_into_vec(paired_devices)?;
+        let auto_lock_delay: TString<'static> =
+            kwargs.get(Qstr::MP_QSTR_auto_lock_delay)?.try_into()?;
         let layout = ModelUI::show_device_menu(
             failed_backup,
             battery_percentage,
             firmware_version,
             device_name,
             paired_devices,
+            auto_lock_delay,
         )?;
         let layout_obj = LayoutObj::new_root(layout)?;
         Ok(layout_obj.into())
@@ -1522,6 +1542,17 @@ pub static mp_module_trezorui_api: Module = obj_module! {
     ///     description."""
     Qstr::MP_QSTR_request_number => obj_fn_kw!(0, new_request_number).as_obj(),
 
+    /// def request_duration(
+    ///     *,
+    ///     title: str,
+    ///     duration_ms: int,
+    ///     min_ms: int,
+    ///     max_ms: int,
+    ///     description: str | None = None,
+    /// ) -> LayoutObj[tuple[UiResult, int]]:
+    ///     """Duration input with + and - buttons, optional static description. """
+    Qstr::MP_QSTR_request_duration => obj_fn_kw!(0, new_request_duration).as_obj(),
+
     /// def request_pin(
     ///     *,
     ///     prompt: str,
@@ -1633,6 +1664,7 @@ pub static mp_module_trezorui_api: Module = obj_module! {
     ///     firmware_version: str,
     ///     device_name: str,
     ///     paired_devices: Iterable[str],
+    ///     auto_lock_delay: str,
     /// ) -> LayoutObj[UiResult]:
     ///     """Show the device menu."""
     Qstr::MP_QSTR_show_device_menu => obj_fn_kw!(0, new_show_device_menu).as_obj(),

core/embed/rust/src/ui/layout_bolt/ui_firmware.rs

@@ -666,6 +666,16 @@ impl FirmwareUI for UIBolt {
         Ok(layout)
     }
 
+    fn request_duration(
+        _title: TString<'static>,
+        _duration_ms: u32,
+        _min_ms: u32,
+        _max_ms: u32,
+        _description: Option<TString<'static>>,
+    ) -> Result<impl LayoutMaybeTrace, Error> {
+        Err::<RootComponent<Empty, ModelUI>, Error>(ERROR_NOT_IMPLEMENTED)
+    }
+
     fn request_pin(
         prompt: TString<'static>,
         subprompt: TString<'static>,
@@ -874,6 +884,7 @@ impl FirmwareUI for UIBolt {
         _firmware_version: TString<'static>,
         _device_name: TString<'static>,
         _paired_devices: heapless::Vec<TString<'static>, 1>,
+        _auto_lock_delay: TString<'static>,
     ) -> Result<impl LayoutMaybeTrace, Error> {
         Err::<RootComponent<Empty, ModelUI>, Error>(Error::ValueError(
             c"show_device_menu not supported",

core/embed/rust/src/ui/layout_caesar/ui_firmware.rs

@@ -872,6 +872,16 @@ impl FirmwareUI for UICaesar {
         Ok(layout)
     }
 
+    fn request_duration(
+        _title: TString<'static>,
+        _duration_ms: u32,
+        _min_ms: u32,
+        _max_ms: u32,
+        _description: Option<TString<'static>>,
+    ) -> Result<impl LayoutMaybeTrace, Error> {
+        Err::<RootComponent<Empty, ModelUI>, Error>(ERROR_NOT_IMPLEMENTED)
+    }
+
     fn request_pin(
         prompt: TString<'static>,
         subprompt: TString<'static>,
@@ -1067,6 +1077,7 @@ impl FirmwareUI for UICaesar {
         _firmware_version: TString<'static>,
         _device_name: TString<'static>,
         _paired_devices: Vec<TString<'static>, 1>,
+        _auto_lock_delay: TString<'static>,
     ) -> Result<impl LayoutMaybeTrace, Error> {
         Err::<RootComponent<Empty, ModelUI>, Error>(Error::ValueError(
             c"show_device_menu not supported",

core/embed/rust/src/ui/layout_delizia/ui_firmware.rs

@@ -720,6 +720,16 @@ impl FirmwareUI for UIDelizia {
         Ok(flow)
     }
 
+    fn request_duration(
+        _title: TString<'static>,
+        _duration_ms: u32,
+        _min_ms: u32,
+        _max_ms: u32,
+        _description: Option<TString<'static>>,
+    ) -> Result<impl LayoutMaybeTrace, Error> {
+        Err::<RootComponent<Empty, ModelUI>, Error>(ERROR_NOT_IMPLEMENTED)
+    }
+
     fn request_pin(
         prompt: TString<'static>,
         subprompt: TString<'static>,
@@ -896,6 +906,7 @@ impl FirmwareUI for UIDelizia {
         _firmware_version: TString<'static>,
         _device_name: TString<'static>,
         _paired_devices: heapless::Vec<TString<'static>, 1>,
+        _auto_lock_delay: TString<'static>,
     ) -> Result<impl LayoutMaybeTrace, Error> {
         Err::<RootComponent<Empty, ModelUI>, Error>(Error::ValueError(
             c"show_device_menu not supported",

core/embed/rust/src/ui/layout_eckhart/component_msg_obj.rs

@@ -17,7 +17,8 @@ use super::firmware::{
     AllowedTextContent, ConfirmHomescreen, ConfirmHomescreenMsg, DeviceMenuMsg, DeviceMenuScreen,
     Homescreen, HomescreenMsg, MnemonicInput, MnemonicKeyboard, MnemonicKeyboardMsg, PinKeyboard,
     PinKeyboardMsg, ProgressScreen, SelectWordCountMsg, SelectWordCountScreen, SelectWordMsg,
-    SelectWordScreen, SetBrightnessScreen, TextScreen, TextScreenMsg,
+    SelectWordScreen, SetBrightnessScreen, TextScreen, TextScreenMsg, ValueInput, ValueInputScreen,
+    ValueInputScreenMsg,
 };
 
 impl ComponentMsgObj for PinKeyboard<'_> {
@@ -116,6 +117,19 @@ impl ComponentMsgObj for SelectWordCountScreen {
     }
 }
 
+impl<T: ValueInput> ComponentMsgObj for ValueInputScreen<T> {
+    fn msg_try_into_obj(&self, msg: Self::Msg) -> Result<Obj, Error> {
+        match msg {
+            ValueInputScreenMsg::Confirmed(i) => i.try_into(),
+            ValueInputScreenMsg::Cancelled => Ok(CANCELLED.as_obj()),
+            // menu message is handled only in the flow
+            ValueInputScreenMsg::Menu => unreachable!(),
+            // changed value message is handled only in the flow
+            ValueInputScreenMsg::Changed(_) => unreachable!(),
+        }
+    }
+}
+
 impl ComponentMsgObj for ConfirmHomescreen {
     fn msg_try_into_obj(&self, msg: Self::Msg) -> Result<Obj, Error> {
         match msg {
@@ -140,6 +154,7 @@ impl<'a> ComponentMsgObj for DeviceMenuScreen<'a> {
             DeviceMenuMsg::CheckBackup => "CheckBackup".try_into(),
             DeviceMenuMsg::WipeDevice => "WipeDevice".try_into(),
             DeviceMenuMsg::ScreenBrightness => "ScreenBrightness".try_into(),
+            DeviceMenuMsg::AutoLockDelay => "AutoLockDelay".try_into(),
             DeviceMenuMsg::Close => Ok(CANCELLED.as_obj()),
         }
     }

core/embed/rust/src/ui/layout_eckhart/firmware/device_menu_screen.rs

@@ -4,6 +4,7 @@ use crate::{
     error::Error,
     micropython::gc::GcBox,
     strutil::TString,
+    trezorhal::storage::has_pin,
     ui::{
         component::{
             text::{
@@ -60,6 +61,7 @@ pub enum DeviceMenuMsg {
 
     // Device menu
     ScreenBrightness,
+    AutoLockDelay,
 
     // nothing selected
     Close,
@@ -166,6 +168,7 @@ impl<'a> DeviceMenuScreen<'a> {
         // (see component_msg_obj.rs, which currently just returns "DeviceDisconnect" with no
         // index!)
         paired_devices: Vec<TString<'static>, 1>,
+        auto_lock_delay: TString<'static>,
     ) -> Result<Self, Error> {
         let mut screen = Self {
             bounds: Rect::zero(),
@@ -181,7 +184,7 @@ impl<'a> DeviceMenuScreen<'a> {
 
         let about = screen.add_subscreen(Subscreen::AboutScreen);
         let security = screen.add_security_menu();
-        let device = screen.add_device_menu(device_name, about);
+        let device = screen.add_device_menu(device_name, about, auto_lock_delay);
         let settings = screen.add_settings_menu(security, device);
 
         let mut paired_device_indices: Vec<usize, 1> = Vec::new();
@@ -274,7 +277,12 @@ impl<'a> DeviceMenuScreen<'a> {
         self.add_subscreen(Subscreen::Submenu(submenu_index))
     }
 
-    fn add_device_menu(&mut self, device_name: TString<'static>, about_index: usize) -> usize {
+    fn add_device_menu(
+        &mut self,
+        device_name: TString<'static>,
+        about_index: usize,
+        auto_lock_delay: TString<'static>,
+    ) -> usize {
         let mut items: Vec<MenuItem, SHORT_MENU_ITEMS> = Vec::new();
         unwrap!(
             items.push(MenuItem::new("Name".into(), None).with_subtext(Some((device_name, None))))
@@ -283,6 +291,17 @@ impl<'a> DeviceMenuScreen<'a> {
             "Screen brightness".into(),
             Some(Action::Return(DeviceMenuMsg::ScreenBrightness)),
         )));
+
+        if has_pin() {
+            unwrap!(items.push(
+                MenuItem::new(
+                    "Auto-lock delay".into(),
+                    Some(Action::Return(DeviceMenuMsg::AutoLockDelay)),
+                )
+                .with_subtext(Some((auto_lock_delay, None)))
+            ));
+        }
+
         unwrap!(items.push(MenuItem::new(
             "About".into(),
             Some(Action::GoTo(about_index))

core/embed/rust/src/ui/layout_eckhart/firmware/mod.rs

@@ -10,13 +10,13 @@ mod hint;
 mod hold_to_confirm;
 mod homescreen;
 mod keyboard;
-mod number_input_screen;
 mod progress_screen;
 mod qr_screen;
 mod select_word_screen;
 mod share_words;
 mod text_screen;
 mod updatable_info_screen;
+mod value_input_screen;
 mod vertical_menu;
 mod vertical_menu_screen;
 
@@ -37,13 +37,15 @@ pub use keyboard::{
     slip39::Slip39Input,
     word_count_screen::{SelectWordCountMsg, SelectWordCountScreen},
 };
-pub use number_input_screen::{NumberInputScreen, NumberInputScreenMsg};
 pub use progress_screen::ProgressScreen;
 pub use qr_screen::{QrMsg, QrScreen};
 pub use select_word_screen::{SelectWordMsg, SelectWordScreen};
 pub use share_words::{ShareWordsScreen, ShareWordsScreenMsg};
 pub use text_screen::{AllowedTextContent, TextScreen, TextScreenMsg};
 pub use updatable_info_screen::UpdatableInfoScreen;
+pub use value_input_screen::{
+    DurationInput, NumberInput, ValueInput, ValueInputScreen, ValueInputScreenMsg,
+};
 pub use vertical_menu::{
     LongMenuGc, MenuItems, ShortMenuVec, VerticalMenu, VerticalMenuMsg, LONG_MENU_ITEMS,
     SHORT_MENU_ITEMS,

core/embed/rust/src/ui/layout_eckhart/firmware/value_input_screen.rs

@@ -0,0 +1,543 @@
+use crate::{
+    strutil::{self, plural_form, ShortString, TString},
+    time::Duration,
+    translations::TR,
+    ui::{
+        component::{swipe_detect::SwipeConfig, Component, Event, EventCtx, Label, Maybe, Timer},
+        flow::Swipable,
+        geometry::{Alignment, Insets, Offset, Rect},
+        shape::{self, Renderer},
+        util::Pager,
+    },
+};
+
+use super::{
+    super::{
+        super::constant::SCREEN,
+        component::{Button, ButtonMsg},
+        fonts, theme,
+    },
+    ActionBar, ActionBarMsg, Header, HeaderMsg,
+};
+
+pub enum ValueInputScreenMsg {
+    Cancelled,
+    Confirmed(u32),
+    Changed(u32),
+    Menu,
+}
+
+pub struct ValueInputScreen<T: ValueInput> {
+    /// Screen header
+    header: Header,
+    /// Screeen description
+    description: Label<'static>,
+    /// Value input dialog
+    input_dialog: ValueInputDialog<T>,
+    /// Return message when the value is changed
+    /// This is only used in the flows
+    changed_value_handling: bool,
+    /// Screen action bar
+    action_bar: ActionBar,
+}
+
+impl<T: ValueInput> ValueInputScreen<T> {
+    const DESCRIPTION_HEIGHT: i16 = 123;
+    const INPUT_HEIGHT: i16 = 170;
+    pub fn new(value: T, text: TString<'static>) -> Self {
+        Self {
+            header: Header::new(TString::empty()),
+            action_bar: ActionBar::new_cancel_confirm(),
+            input_dialog: ValueInputDialog::new(value),
+            changed_value_handling: false,
+            description: Label::new(text, Alignment::Start, theme::TEXT_MEDIUM),
+        }
+    }
+
+    pub fn with_header(mut self, header: Header) -> Self {
+        self.header = header;
+        self
+    }
+
+    pub fn with_action_bar(mut self, action_bar: ActionBar) -> Self {
+        self.action_bar = action_bar;
+        self
+    }
+
+    pub fn with_changed_value_handling(mut self) -> Self {
+        self.changed_value_handling = true;
+        self
+    }
+
+    pub fn value(&self) -> u32 {
+        self.input_dialog.value_input.num()
+    }
+}
+
+impl<T: ValueInput> Component for ValueInputScreen<T> {
+    type Msg = ValueInputScreenMsg;
+
+    fn place(&mut self, bounds: Rect) -> Rect {
+        // assert full screen
+        debug_assert_eq!(bounds.height(), SCREEN.height());
+        debug_assert_eq!(bounds.width(), SCREEN.width());
+
+        let (header_area, rest) = bounds.split_top(Header::HEADER_HEIGHT);
+        let (rest, action_bar_area) = rest.split_bottom(ActionBar::ACTION_BAR_HEIGHT);
+        let (description_area, rest) = rest.split_top(Self::DESCRIPTION_HEIGHT);
+        let (input_area, rest) = rest.split_top(Self::INPUT_HEIGHT);
+
+        // Set touch expansion for the action bar not to overlap with the input area
+        self.action_bar
+            .set_touch_expansion(Insets::top(rest.height()));
+
+        let description_area = description_area.inset(Insets::sides(24));
+
+        self.header.place(header_area);
+        self.description.place(description_area);
+        self.input_dialog.place(input_area);
+        self.action_bar.place(action_bar_area);
+
+        bounds
+    }
+
+    fn event(&mut self, ctx: &mut EventCtx, event: Event) -> Option<Self::Msg> {
+        if let Some(HeaderMsg::Menu) = self.header.event(ctx, event) {
+            return Some(ValueInputScreenMsg::Menu);
+        }
+
+        if let Some(msg) = self.action_bar.event(ctx, event) {
+            match msg {
+                ActionBarMsg::Confirmed => {
+                    return Some(ValueInputScreenMsg::Confirmed(self.value()))
+                }
+                ActionBarMsg::Cancelled => return Some(ValueInputScreenMsg::Cancelled),
+                _ => {}
+            }
+        }
+
+        self.input_dialog
+            .event(ctx, event)
+            .filter(|_| self.changed_value_handling)
+            .map(ValueInputScreenMsg::Changed)
+    }
+
+    fn render<'s>(&'s self, target: &mut impl Renderer<'s>) {
+        self.header.render(target);
+        self.description.render(target);
+        self.input_dialog.render(target);
+        self.action_bar.render(target);
+    }
+}
+
+#[cfg(feature = "micropython")]
+impl<T: ValueInput> Swipable for ValueInputScreen<T> {
+    fn get_swipe_config(&self) -> SwipeConfig {
+        SwipeConfig::new()
+    }
+
+    fn get_pager(&self) -> Pager {
+        Pager::single_page()
+    }
+}
+
+#[cfg(feature = "ui_debug")]
+impl<T: ValueInput> crate::trace::Trace for ValueInputScreen<T> {
+    fn trace(&self, t: &mut dyn crate::trace::Tracer) {
+        t.component("ValueInputScreen");
+        t.child("description", &self.description);
+        t.child("Header", &self.header);
+        t.child("input_dialog", &self.input_dialog);
+    }
+}
+
+struct ValueInputDialog<T: ValueInput> {
+    area: Rect,
+    dec: Maybe<Button>,
+    inc: Maybe<Button>,
+    value_input: T,
+    hold_timer: Timer,
+    counter: u32,
+}
+
+impl<T: ValueInput> ValueInputDialog<T> {
+    const BUTTON_PADDING: i16 = 10;
+    const LABEL_OFFSET: i16 = 21;
+    const BUTTON_SIZE: Offset = Offset::new(138, 130);
+    const BORDER_PADDING: i16 = 24;
+    const HOLD_TIMEOUT_DURATION: Duration = Duration::from_millis(500);
+    const BIG_INCREMENT: u32 = 10;
+    const BIG_INCREMENT_THRESHOLD: u32 = 5;
+    fn new(value_input: T) -> Self {
+        let dec = Button::with_icon(theme::ICON_MINUS)
+            .styled(theme::button_keyboard())
+            .with_radius(12);
+        let inc = Button::with_icon(theme::ICON_PLUS)
+            .styled(theme::button_keyboard())
+            .with_radius(12);
+        Self {
+            area: Rect::zero(),
+            dec: Maybe::new(theme::BG, dec, !value_input.is_min()),
+            inc: Maybe::new(theme::BG, inc, !value_input.is_max()),
+            value_input,
+            hold_timer: Timer::new(),
+            counter: 0,
+        }
+    }
+
+    fn handle_button_event(&mut self, msg: ButtonMsg, ctx: &mut EventCtx, is_increment: bool) {
+        match msg {
+            ButtonMsg::Clicked => {
+                self.hold_timer.stop();
+                if self.counter == 0 {
+                    if is_increment {
+                        self.increase(ctx);
+                    } else {
+                        self.decrease(ctx);
+                    }
+                }
+                self.counter = 0;
+            }
+            ButtonMsg::Released => {
+                self.hold_timer.stop();
+                self.counter = 0;
+            }
+            ButtonMsg::Pressed => {
+                self.hold_timer.start(ctx, Self::HOLD_TIMEOUT_DURATION);
+            }
+            _ => {}
+        }
+    }
+
+    fn increase(&mut self, ctx: &mut EventCtx) {
+        let n = if self.counter < Self::BIG_INCREMENT_THRESHOLD {
+            1
+        } else {
+            Self::BIG_INCREMENT
+        };
+
+        for _ in 0..n {
+            self.value_input.increment();
+        }
+
+        self.on_change(ctx);
+    }
+
+    fn decrease(&mut self, ctx: &mut EventCtx) {
+        let n = if self.counter < Self::BIG_INCREMENT_THRESHOLD {
+            1
+        } else {
+            Self::BIG_INCREMENT
+        };
+
+        for _ in 0..n {
+            self.value_input.decrement();
+        }
+
+        self.on_change(ctx);
+        ctx.request_paint();
+    }
+
+    fn on_change(&mut self, ctx: &mut EventCtx) {
+        if self.value_input.is_min() {
+            self.dec.hide(ctx);
+            // If the value is saturated by a long hold, the button state is reset to
+            // initial
+            self.dec.inner_mut().enable(ctx);
+            self.on_saturation();
+        } else {
+            self.dec.show(ctx);
+        }
+
+        if self.value_input.is_max() {
+            self.inc.hide(ctx);
+            // If the value is saturated by a long hold, the button state must be reset
+            self.inc.inner_mut().enable(ctx);
+            self.on_saturation();
+        } else {
+            self.inc.show(ctx);
+        }
+    }
+
+    fn on_saturation(&mut self) {
+        self.hold_timer.stop();
+        self.counter = 0;
+    }
+
+    fn render_borders<'s>(&'s self, target: &mut impl Renderer<'s>) {
+        let borders = self.area.inset(Insets::sides(Self::BORDER_PADDING));
+        // Render lines as bars with the with 1px
+        let top_line =
+            Rect::from_bottom_right_and_size(borders.top_right(), Offset::new(borders.width(), 1));
+        let bottom_line =
+            Rect::from_top_right_and_size(borders.bottom_right(), Offset::new(borders.width(), 1));
+
+        shape::Bar::new(top_line)
+            .with_fg(theme::GREY_EXTRA_DARK)
+            .with_bg(theme::GREY_EXTRA_DARK)
+            .render(target);
+
+        shape::Bar::new(bottom_line)
+            .with_fg(theme::GREY_EXTRA_DARK)
+            .with_bg(theme::GREY_EXTRA_DARK)
+            .render(target);
+    }
+
+    fn render_number<'s>(&'s self, target: &mut impl Renderer<'s>) {
+        let mut buf = [0u8; 3];
+
+        let (num, label) = self.value_input.repr();
+
+        if let Some(num_str) = strutil::format_i64(num as i64, &mut buf) {
+            let num_font = fonts::FONT_SATOSHI_EXTRALIGHT_72;
+            let label_font = fonts::FONT_SATOSHI_REGULAR_22;
+
+            let mut num_offset = Offset::y(num_font.allcase_text_height() / 2);
+            if label.is_some() {
+                num_offset = num_offset.sub(Offset::y(
+                    label_font.allcase_text_height() / 2 + Self::LABEL_OFFSET,
+                ));
+            }
+            shape::Text::new(self.area.center().ofs(num_offset), num_str, num_font)
+                .with_align(Alignment::Center)
+                .with_fg(theme::GREY)
+                .render(target);
+
+            if let Some(label) = label {
+                let label_offset = num_offset.add(Offset::y(
+                    label_font.allcase_text_height() + Self::LABEL_OFFSET,
+                ));
+
+                shape::Text::new(
+                    self.area.center().ofs(label_offset),
+                    label.as_str(),
+                    label_font,
+                )
+                .with_align(Alignment::Center)
+                .with_fg(theme::GREY)
+                .render(target);
+            }
+        }
+    }
+}
+
+impl<T: ValueInput> Component for ValueInputDialog<T> {
+    type Msg = u32;
+
+    fn place(&mut self, bounds: Rect) -> Rect {
+        self.area = bounds;
+
+        let button_bounds = self.area.inset(Insets::sides(Self::BUTTON_PADDING));
+        // Equivalent to from_left_center_and_size
+        let dec_bounds = Rect::from_center_and_size(
+            button_bounds
+                .left_center()
+                .ofs(Offset::x(Self::BUTTON_SIZE.x / 2)),
+            Self::BUTTON_SIZE,
+        );
+        // Equivalent to from_right_center_and_size
+        let inc_bounds = Rect::from_center_and_size(
+            button_bounds
+                .right_center()
+                .ofs(Offset::x(-Self::BUTTON_SIZE.x / 2)),
+            Self::BUTTON_SIZE,
+        );
+
+        self.dec.place(dec_bounds);
+        self.inc.place(inc_bounds);
+        bounds
+    }
+
+    fn event(&mut self, ctx: &mut EventCtx, event: Event) -> Option<Self::Msg> {
+        let old_value = self.value_input.num();
+        // Closure to return updated value if changed
+        let return_if_changed = |new_value| {
+            if old_value != new_value {
+                Some(new_value)
+            } else {
+                None
+            }
+        };
+
+        // Hold timer expiration
+        if self.hold_timer.expire(event) {
+            // If the value is not saturated (button is pressed and visible),
+            // increase/decrease the value and restart the timer
+            if self.dec.is_visible() && self.dec.inner().is_pressed() {
+                self.decrease(ctx);
+                self.hold_timer.start(ctx, Self::HOLD_TIMEOUT_DURATION);
+                self.counter += 1;
+                ctx.request_paint();
+                return return_if_changed(self.value_input.num());
+            } else if self.inc.is_visible() && self.inc.inner().is_pressed() {
+                self.increase(ctx);
+                self.hold_timer.start(ctx, Self::HOLD_TIMEOUT_DURATION);
+                self.counter += 1;
+                ctx.request_paint();
+                return return_if_changed(self.value_input.num());
+            } else {
+                self.on_saturation();
+                return None;
+            }
+        }
+
+        // Handle decrement button events
+        if let Some(dec_event) = self.dec.event(ctx, event) {
+            self.handle_button_event(dec_event, ctx, false);
+            return return_if_changed(self.value_input.num());
+        }
+
+        // Handle increment button events
+        if let Some(inc_event) = self.inc.event(ctx, event) {
+            self.handle_button_event(inc_event, ctx, true);
+            return return_if_changed(self.value_input.num());
+        }
+
+        None
+    }
+
+    fn render<'s>(&'s self, target: &mut impl Renderer<'s>) {
+        self.render_borders(target);
+        self.render_number(target);
+        self.dec.render(target);
+        self.inc.render(target);
+    }
+}
+
+#[cfg(feature = "ui_debug")]
+impl<T: ValueInput> crate::trace::Trace for ValueInputDialog<T> {
+    fn trace(&self, t: &mut dyn crate::trace::Tracer) {
+        t.component("ValueInput");
+        t.int("value", self.value_input.num() as i64);
+    }
+}
+
+pub trait ValueInput {
+    fn num(&self) -> u32;
+    fn repr(&self) -> (u32, Option<ShortString>);
+    fn increment(&mut self);
+    fn decrement(&mut self);
+    fn is_max(&self) -> bool;
+    fn is_min(&self) -> bool;
+}
+
+pub struct NumberInput {
+    value: u32,
+    min: u32,
+    max: u32,
+}
+
+impl ValueInput for NumberInput {
+    fn num(&self) -> u32 {
+        self.value
+    }
+
+    fn repr(&self) -> (u32, Option<ShortString>) {
+        (self.value, None)
+    }
+
+    fn increment(&mut self) {
+        self.value = self.value.saturating_add(1).min(self.max);
+    }
+
+    fn decrement(&mut self) {
+        self.value = self.value.saturating_sub(1).max(self.min);
+    }
+
+    fn is_max(&self) -> bool {
+        self.value == self.max
+    }
+
+    fn is_min(&self) -> bool {
+        self.value == self.min
+    }
+}
+
+impl NumberInput {
+    pub fn new(min: u32, max: u32, value: u32) -> Self {
+        Self {
+            value: value.clamp(min, max),
+            min,
+            max,
+        }
+    }
+}
+
+pub struct DurationInput {
+    duration: Duration,
+    min: Duration,
+    max: Duration,
+}
+
+impl ValueInput for DurationInput {
+    fn num(&self) -> u32 {
+        self.duration.to_millis()
+    }
+
+    fn repr(&self) -> (u32, Option<ShortString>) {
+        let units = [
+            (self.duration.to_days(), TR::plurals__lock_after_x_days),
+            (self.duration.to_hours(), TR::plurals__lock_after_x_hours),
+            (self.duration.to_mins(), TR::plurals__lock_after_x_minutes),
+        ];
+
+        for &(count, tr) in &units {
+            if count > 0 {
+                let plural =
+                    TString::from_translation(tr).map(|template| plural_form(template, count));
+                return (count, Some(plural));
+            }
+        }
+
+        // Fallback to seconds if all are 0
+        let count = self.duration.to_secs();
+        let plural = TString::from_translation(TR::plurals__lock_after_x_seconds)
+            .map(|template| plural_form(template, count));
+        (count, Some(plural))
+    }
+
+    fn increment(&mut self) {
+        self.duration = unwrap!(self.duration.increment_unit()).min(self.max);
+    }
+
+    fn decrement(&mut self) {
+        self.duration = unwrap!(self.duration.decrement_unit()).max(self.min);
+    }
+
+    fn is_max(&self) -> bool {
+        self.duration == self.max
+    }
+
+    fn is_min(&self) -> bool {
+        self.duration == self.min
+    }
+}
+
+impl DurationInput {
+    pub fn new(min: Duration, max: Duration, duration: Duration) -> Self {
+        let max_crop = max.crop_to_largest_unit();
+        let min_crop = min.crop_to_largest_unit();
+        Self {
+            duration: duration.clamp(min_crop, max_crop).crop_to_largest_unit(),
+            min: min_crop,
+            max: max_crop,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{super::super::constant::SCREEN, *};
+
+    #[test]
+    fn test_component_heights_fit_screen() {
+        assert!(
+            ValueInputScreen::<DurationInput>::DESCRIPTION_HEIGHT
+                + ValueInputScreen::<DurationInput>::INPUT_HEIGHT
+                + Header::HEADER_HEIGHT
+                + ActionBar::ACTION_BAR_HEIGHT
+                <= SCREEN.height(),
+            "Components overflow the screen height",
+        );
+    }
+}

core/embed/rust/src/ui/layout_eckhart/flow/request_number.rs

@@ -17,8 +17,9 @@ use core::sync::atomic::{AtomicU16, Ordering};
 use super::super::{
     component::Button,
     firmware::{
-        Header, NumberInputScreen, NumberInputScreenMsg, ShortMenuVec, TextScreenMsg,
-        UpdatableInfoScreen, VerticalMenu, VerticalMenuScreen, VerticalMenuScreenMsg,
+        ActionBar, Header, NumberInput, ShortMenuVec, TextScreenMsg, UpdatableInfoScreen,
+        ValueInputScreen, ValueInputScreenMsg, VerticalMenu, VerticalMenuScreen,
+        VerticalMenuScreenMsg,
     },
     theme,
 };
@@ -72,20 +73,25 @@ pub fn new_request_number(
         info_closure(curr_number as u32)
     };
 
-    let content_input = NumberInputScreen::new(min_count, max_count, count, description)
-        .with_header(Header::new(title).with_menu_button())
-        .map(|msg| match msg {
-            NumberInputScreenMsg::Cancelled => Some(FlowMsg::Cancelled),
-            NumberInputScreenMsg::Confirmed(n) => {
-                NUM_DISPLAYED.store(n as u16, Ordering::Relaxed);
-                Some(FlowMsg::Choice(n as usize))
-            }
-            NumberInputScreenMsg::Changed(n) => {
-                NUM_DISPLAYED.store(n as u16, Ordering::Relaxed);
-                None
-            }
-            NumberInputScreenMsg::Menu => Some(FlowMsg::Info),
-        });
+    let content_input =
+        ValueInputScreen::new(NumberInput::new(min_count, max_count, count), description)
+            .with_header(Header::new(title).with_menu_button())
+            .with_action_bar(ActionBar::new_single(Button::with_text(
+                TR::buttons__confirm.into(),
+            )))
+            .with_changed_value_handling()
+            .map(|msg| match msg {
+                ValueInputScreenMsg::Cancelled => Some(FlowMsg::Cancelled),
+                ValueInputScreenMsg::Confirmed(n) => {
+                    NUM_DISPLAYED.store(n as u16, Ordering::Relaxed);
+                    Some(FlowMsg::Choice(n as usize))
+                }
+                ValueInputScreenMsg::Changed(n) => {
+                    NUM_DISPLAYED.store(n as u16, Ordering::Relaxed);
+                    None
+                }
+                ValueInputScreenMsg::Menu => Some(FlowMsg::Info),
+            });
 
     let menu_items = VerticalMenu::<ShortMenuVec>::empty()
         .with_item(Button::new_menu_item(

core/embed/rust/src/ui/layout_eckhart/ui_firmware.rs

@@ -5,6 +5,7 @@ use crate::{
     io::BinaryData,
     micropython::{gc::Gc, iter::IterBuf, list::List, obj::Obj, util},
     strutil::TString,
+    time::Duration,
     translations::TR,
     ui::{
         component::{
@@ -33,9 +34,10 @@ use crate::{
 use super::{
     component::Button,
     firmware::{
-        ActionBar, Bip39Input, ConfirmHomescreen, DeviceMenuScreen, Header, HeaderMsg, Hint,
-        Homescreen, MnemonicKeyboard, PinKeyboard, ProgressScreen, SelectWordCountScreen,
-        SelectWordScreen, SetBrightnessScreen, Slip39Input, TextScreen,
+        ActionBar, Bip39Input, ConfirmHomescreen, DeviceMenuScreen, DurationInput, Header,
+        HeaderMsg, Hint, Homescreen, MnemonicKeyboard, PinKeyboard, ProgressScreen,
+        SelectWordCountScreen, SelectWordScreen, SetBrightnessScreen, Slip39Input, TextScreen,
+        ValueInputScreen,
     },
     flow, fonts, theme, UIEckhart,
 };
@@ -762,7 +764,6 @@ impl FirmwareUI for UIEckhart {
         more_info_callback: Option<impl Fn(u32) -> TString<'static> + 'static>,
     ) -> Result<impl LayoutMaybeTrace, Error> {
         let description = description.unwrap_or(TString::empty());
-
         let flow = flow::request_number::new_request_number(
             title,
             count,
@@ -774,6 +775,29 @@ impl FirmwareUI for UIEckhart {
         Ok(flow)
     }
 
+    fn request_duration(
+        title: TString<'static>,
+        duration_ms: u32,
+        min_ms: u32,
+        max_ms: u32,
+        description: Option<TString<'static>>,
+    ) -> Result<impl LayoutMaybeTrace, Error> {
+        let description = description.unwrap_or(TString::empty());
+        let component = ValueInputScreen::new(
+            DurationInput::new(
+                Duration::from_millis(min_ms),
+                Duration::from_millis(max_ms),
+                Duration::from_millis(duration_ms),
+            ),
+            description,
+        )
+        .with_header(Header::new(title));
+
+        let layout = RootComponent::new(component);
+
+        Ok(layout)
+    }
+
     fn request_pin(
         prompt: TString<'static>,
         subprompt: TString<'static>,
@@ -974,6 +998,7 @@ impl FirmwareUI for UIEckhart {
         firmware_version: TString<'static>,
         device_name: TString<'static>,
         paired_devices: Vec<TString<'static>, 1>,
+        auto_lock_delay: TString<'static>,
     ) -> Result<impl LayoutMaybeTrace, Error> {
         let layout = RootComponent::new(DeviceMenuScreen::new(
             failed_backup,
@@ -981,6 +1006,7 @@ impl FirmwareUI for UIEckhart {
             firmware_version,
             device_name,
             paired_devices,
+            auto_lock_delay,
         )?);
         Ok(layout)
     }

core/embed/rust/src/ui/ui_firmware.rs

@@ -239,6 +239,14 @@ pub trait FirmwareUI {
         more_info_callback: Option<impl Fn(u32) -> TString<'static> + 'static>,
     ) -> Result<impl LayoutMaybeTrace, Error>;
 
+    fn request_duration(
+        title: TString<'static>,
+        duration_ms: u32,
+        min_ms: u32,
+        max_ms: u32,
+        description: Option<TString<'static>>,
+    ) -> Result<impl LayoutMaybeTrace, Error>;
+
     fn request_pin(
         prompt: TString<'static>,
         subprompt: TString<'static>,
@@ -311,6 +319,7 @@ pub trait FirmwareUI {
         firmware_version: TString<'static>,
         device_name: TString<'static>,
         paired_devices: Vec<TString<'static>, 1>,
+        auto_lock_delay: TString<'static>,
     ) -> Result<impl LayoutMaybeTrace, Error>;
 
     fn show_pairing_device_name(

core/mocks/generated/trezorui_api.pyi

@@ -419,6 +419,18 @@ def request_number(
     description."""
 
 
+# rust/src/ui/api/firmware_micropython.rs
+def request_duration(
+    *,
+    title: str,
+    duration_ms: int,
+    min_ms: int,
+    max_ms: int,
+    description: str | None = None,
+) -> LayoutObj[tuple[UiResult, int]]:
+    """Duration input with + and - buttons, optional static description. """
+
+
 # rust/src/ui/api/firmware_micropython.rs
 def request_pin(
     *,
@@ -542,6 +554,7 @@ def show_device_menu(
     firmware_version: str,
     device_name: str,
     paired_devices: Iterable[str],
+    auto_lock_delay: str,
 ) -> LayoutObj[UiResult]:
     """Show the device menu."""
 

core/mocks/trezortranslate_keys.pyi

@@ -26,6 +26,7 @@ class TR:
     authenticate__confirm_template: str = "Allow connected computer to confirm your {0} is genuine?"
     authenticate__header: str = "Authenticate device"
     auto_lock__change_template: str = "Auto-lock Trezor after {0} of inactivity?"
+    auto_lock__description: str = "Set the time before your Trezor locks automatically."
     auto_lock__title: str = "Auto-lock delay"
     auto_lock__turned_on: str = "Auto-lock turned on"
     backup__can_back_up_anytime: str = "You can back up your Trezor once, at any time."
@@ -550,6 +551,7 @@ class TR:
     pin__turn_on: str = "Turn on PIN protection?"
     pin__wrong_pin: str = "Wrong PIN"
     plurals__contains_x_keys: str = "key|keys"
+    plurals__lock_after_x_days: str = "day|days"
     plurals__lock_after_x_hours: str = "hour|hours"
     plurals__lock_after_x_milliseconds: str = "millisecond|milliseconds"
     plurals__lock_after_x_minutes: str = "minute|minutes"

core/src/apps/homescreen/device_menu.py

@@ -1,10 +1,35 @@
 import storage.device
 import trezorui_api
-from trezor import utils
+from trezor import TR, config, utils
 from trezor.ui.layouts import raise_if_not_confirmed
+from trezor.ui.layouts.common import interact
+from trezor.wire import ActionCancelled
+
+
+async def _prompt_auto_lock_delay() -> int:
+    auto_lock_delay_ms = await interact(
+        trezorui_api.request_duration(
+            title=TR.auto_lock__title,
+            duration_ms=storage.device.get_autolock_delay_ms(),
+            min_ms=storage.device.AUTOLOCK_DELAY_MINIMUM,
+            max_ms=storage.device.AUTOLOCK_DELAY_MAXIMUM,
+            description=TR.auto_lock__description,
+        ),
+        br_name=None,
+    )
+
+    if auto_lock_delay_ms is not trezorui_api.CANCELLED:
+        assert isinstance(auto_lock_delay_ms, int)
+        assert auto_lock_delay_ms >= storage.device.AUTOLOCK_DELAY_MINIMUM
+        assert auto_lock_delay_ms <= storage.device.AUTOLOCK_DELAY_MAXIMUM
+        return auto_lock_delay_ms
+    else:
+        raise ActionCancelled  # user cancelled request number prompt
 
 
 async def handle_device_menu() -> None:
+    from trezor import strings
+
     # MOCK DATA
     failed_backup = True
     battery_percentage = 22
@@ -12,6 +37,29 @@ async def handle_device_menu() -> None:
     # ###
     firmware_version = ".".join(map(str, utils.VERSION))
     device_name = storage.device.get_label() or "Trezor"
+    # Determine appropriate unit and count for auto-lock delay
+    auto_lock_ms = storage.device.get_autolock_delay_ms()
+    MS = 1000
+    MIN = MS * 60
+    HOUR = MIN * 60
+    DAY = HOUR * 24
+
+    if auto_lock_ms >= DAY:
+        auto_lock_num = auto_lock_ms // DAY
+        auto_lock_label = TR.plurals__lock_after_x_days
+    elif auto_lock_ms >= HOUR:
+        auto_lock_num = auto_lock_ms // HOUR
+        auto_lock_label = TR.plurals__lock_after_x_hours
+    elif auto_lock_ms >= MIN:
+        auto_lock_num = auto_lock_ms // MIN
+        auto_lock_label = TR.plurals__lock_after_x_minutes
+    else:
+        auto_lock_num = auto_lock_ms // MS
+        auto_lock_label = TR.plurals__lock_after_x_seconds
+
+    auto_lock_str = strings.format_plural(
+        "{count} {plural}", auto_lock_num, auto_lock_label
+    )
 
     menu_result = await raise_if_not_confirmed(
         trezorui_api.show_device_menu(
@@ -20,6 +68,7 @@ async def handle_device_menu() -> None:
             paired_devices=paired_devices,
             firmware_version=firmware_version,
             device_name=device_name,
+            auto_lock_delay=auto_lock_str,
         ),
         None,
     )
@@ -27,5 +76,21 @@ async def handle_device_menu() -> None:
         from apps.management.ble.pair_new_device import pair_new_device
 
         await pair_new_device()
+    elif menu_result == "ScreenBrightness":
+        from trezor.ui.layouts import set_brightness
+
+        await set_brightness()
+    elif menu_result == "WipeDevice":
+        from trezor.messages import WipeDevice
+
+        from apps.management.wipe_device import wipe_device
+
+        await wipe_device(WipeDevice())
+    elif menu_result == "AutoLockDelay":
+
+        if config.has_pin():
+
+            auto_lock_delay_ms = await _prompt_auto_lock_delay()
+            storage.device.set_autolock_delay_ms(auto_lock_delay_ms)
     else:
         raise RuntimeError(f"Unknown menu {menu_result}")

core/translations/en.json

@@ -33,7 +33,13 @@
     "authenticate__confirm_template": "Allow connected computer to confirm your {0} is genuine?",
     "authenticate__header": "Authenticate device",
     "auto_lock__change_template": "Auto-lock Trezor after {0} of inactivity?",
-    "auto_lock__title": "Auto-lock delay",
+    "auto_lock__title": {
+      "Bolt": "Auto-lock delay",
+      "Caesar": "Auto-lock delay",
+      "Delizia": "Auto-lock delay",
+      "Eckhart": "Auto-lock"
+    },
+    "auto_lock__description": "Set the time before your Trezor locks automatically.",
     "auto_lock__turned_on": "Auto-lock turned on",
     "backup__can_back_up_anytime": "You can back up your Trezor once, at any time.",
     "backup__create_backup_to_prevent_loss": {
@@ -607,6 +613,7 @@
     "pin__turn_on": "Turn on PIN protection?",
     "pin__wrong_pin": "Wrong PIN",
     "plurals__contains_x_keys": "key|keys",
+    "plurals__lock_after_x_days": "day|days",
     "plurals__lock_after_x_hours": "hour|hours",
     "plurals__lock_after_x_milliseconds": "millisecond|milliseconds",
     "plurals__lock_after_x_minutes": "minute|minutes",

core/translations/order.json

@@ -1030,5 +1030,7 @@
   "1028": "words__wallet",
   "1029": "words__authenticate",
   "1030": "ethereum__deploy_contract",
-  "1031": "ethereum__title_all_input_data_template"
+  "1031": "ethereum__title_all_input_data_template",
+  "1032": "auto_lock__description",
+  "1033": "plurals__lock_after_x_days"
 }

tests/click_tests/reset.py

@@ -75,7 +75,7 @@ def cancel_backup(
 def set_selection(debug: "DebugLink", diff: int) -> None:
     if debug.layout_type in (LayoutType.Bolt, LayoutType.Delizia, LayoutType.Eckhart):
         if debug.layout_type is LayoutType.Eckhart:
-            assert "NumberInputScreen" in debug.read_layout().all_components()
+            assert "ValueInputScreen" in debug.read_layout().all_components()
         else:
             assert "NumberInputDialog" in debug.read_layout().all_components()
 

tests/ui_tests/fixtures.json

@@ -27627,12 +27627,12 @@
 "T3W1_cs_test_recovery.py::test_recovery_cancel_issue4613": "fd734872efb079367fc3d79793e7c722b5ed52eaeb08d760eed718c043a2a9ba",
 "T3W1_cs_test_recovery.py::test_recovery_cancel_number_of_words": "99307f2f30d74a92a6f9d2abc553dc95f8350b26025ca8372a5df6ccc430a63d",
 "T3W1_cs_test_recovery.py::test_recovery_slip39_basic": "245b0a9201a861e1ad5db0aa6399b2688204ce031171c98edf2cc60e058fe60e",
-"T3W1_cs_test_repeated_backup.py::test_repeated_backup": "9377d497ab53aed3c077a370cf215fba06b2db50c0aee0f79cba6aeb5e2d8567",
+"T3W1_cs_test_repeated_backup.py::test_repeated_backup": "d821637d0dbf736b3b65ed2e3fb7bf8174a47311e58db0e3e628319024a87068",
 "T3W1_cs_test_reset_bip39.py::test_reset_bip39": "90545acdc4c134b2c6ffae270eda74eea1fcf4aedf6d17daa5a480118cbb72ab",
-"T3W1_cs_test_reset_slip39_advanced.py::test_reset_slip39_advanced[16of16]": "89bc54beb658c46509ee43423fe1bd7eb41502232708097c7b1964e52bd5c46e",
-"T3W1_cs_test_reset_slip39_advanced.py::test_reset_slip39_advanced[2of2]": "f90b55094c68bf36138777352f20302c198b4fcdd7d48aacc5f67fa3b51d9937",
-"T3W1_cs_test_reset_slip39_basic.py::test_reset_slip39_basic[16of16]": "e613b9ba08e43ad8009e15db2f149d4575aa9b88b734868664b40cba851459bb",
-"T3W1_cs_test_reset_slip39_basic.py::test_reset_slip39_basic[1of1]": "e2c09433cae9eac1ff9790e8d157ca50407a573717f94669928366c6b99d5e80",
+"T3W1_cs_test_reset_slip39_advanced.py::test_reset_slip39_advanced[16of16]": "b8a71357bc1a1370772a5240bd368714051a87ebcdc5b6edb084a86d93f4492b",
+"T3W1_cs_test_reset_slip39_advanced.py::test_reset_slip39_advanced[2of2]": "4833e0a8a4decaa9d1343528584ec51fc06278a183e1065362aac476fd3021a4",
+"T3W1_cs_test_reset_slip39_basic.py::test_reset_slip39_basic[16of16]": "378182424ca749ce9e3ccec51c831524e91b6b3d6a047f83c34b6f84b2b702eb",
+"T3W1_cs_test_reset_slip39_basic.py::test_reset_slip39_basic[1of1]": "2f4e5771b81b8be8f48e524fab83bbadacf033c16799d0d611e764f145eeab39",
 "T3W1_de_test_autolock.py::test_autolock_does_not_interrupt_preauthorized": "ec625ed4ee5b4f2cd03f44946a9b24bfebfd117a2ddc06084040fab3d41b0d5d",
 "T3W1_de_test_autolock.py::test_autolock_does_not_interrupt_signing": "ffab7b856618818b0a4e47d95daf88b0d74cea9a36c51668a9dd3fda65dd7d51",
 "T3W1_de_test_autolock.py::test_autolock_interrupts_passphrase": "724df892498fd3bb18e45aa17ffa9ba4968a70d820646d2fd761f7ae24b27cbf",
@@ -27679,20 +27679,20 @@
 "T3W1_de_test_recovery.py::test_recovery_cancel_issue4613": "5364a4b0b0207bb8632b06f02e05dd9b438c16a2f13760697db86d332f9217b0",
 "T3W1_de_test_recovery.py::test_recovery_cancel_number_of_words": "f1c395b75580775afcd946b0002ab7c440581b3859b4cacfd716bddc13108e03",
 "T3W1_de_test_recovery.py::test_recovery_slip39_basic": "d3361b2356aa7abf62c39dc36b287aaa354cdfd1e95edffd074505efdc05e419",
-"T3W1_de_test_repeated_backup.py::test_repeated_backup": "449c001dd4b5fff9c02d8d81850d65050a53f275b72c998b9a89bef3ca094cae",
+"T3W1_de_test_repeated_backup.py::test_repeated_backup": "1cb71ac1df5986d9e3a2bc8e84bcc1c7d332fb3463c85240b759ece6f21a948e",
 "T3W1_de_test_reset_bip39.py::test_reset_bip39": "75587fe9b0a98661475ea4206319244b74f4c099953e717c571af2132322594b",
-"T3W1_de_test_reset_slip39_advanced.py::test_reset_slip39_advanced[16of16]": "fc7880ef853c5f61a09aacac585fdf8131067eb15c17a670f4a39de583a2c0ed",
-"T3W1_de_test_reset_slip39_advanced.py::test_reset_slip39_advanced[2of2]": "e0152e7e5ed8e235d5b2b11d6fa8f09fb1e48cc8639689737c99e885304727b8",
-"T3W1_de_test_reset_slip39_basic.py::test_reset_slip39_basic[16of16]": "b7863fcef971741bb23f75889ada6cb3925af935a3a0a09c2da2aeba8861134b",
-"T3W1_de_test_reset_slip39_basic.py::test_reset_slip39_basic[1of1]": "83e91fd4a71c8333fa518f2370781d80f9c4ab5411916111eda72da5f8788e3e",
-"T3W1_en_test_autolock.py::test_autolock_does_not_interrupt_preauthorized": "40ee809094dbe2a7e2aa88451fa95be96b40c44810ff9b45847850658bc6d248",
-"T3W1_en_test_autolock.py::test_autolock_does_not_interrupt_signing": "09b8eaaf5bfe75c3d3d94a5fa629f42b909a47a4356c2fa210395b8e130a5b67",
-"T3W1_en_test_autolock.py::test_autolock_interrupts_passphrase": "d6a4d388456997b76882c0bcbe175958584e01956fa735ecfad5a3bffa099b8d",
-"T3W1_en_test_autolock.py::test_autolock_interrupts_signing": "b34ce283a632cd617f01cbdad55cd4de4b5a5a7f830b65c6e5aa2c1f24cde856",
-"T3W1_en_test_autolock.py::test_autolock_passphrase_keyboard": "a03fbc9b512e3a797113706641421da521c86b0ec9a78444c8021d5a8d52bf08",
-"T3W1_en_test_autolock.py::test_dryrun_enter_word_slowly": "338d8fcbb3937ad28cbb8db328dfccc554d878335a22b062edf0ac4f5b4c4fe2",
-"T3W1_en_test_autolock.py::test_dryrun_locks_at_number_of_words": "2d8c02c91493cfe85614d9187df96b61bd1cb6b6a86b90a557829e7029eb54c4",
-"T3W1_en_test_autolock.py::test_dryrun_locks_at_word_entry": "8aa3aeb849e5bcff609c82349d303c2baed20c0ab07fced66ec3cb015d85ddd8",
+"T3W1_de_test_reset_slip39_advanced.py::test_reset_slip39_advanced[16of16]": "a29ff6d137dc44f13061939099e3b81a526c24e6d2e23edd80eb92a7e6dc79e5",
+"T3W1_de_test_reset_slip39_advanced.py::test_reset_slip39_advanced[2of2]": "890dd0a177cc6b03df1c66949bd4ef7425fec3f80d6f5fb0250ddb2e7648a763",
+"T3W1_de_test_reset_slip39_basic.py::test_reset_slip39_basic[16of16]": "4d757830537bd098319377626e98120f368fb966e036549237e455cecb28b943",
+"T3W1_de_test_reset_slip39_basic.py::test_reset_slip39_basic[1of1]": "5490fa0808bfbfdf22932d434b7506eb744d18f36690f84a41e00e8b75b8b268",
+"T3W1_en_test_autolock.py::test_autolock_does_not_interrupt_preauthorized": "8f6b00e00bfe3a62e191b4661ae17905632128bd60a7fd0b04ef556bd1e5beae",
+"T3W1_en_test_autolock.py::test_autolock_does_not_interrupt_signing": "46ba3f7ea5057bfc5fdd29e3ca88f20d7b9ad37acc18e4919df0fef631ea7c91",
+"T3W1_en_test_autolock.py::test_autolock_interrupts_passphrase": "5b226b2b6e93af7ce7dd270e2cf5ec85db2e8f3322527b3e312722585163e7e1",
+"T3W1_en_test_autolock.py::test_autolock_interrupts_signing": "d83a25bb097af2143701e57ecad31c9613824da56dc9131b306c776cefda73c2",
+"T3W1_en_test_autolock.py::test_autolock_passphrase_keyboard": "3b399561f9b0f0f2b0bb20a7f6d3ef90247de834b4d1703650a3f2c886b085ac",
+"T3W1_en_test_autolock.py::test_dryrun_enter_word_slowly": "1157c45c225925132b750249df4407f683ad7f8bee9887bddf3c56cd2d067abf",
+"T3W1_en_test_autolock.py::test_dryrun_locks_at_number_of_words": "a3b824fbe25e0608c2878596c450bca5f9e02fb08836d30702d65c823d91d1bc",
+"T3W1_en_test_autolock.py::test_dryrun_locks_at_word_entry": "8fa8b4cd2cbd01da06e2675481971f8b53a6f89376330bebfb5a2220868290bb",
 "T3W1_en_test_backup_slip39_custom.py::test_backup_slip39_custom[1of1]": "4c4bfa6297809c6796c3a6d91a60033c88bab9fe715c04c6825ee1c01e4a54e5",
 "T3W1_en_test_backup_slip39_custom.py::test_backup_slip39_custom[2of3]": "d05e83309f088dcfdedc95dc2645f5576b2346c119c1764c3b3f3a7e10c286fc",
 "T3W1_en_test_backup_slip39_custom.py::test_backup_slip39_custom[5of5]": "cce6de91cfd0ebd254a9f434ef6a4ba887adc05141cf2180c349c8d5c8198814",
@@ -27711,19 +27711,19 @@
 "T3W1_en_test_passphrase_bde.py::test_passphrase_long_spaces_deletion": "e5368762a236e111319ec02377e89d4a1cbd4530f34ef1516e7fd5fe699d495c",
 "T3W1_en_test_passphrase_bde.py::test_passphrase_loop_all_characters": "618b6f84b6c5d23474e9056df20bc9281f3fdf96737cc5736ea7f196e2893822",
 "T3W1_en_test_passphrase_bde.py::test_passphrase_prompt_disappears": "7f4987b8ccc7f52e6dce898d2cbe942775e8e2e6634d25e0178f2fc1c59bb040",
-"T3W1_en_test_pin.py::test_last_digit_timeout": "0ba1922ba06db29e4c623f06aabd7532b6690182c08266b0817717f822609e02",
+"T3W1_en_test_pin.py::test_last_digit_timeout": "2fb95454913de17ed0b4843175e754388f1df55f63e849d1accdd388e4667067",
 "T3W1_en_test_pin.py::test_pin_cancel": "30588036838efe4820591fe214107a86adf742a252fb5e71cee8337ef0df993e",
 "T3W1_en_test_pin.py::test_pin_change": "7fe25cb66920d88b0800320d94f766d6cf91dce498e8a495331322a58ba5b310",
-"T3W1_en_test_pin.py::test_pin_delete_hold": "d9884688f74c1210b829554a2b390e7d2e7019f89fb19c6c350ad71e0e3de3fc",
-"T3W1_en_test_pin.py::test_pin_empty_cannot_send": "cbb45ac8397772323b2cd54f01f94e7d7600de844c183531d86096a130c49240",
-"T3W1_en_test_pin.py::test_pin_incorrect": "bd94a8cff9fe147db77566061a5c78b85e0ec34c1e24083efae15cad087c80cd",
-"T3W1_en_test_pin.py::test_pin_long": "ec1b7e855f0dcd5e031b82607b8010acabe94fd1bc928695c5cb7c80cfca53a6",
-"T3W1_en_test_pin.py::test_pin_long_delete": "069dd87a43eac5606876043777c36d872753a4927b2c9fa48ff16f8194d49eec",
-"T3W1_en_test_pin.py::test_pin_longer_than_max": "cf56fcd67fa4a610a1b7d1e3599f5ac0f1c137771c77b05905da625bea50382f",
+"T3W1_en_test_pin.py::test_pin_delete_hold": "5ebebecad73f99b9203098172c38d09c6e063dfadefbb76f67c3459baca7ba29",
+"T3W1_en_test_pin.py::test_pin_empty_cannot_send": "95c15af9a1d1d7d7b0df68361c47eb63fe51c5da04a909c5219f6e00ed27de20",
+"T3W1_en_test_pin.py::test_pin_incorrect": "e334998b4352985123f4809c7a02ce996702611a0a46f930c06e9dfa24c18055",
+"T3W1_en_test_pin.py::test_pin_long": "f2c40854097a6ba33a36168ea3c6e46290d8f9f36b0471936e22a03c4d53ea4f",
+"T3W1_en_test_pin.py::test_pin_long_delete": "884037f0e884ab9969bafc9d939584e245455403350756a53e3c3376c91a3aeb",
+"T3W1_en_test_pin.py::test_pin_longer_than_max": "5dd8a3dcf00b22680b05d3a713df1910b468f5455489eec152cb605fa05f9b5b",
 "T3W1_en_test_pin.py::test_pin_same_as_wipe_code": "ddf37906762d6847f8c907ca33f017e5a85061e96caf50c7e6fe2ea2957b89b6",
 "T3W1_en_test_pin.py::test_pin_setup": "5a76cd466ae63a17928900ea099803ea731e25b63dcca0285f6bd03afb9a5fec",
 "T3W1_en_test_pin.py::test_pin_setup_mismatch": "a8b75f43d800e81d6de460a5e50430b76db63eed9211b15e74854102d2862689",
-"T3W1_en_test_pin.py::test_pin_short": "cbb45ac8397772323b2cd54f01f94e7d7600de844c183531d86096a130c49240",
+"T3W1_en_test_pin.py::test_pin_short": "95c15af9a1d1d7d7b0df68361c47eb63fe51c5da04a909c5219f6e00ed27de20",
 "T3W1_en_test_pin.py::test_wipe_code_same_as_pin": "0a2643cd8982ec6308fc44b18b162a6d13ba46dbb61f5b553a7db16e0d41e7cc",
 "T3W1_en_test_pin.py::test_wipe_code_setup": "3dfeb9d32f6e3443145d5f82101d4e9e2957414a1ca8fe6c204b8596f3799c77",
 "T3W1_en_test_recovery.py::test_recovery_bip39": "df34202f7312da7bdb1b5e945ad1e27bd5f5036265c7b9c23215b829f044ed4a",
@@ -27731,12 +27731,12 @@
 "T3W1_en_test_recovery.py::test_recovery_cancel_issue4613": "b85f916470c405499c2bbb2af19e8b5638d44bb51bfc313a7645eb64be380e4c",
 "T3W1_en_test_recovery.py::test_recovery_cancel_number_of_words": "7cb7a85bb1f40811d43ddfac2d22e00edcd74c44c06e4d0e639421e1e0b8c884",
 "T3W1_en_test_recovery.py::test_recovery_slip39_basic": "052a25a63c9114202f97cf2700e098214c9358b80beead5cb4426cd705c8b2f9",
-"T3W1_en_test_repeated_backup.py::test_repeated_backup": "0a8dcb648f0e54edcce6010bcb93800d14115f98bf3ab18f9427acc9c1a86261",
+"T3W1_en_test_repeated_backup.py::test_repeated_backup": "a6f6f6030b39d869e946e7c67bf05c5d2af8aacb03927234eb60a90e4b16b777",
 "T3W1_en_test_reset_bip39.py::test_reset_bip39": "b9b3da868372f943dc88007806e0c38d6ebaab82b0471d26b95f84875786f90e",
-"T3W1_en_test_reset_slip39_advanced.py::test_reset_slip39_advanced[16of16]": "8badb5bd7154045c51549553e8639a5345ea23d6388d97cedbb4437021c99233",
-"T3W1_en_test_reset_slip39_advanced.py::test_reset_slip39_advanced[2of2]": "7e87be2ad025e0d5eee97e7457ed0c32c4a318b31a24ce96d606930f67a7e29d",
-"T3W1_en_test_reset_slip39_basic.py::test_reset_slip39_basic[16of16]": "842adac30093193d106fa698e7d8cc9fc751494bc5726bdd2e57138751072fa6",
-"T3W1_en_test_reset_slip39_basic.py::test_reset_slip39_basic[1of1]": "0e0b9b277dddc4bbdf3978bcd281db6457defc422de5c5333dc42bdf748f75f8",
+"T3W1_en_test_reset_slip39_advanced.py::test_reset_slip39_advanced[16of16]": "df9eb6a69a9f9c529c427538586bce3ebf04b6be453e92c7bfa368862bdec5c9",
+"T3W1_en_test_reset_slip39_advanced.py::test_reset_slip39_advanced[2of2]": "614e0b5b99ce2ce0e82173877550cf72c1c7e1c4cc1c005c47cf92061d5529ed",
+"T3W1_en_test_reset_slip39_basic.py::test_reset_slip39_basic[16of16]": "713848843c11ae059f6f80f60642cae3f37ace40dd6d1b54caf85a1c8c0890b5",
+"T3W1_en_test_reset_slip39_basic.py::test_reset_slip39_basic[1of1]": "ca3601cba2cf7b5a667964d1dd1d198abd986347aeb62626df3164a6b5cf827a",
 "T3W1_es_test_autolock.py::test_autolock_does_not_interrupt_preauthorized": "1c598b053bb70fd0377b99a70fc8dce86f2d879fbaeb1ec20629fb847aaf6bb3",
 "T3W1_es_test_autolock.py::test_autolock_does_not_interrupt_signing": "4c7781432751a356fe83fbc7d7f3ebba2cab314026cfa454f11b76763b306abb",
 "T3W1_es_test_autolock.py::test_autolock_interrupts_passphrase": "da0c521ae527c9b53919bd49f6e5aeaf12fe61a8064f7684803472b160b7e270",
@@ -27783,12 +27783,12 @@
 "T3W1_es_test_recovery.py::test_recovery_cancel_issue4613": "1f51a07a5a7c46a57fa6f5684cddda03ee8557bfef6e755a3b9491227617f614",
 "T3W1_es_test_recovery.py::test_recovery_cancel_number_of_words": "a60037c5612369974db18f799834b8498ad7eda8b0de0c97bc7c96ba88241be8",
 "T3W1_es_test_recovery.py::test_recovery_slip39_basic": "d934a7b04fd24af74e83a9a061bed12df995909beeb1a03780143ca451a90f3f",
-"T3W1_es_test_repeated_backup.py::test_repeated_backup": "2d3892e79fabce04374d62a1732f9309896a31e9684d0e3ef769e87d9b2ed149",
+"T3W1_es_test_repeated_backup.py::test_repeated_backup": "52a01c1dfe48b977a12a82fcc74f4d8795ee3148d4b94e979ef913bd719d26ed",
 "T3W1_es_test_reset_bip39.py::test_reset_bip39": "8faa8e63fb0bfa4c3a02dceb6ec145ebb9d9e48fdc71cdaf9a741e67c5844bd7",
-"T3W1_es_test_reset_slip39_advanced.py::test_reset_slip39_advanced[16of16]": "f0b9d9dcdeb13f728e6761375e6dd181f3cbed417cf0999c5ca929fdab511b96",
-"T3W1_es_test_reset_slip39_advanced.py::test_reset_slip39_advanced[2of2]": "13e03a83aada941196f973a8f443816d9e703406718bc6d169e439a4f695636e",
-"T3W1_es_test_reset_slip39_basic.py::test_reset_slip39_basic[16of16]": "38f8596437dd6f4f6f26a0a36ff40412fb231a0938306694d0baa7d82f18e8bb",
-"T3W1_es_test_reset_slip39_basic.py::test_reset_slip39_basic[1of1]": "c5588d20c7a8a1740e1b9ceec71cec664732755b1993692bb2d9008f4c6edef1",
+"T3W1_es_test_reset_slip39_advanced.py::test_reset_slip39_advanced[16of16]": "2e79b909c27618d4f5a2b753921b285b03aea42cc72bc7ce277f3a2f3102fa40",
+"T3W1_es_test_reset_slip39_advanced.py::test_reset_slip39_advanced[2of2]": "2d527dc7c4f823e2fb368b23694c81ed0d4535bce7aca465f8a1926337242497",
+"T3W1_es_test_reset_slip39_basic.py::test_reset_slip39_basic[16of16]": "9ecb1891f75a150212ee08c0b18da47a5926c49319abd867f52bb14cca195efc",
+"T3W1_es_test_reset_slip39_basic.py::test_reset_slip39_basic[1of1]": "b109e89d979989345f2e1246d4398823f820626d49a1686fc5cd09514ad81b97",
 "T3W1_fr_test_autolock.py::test_autolock_does_not_interrupt_preauthorized": "f1e64d6522fdeddbae7592993d0ce9851b40bf1c9667fd4cfe3993a2f8884e4b",
 "T3W1_fr_test_autolock.py::test_autolock_does_not_interrupt_signing": "b3f3e9baf78ce0471f73e223ad3c177c5d3752f174d8e965f9bfd08575249045",
 "T3W1_fr_test_autolock.py::test_autolock_interrupts_passphrase": "21b36fe05fc56dec5d0f6cf8574bc2247f5a4bac83e6f15ff8004c68d9e0bc48",
@@ -27835,12 +27835,12 @@
 "T3W1_fr_test_recovery.py::test_recovery_cancel_issue4613": "873277079d3de2eeda988c1f2e84f2c92774c4376cc09af5a377dcb029b61c84",
 "T3W1_fr_test_recovery.py::test_recovery_cancel_number_of_words": "05b6b12ebc3bb175d3bb184e778b037e53815f7e6e9c70e80a6714cb8967cf18",
 "T3W1_fr_test_recovery.py::test_recovery_slip39_basic": "e56e9f3d36c87b218fbc231a88e0a0bfcc2af465779f4b06f5f8da370303d733",
-"T3W1_fr_test_repeated_backup.py::test_repeated_backup": "294efca0683c94034b6e311db762aed84c1affbceafbd79199d9e8c09baac9a6",
+"T3W1_fr_test_repeated_backup.py::test_repeated_backup": "7e673fa9af77ad39820d6d63206bbc85e71bb1ff3bbcdf4e1fa4091e8df0bc02",
 "T3W1_fr_test_reset_bip39.py::test_reset_bip39": "3804ee47caf2de46080aeb719e43a1d696582efc5fba550896ae538768c2d08a",
-"T3W1_fr_test_reset_slip39_advanced.py::test_reset_slip39_advanced[16of16]": "e228f1c79f3745d7b16c3c77c187f86ec8e30f50258747599ba09a15e7a449ab",
-"T3W1_fr_test_reset_slip39_advanced.py::test_reset_slip39_advanced[2of2]": "f806422f0db3f0ed71a9d99031154973965442276be280df582772ce26d5148a",
-"T3W1_fr_test_reset_slip39_basic.py::test_reset_slip39_basic[16of16]": "2ac8c2b3b82ae3811d0522230480314e10435a568a446b2d7e0aa4026d7af044",
-"T3W1_fr_test_reset_slip39_basic.py::test_reset_slip39_basic[1of1]": "9b0b1c5ee256afeb51786965a53c3a6e3d4418d166b70d6d9331d7519731d0dd",
+"T3W1_fr_test_reset_slip39_advanced.py::test_reset_slip39_advanced[16of16]": "133df0f5de2883a96d768d43e7855df44bfa2e0f6939b74d12e5f0698fe0afb9",
+"T3W1_fr_test_reset_slip39_advanced.py::test_reset_slip39_advanced[2of2]": "4bb204916aec0402d28568c34a7e465a4d01d02f7529bb72bcd14c49b3b79974",
+"T3W1_fr_test_reset_slip39_basic.py::test_reset_slip39_basic[16of16]": "626e932675789f8b9e14aa88f1a034b04be92209a14fdac84ca418e5f77f41ca",
+"T3W1_fr_test_reset_slip39_basic.py::test_reset_slip39_basic[1of1]": "92c2250e59e097bae7f313efd01698a1e97e9bbfe6a2723c0020ca6372d6e1f8",
 "T3W1_pt_test_autolock.py::test_autolock_does_not_interrupt_preauthorized": "12f446157532766c8f23559ab3f2815b66fb21f227c44d36a6981bfc4462aa17",
 "T3W1_pt_test_autolock.py::test_autolock_does_not_interrupt_signing": "047732cc381d52af8d4332deba77c407d194e68295c4d0434d2a4eaa94ce18e3",
 "T3W1_pt_test_autolock.py::test_autolock_interrupts_passphrase": "63ba964d3c79da5af019ec3456ed04fb806617cdfd5223c8a26a5f220c4a9667",
@@ -27887,12 +27887,12 @@
 "T3W1_pt_test_recovery.py::test_recovery_cancel_issue4613": "0a3d14424bf5c0cd0e2398243db8f43be27adb1e854907ec9453572be25b5e77",
 "T3W1_pt_test_recovery.py::test_recovery_cancel_number_of_words": "d1c8d3193e4ee24f3d2e6d6e4c0adc912bdffbafc5536c479d34d67ea59c1bce",
 "T3W1_pt_test_recovery.py::test_recovery_slip39_basic": "4835814cbb9ac470b60761593d1659daf85c8cbae08338a3775ac5393f13cec0",
-"T3W1_pt_test_repeated_backup.py::test_repeated_backup": "dd225c92159cee3011be90ff78006c75d59c29194bb50e1a4e71c9f77a1eb84b",
+"T3W1_pt_test_repeated_backup.py::test_repeated_backup": "7cdbc43cd2d5af9a908f3c5833015eae5f5d39f896d8a493cc4081d8d2d35c58",
 "T3W1_pt_test_reset_bip39.py::test_reset_bip39": "af7a93976d0596765da257d1726d28f50355578f42446fa01d840133b19de643",
-"T3W1_pt_test_reset_slip39_advanced.py::test_reset_slip39_advanced[16of16]": "bac90c0adc84869d03df5d443eb9b394804a2056b30f2f822fe2fd1ed69eca78",
-"T3W1_pt_test_reset_slip39_advanced.py::test_reset_slip39_advanced[2of2]": "354951b54f91e89b8c028ba81168fd378424ff66375615b4e47fc1fda5e40d7c",
-"T3W1_pt_test_reset_slip39_basic.py::test_reset_slip39_basic[16of16]": "dc4f382f1e01493d3e4bb1857430acf8a25206450088202c6b0acd90c8b9d2d7",
-"T3W1_pt_test_reset_slip39_basic.py::test_reset_slip39_basic[1of1]": "6e8e9ea5f8794bad9cc6dce57101331a41f541d47f8302ad9a297b580efa5e13"
+"T3W1_pt_test_reset_slip39_advanced.py::test_reset_slip39_advanced[16of16]": "ad52308dddcc82cc2f1ae6c4de02fbdf9cb30eaa296d5780b2f3b6d4e80db86b",
+"T3W1_pt_test_reset_slip39_advanced.py::test_reset_slip39_advanced[2of2]": "1cfe72300bb6b57b488b0326f9fcaca063e9401861881420f1e9a1d213d623a5",
+"T3W1_pt_test_reset_slip39_basic.py::test_reset_slip39_basic[16of16]": "a00e3c3f56218c8ce826845f76e0cb48de9a04b9d2bcdb3b3536a2831ddc494e",
+"T3W1_pt_test_reset_slip39_basic.py::test_reset_slip39_basic[1of1]": "3aea208d64eec8d8be88885d20d01cabfa039476a7504f9fe6bd56960fb3dfe8"
 },
 "device_tests": {
 "T3W1_cs_bitcoin-test_authorize_coinjoin.py::test_cancel_authorization": "ee3ee9195d37dc2e526ead58e99e5cf19b280820a8b8e1cc436f6b45bc1e1a80",
@@ -28944,11 +28944,11 @@
 "T3W1_cs_reset_recovery-test_recovery_slip39_basic_dryrun.py::test_2of3_dryrun": "27571e42cfda029291a64fe50f3c3ce13a63c1302d30c2d0a0983dff0f1bdc2a",
 "T3W1_cs_reset_recovery-test_recovery_slip39_basic_dryrun.py::test_2of3_invalid_seed_dryrun": "b58322109a48f308efda1d18678efdb5bfb7a8fadecc4f3b0047856d8681df5a",
 "T3W1_cs_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Bip39-backup_flow_bip39]": "77d6e3e18d611f5c55d20b6bb5591b3bcf22c2a4d366712ef77b6197e9ac7b9b",
-"T3W1_cs_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Advanced_Ext-10ea47d6": "6c162968320407503b11f9d4cd42b08d5e8a7cf1e46fcd145a9240f94f8b53bc",
-"T3W1_cs_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Basic_Extend-5dbe8b0f": "eb32333b25bf7ae813d2a28d52a72428ea96824a7f84c9700acaab586c4063c2",
+"T3W1_cs_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Advanced_Ext-10ea47d6": "7b25770b116995530773831bd935eea8bb6359500782823dde801c1f54bef6bd",
+"T3W1_cs_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Basic_Extend-5dbe8b0f": "cf40e74b53b97362ab47179bc52b250b34c0bb9923e56f5bb36b4e9878f2e7bd",
 "T3W1_cs_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Bip39-backup_flow_bip39]": "54e15e08c8b40f5a74e51ee52fa7adaa4c273c5cf68010009910dc5f5d31d599",
-"T3W1_cs_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Advanced_Extend-8b11c1dc": "16d2838e96d7fb7a59309b76535406c9d79c7eaa3e287c2ec42e04f94ab0927d",
-"T3W1_cs_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Basic_Extendabl-cc19e908": "fefdc68d9a17ca9033f71e9d646c45146428f623b4ffd78e315a414571c766de",
+"T3W1_cs_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Advanced_Extend-8b11c1dc": "2c8d7635638e97d39a6ff089a863bba020507c458e6b074d0b6cd51d7fca911b",
+"T3W1_cs_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Basic_Extendabl-cc19e908": "773d55c02b1212794d08393b060c631fcdfb4d64c1e3acd523eb2974b2e2c1e6",
 "T3W1_cs_reset_recovery-test_reset_bip39_t2.py::test_already_initialized": "487696ed61692e2cb0b87bf8b4ee55a838807142d6cee1435a75e760fb625d4a",
 "T3W1_cs_reset_recovery-test_reset_bip39_t2.py::test_entropy_check": "10f97d18ea74a9417b25929be532df023120954ce8e62ee3f159da165551fdb7",
 "T3W1_cs_reset_recovery-test_reset_bip39_t2.py::test_failed_pin": "16f609f27c1d16f1dd0231707980f11d1db55c69af268474014de2d8fdafde33",
@@ -28959,12 +28959,12 @@
 "T3W1_cs_reset_recovery-test_reset_bip39_t2.py::test_reset_entropy_check": "f0f9decd0629e7277ce190286579f577e582a34f0e303206a910abc8b7981baf",
 "T3W1_cs_reset_recovery-test_reset_bip39_t2.py::test_reset_failed_check": "b1cfe7e98335e111f620f0e6683ad4c24972b44ad0a3a860b9872bd1e139a3df",
 "T3W1_cs_reset_recovery-test_reset_recovery_bip39.py::test_reset_recovery": "e9be5e6269e3c1a8459fec74be4e5f04915ae08324727c52e31fbff94bea7fb4",
-"T3W1_cs_reset_recovery-test_reset_recovery_slip39_advanced.py::test_reset_recovery": "c026998cdefc69f70cb9c83aeb29785c0867fd16c42c88e6cfa8ad5a3af7e047",
-"T3W1_cs_reset_recovery-test_reset_recovery_slip39_basic.py::test_reset_recovery": "7cdd40d7fc665837efcd8a0e29b88881505b16946c51ca79d89942136252f2f3",
-"T3W1_cs_reset_recovery-test_reset_slip39_advanced.py::test_reset_device_slip39_advanced": "62a1628aa3b115cfa3c5a2a937ef45822e6163cbe33a5ce57d142f6febb356fd",
-"T3W1_cs_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic": "b1ca2ecc902a68e4cd17dcb62972facea14ad99f8118078fe13193e9a34c125a",
-"T3W1_cs_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic_256": "78f187c6deffb2b8373aee5210a066ca4aa572ce157244bc40c212812bcd3ef8",
-"T3W1_cs_reset_recovery-test_reset_slip39_basic.py::test_reset_entropy_check": "c758a08c556a8449d8187e3359a0fde32f63ec99aecf185ba749bb38f44fc5a7",
+"T3W1_cs_reset_recovery-test_reset_recovery_slip39_advanced.py::test_reset_recovery": "fc54e4c3961d4bace91aa00797c6129f4e595de56cd938874546d79c1e13c48e",
+"T3W1_cs_reset_recovery-test_reset_recovery_slip39_basic.py::test_reset_recovery": "39c9813cb9141e5b989d58cbafa16d19666664c7361c2198354ce85b53b40c9c",
+"T3W1_cs_reset_recovery-test_reset_slip39_advanced.py::test_reset_device_slip39_advanced": "f2e4e8dab1fa36507f340b3aee10b0bb0468230957f9b8b068300852929cbb59",
+"T3W1_cs_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic": "2bd6db06581a376d011ec2a1a647c00e0bdcb203df4f73945602559f7440c5a0",
+"T3W1_cs_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic_256": "cfe317317d866c91ff6f2343f40571e55488aa4d16c98d41328cccd5966cec5c",
+"T3W1_cs_reset_recovery-test_reset_slip39_basic.py::test_reset_entropy_check": "0583982f713806dee23b71deb84bd506cdbe4a3d24a4f6370e40d2517001faba",
 "T3W1_cs_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-0h-0-0-rNaqKtKrMSwpwZSzRckPf-3321e5d1": "c72606c81f6018aa236c207e48be8c6cd1a983857767c75906157f7e8618c0ff",
 "T3W1_cs_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-0h-0-1-rBKz5MC2iXdoS3XgnNSYm-fd75b415": "2e08abcaa7666ba4f39900ef166dcc344e5c676efef0c54dcf05497457b37dfb",
 "T3W1_cs_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-1h-0-0-rJX2KwzaLJDyFhhtXKi3h-af5daf0f": "4be39fddf1be277647ff7e74c8fd2c6fc35907a107c4eeb362886592c1bf3385",
@@ -29188,10 +29188,10 @@
 "T3W1_cs_test_msg_applysettings.py::test_label_too_long": "487696ed61692e2cb0b87bf8b4ee55a838807142d6cee1435a75e760fb625d4a",
 "T3W1_cs_test_msg_applysettings.py::test_safety_checks": "621f291886bce2a637c49e8264095b3cd73e10d87cd22b095a392e5aff3c1cea",
 "T3W1_cs_test_msg_backup_device.py::test_backup_bip39": "28410ef0d79e4a38ef7e2876a22eea4eff004841b676d5b8e9d7f9a896e3c8b0",
-"T3W1_cs_test_msg_backup_device.py::test_backup_slip39_advanced[click_info]": "be427075753ec408484ef918f5fc13def259c268209ed45765e5cf944ab7ae8b",
-"T3W1_cs_test_msg_backup_device.py::test_backup_slip39_advanced[no_click_info]": "d2033c8ce78a23cf8848eaa9adb57365a16fbd9fc5db00f0b77f4746bc70fe3d",
-"T3W1_cs_test_msg_backup_device.py::test_backup_slip39_basic[click_info]": "3aee2a79bb1eb70ca23bcd8df902706c6812898336f58ba78d62f34d309fcb9e",
-"T3W1_cs_test_msg_backup_device.py::test_backup_slip39_basic[no_click_info]": "ed691ac7fa28582c02f3434acd1bd4948238443c799487499c8a6afe58b16222",
+"T3W1_cs_test_msg_backup_device.py::test_backup_slip39_advanced[click_info]": "2d710f114ac41c3c3307137caf5fbea16a08b1fa890c426f5dcf6c83d73a586f",
+"T3W1_cs_test_msg_backup_device.py::test_backup_slip39_advanced[no_click_info]": "2a487ad75a3bfe33bcf26a00aee48dee3a4389bb3ca5a21c92def83836ae0f88",
+"T3W1_cs_test_msg_backup_device.py::test_backup_slip39_basic[click_info]": "1b23b96bcb561553ab5b1b0adce76baf16c144cd89b5a9af4f66af2a44533720",
+"T3W1_cs_test_msg_backup_device.py::test_backup_slip39_basic[no_click_info]": "ecdaec496ae003d1ec12534eaa9342ed3aec5d3972266bd512d28fbea534e3f6",
 "T3W1_cs_test_msg_backup_device.py::test_backup_slip39_custom[1_of_1]": "2da65cdca5c4cc47d99b3109ec724aa10e640f4c01f49a709e9d61dd4a65387e",
 "T3W1_cs_test_msg_backup_device.py::test_backup_slip39_custom[2_of_2]": "2f60a0b773ed05efaf22d91dba1887cfb8badc89b7f2b3b07a583e259eab2935",
 "T3W1_cs_test_msg_backup_device.py::test_backup_slip39_custom[3_of_5]": "78a87ea7be668472623294b87764394f7c023ecb5db14b41f73338e37e3e3f79",
@@ -29241,10 +29241,10 @@
 "T3W1_cs_test_protection_levels.py::test_unlocked": "e1e4f0ade21261d5d54a2adfdebbb5601146690a74c8e7edf112ffdc05803d16",
 "T3W1_cs_test_protection_levels.py::test_verify_message_t2": "159a926c076509a18a2a234f834888b487ab4f5f6b80ca20e7cd457dfabca1e0",
 "T3W1_cs_test_protection_levels.py::test_wipe_device": "6c6042670dbe115f0cbeb8ca5f565fd4e705fe1b970fed30b6f6cc6b552b2e09",
-"T3W1_cs_test_repeated_backup.py::test_repeated_backup": "a16d1e6d345cb0427ab144d64fcaa3fd08ab0242432c8ba4de389f6f2a1f1010",
-"T3W1_cs_test_repeated_backup.py::test_repeated_backup_cancel": "83b70ccedab5e153280d5cd33196c45fbf3adcc58585e61b1bef9d74400a1bb2",
-"T3W1_cs_test_repeated_backup.py::test_repeated_backup_send_disallowed_message": "83b70ccedab5e153280d5cd33196c45fbf3adcc58585e61b1bef9d74400a1bb2",
-"T3W1_cs_test_repeated_backup.py::test_repeated_backup_upgrade_single": "76b416b636d8b9a1190c306709cebc713ddee0e226f4924e6af2b88d785adba4",
+"T3W1_cs_test_repeated_backup.py::test_repeated_backup": "b440cb7ab183a9e8d06f37cf878b96d47ac3b2568884946f46aad2dc662cf91d",
+"T3W1_cs_test_repeated_backup.py::test_repeated_backup_cancel": "88aca2102ccd2420c1367f3ee1c8af6ded44131a05de13478f6cd4d907035a6a",
+"T3W1_cs_test_repeated_backup.py::test_repeated_backup_send_disallowed_message": "88aca2102ccd2420c1367f3ee1c8af6ded44131a05de13478f6cd4d907035a6a",
+"T3W1_cs_test_repeated_backup.py::test_repeated_backup_upgrade_single": "182ea71a4ac22b03707e6b7c51a0ec7211be25fe70214e9a9d413656b1c38568",
 "T3W1_cs_test_session.py::test_cannot_resume_ended_session": "487696ed61692e2cb0b87bf8b4ee55a838807142d6cee1435a75e760fb625d4a",
 "T3W1_cs_test_session.py::test_clear_session": "680fa08cd7ca7a525b9ef5ace970c89bc80a8181a90ff6674a37554a2d7a7e53",
 "T3W1_cs_test_session.py::test_derive_cardano_empty_session": "487696ed61692e2cb0b87bf8b4ee55a838807142d6cee1435a75e760fb625d4a",
@@ -30343,11 +30343,11 @@
 "T3W1_de_reset_recovery-test_recovery_slip39_basic_dryrun.py::test_2of3_dryrun": "64fa1d34dab36d3caafd6c9881fcbfcb778bf1d4af021761176b5af1afcc009f",
 "T3W1_de_reset_recovery-test_recovery_slip39_basic_dryrun.py::test_2of3_invalid_seed_dryrun": "e8fdc3e013aec2afe0dcfe9e27de3f265a20e5e8378112f74f55c157355047b0",
 "T3W1_de_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Bip39-backup_flow_bip39]": "a81f6917469b8a140e8e4d5c9811c601ea97ac15601eba2bc92f0155815f023f",
-"T3W1_de_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Advanced_Ext-10ea47d6": "6db45a03a43b3b0a4f5ecd40f798e2931fa2fd3212cab1d95466bf1eddc56b47",
-"T3W1_de_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Basic_Extend-5dbe8b0f": "611e713d6b7740edd112c8031f6e7d4b80ad757a168a185ce74e661c281e0ef1",
+"T3W1_de_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Advanced_Ext-10ea47d6": "638fd6b358fc9298f5bc59f758060662c199f9efac3dcbffa81e1346915e4d7e",
+"T3W1_de_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Basic_Extend-5dbe8b0f": "26714e5c3cb45d60d2aba54f637575a0563b6e4290653e75938e32f1d690d657",
 "T3W1_de_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Bip39-backup_flow_bip39]": "2828d4a2a24645896a12014a3342a76f6a8893e0d0d67dd563aa6ba061c4f074",
-"T3W1_de_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Advanced_Extend-8b11c1dc": "1b1f1cf559a46a6a21bb7019ae5f1401c0f91f6364583c70d929e702aff2a4a4",
-"T3W1_de_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Basic_Extendabl-cc19e908": "4b1e820e1d6861fa406ba545e3684975d0eb6fff733f65e5e63bb2971eaf2d15",
+"T3W1_de_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Advanced_Extend-8b11c1dc": "0049a611a5831e8f3cb132fc9abf989aff195044fbebdb3a4f607500958469ae",
+"T3W1_de_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Basic_Extendabl-cc19e908": "d7f7fbe0372a3e24bbded56c91cd8eb7a37555c1952c238a9af23151c8d87830",
 "T3W1_de_reset_recovery-test_reset_bip39_t2.py::test_already_initialized": "552f1e7fde5b98638390d047acae8753c947b8881c26fafaa247c1ee0cf46a0f",
 "T3W1_de_reset_recovery-test_reset_bip39_t2.py::test_entropy_check": "5875d5cbf18ccb988fa5f0dd864ac5e4e95e6a8ae66af08989327643b9254947",
 "T3W1_de_reset_recovery-test_reset_bip39_t2.py::test_failed_pin": "747285cb5935cbc82ed161ed8ba001295c267d35513b84f804a6de505c53e727",
@@ -30358,12 +30358,12 @@
 "T3W1_de_reset_recovery-test_reset_bip39_t2.py::test_reset_entropy_check": "f9299617f64689bbc975d355e8e634a2d47d3f1931dfeb0e3ac56e3bb4b188e3",
 "T3W1_de_reset_recovery-test_reset_bip39_t2.py::test_reset_failed_check": "7283b18dd6447e3f4602475945b324b91ea836da500076938787e545d601794e",
 "T3W1_de_reset_recovery-test_reset_recovery_bip39.py::test_reset_recovery": "6512defa37b8187dbfc0769103ad85a443a2fb25605057e5c4c992da8bc95317",
-"T3W1_de_reset_recovery-test_reset_recovery_slip39_advanced.py::test_reset_recovery": "6402433bf0457e10faa1361b812286d84e70712850e8b2ddd00e3a8c48478b46",
-"T3W1_de_reset_recovery-test_reset_recovery_slip39_basic.py::test_reset_recovery": "72c31d271fbe8ebec2f5ee63e92d6fb0140728e54bec1c8ae7b597eb25c960e5",
-"T3W1_de_reset_recovery-test_reset_slip39_advanced.py::test_reset_device_slip39_advanced": "9e95551e8c9179d42b1e247291b6442d5a1500848a803af469852cda98ea9254",
-"T3W1_de_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic": "9e8633652e7a967ca88dc5950e52df025de0485f039b446da0ad71130971d5cf",
-"T3W1_de_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic_256": "a322ab14db2b97731cc4768f4cf3571568d90c83cd54be2882b6e098e9b0dd7a",
-"T3W1_de_reset_recovery-test_reset_slip39_basic.py::test_reset_entropy_check": "b933faa97cce1597067c9a0effad62461f371423bea7e8cd9e33e168da992862",
+"T3W1_de_reset_recovery-test_reset_recovery_slip39_advanced.py::test_reset_recovery": "d7d45fcccd6c105b151fefc140b94f866eec681297d0fe04c3f8171b89b96a7f",
+"T3W1_de_reset_recovery-test_reset_recovery_slip39_basic.py::test_reset_recovery": "7750406989b00ead996b2f89835a69c782ba5b25369534761b189c3455ed72a5",
+"T3W1_de_reset_recovery-test_reset_slip39_advanced.py::test_reset_device_slip39_advanced": "1ae67daa2598a1548131210c3b84a761b64a24ee77b1fcf9a820e41abdda5e15",
+"T3W1_de_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic": "ded26ecdca461f09301c89b70eb70d8db4d900b9512d587d72ea9f8b1b5c5203",
+"T3W1_de_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic_256": "38565df884701c60b6626486a3da45c83bead60d7f447c27f59e8b69b8d97d73",
+"T3W1_de_reset_recovery-test_reset_slip39_basic.py::test_reset_entropy_check": "27b67be592f08ef1c9581ac3610c019cb0c864d6550b842f06e1d2661e8e4a27",
 "T3W1_de_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-0h-0-0-rNaqKtKrMSwpwZSzRckPf-3321e5d1": "7c1e55fe1afe55d4c25fb2e87c59c12ead7a3fc9b8afaa98628376d500b6f672",
 "T3W1_de_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-0h-0-1-rBKz5MC2iXdoS3XgnNSYm-fd75b415": "7efe517254dda482da5cebcb7364a03fdb921820e9ecbc0535a4293714ad2fc8",
 "T3W1_de_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-1h-0-0-rJX2KwzaLJDyFhhtXKi3h-af5daf0f": "20ce3a2c9340faab826fcf7b79dc3cd1fda601913d5ff010b18de9df567572c0",
@@ -30587,10 +30587,10 @@
 "T3W1_de_test_msg_applysettings.py::test_label_too_long": "552f1e7fde5b98638390d047acae8753c947b8881c26fafaa247c1ee0cf46a0f",
 "T3W1_de_test_msg_applysettings.py::test_safety_checks": "d6cffd0e54208eace1550b6be0c60411cb28c6f843e6c3bc1c5bddf024436013",
 "T3W1_de_test_msg_backup_device.py::test_backup_bip39": "944a897c6787ecb83e2801e5dfb128c3340b39d629f4ba328726a7b119582f78",
-"T3W1_de_test_msg_backup_device.py::test_backup_slip39_advanced[click_info]": "229f548b254bc02192fbbc5c4118d4fad05c0f93ea1f416bc4e0e6d0fc2dccb3",
-"T3W1_de_test_msg_backup_device.py::test_backup_slip39_advanced[no_click_info]": "4a44fa3085e44892a6ee1636346465ced4a77feeabaf27cf408ca55360312315",
-"T3W1_de_test_msg_backup_device.py::test_backup_slip39_basic[click_info]": "51e347b7677eba2403d4c45646942e8cc9623d01604aeb86ab6ca91fed649367",
-"T3W1_de_test_msg_backup_device.py::test_backup_slip39_basic[no_click_info]": "0bef7c272f675bb1a94ee7ecea8a612501c5f68b42dab6b45f43caf89cb41f6e",
+"T3W1_de_test_msg_backup_device.py::test_backup_slip39_advanced[click_info]": "b6810391c3ebfbd8ba30ba62b2fcdc4f5de0c10f355c8fbcb86f604052e1dc4a",
+"T3W1_de_test_msg_backup_device.py::test_backup_slip39_advanced[no_click_info]": "cdfab139fed95e0d0c6762489a688ee4335c4434e0efa942df565d267ee7e868",
+"T3W1_de_test_msg_backup_device.py::test_backup_slip39_basic[click_info]": "2e892d72bc1dfa7c9396523e7a1221593bbd1156b434e8aeb7a24f549fc21957",
+"T3W1_de_test_msg_backup_device.py::test_backup_slip39_basic[no_click_info]": "264460f7c8d3f61716f22f4af8a1bbe14e5263677ff029dbf9b792363c8919f9",
 "T3W1_de_test_msg_backup_device.py::test_backup_slip39_custom[1_of_1]": "d64c419ef5d1dabd294a62907e0676779f11a80761d014c28223686bf70234ba",
 "T3W1_de_test_msg_backup_device.py::test_backup_slip39_custom[2_of_2]": "f2461a909c21c65b12e7545d08b866a9f04a9ba4d1f4b48875e28220d3edea4e",
 "T3W1_de_test_msg_backup_device.py::test_backup_slip39_custom[3_of_5]": "a20c102a8f11521a83a41fd7d515bef3df90fd3e515bd8b74132eab68a4021cd",
@@ -30640,10 +30640,10 @@
 "T3W1_de_test_protection_levels.py::test_unlocked": "76d002810bebd6dcb93c60ff8bd59f849b0d3aa4ba90d966b6466006e495be0b",
 "T3W1_de_test_protection_levels.py::test_verify_message_t2": "0588f6b765cfd5b78d02a4135a67eb5439ed3dd8d81009a5f571a97b063ddc5a",
 "T3W1_de_test_protection_levels.py::test_wipe_device": "fc35c57f06f33055ac15af5d6664f53446301e9e26a0428a2c35674caf855d73",
-"T3W1_de_test_repeated_backup.py::test_repeated_backup": "0e4f365c6632e0afd21bf032d2895370ffb2714036a8d064d82c447197dfa3db",
-"T3W1_de_test_repeated_backup.py::test_repeated_backup_cancel": "1bebc33a44ef2aecdc1c037eb7cc7c367b8441778dcca57c625726cbe54ad82c",
-"T3W1_de_test_repeated_backup.py::test_repeated_backup_send_disallowed_message": "1bebc33a44ef2aecdc1c037eb7cc7c367b8441778dcca57c625726cbe54ad82c",
-"T3W1_de_test_repeated_backup.py::test_repeated_backup_upgrade_single": "030326c21136ab578b0d05834a2ea07dd319ee01140142771cd4ff2381c136e7",
+"T3W1_de_test_repeated_backup.py::test_repeated_backup": "f147e277acf80a0b484a717c0f1b1da110c31a8430f7a3ba5b54b150288202e6",
+"T3W1_de_test_repeated_backup.py::test_repeated_backup_cancel": "bfa6cefd6cc3e539e097c1987b36f43f006a1fe49fe017d0b672c89bb1720c87",
+"T3W1_de_test_repeated_backup.py::test_repeated_backup_send_disallowed_message": "bfa6cefd6cc3e539e097c1987b36f43f006a1fe49fe017d0b672c89bb1720c87",
+"T3W1_de_test_repeated_backup.py::test_repeated_backup_upgrade_single": "c8430ecdebaf05bf285c484d7635c90d8719c4010cd862a7292e54b625cb91e6",
 "T3W1_de_test_session.py::test_cannot_resume_ended_session": "552f1e7fde5b98638390d047acae8753c947b8881c26fafaa247c1ee0cf46a0f",
 "T3W1_de_test_session.py::test_clear_session": "f6c74499e52b45f30dbb6898eec2b23f1b06c9ac8276771fc8cde3ac5b1ea1f1",
 "T3W1_de_test_session.py::test_derive_cardano_empty_session": "552f1e7fde5b98638390d047acae8753c947b8881c26fafaa247c1ee0cf46a0f",
@@ -31742,11 +31742,11 @@
 "T3W1_en_reset_recovery-test_recovery_slip39_basic_dryrun.py::test_2of3_dryrun": "b0e38fce3c0a6ec816611085560515eb3fbb4e87ae844ccfc76fa2d8012594e4",
 "T3W1_en_reset_recovery-test_recovery_slip39_basic_dryrun.py::test_2of3_invalid_seed_dryrun": "dc86a85a80859c2e82456fc60820c4c4d6c51bbcc5bb79bd69b46e9b60a743f2",
 "T3W1_en_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Bip39-backup_flow_bip39]": "3896a42a6f2d7fa1e0c12e8c75443b9e1a4c96c7ef885d1d8e4776d15d8f30c9",
-"T3W1_en_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Advanced_Ext-10ea47d6": "473d465b4a396156bdbc5f4a8b3075547749b6494067cae8cccff0bf7fe8e8e5",
-"T3W1_en_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Basic_Extend-5dbe8b0f": "5bca0ffd7b9b044eb7a1a9a2115a7401802253d528d73ca463c067b807787c48",
+"T3W1_en_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Advanced_Ext-10ea47d6": "e2a15a01c1dda9788abbac6b96203bb33c6a4079e88520f814946708f1e20713",
+"T3W1_en_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Basic_Extend-5dbe8b0f": "40e4330c266b2a30746222540581edefc0f4269b19c49a81ff530576eb637592",
 "T3W1_en_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Bip39-backup_flow_bip39]": "6d077b35e4f672b43fdd09aa37896b75e3e0652bdd81e503068a3fbc0854f9f3",
-"T3W1_en_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Advanced_Extend-8b11c1dc": "d850a672b9e8e77f48e51fbf11310446ca401f07d765ea3d804d32d9209538ab",
-"T3W1_en_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Basic_Extendabl-cc19e908": "23b6ea8f094d522d4956508b0555d7f6676a3b8b026a1458cffe3656f2908708",
+"T3W1_en_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Advanced_Extend-8b11c1dc": "964e2e3b66d9586844101215f80e5f5e2ce2dae58530667ab886f93d524862b0",
+"T3W1_en_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Basic_Extendabl-cc19e908": "a884a626d5538997f72ea3dde4b91a4bfb515aea79c5214fc6d0fff709ab310d",
 "T3W1_en_reset_recovery-test_reset_bip39_t2.py::test_already_initialized": "4ccd52f30548e0528c1a4dcf0c622b1545b471faf292f482e95fe5cebb634473",
 "T3W1_en_reset_recovery-test_reset_bip39_t2.py::test_entropy_check": "0f97d40738b0daf5f95180614e7537cb7a990ad4e394a4807aa734060b9de123",
 "T3W1_en_reset_recovery-test_reset_bip39_t2.py::test_failed_pin": "00c69330b3284bb41716818d9ecbaef8176e4621c8d026aa9e3882ba97de6eb4",
@@ -31757,12 +31757,12 @@
 "T3W1_en_reset_recovery-test_reset_bip39_t2.py::test_reset_entropy_check": "932286b7db7a9531c15f6128a9550a4de7af781d20acc4689482e8cee5a0407f",
 "T3W1_en_reset_recovery-test_reset_bip39_t2.py::test_reset_failed_check": "d71c2a35175671648d853f4873b4827495e1461b3789a8602c5f85e1e0f5b8a2",
 "T3W1_en_reset_recovery-test_reset_recovery_bip39.py::test_reset_recovery": "726743e63a9de0eb31314336a63181d0891ce75fa1d81b7798eff86fec6deab5",
-"T3W1_en_reset_recovery-test_reset_recovery_slip39_advanced.py::test_reset_recovery": "69c9f59617bff98bd9f5e8d16227abeb4454290e410ba548a455964fa1b635a5",
-"T3W1_en_reset_recovery-test_reset_recovery_slip39_basic.py::test_reset_recovery": "190a2b0b86386ed43dc1c5448f2c2550f8a4fca293360d804d0091e42755e207",
-"T3W1_en_reset_recovery-test_reset_slip39_advanced.py::test_reset_device_slip39_advanced": "766692261bdd278e7cf21a25304fbba81d592f053dc10c36f0ef0c89c40e0454",
-"T3W1_en_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic": "530a60e985598975106a07d5808d1f456faba646fce1409fa4cd95d878d370e6",
-"T3W1_en_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic_256": "fde1d2c093a54daea91116c829e4469ed6d19388115985655fe200bcd9fe2822",
-"T3W1_en_reset_recovery-test_reset_slip39_basic.py::test_reset_entropy_check": "0e48fc9a8305f0daa395dec08208367de0925838b22e0bf059592c05130a1ca0",
+"T3W1_en_reset_recovery-test_reset_recovery_slip39_advanced.py::test_reset_recovery": "4ef63a2ce8fd3e25bc1b301c08ba0ed25c2261b251051f2d8136c2026c1cd52b",
+"T3W1_en_reset_recovery-test_reset_recovery_slip39_basic.py::test_reset_recovery": "c0c512c0918c299dc7e4e843b76911657137ed7786a994a21c13c54c71dbd432",
+"T3W1_en_reset_recovery-test_reset_slip39_advanced.py::test_reset_device_slip39_advanced": "d11c6c46b9e11349d5bf1c6561209cf898f6338d8a098b8bc00d434a6104aa67",
+"T3W1_en_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic": "c8cc4a5a6ce0a8c4f523aa9ebc3cbe65616c5ba897b592a8d2cd23caaa5088ff",
+"T3W1_en_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic_256": "8501f82c2bb9191d9e2a2031d0ac6b1edc4c0b913d9802980d36071c8f50692d",
+"T3W1_en_reset_recovery-test_reset_slip39_basic.py::test_reset_entropy_check": "6b869b492281cdef747ae345b2059bd60c6e7da89dcf062a3b75621e424c079b",
 "T3W1_en_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-0h-0-0-rNaqKtKrMSwpwZSzRckPf-3321e5d1": "b9b6448147585fa11b46d03cc3392fd3a81cb8105b68312f9f54a7d301c7f95b",
 "T3W1_en_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-0h-0-1-rBKz5MC2iXdoS3XgnNSYm-fd75b415": "b73e76d934bfa88a68bcffed3408b05d58f1a4d01b4d216584bdddab228ae11e",
 "T3W1_en_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-1h-0-0-rJX2KwzaLJDyFhhtXKi3h-af5daf0f": "49bfc8e937e86338b45e2a04fea0354644a2c2e21ee50a9f67f5e019f5b3477c",
@@ -31917,22 +31917,22 @@
 "T3W1_en_test_authenticate_device.py::test_authenticate_device[\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\-d824e03c": "5891c5a3f53afe7d5f6d30396dd6ee5057367a2fd3214fcf89c95c4116df1ec3",
 "T3W1_en_test_authenticate_device.py::test_authenticate_device[]": "5891c5a3f53afe7d5f6d30396dd6ee5057367a2fd3214fcf89c95c4116df1ec3",
 "T3W1_en_test_authenticate_device.py::test_authenticate_device[hello world]": "5891c5a3f53afe7d5f6d30396dd6ee5057367a2fd3214fcf89c95c4116df1ec3",
-"T3W1_en_test_autolock.py::test_apply_auto_lock_delay": "dfea4928169fbffd3d5facc71387aaf1dceb1b24c16da3dc8e736bdf7b0d1903",
+"T3W1_en_test_autolock.py::test_apply_auto_lock_delay": "60a93048ad956bdf15ad3f2c89407710a4633f2872560470e7b4a070de8e3d7e",
 "T3W1_en_test_autolock.py::test_apply_auto_lock_delay_out_of_range[0]": "05c0b0781bc050ec1e0a4229dce5c4cdf212dbdde6517fe773b797c1222a683e",
 "T3W1_en_test_autolock.py::test_apply_auto_lock_delay_out_of_range[1]": "05c0b0781bc050ec1e0a4229dce5c4cdf212dbdde6517fe773b797c1222a683e",
 "T3W1_en_test_autolock.py::test_apply_auto_lock_delay_out_of_range[4194304]": "05c0b0781bc050ec1e0a4229dce5c4cdf212dbdde6517fe773b797c1222a683e",
 "T3W1_en_test_autolock.py::test_apply_auto_lock_delay_out_of_range[536871]": "05c0b0781bc050ec1e0a4229dce5c4cdf212dbdde6517fe773b797c1222a683e",
 "T3W1_en_test_autolock.py::test_apply_auto_lock_delay_out_of_range[9]": "05c0b0781bc050ec1e0a4229dce5c4cdf212dbdde6517fe773b797c1222a683e",
-"T3W1_en_test_autolock.py::test_apply_auto_lock_delay_valid[10]": "07986bc2f5dce0835a49f5d24866afaae074d25c0fdcbcf3dcca1fdccd55068e",
-"T3W1_en_test_autolock.py::test_apply_auto_lock_delay_valid[123]": "241ee43e2aa9649fdcefa6b4dc474c1304439368d66611eab7b4d69f3e9b0b8c",
-"T3W1_en_test_autolock.py::test_apply_auto_lock_delay_valid[3601]": "8e33e07e1e3f4def3d6e88d303dda75b1ee4f7e22632046ad19023e3357f1904",
-"T3W1_en_test_autolock.py::test_apply_auto_lock_delay_valid[536870]": "405974e672e045540a23a7c8c0090d171e3d586194fa1e8527c75e65e95eb0a7",
-"T3W1_en_test_autolock.py::test_apply_auto_lock_delay_valid[60]": "c39918b6f92d929b535cf0ff02ef5d22b53b2081fb6acbd092aa4e6c2b18fd39",
-"T3W1_en_test_autolock.py::test_apply_auto_lock_delay_valid[7227]": "6bbd2a4ef197b3679661d2ac4d1204788be462d3c72566ae009de550920bda71",
-"T3W1_en_test_autolock.py::test_autolock_cancels_ui": "1297c033f1c91fd56d498f04fd6ce4a31d00418ca89c9d7bceedcc839b393011",
+"T3W1_en_test_autolock.py::test_apply_auto_lock_delay_valid[10]": "00712490a3c8d26e69d147f4e1eb6bd94288794eb0f43f54e90000a48240d62e",
+"T3W1_en_test_autolock.py::test_apply_auto_lock_delay_valid[123]": "d38f9d9c68731227a89aeabcfb357487af0118291bbcc7ab09bda46810d34da8",
+"T3W1_en_test_autolock.py::test_apply_auto_lock_delay_valid[3601]": "b3f3261846077d0804d53a0074fe4815f7891e431da57ee8beb90c78fc7625dd",
+"T3W1_en_test_autolock.py::test_apply_auto_lock_delay_valid[536870]": "916edc1115b2b7dab6f680a534db7d0edbcd001c782f809b66b5546c22eb8dac",
+"T3W1_en_test_autolock.py::test_apply_auto_lock_delay_valid[60]": "740a34fee21ab8585f96e0aafc69c8dee3ea365345183e50a09d95c5bc7a38c5",
+"T3W1_en_test_autolock.py::test_apply_auto_lock_delay_valid[7227]": "bf1c12ae3a4f53a418140d4f691b050189c0388c4268ad04488dbf085d1919a5",
+"T3W1_en_test_autolock.py::test_autolock_cancels_ui": "06f55fe34c36c6e46789584588f7a2a73c81bfc21546e4029d84d7c694f7c1b5",
 "T3W1_en_test_autolock.py::test_autolock_default_value": "43567b6b51cb9d9342868d30ba4f4c501a63c73faebe4c7daa46a53f346010e7",
-"T3W1_en_test_autolock.py::test_autolock_ignores_getaddress": "71e8be1ea9a03058eb64dba47d3900550b499f6b861ba87be54525ccfa518c27",
-"T3W1_en_test_autolock.py::test_autolock_ignores_initialize": "71e8be1ea9a03058eb64dba47d3900550b499f6b861ba87be54525ccfa518c27",
+"T3W1_en_test_autolock.py::test_autolock_ignores_getaddress": "dc08ec6a28a59a04f145275f0701b071f71259761d4f1762c4f42ca6d81a23dc",
+"T3W1_en_test_autolock.py::test_autolock_ignores_initialize": "dc08ec6a28a59a04f145275f0701b071f71259761d4f1762c4f42ca6d81a23dc",
 "T3W1_en_test_basic.py::test_capabilities": "4ccd52f30548e0528c1a4dcf0c622b1545b471faf292f482e95fe5cebb634473",
 "T3W1_en_test_basic.py::test_device_id_different": "94902c0dd26a33c27104db14dbbe3a216cc26642f49868e4597dd9efca094aa9",
 "T3W1_en_test_basic.py::test_device_id_same": "4ccd52f30548e0528c1a4dcf0c622b1545b471faf292f482e95fe5cebb634473",
@@ -31986,10 +31986,10 @@
 "T3W1_en_test_msg_applysettings.py::test_label_too_long": "4ccd52f30548e0528c1a4dcf0c622b1545b471faf292f482e95fe5cebb634473",
 "T3W1_en_test_msg_applysettings.py::test_safety_checks": "9404219ed9280a6c34bc6e5f89093b3a49af1822cb88e1f112fbbe318063dbe5",
 "T3W1_en_test_msg_backup_device.py::test_backup_bip39": "7b4ba68389ff470702484d5f22bff0c39515b75d40ae8701670963332a4c1c75",
-"T3W1_en_test_msg_backup_device.py::test_backup_slip39_advanced[click_info]": "5b95e9f1a2b1f87a00d7aafb6c0b5bfc02d7d20156117e704dc74a8ecf55531b",
-"T3W1_en_test_msg_backup_device.py::test_backup_slip39_advanced[no_click_info]": "78a573b5f51f4b1d3c0d46e2bb64324a8b082537196b602bc6711f13132e7b97",
-"T3W1_en_test_msg_backup_device.py::test_backup_slip39_basic[click_info]": "8804e39394ce3d03201db214644d182782a7f5e553a386cc45d787c72a5ee0de",
-"T3W1_en_test_msg_backup_device.py::test_backup_slip39_basic[no_click_info]": "f4eb2fb4e4b9200e444875a848254785fb66e5e08a0449867463194cba32e421",
+"T3W1_en_test_msg_backup_device.py::test_backup_slip39_advanced[click_info]": "5fd5f70e41087bfcc7dd913a74e1161704a3a32d6d652d92abb790f6902ef62d",
+"T3W1_en_test_msg_backup_device.py::test_backup_slip39_advanced[no_click_info]": "62b153bd0ead66c12e1cd1ccce189fac521566c9ef5007e5ddec1d23be700aa4",
+"T3W1_en_test_msg_backup_device.py::test_backup_slip39_basic[click_info]": "06cc6bc9661e6239e347b19f7e5e96e1e25294af4853bd82c2989b1a24ac2ad1",
+"T3W1_en_test_msg_backup_device.py::test_backup_slip39_basic[no_click_info]": "6aa844bec15fc2982f2c29b1d181e85fe1dc921d868483e18f39b851d8913dee",
 "T3W1_en_test_msg_backup_device.py::test_backup_slip39_custom[1_of_1]": "2330a208fb33faf9e7d752eced61797852b2b5f09cae05ed58d1a9bdb25766ab",
 "T3W1_en_test_msg_backup_device.py::test_backup_slip39_custom[2_of_2]": "d9fabb2f61a40096c3b190c80f25c3c40db5b7d712856611ec240c47da0e87cf",
 "T3W1_en_test_msg_backup_device.py::test_backup_slip39_custom[3_of_5]": "db0bf92f1805695ded1e66810a413d18649e585818c7254145504089c04fcc33",
@@ -32013,7 +32013,7 @@
 "T3W1_en_test_msg_loaddevice.py::test_load_device_slip39_basic": "2344dd4463e13607b0bbff7ae9e064456f2482077e02e3c1ba6cbe396babc94c",
 "T3W1_en_test_msg_loaddevice.py::test_load_device_utf": "f2e75cdfb73f344e375567eddee1b8914b73ec3d895c0ee54c96352f9bb2af22",
 "T3W1_en_test_msg_ping.py::test_ping": "79e5159e9a668f966c96f1a982d444f491893b5965bd7391829421ef5de17305",
-"T3W1_en_test_msg_wipedevice.py::test_autolock_not_retained": "bba6f35f2b19cf16800e22df591da29bd5a23b5c58a3cd757bb5306334c9b00e",
+"T3W1_en_test_msg_wipedevice.py::test_autolock_not_retained": "6df8fec057f33623a4d99c78fb823b97cfbf3126291aea6479fe7c2dc7cae622",
 "T3W1_en_test_msg_wipedevice.py::test_wipe_device": "94902c0dd26a33c27104db14dbbe3a216cc26642f49868e4597dd9efca094aa9",
 "T3W1_en_test_passphrase_slip39_advanced.py::test_128bit_passphrase": "2f843aefe8e22c64bc6856f65ca545b869900bdeeb9d99d2e24af166eebb8bf5",
 "T3W1_en_test_passphrase_slip39_advanced.py::test_256bit_passphrase": "2f843aefe8e22c64bc6856f65ca545b869900bdeeb9d99d2e24af166eebb8bf5",
@@ -32039,10 +32039,10 @@
 "T3W1_en_test_protection_levels.py::test_unlocked": "3a8322a91c9c6fa4476bd49eeb2fc1277d24c29448d318fe64b248f9f0e421f8",
 "T3W1_en_test_protection_levels.py::test_verify_message_t2": "83e1f3ef97b98648a062ef5cab00554aaca5f71490060a3f951772bd5ab51891",
 "T3W1_en_test_protection_levels.py::test_wipe_device": "aa779c5d7411667fb10d1d89848436148af2bb59a8ac36fe3b26c53f6fe6b345",
-"T3W1_en_test_repeated_backup.py::test_repeated_backup": "fe5800be036c65dc7c07773aa8443bc3850975c6fe867ab66423ef99a16ebca9",
-"T3W1_en_test_repeated_backup.py::test_repeated_backup_cancel": "c5eb0a0ef2a4d3562451364499f3bbee4e83418228873a18c5f78491e3001d6e",
-"T3W1_en_test_repeated_backup.py::test_repeated_backup_send_disallowed_message": "c5eb0a0ef2a4d3562451364499f3bbee4e83418228873a18c5f78491e3001d6e",
-"T3W1_en_test_repeated_backup.py::test_repeated_backup_upgrade_single": "b5f4d577634f6df210d1f9815f29f86403dfcfa8b6e72682f4960e4ec92eec30",
+"T3W1_en_test_repeated_backup.py::test_repeated_backup": "929c3c47571d709d275848f5da2882a2a1a99fc1f7399294afa5655f529b381f",
+"T3W1_en_test_repeated_backup.py::test_repeated_backup_cancel": "1f8798aca9c84551f789468b74b58cf3535dbfe1e4578b9f53d435d7f3eb48e9",
+"T3W1_en_test_repeated_backup.py::test_repeated_backup_send_disallowed_message": "1f8798aca9c84551f789468b74b58cf3535dbfe1e4578b9f53d435d7f3eb48e9",
+"T3W1_en_test_repeated_backup.py::test_repeated_backup_upgrade_single": "f84c90cd6ffb18ef9ceba3cbeb7e5fae6d65bbd4b3acb0d752c74d811172f5a9",
 "T3W1_en_test_session.py::test_cannot_resume_ended_session": "4ccd52f30548e0528c1a4dcf0c622b1545b471faf292f482e95fe5cebb634473",
 "T3W1_en_test_session.py::test_clear_session": "7b10973c20294703c5aec6616be116cb6e9a748cecb0462ca4051b59b862b261",
 "T3W1_en_test_session.py::test_derive_cardano_empty_session": "4ccd52f30548e0528c1a4dcf0c622b1545b471faf292f482e95fe5cebb634473",
@@ -33141,11 +33141,11 @@
 "T3W1_es_reset_recovery-test_recovery_slip39_basic_dryrun.py::test_2of3_dryrun": "5f103748c97534579369ea6a61ebe6ba1c431ed574a79f2c8206ec75f4949bc9",
 "T3W1_es_reset_recovery-test_recovery_slip39_basic_dryrun.py::test_2of3_invalid_seed_dryrun": "8ee761c662b3a1efa5a903047e941b47e8c031f352f175b84aec2cdd9239701b",
 "T3W1_es_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Bip39-backup_flow_bip39]": "ba8c1c8f434c87b34c3488e9ad4fc021c4f7ee7b64978d5e9c7fe4fbb486d369",
-"T3W1_es_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Advanced_Ext-10ea47d6": "4e83bdc1aa9639194b5647ac032a6c2c4fc95b7ee7826aadcf95c466f3d2e43a",
-"T3W1_es_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Basic_Extend-5dbe8b0f": "191ad338632b64f9c24a774d04de67f4b0bdc4ca52c00567b53411bc1bcc4987",
+"T3W1_es_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Advanced_Ext-10ea47d6": "1db227764a2461a1c0ae623798dbf2c19c57e66d06e04674c60f3b0a1aad34f0",
+"T3W1_es_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Basic_Extend-5dbe8b0f": "854f1139cbe07a33096acd321756a6fed2ab9a7c6463ecfaa31fd4594ceae9a7",
 "T3W1_es_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Bip39-backup_flow_bip39]": "671b1ce736c4d0590f21b6e00746183ce7e894cb261f51514872562f9a9eb8a1",
-"T3W1_es_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Advanced_Extend-8b11c1dc": "1195fb33f6a3464c6b007ed3a0dd98b06367c3e1ea65a1e77a99ea48b38110eb",
-"T3W1_es_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Basic_Extendabl-cc19e908": "27f4801a25b51aaa248ca5ce68ea5eacfe2fd4b1a0d88e8c95805fc31996c0a5",
+"T3W1_es_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Advanced_Extend-8b11c1dc": "35c6cb73b922d89ea1f094e15808e173f8bdc5c77bd4f01336916ac491e3d6d4",
+"T3W1_es_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Basic_Extendabl-cc19e908": "6f9a5c1f27fa1e4905e45b0ed982fc06879dcf7365cd336fc74ce60ed467dfa3",
 "T3W1_es_reset_recovery-test_reset_bip39_t2.py::test_already_initialized": "29db01bc32cedae65e400e85c8c0635ca66e858f31a256cceca0bc60cc238b2c",
 "T3W1_es_reset_recovery-test_reset_bip39_t2.py::test_entropy_check": "9de8ac607085ff67dea5129c478f757e30c23ca692fbd7aeebdc9d39c5fdc23e",
 "T3W1_es_reset_recovery-test_reset_bip39_t2.py::test_failed_pin": "3f95af87a54ed833f6b05c3b6f43e86238fcde14ed14488fb4088a4642eac500",
@@ -33156,12 +33156,12 @@
 "T3W1_es_reset_recovery-test_reset_bip39_t2.py::test_reset_entropy_check": "8126d1faa7c152298e2725a6fb56395dfe788a7bc172435775266f5ad34e264b",
 "T3W1_es_reset_recovery-test_reset_bip39_t2.py::test_reset_failed_check": "d6708ecff4f494dd623a6dcdadf3533955dcd9326c7fe4eec43aa0ef57cbd7d8",
 "T3W1_es_reset_recovery-test_reset_recovery_bip39.py::test_reset_recovery": "3ce15635597313a19a22520bcbd3348b66664f0a700960a4293ef7e960dc35a9",
-"T3W1_es_reset_recovery-test_reset_recovery_slip39_advanced.py::test_reset_recovery": "e889f2045d5c5b342b88e306208e20154dd35a572c55ff1a45e8387cc68dd1d3",
-"T3W1_es_reset_recovery-test_reset_recovery_slip39_basic.py::test_reset_recovery": "7b2de130adaf7851876bc8d1d5fc33152d155a937b017acf5aa1fc75a218179d",
-"T3W1_es_reset_recovery-test_reset_slip39_advanced.py::test_reset_device_slip39_advanced": "821aec74b2345d5bcc841a8406a7e797b087cfc6e8ff66197d541593f7c1e558",
-"T3W1_es_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic": "d05503fc72fc2a2c158bf6a483a2d7cc43a81a9e81d734688b0530d8a226bf0c",
-"T3W1_es_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic_256": "a30e6833795f7cb6f4cf789b131def07ef69dda351172ae38b3c37a5019d2e87",
-"T3W1_es_reset_recovery-test_reset_slip39_basic.py::test_reset_entropy_check": "e4db7746c532f8110bc80c9c43486faefe3afab7889cd92b6f93d6e602b70a10",
+"T3W1_es_reset_recovery-test_reset_recovery_slip39_advanced.py::test_reset_recovery": "4fdbd8084277f39df34d99abf1cefa11bc6fcb0c3b4b273a431d00d2327c414a",
+"T3W1_es_reset_recovery-test_reset_recovery_slip39_basic.py::test_reset_recovery": "0ddf8c44486fa605f636f217aa3a319c49eb02b533d4272f06b6afd156f8d754",
+"T3W1_es_reset_recovery-test_reset_slip39_advanced.py::test_reset_device_slip39_advanced": "5aaaa3505abd3d75f18cb3d885890aba144224c74e7b7b94f17e0249ce6562c6",
+"T3W1_es_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic": "d916946c5ff34c9c86781b61eaf06f243560fe999a7b4c882bbb9d1a4a501aa0",
+"T3W1_es_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic_256": "c1eb4ad8442f7065a2c5b4e6b16ef938f69baaba7619e9be5dbf3a6e056c4f74",
+"T3W1_es_reset_recovery-test_reset_slip39_basic.py::test_reset_entropy_check": "3be48662d37b5948e0312fff3de973c11ff5c9fb56d9ab1840c32fa0e795c7f6",
 "T3W1_es_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-0h-0-0-rNaqKtKrMSwpwZSzRckPf-3321e5d1": "253967cb375f11c93a30830253349d2996d315fc5ec70c019a103104870434fa",
 "T3W1_es_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-0h-0-1-rBKz5MC2iXdoS3XgnNSYm-fd75b415": "6e8813c23dda1387f3da15e7b2968b3c6500c77bc42e344c79fa5f69264b9722",
 "T3W1_es_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-1h-0-0-rJX2KwzaLJDyFhhtXKi3h-af5daf0f": "12d39e29ee0d6614058e48040a148840f99162eb1599252c665a4e9496362714",
@@ -33385,10 +33385,10 @@
 "T3W1_es_test_msg_applysettings.py::test_label_too_long": "29db01bc32cedae65e400e85c8c0635ca66e858f31a256cceca0bc60cc238b2c",
 "T3W1_es_test_msg_applysettings.py::test_safety_checks": "f1336de4cb1e5334d222727f5ef1f047f457b5a5ba8069e18f46d034b838be0a",
 "T3W1_es_test_msg_backup_device.py::test_backup_bip39": "14f1dcd9dca1a3056d37c6bccec1a7efb2215e3e7c543ee6359d2e26591066c5",
-"T3W1_es_test_msg_backup_device.py::test_backup_slip39_advanced[click_info]": "7426e573a1bbf870a231cb551be634a93d5d9dfdc17f8b4f32c24adc8431600f",
-"T3W1_es_test_msg_backup_device.py::test_backup_slip39_advanced[no_click_info]": "91b54701d3c3edb3dacdb034f8ccda2712a5c54047941140d9d4bc3c0022f88e",
-"T3W1_es_test_msg_backup_device.py::test_backup_slip39_basic[click_info]": "d7019a954933fd5861cf8c10499254eb0c581ab94db269991d90d1591a410861",
-"T3W1_es_test_msg_backup_device.py::test_backup_slip39_basic[no_click_info]": "6bb2d51c36437813c46a8cae3ded82192345f114c23a267bf7ee3f48e5305bfd",
+"T3W1_es_test_msg_backup_device.py::test_backup_slip39_advanced[click_info]": "f8296dfdbc0cc585a97c8330e54e06c3059bd3cb37fcd725d45b53e2dca3876e",
+"T3W1_es_test_msg_backup_device.py::test_backup_slip39_advanced[no_click_info]": "76654aec5ca5e5c1de96215b8dd8c0a8fc6ca8dbee7e270f7ba2eebb5ef03dcd",
+"T3W1_es_test_msg_backup_device.py::test_backup_slip39_basic[click_info]": "c1f882b188d7e4fa74074c750518f37fa0c369ef5c0e938e8c02948d9a381709",
+"T3W1_es_test_msg_backup_device.py::test_backup_slip39_basic[no_click_info]": "2c8ef8811af42debc1fa38421494b2f79531c887b367e205fca3d2b3f9354eb0",
 "T3W1_es_test_msg_backup_device.py::test_backup_slip39_custom[1_of_1]": "79c1d7c92dc317ed2dc7ddbe4fb4780ef2f62cc27fd641e63e4322437e8cbb80",
 "T3W1_es_test_msg_backup_device.py::test_backup_slip39_custom[2_of_2]": "d6a441fcabee67524eb5c2e4041ec5e1feb2fce12beb870913dfdc12251c88bd",
 "T3W1_es_test_msg_backup_device.py::test_backup_slip39_custom[3_of_5]": "6556d17b3951bfe49dbdcf0173644d5b95d76685d01d693f7736bf0ec77cd7e2",
@@ -33438,10 +33438,10 @@
 "T3W1_es_test_protection_levels.py::test_unlocked": "afdcb82d2e37a2538400377332a43ca21a5485c9bb08f539c2b13a7e6df5fcbc",
 "T3W1_es_test_protection_levels.py::test_verify_message_t2": "01c84d645ebc763b8d7484ddaed8c8bc4132df393bde52ca61b1550b77106fa5",
 "T3W1_es_test_protection_levels.py::test_wipe_device": "4d859aa1560895a988e5c3904f669f16eaa6dfaaf611e7625a3997fc32ce3508",
-"T3W1_es_test_repeated_backup.py::test_repeated_backup": "53348dad3f15654059fbdecbba411d0a87602114502fa961bd4fd3b92b09325e",
-"T3W1_es_test_repeated_backup.py::test_repeated_backup_cancel": "2baf2757158f6a537f56ae18a1198ee82ff6502aff4757fe1fd4275d59cf1d45",
-"T3W1_es_test_repeated_backup.py::test_repeated_backup_send_disallowed_message": "2baf2757158f6a537f56ae18a1198ee82ff6502aff4757fe1fd4275d59cf1d45",
-"T3W1_es_test_repeated_backup.py::test_repeated_backup_upgrade_single": "70e43a42ed8362b97e8e395f17c770a101dd2e4a86b708cc1745d78db414d92b",
+"T3W1_es_test_repeated_backup.py::test_repeated_backup": "a79cf754217b214e17cb231d57dddbd9bb6f84151eb8421d44de256ae2e57f63",
+"T3W1_es_test_repeated_backup.py::test_repeated_backup_cancel": "25bc22d3550134cc78c457741194e6a9d830fb49d3a63df99db26b7414a9dadd",
+"T3W1_es_test_repeated_backup.py::test_repeated_backup_send_disallowed_message": "25bc22d3550134cc78c457741194e6a9d830fb49d3a63df99db26b7414a9dadd",
+"T3W1_es_test_repeated_backup.py::test_repeated_backup_upgrade_single": "9c40bf898bc880bd689c97935cc414156688c87071030fb0cee2a6eb36785f36",
 "T3W1_es_test_session.py::test_cannot_resume_ended_session": "29db01bc32cedae65e400e85c8c0635ca66e858f31a256cceca0bc60cc238b2c",
 "T3W1_es_test_session.py::test_clear_session": "ef4824a5f08de83eb37e5e696ce7659799a5058e29e6492ca67a0232f44d2041",
 "T3W1_es_test_session.py::test_derive_cardano_empty_session": "29db01bc32cedae65e400e85c8c0635ca66e858f31a256cceca0bc60cc238b2c",
@@ -34540,11 +34540,11 @@
 "T3W1_fr_reset_recovery-test_recovery_slip39_basic_dryrun.py::test_2of3_dryrun": "9f954f50d88344446c171ffeae8d4edd43b69850770b689e34d1d2e107fd5ada",
 "T3W1_fr_reset_recovery-test_recovery_slip39_basic_dryrun.py::test_2of3_invalid_seed_dryrun": "240f7f22a304c6a1b551a10025a16629e0a8650ed7cbb2d9f159f1944c088be2",
 "T3W1_fr_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Bip39-backup_flow_bip39]": "3c3b23419c3b4b51e3c8606585e14a71e9889a0afc52cc74d8c1cc3bc439baac",
-"T3W1_fr_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Advanced_Ext-10ea47d6": "c6d332a3c293d3f0d71f9ec75f389f86d6867e0b118a59fbc83e4e0ad4b05e28",
-"T3W1_fr_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Basic_Extend-5dbe8b0f": "36ef7ddf2ba55c4ee8f1741a16809341244e0d261c532bf474c8b2d389ad6649",
+"T3W1_fr_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Advanced_Ext-10ea47d6": "0eb42b79095470f9dcb77146924b2441c9c0a156211818265a35adc17de9cad5",
+"T3W1_fr_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Basic_Extend-5dbe8b0f": "287c9ea0ca0b9b9625f1630f63571fed819982e72caf56aaac20570f42682ecb",
 "T3W1_fr_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Bip39-backup_flow_bip39]": "cb6bb27c39fae9249097f7b02de1d6f626e6e8ba76db9cde4866aa44cd27317f",
-"T3W1_fr_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Advanced_Extend-8b11c1dc": "01f55880b163c8f3912331a7e9ccc34f714f9ed462bf808af6d8c54b3ee2d0f7",
-"T3W1_fr_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Basic_Extendabl-cc19e908": "a40cf5bd12391c068591a396fd83017155dab0a8e6bacfcd69de4fc50be3f3be",
+"T3W1_fr_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Advanced_Extend-8b11c1dc": "a54b7dc27bcfc1d8175070a5dc0cbce7119c3ade0bfe93f775a3c47aa2ae288b",
+"T3W1_fr_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Basic_Extendabl-cc19e908": "f1a24e9768a396b29b34bb345d4ec1e9f9730dff48da23ff9f43def30da73618",
 "T3W1_fr_reset_recovery-test_reset_bip39_t2.py::test_already_initialized": "f2e2571051137ed1fa13a1e36ef398d27120b82f4e67b81ac11bacf3f69e9e05",
 "T3W1_fr_reset_recovery-test_reset_bip39_t2.py::test_entropy_check": "a8545bb74fe77a23586823d74027acb2bf8f1773607850c54b2381797c7dbc50",
 "T3W1_fr_reset_recovery-test_reset_bip39_t2.py::test_failed_pin": "b281246a4d86b8e86fc2f52fed7887f5093623f03df143fb2563bbcb910b2e2e",
@@ -34555,12 +34555,12 @@
 "T3W1_fr_reset_recovery-test_reset_bip39_t2.py::test_reset_entropy_check": "8bc60904451706b22d2288d272301b17001ef35b7312d52ef197ea118d6b40cd",
 "T3W1_fr_reset_recovery-test_reset_bip39_t2.py::test_reset_failed_check": "67fbd66f56a0f168478fbaf691cadce4e5268da06eef2ca94f2d092f1e6cd1d5",
 "T3W1_fr_reset_recovery-test_reset_recovery_bip39.py::test_reset_recovery": "da3d522546c77c67633d7cde4f6401079db77ee1026f18a1f646e7d57c1c551f",
-"T3W1_fr_reset_recovery-test_reset_recovery_slip39_advanced.py::test_reset_recovery": "3667a33c6e679e2f0bc1e7a5f368aab86ca8397587fe9ba7d2235197e09f9519",
-"T3W1_fr_reset_recovery-test_reset_recovery_slip39_basic.py::test_reset_recovery": "cfb7b8f6275107f2475fe24a7d822859bd0880b1f8b8420e1368dd724bef482c",
-"T3W1_fr_reset_recovery-test_reset_slip39_advanced.py::test_reset_device_slip39_advanced": "96e46c52e31e8afe80ffb16003e719ef7233c2bd3e83bcf789b8f28850a40753",
-"T3W1_fr_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic": "db87efdec5ef36bbcbe968105d3706bee219a8c76b5a68918fc1ccd55e8705ea",
-"T3W1_fr_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic_256": "0a03655f34314b28e00cc98279ed77c105f82253e7be01e8478afad98fe03a9d",
-"T3W1_fr_reset_recovery-test_reset_slip39_basic.py::test_reset_entropy_check": "4611d148fdbc6ff1918e63246069c8110a472b6d200005ee8151b292c178bebb",
+"T3W1_fr_reset_recovery-test_reset_recovery_slip39_advanced.py::test_reset_recovery": "6b52fd250c68417bda1eaf65318e67ba4af3409f7d40c05a0a86b6a35f7c68e3",
+"T3W1_fr_reset_recovery-test_reset_recovery_slip39_basic.py::test_reset_recovery": "7ae048d1b545704a79aef6015d2f669707ce147b08d10e026bf2e1751278e200",
+"T3W1_fr_reset_recovery-test_reset_slip39_advanced.py::test_reset_device_slip39_advanced": "2d43f97970c52b4afa62017cb571a6bf0573d43651a20751a4d8255e8dff7b6f",
+"T3W1_fr_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic": "31e91838706c42634b9f8f798133381e4142b9de0f361022848fb883a7b30c84",
+"T3W1_fr_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic_256": "8b035b4c8c99e6809ad7312945e5e92916c076f0af2bcfbb91543703ccd1c3d7",
+"T3W1_fr_reset_recovery-test_reset_slip39_basic.py::test_reset_entropy_check": "702e930dcf7dbaf3d14170a0178a4663224fcdbf74c2a1f915da330acbdb0d2a",
 "T3W1_fr_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-0h-0-0-rNaqKtKrMSwpwZSzRckPf-3321e5d1": "e448a40aec4958f5e3d0f5e3b474e63dd28bbb9e88c2cbff71fdad1e88a86ad1",
 "T3W1_fr_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-0h-0-1-rBKz5MC2iXdoS3XgnNSYm-fd75b415": "0cc4d224faaf8f210b879fb85a0817ba4744d33ee8ef19572cb294401669a406",
 "T3W1_fr_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-1h-0-0-rJX2KwzaLJDyFhhtXKi3h-af5daf0f": "84778f0edc03fbcb28e75ec479534b7c1401853e919762dff064d0be7a6c7966",
@@ -34784,10 +34784,10 @@
 "T3W1_fr_test_msg_applysettings.py::test_label_too_long": "f2e2571051137ed1fa13a1e36ef398d27120b82f4e67b81ac11bacf3f69e9e05",
 "T3W1_fr_test_msg_applysettings.py::test_safety_checks": "9c0f2ce65dda883dcbb6c05f35f77fd50b1a37427708382755e854694fd93f69",
 "T3W1_fr_test_msg_backup_device.py::test_backup_bip39": "40edb50eaaf9cc87a431d8af0b69d922232882185e5e848dcf9b3946b2fecc80",
-"T3W1_fr_test_msg_backup_device.py::test_backup_slip39_advanced[click_info]": "7048a2062d3b3ca44fc37f845e174422afdf9731fb4689dc4f98db6249ebc57a",
-"T3W1_fr_test_msg_backup_device.py::test_backup_slip39_advanced[no_click_info]": "fe963d521c97fe742258230242b86882811dea5f24334ba88e54f0774cc5a491",
-"T3W1_fr_test_msg_backup_device.py::test_backup_slip39_basic[click_info]": "b9b612d996a20f6334dbe18a9259a8481e6f340afbe7b9c4ff886a46e5fe4e2e",
-"T3W1_fr_test_msg_backup_device.py::test_backup_slip39_basic[no_click_info]": "19b9ee671a7f1451440b2c15c0fef7b0d65f0448069b3902234f5984459a5af8",
+"T3W1_fr_test_msg_backup_device.py::test_backup_slip39_advanced[click_info]": "1061d02751e5580847fe761b3e059b256152f790a394ce1c62600642173fac89",
+"T3W1_fr_test_msg_backup_device.py::test_backup_slip39_advanced[no_click_info]": "ac9c3596655324cd043b5e119c03e876dccb3b3d56ed226a6f4312945ac260b2",
+"T3W1_fr_test_msg_backup_device.py::test_backup_slip39_basic[click_info]": "b64cb797ec9882d8da0e6ae0b2aab39c248ccbb1b0c43d676eca1fd025ed6f89",
+"T3W1_fr_test_msg_backup_device.py::test_backup_slip39_basic[no_click_info]": "377ec00956569a0c1644e840207193bb9e6ec017a038c7cb65c333a5bcca7887",
 "T3W1_fr_test_msg_backup_device.py::test_backup_slip39_custom[1_of_1]": "f6efca89b35a4bcbd87e2c8f7e4137df44eb1d380a1f54cbc5ea5d043e922487",
 "T3W1_fr_test_msg_backup_device.py::test_backup_slip39_custom[2_of_2]": "e7f797f046158bfbcdbd4931e719b93b06338411124b12a33395d189a31354bb",
 "T3W1_fr_test_msg_backup_device.py::test_backup_slip39_custom[3_of_5]": "869c7798a55c6ab3fb6f959131b432c9f37314fd3a388c11d649c6ab75bf0195",
@@ -34837,10 +34837,10 @@
 "T3W1_fr_test_protection_levels.py::test_unlocked": "bfaef8917152196dd641f0efd219c7555cc08039052ea2c0b3eec073d8fa384a",
 "T3W1_fr_test_protection_levels.py::test_verify_message_t2": "d45127bfe5406f2b80db38bd905900184ca30227f441a3277cb51d7b22a45b8c",
 "T3W1_fr_test_protection_levels.py::test_wipe_device": "c4990927f39054942db0f222ac81adf45d348816fdb34cc99b95c8b8357a04bc",
-"T3W1_fr_test_repeated_backup.py::test_repeated_backup": "2f49334a3180053110941a2b85cc26de1925bc59b85a2de40fa9f4602228727b",
-"T3W1_fr_test_repeated_backup.py::test_repeated_backup_cancel": "cf680823a7c4915450c3d734d3bca8c956ae3120cfd7f26e1af233cda500fb1d",
-"T3W1_fr_test_repeated_backup.py::test_repeated_backup_send_disallowed_message": "cf680823a7c4915450c3d734d3bca8c956ae3120cfd7f26e1af233cda500fb1d",
-"T3W1_fr_test_repeated_backup.py::test_repeated_backup_upgrade_single": "48d5ddcbf37196ea6490f302312afc61ada784f6efb2b4d19ccec7054276a0a8",
+"T3W1_fr_test_repeated_backup.py::test_repeated_backup": "621a657955dd9b95439fe00326eb6eeab344bb5719c35b7edec75c5631e680df",
+"T3W1_fr_test_repeated_backup.py::test_repeated_backup_cancel": "da6e04744debf0ea0750519aad79e1e88b296dba2b59025b27a0ba15b80212d1",
+"T3W1_fr_test_repeated_backup.py::test_repeated_backup_send_disallowed_message": "da6e04744debf0ea0750519aad79e1e88b296dba2b59025b27a0ba15b80212d1",
+"T3W1_fr_test_repeated_backup.py::test_repeated_backup_upgrade_single": "a9dd7e1c9aeea004e8c7cc24d78869e6dc2eeddb5275fa41b5cc32aeebbe4981",
 "T3W1_fr_test_session.py::test_cannot_resume_ended_session": "f2e2571051137ed1fa13a1e36ef398d27120b82f4e67b81ac11bacf3f69e9e05",
 "T3W1_fr_test_session.py::test_clear_session": "7609e2b75ebcf2ae73ace2c90016ac93e4fb4c5887a3fefba46d5b7a0efdb102",
 "T3W1_fr_test_session.py::test_derive_cardano_empty_session": "f2e2571051137ed1fa13a1e36ef398d27120b82f4e67b81ac11bacf3f69e9e05",
@@ -35939,11 +35939,11 @@
 "T3W1_pt_reset_recovery-test_recovery_slip39_basic_dryrun.py::test_2of3_dryrun": "bbd31194c2e1b01088a57ec941e14983fa0c912535af45a62a7aedae82ed6b9c",
 "T3W1_pt_reset_recovery-test_recovery_slip39_basic_dryrun.py::test_2of3_invalid_seed_dryrun": "6c7f41205c023a96ec0dc5220bda14e7c3aab19089c5682cdfc96842a5266c4f",
 "T3W1_pt_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Bip39-backup_flow_bip39]": "c57d162e5c9f5087beefc06a0009eb4729b391e635fed8a710bc3fec0979ba64",
-"T3W1_pt_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Advanced_Ext-10ea47d6": "944f6f4ee2fbfa75018ee51e544caed832166a64a04033c9155b7c043ff02a63",
-"T3W1_pt_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Basic_Extend-5dbe8b0f": "4e238d693d795276f87ed433016b8b813c6f2db40ecd75f838ebf23df03b34fb",
+"T3W1_pt_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Advanced_Ext-10ea47d6": "93f30a6eeea156c5d3a8446eebd429d8665bf723950e86b1744959ab12eee8dd",
+"T3W1_pt_reset_recovery-test_reset_backup.py::test_skip_backup_manual[BackupType.Slip39_Basic_Extend-5dbe8b0f": "b2df1bc095bb8557bb7a09e4d5677a971c02da74c17cecad8567e2ae1d31a8f4",
 "T3W1_pt_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Bip39-backup_flow_bip39]": "3b44091c564493bbbe8df237cb96e1981d8075761776fa5a1ca7f9b967d85788",
-"T3W1_pt_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Advanced_Extend-8b11c1dc": "f1dd50a4530ac67dd00473ef23393051e5e9dee0dc7f52613eb7da025d6f5b81",
-"T3W1_pt_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Basic_Extendabl-cc19e908": "e5e07a821338ecab2d959a882a10f6b2e2d4a2635126974c95edf8ecc5e43f33",
+"T3W1_pt_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Advanced_Extend-8b11c1dc": "082a86e4a760d897e344e3a79689e3d375a7b248dea3531113a07b544ca72b0e",
+"T3W1_pt_reset_recovery-test_reset_backup.py::test_skip_backup_msg[BackupType.Slip39_Basic_Extendabl-cc19e908": "7f65bcdfff46fd92d528ab522d6b10e1687f69f2ffb57f5d471abf7a70e759f6",
 "T3W1_pt_reset_recovery-test_reset_bip39_t2.py::test_already_initialized": "14054e7b49cbfbd536b59b98db1c64e120e941712ca4feab025b7a7378b5e220",
 "T3W1_pt_reset_recovery-test_reset_bip39_t2.py::test_entropy_check": "6e512f8b041c471590c1bfae34afe923ea30cce924e5b17ad3a8e939cb5022fd",
 "T3W1_pt_reset_recovery-test_reset_bip39_t2.py::test_failed_pin": "8c45ea7f02ed7c7c310230db5cef2d92c5f9012e25b3fef2d9c50e726322923b",
@@ -35954,12 +35954,12 @@
 "T3W1_pt_reset_recovery-test_reset_bip39_t2.py::test_reset_entropy_check": "eda54f2e3d137068f03a6481b0ecaad06591fdee14c976ef81ca7e5db3d3f946",
 "T3W1_pt_reset_recovery-test_reset_bip39_t2.py::test_reset_failed_check": "a02037ad144a3f5513b93183a7d8ea1e89f09355a99f4675a15c57f72e9e4072",
 "T3W1_pt_reset_recovery-test_reset_recovery_bip39.py::test_reset_recovery": "da46146ec3b2516770efaf3234276221533af3abd9b49eef9b1f15df5abd68f1",
-"T3W1_pt_reset_recovery-test_reset_recovery_slip39_advanced.py::test_reset_recovery": "1fda616a1b490cf130cb79a6bc284d056f848e67d2bee3d1368bf4afbc6684ef",
-"T3W1_pt_reset_recovery-test_reset_recovery_slip39_basic.py::test_reset_recovery": "05f011d3fe52ad9c67262013ebd7a04e266c0359e864ac0b49e3ff48b41d191a",
-"T3W1_pt_reset_recovery-test_reset_slip39_advanced.py::test_reset_device_slip39_advanced": "63419ab786c1a26aceba4756e024e2ee43d5c84fbf1dd1b2c91e3415aa20383e",
-"T3W1_pt_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic": "466a93bca19a5ee7469a1b5b1ef5e55dd864b7a04f29885cfa5351369771e033",
-"T3W1_pt_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic_256": "02db84de445a41bb4aa818aaa4e6a592f09dcf31e9eacae71bbbc405942e7c6c",
-"T3W1_pt_reset_recovery-test_reset_slip39_basic.py::test_reset_entropy_check": "654b1d6c7b75e9d5967967b175df480f7801947df5836aa71d534c260a90b9df",
+"T3W1_pt_reset_recovery-test_reset_recovery_slip39_advanced.py::test_reset_recovery": "4d5d5e911631a674ea2ed88aff186eb2de0bf11661a8632c5f7a3bd7e42694d3",
+"T3W1_pt_reset_recovery-test_reset_recovery_slip39_basic.py::test_reset_recovery": "a7c8de01d922d2b3a06f99047868e533c35d7114d2cdbda88eade30c49285d16",
+"T3W1_pt_reset_recovery-test_reset_slip39_advanced.py::test_reset_device_slip39_advanced": "adef5a858424a2fb8adc57c48cb321d5fabba6311765bc35514ad602afe5028d",
+"T3W1_pt_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic": "7ecceaddbfb31147578a490023ea3c1aa242b6f876a965040533aad8cbb9e9dc",
+"T3W1_pt_reset_recovery-test_reset_slip39_basic.py::test_reset_device_slip39_basic_256": "c4371d10d3ab68ad133152ec27c72c436234a60df7e88cb793782aed025e9d9b",
+"T3W1_pt_reset_recovery-test_reset_slip39_basic.py::test_reset_entropy_check": "994ffddee535cf582125266cc7c759d801d2596704997afa560970147e877afb",
 "T3W1_pt_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-0h-0-0-rNaqKtKrMSwpwZSzRckPf-3321e5d1": "93f353a4076ccec5cae0a84a6cfcf678fcd49b28a33fcc05a58fb2b1c7778d9a",
 "T3W1_pt_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-0h-0-1-rBKz5MC2iXdoS3XgnNSYm-fd75b415": "1bdbd42675397ae445fe0b632d1825b05956bf411edbbdf0d6900091cb311b74",
 "T3W1_pt_ripple-test_get_address.py::test_ripple_get_address[m-44h-144h-1h-0-0-rJX2KwzaLJDyFhhtXKi3h-af5daf0f": "4699556a3050905555a40cec53b5f23ba1dd2d28a49e108e8f5a954577b5b087",
@@ -36183,10 +36183,10 @@
 "T3W1_pt_test_msg_applysettings.py::test_label_too_long": "14054e7b49cbfbd536b59b98db1c64e120e941712ca4feab025b7a7378b5e220",
 "T3W1_pt_test_msg_applysettings.py::test_safety_checks": "8569c08c3a61b888e8091b44f707a3a58a06d5e4ca333b93231fbca9ff6aac59",
 "T3W1_pt_test_msg_backup_device.py::test_backup_bip39": "edcd86b8e72afe60ec1ec6b1818fc00e9eb8777439f51adf2538dbb58656aff0",
-"T3W1_pt_test_msg_backup_device.py::test_backup_slip39_advanced[click_info]": "c6f61da0814a1cc2a7f462a50d9cb64ea9e2bdec02df8f9ff2416b092a62bbdf",
-"T3W1_pt_test_msg_backup_device.py::test_backup_slip39_advanced[no_click_info]": "31a755c9c2bdd50955545de60a394bc0458a963e01ce8c16abd3ed5fd6651d9a",
-"T3W1_pt_test_msg_backup_device.py::test_backup_slip39_basic[click_info]": "225d546b3e3ea68e49968523e0162853965aadaf2e8b30894f097b8fefb448e0",
-"T3W1_pt_test_msg_backup_device.py::test_backup_slip39_basic[no_click_info]": "43b44cec2b6723c4e65cbacdfdb9897cf7292458b81e73b8ead0a10badd8099c",
+"T3W1_pt_test_msg_backup_device.py::test_backup_slip39_advanced[click_info]": "6d63ceb5c0ef295186a6708e73f82c42d60bd07a6608a40f6021898f7300dc9c",
+"T3W1_pt_test_msg_backup_device.py::test_backup_slip39_advanced[no_click_info]": "03d87df177f486bbd86e990ca9044da794c50eb36214b262033478c4854b293a",
+"T3W1_pt_test_msg_backup_device.py::test_backup_slip39_basic[click_info]": "e9d222fd2f3834d6c536fb1a08ccdef7f745ca32729e4896f7bf01795899e250",
+"T3W1_pt_test_msg_backup_device.py::test_backup_slip39_basic[no_click_info]": "198b88106470e9950d8bc52b7d57a0259d490e5e2022c9952dde22a0cd6ae678",
 "T3W1_pt_test_msg_backup_device.py::test_backup_slip39_custom[1_of_1]": "5027ebc6bd3c8a6fa1fe022afad4cead69b645c1d5deb06a02871ea017a5a262",
 "T3W1_pt_test_msg_backup_device.py::test_backup_slip39_custom[2_of_2]": "8679814b0f33eb64ce861dd618b817b3e4a070afafc856545ed2c28f868bc9c6",
 "T3W1_pt_test_msg_backup_device.py::test_backup_slip39_custom[3_of_5]": "05acb2f2d045acd7fa608f4235233c6fd44267688a04fc75f93fcb4f5c392b79",
@@ -36236,10 +36236,10 @@
 "T3W1_pt_test_protection_levels.py::test_unlocked": "6cee3584446834ba49020cb2ca9198b122356292cd3b9d701e5c16eb801d8958",
 "T3W1_pt_test_protection_levels.py::test_verify_message_t2": "e37274448c82ce2566cbff4c7f3b65973b56aef836c148b0f27d1f54d037631e",
 "T3W1_pt_test_protection_levels.py::test_wipe_device": "3900ca6ee5925f1da2e27be6ad5eeb2eee5aa17d9e8c78c111728f1726f9863b",
-"T3W1_pt_test_repeated_backup.py::test_repeated_backup": "f13e3199d4ae50502370ef17b2000617b7b729ccaea236056bdf10d7a0e9b0d6",
-"T3W1_pt_test_repeated_backup.py::test_repeated_backup_cancel": "98ff62d57a554d2c3c06b1a589d9a864f99c00d6d37819b7106a3b5fb570339a",
-"T3W1_pt_test_repeated_backup.py::test_repeated_backup_send_disallowed_message": "98ff62d57a554d2c3c06b1a589d9a864f99c00d6d37819b7106a3b5fb570339a",
-"T3W1_pt_test_repeated_backup.py::test_repeated_backup_upgrade_single": "0c29cdc773fd0e13b4fb8cdfcaf2df6d55960339489f6f78048630252995b7d0",
+"T3W1_pt_test_repeated_backup.py::test_repeated_backup": "0e138ca4ae41f7d57092f21a678eb961f4cda4dad3ad153c38e51fafe6b20d6a",
+"T3W1_pt_test_repeated_backup.py::test_repeated_backup_cancel": "3cd41e100eee3c9e36f7fe0c48508207e74f89326cfad198515fe127ef1d3af8",
+"T3W1_pt_test_repeated_backup.py::test_repeated_backup_send_disallowed_message": "3cd41e100eee3c9e36f7fe0c48508207e74f89326cfad198515fe127ef1d3af8",
+"T3W1_pt_test_repeated_backup.py::test_repeated_backup_upgrade_single": "e7e338f0f92b56c2a3f62e089c5df8328657d47d96d5be1fcfb5c0305ec0ffdf",
 "T3W1_pt_test_session.py::test_cannot_resume_ended_session": "14054e7b49cbfbd536b59b98db1c64e120e941712ca4feab025b7a7378b5e220",
 "T3W1_pt_test_session.py::test_clear_session": "b1813325ee2d16f13d32783a646557ef9be2ac60dc65cd8ebfdf3d3b8425670f",
 "T3W1_pt_test_session.py::test_derive_cardano_empty_session": "14054e7b49cbfbd536b59b98db1c64e120e941712ca4feab025b7a7378b5e220",