1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
use core::slice::Iter;
pub(crate) fn skip_digits(iter: &mut Iter<u8>) -> bool {
let mut any = false;
while let Some(digit) = iter.clone().next() {
if !digit.is_ascii_digit() {
break;
}
any = true;
iter.next().unwrap();
}
any
}
pub(crate) fn skip_sign(iter: &mut Iter<u8>) {
if let Some(sign) = iter.clone().next() {
if *sign == b'+' || *sign == b'-' {
iter.next().unwrap();
}
}
}
pub(crate) fn skip_ws(iter: &mut Iter<u8>) {
while iter
.clone()
.next()
.map_or(false, |ch| ch.is_ascii_whitespace())
{
iter.next().unwrap();
}
}
pub(crate) fn mnemonic_split_index(mnemonic: &[u8]) -> Option<(&[u8], &[u8])> {
let last = mnemonic.iter().rposition(|p| !p.is_ascii_digit());
if let Some(index) = last {
if index == mnemonic.len() - 1 {
None
} else {
Some(mnemonic.split_at(index + 1))
}
} else {
None
}
}
pub fn mnemonic_compare(mnemonic: &[u8], s: &[u8]) -> bool {
let mut optional = true;
mnemonic.len() >= s.len() && {
let mut s_iter = s.iter();
mnemonic.iter().all(|m| {
let x = s_iter.next();
if m.is_ascii_lowercase() && x.is_some() {
optional = false;
}
x.map_or(
!(m.is_ascii_uppercase() || m.is_ascii_digit()) && optional,
|x| m.eq_ignore_ascii_case(x),
)
})
}
}
pub(crate) fn ascii_to_digit(digit: u8, radix: u8) -> Option<u32> {
let lowercase = digit.to_ascii_lowercase();
if digit.is_ascii_digit() && digit - b'0' < radix {
Some((digit - b'0') as u32)
} else if radix > 10 && lowercase.is_ascii_alphabetic() && lowercase - b'a' < radix - 10 {
Some((lowercase - b'a' + 10) as u32)
} else {
None
}
}