1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum StoreOnChainWalletsCreateOnChainTransactionError {
22 Status403(),
23 Status404(),
24 UnknownValue(serde_json::Value),
25}
26
27#[derive(Debug, Clone, Serialize, Deserialize)]
29#[serde(untagged)]
30pub enum StoreOnChainWalletsGetOnChainFeeRateError {
31 Status403(),
32 Status404(),
33 UnknownValue(serde_json::Value),
34}
35
36#[derive(Debug, Clone, Serialize, Deserialize)]
38#[serde(untagged)]
39pub enum StoreOnChainWalletsGetOnChainWalletReceiveAddressError {
40 Status403(),
41 Status404(),
42 UnknownValue(serde_json::Value),
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum StoreOnChainWalletsGetOnChainWalletTransactionError {
49 Status403(),
50 Status404(),
51 UnknownValue(serde_json::Value),
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
56#[serde(untagged)]
57pub enum StoreOnChainWalletsGetOnChainWalletUtxosError {
58 Status403(),
59 Status404(),
60 UnknownValue(serde_json::Value),
61}
62
63#[derive(Debug, Clone, Serialize, Deserialize)]
65#[serde(untagged)]
66pub enum StoreOnChainWalletsPatchOnChainWalletTransactionError {
67 Status403(),
68 Status404(),
69 UnknownValue(serde_json::Value),
70}
71
72#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum StoreOnChainWalletsShowOnChainWalletOverviewError {
76 Status403(),
77 Status404(),
78 UnknownValue(serde_json::Value),
79}
80
81#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum StoreOnChainWalletsShowOnChainWalletTransactionsError {
85 Status403(),
86 Status404(),
87 Status503(),
88 UnknownValue(serde_json::Value),
89}
90
91#[derive(Debug, Clone, Serialize, Deserialize)]
93#[serde(untagged)]
94pub enum StoreOnChainWalletsUnReserveOnChainWalletReceiveAddressError {
95 Status403(),
96 Status404(),
97 UnknownValue(serde_json::Value),
98}
99
100
101pub async fn store_on_chain_wallets_create_on_chain_transaction(configuration: &configuration::Configuration, store_id: &str, crypto_code: &str, create_on_chain_transaction_request: crate::models::CreateOnChainTransactionRequest) -> Result<crate::models::StoreOnChainWalletsCreateOnChainTransaction200Response, Error<StoreOnChainWalletsCreateOnChainTransactionError>> {
103 let local_var_configuration = configuration;
104
105 let local_var_client = &local_var_configuration.client;
106
107 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), cryptoCode=crate::apis::urlencode(crypto_code));
108 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
109
110 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
111 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
112 }
113 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
114 let local_var_key = local_var_apikey.key.clone();
115 let local_var_value = match local_var_apikey.prefix {
116 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
117 None => local_var_key,
118 };
119 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
120 };
121 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
122 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
123 };
124 local_var_req_builder = local_var_req_builder.json(&create_on_chain_transaction_request);
125
126 let local_var_req = local_var_req_builder.build()?;
127 let local_var_resp = local_var_client.execute(local_var_req).await?;
128
129 let local_var_status = local_var_resp.status();
130 let local_var_content = local_var_resp.text().await?;
131
132 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
133 serde_json::from_str(&local_var_content).map_err(Error::from)
134 } else {
135 let local_var_entity: Option<StoreOnChainWalletsCreateOnChainTransactionError> = serde_json::from_str(&local_var_content).ok();
136 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
137 Err(Error::ResponseError(local_var_error))
138 }
139}
140
141pub async fn store_on_chain_wallets_get_on_chain_fee_rate(configuration: &configuration::Configuration, store_id: &str, crypto_code: &str, block_target: Option<f32>) -> Result<crate::models::OnChainWalletFeeRateData, Error<StoreOnChainWalletsGetOnChainFeeRateError>> {
143 let local_var_configuration = configuration;
144
145 let local_var_client = &local_var_configuration.client;
146
147 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/feerate", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), cryptoCode=crate::apis::urlencode(crypto_code));
148 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
149
150 if let Some(ref local_var_str) = block_target {
151 local_var_req_builder = local_var_req_builder.query(&[("blockTarget", &local_var_str.to_string())]);
152 }
153 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
154 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
155 }
156 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
157 let local_var_key = local_var_apikey.key.clone();
158 let local_var_value = match local_var_apikey.prefix {
159 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
160 None => local_var_key,
161 };
162 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
163 };
164 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
165 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
166 };
167
168 let local_var_req = local_var_req_builder.build()?;
169 let local_var_resp = local_var_client.execute(local_var_req).await?;
170
171 let local_var_status = local_var_resp.status();
172 let local_var_content = local_var_resp.text().await?;
173
174 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
175 serde_json::from_str(&local_var_content).map_err(Error::from)
176 } else {
177 let local_var_entity: Option<StoreOnChainWalletsGetOnChainFeeRateError> = serde_json::from_str(&local_var_content).ok();
178 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
179 Err(Error::ResponseError(local_var_error))
180 }
181}
182
183pub async fn store_on_chain_wallets_get_on_chain_wallet_receive_address(configuration: &configuration::Configuration, store_id: &str, crypto_code: &str, force_generate: Option<bool>) -> Result<crate::models::OnChainWalletAddressData, Error<StoreOnChainWalletsGetOnChainWalletReceiveAddressError>> {
185 let local_var_configuration = configuration;
186
187 let local_var_client = &local_var_configuration.client;
188
189 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/address", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), cryptoCode=crate::apis::urlencode(crypto_code));
190 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
191
192 if let Some(ref local_var_str) = force_generate {
193 local_var_req_builder = local_var_req_builder.query(&[("forceGenerate", &local_var_str.to_string())]);
194 }
195 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
196 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
197 }
198 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
199 let local_var_key = local_var_apikey.key.clone();
200 let local_var_value = match local_var_apikey.prefix {
201 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
202 None => local_var_key,
203 };
204 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
205 };
206 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
207 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
208 };
209
210 let local_var_req = local_var_req_builder.build()?;
211 let local_var_resp = local_var_client.execute(local_var_req).await?;
212
213 let local_var_status = local_var_resp.status();
214 let local_var_content = local_var_resp.text().await?;
215
216 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
217 serde_json::from_str(&local_var_content).map_err(Error::from)
218 } else {
219 let local_var_entity: Option<StoreOnChainWalletsGetOnChainWalletReceiveAddressError> = serde_json::from_str(&local_var_content).ok();
220 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
221 Err(Error::ResponseError(local_var_error))
222 }
223}
224
225pub async fn store_on_chain_wallets_get_on_chain_wallet_transaction(configuration: &configuration::Configuration, store_id: &str, crypto_code: &str, transaction_id: &str) -> Result<crate::models::OnChainWalletTransactionData, Error<StoreOnChainWalletsGetOnChainWalletTransactionError>> {
227 let local_var_configuration = configuration;
228
229 let local_var_client = &local_var_configuration.client;
230
231 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions/{transactionId}", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), cryptoCode=crate::apis::urlencode(crypto_code), transactionId=crate::apis::urlencode(transaction_id));
232 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
233
234 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
235 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
236 }
237 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
238 let local_var_key = local_var_apikey.key.clone();
239 let local_var_value = match local_var_apikey.prefix {
240 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
241 None => local_var_key,
242 };
243 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
244 };
245 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
246 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
247 };
248
249 let local_var_req = local_var_req_builder.build()?;
250 let local_var_resp = local_var_client.execute(local_var_req).await?;
251
252 let local_var_status = local_var_resp.status();
253 let local_var_content = local_var_resp.text().await?;
254
255 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
256 serde_json::from_str(&local_var_content).map_err(Error::from)
257 } else {
258 let local_var_entity: Option<StoreOnChainWalletsGetOnChainWalletTransactionError> = serde_json::from_str(&local_var_content).ok();
259 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
260 Err(Error::ResponseError(local_var_error))
261 }
262}
263
264pub async fn store_on_chain_wallets_get_on_chain_wallet_utxos(configuration: &configuration::Configuration, store_id: &str, crypto_code: &str) -> Result<Vec<crate::models::OnChainWalletUtxoData>, Error<StoreOnChainWalletsGetOnChainWalletUtxosError>> {
266 let local_var_configuration = configuration;
267
268 let local_var_client = &local_var_configuration.client;
269
270 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/utxos", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), cryptoCode=crate::apis::urlencode(crypto_code));
271 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
272
273 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
274 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
275 }
276 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
277 let local_var_key = local_var_apikey.key.clone();
278 let local_var_value = match local_var_apikey.prefix {
279 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
280 None => local_var_key,
281 };
282 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
283 };
284 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
285 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
286 };
287
288 let local_var_req = local_var_req_builder.build()?;
289 let local_var_resp = local_var_client.execute(local_var_req).await?;
290
291 let local_var_status = local_var_resp.status();
292 let local_var_content = local_var_resp.text().await?;
293
294 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
295 serde_json::from_str(&local_var_content).map_err(Error::from)
296 } else {
297 let local_var_entity: Option<StoreOnChainWalletsGetOnChainWalletUtxosError> = serde_json::from_str(&local_var_content).ok();
298 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
299 Err(Error::ResponseError(local_var_error))
300 }
301}
302
303pub async fn store_on_chain_wallets_patch_on_chain_wallet_transaction(configuration: &configuration::Configuration, store_id: &str, crypto_code: &str, transaction_id: &str, patch_on_chain_transaction_request: crate::models::PatchOnChainTransactionRequest, force: Option<&str>) -> Result<crate::models::OnChainWalletTransactionData, Error<StoreOnChainWalletsPatchOnChainWalletTransactionError>> {
305 let local_var_configuration = configuration;
306
307 let local_var_client = &local_var_configuration.client;
308
309 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions/{transactionId}", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), cryptoCode=crate::apis::urlencode(crypto_code), transactionId=crate::apis::urlencode(transaction_id));
310 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
311
312 if let Some(ref local_var_str) = force {
313 local_var_req_builder = local_var_req_builder.query(&[("force", &local_var_str.to_string())]);
314 }
315 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
316 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
317 }
318 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
319 let local_var_key = local_var_apikey.key.clone();
320 let local_var_value = match local_var_apikey.prefix {
321 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
322 None => local_var_key,
323 };
324 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
325 };
326 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
327 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
328 };
329 local_var_req_builder = local_var_req_builder.json(&patch_on_chain_transaction_request);
330
331 let local_var_req = local_var_req_builder.build()?;
332 let local_var_resp = local_var_client.execute(local_var_req).await?;
333
334 let local_var_status = local_var_resp.status();
335 let local_var_content = local_var_resp.text().await?;
336
337 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
338 serde_json::from_str(&local_var_content).map_err(Error::from)
339 } else {
340 let local_var_entity: Option<StoreOnChainWalletsPatchOnChainWalletTransactionError> = serde_json::from_str(&local_var_content).ok();
341 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
342 Err(Error::ResponseError(local_var_error))
343 }
344}
345
346pub async fn store_on_chain_wallets_show_on_chain_wallet_overview(configuration: &configuration::Configuration, store_id: &str, crypto_code: &str) -> Result<crate::models::OnChainWalletOverviewData, Error<StoreOnChainWalletsShowOnChainWalletOverviewError>> {
348 let local_var_configuration = configuration;
349
350 let local_var_client = &local_var_configuration.client;
351
352 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), cryptoCode=crate::apis::urlencode(crypto_code));
353 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
354
355 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
356 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
357 }
358 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
359 let local_var_key = local_var_apikey.key.clone();
360 let local_var_value = match local_var_apikey.prefix {
361 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
362 None => local_var_key,
363 };
364 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
365 };
366 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
367 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
368 };
369
370 let local_var_req = local_var_req_builder.build()?;
371 let local_var_resp = local_var_client.execute(local_var_req).await?;
372
373 let local_var_status = local_var_resp.status();
374 let local_var_content = local_var_resp.text().await?;
375
376 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
377 serde_json::from_str(&local_var_content).map_err(Error::from)
378 } else {
379 let local_var_entity: Option<StoreOnChainWalletsShowOnChainWalletOverviewError> = serde_json::from_str(&local_var_content).ok();
380 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
381 Err(Error::ResponseError(local_var_error))
382 }
383}
384
385pub async fn store_on_chain_wallets_show_on_chain_wallet_transactions(configuration: &configuration::Configuration, store_id: &str, crypto_code: &str, status_filter: Option<Vec<crate::models::TransactionStatus>>, label_filter: Option<&str>, skip: Option<i32>, limit: Option<i32>) -> Result<Vec<crate::models::OnChainWalletTransactionData>, Error<StoreOnChainWalletsShowOnChainWalletTransactionsError>> {
387 let local_var_configuration = configuration;
388
389 let local_var_client = &local_var_configuration.client;
390
391 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), cryptoCode=crate::apis::urlencode(crypto_code));
392 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
393
394 if let Some(ref local_var_str) = status_filter {
395 local_var_req_builder = match "multi" {
396 "multi" => local_var_req_builder.query(&local_var_str.into_iter().map(|p| ("statusFilter".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
397 _ => local_var_req_builder.query(&[("statusFilter", &local_var_str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
398 };
399 }
400 if let Some(ref local_var_str) = label_filter {
401 local_var_req_builder = local_var_req_builder.query(&[("labelFilter", &local_var_str.to_string())]);
402 }
403 if let Some(ref local_var_str) = skip {
404 local_var_req_builder = local_var_req_builder.query(&[("skip", &local_var_str.to_string())]);
405 }
406 if let Some(ref local_var_str) = limit {
407 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
408 }
409 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
410 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
411 }
412 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
413 let local_var_key = local_var_apikey.key.clone();
414 let local_var_value = match local_var_apikey.prefix {
415 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
416 None => local_var_key,
417 };
418 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
419 };
420 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
421 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
422 };
423
424 let local_var_req = local_var_req_builder.build()?;
425 let local_var_resp = local_var_client.execute(local_var_req).await?;
426
427 let local_var_status = local_var_resp.status();
428 let local_var_content = local_var_resp.text().await?;
429
430 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
431 serde_json::from_str(&local_var_content).map_err(Error::from)
432 } else {
433 let local_var_entity: Option<StoreOnChainWalletsShowOnChainWalletTransactionsError> = serde_json::from_str(&local_var_content).ok();
434 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
435 Err(Error::ResponseError(local_var_error))
436 }
437}
438
439pub async fn store_on_chain_wallets_un_reserve_on_chain_wallet_receive_address(configuration: &configuration::Configuration, store_id: &str, crypto_code: &str) -> Result<(), Error<StoreOnChainWalletsUnReserveOnChainWalletReceiveAddressError>> {
441 let local_var_configuration = configuration;
442
443 let local_var_client = &local_var_configuration.client;
444
445 let local_var_uri_str = format!("{}/api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/address", local_var_configuration.base_path, storeId=crate::apis::urlencode(store_id), cryptoCode=crate::apis::urlencode(crypto_code));
446 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
447
448 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
449 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
450 }
451 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
452 let local_var_key = local_var_apikey.key.clone();
453 let local_var_value = match local_var_apikey.prefix {
454 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
455 None => local_var_key,
456 };
457 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
458 };
459 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
460 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
461 };
462
463 let local_var_req = local_var_req_builder.build()?;
464 let local_var_resp = local_var_client.execute(local_var_req).await?;
465
466 let local_var_status = local_var_resp.status();
467 let local_var_content = local_var_resp.text().await?;
468
469 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
470 Ok(())
471 } else {
472 let local_var_entity: Option<StoreOnChainWalletsUnReserveOnChainWalletReceiveAddressError> = serde_json::from_str(&local_var_content).ok();
473 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
474 Err(Error::ResponseError(local_var_error))
475 }
476}
477