blvm-node 0.1.74

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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Network endpoints
//!
//! GET /api/v1/network/info
//! GET /api/v1/network/peers
//! GET /api/v1/network/connections/count
//! GET /api/v1/network/totals
//! GET /api/v1/network/nodes
//! GET /api/v1/network/nodes/addresses
//! GET /api/v1/network/bans
//! POST /api/v1/network/ping
//! POST /api/v1/network/nodes
//! POST /api/v1/network/active
//! POST /api/v1/network/bans
//! DELETE /api/v1/network/nodes/{address}
//! DELETE /api/v1/network/bans

use crate::rpc::network::NetworkRpc;
use anyhow::Result;
use serde_json::{Value, json};

/// Get network information
pub async fn get_network_info(network: &NetworkRpc) -> Result<Value> {
    let info = network.get_network_info().await?;
    Ok(info)
}

/// Get peer information
pub async fn get_network_peers(network: &NetworkRpc) -> Result<Value> {
    let peers = network.get_peer_info().await?;
    Ok(peers)
}

/// Get connection count
pub async fn get_connection_count(network: &NetworkRpc) -> Result<Value> {
    let params = json!([]);
    let count = network.get_connection_count(&params).await?;
    Ok(count)
}

/// Get network totals
pub async fn get_net_totals(network: &NetworkRpc) -> Result<Value> {
    let params = json!([]);
    let totals = network.get_net_totals(&params).await?;
    Ok(totals)
}

/// Get added node info
pub async fn get_added_node_info(
    network: &NetworkRpc,
    node: Option<&str>,
    dns: bool,
) -> Result<Value> {
    let params = if let Some(n) = node {
        json!([n, dns])
    } else {
        json!([])
    };
    let info = network.getaddednodeinfo(&params).await?;
    Ok(info)
}

/// Get node addresses
pub async fn get_node_addresses(network: &NetworkRpc, count: Option<u32>) -> Result<Value> {
    let params = if let Some(c) = count {
        json!([c])
    } else {
        json!([])
    };
    let addresses = network.getnodeaddresses(&params).await?;
    Ok(addresses)
}

/// List banned nodes
pub async fn list_banned(network: &NetworkRpc) -> Result<Value> {
    let params = json!([]);
    let banned = network.list_banned(&params).await?;
    Ok(banned)
}

/// Ping network
pub async fn ping_network(network: &NetworkRpc) -> Result<Value> {
    let params = json!([]);
    let result = network.ping(&params).await?;
    Ok(result)
}

/// Add node
pub async fn add_node(network: &NetworkRpc, address: &str, command: &str) -> Result<Value> {
    let params = json!([address, command]);
    let result = network.add_node(&params).await?;
    Ok(result)
}

/// Disconnect node
pub async fn disconnect_node(network: &NetworkRpc, address: &str) -> Result<Value> {
    let params = json!([address]);
    let result = network.disconnect_node(&params).await?;
    Ok(result)
}

/// Set network active
pub async fn set_network_active(network: &NetworkRpc, state: bool) -> Result<Value> {
    let params = json!([state]);
    let result = network.setnetworkactive(&params).await?;
    Ok(result)
}

/// Apply `state` when the body has one. A missing field leaves the current flag.
pub async fn set_network_active_body(network: &NetworkRpc, body: &Value) -> Result<Value> {
    match body.get("state").and_then(|v| v.as_bool()) {
        Some(state) => set_network_active(network, state).await,
        None => {
            let info = network.get_network_info().await?;
            Ok(json!(info["networkactive"]))
        }
    }
}

/// Set ban
pub async fn set_ban(
    network: &NetworkRpc,
    subnet: &str,
    command: &str,
    bantime: Option<u64>,
    absolute: Option<bool>,
) -> Result<Value> {
    if absolute.is_some() && bantime.is_none() {
        anyhow::bail!("setban: absolute requires bantime");
    }
    let mut params = json!([subnet, command]);
    if let Some(bt) = bantime {
        params.as_array_mut().unwrap().push(json!(bt));
    }
    if let Some(abs) = absolute {
        params.as_array_mut().unwrap().push(json!(abs));
    }
    let result = network.set_ban(&params).await?;
    Ok(result)
}

/// Clear banned nodes
pub async fn clear_banned(network: &NetworkRpc) -> Result<Value> {
    let params = json!([]);
    let result = network.clear_banned(&params).await?;
    Ok(result)
}