kaspa-wrpc-server 0.15.0

Kaspa wRPC server
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

use crate::service::WrpcEncoding;
use kaspa_consensus_core::network::NetworkType;
use kaspa_utils::networking::ContextualNetAddress;
use serde::Deserialize;
use std::{net::AddrParseError, str::FromStr};

#[derive(Clone, Debug, Deserialize)]
#[serde(rename = "lowercase")]
pub enum WrpcNetAddress {
    Default,
    Public,
    Custom(ContextualNetAddress),
}

impl WrpcNetAddress {
    pub fn to_address(&self, network_type: &NetworkType, encoding: &WrpcEncoding) -> ContextualNetAddress {
        match self {
            WrpcNetAddress::Default => {
                let port = match encoding {
                    WrpcEncoding::Borsh => network_type.default_borsh_rpc_port(),
                    WrpcEncoding::SerdeJson => network_type.default_json_rpc_port(),
                };
                format!("127.0.0.1:{port}").parse().unwrap()
            }
            WrpcNetAddress::Public => {
                let port = match encoding {
                    WrpcEncoding::Borsh => network_type.default_borsh_rpc_port(),
                    WrpcEncoding::SerdeJson => network_type.default_json_rpc_port(),
                };
                format!("0.0.0.0:{port}").parse().unwrap()
            }
            WrpcNetAddress::Custom(address) => {
                if address.port_not_specified() {
                    let port = match encoding {
                        WrpcEncoding::Borsh => network_type.default_borsh_rpc_port(),
                        WrpcEncoding::SerdeJson => network_type.default_json_rpc_port(),
                    };
                    address.with_port(port)
                } else {
                    *address
                }
            }
        }
    }
}
impl FromStr for WrpcNetAddress {
    type Err = AddrParseError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "default" => Ok(WrpcNetAddress::Default),
            "public" => Ok(WrpcNetAddress::Public),
            _ => {
                let addr: ContextualNetAddress = s.parse()?;
                Ok(Self::Custom(addr))
            }
        }
    }
}

impl TryFrom<&str> for WrpcNetAddress {
    type Error = AddrParseError;

    fn try_from(s: &str) -> Result<Self, Self::Error> {
        WrpcNetAddress::from_str(s)
    }
}

impl TryFrom<String> for WrpcNetAddress {
    type Error = AddrParseError;

    fn try_from(s: String) -> Result<Self, Self::Error> {
        WrpcNetAddress::from_str(&s)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use kaspa_utils::networking::IpAddress;

    #[test]
    fn test_wrpc_net_address_from_str() {
        // Addresses
        let port: u16 = 8080;
        let addr = format!("1.2.3.4:{port}").parse::<WrpcNetAddress>().unwrap();
        let addr_without_port = "1.2.3.4".parse::<WrpcNetAddress>().unwrap();
        let ip_addr = "1.2.3.4".parse::<IpAddress>().unwrap();
        // Test
        for schema in WrpcEncoding::iter() {
            for network in NetworkType::iter() {
                let expected_port = match schema {
                    WrpcEncoding::Borsh => Some(network.default_borsh_rpc_port()),
                    WrpcEncoding::SerdeJson => Some(network.default_json_rpc_port()),
                };
                // Custom address with port
                assert_eq!(addr.to_address(&network, schema), ContextualNetAddress::new(ip_addr, Some(port)));
                // Custom address without port
                assert_eq!(addr_without_port.to_address(&network, schema), ContextualNetAddress::new(ip_addr, expected_port))
            }
        }
    }
}