coinswap/tests/wallet_backup.rs at master · abhinavraajput/coinswap · GitHub

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
135
136
137
138
139
140
141
142
143
144
145
146
#![cfg(feature = "integration-test")]
mod test_framework;

use std::{fs, path::PathBuf};

use bip39::rand;
use bitcoin::{Address, Amount};
use bitcoind::{
    bitcoincore_rpc::{self, Auth},
    BitcoinD,
};
use log::info;

use coinswap::wallet::{AddressType, RPCConfig, Wallet, WalletBackup};

use coinswap::security::{load_sensitive_struct_interactive, KeyMaterial, SerdeJson};

use test_framework::init_bitcoind;

use crate::test_framework::{generate_blocks, send_to_address};

fn setup(test_name: String) -> (PathBuf, RPCConfig, PathBuf, BitcoinD, PathBuf) {
    let temp_dir = std::env::temp_dir()
        .join("coinswap")
        .join("wallet-tests")
        .join(test_name);
    let wallets_dir = temp_dir.join("");

    let original_wallet_name = "original-wallet".to_string();
    let original_wallet = wallets_dir.join(&original_wallet_name);
    let wallet_backup_file = wallets_dir.join("wallet-backup.json");
    let restored_wallet_name = "restored-wallet".to_string();
    let restored_wallet_file = wallets_dir.join(&restored_wallet_name);
    if temp_dir.exists() {
        fs::remove_dir_all(&temp_dir).unwrap();
    }

    let port_zmq = 28332 + rand::random::<u16>() % 1000;

    let zmq_addr = format!("tcp://127.0.0.1:{port_zmq}");

    let bitcoind = init_bitcoind(&temp_dir, zmq_addr);

    let url = bitcoind.rpc_url().split_at(7).1.to_string();
    let auth = Auth::CookieFile(bitcoind.params.cookie_file.clone());

    let rpc_config = RPCConfig {
        url,
        auth,
        wallet_name: original_wallet_name.clone(),
    };
    (
        original_wallet,
        rpc_config,
        wallet_backup_file,
        bitcoind,
        restored_wallet_file,
    )
}

fn cleanup(bitcoind: &mut BitcoinD) {
    bitcoind.stop().unwrap();
}

fn send_and_mine(
    bitcoind: &mut BitcoinD,
    address: &Address,
    btc_amount: f64,
    blocks_to_generate: u64,
) -> Result<(), bitcoincore_rpc::Error> {
    send_to_address(bitcoind, address, Amount::from_btc(btc_amount)?);
    generate_blocks(bitcoind, blocks_to_generate);
    Ok(())
}

#[test]
fn plainwallet_plainbackup_plainrestore() {
    info!("Running Test: Creating Wallet file, backing it up, then recieve a payment, and restore backup");

    let (original_wallet, rpc_config, wallet_backup_file, mut bitcoind, restored_wallet_file) =
        setup("plain_wallet_plainbackup_plain_restore".to_string());

    let mut wallet = coinswap::wallet::Wallet::init(&original_wallet, &rpc_config, None).unwrap();

    let addr = wallet
        .get_next_external_address(AddressType::P2WPKH)
        .unwrap();
    send_and_mine(&mut bitcoind, &addr, 0.05, 1).unwrap();

    let _ = wallet.backup(&wallet_backup_file, None);

    let addr = wallet
        .get_next_external_address(AddressType::P2WPKH)
        .unwrap();
    send_and_mine(&mut bitcoind, &addr, 0.05, 1).unwrap();

    wallet.sync_and_save().unwrap();

    let (backup, _) =
        load_sensitive_struct_interactive::<WalletBackup, SerdeJson>(&wallet_backup_file);

    let restored_wallet =
        Wallet::restore(&backup, &restored_wallet_file, &rpc_config, None).unwrap();

    assert_eq!(wallet, restored_wallet); // only compares .store!

    //cleanup(&mut bitcoind);
    cleanup(&mut bitcoind);

    info!("🎉 Wallet Backup and Restore after tx test ran succefully!");
}

#[test]
fn encwallet_encbackup_encrestore() {
    let (original_wallet, rpc_config, wallet_backup_file, mut bitcoind, restored_wallet_file) =
        setup("encwallet_encbackup_encrestore".to_string());

    let km = KeyMaterial::new_interactive(None);

    let mut wallet =
        coinswap::wallet::Wallet::init(&original_wallet, &rpc_config, km.clone()).unwrap();

    let addr = wallet
        .get_next_external_address(AddressType::P2WPKH)
        .unwrap();
    send_and_mine(&mut bitcoind, &addr, 0.05, 1).unwrap();

    let _ = wallet.backup(&wallet_backup_file, km.clone());

    let addr = wallet
        .get_next_external_address(AddressType::P2WPKH)
        .unwrap();
    send_and_mine(&mut bitcoind, &addr, 0.05, 1).unwrap();

    wallet.sync_and_save().unwrap();

    let (backup, _) =
        load_sensitive_struct_interactive::<WalletBackup, SerdeJson>(&wallet_backup_file);

    let restored_wallet =
        Wallet::restore(&backup, &restored_wallet_file, &rpc_config, km.clone()).unwrap();

    assert_eq!(wallet, restored_wallet); // only compares .store!

    cleanup(&mut bitcoind);
}