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
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

//! `Node` accessors, config builders, and health report paths.

use blvm_node::config::NodeConfig;
use blvm_node::node::health::HealthStatus;
use blvm_node::node::Node;
use blvm_protocol::ProtocolVersion;
use serial_test::serial;
use std::net::SocketAddr;
use tempfile::TempDir;

mod common;
use common::setup_mining_chain_on;

fn base_node() -> (TempDir, Node) {
    let temp_dir = TempDir::new().unwrap();
    let network_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let rpc_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let node = Node::new(
        temp_dir.path().to_str().unwrap(),
        network_addr,
        rpc_addr,
        Some(ProtocolVersion::Regtest),
    )
    .unwrap();
    (temp_dir, node)
}

#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn test_node_accessors_and_protocol() {
    let (_dir, node) = base_node();
    assert_eq!(node.network().peer_count(), 0);
    assert!(node.protocol().supports_feature("fast_mining"));
    assert!(!node.storage().is_pruning_enabled());
    assert!(node.module_manager().is_none());
    assert!(node.event_publisher().is_none());
    let _rpc = node.rpc();
}

#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn test_node_with_modules_enables_manager() {
    let temp_dir = TempDir::new().unwrap();
    let modules_dir = temp_dir.path().join("modules");
    let socket_dir = temp_dir.path().join("sockets");
    std::fs::create_dir_all(&modules_dir).unwrap();
    std::fs::create_dir_all(&socket_dir).unwrap();

    let network_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let rpc_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let node = Node::new(
        temp_dir.path().to_str().unwrap(),
        network_addr,
        rpc_addr,
        Some(ProtocolVersion::Regtest),
    )
    .unwrap()
    .with_modules(&modules_dir, &socket_dir)
    .unwrap();

    assert!(node.module_manager().is_some());
}

#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn test_node_with_modules_from_config_disabled() {
    let temp_dir = TempDir::new().unwrap();
    let network_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let rpc_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
    let mut config = NodeConfig::default();
    config.modules = Some(blvm_node::config::ModuleConfig {
        enabled: false,
        modules_dir: temp_dir.path().join("modules").to_string_lossy().into(),
        data_dir: temp_dir.path().join("data").to_string_lossy().into(),
        socket_dir: temp_dir.path().join("sockets").to_string_lossy().into(),
        ..Default::default()
    });

    let node = Node::new(
        temp_dir.path().to_str().unwrap(),
        network_addr,
        rpc_addr,
        Some(ProtocolVersion::Regtest),
    )
    .unwrap()
    .with_modules_from_config(&config)
    .unwrap();

    assert!(node.module_manager().is_none());
}

#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn test_node_testnet_and_mainnet_protocol_init() {
    use blvm_node::config::StorageConfig;

    for version in [ProtocolVersion::Testnet3, ProtocolVersion::BitcoinV1] {
        let temp_dir = TempDir::new().unwrap();
        let network_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
        let rpc_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
        let node = Node::with_storage_config(
            temp_dir.path().to_str().unwrap(),
            network_addr,
            rpc_addr,
            Some(version),
            Some(&StorageConfig::default()),
        )
        .unwrap();
        assert!(node.protocol().get_network_params().magic_bytes.len() == 4);
    }
}

#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn test_node_with_config_applies_settings() {
    let (_dir, mut node) = base_node();
    let mut config = NodeConfig::default();
    config.max_outbound_peers = Some(4);
    node = node.with_config(config).unwrap();
    setup_mining_chain_on(node.storage(), 6).unwrap();
    let report = node.health_check();
    assert!(
        report.overall_status == HealthStatus::Healthy
            || report.overall_status == HealthStatus::Degraded
    );
    assert!(report.uptime_seconds >= 0);
}