simulator-client 0.7.2

Async WebSocket client for the Solana simulator backtest API
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

use thiserror::Error;

/// Error converting a URL scheme.
#[derive(Debug, Error)]
pub enum UrlError {
    #[error("cannot derive WebSocket URL from `{url}`: expected http:// or https:// scheme")]
    InvalidScheme { url: String },
}

/// Convert an `http(s)://` RPC endpoint URL to a `ws(s)://` URL.
pub fn http_to_ws_url(url: &str) -> Result<String, UrlError> {
    let scheme = if url.starts_with("https://") {
        "wss"
    } else if url.starts_with("http://") {
        "ws"
    } else {
        return Err(UrlError::InvalidScheme {
            url: url.to_string(),
        });
    };
    let rest = url.split_once("://").map(|x| x.1).unwrap_or(url);
    Ok(format!("{scheme}://{rest}"))
}

/// Derive an HTTP base URL from a WebSocket URL.
/// `wss://host:port/path` → `https://host:port`
pub fn http_base_from_ws_url(ws_url: &str) -> String {
    let http = ws_url
        .replacen("wss://", "https://", 1)
        .replacen("ws://", "http://", 1);
    if let Some(start) = http.find("://").map(|i| i + 3)
        && let Some(slash) = http[start..].find('/')
    {
        return http[..start + slash].to_string();
    }
    http
}

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

    #[test]
    fn http_to_ws_converts_http() {
        assert_eq!(
            http_to_ws_url("http://localhost:8899").unwrap(),
            "ws://localhost:8899"
        );
    }

    #[test]
    fn http_to_ws_converts_https() {
        assert_eq!(
            http_to_ws_url("https://api.mainnet-beta.solana.com").unwrap(),
            "wss://api.mainnet-beta.solana.com"
        );
    }

    #[test]
    fn http_to_ws_rejects_other_schemes() {
        assert!(matches!(
            http_to_ws_url("ws://example.com"),
            Err(UrlError::InvalidScheme { .. })
        ));
        assert!(matches!(
            http_to_ws_url("ftp://example.com"),
            Err(UrlError::InvalidScheme { .. })
        ));
        assert!(matches!(
            http_to_ws_url("example.com"),
            Err(UrlError::InvalidScheme { .. })
        ));
    }

    #[test]
    fn http_base_strips_path() {
        assert_eq!(
            http_base_from_ws_url("wss://host:8900/backtest"),
            "https://host:8900"
        );
        assert_eq!(
            http_base_from_ws_url("ws://localhost:8900/backtest"),
            "http://localhost:8900"
        );
    }

    #[test]
    fn http_base_no_path() {
        assert_eq!(
            http_base_from_ws_url("wss://host:8900"),
            "https://host:8900"
        );
    }
}