firma 0.20.0

Firma is a library to create bitcoin multisig wallets with private keys stored on offline devices.
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

use crate::*;
use log::debug;
use serde::{Deserialize, Serialize};
use structopt::StructOpt;

#[derive(StructOpt, Debug, Serialize, Deserialize)]
pub struct ListOptions {
    /// list wallets, keys or psbts
    #[structopt(short, long)]
    pub kind: Kind,
}

impl Context {
    pub fn list(&self, opt: &ListOptions) -> Result<ListOutput> {
        let mut path = self.base()?;
        path.push(opt.kind.dir());
        let mut list = ListOutput::default();

        if path.is_dir() {
            debug!("listing {:?}", path);
            for entry in std::fs::read_dir(path)? {
                let entry = entry?;
                let path = entry.path();
                let name = path.file_name().unwrap().to_str().unwrap(); //TODO map err
                match opt.kind {
                    Kind::Wallet => {
                        debug!("read wallet jsons {:?}", name);
                        match self.read::<Wallet>(name) {
                            Ok(wallet) => list.wallets.push(wallet),
                            Err(e) => debug!("can't read {} because {:?}", name, e),
                        }
                    }
                    Kind::WalletSignature => {
                        debug!("read wallet signature jsons {:?}", name);
                        match self.read::<WalletSignature>(name) {
                            Ok(wallet_signature) => list.wallets_signatures.push(wallet_signature),
                            Err(e) => debug!("can't read {} because {:?}", name, e),
                        }
                    }
                    Kind::Psbt => {
                        debug!("read psbt json {:?}", name);
                        match self.read::<Psbt>(name) {
                            Ok(psbt_json) => list.psbts.push(psbt_json),
                            Err(e) => debug!("can't read {} because {:?}", name, e),
                        }
                    }
                    Kind::MasterSecret => {
                        debug!("read keys jsons {:?}", name);
                        match self.read::<MasterSecret>(name) {
                            Ok(secret_key) => list.master_secrets.push(secret_key),
                            Err(e) => debug!("can't read {} because {:?}", name, e),
                        }
                    }
                    _ => unimplemented!(),
                }
            }
        }

        Ok(list)
    }
}

fn _signatures_needed(inputs: &[TxIn]) -> String {
    // TODO reasoning on the first input, should reason as a total?
    let number = inputs.first().map(|i| i.signatures.len()).unwrap_or(0);
    match number {
        0 => "No signatures".to_string(),
        1 => "1 signature".to_string(),
        n => format!("{} signatures", n),
    }
}

#[cfg(test)]
mod tests {
    use crate::common::context::tests::TestContext;
    use crate::common::entities::identifier::Kind;
    use crate::common::list::ListOptions;
    use crate::offline::random::RandomOptions;

    #[test]
    fn test_list() {
        let key_name = "list".to_string();
        let rand_opts = RandomOptions { key_name };
        let context = TestContext::default();
        let context = &context.context;
        let _key = context.create_key(&rand_opts).unwrap();

        let kind = Kind::MasterSecret;
        let opt = ListOptions { kind };
        let result = context.list(&opt);
        assert!(result.is_ok());
        let list = result.unwrap();
        assert!(list
            .master_secrets
            .iter()
            .any(|key| key.id.name == rand_opts.key_name));
    }
}