blvm-node 0.1.30

Bitcoin Commons BLVM: Minimal Bitcoin node implementation using blvm-protocol and blvm-consensus
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

//! Settlement monitor start/stop and background monitoring smoke.

use blvm_node::config::PaymentConfig;
use blvm_node::payment::processor::PaymentProcessor;
use blvm_node::payment::settlement::SettlementMonitor;
use blvm_node::payment::state_machine::PaymentStateMachine;
use blvm_node::storage::Storage;
use blvm_protocol::payment::PaymentOutput;
use std::sync::Arc;
use std::time::Duration;
use tempfile::TempDir;

fn settlement_fixture() -> (TempDir, Arc<PaymentStateMachine>, Arc<Storage>) {
    let temp_dir = TempDir::new().unwrap();
    let storage = Arc::new(Storage::new(temp_dir.path()).unwrap());
    let processor =
        Arc::new(PaymentProcessor::new(PaymentConfig::default()).expect("payment processor"));
    let state_machine = Arc::new(PaymentStateMachine::new(processor));
    (temp_dir, state_machine, storage)
}

#[tokio::test]
async fn test_settlement_monitor_start_and_stop() {
    let (_dir, state_machine, storage) = settlement_fixture();
    let monitor = SettlementMonitor::new(state_machine).with_storage(storage);

    let outputs = vec![PaymentOutput {
        script: vec![0x51],
        amount: Some(10_000),
    }];
    monitor
        .start_monitoring("payment-a", outputs, None)
        .await
        .expect("start monitoring");

    tokio::time::sleep(Duration::from_millis(20)).await;
    monitor.stop_monitoring("payment-a").await;
}

#[tokio::test]
async fn test_settlement_monitor_with_expected_tx_hash() {
    let (_dir, state_machine, storage) = settlement_fixture();
    let monitor = SettlementMonitor::new(state_machine).with_storage(storage);

    let outputs = vec![PaymentOutput {
        script: vec![0x52, 0x87],
        amount: None,
    }];
    let expected = [0x11u8; 32];
    monitor
        .start_monitoring("payment-b", outputs, Some(expected))
        .await
        .expect("start with expected hash");

    tokio::time::sleep(Duration::from_millis(20)).await;
    monitor.stop_monitoring("payment-b").await;
}

#[tokio::test]
async fn test_settlement_monitor_restart_same_payment_id() {
    let (_dir, state_machine, _storage) = settlement_fixture();
    let monitor = SettlementMonitor::new(state_machine);

    let outputs = vec![PaymentOutput {
        script: vec![0x53],
        amount: Some(1),
    }];
    monitor
        .start_monitoring("payment-c", outputs.clone(), None)
        .await
        .expect("first start");
    monitor.stop_monitoring("payment-c").await;

    monitor
        .start_monitoring("payment-c", outputs, None)
        .await
        .expect("second start");
    monitor.stop_monitoring("payment-c").await;
}