tycho-simulation 0.255.1

Provides tools for interacting with protocol states, calculating spot prices, and quoting token swaps.
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 std::env;

use crate::rfq::errors::RFQError;

/// Hashflow authentication configuration
pub struct HashflowAuth {
    pub user: String,
    pub key: String,
}

/// Bebop authentication configuration
pub struct BebopAuth {
    pub user: String,
    pub key: String,
}

/// Read Hashflow authentication from environment variables
/// Returns the HASHFLOW_USER and HASHFLOW_KEY environment variables
pub fn get_hashflow_auth() -> Result<HashflowAuth, RFQError> {
    let user = env::var("HASHFLOW_USER").map_err(|_| {
        RFQError::InvalidInput("HASHFLOW_USER environment variable is required".into())
    })?;

    let key = env::var("HASHFLOW_KEY").map_err(|_| {
        RFQError::InvalidInput("HASHFLOW_KEY environment variable is required".into())
    })?;

    Ok(HashflowAuth { user, key })
}

/// Liquorice authentication configuration
pub struct LiquoriceAuth {
    pub solver: String,
    pub key: String,
}

/// Read Liquorice authentication from environment variables
/// Returns the LIQUORICE_USER and LIQUORICE_KEY environment variables
pub fn get_liquorice_auth() -> Result<LiquoriceAuth, RFQError> {
    let solver = env::var("LIQUORICE_USER").map_err(|_| {
        RFQError::InvalidInput("LIQUORICE_USER environment variable is required".into())
    })?;

    let key = env::var("LIQUORICE_KEY").map_err(|_| {
        RFQError::InvalidInput("LIQUORICE_KEY environment variable is required".into())
    })?;

    Ok(LiquoriceAuth { solver, key })
}

/// Read Bebop authentication from environment variables
/// Returns the BEBOP_USER and BEBOP_KEY environment variables
pub fn get_bebop_auth() -> Result<BebopAuth, RFQError> {
    let user = env::var("BEBOP_USER").map_err(|_| {
        RFQError::InvalidInput("BEBOP_USER environment variable is required".into())
    })?;

    let key = env::var("BEBOP_KEY")
        .map_err(|_| RFQError::InvalidInput("BEBOP_KEY environment variable is required".into()))?;

    Ok(BebopAuth { user, key })
}

#[cfg(test)]
mod tests {
    use std::env;

    use super::*;

    #[test]
    fn test_hashflow_auth_success() {
        env::set_var("HASHFLOW_USER", "test_user");
        env::set_var("HASHFLOW_KEY", "test_key");

        let auth = get_hashflow_auth().unwrap();
        assert_eq!(auth.user, "test_user");
        assert_eq!(auth.key, "test_key");

        env::remove_var("HASHFLOW_USER");
        env::remove_var("HASHFLOW_KEY");
    }

    #[test]
    fn test_hashflow_auth_missing_user() {
        env::remove_var("HASHFLOW_USER");
        env::set_var("HASHFLOW_KEY", "test_key");

        let result = get_hashflow_auth();
        assert!(result.is_err());

        env::remove_var("HASHFLOW_KEY");
    }

    #[test]
    fn test_hashflow_auth_missing_key() {
        env::set_var("HASHFLOW_USER", "test_user");
        env::remove_var("HASHFLOW_KEY");

        let result = get_hashflow_auth();
        assert!(result.is_err());

        env::remove_var("HASHFLOW_USER");
    }

    #[test]
    fn test_bebop_auth_success() {
        env::set_var("BEBOP_USER", "test_user");
        env::set_var("BEBOP_KEY", "test_key");

        let auth = get_bebop_auth().unwrap();
        assert_eq!(auth.user, "test_user");
        assert_eq!(auth.key, "test_key");

        env::remove_var("BEBOP_USER");
        env::remove_var("BEBOP_KEY");
    }

    #[test]
    fn test_bebop_auth_missing_user() {
        env::remove_var("BEBOP_USER");
        env::set_var("BEBOP_KEY", "test_key");

        let result = get_bebop_auth();
        assert!(result.is_err());

        env::remove_var("BEBOP_KEY");
    }

    #[test]
    fn test_bebop_auth_missing_key() {
        env::set_var("BEBOP_USER", "test_user");
        env::remove_var("BEBOP_KEY");

        let result = get_bebop_auth();
        assert!(result.is_err());

        env::remove_var("BEBOP_USER");
    }
}