chik-sdk-client 0.20.0

Utilities for connecting to Chik full node peers via the light wallet protocol.
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

use std::{
    collections::{HashMap, HashSet},
    fmt,
    net::{IpAddr, SocketAddr},
    ops::Deref,
    sync::Arc,
    time::{SystemTime, UNIX_EPOCH},
};

use chik_protocol::Message;
use tokio::sync::{mpsc, Mutex};
use tokio_tungstenite::Connector;

use crate::{connect_peer, ClientError, Network, Peer, PeerOptions};

#[derive(Clone)]
pub struct Client {
    network_id: String,
    network: Network,
    connector: Connector,
    state: Arc<Mutex<ClientState>>,
}

#[allow(clippy::missing_fields_in_debug)]
impl fmt::Debug for Client {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Client")
            .field("network_id", &self.network_id)
            .field("network", &self.network)
            .finish()
    }
}

impl Deref for Client {
    type Target = Mutex<ClientState>;

    fn deref(&self) -> &Self::Target {
        &self.state
    }
}

#[derive(Debug, Default, Clone)]
pub struct ClientState {
    peers: HashMap<IpAddr, Peer>,
    banned_peers: HashMap<IpAddr, u64>,
    trusted_peers: HashSet<IpAddr>,
}

impl Client {
    pub fn new(network_id: String, network: Network, connector: Connector) -> Self {
        Self {
            network_id,
            network,
            connector,
            state: Arc::new(Mutex::new(ClientState::default())),
        }
    }

    pub fn network_id(&self) -> &str {
        &self.network_id
    }

    pub fn network(&self) -> &Network {
        &self.network
    }

    pub async fn connect(
        &self,
        socket_addr: SocketAddr,
        options: PeerOptions,
    ) -> Result<mpsc::Receiver<Message>, ClientError> {
        let (peer, receiver) = connect_peer(
            self.network_id.clone(),
            self.connector.clone(),
            socket_addr,
            options,
        )
        .await?;

        let mut state = self.state.lock().await;
        let ip_addr = peer.socket_addr().ip();

        if state.is_banned(&ip_addr) {
            return Err(ClientError::BannedPeer);
        }

        state.peers.insert(peer.socket_addr().ip(), peer);

        Ok(receiver)
    }
}

impl ClientState {
    pub fn peers(&self) -> impl Iterator<Item = &Peer> {
        self.peers.values()
    }

    pub fn disconnect(&mut self, ip_addr: &IpAddr) -> bool {
        self.peers.remove(ip_addr).is_some()
    }

    pub fn is_banned(&self, ip_addr: &IpAddr) -> bool {
        self.banned_peers.contains_key(ip_addr)
    }

    pub fn is_trusted(&self, ip_addr: &IpAddr) -> bool {
        self.trusted_peers.contains(ip_addr)
    }

    pub fn ban(&mut self, ip_addr: IpAddr) -> bool {
        if self.is_trusted(&ip_addr) {
            return false;
        }

        let timestamp = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .expect("Time went backwards")
            .as_secs();

        self.disconnect(&ip_addr);
        self.banned_peers.insert(ip_addr, timestamp).is_none()
    }

    pub fn unban(&mut self, ip_addr: IpAddr) -> bool {
        self.banned_peers.remove(&ip_addr).is_some()
    }

    pub fn trust(&mut self, ip_addr: IpAddr) -> bool {
        let result = self.trusted_peers.insert(ip_addr);
        self.banned_peers.remove(&ip_addr);
        result
    }

    pub fn untrust(&mut self, ip_addr: IpAddr) -> bool {
        self.trusted_peers.remove(&ip_addr)
    }
}