bitbox-api 0.12.0

A library to interact with BitBox hardware wallets
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

// SPDX-License-Identifier: Apache-2.0

use bitbox_api::pb;

async fn signtx<R: bitbox_api::runtime::Runtime>() {
    let noise_config = Box::new(bitbox_api::NoiseConfigNoCache {});
    let bitbox = bitbox_api::BitBox::<R>::from_hid_device(
        bitbox_api::usb::get_any_bitbox02().unwrap(),
        noise_config,
    )
    .await
    .unwrap();
    let pairing_bitbox = bitbox.unlock_and_pair().await.unwrap();
    if let Some(pairing_code) = pairing_bitbox.get_pairing_code().as_ref() {
        println!("Pairing code\n{pairing_code}");
    }
    let paired_bitbox = pairing_bitbox.wait_confirm().await.unwrap();

    let prevtx = bitbox_api::btc::PrevTx {
        version: 1,
        inputs: vec![bitbox_api::btc::PrevTxInput {
            prev_out_hash: vec![b'1'; 32],
            prev_out_index: 0,
            signature_script: b"some signature script".to_vec(),
            sequence: 0xFFFFFFFF,
        }],
        outputs: vec![bitbox_api::btc::PrevTxOutput {
            value: 60005000,
            pubkey_script: b"some pubkey script".to_vec(),
        }],
        locktime: 0,
    };
    let transaction = bitbox_api::btc::Transaction {
        script_configs: vec![
            pb::BtcScriptConfigWithKeypath {
                script_config: Some(bitbox_api::btc::make_script_config_simple(
                    pb::btc_script_config::SimpleType::P2wpkh,
                )),
                keypath: bitbox_api::Keypath::try_from("m/84'/0'/0'")
                    .unwrap()
                    .to_vec(),
            },
            pb::BtcScriptConfigWithKeypath {
                script_config: Some(bitbox_api::btc::make_script_config_simple(
                    pb::btc_script_config::SimpleType::P2wpkhP2sh,
                )),
                keypath: bitbox_api::Keypath::try_from("m/49'/0'/0'")
                    .unwrap()
                    .to_vec(),
            },
        ],
        version: 1,
        inputs: vec![
            bitbox_api::btc::TxInput {
                prev_out_hash: hex::decode(
                    "c58b7e3f1200e0c0ec9a5e81e925baface2cc1d4715514f2d8205be2508b48ee",
                )
                .unwrap(),
                prev_out_index: 0,
                prev_out_value: 60005000,
                sequence: 0xFFFFFFFF,
                keypath: "m/84'/0'/0'/0/0".try_into().unwrap(),
                script_config_index: 0,
                prev_tx: Some(prevtx.clone()),
            },
            bitbox_api::btc::TxInput {
                prev_out_hash: hex::decode(
                    "c58b7e3f1200e0c0ec9a5e81e925baface2cc1d4715514f2d8205be2508b48ee",
                )
                .unwrap(),
                prev_out_index: 0,
                prev_out_value: 60005000,
                sequence: 0xFFFFFFFF,
                keypath: "m/49'/0'/0'/0/1".try_into().unwrap(),
                script_config_index: 1,
                prev_tx: Some(prevtx.clone()),
            },
        ],
        outputs: vec![
            bitbox_api::btc::TxOutput::Internal(bitbox_api::btc::TxInternalOutput {
                keypath: "m/84'/0'/0'/1/0".try_into().unwrap(),
                value: 100000000,
                script_config_index: 0,
            }),
            bitbox_api::btc::TxOutput::External(bitbox_api::btc::TxExternalOutput {
                payload: bitbox_api::btc::Payload {
                    data: vec![1; 32],
                    output_type: pb::BtcOutputType::P2wsh,
                },
                value: 20000000,
            }),
        ],
        locktime: 0,
    };
    let sigs = paired_bitbox
        .btc_sign(
            pb::BtcCoin::Btc,
            &transaction,
            pb::btc_sign_init_request::FormatUnit::Default,
        )
        .await
        .unwrap();
    println!("Sigs:");
    for (i, sig) in sigs.iter().enumerate() {
        println!("Input {}: {}", i, hex::encode(sig));
    }
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
    signtx::<bitbox_api::runtime::TokioRuntime>().await
}