solana_trader_client_rust/provider/ws/
general.rs

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
use crate::provider::ws::WebSocketClient;
use anyhow::Result;
use solana_trader_proto::api;
use solana_trader_proto::api::{
    GetAccountBalanceRequest, GetRateLimitRequest, GetRecentBlockHashRequest,
    GetRecentBlockHashRequestV2, GetTransactionRequest,
};

impl WebSocketClient {
    pub async fn get_transaction(
        &self,
        request: GetTransactionRequest,
    ) -> anyhow::Result<api::GetTransactionResponse> {
        let params = serde_json::to_value(request)
            .map_err(|e| anyhow::anyhow!("Failed to serialize request: {}", e))?;

        self.conn.request("GetTransaction", params).await
    }

    pub async fn get_recent_block_hash(
        &self,
        request: GetRecentBlockHashRequest,
    ) -> anyhow::Result<api::GetRecentBlockHashResponse> {
        let params = serde_json::to_value(request)
            .map_err(|e| anyhow::anyhow!("Failed to serialize request: {}", e))?;

        self.conn.request("GetRecentBlockHash", params).await
    }

    pub async fn get_recent_block_hash_v2(
        &self,
        request: &GetRecentBlockHashRequestV2,
    ) -> anyhow::Result<api::GetRecentBlockHashResponseV2> {
        let params = serde_json::to_value(request)
            .map_err(|e| anyhow::anyhow!("Failed to serialize request: {}", e))?;

        self.conn.request("GetRecentBlockHashV2", params).await
    }
    pub async fn get_rate_limit(
        &self,
        request: GetRateLimitRequest,
    ) -> anyhow::Result<api::GetRateLimitResponse> {
        let params = serde_json::to_value(request)
            .map_err(|e| anyhow::anyhow!("Failed to serialize request: {}", e))?;

        self.conn.request("GetRateLimit", params).await
    }

    pub async fn get_account_balance_v2(
        &self,
        request: GetAccountBalanceRequest,
    ) -> anyhow::Result<api::GetAccountBalanceResponse> {
        let params = serde_json::to_value(request)
            .map_err(|e| anyhow::anyhow!("Failed to serialize request: {}", e))?;

        self.conn.request("GetAccountBalanceV2", params).await
    }

    pub async fn get_priority_fee(
        &self,
        project: api::Project,
        percentile: Option<f64>,
    ) -> Result<api::GetPriorityFeeResponse> {
        let request = api::GetPriorityFeeRequest {
            project: project as i32,
            percentile,
        };

        let params = serde_json::to_value(request)
            .map_err(|e| anyhow::anyhow!("Failed to serialize request: {}", e))?;

        self.conn.request("GetPriorityFee", params).await
    }

    pub async fn get_priority_fee_by_program(
        &self,
        programs: Vec<String>,
    ) -> Result<api::GetPriorityFeeByProgramResponse> {
        let request = api::GetPriorityFeeByProgramRequest { programs };

        let params = serde_json::to_value(request)
            .map_err(|e| anyhow::anyhow!("Failed to serialize request: {}", e))?;

        self.conn.request("GetPriorityFeeByProgram", params).await
    }

    pub async fn get_token_accounts(
        &self,
        owner_address: String,
    ) -> Result<api::GetTokenAccountsResponse> {
        let request = api::GetTokenAccountsRequest { owner_address };

        let params = serde_json::to_value(request)
            .map_err(|e| anyhow::anyhow!("Failed to serialize request: {}", e))?;

        self.conn.request("GetTokenAccounts", params).await
    }

    pub async fn get_account_balance(
        &self,
        owner_address: String,
    ) -> Result<api::GetAccountBalanceResponse> {
        let request = api::GetAccountBalanceRequest { owner_address };

        let params = serde_json::to_value(request)
            .map_err(|e| anyhow::anyhow!("Failed to serialize request: {}", e))?;

        self.conn.request("GetAccountBalance", params).await
    }

    pub async fn get_leader_schedule(
        &self,
        max_slots: u64,
    ) -> Result<api::GetLeaderScheduleResponse> {
        let request = api::GetLeaderScheduleRequest { max_slots };

        let params = serde_json::to_value(request)
            .map_err(|e| anyhow::anyhow!("Failed to serialize request: {}", e))?;

        self.conn.request("GetLeaderSchedule", params).await
    }
}