hw-wallet 0.1.2

Shared wallet orchestration utilities for CLI and FFI
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

use serde::Deserialize;
use trezor_connect::thp::{BtcHDNode, BtcHDNodePath, BtcMultisig, BtcMultisigPubkeysOrder};

use super::hd_node::{TxInputHDNode, TxInputHDNodePath};
use crate::error::{WalletError, WalletResult};
use crate::hex::decode;

#[derive(Debug, Clone, Copy, Default, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum TxInputMultisigPubkeysOrder {
    #[serde(alias = "PRESERVED")]
    #[default]
    Preserved,
    #[serde(alias = "LEXICOGRAPHIC")]
    Lexicographic,
}

#[derive(Debug, Deserialize)]
pub struct TxInputMultisig {
    #[serde(default)]
    pub pubkeys: Vec<TxInputHDNodePath>,
    #[serde(default)]
    pub signatures: Vec<String>,
    pub m: u32,
    #[serde(default)]
    pub nodes: Vec<TxInputHDNode>,
    #[serde(default)]
    pub address_n: Vec<u32>,
    #[serde(default)]
    pub pubkeys_order: TxInputMultisigPubkeysOrder,
}

impl From<TxInputMultisigPubkeysOrder> for BtcMultisigPubkeysOrder {
    fn from(order: TxInputMultisigPubkeysOrder) -> Self {
        match order {
            TxInputMultisigPubkeysOrder::Preserved => Self::Preserved,
            TxInputMultisigPubkeysOrder::Lexicographic => Self::Lexicographic,
        }
    }
}

impl TryFrom<TxInputMultisig> for BtcMultisig {
    type Error = WalletError;

    fn try_from(ms: TxInputMultisig) -> WalletResult<Self> {
        if ms.m == 0 {
            return Err(WalletError::Signing(
                "multisig threshold m must be at least 1".into(),
            ));
        }
        let n = if ms.pubkeys.is_empty() {
            ms.nodes.len()
        } else {
            ms.pubkeys.len()
        };
        if n == 0 {
            return Err(WalletError::Signing(
                "multisig requires at least one cosigner (pubkeys or nodes)".into(),
            ));
        }
        if ms.m as usize > n {
            return Err(WalletError::Signing(format!(
                "multisig threshold m={} exceeds number of cosigners n={n}",
                ms.m
            )));
        }

        Ok(Self {
            pubkeys: ms
                .pubkeys
                .into_iter()
                .map(BtcHDNodePath::try_from)
                .collect::<WalletResult<_>>()?,
            signatures: ms
                .signatures
                .iter()
                .map(|sig| decode(sig))
                .collect::<WalletResult<_>>()?,
            m: ms.m,
            nodes: ms
                .nodes
                .iter()
                .map(BtcHDNode::try_from)
                .collect::<WalletResult<_>>()?,
            address_n: ms.address_n,
            pubkeys_order: ms.pubkeys_order.into(),
        })
    }
}