arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2025-07-08 15:48:08 +00:00
Code Issues Releases Wiki Activity

WIP - Shamir wallet recovery

Browse Source
This commit is contained in:
grdddj 2023-01-07 21:00:38 +01:00
parent d7b1f79f8b
commit 9f62e4467d
11 changed files with 316 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/embed/rust/build.rs
View File

@ -313,6 +313,8 @@ fn generate_trezorhal_bindings() {
// slip39
.allowlist_function("slip39_word_completion_mask")
.allowlist_function("button_sequence_to_word")
.allowlist_var("SLIP39_WORDLIST")
.allowlist_var("SLIP39_WORD_COUNT")
// random
.allowlist_function("random_uniform")
// rgb led

234
core/embed/rust/src/trezorhal/bip39.rs
View File

@ -1,40 +1,10 @@
use super::ffi;
use core::cmp::Ordering;
use cstr_core::CStr;
unsafe fn from_utf8_unchecked<'a>(word: *const cty::c_char) -> &'a str {
// SAFETY: caller must pass a valid 0-terminated UTF-8 string.
// This assumption holds for usage on words of the BIP-39 wordlist.
unsafe {
let word = CStr::from_ptr(word);
core::str::from_utf8_unchecked(word.to_bytes())
}
}
/// Compare word from wordlist to a prefix.
///
/// The comparison returns Less if the word comes lexicographically before all
/// possible words starting with `prefix`, and Greater if it comes after.
/// Equal is returned if the word starts with `prefix`.
unsafe fn prefix_cmp(prefix: &str, word: *const cty::c_char) -> Ordering {
// SAFETY: we assume `word` is a pointer to a 0-terminated string.
for (i, prefix_char) in prefix.as_bytes().iter().enumerate() {
let word_char = unsafe { *(word.add(i)) } as u8;
if word_char == 0 {
// Prefix is longer than word.
return Ordering::Less;
} else if *prefix_char != word_char {
return word_char.cmp(prefix_char);
}
}
Ordering::Equal
}
use super::{ffi, wordlist::Wordlist};
pub fn complete_word(prefix: &str) -> Option<&'static str> {
if prefix.is_empty() {
None
} else {
Wordlist::all().filter_prefix(prefix).iter().next()
Wordlist::bip39().filter_prefix(prefix).iter().next()
}
}
@ -42,7 +12,7 @@ pub fn options_num(prefix: &str) -> Option<usize> {
if prefix.is_empty() {
None
} else {
Some(Wordlist::all().filter_prefix(prefix).len())
Some(Wordlist::bip39().filter_prefix(prefix).len())
}
}
@ -51,201 +21,3 @@ pub fn word_completion_mask(prefix: &str) -> u32 {
// passed byte string, making the call safe.
unsafe { ffi::mnemonic_word_completion_mask(prefix.as_ptr() as _, prefix.len() as _) }
}
/// Returns all possible letters that form a valid word together with some
/// prefix.
pub fn get_available_letters(prefix: &str) -> impl Iterator<Item = char> {
const CHARS: [char; 26] = [
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
];
let mask = word_completion_mask(prefix);
CHARS
.iter()
.filter(move |ch| bitmask_from_char(ch) & mask != 0)
.copied()
}
fn bitmask_from_char(ch: &char) -> u32 {
1 << (*ch as u8 - b'a')
}
pub struct Wordlist(&'static [*const cty::c_char]);
impl Wordlist {
pub fn all() -> Self {
Self(unsafe { &ffi::BIP39_WORDLIST_ENGLISH })
}
pub const fn empty() -> Self {
Self(&[])
}
pub fn filter_prefix(&self, prefix: &str) -> Self {
let mut start = 0usize;
let mut end = self.0.len();
for (i, word) in self.0.iter().enumerate() {
// SAFETY: We assume our slice is an array of 0-terminated strings.
match unsafe { prefix_cmp(prefix, *word) } {
Ordering::Less => {
start = i + 1;
}
Ordering::Greater => {
end = i;
break;
}
_ => {}
}
}
Self(&self.0[start..end])
}
pub fn get(&self, index: usize) -> Option<&'static str> {
// SAFETY: we assume every word in the wordlist is a valid 0-terminated UTF-8
// string.
self.0
.get(index)
.map(|word| unsafe { from_utf8_unchecked(*word) })
}
pub const fn len(&self) -> usize {
self.0.len()
}
pub fn iter(&self) -> impl Iterator<Item = &'static str> {
self.0
.iter()
.map(|word| unsafe { from_utf8_unchecked(*word) })
}
}
#[cfg(test)]
mod tests {
use super::*;
use cstr_core::cstr;
const BIP39_WORD_COUNT: usize = ffi::BIP39_WORD_COUNT as usize;
#[test]
fn test_prefix_cmp() {
assert_eq!(
unsafe { prefix_cmp("", cstr!("").as_ptr()) },
Ordering::Equal
);
assert_eq!(
unsafe { prefix_cmp("b", cstr!("").as_ptr()) },
Ordering::Less
);
assert_eq!(
unsafe { prefix_cmp("b", cstr!("a").as_ptr()) },
Ordering::Less
);
assert_eq!(
unsafe { prefix_cmp("b", cstr!("b").as_ptr()) },
Ordering::Equal
);
assert_eq!(
unsafe { prefix_cmp("b", cstr!("below").as_ptr()) },
Ordering::Equal
);
assert_eq!(
unsafe { prefix_cmp("b", cstr!("c").as_ptr()) },
Ordering::Greater
);
assert_eq!(
unsafe { prefix_cmp("bartender", cstr!("bar").as_ptr()) },
Ordering::Less
);
}
#[test]
fn test_filter_prefix_empty() {
let words = Wordlist::all().filter_prefix("");
assert_eq!(words.len(), BIP39_WORD_COUNT);
let iter = words.iter();
assert_eq!(iter.size_hint(), (BIP39_WORD_COUNT, Some(BIP39_WORD_COUNT)));
}
#[test]
fn test_filter_prefix() {
let expected_result = vec!["strategy", "street", "strike", "strong", "struggle"];
let result = Wordlist::all()
.filter_prefix("str")
.iter()
.collect::<Vec<_>>();
assert_eq!(result, expected_result);
}
#[test]
fn test_filter_prefix_refine() {
let expected_result = vec!["strategy", "street", "strike", "strong", "struggle"];
let words = Wordlist::all().filter_prefix("st");
let result_a = words.filter_prefix("str").iter().collect::<Vec<_>>();
let result_b = Wordlist::all()
.filter_prefix("str")
.iter()
.collect::<Vec<_>>();
assert_eq!(result_a, expected_result);
assert_eq!(result_b, expected_result);
let empty = words.filter_prefix("c");
assert_eq!(empty.len(), 0);
}
#[test]
fn test_wordlist_get() {
let words = Wordlist::all();
assert_eq!(words.get(0), Some("abandon"));
assert_eq!(words.get(BIP39_WORD_COUNT - 1), Some("zoo"));
assert_eq!(words.get(BIP39_WORD_COUNT), None);
assert_eq!(words.get(BIP39_WORD_COUNT + 1), None);
let filtered = words.filter_prefix("str");
assert_eq!(filtered.get(0), Some("strategy"));
assert_eq!(filtered.get(filtered.len()), None);
}
#[test]
fn test_filter_prefix_just_one() {
let expected_result = vec!["stick"];
let result = Wordlist::all()
.filter_prefix("stick")
.iter()
.collect::<Vec<_>>();
assert_eq!(result, expected_result);
}
#[test]
fn test_word_completion_mask() {
let result = word_completion_mask("ab");
assert_eq!(result, 0b101000100100100000001);
let result = word_completion_mask("zoo");
assert_eq!(result, 0b0);
}
#[test]
fn test_get_available_letters() {
let expected_result = vec!['a', 'i', 'l', 'o', 's', 'u'];
let result = get_available_letters("ab").collect::<Vec<_>>();
assert_eq!(result, expected_result);
let expected_result = vec!['a', 'e', 'i', 'o', 'u'];
let result = get_available_letters("str").collect::<Vec<_>>();
assert_eq!(result, expected_result);
let result = get_available_letters("zoo").collect::<Vec<_>>();
assert_eq!(result.len(), 0);
}
#[test]
fn test_bitmask_from_char() {
assert_eq!(bitmask_from_char(&'a'), 0b1);
assert_eq!(bitmask_from_char(&'b'), 0b10);
assert_eq!(bitmask_from_char(&'c'), 0b100);
assert_eq!(bitmask_from_char(&'m'), 0b1000000000000);
assert_eq!(bitmask_from_char(&'z'), 0b10000000000000000000000000);
}
}

1
core/embed/rust/src/trezorhal/mod.rs
View File

@ -15,6 +15,7 @@ pub mod slip39;
pub mod storage;
pub mod usb;
pub mod uzlib;
pub mod wordlist;
pub mod buffers;
#[cfg(not(feature = "micropython"))]

199
core/embed/rust/src/trezorhal/wordlist.rs Normal file
View File

@ -0,0 +1,199 @@
use super::ffi;
use core::cmp::Ordering;
use cstr_core::CStr;
/// Holds all the possible words with the possibility to interact
/// with the "list" - filtering it further, getting their count, etc.
pub struct Wordlist(&'static [*const cty::c_char]);
impl Wordlist {
/// Initialize BIP39 wordlist.
pub fn bip39() -> Self {
Self(unsafe { &ffi::BIP39_WORDLIST_ENGLISH })
}
/// Initialize SLIP39 wordlist.
pub fn slip39() -> Self {
Self(unsafe { &ffi::SLIP39_WORDLIST })
}
/// Returns all possible letters that form a valid word together with some
/// prefix. Alphabetically sorted.
pub fn get_available_letters(&self, prefix: &str) -> impl Iterator<Item = char> {
// Fill a "set" of all unique characters, not sorted yet
let mut suffixes: heapless::Vec<char, 26> = heapless::Vec::new();
for word in self.iter() {
if word.starts_with(prefix) && word.len() > prefix.len() {
let following_char = word.chars().nth(prefix.len()).unwrap();
if !suffixes.contains(&following_char) {
suffixes.push(following_char).unwrap();
}
}
}
suffixes.sort_unstable();
suffixes.into_iter()
}
/// Only leaves words that have a specified prefix. Throw away others.
pub fn filter_prefix(&self, prefix: &str) -> Self {
let mut start = 0usize;
let mut end = self.0.len();
for (i, word) in self.0.iter().enumerate() {
// SAFETY: We assume our slice is an array of 0-terminated strings.
match unsafe { prefix_cmp(prefix, *word) } {
Ordering::Less => {
start = i + 1;
}
Ordering::Greater => {
end = i;
break;
}
_ => {}
}
}
Self(&self.0[start..end])
}
/// Get a word at the certain position.
pub fn get(&self, index: usize) -> Option<&'static str> {
// SAFETY: we assume every word in the wordlist is a valid 0-terminated UTF-8
// string.
self.0
.get(index)
.map(|word| unsafe { from_utf8_unchecked(*word) })
}
/// How many words are currently in the list.
pub const fn len(&self) -> usize {
self.0.len()
}
/// Iterator of all current words.
pub fn iter(&self) -> impl Iterator<Item = &'static str> {
self.0
.iter()
.map(|word| unsafe { from_utf8_unchecked(*word) })
}
}
/// Compare word from wordlist to a prefix.
///
/// The comparison returns Less if the word comes lexicographically before all
/// possible words starting with `prefix`, and Greater if it comes after.
/// Equal is returned if the word starts with `prefix`.
unsafe fn prefix_cmp(prefix: &str, word: *const cty::c_char) -> Ordering {
// SAFETY: we assume `word` is a pointer to a 0-terminated string.
for (i, prefix_char) in prefix.as_bytes().iter().enumerate() {
let word_char = unsafe { *(word.add(i)) } as u8;
if word_char == 0 {
// Prefix is longer than word.
return Ordering::Less;
} else if *prefix_char != word_char {
return word_char.cmp(prefix_char);
}
}
Ordering::Equal
}
unsafe fn from_utf8_unchecked<'a>(word: *const cty::c_char) -> &'a str {
// SAFETY: caller must pass a valid 0-terminated UTF-8 string.
// This assumption holds for usage on words of the BIP-39 wordlist.
unsafe {
let word = CStr::from_ptr(word);
core::str::from_utf8_unchecked(word.to_bytes())
}
}
#[cfg(test)]
mod tests {
use super::*;
const BIP39_WORD_COUNT: usize = ffi::BIP39_WORD_COUNT as usize;
const SLIP39_WORD_COUNT: usize = ffi::SLIP39_WORD_COUNT as usize;
#[test]
fn test_filter_prefix_empty() {
let words = Wordlist::bip39().filter_prefix("");
assert_eq!(words.len(), BIP39_WORD_COUNT);
let iter = words.iter();
assert_eq!(iter.size_hint(), (BIP39_WORD_COUNT, Some(BIP39_WORD_COUNT)));
let words = Wordlist::slip39().filter_prefix("");
assert_eq!(words.len(), SLIP39_WORD_COUNT);
let iter = words.iter();
assert_eq!(
iter.size_hint(),
(SLIP39_WORD_COUNT, Some(SLIP39_WORD_COUNT))
);
}
#[test]
fn test_filter_prefix() {
let expected_result = vec!["strategy", "street", "strike", "strong", "struggle"];
let result = Wordlist::bip39()
.filter_prefix("str")
.iter()
.collect::<Vec<_>>();
assert_eq!(result, expected_result);
}
#[test]
fn test_filter_prefix_refine() {
let expected_result = vec!["strategy", "street", "strike", "strong", "struggle"];
let words = Wordlist::bip39().filter_prefix("st");
let result_a = words.filter_prefix("str").iter().collect::<Vec<_>>();
let result_b = Wordlist::bip39()
.filter_prefix("str")
.iter()
.collect::<Vec<_>>();
assert_eq!(result_a, expected_result);
assert_eq!(result_b, expected_result);
let empty = words.filter_prefix("c");
assert_eq!(empty.len(), 0);
}
#[test]
fn test_wordlist_get() {
let words = Wordlist::bip39();
assert_eq!(words.get(0), Some("abandon"));
assert_eq!(words.get(BIP39_WORD_COUNT - 1), Some("zoo"));
assert_eq!(words.get(BIP39_WORD_COUNT), None);
assert_eq!(words.get(BIP39_WORD_COUNT + 1), None);
let filtered = words.filter_prefix("str");
assert_eq!(filtered.get(0), Some("strategy"));
assert_eq!(filtered.get(filtered.len()), None);
}
#[test]
fn test_filter_prefix_just_one() {
let expected_result = vec!["stick"];
let result = Wordlist::bip39()
.filter_prefix("stick")
.iter()
.collect::<Vec<_>>();
assert_eq!(result, expected_result);
}
#[test]
fn test_get_available_letters() {
let expected_result = vec!['a', 'i', 'l', 'o', 's', 'u'];
let result = Wordlist::bip39()
.get_available_letters("ab")
.collect::<Vec<_>>();
assert_eq!(result, expected_result);
let expected_result = vec!['a', 'e', 'i', 'o', 'u'];
let result = Wordlist::bip39()
.get_available_letters("str")
.collect::<Vec<_>>();
assert_eq!(result, expected_result);
let result = Wordlist::bip39()
.get_available_letters("zoo")
.collect::<Vec<_>>();
assert_eq!(result.len(), 0);
}
}

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

@ -1,7 +1,7 @@
pub mod bip39;
pub mod choice;
pub mod choice_item;
pub mod number_input;
pub mod passphrase;
pub mod pin;
pub mod simple_choice;
pub mod wordlist;

76
core/embed/rust/src/ui/model_tr/component/input_methods/bip39.rs → core/embed/rust/src/ui/model_tr/component/input_methods/wordlist.rs
View File

@ -1,5 +1,5 @@
use crate::{
trezorhal::bip39,
trezorhal::wordlist::Wordlist,
ui::{
component::{text::common::TextBox, Child, Component, ComponentExt, Event, EventCtx},
display::Icon,
@ -14,26 +14,32 @@ use super::super::{
};
use heapless::{String, Vec};
pub enum Bip39EntryMsg {
pub enum WordlistEntryMsg {
ResultWord(String<15>),
}
const MAX_WORD_LENGTH: usize = 10;
const MAX_CHOICE_LENGTH: usize = 26;
const MAX_LETTERS_LENGTH: usize = 26;
/// Offer words when there will be fewer of them than this
const OFFER_WORDS_THRESHOLD: usize = 10;
const PROMPT: &str = "_";
/// Type of the wordlist, deciding the list of words to be used
pub enum WordlistType {
Bip39,
Slip39,
}
/// We are offering either letters or words.
enum ChoiceFactoryBIP39 {
Letters(Vec<char, MAX_CHOICE_LENGTH>),
enum ChoiceFactoryWordlist {
Letters(Vec<char, MAX_LETTERS_LENGTH>),
Words(Vec<&'static str, OFFER_WORDS_THRESHOLD>),
}
impl ChoiceFactoryBIP39 {
fn letters(letter_choices: Vec<char, MAX_CHOICE_LENGTH>) -> Self {
impl ChoiceFactoryWordlist {
fn letters(letter_choices: Vec<char, MAX_LETTERS_LENGTH>) -> Self {
Self::Letters(letter_choices)
}
@ -42,7 +48,7 @@ impl ChoiceFactoryBIP39 {
}
}
impl ChoiceFactory for ChoiceFactoryBIP39 {
impl ChoiceFactory for ChoiceFactoryWordlist {
type Item = ChoiceItem;
fn count(&self) -> u8 {
@ -88,21 +94,23 @@ impl ChoiceFactory for ChoiceFactoryBIP39 {
}
}
/// Component for entering a BIP39 mnemonic.
pub struct Bip39Entry {
choice_page: ChoicePage<ChoiceFactoryBIP39>,
/// Component for entering a mnemonic from a wordlist - BIP39 or SLIP39.
pub struct WordlistEntry {
choice_page: ChoicePage<ChoiceFactoryWordlist>,
chosen_letters: Child<ChangingTextLine<String<{ MAX_WORD_LENGTH + 1 }>>>,
letter_choices: Vec<char, MAX_CHOICE_LENGTH>,
letter_choices: Vec<char, MAX_LETTERS_LENGTH>,
textbox: TextBox<MAX_WORD_LENGTH>,
offer_words: bool,
words_list: bip39::Wordlist,
words_list: Wordlist,
wordlist_type: WordlistType,
}
impl Bip39Entry {
pub fn new() -> Self {
let letter_choices: Vec<char, MAX_CHOICE_LENGTH> =
bip39::get_available_letters("").collect();
let choices = ChoiceFactoryBIP39::letters(letter_choices.clone());
impl WordlistEntry {
pub fn new(wordlist_type: WordlistType) -> Self {
let words_list = Self::get_fresh_wordlist(&wordlist_type);
let letter_choices: Vec<char, MAX_LETTERS_LENGTH> =
words_list.get_available_letters("").collect();
let choices = ChoiceFactoryWordlist::letters(letter_choices.clone());
Self {
choice_page: ChoicePage::new(choices)
@ -112,12 +120,21 @@ impl Bip39Entry {
letter_choices,
textbox: TextBox::empty(),
offer_words: false,
words_list: bip39::Wordlist::all(),
words_list,
wordlist_type,
}
}
/// Get appropriate wordlist with all possible words
fn get_fresh_wordlist(wordlist_type: &WordlistType) -> Wordlist {
match wordlist_type {
WordlistType::Bip39 => Wordlist::bip39(),
WordlistType::Slip39 => Wordlist::slip39(),
}
}
/// Gets up-to-date choices for letters or words.
fn get_current_choices(&mut self) -> ChoiceFactoryBIP39 {
fn get_current_choices(&mut self) -> ChoiceFactoryWordlist {
// Narrowing the word list
self.words_list = self.words_list.filter_prefix(self.textbox.content());
@ -126,11 +143,14 @@ impl Bip39Entry {
if self.words_list.len() < OFFER_WORDS_THRESHOLD {
self.offer_words = true;
let word_choices = self.words_list.iter().collect();
ChoiceFactoryBIP39::words(word_choices)
ChoiceFactoryWordlist::words(word_choices)
} else {
self.offer_words = false;
self.letter_choices = bip39::get_available_letters(self.textbox.content()).collect();
ChoiceFactoryBIP39::letters(self.letter_choices.clone())
self.letter_choices = self
.words_list
.get_available_letters(self.textbox.content())
.collect();
ChoiceFactoryWordlist::letters(self.letter_choices.clone())
}
}
@ -161,7 +181,7 @@ impl Bip39Entry {
}
fn reset_wordlist(&mut self) {
self.words_list = bip39::Wordlist::all();
self.words_list = Self::get_fresh_wordlist(&self.wordlist_type);
}
/// Get the index of DELETE item, which is always at the end.
@ -174,8 +194,8 @@ impl Bip39Entry {
}
}
impl Component for Bip39Entry {
type Msg = Bip39EntryMsg;
impl Component for WordlistEntry {
type Msg = WordlistEntryMsg;
fn place(&mut self, bounds: Rect) -> Rect {
let letters_area_height = self.chosen_letters.inner().needed_height();
@ -201,7 +221,7 @@ impl Component for Bip39Entry {
.words_list
.get(page_counter as usize)
.unwrap_or_default();
return Some(Bip39EntryMsg::ResultWord(String::from(word)));
return Some(WordlistEntryMsg::ResultWord(String::from(word)));
} else {
let new_letter = self.letter_choices[page_counter as usize];
self.append_letter(ctx, new_letter);
@ -226,7 +246,7 @@ use super::super::{ButtonAction, ButtonPos};
use crate::ui::util;
#[cfg(feature = "ui_debug")]
impl crate::trace::Trace for Bip39Entry {
impl crate::trace::Trace for WordlistEntry {
fn get_btn_action(&self, pos: ButtonPos) -> String<25> {
match pos {
ButtonPos::Left => ButtonAction::PrevPage.string(),

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

@ -33,13 +33,13 @@ pub use flow_pages::{FlowPages, Page};
pub use frame::Frame;
pub use homescreen::{Homescreen, HomescreenMsg, Lockscreen};
pub use input_methods::{
bip39::{Bip39Entry, Bip39EntryMsg},
choice::{Choice, ChoiceFactory, ChoicePage, ChoicePageMsg},
choice_item::ChoiceItem,
number_input::{NumberInput, NumberInputMsg},
passphrase::{PassphraseEntry, PassphraseEntryMsg},
pin::{PinEntry, PinEntryMsg},
simple_choice::{SimpleChoice, SimpleChoiceMsg},
wordlist::{WordlistEntry, WordlistEntryMsg, WordlistType},
};
pub use loader::{Loader, LoaderMsg, LoaderStyle, LoaderStyleSheet};
pub use no_btn_dialog::{NoBtnDialog, NoBtnDialogMsg};

35
core/embed/rust/src/ui/model_tr/layout.rs
View File

@ -37,10 +37,10 @@ use crate::{
use super::{
component::{
Bip39Entry, Bip39EntryMsg, ButtonActions, ButtonDetails, ButtonLayout, ButtonPage, Flow,
FlowMsg, FlowPages, Frame, Homescreen, HomescreenMsg, Lockscreen, NoBtnDialog,
NoBtnDialogMsg, NumberInput, NumberInputMsg, Page, PassphraseEntry, PassphraseEntryMsg,
PinEntry, PinEntryMsg, Progress, ShareWords, SimpleChoice, SimpleChoiceMsg,
ButtonActions, ButtonDetails, ButtonLayout, ButtonPage, Flow, FlowMsg, FlowPages, Frame,
Homescreen, HomescreenMsg, Lockscreen, NoBtnDialog, NoBtnDialogMsg, NumberInput,
NumberInputMsg, Page, PassphraseEntry, PassphraseEntryMsg, PinEntry, PinEntryMsg, Progress,
ShareWords, SimpleChoice, SimpleChoiceMsg, WordlistEntry, WordlistEntryMsg, WordlistType,
},
constant, theme,
};
@ -127,10 +127,10 @@ impl<const N: usize> ComponentMsgObj for SimpleChoice<N> {
}
}
impl ComponentMsgObj for Bip39Entry {
impl ComponentMsgObj for WordlistEntry {
fn msg_try_into_obj(&self, msg: Self::Msg) -> Result<Obj, Error> {
match msg {
Bip39EntryMsg::ResultWord(word) => word.as_str().try_into(),
WordlistEntryMsg::ResultWord(word) => word.as_str().try_into(),
}
}
}
@ -766,7 +766,21 @@ extern "C" fn new_request_bip39(n_args: usize, args: *const Obj, kwargs: *mut Ma
let block = |_args: &[Obj], kwargs: &Map| {
let prompt: StrBuffer = kwargs.get(Qstr::MP_QSTR_prompt)?.try_into()?;
let obj = LayoutObj::new(Frame::new(prompt, Bip39Entry::new()).with_title_center(true))?;
let obj = LayoutObj::new(
Frame::new(prompt, WordlistEntry::new(WordlistType::Bip39)).with_title_center(true),
)?;
Ok(obj.into())
};
unsafe { util::try_with_args_and_kwargs(n_args, args, kwargs, block) }
}
extern "C" fn new_request_slip39(n_args: usize, args: *const Obj, kwargs: *mut Map) -> Obj {
let block = |_args: &[Obj], kwargs: &Map| {
let prompt: StrBuffer = kwargs.get(Qstr::MP_QSTR_prompt)?.try_into()?;
let obj = LayoutObj::new(
Frame::new(prompt, WordlistEntry::new(WordlistType::Slip39)).with_title_center(true),
)?;
Ok(obj.into())
};
unsafe { util::try_with_args_and_kwargs(n_args, args, kwargs, block) }
@ -1024,6 +1038,13 @@ pub static mp_module_trezorui2: Module = obj_module! {
/// """Get recovery word for BIP39."""
Qstr::MP_QSTR_request_bip39 => obj_fn_kw!(0, new_request_bip39).as_obj(),
/// def request_slip39(
/// *,
/// prompt: str,
/// ) -> str:
/// """SLIP39 word input keyboard."""
Qstr::MP_QSTR_request_slip39 => obj_fn_kw!(0, new_request_slip39).as_obj(),
/// def request_passphrase(
/// *,
/// prompt: str,

8
core/mocks/generated/trezorui2.pyi
View File

@ -166,6 +166,14 @@ def request_bip39(
"""Get recovery word for BIP39."""
# rust/src/ui/model_tr/layout.rs
def request_slip39(
*,
prompt: str,
) -> str:
"""SLIP39 word input keyboard."""
# rust/src/ui/model_tr/layout.rs
def request_passphrase(
*,

2
core/src/trezor/ui/layouts/tr/__init__.py
View File

@ -759,7 +759,7 @@ def show_warning(
ctx,
br_type,
"",
subheader or "Warning",
subheader or "WARNING",
content,
button_confirm=button,
button_cancel=None,

39
core/src/trezor/ui/layouts/tr/recovery.py
View File

@ -5,7 +5,7 @@ from trezor.enums import ButtonRequestType
import trezorui2
from ..common import button_request, interact
from . import RustLayout, get_bool
from . import RustLayout, confirm_action, get_bool
if TYPE_CHECKING:
from trezor import wire
@ -20,7 +20,7 @@ async def request_word_count(ctx: wire.GenericContext, dry_run: bool) -> int:
"word_count",
ButtonRequestType.MnemonicWordCount,
)
# It can be returning a string
# It can be returning a string (for example for __debug__ in tests)
return int(count)
@ -30,15 +30,11 @@ async def request_word(
prompt = f"WORD {word_index + 1} OF {word_count}"
if is_slip39:
raise NotImplementedError
word_choice = RustLayout(trezorui2.request_slip39(prompt=prompt))
else:
word = await interact(
ctx,
RustLayout(trezorui2.request_bip39(prompt=prompt)),
"request_word",
ButtonRequestType.MnemonicInput,
)
word_choice = RustLayout(trezorui2.request_bip39(prompt=prompt))
word: str = await ctx.wait(word_choice)
return word
@ -54,7 +50,14 @@ async def show_remaining_shares(
async def show_group_share_success(
ctx: wire.GenericContext, share_index: int, group_index: int
) -> None:
raise NotImplementedError
await confirm_action(
ctx,
"share_success",
"Success",
description=f"You have entered\nShare {share_index + 1} from\nGroup {group_index + 1}",
verb="CONTINUE",
verb_cancel=None,
)
async def continue_recovery(
@ -65,19 +68,25 @@ async def continue_recovery(
info_func: Callable | None,
dry_run: bool,
) -> bool:
# NOTE: no need to implement `info_func`, as it is used only in
# Shamir backup, which is not implemented for TR.
# TODO: implement info_func?
# There is very limited space on the screen
# (and having middle button would mean shortening the right button text)
description = text
if subtext:
description += f"\n\n{subtext}"
if dry_run:
title = "SEED CHECK"
else:
title = "RECOVERY MODE"
return await get_bool(
ctx,
"recovery",
"START RECOVERY",
title,
None,
description,
verb="HOLD TO BEGIN",
hold=True,
verb=button_label.upper(),
br_code=ButtonRequestType.RecoveryHomepage,
)