rain_sdk/api/signatures.rs
1//! Signatures API
2//!
3//! This module provides functionality to get payment and withdrawal signatures.
4
5use crate::client::RainClient;
6use crate::error::Result;
7use crate::models::signatures::*;
8use uuid::Uuid;
9
10impl RainClient {
11 /// Get payment signature for a company
12 ///
13 /// # Arguments
14 ///
15 /// * `company_id` - The unique identifier of the company
16 /// * `params` - Query parameters for the signature request
17 ///
18 /// # Returns
19 ///
20 /// Returns a [`PaymentSignatureResponse`] which can be either pending or ready.
21 ///
22 /// # Examples
23 ///
24 /// ```no_run
25 /// use rain_sdk::{RainClient, Config, Environment, AuthConfig};
26 /// use rain_sdk::models::signatures::PaymentSignatureParams;
27 /// use uuid::Uuid;
28 ///
29 /// # #[cfg(feature = "async")]
30 /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
31 /// let config = Config::new(Environment::Dev);
32 /// let auth = AuthConfig::with_api_key("your-api-key".to_string());
33 /// let client = RainClient::new(config, auth)?;
34 ///
35 /// let company_id = Uuid::new_v4();
36 /// let params = PaymentSignatureParams {
37 /// chain_id: Some(1),
38 /// token: "0xabc123...".to_string(),
39 /// amount: "1000000".to_string(),
40 /// admin_address: "0xdef456...".to_string(),
41 /// is_amount_native: Some(false),
42 /// rain_collateral_contract_id: None,
43 /// };
44 /// let response = client.get_company_payment_signature(&company_id, ¶ms).await?;
45 /// # Ok(())
46 /// # }
47 /// ```
48 #[cfg(feature = "async")]
49 pub async fn get_company_payment_signature(
50 &self,
51 company_id: &Uuid,
52 params: &PaymentSignatureParams,
53 ) -> Result<PaymentSignatureResponse> {
54 let path = format!("/issuing/companies/{company_id}/signatures/payments");
55 let query_string = serde_urlencoded::to_string(params)?;
56 let full_path = if query_string.is_empty() {
57 path
58 } else {
59 format!("{path}?{query_string}")
60 };
61 self.get(&full_path).await
62 }
63
64 /// Get withdrawal signature for a company
65 ///
66 /// # Arguments
67 ///
68 /// * `company_id` - The unique identifier of the company
69 /// * `params` - Query parameters for the signature request
70 ///
71 /// # Returns
72 ///
73 /// Returns a [`WithdrawalSignatureResponse`] which can be either pending or ready.
74 ///
75 /// # Examples
76 ///
77 /// ```no_run
78 /// use rain_sdk::{RainClient, Config, Environment, AuthConfig};
79 /// use rain_sdk::models::signatures::WithdrawalSignatureParams;
80 /// use uuid::Uuid;
81 ///
82 /// # #[cfg(feature = "async")]
83 /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
84 /// let config = Config::new(Environment::Dev);
85 /// let auth = AuthConfig::with_api_key("your-api-key".to_string());
86 /// let client = RainClient::new(config, auth)?;
87 ///
88 /// let company_id = Uuid::new_v4();
89 /// let params = WithdrawalSignatureParams {
90 /// chain_id: Some(1),
91 /// token: "0xabc123...".to_string(),
92 /// amount: "500000".to_string(),
93 /// admin_address: "0xdef456...".to_string(),
94 /// recipient_address: "0x789ghi...".to_string(),
95 /// is_amount_native: Some(false),
96 /// rain_collateral_contract_id: None,
97 /// };
98 /// let response = client.get_company_withdrawal_signature(&company_id, ¶ms).await?;
99 /// # Ok(())
100 /// # }
101 /// ```
102 #[cfg(feature = "async")]
103 pub async fn get_company_withdrawal_signature(
104 &self,
105 company_id: &Uuid,
106 params: &WithdrawalSignatureParams,
107 ) -> Result<WithdrawalSignatureResponse> {
108 let path = format!("/issuing/companies/{company_id}/signatures/withdrawals");
109 let query_string = serde_urlencoded::to_string(params)?;
110 let full_path = if query_string.is_empty() {
111 path
112 } else {
113 format!("{path}?{query_string}")
114 };
115 self.get(&full_path).await
116 }
117
118 /// Get payment signature for an authorized user tenant
119 ///
120 /// # Arguments
121 ///
122 /// * `params` - Query parameters for the signature request
123 ///
124 /// # Returns
125 ///
126 /// Returns a [`PaymentSignatureResponse`] which can be either pending or ready.
127 #[cfg(feature = "async")]
128 pub async fn get_payment_signature(
129 &self,
130 params: &PaymentSignatureParams,
131 ) -> Result<PaymentSignatureResponse> {
132 let path = "/issuing/signatures/payments";
133 let query_string = serde_urlencoded::to_string(params)?;
134 let full_path = if query_string.is_empty() {
135 path.to_string()
136 } else {
137 format!("{path}?{query_string}")
138 };
139 self.get(&full_path).await
140 }
141
142 /// Get withdrawal signature for an authorized user tenant
143 ///
144 /// # Arguments
145 ///
146 /// * `params` - Query parameters for the signature request
147 ///
148 /// # Returns
149 ///
150 /// Returns a [`WithdrawalSignatureResponse`] which can be either pending or ready.
151 #[cfg(feature = "async")]
152 pub async fn get_withdrawal_signature(
153 &self,
154 params: &WithdrawalSignatureParams,
155 ) -> Result<WithdrawalSignatureResponse> {
156 let path = "/issuing/signatures/withdrawals";
157 let query_string = serde_urlencoded::to_string(params)?;
158 let full_path = if query_string.is_empty() {
159 path.to_string()
160 } else {
161 format!("{path}?{query_string}")
162 };
163 self.get(&full_path).await
164 }
165
166 /// Get payment signature for a user
167 ///
168 /// # Arguments
169 ///
170 /// * `user_id` - The unique identifier of the user
171 /// * `params` - Query parameters for the signature request
172 ///
173 /// # Returns
174 ///
175 /// Returns a [`PaymentSignatureResponse`] which can be either pending or ready.
176 #[cfg(feature = "async")]
177 pub async fn get_user_payment_signature(
178 &self,
179 user_id: &Uuid,
180 params: &PaymentSignatureParams,
181 ) -> Result<PaymentSignatureResponse> {
182 let path = format!("/issuing/users/{user_id}/signatures/payments");
183 let query_string = serde_urlencoded::to_string(params)?;
184 let full_path = if query_string.is_empty() {
185 path
186 } else {
187 format!("{path}?{query_string}")
188 };
189 self.get(&full_path).await
190 }
191
192 /// Get withdrawal signature for a user
193 ///
194 /// # Arguments
195 ///
196 /// * `user_id` - The unique identifier of the user
197 /// * `params` - Query parameters for the signature request
198 ///
199 /// # Returns
200 ///
201 /// Returns a [`WithdrawalSignatureResponse`] which can be either pending or ready.
202 #[cfg(feature = "async")]
203 pub async fn get_user_withdrawal_signature(
204 &self,
205 user_id: &Uuid,
206 params: &WithdrawalSignatureParams,
207 ) -> Result<WithdrawalSignatureResponse> {
208 let path = format!("/issuing/users/{user_id}/signatures/withdrawals");
209 let query_string = serde_urlencoded::to_string(params)?;
210 let full_path = if query_string.is_empty() {
211 path
212 } else {
213 format!("{path}?{query_string}")
214 };
215 self.get(&full_path).await
216 }
217
218 // ============================================================================
219 // Blocking Methods
220 // ============================================================================
221
222 /// Get payment signature for a company (blocking)
223 #[cfg(feature = "sync")]
224 pub fn get_company_payment_signature_blocking(
225 &self,
226 company_id: &Uuid,
227 params: &PaymentSignatureParams,
228 ) -> Result<PaymentSignatureResponse> {
229 let path = format!("/issuing/companies/{company_id}/signatures/payments");
230 let query_string = serde_urlencoded::to_string(params)?;
231 let full_path = if query_string.is_empty() {
232 path
233 } else {
234 format!("{path}?{query_string}")
235 };
236 self.get_blocking(&full_path)
237 }
238
239 /// Get withdrawal signature for a company (blocking)
240 #[cfg(feature = "sync")]
241 pub fn get_company_withdrawal_signature_blocking(
242 &self,
243 company_id: &Uuid,
244 params: &WithdrawalSignatureParams,
245 ) -> Result<WithdrawalSignatureResponse> {
246 let path = format!("/issuing/companies/{company_id}/signatures/withdrawals");
247 let query_string = serde_urlencoded::to_string(params)?;
248 let full_path = if query_string.is_empty() {
249 path
250 } else {
251 format!("{path}?{query_string}")
252 };
253 self.get_blocking(&full_path)
254 }
255
256 /// Get payment signature for an authorized user tenant (blocking)
257 #[cfg(feature = "sync")]
258 pub fn get_payment_signature_blocking(
259 &self,
260 params: &PaymentSignatureParams,
261 ) -> Result<PaymentSignatureResponse> {
262 let path = "/issuing/signatures/payments";
263 let query_string = serde_urlencoded::to_string(params)?;
264 let full_path = if query_string.is_empty() {
265 path.to_string()
266 } else {
267 format!("{path}?{query_string}")
268 };
269 self.get_blocking(&full_path)
270 }
271
272 /// Get withdrawal signature for an authorized user tenant (blocking)
273 #[cfg(feature = "sync")]
274 pub fn get_withdrawal_signature_blocking(
275 &self,
276 params: &WithdrawalSignatureParams,
277 ) -> Result<WithdrawalSignatureResponse> {
278 let path = "/issuing/signatures/withdrawals";
279 let query_string = serde_urlencoded::to_string(params)?;
280 let full_path = if query_string.is_empty() {
281 path.to_string()
282 } else {
283 format!("{path}?{query_string}")
284 };
285 self.get_blocking(&full_path)
286 }
287
288 /// Get payment signature for a user (blocking)
289 #[cfg(feature = "sync")]
290 pub fn get_user_payment_signature_blocking(
291 &self,
292 user_id: &Uuid,
293 params: &PaymentSignatureParams,
294 ) -> Result<PaymentSignatureResponse> {
295 let path = format!("/issuing/users/{user_id}/signatures/payments");
296 let query_string = serde_urlencoded::to_string(params)?;
297 let full_path = if query_string.is_empty() {
298 path
299 } else {
300 format!("{path}?{query_string}")
301 };
302 self.get_blocking(&full_path)
303 }
304
305 /// Get withdrawal signature for a user (blocking)
306 #[cfg(feature = "sync")]
307 pub fn get_user_withdrawal_signature_blocking(
308 &self,
309 user_id: &Uuid,
310 params: &WithdrawalSignatureParams,
311 ) -> Result<WithdrawalSignatureResponse> {
312 let path = format!("/issuing/users/{user_id}/signatures/withdrawals");
313 let query_string = serde_urlencoded::to_string(params)?;
314 let full_path = if query_string.is_empty() {
315 path
316 } else {
317 format!("{path}?{query_string}")
318 };
319 self.get_blocking(&full_path)
320 }
321}