rrelayer 0.1.1

The official Rust SDK for interacting with rrelayer services - a powerful blockchain transaction relay service
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

mod allowlist;

pub use allowlist::RelayerAllowlist;
use rrelayer_core::{
    common_types::{PagingContext, PagingResult},
    relayer::{CreateRelayerResult, GetRelayerResult, Relayer, RelayerId},
};
use std::sync::Arc;

use crate::api::{
    http::HttpClient,
    types::{ApiResult, ApiSdkError},
};

#[derive(Debug, Clone)]
pub struct RelayerApi {
    client: Arc<HttpClient>,
    pub allowlist: RelayerAllowlist,
}

impl RelayerApi {
    pub fn new(client: Arc<HttpClient>) -> Self {
        Self { allowlist: RelayerAllowlist::new(client.clone()), client }
    }

    pub async fn get_all(
        &self,
        chain_id: Option<u64>,
        paging: &PagingContext,
    ) -> ApiResult<PagingResult<Relayer>> {
        let mut query = serde_json::Map::new();
        if let Some(chain_id) = chain_id {
            query.insert("chainId".to_string(), chain_id.to_string().into());
        }

        let paging_value = serde_json::to_value(paging)
            .map_err(|e| ApiSdkError::SerializationError(e.to_string()))?;

        query.extend(
            paging_value
                .as_object()
                .ok_or_else(|| {
                    ApiSdkError::SerializationError("Failed to convert paging to object".into())
                })?
                .clone(),
        );

        self.client.get_with_query("relayers", Some(&query)).await
    }

    pub async fn get(&self, id: &RelayerId) -> ApiResult<Option<GetRelayerResult>> {
        self.client.get_or_none(&format!("relayers/{}", id)).await
    }

    pub async fn create(&self, chain_id: u64, name: &str) -> ApiResult<CreateRelayerResult> {
        self.client
            .post(&format!("relayers/{}/new", chain_id), &serde_json::json!({ "name": name }))
            .await
    }

    pub async fn clone(
        &self,
        id: &RelayerId,
        chain_id: u64,
        name: &str,
    ) -> ApiResult<CreateRelayerResult> {
        self.client
            .post(
                &format!("relayers/{}/clone", id),
                &serde_json::json!({ "new_relayer_name": name, "chain_id": chain_id }),
            )
            .await
    }

    pub async fn delete(&self, id: &RelayerId) -> ApiResult<()> {
        self.client.delete_status(&format!("relayers/{}", id)).await
    }

    pub async fn pause(&self, id: &RelayerId) -> ApiResult<()> {
        self.client.put_status(&format!("relayers/{}/pause", id), &()).await
    }

    pub async fn unpause(&self, id: &RelayerId) -> ApiResult<()> {
        self.client.put_status(&format!("relayers/{}/unpause", id), &()).await
    }

    pub async fn update_eip1559_status(&self, id: &RelayerId, status: bool) -> ApiResult<()> {
        self.client.put_status(&format!("relayers/{}/gas/eip1559/{}", id, status), &()).await
    }

    pub async fn update_max_gas_price<T: ToString>(&self, id: &RelayerId, cap: T) -> ApiResult<()> {
        self.client.put_status(&format!("relayers/{}/gas/max/{}", id, cap.to_string()), &()).await
    }

    pub async fn remove_max_gas_price(&self, id: &RelayerId) -> ApiResult<()> {
        self.client.put_status(&format!("relayers/{}/gas/max/0", id), &()).await
    }

    pub async fn get_pending_count(&self, id: &RelayerId) -> ApiResult<u32> {
        self.client.get(&format!("transactions/relayers/{}/pending/count", id)).await
    }

    pub async fn get_inmempool_count(&self, id: &RelayerId) -> ApiResult<u32> {
        self.client.get(&format!("transactions/relayers/{}/inmempool/count", id)).await
    }
}