rrelayer 0.7.0

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
107

use crate::api::{http::HttpClient, types::ApiResult};
use reqwest::header::{HeaderMap, HeaderValue};
use rrelayer_core::RATE_LIMIT_HEADER_NAME;
use rrelayer_core::common_types::{PagingContext, PagingResult};
use rrelayer_core::relayer::RelayerId;
use rrelayer_core::signing::{SignTextRequest, SignTextResult, SignTypedDataResult};
use rrelayer_core::signing::{SignedTextHistory, SignedTypedDataHistory};
use std::sync::Arc;

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

impl SignApi {
    pub fn new(client: Arc<HttpClient>) -> Self {
        Self { client }
    }

    pub async fn sign_text(
        &self,
        relayer_id: &RelayerId,
        text: &str,
        rate_limit_key: Option<String>,
    ) -> ApiResult<SignTextResult> {
        let mut headers = HeaderMap::new();
        if let Some(rate_limit_key) = rate_limit_key.as_ref() {
            headers.insert(
                RATE_LIMIT_HEADER_NAME,
                HeaderValue::from_str(rate_limit_key).expect("Invalid rate limit key"),
            );
        }

        self.client
            .post_with_headers(
                &format!("signing/relayers/{}/message", relayer_id),
                &SignTextRequest { text: text.to_string() },
                headers,
            )
            .await
    }

    pub async fn sign_typed_data(
        &self,
        relayer_id: &RelayerId,
        typed_data: &alloy::dyn_abi::TypedData,
        rate_limit_key: Option<String>,
    ) -> ApiResult<SignTypedDataResult> {
        let mut headers = HeaderMap::new();
        if let Some(rate_limit_key) = rate_limit_key.as_ref() {
            headers.insert(
                RATE_LIMIT_HEADER_NAME,
                HeaderValue::from_str(rate_limit_key).expect("Invalid rate limit key"),
            );
        }

        self.client
            .post_with_headers(
                &format!("signing/relayers/{}/typed-data", relayer_id),
                typed_data,
                headers,
            )
            .await
    }

    /// Retrieves the signing text history for a specific relayer with pagination.
    ///
    /// # Arguments
    /// * `relayer_id` - The relayer ID to get history for
    /// * `paging_context` - Pagination parameters (limit and offset)
    ///
    /// # Returns
    /// * `Ok(PagingResult<SignedTextHistory>)` - Paginated list of signed text messages
    /// * `Err(ApiSdkError)` - If the API call fails
    pub async fn get_signed_text_history(
        &self,
        relayer_id: &RelayerId,
        paging_context: &PagingContext,
    ) -> ApiResult<PagingResult<SignedTextHistory>> {
        let url = format!(
            "signing/relayers/{}/text-history?limit={}&offset={}",
            relayer_id, paging_context.limit, paging_context.offset
        );
        self.client.get(&url).await
    }

    /// Retrieves the signing typed data history for a specific relayer with pagination.
    ///
    /// # Arguments
    /// * `relayer_id` - The relayer ID to get history for
    /// * `paging_context` - Pagination parameters (limit and offset)
    ///
    /// # Returns
    /// * `Ok(PagingResult<SignedTypedDataHistory>)` - Paginated list of signed typed data messages
    /// * `Err(ApiSdkError)` - If the API call fails
    pub async fn get_signed_typed_data_history(
        &self,
        relayer_id: &RelayerId,
        paging_context: &PagingContext,
    ) -> ApiResult<PagingResult<SignedTypedDataHistory>> {
        let url = format!(
            "signing/relayers/{}/typed-data-history?limit={}&offset={}",
            relayer_id, paging_context.limit, paging_context.offset
        );
        self.client.get(&url).await
    }
}