rostrum 14.0.1

An efficient implementation of Electrum Server with token support
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
140
141
142
143
144
145
146
147
148
149

use std::{collections::hash_map::DefaultHasher, hash::Hasher, net::IpAddr, time::Instant};

use super::FALLBACK_VERSION;

#[async_trait::async_trait]
pub trait ServerPeer: Send + Sync {
    /// Every implementation of this trait must produce
    /// the same ID, given the same data.
    fn id(&self) -> u64 {
        let mut hasher = DefaultHasher::new();
        if let Some(p) = self.tcp_port() {
            hasher.write_u16(p)
        };
        if let Some(p) = self.ssl_port() {
            hasher.write_u16(p)
        };
        hasher.write(self.ip().to_string().as_bytes());
        hasher.finish()
    }
    fn tcp_port(&self) -> Option<u16>;
    fn ssl_port(&self) -> Option<u16>;
    fn ip(&self) -> IpAddr;
    fn hostname(&self) -> Option<String>;
    fn pretty_hostname(&self) -> String;
    /// maximum protocol version
    fn version(&self) -> String;
    fn last_candidate_request(&self) -> Option<Instant>;
}

impl std::fmt::Display for dyn ServerPeer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        // Strip weird utf-8 characters.
        let safe_hostname = self
            .hostname()
            .unwrap_or(self.ip().to_string())
            .chars()
            .filter(|c| c.is_ascii())
            .collect::<String>();
        write!(
            f,
            "Peer {} - IP: {} TCP: {} SSL: {} version: {}",
            safe_hostname,
            self.ip(),
            self.tcp_port().unwrap_or_default(),
            self.ssl_port().unwrap_or_default(),
            self.version()
        )
    }
}

/**
 * A server that has announced itself to us, but we have not verified.
 */
#[derive(Debug, Clone)]
pub struct CandidatePeer {
    pub(crate) tcp_port: Option<u16>,
    pub(crate) ssl_port: Option<u16>,
    #[allow(dead_code)]
    pub(crate) ws_port: Option<u16>,
    #[allow(dead_code)]
    pub(crate) wss_port: Option<u16>,
    pub(crate) hostname: Option<String>,
    pub(crate) ip: IpAddr,
    pub(crate) version: Option<String>,
}

impl ServerPeer for CandidatePeer {
    fn tcp_port(&self) -> Option<u16> {
        self.tcp_port
    }

    fn ssl_port(&self) -> Option<u16> {
        self.ssl_port
    }

    fn ip(&self) -> IpAddr {
        self.ip
    }

    fn hostname(&self) -> Option<String> {
        self.hostname.clone()
    }

    fn version(&self) -> String {
        match self.version.as_ref() {
            Some(v) => v.clone(),
            None => FALLBACK_VERSION.to_owned(),
        }
    }

    fn pretty_hostname(&self) -> String {
        if let Some(h) = self.hostname() {
            format!("{} (IP: {})", h, self.ip())
        } else {
            self.ip().to_string()
        }
    }

    fn last_candidate_request(&self) -> Option<Instant> {
        None
    }
}

#[derive(Debug, Clone)]
pub struct GoodKnownPeer {
    pub tcp_port: Option<u16>,
    pub ssl_port: Option<u16>,
    pub hostname: Option<String>,
    pub ip: IpAddr,
    /// Last time we checked if this was a good peer.
    pub last_visit: Instant,
    /// Last time we asked it for server peer candidates
    pub last_candidate_request: Option<Instant>,
    pub version: String,
}

impl ServerPeer for GoodKnownPeer {
    fn tcp_port(&self) -> Option<u16> {
        self.tcp_port
    }

    fn ssl_port(&self) -> Option<u16> {
        self.ssl_port
    }

    fn ip(&self) -> IpAddr {
        self.ip
    }

    fn hostname(&self) -> Option<String> {
        self.hostname.clone()
    }

    fn version(&self) -> String {
        self.version.clone()
    }

    fn pretty_hostname(&self) -> String {
        if let Some(h) = self.hostname() {
            format!("{} (IP: {})", h, self.ip())
        } else {
            self.ip().to_string()
        }
    }

    fn last_candidate_request(&self) -> Option<Instant> {
        self.last_candidate_request
    }
}