bhwi 0.1.0

Sans-IO Bitcoin hardware wallet interpreters and their common command model
Documentation 
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::common::{
    Command, DeviceCode, DeviceContext, DisplayAddress, Error, MultisigAddressType,
    MultisigDisplayAddress,
};
use crate::keepkey::{
    KeepKeyCommand, KeepKeyError, KeepKeyMultisigAddress, KeepKeyMultisigAddressType,
    ManagementContext,
};
use crate::trezor::TrezorError;
use crate::trezor::interpreter::{address_n, script_type};

impl From<KeepKeyError> for Error {
    fn from(e: KeepKeyError) -> Self {
        super::trezor::engine_error(e.0, DeviceCode::KeepKey)
    }
}

impl TryFrom<Command> for KeepKeyCommand {
    type Error = TrezorError;

    fn try_from(command: Command) -> Result<Self, Self::Error> {
        Ok(match command {
            Command::Unlock { options } => Self::Initialize(options.network),
            Command::GetVersion => Self::GetFeatures,
            Command::GetMasterFingerprint => Self::GetMasterFingerprint,
            Command::GetXpub { path, display } => Self::GetXpub {
                address_n: address_n(&path),
                display,
            },
            Command::DisplayAddress(
                DisplayAddress::ByPath {
                    path,
                    display,
                    address_format,
                },
                _,
            ) => Self::GetAddress {
                address_n: address_n(&path),
                display,
                script_type: script_type(address_format, &path),
            },
            Command::DisplayAddress(DisplayAddress::ByDescriptor { .. }, _) => {
                return Err(TrezorError::UnsupportedDisplayAddress(
                    "descriptor address display is not yet supported",
                ));
            }
            Command::DisplayAddress(DisplayAddress::ByMultisig(address), _) => {
                Self::GetMultisigAddress(multisig_address(address))
            }
            Command::SignTx(psbt, context) => {
                if context.is_some() {
                    return Err(TrezorError::Unsupported(
                        "KeepKey SignTx does not support device context",
                    ));
                }
                Self::SignTx(Box::new(psbt))
            }
            Command::SignMessage { message, path } => Self::SignMessage {
                address_n: address_n(&path),
                message,
            },
            Command::RegisterWallet { .. } => {
                return Err(TrezorError::Unsupported("register_wallet is not supported"));
            }
            Command::Backup => {
                return Err(TrezorError::Unsupported(
                    "The Keepkey does not support creating a backup via software",
                ));
            }
            Command::Setup(options, context) => {
                let Some(DeviceContext::KeepKeyManagement(ManagementContext::Setup {
                    host_entropy,
                })) = context
                else {
                    return Err(TrezorError::MissingContext(
                        "KeepKey setup requires host entropy in the device context",
                    ));
                };
                Self::Setup {
                    label: (!options.label.is_empty()).then_some(options.label),
                    host_entropy,
                }
            }
            Command::Wipe => Self::Wipe,
            Command::Restore(options, context) => {
                let Some(DeviceContext::KeepKeyManagement(ManagementContext::Restore {
                    u2f_counter,
                })) = context
                else {
                    return Err(TrezorError::MissingContext(
                        "KeepKey restore requires a U2F counter in the device context",
                    ));
                };
                let word_count = u32::try_from(options.word_count).map_err(|_| {
                    TrezorError::InvalidInput("restore word count must be positive".into())
                })?;
                if !matches!(word_count, 12 | 18 | 24) {
                    return Err(TrezorError::InvalidInput(
                        "restore word count must be 12, 18, or 24".into(),
                    ));
                }
                Self::Restore {
                    label: (!options.label.is_empty()).then_some(options.label),
                    word_count,
                    u2f_counter,
                }
            }
            Command::TogglePassphrase => Self::TogglePassphrase,
            Command::PromptPin => Self::PromptPin,
            Command::SendPin(context) => {
                let Some(DeviceContext::KeepKeyManagement(ManagementContext::Pin(pin))) = context
                else {
                    return Err(TrezorError::MissingContext(
                        "KeepKey sendpin requires the PIN positions in the device context",
                    ));
                };
                Self::SendPin(pin)
            }
        })
    }
}

fn multisig_address(address: MultisigDisplayAddress) -> KeepKeyMultisigAddress {
    KeepKeyMultisigAddress {
        threshold: address.threshold,
        address_type: match address.address_type {
            MultisigAddressType::Legacy => KeepKeyMultisigAddressType::Legacy,
            MultisigAddressType::ShWit => KeepKeyMultisigAddressType::ShWit,
            MultisigAddressType::Wit => KeepKeyMultisigAddressType::Wit,
        },
        sorted: address.sorted,
        keys: address.keys,
    }
}