solana_trader_client_rust/provider/grpc/
quote.rs

1use anyhow::Result;
2use solana_trader_proto::api;
3use tonic::Request;
4
5use super::GrpcClient;
6
7impl GrpcClient {
8    pub async fn get_raydium_quotes(
9        &mut self,
10        request: &api::GetRaydiumQuotesRequest,
11    ) -> Result<api::GetRaydiumQuotesResponse> {
12        let response = self
13            .client
14            .get_raydium_quotes(Request::new(request.clone()))
15            .await
16            .map_err(|e| anyhow::anyhow!("GetRaydiumQuotes error: {}", e))?;
17
18        Ok(response.into_inner())
19    }
20
21    pub async fn get_raydium_cpmm_quotes(
22        &mut self,
23        request: &api::GetRaydiumCpmmQuotesRequest,
24    ) -> Result<api::GetRaydiumCpmmQuotesResponse> {
25        let response = self
26            .client
27            .get_raydium_cpmm_quotes(Request::new(request.clone()))
28            .await
29            .map_err(|e| anyhow::anyhow!("GetRaydiumCPMMQuotes error: {}", e))?;
30
31        Ok(response.into_inner())
32    }
33
34    pub async fn get_raydium_clmm_quotes(
35        &mut self,
36        request: &api::GetRaydiumClmmQuotesRequest,
37    ) -> Result<api::GetRaydiumClmmQuotesResponse> {
38        let response = self
39            .client
40            .get_raydium_clmm_quotes(Request::new(request.clone()))
41            .await
42            .map_err(|e| anyhow::anyhow!("GetRaydiumCLMMQuotes error: {}", e))?;
43
44        Ok(response.into_inner())
45    }
46
47    pub async fn get_pump_fun_quotes(
48        &mut self,
49        request: &api::GetPumpFunQuotesRequest,
50    ) -> Result<api::GetPumpFunQuotesResponse> {
51        let response = self
52            .client
53            .get_pump_fun_quotes(Request::new(request.clone()))
54            .await
55            .map_err(|e| anyhow::anyhow!("GetPumpFunQuotes error: {}", e))?;
56
57        Ok(response.into_inner())
58    }
59
60    // NOTE: Fast mode is not used as of 11/1/24, breaks the endpoint.
61    pub async fn get_jupiter_quotes(
62        &mut self,
63        request: &api::GetJupiterQuotesRequest,
64    ) -> Result<api::GetJupiterQuotesResponse> {
65        let req = Request::new(request.clone());
66
67        let response = self
68            .client
69            .get_jupiter_quotes(req)
70            .await
71            .map_err(|e| anyhow::anyhow!("GetJupiterQuotes error: {}", e))?;
72
73        Ok(response.into_inner())
74    }
75
76    pub async fn get_quotes(
77        &mut self,
78        request: &api::GetQuotesRequest,
79    ) -> Result<api::GetQuotesResponse> {
80        let response = self
81            .client
82            .get_quotes(Request::new(request.clone()))
83            .await
84            .map_err(|e| anyhow::anyhow!("GetQuotes error: {}", e))?;
85
86        Ok(response.into_inner())
87    }
88
89    pub async fn get_raydium_prices(
90        &mut self,
91        tokens: Vec<String>,
92    ) -> Result<api::GetRaydiumPricesResponse> {
93        let request = Request::new(api::GetRaydiumPricesRequest { tokens });
94
95        let response = self
96            .client
97            .get_raydium_prices(request)
98            .await
99            .map_err(|e| anyhow::anyhow!("GetRaydiumPrices error: {}", e))?;
100
101        Ok(response.into_inner())
102    }
103
104    pub async fn get_jupiter_prices(
105        &mut self,
106        tokens: Vec<String>,
107    ) -> Result<api::GetJupiterPricesResponse> {
108        let request = Request::new(api::GetJupiterPricesRequest { tokens });
109
110        let response = self
111            .client
112            .get_jupiter_prices(request)
113            .await
114            .map_err(|e| anyhow::anyhow!("GetJupiterPrices error: {}", e))?;
115
116        Ok(response.into_inner())
117    }
118}