blockchain-client 1.0.2

A client for interacting with BTC-based blockchains.
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
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

use serde::{Deserialize, Serialize};
use std::time::Duration;

#[derive(Debug, Clone)]
pub struct RpcConfig {
    pub url: String,
    pub username: String,
    pub password: String,
    pub timeout_secs: u64,
    pub pool_max_idle_per_host: usize,
    pub pool_idle_timeout_secs: u64,
    pub tcp_keepalive_secs: u64,
}

impl RpcConfig {
    pub fn new(url: String, username: String, password: String) -> Self {
        Self {
            url,
            username,
            password,
            timeout_secs: 30,
            pool_max_idle_per_host: 4,
            pool_idle_timeout_secs: 300,
            tcp_keepalive_secs: 60,
        }
    }

    pub fn with_timeout(mut self, timeout_secs: u64) -> Self {
        self.timeout_secs = timeout_secs;
        self
    }

    pub fn with_pool_max_idle_per_host(mut self, pool_max_idle_per_host: usize) -> Self {
        self.pool_max_idle_per_host = pool_max_idle_per_host.max(1);
        self
    }

    pub fn with_pool_idle_timeout(mut self, pool_idle_timeout_secs: u64) -> Self {
        self.pool_idle_timeout_secs = pool_idle_timeout_secs;
        self
    }

    pub fn with_tcp_keepalive(mut self, tcp_keepalive_secs: u64) -> Self {
        self.tcp_keepalive_secs = tcp_keepalive_secs;
        self
    }

    pub fn with_connection_pool(
        mut self,
        pool_max_idle_per_host: usize,
        pool_idle_timeout_secs: u64,
        tcp_keepalive_secs: u64,
    ) -> Self {
        self.pool_max_idle_per_host = pool_max_idle_per_host.max(1);
        self.pool_idle_timeout_secs = pool_idle_timeout_secs;
        self.tcp_keepalive_secs = tcp_keepalive_secs;
        self
    }

    pub fn timeout(&self) -> Duration {
        Duration::from_secs(self.timeout_secs)
    }

    pub fn pool_idle_timeout(&self) -> Duration {
        Duration::from_secs(self.pool_idle_timeout_secs)
    }

    pub fn tcp_keepalive(&self) -> Duration {
        Duration::from_secs(self.tcp_keepalive_secs)
    }
}

#[derive(Debug, Serialize)]
pub struct JsonRpcRequest {
    pub jsonrpc: String,
    pub id: String,
    pub method: String,
    pub params: serde_json::Value,
}

impl JsonRpcRequest {
    pub fn new(method: String, params: serde_json::Value) -> Self {
        Self {
            jsonrpc: "1.0".to_string(),
            id: "blockchain-client".to_string(),
            method,
            params,
        }
    }
}

#[derive(Debug, Deserialize)]
pub struct JsonRpcResponse<T> {
    pub result: Option<T>,
    pub error: Option<JsonRpcError>,
    pub id: String,
}

#[derive(Debug, Deserialize)]
pub struct JsonRpcError {
    pub code: i32,
    pub message: String,
}

#[cfg(test)]
mod tests {
    use super::RpcConfig;
    use std::time::Duration;

    #[test]
    fn rpc_config_uses_pooling_defaults() {
        let config = RpcConfig::new(
            "http://localhost:9332".to_string(),
            "user".to_string(),
            "pass".to_string(),
        );

        assert_eq!(config.timeout(), Duration::from_secs(30));
        assert_eq!(config.pool_max_idle_per_host, 4);
        assert_eq!(config.pool_idle_timeout(), Duration::from_secs(300));
        assert_eq!(config.tcp_keepalive(), Duration::from_secs(60));
    }

    #[test]
    fn rpc_config_allows_pooling_overrides() {
        let config = RpcConfig::new(
            "http://localhost:9332".to_string(),
            "user".to_string(),
            "pass".to_string(),
        )
        .with_connection_pool(8, 600, 120)
        .with_timeout(45);

        assert_eq!(config.timeout(), Duration::from_secs(45));
        assert_eq!(config.pool_max_idle_per_host, 8);
        assert_eq!(config.pool_idle_timeout(), Duration::from_secs(600));
        assert_eq!(config.tcp_keepalive(), Duration::from_secs(120));
    }
}