photon_api/apis/
default_api.rs

1/*
2 * photon-indexer
3 *
4 * Solana indexer for general compression
5 *
6 * The version of the OpenAPI document: 0.45.0
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{configuration, Error};
14use crate::apis::configuration::Configuration;
15use crate::{apis::ResponseContent, models};
16
17/// struct for typed errors of method [`get_compressed_account_balance_post`]
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum GetCompressedAccountBalancePostError {
21    Status429(models::GetCompressedAccountPost429Response),
22    Status500(models::GetCompressedAccountPost429Response),
23    UnknownValue(serde_json::Value),
24}
25
26/// struct for typed errors of method [`get_compressed_account_post`]
27#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(untagged)]
29pub enum GetCompressedAccountPostError {
30    Status429(models::GetCompressedAccountPost429Response),
31    Status500(models::GetCompressedAccountPost429Response),
32    UnknownValue(serde_json::Value),
33}
34
35/// struct for typed errors of method [`get_compressed_account_proof_post`]
36#[derive(Debug, Clone, Serialize, Deserialize)]
37#[serde(untagged)]
38pub enum GetCompressedAccountProofPostError {
39    Status429(models::GetCompressedAccountPost429Response),
40    Status500(models::GetCompressedAccountPost429Response),
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`get_compressed_accounts_by_owner_post`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum GetCompressedAccountsByOwnerPostError {
48    Status429(models::GetCompressedAccountPost429Response),
49    Status500(models::GetCompressedAccountPost429Response),
50    UnknownValue(serde_json::Value),
51}
52
53/// struct for typed errors of method [`get_compressed_balance_by_owner_post`]
54#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum GetCompressedBalanceByOwnerPostError {
57    Status429(models::GetCompressedAccountPost429Response),
58    Status500(models::GetCompressedAccountPost429Response),
59    UnknownValue(serde_json::Value),
60}
61
62/// struct for typed errors of method [`get_compressed_token_account_balance_post`]
63#[derive(Debug, Clone, Serialize, Deserialize)]
64#[serde(untagged)]
65pub enum GetCompressedTokenAccountBalancePostError {
66    Status429(models::GetCompressedAccountPost429Response),
67    Status500(models::GetCompressedAccountPost429Response),
68    UnknownValue(serde_json::Value),
69}
70
71/// struct for typed errors of method [`get_compressed_token_accounts_by_delegate_post`]
72#[derive(Debug, Clone, Serialize, Deserialize)]
73#[serde(untagged)]
74pub enum GetCompressedTokenAccountsByDelegatePostError {
75    Status429(models::GetCompressedAccountPost429Response),
76    Status500(models::GetCompressedAccountPost429Response),
77    UnknownValue(serde_json::Value),
78}
79
80/// struct for typed errors of method [`get_compressed_token_accounts_by_owner_post`]
81#[derive(Debug, Clone, Serialize, Deserialize)]
82#[serde(untagged)]
83pub enum GetCompressedTokenAccountsByOwnerPostError {
84    Status429(models::GetCompressedAccountPost429Response),
85    Status500(models::GetCompressedAccountPost429Response),
86    UnknownValue(serde_json::Value),
87}
88
89/// struct for typed errors of method [`get_compressed_token_balances_by_owner_post`]
90#[derive(Debug, Clone, Serialize, Deserialize)]
91#[serde(untagged)]
92pub enum GetCompressedTokenBalancesByOwnerPostError {
93    Status429(models::GetCompressedAccountPost429Response),
94    Status500(models::GetCompressedAccountPost429Response),
95    UnknownValue(serde_json::Value),
96}
97
98/// struct for typed errors of method [`get_compression_signatures_for_account_post`]
99#[derive(Debug, Clone, Serialize, Deserialize)]
100#[serde(untagged)]
101pub enum GetCompressionSignaturesForAccountPostError {
102    Status429(models::GetCompressedAccountPost429Response),
103    Status500(models::GetCompressedAccountPost429Response),
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed errors of method [`get_compression_signatures_for_address_post`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum GetCompressionSignaturesForAddressPostError {
111    Status429(models::GetCompressedAccountPost429Response),
112    Status500(models::GetCompressedAccountPost429Response),
113    UnknownValue(serde_json::Value),
114}
115
116/// struct for typed errors of method [`get_compression_signatures_for_owner_post`]
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum GetCompressionSignaturesForOwnerPostError {
120    Status429(models::GetCompressedAccountPost429Response),
121    Status500(models::GetCompressedAccountPost429Response),
122    UnknownValue(serde_json::Value),
123}
124
125/// struct for typed errors of method [`get_compression_signatures_for_token_owner_post`]
126#[derive(Debug, Clone, Serialize, Deserialize)]
127#[serde(untagged)]
128pub enum GetCompressionSignaturesForTokenOwnerPostError {
129    Status429(models::GetCompressedAccountPost429Response),
130    Status500(models::GetCompressedAccountPost429Response),
131    UnknownValue(serde_json::Value),
132}
133
134/// struct for typed errors of method [`get_indexer_health_post`]
135#[derive(Debug, Clone, Serialize, Deserialize)]
136#[serde(untagged)]
137pub enum GetIndexerHealthPostError {
138    Status429(models::GetCompressedAccountPost429Response),
139    Status500(models::GetCompressedAccountPost429Response),
140    UnknownValue(serde_json::Value),
141}
142
143/// struct for typed errors of method [`get_indexer_slot_post`]
144#[derive(Debug, Clone, Serialize, Deserialize)]
145#[serde(untagged)]
146pub enum GetIndexerSlotPostError {
147    Status429(models::GetCompressedAccountPost429Response),
148    Status500(models::GetCompressedAccountPost429Response),
149    UnknownValue(serde_json::Value),
150}
151
152/// struct for typed errors of method [`get_latest_compression_signatures_post`]
153#[derive(Debug, Clone, Serialize, Deserialize)]
154#[serde(untagged)]
155pub enum GetLatestCompressionSignaturesPostError {
156    Status429(models::GetCompressedAccountPost429Response),
157    Status500(models::GetCompressedAccountPost429Response),
158    UnknownValue(serde_json::Value),
159}
160
161/// struct for typed errors of method [`get_latest_non_voting_signatures_post`]
162#[derive(Debug, Clone, Serialize, Deserialize)]
163#[serde(untagged)]
164pub enum GetLatestNonVotingSignaturesPostError {
165    Status429(models::GetCompressedAccountPost429Response),
166    Status500(models::GetCompressedAccountPost429Response),
167    UnknownValue(serde_json::Value),
168}
169
170/// struct for typed errors of method [`get_multiple_compressed_account_proofs_post`]
171#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum GetMultipleCompressedAccountProofsPostError {
174    Status429(models::GetCompressedAccountPost429Response),
175    Status500(models::GetCompressedAccountPost429Response),
176    UnknownValue(serde_json::Value),
177}
178
179/// struct for typed errors of method [`get_multiple_compressed_accounts_post`]
180#[derive(Debug, Clone, Serialize, Deserialize)]
181#[serde(untagged)]
182pub enum GetMultipleCompressedAccountsPostError {
183    Status429(models::GetCompressedAccountPost429Response),
184    Status500(models::GetCompressedAccountPost429Response),
185    UnknownValue(serde_json::Value),
186}
187
188/// struct for typed errors of method [`get_multiple_new_address_proofs_post`]
189#[derive(Debug, Clone, Serialize, Deserialize)]
190#[serde(untagged)]
191pub enum GetMultipleNewAddressProofsPostError {
192    Status429(models::GetCompressedAccountPost429Response),
193    Status500(models::GetCompressedAccountPost429Response),
194    UnknownValue(serde_json::Value),
195}
196
197/// struct for typed errors of method [`get_multiple_new_address_proofs_v2_post`]
198#[derive(Debug, Clone, Serialize, Deserialize)]
199#[serde(untagged)]
200pub enum GetMultipleNewAddressProofsV2PostError {
201    Status429(models::GetCompressedAccountPost429Response),
202    Status500(models::GetCompressedAccountPost429Response),
203    UnknownValue(serde_json::Value),
204}
205
206/// struct for typed errors of method [`get_transaction_with_compression_info_post`]
207#[derive(Debug, Clone, Serialize, Deserialize)]
208#[serde(untagged)]
209pub enum GetTransactionWithCompressionInfoPostError {
210    Status429(models::GetCompressedAccountPost429Response),
211    Status500(models::GetCompressedAccountPost429Response),
212    UnknownValue(serde_json::Value),
213}
214
215/// struct for typed errors of method [`get_validity_proof_post`]
216#[derive(Debug, Clone, Serialize, Deserialize)]
217#[serde(untagged)]
218pub enum GetValidityProofPostError {
219    Status429(models::GetCompressedAccountPost429Response),
220    Status500(models::GetCompressedAccountPost429Response),
221    UnknownValue(serde_json::Value),
222}
223
224pub async fn get_compressed_account_balance_post(
225    configuration: &configuration::Configuration,
226    get_compressed_account_balance_post_request: models::GetCompressedAccountBalancePostRequest,
227) -> Result<
228    models::GetCompressedAccountBalancePost200Response,
229    Error<GetCompressedAccountBalancePostError>,
230> {
231    let local_var_configuration = configuration;
232
233    let local_var_client = &local_var_configuration.client;
234
235    let local_var_uri_str = format!(
236        "{}/getCompressedAccountBalance",
237        local_var_configuration.base_path
238    );
239    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
240
241    let mut local_var_req_builder =
242        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
243
244    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
245        local_var_req_builder =
246            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
247    }
248    local_var_req_builder =
249        local_var_req_builder.json(&get_compressed_account_balance_post_request);
250
251    let local_var_req = local_var_req_builder.build()?;
252    let local_var_resp = local_var_client.execute(local_var_req).await?;
253
254    let local_var_status = local_var_resp.status();
255    let local_var_content = local_var_resp.text().await?;
256
257    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
258        serde_json::from_str(&local_var_content).map_err(Error::from)
259    } else {
260        let local_var_entity: Option<GetCompressedAccountBalancePostError> =
261            serde_json::from_str(&local_var_content).ok();
262        let local_var_error = ResponseContent {
263            status: local_var_status,
264            content: local_var_content,
265            entity: local_var_entity,
266        };
267        Err(Error::ResponseError(local_var_error))
268    }
269}
270
271pub async fn get_compressed_account_post(
272    configuration: &configuration::Configuration,
273    get_compressed_account_post_request: models::GetCompressedAccountPostRequest,
274) -> Result<models::GetCompressedAccountPost200Response, Error<GetCompressedAccountPostError>> {
275    let local_var_configuration = configuration;
276
277    let local_var_client = &local_var_configuration.client;
278
279    let local_var_uri_str = format!("{}/getCompressedAccount", local_var_configuration.base_path);
280    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
281    let mut local_var_req_builder =
282        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
283
284    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
285        local_var_req_builder =
286            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
287    }
288    local_var_req_builder = local_var_req_builder.json(&get_compressed_account_post_request);
289
290    let local_var_req = local_var_req_builder.build()?;
291    let local_var_resp = local_var_client.execute(local_var_req).await?;
292
293    let local_var_status = local_var_resp.status();
294    let local_var_content = local_var_resp.text().await?;
295
296    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
297        serde_json::from_str(&local_var_content).map_err(Error::from)
298    } else {
299        let local_var_entity: Option<GetCompressedAccountPostError> =
300            serde_json::from_str(&local_var_content).ok();
301        let local_var_error = ResponseContent {
302            status: local_var_status,
303            content: local_var_content,
304            entity: local_var_entity,
305        };
306        Err(Error::ResponseError(local_var_error))
307    }
308}
309
310pub async fn get_compressed_account_proof_post(
311    configuration: &configuration::Configuration,
312    get_compressed_account_proof_post_request: models::GetCompressedAccountProofPostRequest,
313) -> Result<
314    models::GetCompressedAccountProofPost200Response,
315    Error<GetCompressedAccountProofPostError>,
316> {
317    let local_var_configuration = configuration;
318
319    let local_var_client = &local_var_configuration.client;
320
321    let local_var_uri_str = format!(
322        "{}/getCompressedAccountProof",
323        local_var_configuration.base_path
324    );
325    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
326    let mut local_var_req_builder =
327        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
328
329    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
330        local_var_req_builder =
331            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
332    }
333    local_var_req_builder = local_var_req_builder.json(&get_compressed_account_proof_post_request);
334
335    let local_var_req = local_var_req_builder.build()?;
336    let local_var_resp = local_var_client.execute(local_var_req).await?;
337
338    let local_var_status = local_var_resp.status();
339    let local_var_content = local_var_resp.text().await?;
340
341    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
342        serde_json::from_str(&local_var_content).map_err(Error::from)
343    } else {
344        let local_var_entity: Option<GetCompressedAccountProofPostError> =
345            serde_json::from_str(&local_var_content).ok();
346        let local_var_error = ResponseContent {
347            status: local_var_status,
348            content: local_var_content,
349            entity: local_var_entity,
350        };
351        Err(Error::ResponseError(local_var_error))
352    }
353}
354
355pub async fn get_compressed_accounts_by_owner_post(
356    configuration: &configuration::Configuration,
357    get_compressed_accounts_by_owner_post_request: models::GetCompressedAccountsByOwnerPostRequest,
358) -> Result<
359    models::GetCompressedAccountsByOwnerPost200Response,
360    Error<GetCompressedAccountsByOwnerPostError>,
361> {
362    let local_var_configuration = configuration;
363
364    let local_var_client = &local_var_configuration.client;
365
366    let local_var_uri_str = format!(
367        "{}/getCompressedAccountsByOwner",
368        local_var_configuration.base_path
369    );
370    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
371    let mut local_var_req_builder =
372        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
373
374    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
375        local_var_req_builder =
376            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
377    }
378    local_var_req_builder =
379        local_var_req_builder.json(&get_compressed_accounts_by_owner_post_request);
380
381    let local_var_req = local_var_req_builder.build()?;
382    let local_var_resp = local_var_client.execute(local_var_req).await?;
383
384    let local_var_status = local_var_resp.status();
385    let local_var_content = local_var_resp.text().await?;
386
387    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
388        serde_json::from_str(&local_var_content).map_err(Error::from)
389    } else {
390        let local_var_entity: Option<GetCompressedAccountsByOwnerPostError> =
391            serde_json::from_str(&local_var_content).ok();
392        let local_var_error = ResponseContent {
393            status: local_var_status,
394            content: local_var_content,
395            entity: local_var_entity,
396        };
397        Err(Error::ResponseError(local_var_error))
398    }
399}
400
401pub async fn get_compressed_balance_by_owner_post(
402    configuration: &configuration::Configuration,
403    get_compressed_balance_by_owner_post_request: models::GetCompressedBalanceByOwnerPostRequest,
404) -> Result<
405    models::GetCompressedAccountBalancePost200Response,
406    Error<GetCompressedBalanceByOwnerPostError>,
407> {
408    let local_var_configuration = configuration;
409
410    let local_var_client = &local_var_configuration.client;
411
412    let local_var_uri_str = format!(
413        "{}/getCompressedBalanceByOwner",
414        local_var_configuration.base_path
415    );
416    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
417    let mut local_var_req_builder =
418        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
419
420    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
421        local_var_req_builder =
422            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
423    }
424    local_var_req_builder =
425        local_var_req_builder.json(&get_compressed_balance_by_owner_post_request);
426
427    let local_var_req = local_var_req_builder.build()?;
428    let local_var_resp = local_var_client.execute(local_var_req).await?;
429
430    let local_var_status = local_var_resp.status();
431    let local_var_content = local_var_resp.text().await?;
432
433    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
434        serde_json::from_str(&local_var_content).map_err(Error::from)
435    } else {
436        let local_var_entity: Option<GetCompressedBalanceByOwnerPostError> =
437            serde_json::from_str(&local_var_content).ok();
438        let local_var_error = ResponseContent {
439            status: local_var_status,
440            content: local_var_content,
441            entity: local_var_entity,
442        };
443        Err(Error::ResponseError(local_var_error))
444    }
445}
446
447pub async fn get_compressed_token_account_balance_post(
448    configuration: &configuration::Configuration,
449    get_compressed_token_account_balance_post_request: models::GetCompressedTokenAccountBalancePostRequest,
450) -> Result<
451    models::GetCompressedTokenAccountBalancePost200Response,
452    Error<GetCompressedTokenAccountBalancePostError>,
453> {
454    let local_var_configuration = configuration;
455
456    let local_var_client = &local_var_configuration.client;
457
458    let local_var_uri_str = format!(
459        "{}/getCompressedTokenAccountBalance",
460        local_var_configuration.base_path
461    );
462    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
463    let mut local_var_req_builder =
464        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
465
466    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
467        local_var_req_builder =
468            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
469    }
470    local_var_req_builder =
471        local_var_req_builder.json(&get_compressed_token_account_balance_post_request);
472
473    let local_var_req = local_var_req_builder.build()?;
474    let local_var_resp = local_var_client.execute(local_var_req).await?;
475
476    let local_var_status = local_var_resp.status();
477    let local_var_content = local_var_resp.text().await?;
478
479    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
480        serde_json::from_str(&local_var_content).map_err(Error::from)
481    } else {
482        let local_var_entity: Option<GetCompressedTokenAccountBalancePostError> =
483            serde_json::from_str(&local_var_content).ok();
484        let local_var_error = ResponseContent {
485            status: local_var_status,
486            content: local_var_content,
487            entity: local_var_entity,
488        };
489        Err(Error::ResponseError(local_var_error))
490    }
491}
492
493pub async fn get_compressed_token_accounts_by_delegate_post(
494    configuration: &configuration::Configuration,
495    get_compressed_token_accounts_by_delegate_post_request: models::GetCompressedTokenAccountsByDelegatePostRequest,
496) -> Result<
497    models::GetCompressedTokenAccountsByDelegatePost200Response,
498    Error<GetCompressedTokenAccountsByDelegatePostError>,
499> {
500    let local_var_configuration = configuration;
501
502    let local_var_client = &local_var_configuration.client;
503
504    let local_var_uri_str = format!(
505        "{}/getCompressedTokenAccountsByDelegate",
506        local_var_configuration.base_path
507    );
508    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
509    let mut local_var_req_builder =
510        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
511
512    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
513        local_var_req_builder =
514            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
515    }
516    local_var_req_builder =
517        local_var_req_builder.json(&get_compressed_token_accounts_by_delegate_post_request);
518
519    let local_var_req = local_var_req_builder.build()?;
520    let local_var_resp = local_var_client.execute(local_var_req).await?;
521
522    let local_var_status = local_var_resp.status();
523    let local_var_content = local_var_resp.text().await?;
524
525    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
526        serde_json::from_str(&local_var_content).map_err(Error::from)
527    } else {
528        let local_var_entity: Option<GetCompressedTokenAccountsByDelegatePostError> =
529            serde_json::from_str(&local_var_content).ok();
530        let local_var_error = ResponseContent {
531            status: local_var_status,
532            content: local_var_content,
533            entity: local_var_entity,
534        };
535        Err(Error::ResponseError(local_var_error))
536    }
537}
538
539pub async fn get_compressed_token_accounts_by_owner_post(
540    configuration: &configuration::Configuration,
541    get_compressed_token_accounts_by_owner_post_request: models::GetCompressedTokenAccountsByOwnerPostRequest,
542) -> Result<
543    models::GetCompressedTokenAccountsByDelegatePost200Response,
544    Error<GetCompressedTokenAccountsByOwnerPostError>,
545> {
546    let local_var_configuration = configuration;
547
548    let local_var_client = &local_var_configuration.client;
549
550    let local_var_uri_str = format!(
551        "{}/getCompressedTokenAccountsByOwner",
552        local_var_configuration.base_path
553    );
554    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
555    let mut local_var_req_builder =
556        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
557
558    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
559        local_var_req_builder =
560            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
561    }
562    local_var_req_builder =
563        local_var_req_builder.json(&get_compressed_token_accounts_by_owner_post_request);
564
565    let local_var_req = local_var_req_builder.build()?;
566    let local_var_resp = local_var_client.execute(local_var_req).await?;
567
568    let local_var_status = local_var_resp.status();
569    let local_var_content = local_var_resp.text().await?;
570
571    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
572        serde_json::from_str(&local_var_content).map_err(Error::from)
573    } else {
574        let local_var_entity: Option<GetCompressedTokenAccountsByOwnerPostError> =
575            serde_json::from_str(&local_var_content).ok();
576        let local_var_error = ResponseContent {
577            status: local_var_status,
578            content: local_var_content,
579            entity: local_var_entity,
580        };
581        Err(Error::ResponseError(local_var_error))
582    }
583}
584
585pub async fn get_compressed_token_balances_by_owner_post(
586    configuration: &configuration::Configuration,
587    get_compressed_token_balances_by_owner_post_request: models::GetCompressedTokenBalancesByOwnerPostRequest,
588) -> Result<
589    models::GetCompressedTokenBalancesByOwnerPost200Response,
590    Error<GetCompressedTokenBalancesByOwnerPostError>,
591> {
592    let local_var_configuration = configuration;
593
594    let local_var_client = &local_var_configuration.client;
595
596    let local_var_uri_str = format!(
597        "{}/getCompressedTokenBalancesByOwner",
598        local_var_configuration.base_path
599    );
600    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
601    let mut local_var_req_builder =
602        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
603
604    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
605        local_var_req_builder =
606            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
607    }
608    local_var_req_builder =
609        local_var_req_builder.json(&get_compressed_token_balances_by_owner_post_request);
610
611    let local_var_req = local_var_req_builder.build()?;
612    let local_var_resp = local_var_client.execute(local_var_req).await?;
613
614    let local_var_status = local_var_resp.status();
615    let local_var_content = local_var_resp.text().await?;
616
617    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
618        serde_json::from_str(&local_var_content).map_err(Error::from)
619    } else {
620        let local_var_entity: Option<GetCompressedTokenBalancesByOwnerPostError> =
621            serde_json::from_str(&local_var_content).ok();
622        let local_var_error = ResponseContent {
623            status: local_var_status,
624            content: local_var_content,
625            entity: local_var_entity,
626        };
627        Err(Error::ResponseError(local_var_error))
628    }
629}
630
631pub async fn get_compression_signatures_for_account_post(
632    configuration: &configuration::Configuration,
633    get_compression_signatures_for_account_post_request: models::GetCompressionSignaturesForAccountPostRequest,
634) -> Result<
635    models::GetCompressionSignaturesForAccountPost200Response,
636    Error<GetCompressionSignaturesForAccountPostError>,
637> {
638    let local_var_configuration = configuration;
639
640    let local_var_client = &local_var_configuration.client;
641
642    let local_var_uri_str = format!(
643        "{}/getCompressionSignaturesForAccount",
644        local_var_configuration.base_path
645    );
646    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
647
648    let mut local_var_req_builder =
649        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
650
651    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
652        local_var_req_builder =
653            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
654    }
655    local_var_req_builder =
656        local_var_req_builder.json(&get_compression_signatures_for_account_post_request);
657
658    let local_var_req = local_var_req_builder.build()?;
659    let local_var_resp = local_var_client.execute(local_var_req).await?;
660
661    let local_var_status = local_var_resp.status();
662    let local_var_content = local_var_resp.text().await?;
663
664    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
665        serde_json::from_str(&local_var_content).map_err(Error::from)
666    } else {
667        let local_var_entity: Option<GetCompressionSignaturesForAccountPostError> =
668            serde_json::from_str(&local_var_content).ok();
669        let local_var_error = ResponseContent {
670            status: local_var_status,
671            content: local_var_content,
672            entity: local_var_entity,
673        };
674        Err(Error::ResponseError(local_var_error))
675    }
676}
677
678pub async fn get_compression_signatures_for_address_post(
679    configuration: &configuration::Configuration,
680    get_compression_signatures_for_address_post_request: models::GetCompressionSignaturesForAddressPostRequest,
681) -> Result<
682    models::GetCompressionSignaturesForAddressPost200Response,
683    Error<GetCompressionSignaturesForAddressPostError>,
684> {
685    let local_var_configuration = configuration;
686
687    let local_var_client = &local_var_configuration.client;
688
689    let local_var_uri_str = format!(
690        "{}/getCompressionSignaturesForAddress",
691        local_var_configuration.base_path
692    );
693    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
694
695    let mut local_var_req_builder =
696        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
697
698    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
699        local_var_req_builder =
700            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
701    }
702    local_var_req_builder =
703        local_var_req_builder.json(&get_compression_signatures_for_address_post_request);
704
705    let local_var_req = local_var_req_builder.build()?;
706    let local_var_resp = local_var_client.execute(local_var_req).await?;
707
708    let local_var_status = local_var_resp.status();
709    let local_var_content = local_var_resp.text().await?;
710
711    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
712        serde_json::from_str(&local_var_content).map_err(Error::from)
713    } else {
714        let local_var_entity: Option<GetCompressionSignaturesForAddressPostError> =
715            serde_json::from_str(&local_var_content).ok();
716        let local_var_error = ResponseContent {
717            status: local_var_status,
718            content: local_var_content,
719            entity: local_var_entity,
720        };
721        Err(Error::ResponseError(local_var_error))
722    }
723}
724
725pub async fn get_compression_signatures_for_owner_post(
726    configuration: &configuration::Configuration,
727    get_compression_signatures_for_owner_post_request: models::GetCompressionSignaturesForOwnerPostRequest,
728) -> Result<
729    models::GetCompressionSignaturesForAddressPost200Response,
730    Error<GetCompressionSignaturesForOwnerPostError>,
731> {
732    let local_var_configuration = configuration;
733
734    let local_var_client = &local_var_configuration.client;
735
736    let local_var_uri_str = format!(
737        "{}/getCompressionSignaturesForOwner",
738        local_var_configuration.base_path
739    );
740    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
741
742    let mut local_var_req_builder =
743        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
744
745    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
746        local_var_req_builder =
747            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
748    }
749    local_var_req_builder =
750        local_var_req_builder.json(&get_compression_signatures_for_owner_post_request);
751
752    let local_var_req = local_var_req_builder.build()?;
753    let local_var_resp = local_var_client.execute(local_var_req).await?;
754
755    let local_var_status = local_var_resp.status();
756    let local_var_content = local_var_resp.text().await?;
757
758    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
759        serde_json::from_str(&local_var_content).map_err(Error::from)
760    } else {
761        let local_var_entity: Option<GetCompressionSignaturesForOwnerPostError> =
762            serde_json::from_str(&local_var_content).ok();
763        let local_var_error = ResponseContent {
764            status: local_var_status,
765            content: local_var_content,
766            entity: local_var_entity,
767        };
768        Err(Error::ResponseError(local_var_error))
769    }
770}
771
772pub async fn get_compression_signatures_for_token_owner_post(
773    configuration: &configuration::Configuration,
774    get_compression_signatures_for_token_owner_post_request: models::GetCompressionSignaturesForTokenOwnerPostRequest,
775) -> Result<
776    models::GetCompressionSignaturesForAddressPost200Response,
777    Error<GetCompressionSignaturesForTokenOwnerPostError>,
778> {
779    let local_var_configuration = configuration;
780
781    let local_var_client = &local_var_configuration.client;
782
783    let local_var_uri_str = format!(
784        "{}/getCompressionSignaturesForTokenOwner",
785        local_var_configuration.base_path
786    );
787    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
788
789    let mut local_var_req_builder =
790        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
791
792    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
793        local_var_req_builder =
794            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
795    }
796    local_var_req_builder =
797        local_var_req_builder.json(&get_compression_signatures_for_token_owner_post_request);
798
799    let local_var_req = local_var_req_builder.build()?;
800    let local_var_resp = local_var_client.execute(local_var_req).await?;
801
802    let local_var_status = local_var_resp.status();
803    let local_var_content = local_var_resp.text().await?;
804
805    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
806        serde_json::from_str(&local_var_content).map_err(Error::from)
807    } else {
808        let local_var_entity: Option<GetCompressionSignaturesForTokenOwnerPostError> =
809            serde_json::from_str(&local_var_content).ok();
810        let local_var_error = ResponseContent {
811            status: local_var_status,
812            content: local_var_content,
813            entity: local_var_entity,
814        };
815        Err(Error::ResponseError(local_var_error))
816    }
817}
818
819pub async fn get_indexer_health_post(
820    configuration: &configuration::Configuration,
821    get_indexer_health_post_request: models::GetIndexerHealthPostRequest,
822) -> Result<models::GetIndexerHealthPost200Response, Error<GetIndexerHealthPostError>> {
823    let local_var_configuration = configuration;
824
825    let local_var_client = &local_var_configuration.client;
826
827    let local_var_uri_str = format!("{}/getIndexerHealth", local_var_configuration.base_path);
828    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
829
830    let mut local_var_req_builder =
831        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
832
833    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
834        local_var_req_builder =
835            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
836    }
837    local_var_req_builder = local_var_req_builder.json(&get_indexer_health_post_request);
838
839    let local_var_req = local_var_req_builder.build()?;
840    let local_var_resp = local_var_client.execute(local_var_req).await?;
841
842    let local_var_status = local_var_resp.status();
843    let local_var_content = local_var_resp.text().await?;
844
845    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
846        serde_json::from_str(&local_var_content).map_err(Error::from)
847    } else {
848        let local_var_entity: Option<GetIndexerHealthPostError> =
849            serde_json::from_str(&local_var_content).ok();
850        let local_var_error = ResponseContent {
851            status: local_var_status,
852            content: local_var_content,
853            entity: local_var_entity,
854        };
855        Err(Error::ResponseError(local_var_error))
856    }
857}
858
859pub async fn get_indexer_slot_post(
860    configuration: &configuration::Configuration,
861    get_indexer_slot_post_request: models::GetIndexerSlotPostRequest,
862) -> Result<models::GetIndexerSlotPost200Response, Error<GetIndexerSlotPostError>> {
863    let local_var_configuration = configuration;
864
865    let local_var_client = &local_var_configuration.client;
866
867    let local_var_uri_str = format!("{}/getIndexerSlot", local_var_configuration.base_path);
868    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
869
870    let mut local_var_req_builder =
871        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
872
873    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
874        local_var_req_builder =
875            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
876    }
877    local_var_req_builder = local_var_req_builder.json(&get_indexer_slot_post_request);
878
879    let local_var_req = local_var_req_builder.build()?;
880    let local_var_resp = local_var_client.execute(local_var_req).await?;
881
882    let local_var_status = local_var_resp.status();
883    let local_var_content = local_var_resp.text().await?;
884
885    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
886        serde_json::from_str(&local_var_content).map_err(Error::from)
887    } else {
888        let local_var_entity: Option<GetIndexerSlotPostError> =
889            serde_json::from_str(&local_var_content).ok();
890        let local_var_error = ResponseContent {
891            status: local_var_status,
892            content: local_var_content,
893            entity: local_var_entity,
894        };
895        Err(Error::ResponseError(local_var_error))
896    }
897}
898
899pub async fn get_latest_compression_signatures_post(
900    configuration: &configuration::Configuration,
901    get_latest_compression_signatures_post_request: models::GetLatestCompressionSignaturesPostRequest,
902) -> Result<
903    models::GetCompressionSignaturesForAddressPost200Response,
904    Error<GetLatestCompressionSignaturesPostError>,
905> {
906    let local_var_configuration = configuration;
907
908    let local_var_client = &local_var_configuration.client;
909
910    let local_var_uri_str = format!(
911        "{}/getLatestCompressionSignatures",
912        local_var_configuration.base_path
913    );
914    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
915
916    let mut local_var_req_builder =
917        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
918
919    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
920        local_var_req_builder =
921            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
922    }
923    local_var_req_builder =
924        local_var_req_builder.json(&get_latest_compression_signatures_post_request);
925
926    let local_var_req = local_var_req_builder.build()?;
927    let local_var_resp = local_var_client.execute(local_var_req).await?;
928
929    let local_var_status = local_var_resp.status();
930    let local_var_content = local_var_resp.text().await?;
931
932    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
933        serde_json::from_str(&local_var_content).map_err(Error::from)
934    } else {
935        let local_var_entity: Option<GetLatestCompressionSignaturesPostError> =
936            serde_json::from_str(&local_var_content).ok();
937        let local_var_error = ResponseContent {
938            status: local_var_status,
939            content: local_var_content,
940            entity: local_var_entity,
941        };
942        Err(Error::ResponseError(local_var_error))
943    }
944}
945
946pub async fn get_latest_non_voting_signatures_post(
947    configuration: &configuration::Configuration,
948    get_latest_non_voting_signatures_post_request: models::GetLatestNonVotingSignaturesPostRequest,
949) -> Result<
950    models::GetLatestNonVotingSignaturesPost200Response,
951    Error<GetLatestNonVotingSignaturesPostError>,
952> {
953    let local_var_configuration = configuration;
954
955    let local_var_client = &local_var_configuration.client;
956
957    let local_var_uri_str = format!(
958        "{}/getLatestNonVotingSignatures",
959        local_var_configuration.base_path
960    );
961    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
962
963    let mut local_var_req_builder =
964        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
965
966    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
967        local_var_req_builder =
968            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
969    }
970    local_var_req_builder =
971        local_var_req_builder.json(&get_latest_non_voting_signatures_post_request);
972
973    let local_var_req = local_var_req_builder.build()?;
974    let local_var_resp = local_var_client.execute(local_var_req).await?;
975
976    let local_var_status = local_var_resp.status();
977    let local_var_content = local_var_resp.text().await?;
978
979    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
980        serde_json::from_str(&local_var_content).map_err(Error::from)
981    } else {
982        let local_var_entity: Option<GetLatestNonVotingSignaturesPostError> =
983            serde_json::from_str(&local_var_content).ok();
984        let local_var_error = ResponseContent {
985            status: local_var_status,
986            content: local_var_content,
987            entity: local_var_entity,
988        };
989        Err(Error::ResponseError(local_var_error))
990    }
991}
992
993pub async fn get_multiple_compressed_account_proofs_post(
994    configuration: &configuration::Configuration,
995    get_multiple_compressed_account_proofs_post_request: models::GetMultipleCompressedAccountProofsPostRequest,
996) -> Result<
997    models::GetMultipleCompressedAccountProofsPost200Response,
998    Error<GetMultipleCompressedAccountProofsPostError>,
999> {
1000    let local_var_configuration = configuration;
1001
1002    let local_var_client = &local_var_configuration.client;
1003
1004    let local_var_uri_str = format!(
1005        "{}/getMultipleCompressedAccountProofs",
1006        local_var_configuration.base_path
1007    );
1008    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1009
1010    let mut local_var_req_builder =
1011        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1012
1013    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1014        local_var_req_builder =
1015            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1016    }
1017    local_var_req_builder =
1018        local_var_req_builder.json(&get_multiple_compressed_account_proofs_post_request);
1019
1020    let local_var_req = local_var_req_builder.build()?;
1021    let local_var_resp = local_var_client.execute(local_var_req).await?;
1022
1023    let local_var_status = local_var_resp.status();
1024    let local_var_content = local_var_resp.text().await?;
1025
1026    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1027        serde_json::from_str(&local_var_content).map_err(Error::from)
1028    } else {
1029        let local_var_entity: Option<GetMultipleCompressedAccountProofsPostError> =
1030            serde_json::from_str(&local_var_content).ok();
1031        let local_var_error = ResponseContent {
1032            status: local_var_status,
1033            content: local_var_content,
1034            entity: local_var_entity,
1035        };
1036        Err(Error::ResponseError(local_var_error))
1037    }
1038}
1039
1040pub async fn get_multiple_compressed_accounts_post(
1041    configuration: &configuration::Configuration,
1042    get_multiple_compressed_accounts_post_request: models::GetMultipleCompressedAccountsPostRequest,
1043) -> Result<
1044    models::GetMultipleCompressedAccountsPost200Response,
1045    Error<GetMultipleCompressedAccountsPostError>,
1046> {
1047    let local_var_configuration = configuration;
1048
1049    let local_var_client = &local_var_configuration.client;
1050
1051    let local_var_uri_str = format!(
1052        "{}/getMultipleCompressedAccounts",
1053        local_var_configuration.base_path
1054    );
1055    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1056
1057    let mut local_var_req_builder =
1058        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1059
1060    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1061        local_var_req_builder =
1062            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1063    }
1064    local_var_req_builder =
1065        local_var_req_builder.json(&get_multiple_compressed_accounts_post_request);
1066
1067    let local_var_req = local_var_req_builder.build()?;
1068    let local_var_resp = local_var_client.execute(local_var_req).await?;
1069
1070    let local_var_status = local_var_resp.status();
1071    let local_var_content = local_var_resp.text().await?;
1072
1073    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1074        serde_json::from_str(&local_var_content).map_err(Error::from)
1075    } else {
1076        let local_var_entity: Option<GetMultipleCompressedAccountsPostError> =
1077            serde_json::from_str(&local_var_content).ok();
1078        let local_var_error = ResponseContent {
1079            status: local_var_status,
1080            content: local_var_content,
1081            entity: local_var_entity,
1082        };
1083        Err(Error::ResponseError(local_var_error))
1084    }
1085}
1086
1087pub async fn get_multiple_new_address_proofs_post(
1088    configuration: &configuration::Configuration,
1089    get_multiple_new_address_proofs_post_request: models::GetMultipleNewAddressProofsPostRequest,
1090) -> Result<
1091    models::GetMultipleNewAddressProofsPost200Response,
1092    Error<GetMultipleNewAddressProofsPostError>,
1093> {
1094    let local_var_configuration = configuration;
1095
1096    let local_var_client = &local_var_configuration.client;
1097
1098    let local_var_uri_str = format!(
1099        "{}/getMultipleNewAddressProofs",
1100        local_var_configuration.base_path
1101    );
1102    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1103
1104    let mut local_var_req_builder =
1105        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1106
1107    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1108        local_var_req_builder =
1109            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1110    }
1111    local_var_req_builder =
1112        local_var_req_builder.json(&get_multiple_new_address_proofs_post_request);
1113
1114    let local_var_req = local_var_req_builder.build()?;
1115    let local_var_resp = local_var_client.execute(local_var_req).await?;
1116
1117    let local_var_status = local_var_resp.status();
1118    let local_var_content = local_var_resp.text().await?;
1119
1120    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1121        serde_json::from_str(&local_var_content).map_err(Error::from)
1122    } else {
1123        let local_var_entity: Option<GetMultipleNewAddressProofsPostError> =
1124            serde_json::from_str(&local_var_content).ok();
1125        let local_var_error = ResponseContent {
1126            status: local_var_status,
1127            content: local_var_content,
1128            entity: local_var_entity,
1129        };
1130        Err(Error::ResponseError(local_var_error))
1131    }
1132}
1133
1134pub async fn get_multiple_new_address_proofs_v2_post(
1135    configuration: &configuration::Configuration,
1136    get_multiple_new_address_proofs_v2_post_request: models::GetMultipleNewAddressProofsV2PostRequest,
1137) -> Result<
1138    models::GetMultipleNewAddressProofsPost200Response,
1139    Error<GetMultipleNewAddressProofsV2PostError>,
1140> {
1141    let local_var_configuration = configuration;
1142
1143    let local_var_client = &local_var_configuration.client;
1144
1145    let local_var_uri_str = format!(
1146        "{}/getMultipleNewAddressProofsV2",
1147        local_var_configuration.base_path
1148    );
1149    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1150
1151    let mut local_var_req_builder =
1152        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1153
1154    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1155        local_var_req_builder =
1156            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1157    }
1158    local_var_req_builder =
1159        local_var_req_builder.json(&get_multiple_new_address_proofs_v2_post_request);
1160
1161    let local_var_req = local_var_req_builder.build()?;
1162    let local_var_resp = local_var_client.execute(local_var_req).await?;
1163
1164    let local_var_status = local_var_resp.status();
1165    let local_var_content = local_var_resp.text().await?;
1166
1167    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1168        serde_json::from_str(&local_var_content).map_err(Error::from)
1169    } else {
1170        let local_var_entity: Option<GetMultipleNewAddressProofsV2PostError> =
1171            serde_json::from_str(&local_var_content).ok();
1172        let local_var_error = ResponseContent {
1173            status: local_var_status,
1174            content: local_var_content,
1175            entity: local_var_entity,
1176        };
1177        Err(Error::ResponseError(local_var_error))
1178    }
1179}
1180
1181pub async fn get_transaction_with_compression_info_post(
1182    configuration: &configuration::Configuration,
1183    get_transaction_with_compression_info_post_request: models::GetTransactionWithCompressionInfoPostRequest,
1184) -> Result<
1185    models::GetTransactionWithCompressionInfoPost200Response,
1186    Error<GetTransactionWithCompressionInfoPostError>,
1187> {
1188    let local_var_configuration = configuration;
1189
1190    let local_var_client = &local_var_configuration.client;
1191
1192    let local_var_uri_str = format!(
1193        "{}/getTransactionWithCompressionInfo",
1194        local_var_configuration.base_path
1195    );
1196    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1197
1198    let mut local_var_req_builder =
1199        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1200
1201    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1202        local_var_req_builder =
1203            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1204    }
1205    local_var_req_builder =
1206        local_var_req_builder.json(&get_transaction_with_compression_info_post_request);
1207
1208    let local_var_req = local_var_req_builder.build()?;
1209    let local_var_resp = local_var_client.execute(local_var_req).await?;
1210
1211    let local_var_status = local_var_resp.status();
1212    let local_var_content = local_var_resp.text().await?;
1213
1214    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1215        serde_json::from_str(&local_var_content).map_err(Error::from)
1216    } else {
1217        let local_var_entity: Option<GetTransactionWithCompressionInfoPostError> =
1218            serde_json::from_str(&local_var_content).ok();
1219        let local_var_error = ResponseContent {
1220            status: local_var_status,
1221            content: local_var_content,
1222            entity: local_var_entity,
1223        };
1224        Err(Error::ResponseError(local_var_error))
1225    }
1226}
1227
1228pub async fn get_validity_proof_post(
1229    configuration: &configuration::Configuration,
1230    get_validity_proof_post_request: models::GetValidityProofPostRequest,
1231) -> Result<models::GetValidityProofPost200Response, Error<GetValidityProofPostError>> {
1232    let local_var_configuration = configuration;
1233
1234    let local_var_client = &local_var_configuration.client;
1235
1236    let local_var_uri_str = format!("{}/getValidityProof", local_var_configuration.base_path);
1237    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1238
1239    let mut local_var_req_builder =
1240        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1241
1242    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1243        local_var_req_builder =
1244            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1245    }
1246    local_var_req_builder = local_var_req_builder.json(&get_validity_proof_post_request);
1247
1248    let local_var_req = local_var_req_builder.build()?;
1249    let local_var_resp = local_var_client.execute(local_var_req).await?;
1250
1251    let local_var_status = local_var_resp.status();
1252    let local_var_content = local_var_resp.text().await?;
1253
1254    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1255        serde_json::from_str(&local_var_content).map_err(Error::from)
1256    } else {
1257        let local_var_entity: Option<GetValidityProofPostError> =
1258            serde_json::from_str(&local_var_content).ok();
1259        let local_var_error = ResponseContent {
1260            status: local_var_status,
1261            content: local_var_content,
1262            entity: local_var_entity,
1263        };
1264        Err(Error::ResponseError(local_var_error))
1265    }
1266}
1267
1268fn append_api_key(configuration: &Configuration, uri_str: &str) -> String {
1269    let mut uri_str = uri_str.to_string();
1270    if let Some(ref api_key) = configuration.api_key {
1271        let prefix = api_key.prefix.clone().unwrap_or("api-key".to_string());
1272        uri_str = format!("{}?{}={}", uri_str, prefix, api_key.key);
1273    }
1274    uri_str
1275}
photon_api/apis/default_api.rs

photon_api/apis/
default_api.rs
