arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2025-04-23 02:29:10 +00:00
Code Issues Releases Wiki Activity

feat(core/ui): ability to cancel recovery on word count selector

Browse Source
This commit is contained in:
Ioan Bizău 2025-02-17 14:16:31 +01:00 committed by Ioan Bizău
parent 6d7b039e6a
commit 64b9084b6c
31 changed files with 1691 additions and 1415 deletions

1
core/.changelog.d/3503.added Normal file
View File

@ -0,0 +1 @@
Added ability to cancel recovery on word count selection screen.

4
core/embed/rust/src/ui/api/firmware_micropython.rs
View File

@ -1463,9 +1463,9 @@ pub static mp_module_trezorui_api: Module = obj_module! {
/// def select_word_count(
/// *,
/// recovery_type: RecoveryType,
/// ) -> LayoutObj[int | str]: # TR returns str
/// ) -> LayoutObj[int | str | UIResult]: # TR returns str
/// """Select a mnemonic word count from the options: 12, 18, 20, 24, or 33.
/// For unlocking a repeated backup, select from 20 or 33."""
/// For unlocking a repeated backup, select between 20 and 33."""
Qstr::MP_QSTR_select_word_count => obj_fn_kw!(0, new_select_word_count).as_obj(),
/// def set_brightness(*, current: int | None = None) -> LayoutObj[UiResult]:

177
core/embed/rust/src/ui/layout_bolt/component/keyboard/word_count.rs
View File

@ -1,7 +1,10 @@
use crate::ui::{
component::{Component, Event, EventCtx},
geometry::{Grid, GridCellSpan, Rect},
shape::Renderer,
use crate::{
strutil::TString,
ui::{
component::{Component, Event, EventCtx},
geometry::{Grid, GridCellSpan, Rect},
shape::Renderer,
},
};
use super::super::{
@ -11,37 +14,90 @@ use super::super::{
use heapless::Vec;
#[cfg_attr(feature = "debug", derive(ufmt::derive::uDebug))]
#[derive(Copy, Clone)]
pub enum SelectWordCountMsg {
Selected(u32),
Cancelled,
}
type Cell = (usize, usize);
struct Btn {
text: TString<'static>,
msg: SelectWordCountMsg,
placement: GridCellSpan,
}
impl Btn {
pub const fn new(content: &'static str, value: u32, cell: Cell) -> Self {
Self {
text: TString::Str(content),
msg: SelectWordCountMsg::Selected(value),
placement: GridCellSpan {
from: cell,
to: (cell.0, cell.1 + 1),
},
}
}
}
pub struct SelectWordCountLayout {
choice_buttons: &'static [Btn],
cancel_button_placement: GridCellSpan,
}
impl SelectWordCountLayout {
/*
* 12 | 18 | 20
* ------------
* x | 24 | 33
*/
pub const LAYOUT_ALL: SelectWordCountLayout = SelectWordCountLayout {
choice_buttons: &[
Btn::new("12", 12, (0, 0)),
Btn::new("18", 18, (0, 2)),
Btn::new("20", 20, (0, 4)),
Btn::new("24", 24, (1, 2)),
Btn::new("33", 33, (1, 4)),
],
cancel_button_placement: GridCellSpan {
from: (1, 0),
to: (1, 1),
},
};
/*
* x | 20 | 33
*/
pub const LAYOUT_MULTISHARE: SelectWordCountLayout = SelectWordCountLayout {
choice_buttons: &[Btn::new("20", 20, (0, 2)), Btn::new("33", 33, (0, 4))],
cancel_button_placement: GridCellSpan {
from: (0, 0),
to: (0, 1),
},
};
}
pub struct SelectWordCount {
keypad: ValueKeypad,
layout: SelectWordCountLayout,
choice_buttons: Vec<Button, 5>,
cancel_button: Button,
}
impl SelectWordCount {
const NUMBERS_ALL: [u32; 5] = [12, 18, 20, 24, 33];
const LABELS_ALL: [&'static str; 5] = ["12", "18", "20", "24", "33"];
const CELLS_ALL: [(usize, usize); 5] = [(0, 0), (0, 2), (0, 4), (1, 0), (1, 2)];
pub fn new(layout: SelectWordCountLayout) -> Self {
let choice_buttons = layout
.choice_buttons
.iter()
.map(|btn| Button::with_text(btn.text).styled(theme::button_pin()))
.collect();
const NUMBERS_MULTISHARE: [u32; 2] = [20, 33];
const LABELS_MULTISHARE: [&'static str; 2] = ["20", "33"];
const CELLS_MULTISHARE: [(usize, usize); 2] = [(0, 0), (0, 2)];
let cancel_button = Button::with_icon(theme::ICON_CANCEL).styled(theme::button_cancel());
pub fn new_all() -> Self {
Self {
keypad: ValueKeypad::new(&Self::NUMBERS_ALL, &Self::LABELS_ALL, &Self::CELLS_ALL),
}
}
pub fn new_multishare() -> Self {
Self {
keypad: ValueKeypad::new(
&Self::NUMBERS_MULTISHARE,
&Self::LABELS_MULTISHARE,
&Self::CELLS_MULTISHARE,
),
layout,
choice_buttons,
cancel_button,
}
}
}
@ -49,69 +105,38 @@ impl SelectWordCount {
impl Component for SelectWordCount {
type Msg = SelectWordCountMsg;
fn place(&mut self, bounds: Rect) -> Rect {
self.keypad.place(bounds)
}
fn event(&mut self, ctx: &mut EventCtx, event: Event) -> Option<Self::Msg> {
self.keypad.event(ctx, event)
}
fn render<'s>(&'s self, target: &mut impl Renderer<'s>) {
self.keypad.render(target)
}
}
type ValueKeyPacked = (Button, u32, (usize, usize)); // (Button, number, cell)
pub struct ValueKeypad {
buttons: Vec<ValueKeyPacked, 5>,
}
impl ValueKeypad {
fn new(numbers: &[u32], labels: &[&'static str], cells: &[(usize, usize)]) -> Self {
let mut buttons = Vec::new();
for ((&number, &label), &cell) in numbers.iter().zip(labels).zip(cells).take(5) {
unwrap!(buttons.push((
Button::with_text(label.into()).styled(theme::button_pin()),
number,
cell
)));
}
Self { buttons }
}
}
impl Component for ValueKeypad {
type Msg = SelectWordCountMsg;
fn place(&mut self, bounds: Rect) -> Rect {
let (_, bounds) = bounds.split_bottom(2 * theme::BUTTON_HEIGHT + theme::BUTTON_SPACING);
let grid = Grid::new(bounds, 2, 6).with_spacing(theme::BUTTON_SPACING);
for (btn, _, (x, y)) in self.buttons.iter_mut() {
btn.place(grid.cells(GridCellSpan {
from: (*x, *y),
to: (*x, *y + 1),
}));
for (i, button) in self.choice_buttons.iter_mut().enumerate() {
button.place(grid.cells(self.layout.choice_buttons[i].placement));
}
self.cancel_button
.place(grid.cells(self.layout.cancel_button_placement));
bounds
}
fn event(&mut self, ctx: &mut EventCtx, event: Event) -> Option<Self::Msg> {
for (i, (btn, _, _)) in self.buttons.iter_mut().enumerate() {
if let Some(ButtonMsg::Clicked) = btn.event(ctx, event) {
return Some(SelectWordCountMsg::Selected(self.buttons[i].1));
for (i, button) in self.choice_buttons.iter_mut().enumerate() {
if matches!(button.event(ctx, event), Some(ButtonMsg::Clicked)) {
return Some(self.layout.choice_buttons[i].msg);
}
}
if matches!(
self.cancel_button.event(ctx, event),
Some(ButtonMsg::Clicked)
) {
return Some(SelectWordCountMsg::Cancelled);
}
None
}
fn render<'s>(&'s self, target: &mut impl Renderer<'s>) {
for btn in self.buttons.iter() {
btn.0.render(target)
for button in self.choice_buttons.iter() {
button.render(target);
}
self.cancel_button.render(target);
}
}
@ -119,13 +144,5 @@ impl Component for ValueKeypad {
impl crate::trace::Trace for SelectWordCount {
fn trace(&self, t: &mut dyn crate::trace::Tracer) {
t.component("SelectWordCount");
t.child("keypad", &self.keypad);
}
}
#[cfg(feature = "ui_debug")]
impl crate::trace::Trace for ValueKeypad {
fn trace(&self, t: &mut dyn crate::trace::Tracer) {
t.component("ValueKeypad");
}
}

2
core/embed/rust/src/ui/layout_bolt/component/mod.rs
View File

@ -49,7 +49,7 @@ pub use keyboard::{
passphrase::{PassphraseKeyboard, PassphraseKeyboardMsg},
pin::{PinKeyboard, PinKeyboardMsg},
slip39::Slip39Input,
word_count::{SelectWordCount, SelectWordCountMsg},
word_count::{SelectWordCount, SelectWordCountLayout, SelectWordCountMsg},
};
pub use loader::{Loader, LoaderMsg, LoaderStyle, LoaderStyleSheet};
#[cfg(feature = "translations")]

1
core/embed/rust/src/ui/layout_bolt/component_msg_obj.rs
View File

@ -64,6 +64,7 @@ impl TryFrom<SelectWordCountMsg> for Obj {
fn try_from(value: SelectWordCountMsg) -> Result<Self, Self::Error> {
match value {
SelectWordCountMsg::Selected(i) => i.try_into(),
SelectWordCountMsg::Cancelled => Ok(CANCELLED.as_obj()),
}
}
}

19
core/embed/rust/src/ui/layout_bolt/ui_firmware.rs
View File

@ -37,8 +37,8 @@ use super::{
check_homescreen_format, AddressDetails, Bip39Input, Button, ButtonMsg, ButtonPage,
ButtonStyleSheet, CancelConfirmMsg, CoinJoinProgress, Dialog, FidoConfirm, Frame,
Homescreen, IconDialog, Lockscreen, MnemonicKeyboard, NumberInputDialog,
PassphraseKeyboard, PinKeyboard, Progress, SelectWordCount, SetBrightnessDialog,
ShareWords, SimplePage, Slip39Input,
PassphraseKeyboard, PinKeyboard, Progress, SelectWordCount, SelectWordCountLayout,
SetBrightnessDialog, ShareWords, SimplePage, Slip39Input,
},
fonts, theme, UIBolt,
};
@ -700,16 +700,17 @@ impl FirmwareUI for UIBolt {
TR::recovery__num_of_words,
));
let content = if matches!(recovery_type, RecoveryType::UnlockRepeatedBackup) {
SelectWordCount::new_multishare()
} else {
SelectWordCount::new_all()
};
let selector = SelectWordCount::new(
if matches!(recovery_type, RecoveryType::UnlockRepeatedBackup) {
SelectWordCountLayout::LAYOUT_MULTISHARE
} else {
SelectWordCountLayout::LAYOUT_ALL
},
);
let layout = RootComponent::new(Frame::left_aligned(
theme::label_title(),
title,
Dialog::new(paragraphs, content),
Dialog::new(paragraphs, selector),
));
Ok(layout)
}

13
core/embed/rust/src/ui/layout_caesar/bootloader/menu.rs
View File

@ -14,7 +14,7 @@ use crate::{
};
use super::super::{
component::{ButtonLayout, Choice, ChoiceFactory, ChoicePage},
component::{ButtonLayout, Choice, ChoiceFactory, ChoiceMsg, ChoicePage},
fonts,
theme::bootloader::{BLD_BG, BLD_FG, ICON_EXIT, ICON_REDO, ICON_TRASH},
};
@ -140,11 +140,7 @@ impl Menu {
let choices = MenuChoiceFactory::new(firmware_present);
Self {
pad: Pad::with_background(BLD_BG).with_clear(),
choice_page: Child::new(
ChoicePage::new(choices)
.with_carousel(true)
.with_only_one_item(true),
),
choice_page: Child::new(ChoicePage::new(choices).with_only_one_item(true)),
}
}
}
@ -159,7 +155,10 @@ impl Component for Menu {
}
fn event(&mut self, ctx: &mut EventCtx, event: Event) -> Option<Self::Msg> {
self.choice_page.event(ctx, event).map(|evt| evt.0)
match self.choice_page.event(ctx, event) {
Some(ChoiceMsg::Choice { item, .. }) => Some(item),
_ => None,
}
}
fn render<'s>(&'s self, target: &mut impl Renderer<'s>) {

76
core/embed/rust/src/ui/layout_caesar/component/input_methods/choice.rs
View File

@ -11,6 +11,11 @@ use super::super::{
const DEFAULT_ITEMS_DISTANCE: i16 = 10;
pub enum ChoiceMsg<T> {
Choice { item: T, long_press: bool },
Cancel,
}
pub trait Choice {
fn render_center<'s>(&self, target: &mut impl Renderer<'s>, _area: Rect, _inverse: bool);
@ -50,6 +55,12 @@ pub trait ChoiceFactory {
fn get(&self, index: usize) -> (Self::Item, Self::Action);
}
#[derive(PartialEq, Copy, Clone)]
pub enum ChoiceControls {
Carousel,
Cancellable,
}
/// General component displaying a set of items on the screen
/// and allowing the user to select one of them.
///
@ -60,9 +71,6 @@ pub trait ChoiceFactory {
/// Each `Choice` is responsible for setting the screen -
/// choosing the button text, their duration, text displayed
/// on screen etc.
///
/// `is_carousel` can be used to make the choice page "infinite" -
/// after reaching one end, users will appear at the other end.
pub struct ChoicePage<F, A>
where
F: ChoiceFactory<Action = A>,
@ -73,8 +81,9 @@ where
page_counter: usize,
/// How many pixels are between the items.
items_distance: i16,
/// Whether the choice page is "infinite" (carousel).
is_carousel: bool,
/// Whether the choice page is cancelable
/// or a carousel.
controls: ChoiceControls,
/// Whether we should show items on left/right even when they cannot
/// be painted entirely (they would be cut off).
show_incomplete: bool,
@ -116,7 +125,7 @@ where
),
page_counter: 0,
items_distance: DEFAULT_ITEMS_DISTANCE,
is_carousel: false,
controls: ChoiceControls::Cancellable,
show_incomplete: false,
show_only_one_item: false,
inverse_selected_item: false,
@ -138,9 +147,8 @@ where
self
}
/// Enabling the carousel mode.
pub fn with_carousel(mut self, carousel: bool) -> Self {
self.is_carousel = carousel;
pub fn with_controls(mut self, controls: ChoiceControls) -> Self {
self.controls = controls;
self
}
@ -172,13 +180,13 @@ where
ctx: &mut EventCtx,
new_choices: F,
new_page_counter: Option<usize>,
is_carousel: bool,
controls: ChoiceControls,
) {
self.choices = new_choices;
if let Some(new_counter) = new_page_counter {
self.page_counter = new_counter;
}
self.is_carousel = is_carousel;
self.controls = controls;
self.update(ctx);
}
@ -239,12 +247,12 @@ where
let (left_area, _center_area, right_area) = center_row_area.split_center(center_width);
// Possibly drawing on the left side.
if self.has_previous_choice() || self.is_carousel {
if self.has_previous_choice() || self.controls == ChoiceControls::Carousel {
self.show_left_choices(target, left_area);
}
// Possibly drawing on the right side.
if self.has_next_choice() || self.is_carousel {
if self.has_next_choice() || self.controls == ChoiceControls::Carousel {
self.show_right_choices(target, right_area);
}
}
@ -307,7 +315,7 @@ where
// Breaking out of the loop if we exhausted left items
// and the carousel mode is not enabled.
if page_index < 0 {
if self.is_carousel {
if self.controls == ChoiceControls::Carousel {
// Moving to the last page.
page_index = self.last_page_index() as i16;
} else {
@ -348,7 +356,7 @@ where
// Breaking out of the loop if we exhausted right items
// and the carousel mode is not enabled.
if page_index > self.last_page_index() {
if self.is_carousel {
if self.controls == ChoiceControls::Carousel {
// Moving to the first page.
page_index = 0;
} else {
@ -428,8 +436,10 @@ where
/// Check possibility of going left/right.
fn can_move(&self, button: ButtonPos) -> bool {
match button {
ButtonPos::Left => self.has_previous_choice() || self.is_carousel,
ButtonPos::Right => self.has_next_choice() || self.is_carousel,
ButtonPos::Left => {
self.has_previous_choice() || self.controls == ChoiceControls::Carousel
}
ButtonPos::Right => self.has_next_choice() || self.controls == ChoiceControls::Carousel,
_ => false,
}
}
@ -439,7 +449,7 @@ where
if self.has_previous_choice() {
self.decrease_page_counter();
self.update(ctx);
} else if self.is_carousel {
} else if self.controls == ChoiceControls::Carousel {
self.page_counter_to_max();
self.update(ctx);
}
@ -450,7 +460,7 @@ where
if self.has_next_choice() {
self.increase_page_counter();
self.update(ctx);
} else if self.is_carousel {
} else if self.controls == ChoiceControls::Carousel {
self.page_counter_to_zero();
self.update(ctx);
}
@ -486,7 +496,7 @@ impl<F, A> Component for ChoicePage<F, A>
where
F: ChoiceFactory<Action = A>,
{
type Msg = (A, bool);
type Msg = ChoiceMsg<A>;
fn place(&mut self, bounds: Rect) -> Rect {
let (content_area, button_area) = bounds.split_bottom(theme::BUTTON_HEIGHT);
@ -558,9 +568,13 @@ where
if let Some(ButtonControllerMsg::Triggered(pos, long_press)) = button_event {
match pos {
ButtonPos::Left => {
// Clicked BACK. Decrease the page counter.
// In case of carousel going to the right end.
self.move_left(ctx);
if self.controls == ChoiceControls::Cancellable && self.page_counter == 0 {
return Some(ChoiceMsg::<A>::Cancel);
} else {
// Clicked BACK. Decrease the page counter.
// In case of carousel going to the right end.
self.move_left(ctx);
}
}
ButtonPos::Right => {
// Clicked NEXT. Increase the page counter.
@ -570,7 +584,10 @@ where
ButtonPos::Middle => {
// Clicked SELECT. Send current choice index with information about long-press
self.clear_and_repaint(ctx);
return Some((self.get_current_action(), long_press));
return Some(ChoiceMsg::Choice {
item: self.get_current_action(),
long_press,
});
}
}
};
@ -583,7 +600,10 @@ where
buttons.reset_state(ctx);
});
self.clear_and_repaint(ctx);
return Some((self.get_current_action(), true));
return Some(ChoiceMsg::Choice {
item: self.get_current_action(),
long_press: true,
});
}
};
// The middle button was pressed, highlighting the current choice by color
@ -614,11 +634,11 @@ where
t.component("ChoicePage");
t.int("active_page", self.page_counter as i64);
t.int("page_count", self.choices.count() as i64);
t.bool("is_carousel", self.is_carousel);
t.bool("is_carousel", self.controls == ChoiceControls::Carousel);
if self.has_previous_choice() {
t.child("prev_choice", &self.choices.get(self.page_counter - 1).0);
} else if self.is_carousel {
} else if self.controls == ChoiceControls::Carousel {
// In case of carousel going to the left end.
t.child("prev_choice", &self.choices.get(self.last_page_index()).0);
}
@ -627,7 +647,7 @@ where
if self.has_next_choice() {
t.child("next_choice", &self.choices.get(self.page_counter + 1).0);
} else if self.is_carousel {
} else if self.controls == ChoiceControls::Carousel {
// In case of carousel going to the very left.
t.child("next_choice", &self.choices.get(0).0);
}

6
core/embed/rust/src/ui/layout_caesar/component/input_methods/number_input.rs
View File

@ -8,7 +8,7 @@ use crate::{
},
};
use super::super::{ButtonLayout, ChoiceFactory, ChoiceItem, ChoicePage};
use super::super::{ButtonLayout, ChoiceFactory, ChoiceItem, ChoiceMsg, ChoicePage};
struct ChoiceFactoryNumberInput {
min: u32,
@ -69,14 +69,14 @@ impl NumberInput {
}
impl Component for NumberInput {
type Msg = u32;
type Msg = ChoiceMsg<u32>;
fn place(&mut self, bounds: Rect) -> Rect {
self.choice_page.place(bounds)
}
fn event(&mut self, ctx: &mut EventCtx, event: Event) -> Option<Self::Msg> {
self.choice_page.event(ctx, event).map(|evt| evt.0)
self.choice_page.event(ctx, event)
}
fn render<'s>(&'s self, target: &mut impl Renderer<'s>) {

118
core/embed/rust/src/ui/layout_caesar/component/input_methods/passphrase.rs
View File

@ -12,8 +12,8 @@ use crate::{
};
use super::super::{
theme, ButtonDetails, ButtonLayout, CancelConfirmMsg, ChangingTextLine, ChoiceFactory,
ChoiceItem, ChoicePage,
theme, ButtonDetails, ButtonLayout, CancelConfirmMsg, ChangingTextLine, ChoiceControls,
ChoiceFactory, ChoiceItem, ChoiceMsg, ChoicePage,
};
/// Defines the choices currently available on the screen
@ -279,8 +279,8 @@ impl PassphraseEntry {
pub fn new() -> Self {
Self {
choice_page: ChoicePage::new(ChoiceFactoryPassphrase::new(ChoiceCategory::Menu, true))
.with_carousel(true)
.with_initial_page_counter(random_menu_position()),
.with_initial_page_counter(random_menu_position())
.with_controls(ChoiceControls::Carousel),
passphrase_dots: Child::new(ChangingTextLine::center_mono("", MAX_PASSPHRASE_LENGTH)),
show_plain_passphrase: false,
show_last_digit: false,
@ -334,8 +334,12 @@ impl PassphraseEntry {
/// Displaying the MENU
fn show_menu_page(&mut self, ctx: &mut EventCtx) {
let menu_choices = ChoiceFactoryPassphrase::new(ChoiceCategory::Menu, self.is_empty());
self.choice_page
.reset(ctx, menu_choices, Some(random_menu_position()), true);
self.choice_page.reset(
ctx,
menu_choices,
Some(random_menu_position()),
ChoiceControls::Carousel,
);
}
/// Displaying the character category
@ -345,7 +349,7 @@ impl PassphraseEntry {
ctx,
category_choices,
Some(random_category_position(&self.current_category)),
true,
ChoiceControls::Carousel,
);
}
@ -396,54 +400,70 @@ impl Component for PassphraseEntry {
}
}
if let Some((action, long_press)) = self.choice_page.event(ctx, event) {
match action {
PassphraseAction::CancelOrDelete => {
if self.is_empty() {
return Some(CancelConfirmMsg::Cancelled);
match self.choice_page.event(ctx, event) {
Some(ChoiceMsg::Choice {
item: PassphraseAction::CancelOrDelete,
long_press,
}) => {
if self.is_empty() {
return Some(CancelConfirmMsg::Cancelled);
} else {
// Deleting all when long-pressed
if long_press {
self.delete_all_digits(ctx);
} else {
// Deleting all when long-pressed
if long_press {
self.delete_all_digits(ctx);
} else {
self.delete_last_digit(ctx);
}
self.update_passphrase_dots(ctx);
if self.is_empty() {
// Allowing for DELETE/CANCEL change
self.show_menu_page(ctx);
}
ctx.request_paint();
self.delete_last_digit(ctx);
}
}
PassphraseAction::Enter => {
return Some(CancelConfirmMsg::Confirmed);
}
PassphraseAction::Show => {
self.show_plain_passphrase = true;
self.update_passphrase_dots(ctx);
if self.is_empty() {
// Allowing for DELETE/CANCEL change
self.show_menu_page(ctx);
}
ctx.request_paint();
}
PassphraseAction::Category(category) => {
self.current_category = category;
self.show_category_page(ctx);
ctx.request_paint();
}
PassphraseAction::Menu => {
self.current_category = ChoiceCategory::Menu;
self.show_menu_page(ctx);
ctx.request_paint();
}
PassphraseAction::Character(ch) if !self.is_full() => {
self.append_char(ctx, ch);
self.show_last_digit = true;
self.update_passphrase_dots(ctx);
self.randomize_category_position(ctx);
ctx.request_paint();
}
_ => {}
}
}
Some(ChoiceMsg::Choice {
item: PassphraseAction::Enter,
..
}) => {
return Some(CancelConfirmMsg::Confirmed);
}
Some(ChoiceMsg::Choice {
item: PassphraseAction::Show,
..
}) => {
self.show_plain_passphrase = true;
self.update_passphrase_dots(ctx);
ctx.request_paint();
}
Some(ChoiceMsg::Choice {
item: PassphraseAction::Category(category),
..
}) => {
self.current_category = category;
self.show_category_page(ctx);
ctx.request_paint();
}
Some(ChoiceMsg::Choice {
item: PassphraseAction::Menu,
..
}) => {
self.current_category = ChoiceCategory::Menu;
self.show_menu_page(ctx);
ctx.request_paint();
}
Some(ChoiceMsg::Choice {
item: PassphraseAction::Character(ch),
..
}) if !self.is_full() => {
self.append_char(ctx, ch);
self.show_last_digit = true;
self.update_passphrase_dots(ctx);
self.randomize_category_position(ctx);
ctx.request_paint();
}
_ => {}
};
None
}

75
core/embed/rust/src/ui/layout_caesar/component/input_methods/pin.rs
View File

@ -15,7 +15,7 @@ use crate::{
use super::super::{
super::fonts, theme, ButtonDetails, ButtonLayout, CancelConfirmMsg, ChangingTextLine,
ChoiceFactory, ChoiceItem, ChoicePage,
ChoiceControls, ChoiceFactory, ChoiceItem, ChoiceMsg, ChoicePage,
};
#[derive(Clone, Copy)]
@ -171,7 +171,7 @@ impl<'a> PinEntry<'a> {
// Starting at a random digit.
choice_page: ChoicePage::new(ChoiceFactoryPIN)
.with_initial_page_counter(get_random_digit_position())
.with_carousel(true),
.with_controls(ChoiceControls::Carousel),
header_line: Child::new(
header_line_content
.map(|s| ChangingTextLine::center_bold(s, MAX_PIN_LENGTH))
@ -295,38 +295,49 @@ impl Component for PinEntry<'_> {
}
}
if let Some((action, long_press)) = self.choice_page.event(ctx, event) {
match action {
PinAction::Delete => {
// Deleting all when long-pressed
if long_press {
self.textbox.clear(ctx);
} else {
self.textbox.delete_last(ctx);
}
self.update(ctx);
match self.choice_page.event(ctx, event) {
Some(ChoiceMsg::Choice {
item: PinAction::Delete,
long_press,
}) => {
// Deleting all when long-pressed
if long_press {
self.textbox.clear(ctx);
} else {
self.textbox.delete_last(ctx);
}
PinAction::Show => {
self.show_real_pin = true;
self.update(ctx);
}
PinAction::Enter if !self.is_empty() => {
// ENTER is not valid when the PIN is empty
return Some(CancelConfirmMsg::Confirmed);
}
PinAction::Digit(ch) if !self.is_full() => {
self.textbox.append(ctx, ch);
// Choosing random digit to be shown next
self.choice_page
.set_page_counter(ctx, get_random_digit_position(), true);
self.show_last_digit = true;
self.timeout_timer
.start(ctx, Duration::from_secs(LAST_DIGIT_TIMEOUT_S));
self.update(ctx);
}
_ => {}
self.update(ctx);
}
}
Some(ChoiceMsg::Choice {
item: PinAction::Show,
..
}) => {
self.show_real_pin = true;
self.update(ctx);
}
Some(ChoiceMsg::Choice {
item: PinAction::Enter,
..
}) if !self.is_empty() => {
// ENTER is not valid when the PIN is empty
return Some(CancelConfirmMsg::Confirmed);
}
Some(ChoiceMsg::Choice {
item: PinAction::Digit(ch),
..
}) if !self.is_full() => {
self.textbox.append(ctx, ch);
// Choosing random digit to be shown next
self.choice_page
.set_page_counter(ctx, get_random_digit_position(), true);
self.show_last_digit = true;
self.timeout_timer
.start(ctx, Duration::from_secs(LAST_DIGIT_TIMEOUT_S));
self.update(ctx);
}
_ => {}
};
None
}

31
core/embed/rust/src/ui/layout_caesar/component/input_methods/simple_choice.rs
View File

@ -8,7 +8,9 @@ use crate::{
},
};
use super::super::{ButtonLayout, ChoiceFactory, ChoiceItem, ChoicePage};
use super::super::{
ButtonDetails, ButtonLayout, ChoiceControls, ChoiceFactory, ChoiceItem, ChoiceMsg, ChoicePage,
};
use heapless::Vec;
// So that there is only one implementation, and not multiple generic ones
@ -17,12 +19,12 @@ const MAX_LENGTH: usize = 5;
struct ChoiceFactorySimple {
choices: Vec<TString<'static>, MAX_LENGTH>,
carousel: bool,
controls: ChoiceControls,
}
impl ChoiceFactorySimple {
fn new(choices: Vec<TString<'static>, MAX_LENGTH>, carousel: bool) -> Self {
Self { choices, carousel }
fn new(choices: Vec<TString<'static>, MAX_LENGTH>, controls: ChoiceControls) -> Self {
Self { choices, controls }
}
fn get_string(&self, choice_index: usize) -> TString<'static> {
@ -48,10 +50,14 @@ impl ChoiceFactory for ChoiceFactorySimple {
});
// Disabling prev/next buttons for the first/last choice when not in carousel.
// (could be done to the same button if there is only one)
if !self.carousel {
// (could be done to the same item if there is only one)
if self.controls != ChoiceControls::Carousel {
if choice_index == 0 {
choice_item.set_left_btn(None);
if self.controls == ChoiceControls::Cancellable {
choice_item.set_left_btn(Some(ButtonDetails::cancel_icon()));
} else {
choice_item.set_left_btn(None);
}
}
if choice_index == self.count() - 1 {
choice_item.set_right_btn(None);
@ -70,10 +76,11 @@ pub struct SimpleChoice {
}
impl SimpleChoice {
pub fn new(str_choices: Vec<TString<'static>, MAX_LENGTH>, carousel: bool) -> Self {
let choices = ChoiceFactorySimple::new(str_choices, carousel);
pub fn new(str_choices: Vec<TString<'static>, MAX_LENGTH>, controls: ChoiceControls) -> Self {
let choices = ChoiceFactorySimple::new(str_choices, controls);
let choice_page = ChoicePage::new(choices).with_controls(controls);
Self {
choice_page: ChoicePage::new(choices).with_carousel(carousel),
choice_page,
return_index: false,
}
}
@ -103,14 +110,14 @@ impl SimpleChoice {
}
impl Component for SimpleChoice {
type Msg = usize;
type Msg = ChoiceMsg<usize>;
fn place(&mut self, bounds: Rect) -> Rect {
self.choice_page.place(bounds)
}
fn event(&mut self, ctx: &mut EventCtx, event: Event) -> Option<Self::Msg> {
self.choice_page.event(ctx, event).map(|evt| evt.0)
self.choice_page.event(ctx, event)
}
fn render<'s>(&'s self, target: &mut impl Renderer<'s>) {

75
core/embed/rust/src/ui/layout_caesar/component/input_methods/wordlist.rs
View File

@ -9,7 +9,10 @@ use crate::{
},
};
use super::super::{theme, ButtonLayout, ChangingTextLine, ChoiceFactory, ChoiceItem, ChoicePage};
use super::super::{
theme, ButtonLayout, ChangingTextLine, ChoiceControls, ChoiceFactory, ChoiceItem, ChoiceMsg,
ChoicePage,
};
use heapless::Vec;
enum WordlistAction {
@ -173,8 +176,8 @@ impl WordlistEntry {
// Starting at random letter position
choice_page: ChoicePage::new(choices)
.with_incomplete(true)
.with_carousel(true)
.with_initial_page_counter(get_random_position(choices_count)),
.with_initial_page_counter(get_random_position(choices_count))
.with_controls(ChoiceControls::Carousel),
chosen_letters: Child::new(ChangingTextLine::center_mono(PROMPT, LINE_CAPACITY)),
textbox: TextBox::empty(MAX_WORD_LENGTH),
offer_words: false,
@ -253,8 +256,12 @@ impl WordlistEntry {
let new_page_counter = self.get_new_page_counter(&new_choices);
// Not using carousel in case of words, as that looks weird in case
// there is only one word to choose from.
self.choice_page
.reset(ctx, new_choices, Some(new_page_counter), !self.offer_words);
self.choice_page.reset(
ctx,
new_choices,
Some(new_page_counter),
ChoiceControls::Carousel,
);
ctx.request_paint();
}
@ -280,31 +287,41 @@ impl Component for WordlistEntry {
}
fn event(&mut self, ctx: &mut EventCtx, event: Event) -> Option<Self::Msg> {
if let Some((action, long_press)) = self.choice_page.event(ctx, event) {
match action {
WordlistAction::Previous => {
if self.can_go_back {
return Some("");
}
}
WordlistAction::Delete => {
// Deleting all when long-pressed
if long_press {
self.textbox.clear(ctx);
} else {
self.textbox.delete_last(ctx);
}
self.update(ctx);
}
WordlistAction::Letter(letter) => {
self.textbox.append(ctx, letter);
self.update(ctx);
}
WordlistAction::Word(word) => {
return Some(word);
}
match self.choice_page.event(ctx, event) {
Some(ChoiceMsg::Choice {
item: WordlistAction::Previous,
..
}) if self.can_go_back => {
return Some("");
}
}
Some(ChoiceMsg::Choice {
item: WordlistAction::Delete,
long_press,
}) => {
// Deleting all when long-pressed
if long_press {
self.textbox.clear(ctx);
} else {
self.textbox.delete_last(ctx);
}
self.update(ctx);
}
Some(ChoiceMsg::Choice {
item: WordlistAction::Letter(letter),
..
}) => {
self.textbox.append(ctx, letter);
self.update(ctx);
}
Some(ChoiceMsg::Choice {
item: WordlistAction::Word(word),
..
}) => {
return Some(word);
}
_ => {}
};
None
}

2
core/embed/rust/src/ui/layout_caesar/component/mod.rs
View File

@ -18,7 +18,7 @@ pub use common_messages::CancelConfirmMsg;
pub use error::ErrorScreen;
pub use hold_to_confirm::{HoldToConfirm, HoldToConfirmMsg};
pub use input_methods::{
choice::{Choice, ChoiceFactory, ChoicePage},
choice::{Choice, ChoiceControls, ChoiceFactory, ChoiceMsg, ChoicePage},
choice_item::ChoiceItem,
};
pub use loader::{Loader, LoaderMsg, LoaderStyle, LoaderStyleSheet, ProgressLoader};

20
core/embed/rust/src/ui/layout_caesar/component_msg_obj.rs
View File

@ -117,17 +117,25 @@ impl ComponentMsgObj for CoinJoinProgress {
impl ComponentMsgObj for NumberInput {
fn msg_try_into_obj(&self, msg: Self::Msg) -> Result<Obj, Error> {
(CONFIRMED.as_obj(), msg.try_into()?).try_into()
match msg {
Self::Msg::Cancel => (CANCELLED.as_obj(), 0.try_into()?).try_into(),
Self::Msg::Choice { item, .. } => (CONFIRMED.as_obj(), item.try_into()?).try_into(),
}
}
}
impl ComponentMsgObj for SimpleChoice {
fn msg_try_into_obj(&self, msg: Self::Msg) -> Result<Obj, Error> {
if self.return_index {
msg.try_into()
} else {
let text = self.result_by_index(msg);
text.try_into()
match msg {
Self::Msg::Cancel => Ok(CANCELLED.as_obj()),
Self::Msg::Choice { item, .. } => {
if self.return_index {
item.try_into()
} else {
let text = self.result_by_index(item);
text.try_into()
}
}
}
}
}

18
core/embed/rust/src/ui/layout_caesar/ui_firmware.rs
View File

@ -34,10 +34,10 @@ use crate::{
use super::{
component::{
AddressDetails, ButtonActions, ButtonDetails, ButtonLayout, ButtonPage, CoinJoinProgress,
ConfirmHomescreen, Flow, FlowPages, Frame, Homescreen, Lockscreen, NumberInput, Page,
PassphraseEntry, PinEntry, Progress, ScrollableFrame, ShareWords, ShowMore, SimpleChoice,
WordlistEntry, WordlistType,
AddressDetails, ButtonActions, ButtonDetails, ButtonLayout, ButtonPage, ChoiceControls,
CoinJoinProgress, ConfirmHomescreen, Flow, FlowPages, Frame, Homescreen, Lockscreen,
NumberInput, Page, PassphraseEntry, PinEntry, Progress, ScrollableFrame, ShareWords,
ShowMore, SimpleChoice, WordlistEntry, WordlistType,
},
constant, fonts, theme, UICaesar,
};
@ -887,7 +887,7 @@ impl FirmwareUI for UICaesar {
let layout = RootComponent::new(
Frame::new(
description,
SimpleChoice::new(words, false)
SimpleChoice::new(words, ChoiceControls::Carousel)
.with_show_incomplete()
.with_return_index(),
)
@ -904,12 +904,14 @@ impl FirmwareUI for UICaesar {
} else {
&["12", "18", "20", "24", "33"]
};
nums.iter().map(|&num| num.into()).collect()
};
let layout = RootComponent::new(
Frame::new(title, SimpleChoice::new(choices, false)).with_title_centered(),
Frame::new(
title,
SimpleChoice::new(choices, ChoiceControls::Cancellable),
)
.with_title_centered(),
);
Ok(layout)
}

217
core/embed/rust/src/ui/layout_delizia/component/keyboard/word_count.rs
View File

@ -1,41 +1,116 @@
use crate::ui::{
component::{Component, Event, EventCtx},
geometry::{Alignment, Grid, GridCellSpan, Rect},
shape::Renderer,
use crate::{
strutil::TString,
ui::{
component::{Component, Event, EventCtx},
geometry::{Alignment, Grid, GridCellSpan, Rect},
shape::Renderer,
},
};
use heapless::Vec;
use super::super::super::{
component::{
button::{Button, ButtonContent, ButtonMsg},
BinarySelection, BinarySelectionMsg,
},
component::button::{Button, ButtonMsg},
cshape, theme,
};
#[derive(Copy, Clone)]
pub enum SelectWordCountMsg {
Selected(u32),
Cancelled,
}
// We allow large_enum_variant here because the code is simpler and the larger
// variant (ValueKeypad) predates the smaller one.
#[allow(clippy::large_enum_variant)]
pub enum SelectWordCount {
All(ValueKeypad),
Multishare(BinarySelection),
type Cell = (usize, usize);
struct Btn {
text: TString<'static>,
msg: SelectWordCountMsg,
placement: GridCellSpan,
}
impl Btn {
pub const fn new(content: &'static str, value: u32, cell: Cell) -> Self {
Self {
text: TString::Str(content),
msg: SelectWordCountMsg::Selected(value),
placement: GridCellSpan {
from: cell,
to: (cell.0 + 1, cell.1 + 1),
},
}
}
}
pub struct SelectWordCountLayout {
choice_buttons: &'static [Btn],
cancel_button_placement: GridCellSpan,
}
impl SelectWordCountLayout {
/*
* 12 | 18
* -------
* 20 | 24
* -------
* x | 33
*/
pub const LAYOUT_ALL: SelectWordCountLayout = SelectWordCountLayout {
choice_buttons: &[
Btn::new("12", 12, (0, 0)),
Btn::new("18", 18, (0, 2)),
Btn::new("20", 20, (2, 0)),
Btn::new("24", 24, (2, 2)),
Btn::new("33", 33, (4, 2)),
],
cancel_button_placement: GridCellSpan {
from: (4, 0),
to: (5, 1),
},
};
/*
* 20 | 33
* -------
* x
*/
pub const LAYOUT_MULTISHARE: SelectWordCountLayout = SelectWordCountLayout {
choice_buttons: &[Btn::new("20", 20, (0, 0)), Btn::new("33", 33, (0, 2))],
cancel_button_placement: GridCellSpan {
from: (2, 0),
to: (3, 3),
},
};
}
pub struct SelectWordCount {
keypad_area: Rect,
layout: SelectWordCountLayout,
choice_buttons: Vec<Button, 5>,
cancel_button: Button,
}
impl SelectWordCount {
pub fn new_all() -> Self {
Self::All(ValueKeypad::new())
}
pub fn new(layout: SelectWordCountLayout) -> Self {
let choice_buttons = layout
.choice_buttons
.iter()
.map(|btn| {
Button::with_text(btn.text)
.styled(theme::button_keyboard())
.with_text_align(Alignment::Center)
})
.collect();
pub fn new_multishare() -> Self {
Self::Multishare(BinarySelection::new(
ButtonContent::Text("20".into()),
ButtonContent::Text("33".into()),
theme::button_keyboard(),
theme::button_keyboard(),
))
let cancel_button = Button::with_icon(theme::ICON_CLOSE)
.styled(theme::button_cancel())
.with_text_align(Alignment::Center);
Self {
keypad_area: Rect::zero(),
layout,
choice_buttons,
cancel_button,
}
}
}
@ -43,91 +118,42 @@ impl Component for SelectWordCount {
type Msg = SelectWordCountMsg;
fn place(&mut self, bounds: Rect) -> Rect {
match self {
SelectWordCount::All(full_selector) => full_selector.place(bounds),
SelectWordCount::Multishare(bin_selector) => bin_selector.place(bounds),
}
}
fn event(&mut self, ctx: &mut EventCtx, event: Event) -> Option<Self::Msg> {
match self {
SelectWordCount::All(full_selector) => full_selector.event(ctx, event),
SelectWordCount::Multishare(bin_selector) => {
if let Some(m) = bin_selector.event(ctx, event) {
return match m {
BinarySelectionMsg::Left => Some(SelectWordCountMsg::Selected(20)),
BinarySelectionMsg::Right => Some(SelectWordCountMsg::Selected(33)),
};
}
None
}
}
}
fn render<'s>(&'s self, target: &mut impl Renderer<'s>) {
match self {
SelectWordCount::All(full_selector) => full_selector.render(target),
SelectWordCount::Multishare(bin_selector) => bin_selector.render(target),
}
}
}
pub struct ValueKeypad {
button: [Button; Self::NUMBERS.len()],
keypad_area: Rect,
}
impl ValueKeypad {
const NUMBERS: [u32; 5] = [12, 18, 20, 24, 33];
const LABELS: [&'static str; 5] = ["12", "18", "20", "24", "33"];
const CELLS: [(usize, usize); 5] = [(0, 0), (0, 2), (1, 0), (1, 2), (2, 1)];
fn new() -> Self {
ValueKeypad {
button: Self::LABELS.map(|t| {
Button::with_text(t.into())
.styled(theme::button_keyboard())
.with_text_align(Alignment::Center)
}),
keypad_area: Rect::zero(),
}
}
}
impl Component for ValueKeypad {
type Msg = SelectWordCountMsg;
fn place(&mut self, bounds: Rect) -> Rect {
let n_rows: usize = 3;
let n_rows: usize = self.layout.choice_buttons.len() + 1;
let n_cols: usize = 4;
let (_, bounds) = bounds.split_bottom(
n_rows as i16 * theme::BUTTON_HEIGHT + (n_rows as i16 - 1) * theme::BUTTON_SPACING,
);
let grid = Grid::new(bounds, n_rows, n_cols).with_spacing(theme::BUTTON_SPACING);
for (btn, (x, y)) in self.button.iter_mut().zip(Self::CELLS) {
btn.place(grid.cells(GridCellSpan {
from: (x, y),
to: (x, y + 1),
}));
for (i, button) in self.choice_buttons.iter_mut().enumerate() {
button.place(grid.cells(self.layout.choice_buttons[i].placement));
}
self.cancel_button
.place(grid.cells(self.layout.cancel_button_placement));
self.keypad_area = grid.area;
bounds
}
fn event(&mut self, ctx: &mut EventCtx, event: Event) -> Option<Self::Msg> {
for (i, btn) in self.button.iter_mut().enumerate() {
if let Some(ButtonMsg::Clicked) = btn.event(ctx, event) {
return Some(SelectWordCountMsg::Selected(Self::NUMBERS[i]));
for (i, button) in self.choice_buttons.iter_mut().enumerate() {
if matches!(button.event(ctx, event), Some(ButtonMsg::Clicked)) {
return Some(self.layout.choice_buttons[i].msg);
}
}
if matches!(
self.cancel_button.event(ctx, event),
Some(ButtonMsg::Clicked)
) {
return Some(SelectWordCountMsg::Cancelled);
}
None
}
fn render<'s>(&'s self, target: &mut impl Renderer<'s>) {
for btn in self.button.iter() {
btn.render(target)
for button in self.choice_buttons.iter() {
button.render(target);
}
self.cancel_button.render(target);
cshape::KeyboardOverlay::new(self.keypad_area).render(target);
}
@ -137,16 +163,5 @@ impl Component for ValueKeypad {
impl crate::trace::Trace for SelectWordCount {
fn trace(&self, t: &mut dyn crate::trace::Tracer) {
t.component("SelectWordCount");
match self {
SelectWordCount::All(full_selector) => t.child("all", full_selector),
SelectWordCount::Multishare(bin_selector) => t.child("multi-share", bin_selector),
}
}
}
#[cfg(feature = "ui_debug")]
impl crate::trace::Trace for ValueKeypad {
fn trace(&self, t: &mut dyn crate::trace::Tracer) {
t.component("ValueKeypad");
}
}

2
core/embed/rust/src/ui/layout_delizia/component/mod.rs
View File

@ -63,7 +63,7 @@ pub use keyboard::{
passphrase::{PassphraseKeyboard, PassphraseKeyboardMsg},
pin::{PinKeyboard, PinKeyboardMsg},
slip39::Slip39Input,
word_count::{SelectWordCount, SelectWordCountMsg},
word_count::{SelectWordCount, SelectWordCountLayout, SelectWordCountMsg},
};
pub use loader::{Loader, LoaderMsg, LoaderStyle, LoaderStyleSheet};
#[cfg(feature = "translations")]

2
core/embed/rust/src/ui/layout_delizia/component_msg_obj.rs
View File

@ -28,6 +28,7 @@ impl TryFrom<SelectWordCountMsg> for Obj {
fn try_from(value: SelectWordCountMsg) -> Result<Self, Self::Error> {
match value {
SelectWordCountMsg::Selected(i) => i.try_into(),
SelectWordCountMsg::Cancelled => Ok(CANCELLED.as_obj()),
}
}
}
@ -84,6 +85,7 @@ where
impl ComponentMsgObj for SelectWordCount {
fn msg_try_into_obj(&self, msg: Self::Msg) -> Result<Obj, Error> {
match msg {
SelectWordCountMsg::Cancelled => Ok(CANCELLED.as_obj()),
SelectWordCountMsg::Selected(n) => n.try_into(),
}
}

18
core/embed/rust/src/ui/layout_delizia/ui_firmware.rs
View File

@ -35,8 +35,8 @@ use crate::{
use super::{
component::{
check_homescreen_format, Bip39Input, CoinJoinProgress, Frame, Homescreen, Lockscreen,
MnemonicKeyboard, PinKeyboard, Progress, SelectWordCount, Slip39Input, StatusScreen,
SwipeContent, SwipeUpScreen, VerticalMenu,
MnemonicKeyboard, PinKeyboard, Progress, SelectWordCount, SelectWordCountLayout,
Slip39Input, StatusScreen, SwipeContent, SwipeUpScreen, VerticalMenu,
},
flow::{
self, new_confirm_action_simple, ConfirmActionExtra, ConfirmActionMenuStrings,
@ -752,14 +752,16 @@ impl FirmwareUI for UIDelizia {
}
fn select_word_count(recovery_type: RecoveryType) -> Result<impl LayoutMaybeTrace, Error> {
let content = if matches!(recovery_type, RecoveryType::UnlockRepeatedBackup) {
SelectWordCount::new_multishare()
} else {
SelectWordCount::new_all()
};
let selector = SelectWordCount::new(
if matches!(recovery_type, RecoveryType::UnlockRepeatedBackup) {
SelectWordCountLayout::LAYOUT_MULTISHARE
} else {
SelectWordCountLayout::LAYOUT_ALL
},
);
let layout = RootComponent::new(Frame::left_aligned(
TR::recovery__num_of_words.into(),
content,
selector,
));
Ok(layout)
}

4
core/mocks/generated/trezorui_api.pyi
View File

@ -445,9 +445,9 @@ def select_word(
def select_word_count(
*,
recovery_type: RecoveryType,
) -> LayoutObj[int | str]: # TR returns str
) -> LayoutObj[int | str | UIResult]: # TR returns str
"""Select a mnemonic word count from the options: 12, 18, 20, 24, or 33.
For unlocking a repeated backup, select from 20 or 33."""
For unlocking a repeated backup, select between 20 and 33."""
# rust/src/ui/api/firmware_micropython.rs

6
core/src/apps/management/recovery_device/homescreen.py
View File

@ -7,6 +7,7 @@ from trezor import TR, wire
from trezor.messages import Success
from apps.common import backup_types
from apps.management.recovery_device.recover import RecoveryAborted
from . import layout, recover
@ -103,7 +104,10 @@ async def _continue_recovery_process() -> Success:
TR.buttons__continue, TR.recovery__num_of_words
)
# ask for the number of words
word_count = await layout.request_word_count(recovery_type)
try:
word_count = await layout.request_word_count(recovery_type)
except wire.ActionCancelled:
raise RecoveryAborted
# ...and only then show the starting screen with word count.
await _request_share_first_screen(word_count, recovery_type)
assert word_count is not None

39
tests/click_tests/recovery.py
View File

@ -63,6 +63,35 @@ def confirm_recovery(debug: "DebugLink", title: str = "recovery__title") -> None
debug.press_right()
def cancel_select_number_of_words(
debug: "DebugLink",
unlock_repeated_backup=False,
) -> None:
if debug.layout_type is LayoutType.Bolt:
assert debug.read_layout().text_content() == TR.recovery__num_of_words
# click the button from ValuePad
if unlock_repeated_backup:
coords = buttons.grid34(0, 2)
else:
coords = buttons.grid34(0, 3)
debug.click(coords)
elif debug.layout_type is LayoutType.Caesar:
debug.press_right()
layout = debug.read_layout()
assert layout.title() == TR.word_count__title
# navigate to the number and confirm it
debug.press_left()
elif debug.layout_type is LayoutType.Delizia:
# click the button from ValuePad
if unlock_repeated_backup:
coords = buttons.grid34(0, 3)
else:
coords = buttons.grid34(0, 3)
debug.click(coords)
else:
raise ValueError("Unknown model")
def select_number_of_words(
debug: "DebugLink",
num_of_words: int = 20,
@ -74,14 +103,14 @@ def select_number_of_words(
def select_bolt() -> "LayoutContent":
# click the button from ValuePad
if unlock_repeated_backup:
coords_map = {20: buttons.grid34(0, 2), 33: buttons.grid34(1, 2)}
coords_map = {20: buttons.grid34(1, 2), 33: buttons.grid34(2, 2)}
else:
coords_map = {
12: buttons.grid34(0, 2),
18: buttons.grid34(1, 2),
20: buttons.grid34(2, 2),
24: buttons.grid34(0, 3),
33: buttons.grid34(1, 3),
24: buttons.grid34(1, 3),
33: buttons.grid34(2, 3),
}
coords = coords_map.get(num_of_words)
if coords is None:
@ -101,14 +130,14 @@ def select_number_of_words(
def select_delizia() -> "LayoutContent":
# click the button from ValuePad
if unlock_repeated_backup:
coords_map = {20: buttons.NO_UI_DELIZIA, 33: buttons.YES_UI_DELIZIA}
coords_map = {20: buttons.grid34(0, 1), 33: buttons.grid34(2, 1)}
else:
coords_map = {
12: buttons.grid34(0, 1),
18: buttons.grid34(2, 1),
20: buttons.grid34(0, 2),
24: buttons.grid34(2, 2),
33: buttons.grid34(1, 3),
33: buttons.grid34(2, 3),
}
coords = coords_map.get(num_of_words)
if coords is None:

26
tests/click_tests/test_recovery.py
View File

@ -51,6 +51,25 @@ def prepare_recovery_and_evaluate(
assert features.recovery_status == messages.RecoveryStatus.Nothing
@contextmanager
def prepare_recovery_and_evaluate_cancel(
device_handler: "BackgroundDeviceHandler",
) -> Generator["DebugLink", None, None]:
features = device_handler.features()
debug = device_handler.debuglink()
assert features.initialized is False
device_handler.run(device.recover, pin_protection=False) # type: ignore
yield debug
with pytest.raises(exceptions.Cancelled):
device_handler.result()
features = device_handler.features()
assert features.initialized is False
assert features.recovery_status == messages.RecoveryStatus.Nothing
@pytest.mark.setup_client(uninitialized=True)
def test_recovery_slip39_basic(device_handler: "BackgroundDeviceHandler"):
with prepare_recovery_and_evaluate(device_handler) as debug:
@ -60,6 +79,13 @@ def test_recovery_slip39_basic(device_handler: "BackgroundDeviceHandler"):
recovery.finalize(debug)
@pytest.mark.setup_client(uninitialized=True)
def test_recovery_cancel_number_of_words(device_handler: "BackgroundDeviceHandler"):
with prepare_recovery_and_evaluate_cancel(device_handler) as debug:
recovery.confirm_recovery(debug)
recovery.cancel_select_number_of_words(debug)
@pytest.mark.setup_client(uninitialized=True)
def test_recovery_bip39(device_handler: "BackgroundDeviceHandler"):
with prepare_recovery_and_evaluate(device_handler) as debug:

24
tests/click_tests/test_repeated_backup.py
View File

@ -18,7 +18,7 @@ from typing import TYPE_CHECKING
import pytest
from trezorlib import device, messages
from trezorlib import device, exceptions, messages
from .. import buttons
from ..common import MOCK_GET_ENTROPY
@ -202,3 +202,25 @@ def test_repeated_backup(
assert features.backup_availability == messages.BackupAvailability.NotAvailable
assert features.no_backup is False
assert features.recovery_status == messages.RecoveryStatus.Nothing
# try to unlock backup yet again...
device_handler.run(
device.recover,
type=messages.RecoveryType.UnlockRepeatedBackup,
)
recovery.confirm_recovery(debug, "recovery__title_unlock_repeated_backup")
# but cancel on the word count selection screen!
recovery.cancel_select_number_of_words(debug, unlock_repeated_backup=True)
with pytest.raises(exceptions.Cancelled):
device_handler.result()
# ...we are out of recovery mode!
features = device_handler.features()
assert features.backup_type is messages.BackupType.Slip39_Basic_Extendable
assert features.initialized is True
assert features.backup_availability == messages.BackupAvailability.NotAvailable
assert features.no_backup is False
assert features.recovery_status == messages.RecoveryStatus.Nothing

15
tests/device_tests/reset_recovery/test_recovery_slip39_basic.py
View File

@ -29,6 +29,7 @@ from ...input_flows import (
InputFlowSlip39BasicRecovery,
InputFlowSlip39BasicRecoveryAbort,
InputFlowSlip39BasicRecoveryAbortBetweenShares,
InputFlowSlip39BasicRecoveryAbortOnNumberOfWords,
InputFlowSlip39BasicRecoveryInvalidFirstShare,
InputFlowSlip39BasicRecoveryInvalidSecondShare,
InputFlowSlip39BasicRecoveryNoAbort,
@ -118,6 +119,20 @@ def test_abort(client: Client):
assert client.features.recovery_status is messages.RecoveryStatus.Nothing
@pytest.mark.models(skip=["legacy", "safe3"])
@pytest.mark.setup_client(uninitialized=True)
def test_abort_on_number_of_words(client: Client):
# on Caesar, test_abort actually aborts on the # of words selection
with client:
IF = InputFlowSlip39BasicRecoveryAbortOnNumberOfWords(client)
client.set_input_flow(IF.get())
with pytest.raises(exceptions.Cancelled):
device.recover(client, pin_protection=False, label="label")
client.init_device()
assert client.features.initialized is False
assert client.features.recovery_status is messages.RecoveryStatus.Nothing
@pytest.mark.setup_client(uninitialized=True)
def test_abort_between_shares(client: Client):
with client:

10
tests/input_flows.py
View File

@ -2075,6 +2075,16 @@ class InputFlowSlip39BasicRecovery(InputFlowBase):
yield from self.REC.success_wallet_recovered()
class InputFlowSlip39BasicRecoveryAbortOnNumberOfWords(InputFlowBase):
def __init__(self, client: Client):
super().__init__(client)
def input_flow_common(self) -> BRGeneratorType:
yield from self.REC.confirm_recovery()
if self.client.layout_type in (LayoutType.Bolt, LayoutType.Delizia):
yield from self.REC.input_number_of_words(None)
class InputFlowSlip39BasicRecoveryAbort(InputFlowBase):
def __init__(self, client: Client):
super().__init__(client)

8
tests/input_flows_helpers.py
View File

@ -192,7 +192,7 @@ class RecoveryFlow:
assert TR.recovery__wanna_cancel_recovery in self._text_content()
self.debug.press_yes()
def input_number_of_words(self, num_words: int) -> BRGeneratorType:
def input_number_of_words(self, num_words: int | None) -> BRGeneratorType:
br = yield
assert br.code == B.MnemonicWordCount
assert br.name == "recovery_word_count"
@ -200,7 +200,11 @@ class RecoveryFlow:
assert TR.word_count__title in self.debug.read_layout().title()
else:
assert TR.recovery__num_of_words in self._text_content()
self.debug.input(str(num_words))
if num_words is None:
self.debug.press_no()
else:
self.debug.input(str(num_words))
def warning_invalid_recovery_seed(self) -> BRGeneratorType:
br = yield

2056
tests/ui_tests/fixtures.json
View File

File diff suppressed because it is too large Load Diff

34
tests/upgrade_tests/recovery_old.py
View File

@ -23,17 +23,29 @@ def confirm_recovery(debug: "DebugLink") -> None:
debug.read_layout(wait=True)
def select_number_of_words(debug: "DebugLink", num_of_words: int = 20) -> None:
debug.click(buttons.OK)
debug.read_layout(wait=True)
# click the number
word_option_offset = 6
word_options = (12, 18, 20, 24, 33)
index = word_option_offset + word_options.index(
num_of_words
) # raises if num of words is invalid
coords = buttons.grid34(index % 3, index // 3)
def select_number_of_words(
debug: "DebugLink", tag_version: tuple | None, num_of_words: int = 20
) -> None:
if "SelectWordCount" not in debug.read_layout().all_components():
debug.click(buttons.OK)
debug.read_layout(wait=True)
if tag_version is None or tag_version > (2, 8, 8):
# layout changed after adding the cancel button
coords_map = {
12: buttons.grid34(0, 2),
18: buttons.grid34(1, 2),
20: buttons.grid34(2, 2),
24: buttons.grid34(1, 3),
33: buttons.grid34(2, 3),
}
coords = coords_map.get(num_of_words)
else:
word_option_offset = 6
word_options = (12, 18, 20, 24, 33)
index = word_option_offset + word_options.index(
num_of_words
) # raises if num of words is invalid
coords = buttons.grid34(index % 3, index // 3)
debug.click(coords)
debug.read_layout(wait=True)

7
tests/upgrade_tests/test_firmware_upgrades.py
View File

@ -30,6 +30,7 @@ from trezorlib.messages import (
)
from trezorlib.tools import H_
from ..click_tests import recovery
from ..common import MNEMONIC_SLIP39_BASIC_20_3of6, MNEMONIC_SLIP39_BASIC_20_3of6_SECRET
from ..device_handler import BackgroundDeviceHandler
from ..emulators import ALL_TAGS, EmulatorWrapper
@ -308,7 +309,7 @@ def test_upgrade_shamir_recovery(gen: str, tag: Optional[str]):
device_handler.run(device.recover, pin_protection=False)
recovery_old.confirm_recovery(debug)
recovery_old.select_number_of_words(debug)
recovery_old.select_number_of_words(debug, version_from_tag(tag))
layout = recovery_old.enter_share(debug, MNEMONIC_SLIP39_BASIC_20_3of6[0])
if not debug.legacy_ui and not debug.legacy_debug:
assert (
@ -327,14 +328,14 @@ def test_upgrade_shamir_recovery(gen: str, tag: Optional[str]):
emu.client.watch_layout(True)
# second share
layout = recovery_old.enter_share(debug, MNEMONIC_SLIP39_BASIC_20_3of6[2])
layout = recovery.enter_share(debug, MNEMONIC_SLIP39_BASIC_20_3of6[2])
assert (
"2 of 3 shares entered" in layout.text_content()
or "1 more share" in layout.text_content()
)
# last one
layout = recovery_old.enter_share(debug, MNEMONIC_SLIP39_BASIC_20_3of6[1])
layout = recovery.enter_share(debug, MNEMONIC_SLIP39_BASIC_20_3of6[1])
assert (
"Wallet recovery completed" in layout.text_content()
or "finished recovering" in layout.text_content()