1use reqwest;
12
13use super::{configuration, Error};
14use crate::{
15 apis::{configuration::Configuration, ResponseContent},
16 models,
17};
18
19#[derive(Debug, Clone, Serialize, Deserialize)]
21#[serde(untagged)]
22pub enum GetBatchAddressUpdateInfoPostError {
23 Status429(models::GetBatchAddressUpdateInfoPost429Response),
24 Status500(models::GetBatchAddressUpdateInfoPost429Response),
25 UnknownValue(serde_json::Value),
26}
27
28#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(untagged)]
31pub enum GetCompressedAccountBalancePostError {
32 Status429(models::GetBatchAddressUpdateInfoPost429Response),
33 Status500(models::GetBatchAddressUpdateInfoPost429Response),
34 UnknownValue(serde_json::Value),
35}
36
37#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum GetCompressedAccountPostError {
41 Status429(models::GetBatchAddressUpdateInfoPost429Response),
42 Status500(models::GetBatchAddressUpdateInfoPost429Response),
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum GetCompressedAccountProofPostError {
50 Status429(models::GetBatchAddressUpdateInfoPost429Response),
51 Status500(models::GetBatchAddressUpdateInfoPost429Response),
52 UnknownValue(serde_json::Value),
53}
54
55#[derive(Debug, Clone, Serialize, Deserialize)]
57#[serde(untagged)]
58pub enum GetCompressedAccountProofV2PostError {
59 Status429(models::GetBatchAddressUpdateInfoPost429Response),
60 Status500(models::GetBatchAddressUpdateInfoPost429Response),
61 UnknownValue(serde_json::Value),
62}
63
64#[derive(Debug, Clone, Serialize, Deserialize)]
66#[serde(untagged)]
67pub enum GetCompressedAccountV2PostError {
68 Status429(models::GetBatchAddressUpdateInfoPost429Response),
69 Status500(models::GetBatchAddressUpdateInfoPost429Response),
70 UnknownValue(serde_json::Value),
71}
72
73#[derive(Debug, Clone, Serialize, Deserialize)]
75#[serde(untagged)]
76pub enum GetCompressedAccountsByOwnerPostError {
77 Status429(models::GetBatchAddressUpdateInfoPost429Response),
78 Status500(models::GetBatchAddressUpdateInfoPost429Response),
79 UnknownValue(serde_json::Value),
80}
81
82#[derive(Debug, Clone, Serialize, Deserialize)]
84#[serde(untagged)]
85pub enum GetCompressedAccountsByOwnerV2PostError {
86 Status429(models::GetBatchAddressUpdateInfoPost429Response),
87 Status500(models::GetBatchAddressUpdateInfoPost429Response),
88 UnknownValue(serde_json::Value),
89}
90
91#[derive(Debug, Clone, Serialize, Deserialize)]
93#[serde(untagged)]
94pub enum GetCompressedBalanceByOwnerPostError {
95 Status429(models::GetBatchAddressUpdateInfoPost429Response),
96 Status500(models::GetBatchAddressUpdateInfoPost429Response),
97 UnknownValue(serde_json::Value),
98}
99
100#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum GetCompressedMintTokenHoldersPostError {
104 Status429(models::GetBatchAddressUpdateInfoPost429Response),
105 Status500(models::GetBatchAddressUpdateInfoPost429Response),
106 UnknownValue(serde_json::Value),
107}
108
109#[derive(Debug, Clone, Serialize, Deserialize)]
111#[serde(untagged)]
112pub enum GetCompressedTokenAccountBalancePostError {
113 Status429(models::GetBatchAddressUpdateInfoPost429Response),
114 Status500(models::GetBatchAddressUpdateInfoPost429Response),
115 UnknownValue(serde_json::Value),
116}
117
118#[derive(Debug, Clone, Serialize, Deserialize)]
120#[serde(untagged)]
121pub enum GetCompressedTokenAccountsByDelegatePostError {
122 Status429(models::GetBatchAddressUpdateInfoPost429Response),
123 Status500(models::GetBatchAddressUpdateInfoPost429Response),
124 UnknownValue(serde_json::Value),
125}
126
127#[derive(Debug, Clone, Serialize, Deserialize)]
129#[serde(untagged)]
130pub enum GetCompressedTokenAccountsByDelegateV2PostError {
131 Status429(models::GetBatchAddressUpdateInfoPost429Response),
132 Status500(models::GetBatchAddressUpdateInfoPost429Response),
133 UnknownValue(serde_json::Value),
134}
135
136#[derive(Debug, Clone, Serialize, Deserialize)]
138#[serde(untagged)]
139pub enum GetCompressedTokenAccountsByOwnerPostError {
140 Status429(models::GetBatchAddressUpdateInfoPost429Response),
141 Status500(models::GetBatchAddressUpdateInfoPost429Response),
142 UnknownValue(serde_json::Value),
143}
144
145#[derive(Debug, Clone, Serialize, Deserialize)]
147#[serde(untagged)]
148pub enum GetCompressedTokenAccountsByOwnerV2PostError {
149 Status429(models::GetBatchAddressUpdateInfoPost429Response),
150 Status500(models::GetBatchAddressUpdateInfoPost429Response),
151 UnknownValue(serde_json::Value),
152}
153
154#[derive(Debug, Clone, Serialize, Deserialize)]
156#[serde(untagged)]
157pub enum GetCompressedTokenBalancesByOwnerPostError {
158 Status429(models::GetBatchAddressUpdateInfoPost429Response),
159 Status500(models::GetBatchAddressUpdateInfoPost429Response),
160 UnknownValue(serde_json::Value),
161}
162
163#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum GetCompressedTokenBalancesByOwnerV2PostError {
167 Status429(models::GetBatchAddressUpdateInfoPost429Response),
168 Status500(models::GetBatchAddressUpdateInfoPost429Response),
169 UnknownValue(serde_json::Value),
170}
171
172#[derive(Debug, Clone, Serialize, Deserialize)]
174#[serde(untagged)]
175pub enum GetCompressionSignaturesForAccountPostError {
176 Status429(models::GetBatchAddressUpdateInfoPost429Response),
177 Status500(models::GetBatchAddressUpdateInfoPost429Response),
178 UnknownValue(serde_json::Value),
179}
180
181#[derive(Debug, Clone, Serialize, Deserialize)]
183#[serde(untagged)]
184pub enum GetCompressionSignaturesForAddressPostError {
185 Status429(models::GetBatchAddressUpdateInfoPost429Response),
186 Status500(models::GetBatchAddressUpdateInfoPost429Response),
187 UnknownValue(serde_json::Value),
188}
189
190#[derive(Debug, Clone, Serialize, Deserialize)]
192#[serde(untagged)]
193pub enum GetCompressionSignaturesForOwnerPostError {
194 Status429(models::GetBatchAddressUpdateInfoPost429Response),
195 Status500(models::GetBatchAddressUpdateInfoPost429Response),
196 UnknownValue(serde_json::Value),
197}
198
199#[derive(Debug, Clone, Serialize, Deserialize)]
201#[serde(untagged)]
202pub enum GetCompressionSignaturesForTokenOwnerPostError {
203 Status429(models::GetBatchAddressUpdateInfoPost429Response),
204 Status500(models::GetBatchAddressUpdateInfoPost429Response),
205 UnknownValue(serde_json::Value),
206}
207
208#[derive(Debug, Clone, Serialize, Deserialize)]
210#[serde(untagged)]
211pub enum GetIndexerHealthPostError {
212 Status429(models::GetBatchAddressUpdateInfoPost429Response),
213 Status500(models::GetBatchAddressUpdateInfoPost429Response),
214 UnknownValue(serde_json::Value),
215}
216
217#[derive(Debug, Clone, Serialize, Deserialize)]
219#[serde(untagged)]
220pub enum GetIndexerSlotPostError {
221 Status429(models::GetBatchAddressUpdateInfoPost429Response),
222 Status500(models::GetBatchAddressUpdateInfoPost429Response),
223 UnknownValue(serde_json::Value),
224}
225
226#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum GetLatestCompressionSignaturesPostError {
230 Status429(models::GetBatchAddressUpdateInfoPost429Response),
231 Status500(models::GetBatchAddressUpdateInfoPost429Response),
232 UnknownValue(serde_json::Value),
233}
234
235#[derive(Debug, Clone, Serialize, Deserialize)]
237#[serde(untagged)]
238pub enum GetLatestNonVotingSignaturesPostError {
239 Status429(models::GetBatchAddressUpdateInfoPost429Response),
240 Status500(models::GetBatchAddressUpdateInfoPost429Response),
241 UnknownValue(serde_json::Value),
242}
243
244#[derive(Debug, Clone, Serialize, Deserialize)]
246#[serde(untagged)]
247pub enum GetMultipleCompressedAccountProofsPostError {
248 Status429(models::GetBatchAddressUpdateInfoPost429Response),
249 Status500(models::GetBatchAddressUpdateInfoPost429Response),
250 UnknownValue(serde_json::Value),
251}
252
253#[derive(Debug, Clone, Serialize, Deserialize)]
255#[serde(untagged)]
256pub enum GetMultipleCompressedAccountProofsV2PostError {
257 Status429(models::GetBatchAddressUpdateInfoPost429Response),
258 Status500(models::GetBatchAddressUpdateInfoPost429Response),
259 UnknownValue(serde_json::Value),
260}
261
262#[derive(Debug, Clone, Serialize, Deserialize)]
264#[serde(untagged)]
265pub enum GetMultipleCompressedAccountsPostError {
266 Status429(models::GetBatchAddressUpdateInfoPost429Response),
267 Status500(models::GetBatchAddressUpdateInfoPost429Response),
268 UnknownValue(serde_json::Value),
269}
270
271#[derive(Debug, Clone, Serialize, Deserialize)]
273#[serde(untagged)]
274pub enum GetMultipleCompressedAccountsV2PostError {
275 Status429(models::GetBatchAddressUpdateInfoPost429Response),
276 Status500(models::GetBatchAddressUpdateInfoPost429Response),
277 UnknownValue(serde_json::Value),
278}
279
280#[derive(Debug, Clone, Serialize, Deserialize)]
282#[serde(untagged)]
283pub enum GetMultipleNewAddressProofsPostError {
284 Status429(models::GetBatchAddressUpdateInfoPost429Response),
285 Status500(models::GetBatchAddressUpdateInfoPost429Response),
286 UnknownValue(serde_json::Value),
287}
288
289#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(untagged)]
292pub enum GetMultipleNewAddressProofsV2PostError {
293 Status429(models::GetBatchAddressUpdateInfoPost429Response),
294 Status500(models::GetBatchAddressUpdateInfoPost429Response),
295 UnknownValue(serde_json::Value),
296}
297
298#[derive(Debug, Clone, Serialize, Deserialize)]
300#[serde(untagged)]
301pub enum GetQueueElementsPostError {
302 Status429(models::GetBatchAddressUpdateInfoPost429Response),
303 Status500(models::GetBatchAddressUpdateInfoPost429Response),
304 UnknownValue(serde_json::Value),
305}
306
307#[derive(Debug, Clone, Serialize, Deserialize)]
309#[serde(untagged)]
310pub enum GetTransactionWithCompressionInfoPostError {
311 Status429(models::GetBatchAddressUpdateInfoPost429Response),
312 Status500(models::GetBatchAddressUpdateInfoPost429Response),
313 UnknownValue(serde_json::Value),
314}
315
316#[derive(Debug, Clone, Serialize, Deserialize)]
318#[serde(untagged)]
319pub enum GetTransactionWithCompressionInfoV2PostError {
320 Status429(models::GetBatchAddressUpdateInfoPost429Response),
321 Status500(models::GetBatchAddressUpdateInfoPost429Response),
322 UnknownValue(serde_json::Value),
323}
324
325#[derive(Debug, Clone, Serialize, Deserialize)]
327#[serde(untagged)]
328pub enum GetValidityProofPostError {
329 Status429(models::GetBatchAddressUpdateInfoPost429Response),
330 Status500(models::GetBatchAddressUpdateInfoPost429Response),
331 UnknownValue(serde_json::Value),
332}
333
334#[derive(Debug, Clone, Serialize, Deserialize)]
336#[serde(untagged)]
337pub enum GetValidityProofV2PostError {
338 Status429(models::GetBatchAddressUpdateInfoPost429Response),
339 Status500(models::GetBatchAddressUpdateInfoPost429Response),
340 UnknownValue(serde_json::Value),
341}
342
343pub async fn get_batch_address_update_info_post(
344 configuration: &configuration::Configuration,
345 get_batch_address_update_info_post_request: models::GetBatchAddressUpdateInfoPostRequest,
346) -> Result<
347 models::GetBatchAddressUpdateInfoPost200Response,
348 Error<GetBatchAddressUpdateInfoPostError>,
349> {
350 let local_var_configuration = configuration;
351
352 let local_var_client = &local_var_configuration.client;
353
354 let local_var_uri_str = format!(
355 "{}/getBatchAddressUpdateInfo",
356 local_var_configuration.base_path
357 );
358 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
359 let mut local_var_req_builder =
360 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
361
362 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
363 local_var_req_builder =
364 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
365 }
366 local_var_req_builder = local_var_req_builder.json(&get_batch_address_update_info_post_request);
367
368 let local_var_req = local_var_req_builder.build()?;
369 let local_var_resp = local_var_client.execute(local_var_req).await?;
370
371 let local_var_status = local_var_resp.status();
372 let local_var_content = local_var_resp.text().await?;
373
374 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
375 serde_json::from_str(&local_var_content).map_err(Error::from)
376 } else {
377 let local_var_entity: Option<GetBatchAddressUpdateInfoPostError> =
378 serde_json::from_str(&local_var_content).ok();
379 let local_var_error = ResponseContent {
380 status: local_var_status,
381 content: local_var_content,
382 entity: local_var_entity,
383 };
384 Err(Error::ResponseError(local_var_error))
385 }
386}
387
388pub async fn get_compressed_account_balance_post(
389 configuration: &configuration::Configuration,
390 get_compressed_account_balance_post_request: models::GetCompressedAccountBalancePostRequest,
391) -> Result<
392 models::GetCompressedAccountBalancePost200Response,
393 Error<GetCompressedAccountBalancePostError>,
394> {
395 let local_var_configuration = configuration;
396
397 let local_var_client = &local_var_configuration.client;
398
399 let local_var_uri_str = format!(
400 "{}/getCompressedAccountBalance",
401 local_var_configuration.base_path
402 );
403 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
404 let mut local_var_req_builder =
405 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
406
407 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
408 local_var_req_builder =
409 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
410 }
411 local_var_req_builder =
412 local_var_req_builder.json(&get_compressed_account_balance_post_request);
413
414 let local_var_req = local_var_req_builder.build()?;
415 let local_var_resp = local_var_client.execute(local_var_req).await?;
416
417 let local_var_status = local_var_resp.status();
418 let local_var_content = local_var_resp.text().await?;
419
420 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
421 serde_json::from_str(&local_var_content).map_err(Error::from)
422 } else {
423 let local_var_entity: Option<GetCompressedAccountBalancePostError> =
424 serde_json::from_str(&local_var_content).ok();
425 let local_var_error = ResponseContent {
426 status: local_var_status,
427 content: local_var_content,
428 entity: local_var_entity,
429 };
430 Err(Error::ResponseError(local_var_error))
431 }
432}
433
434pub async fn get_compressed_account_post(
435 configuration: &configuration::Configuration,
436 get_compressed_account_post_request: models::GetCompressedAccountPostRequest,
437) -> Result<models::GetCompressedAccountPost200Response, Error<GetCompressedAccountPostError>> {
438 let local_var_configuration = configuration;
439
440 let local_var_client = &local_var_configuration.client;
441
442 let local_var_uri_str = format!("{}/getCompressedAccount", local_var_configuration.base_path);
443 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
444 let mut local_var_req_builder =
445 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
446
447 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
448 local_var_req_builder =
449 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
450 }
451 local_var_req_builder = local_var_req_builder.json(&get_compressed_account_post_request);
452
453 let local_var_req = local_var_req_builder.build()?;
454 let local_var_resp = local_var_client.execute(local_var_req).await?;
455
456 let local_var_status = local_var_resp.status();
457 let local_var_content = local_var_resp.text().await?;
458
459 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
460 serde_json::from_str(&local_var_content).map_err(Error::from)
461 } else {
462 let local_var_entity: Option<GetCompressedAccountPostError> =
463 serde_json::from_str(&local_var_content).ok();
464 let local_var_error = ResponseContent {
465 status: local_var_status,
466 content: local_var_content,
467 entity: local_var_entity,
468 };
469 Err(Error::ResponseError(local_var_error))
470 }
471}
472
473pub async fn get_compressed_account_proof_post(
474 configuration: &configuration::Configuration,
475 get_compressed_account_proof_post_request: models::GetCompressedAccountProofPostRequest,
476) -> Result<
477 models::GetCompressedAccountProofPost200Response,
478 Error<GetCompressedAccountProofPostError>,
479> {
480 let local_var_configuration = configuration;
481
482 let local_var_client = &local_var_configuration.client;
483
484 let local_var_uri_str = format!(
485 "{}/getCompressedAccountProof",
486 local_var_configuration.base_path
487 );
488 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
489 let mut local_var_req_builder =
490 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
491
492 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
493 local_var_req_builder =
494 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
495 }
496 local_var_req_builder = local_var_req_builder.json(&get_compressed_account_proof_post_request);
497
498 let local_var_req = local_var_req_builder.build()?;
499 let local_var_resp = local_var_client.execute(local_var_req).await?;
500
501 let local_var_status = local_var_resp.status();
502 let local_var_content = local_var_resp.text().await?;
503
504 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
505 serde_json::from_str(&local_var_content).map_err(Error::from)
506 } else {
507 let local_var_entity: Option<GetCompressedAccountProofPostError> =
508 serde_json::from_str(&local_var_content).ok();
509 let local_var_error = ResponseContent {
510 status: local_var_status,
511 content: local_var_content,
512 entity: local_var_entity,
513 };
514 Err(Error::ResponseError(local_var_error))
515 }
516}
517
518pub async fn get_compressed_account_proof_v2_post(
519 configuration: &configuration::Configuration,
520 get_compressed_account_proof_v2_post_request: models::GetCompressedAccountProofV2PostRequest,
521) -> Result<
522 models::GetCompressedAccountProofV2Post200Response,
523 Error<GetCompressedAccountProofV2PostError>,
524> {
525 let local_var_configuration = configuration;
526
527 let local_var_client = &local_var_configuration.client;
528
529 let local_var_uri_str = format!(
530 "{}/getCompressedAccountProofV2",
531 local_var_configuration.base_path
532 );
533 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
534 let mut local_var_req_builder =
535 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
536
537 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
538 local_var_req_builder =
539 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
540 }
541 local_var_req_builder =
542 local_var_req_builder.json(&get_compressed_account_proof_v2_post_request);
543
544 let local_var_req = local_var_req_builder.build()?;
545 let local_var_resp = local_var_client.execute(local_var_req).await?;
546
547 let local_var_status = local_var_resp.status();
548 let local_var_content = local_var_resp.text().await?;
549
550 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
551 serde_json::from_str(&local_var_content).map_err(Error::from)
552 } else {
553 let local_var_entity: Option<GetCompressedAccountProofV2PostError> =
554 serde_json::from_str(&local_var_content).ok();
555 let local_var_error = ResponseContent {
556 status: local_var_status,
557 content: local_var_content,
558 entity: local_var_entity,
559 };
560 Err(Error::ResponseError(local_var_error))
561 }
562}
563
564pub async fn get_compressed_account_v2_post(
565 configuration: &configuration::Configuration,
566 get_compressed_account_v2_post_request: models::GetCompressedAccountV2PostRequest,
567) -> Result<models::GetCompressedAccountV2Post200Response, Error<GetCompressedAccountV2PostError>> {
568 let local_var_configuration = configuration;
569
570 let local_var_client = &local_var_configuration.client;
571
572 let local_var_uri_str = format!(
573 "{}/getCompressedAccountV2",
574 local_var_configuration.base_path
575 );
576 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
577 let mut local_var_req_builder =
578 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
579
580 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
581 local_var_req_builder =
582 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
583 }
584 local_var_req_builder = local_var_req_builder.json(&get_compressed_account_v2_post_request);
585
586 let local_var_req = local_var_req_builder.build()?;
587 let local_var_resp = local_var_client.execute(local_var_req).await?;
588
589 let local_var_status = local_var_resp.status();
590 let local_var_content = local_var_resp.text().await?;
591
592 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
593 serde_json::from_str(&local_var_content).map_err(Error::from)
594 } else {
595 let local_var_entity: Option<GetCompressedAccountV2PostError> =
596 serde_json::from_str(&local_var_content).ok();
597 let local_var_error = ResponseContent {
598 status: local_var_status,
599 content: local_var_content,
600 entity: local_var_entity,
601 };
602 Err(Error::ResponseError(local_var_error))
603 }
604}
605
606pub async fn get_compressed_accounts_by_owner_post(
607 configuration: &configuration::Configuration,
608 get_compressed_accounts_by_owner_post_request: models::GetCompressedAccountsByOwnerPostRequest,
609) -> Result<
610 models::GetCompressedAccountsByOwnerPost200Response,
611 Error<GetCompressedAccountsByOwnerPostError>,
612> {
613 let local_var_configuration = configuration;
614
615 let local_var_client = &local_var_configuration.client;
616
617 let local_var_uri_str = format!(
618 "{}/getCompressedAccountsByOwner",
619 local_var_configuration.base_path
620 );
621 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
622 let mut local_var_req_builder =
623 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
624
625 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
626 local_var_req_builder =
627 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
628 }
629 local_var_req_builder =
630 local_var_req_builder.json(&get_compressed_accounts_by_owner_post_request);
631
632 let local_var_req = local_var_req_builder.build()?;
633 let local_var_resp = local_var_client.execute(local_var_req).await?;
634
635 let local_var_status = local_var_resp.status();
636 let local_var_content = local_var_resp.text().await?;
637
638 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
639 serde_json::from_str(&local_var_content).map_err(Error::from)
640 } else {
641 let local_var_entity: Option<GetCompressedAccountsByOwnerPostError> =
642 serde_json::from_str(&local_var_content).ok();
643 let local_var_error = ResponseContent {
644 status: local_var_status,
645 content: local_var_content,
646 entity: local_var_entity,
647 };
648 Err(Error::ResponseError(local_var_error))
649 }
650}
651
652pub async fn get_compressed_accounts_by_owner_v2_post(
653 configuration: &configuration::Configuration,
654 get_compressed_accounts_by_owner_v2_post_request: models::GetCompressedAccountsByOwnerV2PostRequest,
655) -> Result<
656 models::GetCompressedAccountsByOwnerV2Post200Response,
657 Error<GetCompressedAccountsByOwnerV2PostError>,
658> {
659 let local_var_configuration = configuration;
660
661 let local_var_client = &local_var_configuration.client;
662
663 let local_var_uri_str = format!(
664 "{}/getCompressedAccountsByOwnerV2",
665 local_var_configuration.base_path
666 );
667 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
668 let mut local_var_req_builder =
669 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
670
671 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
672 local_var_req_builder =
673 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
674 }
675 local_var_req_builder =
676 local_var_req_builder.json(&get_compressed_accounts_by_owner_v2_post_request);
677
678 let local_var_req = local_var_req_builder.build()?;
679 let local_var_resp = local_var_client.execute(local_var_req).await?;
680
681 let local_var_status = local_var_resp.status();
682 let local_var_content = local_var_resp.text().await?;
683
684 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
685 serde_json::from_str(&local_var_content).map_err(Error::from)
686 } else {
687 let local_var_entity: Option<GetCompressedAccountsByOwnerV2PostError> =
688 serde_json::from_str(&local_var_content).ok();
689 let local_var_error = ResponseContent {
690 status: local_var_status,
691 content: local_var_content,
692 entity: local_var_entity,
693 };
694 Err(Error::ResponseError(local_var_error))
695 }
696}
697
698pub async fn get_compressed_balance_by_owner_post(
699 configuration: &configuration::Configuration,
700 get_compressed_balance_by_owner_post_request: models::GetCompressedBalanceByOwnerPostRequest,
701) -> Result<
702 models::GetCompressedAccountBalancePost200Response,
703 Error<GetCompressedBalanceByOwnerPostError>,
704> {
705 let local_var_configuration = configuration;
706
707 let local_var_client = &local_var_configuration.client;
708
709 let local_var_uri_str = format!(
710 "{}/getCompressedBalanceByOwner",
711 local_var_configuration.base_path
712 );
713 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
714 let mut local_var_req_builder =
715 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
716
717 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
718 local_var_req_builder =
719 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
720 }
721 local_var_req_builder =
722 local_var_req_builder.json(&get_compressed_balance_by_owner_post_request);
723
724 let local_var_req = local_var_req_builder.build()?;
725 let local_var_resp = local_var_client.execute(local_var_req).await?;
726
727 let local_var_status = local_var_resp.status();
728 let local_var_content = local_var_resp.text().await?;
729
730 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
731 serde_json::from_str(&local_var_content).map_err(Error::from)
732 } else {
733 let local_var_entity: Option<GetCompressedBalanceByOwnerPostError> =
734 serde_json::from_str(&local_var_content).ok();
735 let local_var_error = ResponseContent {
736 status: local_var_status,
737 content: local_var_content,
738 entity: local_var_entity,
739 };
740 Err(Error::ResponseError(local_var_error))
741 }
742}
743
744pub async fn get_compressed_mint_token_holders_post(
745 configuration: &configuration::Configuration,
746 get_compressed_mint_token_holders_post_request: models::GetCompressedMintTokenHoldersPostRequest,
747) -> Result<
748 models::GetCompressedMintTokenHoldersPost200Response,
749 Error<GetCompressedMintTokenHoldersPostError>,
750> {
751 let local_var_configuration = configuration;
752
753 let local_var_client = &local_var_configuration.client;
754
755 let local_var_uri_str = format!(
756 "{}/getCompressedMintTokenHolders",
757 local_var_configuration.base_path
758 );
759 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
760 let mut local_var_req_builder =
761 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
762
763 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
764 local_var_req_builder =
765 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
766 }
767 local_var_req_builder =
768 local_var_req_builder.json(&get_compressed_mint_token_holders_post_request);
769
770 let local_var_req = local_var_req_builder.build()?;
771 let local_var_resp = local_var_client.execute(local_var_req).await?;
772
773 let local_var_status = local_var_resp.status();
774 let local_var_content = local_var_resp.text().await?;
775
776 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
777 serde_json::from_str(&local_var_content).map_err(Error::from)
778 } else {
779 let local_var_entity: Option<GetCompressedMintTokenHoldersPostError> =
780 serde_json::from_str(&local_var_content).ok();
781 let local_var_error = ResponseContent {
782 status: local_var_status,
783 content: local_var_content,
784 entity: local_var_entity,
785 };
786 Err(Error::ResponseError(local_var_error))
787 }
788}
789
790pub async fn get_compressed_token_account_balance_post(
791 configuration: &configuration::Configuration,
792 get_compressed_token_account_balance_post_request: models::GetCompressedTokenAccountBalancePostRequest,
793) -> Result<
794 models::GetCompressedTokenAccountBalancePost200Response,
795 Error<GetCompressedTokenAccountBalancePostError>,
796> {
797 let local_var_configuration = configuration;
798
799 let local_var_client = &local_var_configuration.client;
800
801 let local_var_uri_str = format!(
802 "{}/getCompressedTokenAccountBalance",
803 local_var_configuration.base_path
804 );
805 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
806 let mut local_var_req_builder =
807 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
808
809 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
810 local_var_req_builder =
811 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
812 }
813 local_var_req_builder =
814 local_var_req_builder.json(&get_compressed_token_account_balance_post_request);
815
816 let local_var_req = local_var_req_builder.build()?;
817 let local_var_resp = local_var_client.execute(local_var_req).await?;
818
819 let local_var_status = local_var_resp.status();
820 let local_var_content = local_var_resp.text().await?;
821
822 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
823 serde_json::from_str(&local_var_content).map_err(Error::from)
824 } else {
825 let local_var_entity: Option<GetCompressedTokenAccountBalancePostError> =
826 serde_json::from_str(&local_var_content).ok();
827 let local_var_error = ResponseContent {
828 status: local_var_status,
829 content: local_var_content,
830 entity: local_var_entity,
831 };
832 Err(Error::ResponseError(local_var_error))
833 }
834}
835
836pub async fn get_compressed_token_accounts_by_delegate_post(
837 configuration: &configuration::Configuration,
838 get_compressed_token_accounts_by_delegate_post_request: models::GetCompressedTokenAccountsByDelegatePostRequest,
839) -> Result<
840 models::GetCompressedTokenAccountsByDelegatePost200Response,
841 Error<GetCompressedTokenAccountsByDelegatePostError>,
842> {
843 let local_var_configuration = configuration;
844
845 let local_var_client = &local_var_configuration.client;
846
847 let local_var_uri_str = format!(
848 "{}/getCompressedTokenAccountsByDelegate",
849 local_var_configuration.base_path
850 );
851 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
852 let mut local_var_req_builder =
853 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
854
855 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
856 local_var_req_builder =
857 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
858 }
859 local_var_req_builder =
860 local_var_req_builder.json(&get_compressed_token_accounts_by_delegate_post_request);
861
862 let local_var_req = local_var_req_builder.build()?;
863 let local_var_resp = local_var_client.execute(local_var_req).await?;
864
865 let local_var_status = local_var_resp.status();
866 let local_var_content = local_var_resp.text().await?;
867
868 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
869 serde_json::from_str(&local_var_content).map_err(Error::from)
870 } else {
871 let local_var_entity: Option<GetCompressedTokenAccountsByDelegatePostError> =
872 serde_json::from_str(&local_var_content).ok();
873 let local_var_error = ResponseContent {
874 status: local_var_status,
875 content: local_var_content,
876 entity: local_var_entity,
877 };
878 Err(Error::ResponseError(local_var_error))
879 }
880}
881
882pub async fn get_compressed_token_accounts_by_delegate_v2_post(
883 configuration: &configuration::Configuration,
884 get_compressed_token_accounts_by_delegate_v2_post_request: models::GetCompressedTokenAccountsByDelegateV2PostRequest,
885) -> Result<
886 models::GetCompressedTokenAccountsByDelegateV2Post200Response,
887 Error<GetCompressedTokenAccountsByDelegateV2PostError>,
888> {
889 let local_var_configuration = configuration;
890
891 let local_var_client = &local_var_configuration.client;
892
893 let local_var_uri_str = format!(
894 "{}/getCompressedTokenAccountsByDelegateV2",
895 local_var_configuration.base_path
896 );
897 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
898 let mut local_var_req_builder =
899 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
900
901 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
902 local_var_req_builder =
903 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
904 }
905 local_var_req_builder =
906 local_var_req_builder.json(&get_compressed_token_accounts_by_delegate_v2_post_request);
907
908 let local_var_req = local_var_req_builder.build()?;
909 let local_var_resp = local_var_client.execute(local_var_req).await?;
910
911 let local_var_status = local_var_resp.status();
912 let local_var_content = local_var_resp.text().await?;
913
914 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
915 serde_json::from_str(&local_var_content).map_err(Error::from)
916 } else {
917 let local_var_entity: Option<GetCompressedTokenAccountsByDelegateV2PostError> =
918 serde_json::from_str(&local_var_content).ok();
919 let local_var_error = ResponseContent {
920 status: local_var_status,
921 content: local_var_content,
922 entity: local_var_entity,
923 };
924 Err(Error::ResponseError(local_var_error))
925 }
926}
927
928pub async fn get_compressed_token_accounts_by_owner_post(
929 configuration: &configuration::Configuration,
930 get_compressed_token_accounts_by_owner_post_request: models::GetCompressedTokenAccountsByOwnerPostRequest,
931) -> Result<
932 models::GetCompressedTokenAccountsByDelegatePost200Response,
933 Error<GetCompressedTokenAccountsByOwnerPostError>,
934> {
935 let local_var_configuration = configuration;
936
937 let local_var_client = &local_var_configuration.client;
938
939 let local_var_uri_str = format!(
940 "{}/getCompressedTokenAccountsByOwner",
941 local_var_configuration.base_path
942 );
943 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
944 let mut local_var_req_builder =
945 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
946
947 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
948 local_var_req_builder =
949 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
950 }
951 local_var_req_builder =
952 local_var_req_builder.json(&get_compressed_token_accounts_by_owner_post_request);
953
954 let local_var_req = local_var_req_builder.build()?;
955 let local_var_resp = local_var_client.execute(local_var_req).await?;
956
957 let local_var_status = local_var_resp.status();
958 let local_var_content = local_var_resp.text().await?;
959
960 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
961 serde_json::from_str(&local_var_content).map_err(Error::from)
962 } else {
963 let local_var_entity: Option<GetCompressedTokenAccountsByOwnerPostError> =
964 serde_json::from_str(&local_var_content).ok();
965 let local_var_error = ResponseContent {
966 status: local_var_status,
967 content: local_var_content,
968 entity: local_var_entity,
969 };
970 Err(Error::ResponseError(local_var_error))
971 }
972}
973
974pub async fn get_compressed_token_accounts_by_owner_v2_post(
975 configuration: &configuration::Configuration,
976 get_compressed_token_accounts_by_owner_v2_post_request: models::GetCompressedTokenAccountsByOwnerV2PostRequest,
977) -> Result<
978 models::GetCompressedTokenAccountsByDelegateV2Post200Response,
979 Error<GetCompressedTokenAccountsByOwnerV2PostError>,
980> {
981 let local_var_configuration = configuration;
982
983 let local_var_client = &local_var_configuration.client;
984
985 let local_var_uri_str = format!(
986 "{}/getCompressedTokenAccountsByOwnerV2",
987 local_var_configuration.base_path
988 );
989 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
990 let mut local_var_req_builder =
991 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
992
993 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
994 local_var_req_builder =
995 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
996 }
997 local_var_req_builder =
998 local_var_req_builder.json(&get_compressed_token_accounts_by_owner_v2_post_request);
999
1000 let local_var_req = local_var_req_builder.build()?;
1001 let local_var_resp = local_var_client.execute(local_var_req).await?;
1002
1003 let local_var_status = local_var_resp.status();
1004 let local_var_content = local_var_resp.text().await?;
1005
1006 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1007 serde_json::from_str(&local_var_content).map_err(Error::from)
1008 } else {
1009 let local_var_entity: Option<GetCompressedTokenAccountsByOwnerV2PostError> =
1010 serde_json::from_str(&local_var_content).ok();
1011 let local_var_error = ResponseContent {
1012 status: local_var_status,
1013 content: local_var_content,
1014 entity: local_var_entity,
1015 };
1016 Err(Error::ResponseError(local_var_error))
1017 }
1018}
1019
1020pub async fn get_compressed_token_balances_by_owner_post(
1021 configuration: &configuration::Configuration,
1022 get_compressed_token_balances_by_owner_post_request: models::GetCompressedTokenBalancesByOwnerPostRequest,
1023) -> Result<
1024 models::GetCompressedTokenBalancesByOwnerPost200Response,
1025 Error<GetCompressedTokenBalancesByOwnerPostError>,
1026> {
1027 let local_var_configuration = configuration;
1028
1029 let local_var_client = &local_var_configuration.client;
1030
1031 let local_var_uri_str = format!(
1032 "{}/getCompressedTokenBalancesByOwner",
1033 local_var_configuration.base_path
1034 );
1035 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1036 let mut local_var_req_builder =
1037 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1038
1039 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1040 local_var_req_builder =
1041 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1042 }
1043 local_var_req_builder =
1044 local_var_req_builder.json(&get_compressed_token_balances_by_owner_post_request);
1045
1046 let local_var_req = local_var_req_builder.build()?;
1047 let local_var_resp = local_var_client.execute(local_var_req).await?;
1048
1049 let local_var_status = local_var_resp.status();
1050 let local_var_content = local_var_resp.text().await?;
1051
1052 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1053 serde_json::from_str(&local_var_content).map_err(Error::from)
1054 } else {
1055 let local_var_entity: Option<GetCompressedTokenBalancesByOwnerPostError> =
1056 serde_json::from_str(&local_var_content).ok();
1057 let local_var_error = ResponseContent {
1058 status: local_var_status,
1059 content: local_var_content,
1060 entity: local_var_entity,
1061 };
1062 Err(Error::ResponseError(local_var_error))
1063 }
1064}
1065
1066pub async fn get_compressed_token_balances_by_owner_v2_post(
1067 configuration: &configuration::Configuration,
1068 get_compressed_token_balances_by_owner_v2_post_request: models::GetCompressedTokenBalancesByOwnerV2PostRequest,
1069) -> Result<
1070 models::GetCompressedTokenBalancesByOwnerV2Post200Response,
1071 Error<GetCompressedTokenBalancesByOwnerV2PostError>,
1072> {
1073 let local_var_configuration = configuration;
1074
1075 let local_var_client = &local_var_configuration.client;
1076
1077 let local_var_uri_str = format!(
1078 "{}/getCompressedTokenBalancesByOwnerV2",
1079 local_var_configuration.base_path
1080 );
1081 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1082 let mut local_var_req_builder =
1083 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1084
1085 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1086 local_var_req_builder =
1087 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1088 }
1089 local_var_req_builder =
1090 local_var_req_builder.json(&get_compressed_token_balances_by_owner_v2_post_request);
1091
1092 let local_var_req = local_var_req_builder.build()?;
1093 let local_var_resp = local_var_client.execute(local_var_req).await?;
1094
1095 let local_var_status = local_var_resp.status();
1096 let local_var_content = local_var_resp.text().await?;
1097
1098 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1099 serde_json::from_str(&local_var_content).map_err(Error::from)
1100 } else {
1101 let local_var_entity: Option<GetCompressedTokenBalancesByOwnerV2PostError> =
1102 serde_json::from_str(&local_var_content).ok();
1103 let local_var_error = ResponseContent {
1104 status: local_var_status,
1105 content: local_var_content,
1106 entity: local_var_entity,
1107 };
1108 Err(Error::ResponseError(local_var_error))
1109 }
1110}
1111
1112pub async fn get_compression_signatures_for_account_post(
1113 configuration: &configuration::Configuration,
1114 get_compression_signatures_for_account_post_request: models::GetCompressionSignaturesForAccountPostRequest,
1115) -> Result<
1116 models::GetCompressionSignaturesForAccountPost200Response,
1117 Error<GetCompressionSignaturesForAccountPostError>,
1118> {
1119 let local_var_configuration = configuration;
1120
1121 let local_var_client = &local_var_configuration.client;
1122
1123 let local_var_uri_str = format!(
1124 "{}/getCompressionSignaturesForAccount",
1125 local_var_configuration.base_path
1126 );
1127 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1128 let mut local_var_req_builder =
1129 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1130
1131 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1132 local_var_req_builder =
1133 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1134 }
1135 local_var_req_builder =
1136 local_var_req_builder.json(&get_compression_signatures_for_account_post_request);
1137
1138 let local_var_req = local_var_req_builder.build()?;
1139 let local_var_resp = local_var_client.execute(local_var_req).await?;
1140
1141 let local_var_status = local_var_resp.status();
1142 let local_var_content = local_var_resp.text().await?;
1143
1144 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1145 serde_json::from_str(&local_var_content).map_err(Error::from)
1146 } else {
1147 let local_var_entity: Option<GetCompressionSignaturesForAccountPostError> =
1148 serde_json::from_str(&local_var_content).ok();
1149 let local_var_error = ResponseContent {
1150 status: local_var_status,
1151 content: local_var_content,
1152 entity: local_var_entity,
1153 };
1154 Err(Error::ResponseError(local_var_error))
1155 }
1156}
1157
1158pub async fn get_compression_signatures_for_address_post(
1159 configuration: &configuration::Configuration,
1160 get_compression_signatures_for_address_post_request: models::GetCompressionSignaturesForAddressPostRequest,
1161) -> Result<
1162 models::GetCompressionSignaturesForAddressPost200Response,
1163 Error<GetCompressionSignaturesForAddressPostError>,
1164> {
1165 let local_var_configuration = configuration;
1166
1167 let local_var_client = &local_var_configuration.client;
1168
1169 let local_var_uri_str = format!(
1170 "{}/getCompressionSignaturesForAddress",
1171 local_var_configuration.base_path
1172 );
1173 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1174 let mut local_var_req_builder =
1175 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1176
1177 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1178 local_var_req_builder =
1179 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1180 }
1181 local_var_req_builder =
1182 local_var_req_builder.json(&get_compression_signatures_for_address_post_request);
1183
1184 let local_var_req = local_var_req_builder.build()?;
1185 let local_var_resp = local_var_client.execute(local_var_req).await?;
1186
1187 let local_var_status = local_var_resp.status();
1188 let local_var_content = local_var_resp.text().await?;
1189
1190 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1191 serde_json::from_str(&local_var_content).map_err(Error::from)
1192 } else {
1193 let local_var_entity: Option<GetCompressionSignaturesForAddressPostError> =
1194 serde_json::from_str(&local_var_content).ok();
1195 let local_var_error = ResponseContent {
1196 status: local_var_status,
1197 content: local_var_content,
1198 entity: local_var_entity,
1199 };
1200 Err(Error::ResponseError(local_var_error))
1201 }
1202}
1203
1204pub async fn get_compression_signatures_for_owner_post(
1205 configuration: &configuration::Configuration,
1206 get_compression_signatures_for_owner_post_request: models::GetCompressionSignaturesForOwnerPostRequest,
1207) -> Result<
1208 models::GetCompressionSignaturesForAddressPost200Response,
1209 Error<GetCompressionSignaturesForOwnerPostError>,
1210> {
1211 let local_var_configuration = configuration;
1212
1213 let local_var_client = &local_var_configuration.client;
1214
1215 let local_var_uri_str = format!(
1216 "{}/getCompressionSignaturesForOwner",
1217 local_var_configuration.base_path
1218 );
1219 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1220 let mut local_var_req_builder =
1221 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1222
1223 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1224 local_var_req_builder =
1225 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1226 }
1227 local_var_req_builder =
1228 local_var_req_builder.json(&get_compression_signatures_for_owner_post_request);
1229
1230 let local_var_req = local_var_req_builder.build()?;
1231 let local_var_resp = local_var_client.execute(local_var_req).await?;
1232
1233 let local_var_status = local_var_resp.status();
1234 let local_var_content = local_var_resp.text().await?;
1235
1236 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1237 serde_json::from_str(&local_var_content).map_err(Error::from)
1238 } else {
1239 let local_var_entity: Option<GetCompressionSignaturesForOwnerPostError> =
1240 serde_json::from_str(&local_var_content).ok();
1241 let local_var_error = ResponseContent {
1242 status: local_var_status,
1243 content: local_var_content,
1244 entity: local_var_entity,
1245 };
1246 Err(Error::ResponseError(local_var_error))
1247 }
1248}
1249
1250pub async fn get_compression_signatures_for_token_owner_post(
1251 configuration: &configuration::Configuration,
1252 get_compression_signatures_for_token_owner_post_request: models::GetCompressionSignaturesForTokenOwnerPostRequest,
1253) -> Result<
1254 models::GetCompressionSignaturesForAddressPost200Response,
1255 Error<GetCompressionSignaturesForTokenOwnerPostError>,
1256> {
1257 let local_var_configuration = configuration;
1258
1259 let local_var_client = &local_var_configuration.client;
1260
1261 let local_var_uri_str = format!(
1262 "{}/getCompressionSignaturesForTokenOwner",
1263 local_var_configuration.base_path
1264 );
1265 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1266 let mut local_var_req_builder =
1267 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1268
1269 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1270 local_var_req_builder =
1271 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1272 }
1273 local_var_req_builder =
1274 local_var_req_builder.json(&get_compression_signatures_for_token_owner_post_request);
1275
1276 let local_var_req = local_var_req_builder.build()?;
1277 let local_var_resp = local_var_client.execute(local_var_req).await?;
1278
1279 let local_var_status = local_var_resp.status();
1280 let local_var_content = local_var_resp.text().await?;
1281
1282 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1283 serde_json::from_str(&local_var_content).map_err(Error::from)
1284 } else {
1285 let local_var_entity: Option<GetCompressionSignaturesForTokenOwnerPostError> =
1286 serde_json::from_str(&local_var_content).ok();
1287 let local_var_error = ResponseContent {
1288 status: local_var_status,
1289 content: local_var_content,
1290 entity: local_var_entity,
1291 };
1292 Err(Error::ResponseError(local_var_error))
1293 }
1294}
1295
1296pub async fn get_indexer_health_post(
1297 configuration: &configuration::Configuration,
1298 get_indexer_health_post_request: models::GetIndexerHealthPostRequest,
1299) -> Result<models::GetIndexerHealthPost200Response, Error<GetIndexerHealthPostError>> {
1300 let local_var_configuration = configuration;
1301
1302 let local_var_client = &local_var_configuration.client;
1303
1304 let local_var_uri_str = format!("{}/getIndexerHealth", local_var_configuration.base_path);
1305 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1306 let mut local_var_req_builder =
1307 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1308
1309 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1310 local_var_req_builder =
1311 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1312 }
1313 local_var_req_builder = local_var_req_builder.json(&get_indexer_health_post_request);
1314
1315 let local_var_req = local_var_req_builder.build()?;
1316 let local_var_resp = local_var_client.execute(local_var_req).await?;
1317
1318 let local_var_status = local_var_resp.status();
1319 let local_var_content = local_var_resp.text().await?;
1320
1321 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1322 serde_json::from_str(&local_var_content).map_err(Error::from)
1323 } else {
1324 let local_var_entity: Option<GetIndexerHealthPostError> =
1325 serde_json::from_str(&local_var_content).ok();
1326 let local_var_error = ResponseContent {
1327 status: local_var_status,
1328 content: local_var_content,
1329 entity: local_var_entity,
1330 };
1331 Err(Error::ResponseError(local_var_error))
1332 }
1333}
1334
1335pub async fn get_indexer_slot_post(
1336 configuration: &configuration::Configuration,
1337 get_indexer_slot_post_request: models::GetIndexerSlotPostRequest,
1338) -> Result<models::GetIndexerSlotPost200Response, Error<GetIndexerSlotPostError>> {
1339 let local_var_configuration = configuration;
1340
1341 let local_var_client = &local_var_configuration.client;
1342
1343 let local_var_uri_str = format!("{}/getIndexerSlot", local_var_configuration.base_path);
1344 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1345 let mut local_var_req_builder =
1346 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1347
1348 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1349 local_var_req_builder =
1350 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1351 }
1352 local_var_req_builder = local_var_req_builder.json(&get_indexer_slot_post_request);
1353
1354 let local_var_req = local_var_req_builder.build()?;
1355 let local_var_resp = local_var_client.execute(local_var_req).await?;
1356
1357 let local_var_status = local_var_resp.status();
1358 let local_var_content = local_var_resp.text().await?;
1359
1360 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1361 serde_json::from_str(&local_var_content).map_err(Error::from)
1362 } else {
1363 let local_var_entity: Option<GetIndexerSlotPostError> =
1364 serde_json::from_str(&local_var_content).ok();
1365 let local_var_error = ResponseContent {
1366 status: local_var_status,
1367 content: local_var_content,
1368 entity: local_var_entity,
1369 };
1370 Err(Error::ResponseError(local_var_error))
1371 }
1372}
1373
1374pub async fn get_latest_compression_signatures_post(
1375 configuration: &configuration::Configuration,
1376 get_latest_compression_signatures_post_request: models::GetLatestCompressionSignaturesPostRequest,
1377) -> Result<
1378 models::GetCompressionSignaturesForAddressPost200Response,
1379 Error<GetLatestCompressionSignaturesPostError>,
1380> {
1381 let local_var_configuration = configuration;
1382
1383 let local_var_client = &local_var_configuration.client;
1384
1385 let local_var_uri_str = format!(
1386 "{}/getLatestCompressionSignatures",
1387 local_var_configuration.base_path
1388 );
1389 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1390 let mut local_var_req_builder =
1391 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1392
1393 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1394 local_var_req_builder =
1395 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1396 }
1397 local_var_req_builder =
1398 local_var_req_builder.json(&get_latest_compression_signatures_post_request);
1399
1400 let local_var_req = local_var_req_builder.build()?;
1401 let local_var_resp = local_var_client.execute(local_var_req).await?;
1402
1403 let local_var_status = local_var_resp.status();
1404 let local_var_content = local_var_resp.text().await?;
1405
1406 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1407 serde_json::from_str(&local_var_content).map_err(Error::from)
1408 } else {
1409 let local_var_entity: Option<GetLatestCompressionSignaturesPostError> =
1410 serde_json::from_str(&local_var_content).ok();
1411 let local_var_error = ResponseContent {
1412 status: local_var_status,
1413 content: local_var_content,
1414 entity: local_var_entity,
1415 };
1416 Err(Error::ResponseError(local_var_error))
1417 }
1418}
1419
1420pub async fn get_latest_non_voting_signatures_post(
1421 configuration: &configuration::Configuration,
1422 get_latest_non_voting_signatures_post_request: models::GetLatestNonVotingSignaturesPostRequest,
1423) -> Result<
1424 models::GetLatestNonVotingSignaturesPost200Response,
1425 Error<GetLatestNonVotingSignaturesPostError>,
1426> {
1427 let local_var_configuration = configuration;
1428
1429 let local_var_client = &local_var_configuration.client;
1430
1431 let local_var_uri_str = format!(
1432 "{}/getLatestNonVotingSignatures",
1433 local_var_configuration.base_path
1434 );
1435 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1436 let mut local_var_req_builder =
1437 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1438
1439 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1440 local_var_req_builder =
1441 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1442 }
1443 local_var_req_builder =
1444 local_var_req_builder.json(&get_latest_non_voting_signatures_post_request);
1445
1446 let local_var_req = local_var_req_builder.build()?;
1447 let local_var_resp = local_var_client.execute(local_var_req).await?;
1448
1449 let local_var_status = local_var_resp.status();
1450 let local_var_content = local_var_resp.text().await?;
1451
1452 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1453 serde_json::from_str(&local_var_content).map_err(Error::from)
1454 } else {
1455 let local_var_entity: Option<GetLatestNonVotingSignaturesPostError> =
1456 serde_json::from_str(&local_var_content).ok();
1457 let local_var_error = ResponseContent {
1458 status: local_var_status,
1459 content: local_var_content,
1460 entity: local_var_entity,
1461 };
1462 Err(Error::ResponseError(local_var_error))
1463 }
1464}
1465
1466pub async fn get_multiple_compressed_account_proofs_post(
1467 configuration: &configuration::Configuration,
1468 get_multiple_compressed_account_proofs_post_request: models::GetMultipleCompressedAccountProofsPostRequest,
1469) -> Result<
1470 models::GetMultipleCompressedAccountProofsPost200Response,
1471 Error<GetMultipleCompressedAccountProofsPostError>,
1472> {
1473 let local_var_configuration = configuration;
1474
1475 let local_var_client = &local_var_configuration.client;
1476
1477 let local_var_uri_str = format!(
1478 "{}/getMultipleCompressedAccountProofs",
1479 local_var_configuration.base_path
1480 );
1481 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1482
1483 let mut local_var_req_builder =
1484 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1485
1486 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1487 local_var_req_builder =
1488 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1489 }
1490 local_var_req_builder =
1491 local_var_req_builder.json(&get_multiple_compressed_account_proofs_post_request);
1492
1493 let local_var_req = local_var_req_builder.build()?;
1494 let local_var_resp = local_var_client.execute(local_var_req).await?;
1495
1496 let local_var_status = local_var_resp.status();
1497 let local_var_content = local_var_resp.text().await?;
1498
1499 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1500 serde_json::from_str(&local_var_content).map_err(Error::from)
1501 } else {
1502 let local_var_entity: Option<GetMultipleCompressedAccountProofsPostError> =
1503 serde_json::from_str(&local_var_content).ok();
1504 let local_var_error = ResponseContent {
1505 status: local_var_status,
1506 content: local_var_content,
1507 entity: local_var_entity,
1508 };
1509 Err(Error::ResponseError(local_var_error))
1510 }
1511}
1512
1513pub async fn get_multiple_compressed_account_proofs_v2_post(
1514 configuration: &configuration::Configuration,
1515 get_multiple_compressed_account_proofs_v2_post_request: models::GetMultipleCompressedAccountProofsV2PostRequest,
1516) -> Result<
1517 models::GetMultipleCompressedAccountProofsV2Post200Response,
1518 Error<GetMultipleCompressedAccountProofsV2PostError>,
1519> {
1520 let local_var_configuration = configuration;
1521
1522 let local_var_client = &local_var_configuration.client;
1523
1524 let local_var_uri_str = format!(
1525 "{}/getMultipleCompressedAccountProofsV2",
1526 local_var_configuration.base_path
1527 );
1528 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1529 let mut local_var_req_builder =
1530 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1531
1532 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1533 local_var_req_builder =
1534 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1535 }
1536 local_var_req_builder =
1537 local_var_req_builder.json(&get_multiple_compressed_account_proofs_v2_post_request);
1538
1539 let local_var_req = local_var_req_builder.build()?;
1540 let local_var_resp = local_var_client.execute(local_var_req).await?;
1541
1542 let local_var_status = local_var_resp.status();
1543 let local_var_content = local_var_resp.text().await?;
1544
1545 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1546 serde_json::from_str(&local_var_content).map_err(Error::from)
1547 } else {
1548 let local_var_entity: Option<GetMultipleCompressedAccountProofsV2PostError> =
1549 serde_json::from_str(&local_var_content).ok();
1550 let local_var_error = ResponseContent {
1551 status: local_var_status,
1552 content: local_var_content,
1553 entity: local_var_entity,
1554 };
1555 Err(Error::ResponseError(local_var_error))
1556 }
1557}
1558
1559pub async fn get_multiple_compressed_accounts_post(
1560 configuration: &configuration::Configuration,
1561 get_multiple_compressed_accounts_post_request: models::GetMultipleCompressedAccountsPostRequest,
1562) -> Result<
1563 models::GetMultipleCompressedAccountsPost200Response,
1564 Error<GetMultipleCompressedAccountsPostError>,
1565> {
1566 let local_var_configuration = configuration;
1567
1568 let local_var_client = &local_var_configuration.client;
1569
1570 let local_var_uri_str = format!(
1571 "{}/getMultipleCompressedAccounts",
1572 local_var_configuration.base_path
1573 );
1574 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1575 let mut local_var_req_builder =
1576 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1577
1578 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1579 local_var_req_builder =
1580 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1581 }
1582 local_var_req_builder =
1583 local_var_req_builder.json(&get_multiple_compressed_accounts_post_request);
1584
1585 let local_var_req = local_var_req_builder.build()?;
1586 let local_var_resp = local_var_client.execute(local_var_req).await?;
1587
1588 let local_var_status = local_var_resp.status();
1589 let local_var_content = local_var_resp.text().await?;
1590
1591 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1592 serde_json::from_str(&local_var_content).map_err(Error::from)
1593 } else {
1594 let local_var_entity: Option<GetMultipleCompressedAccountsPostError> =
1595 serde_json::from_str(&local_var_content).ok();
1596 let local_var_error = ResponseContent {
1597 status: local_var_status,
1598 content: local_var_content,
1599 entity: local_var_entity,
1600 };
1601 Err(Error::ResponseError(local_var_error))
1602 }
1603}
1604
1605pub async fn get_multiple_compressed_accounts_v2_post(
1606 configuration: &configuration::Configuration,
1607 get_multiple_compressed_accounts_v2_post_request: models::GetMultipleCompressedAccountsV2PostRequest,
1608) -> Result<
1609 models::GetMultipleCompressedAccountsV2Post200Response,
1610 Error<GetMultipleCompressedAccountsV2PostError>,
1611> {
1612 let local_var_configuration = configuration;
1613
1614 let local_var_client = &local_var_configuration.client;
1615
1616 let local_var_uri_str = format!(
1617 "{}/getMultipleCompressedAccountsV2",
1618 local_var_configuration.base_path
1619 );
1620 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1621 let mut local_var_req_builder =
1622 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1623
1624 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1625 local_var_req_builder =
1626 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1627 }
1628 local_var_req_builder =
1629 local_var_req_builder.json(&get_multiple_compressed_accounts_v2_post_request);
1630
1631 let local_var_req = local_var_req_builder.build()?;
1632 let local_var_resp = local_var_client.execute(local_var_req).await?;
1633
1634 let local_var_status = local_var_resp.status();
1635 let local_var_content = local_var_resp.text().await?;
1636
1637 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1638 serde_json::from_str(&local_var_content).map_err(Error::from)
1639 } else {
1640 let local_var_entity: Option<GetMultipleCompressedAccountsV2PostError> =
1641 serde_json::from_str(&local_var_content).ok();
1642 let local_var_error = ResponseContent {
1643 status: local_var_status,
1644 content: local_var_content,
1645 entity: local_var_entity,
1646 };
1647 Err(Error::ResponseError(local_var_error))
1648 }
1649}
1650
1651pub async fn get_multiple_new_address_proofs_post(
1652 configuration: &configuration::Configuration,
1653 get_multiple_new_address_proofs_post_request: models::GetMultipleNewAddressProofsPostRequest,
1654) -> Result<
1655 models::GetMultipleNewAddressProofsPost200Response,
1656 Error<GetMultipleNewAddressProofsPostError>,
1657> {
1658 let local_var_configuration = configuration;
1659
1660 let local_var_client = &local_var_configuration.client;
1661
1662 let local_var_uri_str = format!(
1663 "{}/getMultipleNewAddressProofs",
1664 local_var_configuration.base_path
1665 );
1666 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1667 let mut local_var_req_builder =
1668 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1669
1670 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1671 local_var_req_builder =
1672 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1673 }
1674 local_var_req_builder =
1675 local_var_req_builder.json(&get_multiple_new_address_proofs_post_request);
1676
1677 let local_var_req = local_var_req_builder.build()?;
1678 let local_var_resp = local_var_client.execute(local_var_req).await?;
1679
1680 let local_var_status = local_var_resp.status();
1681 let local_var_content = local_var_resp.text().await?;
1682
1683 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1684 serde_json::from_str(&local_var_content).map_err(Error::from)
1685 } else {
1686 let local_var_entity: Option<GetMultipleNewAddressProofsPostError> =
1687 serde_json::from_str(&local_var_content).ok();
1688 let local_var_error = ResponseContent {
1689 status: local_var_status,
1690 content: local_var_content,
1691 entity: local_var_entity,
1692 };
1693 Err(Error::ResponseError(local_var_error))
1694 }
1695}
1696
1697pub async fn get_multiple_new_address_proofs_v2_post(
1698 configuration: &configuration::Configuration,
1699 get_multiple_new_address_proofs_v2_post_request: models::GetMultipleNewAddressProofsV2PostRequest,
1700) -> Result<
1701 models::GetMultipleNewAddressProofsPost200Response,
1702 Error<GetMultipleNewAddressProofsV2PostError>,
1703> {
1704 let local_var_configuration = configuration;
1705
1706 let local_var_client = &local_var_configuration.client;
1707
1708 let local_var_uri_str = format!(
1709 "{}/getMultipleNewAddressProofsV2",
1710 local_var_configuration.base_path
1711 );
1712 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1713 let mut local_var_req_builder =
1714 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1715
1716 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1717 local_var_req_builder =
1718 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1719 }
1720 local_var_req_builder =
1721 local_var_req_builder.json(&get_multiple_new_address_proofs_v2_post_request);
1722
1723 let local_var_req = local_var_req_builder.build()?;
1724 let local_var_resp = local_var_client.execute(local_var_req).await?;
1725
1726 let local_var_status = local_var_resp.status();
1727 let local_var_content = local_var_resp.text().await?;
1728
1729 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1730 serde_json::from_str(&local_var_content).map_err(Error::from)
1731 } else {
1732 let local_var_entity: Option<GetMultipleNewAddressProofsV2PostError> =
1733 serde_json::from_str(&local_var_content).ok();
1734 let local_var_error = ResponseContent {
1735 status: local_var_status,
1736 content: local_var_content,
1737 entity: local_var_entity,
1738 };
1739 Err(Error::ResponseError(local_var_error))
1740 }
1741}
1742
1743pub async fn get_queue_elements_post(
1744 configuration: &configuration::Configuration,
1745 get_queue_elements_post_request: models::GetQueueElementsPostRequest,
1746) -> Result<models::GetQueueElementsPost200Response, Error<GetQueueElementsPostError>> {
1747 let local_var_configuration = configuration;
1748
1749 let local_var_client = &local_var_configuration.client;
1750
1751 let local_var_uri_str = format!("{}/getQueueElements", local_var_configuration.base_path);
1752 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1753 let mut local_var_req_builder =
1754 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1755
1756 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1757 local_var_req_builder =
1758 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1759 }
1760 local_var_req_builder = local_var_req_builder.json(&get_queue_elements_post_request);
1761
1762 let local_var_req = local_var_req_builder.build()?;
1763 let local_var_resp = local_var_client.execute(local_var_req).await?;
1764
1765 let local_var_status = local_var_resp.status();
1766 let local_var_content = local_var_resp.text().await?;
1767
1768 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1769 serde_json::from_str(&local_var_content).map_err(Error::from)
1770 } else {
1771 let local_var_entity: Option<GetQueueElementsPostError> =
1772 serde_json::from_str(&local_var_content).ok();
1773 let local_var_error = ResponseContent {
1774 status: local_var_status,
1775 content: local_var_content,
1776 entity: local_var_entity,
1777 };
1778 Err(Error::ResponseError(local_var_error))
1779 }
1780}
1781
1782pub async fn get_transaction_with_compression_info_post(
1783 configuration: &configuration::Configuration,
1784 get_transaction_with_compression_info_post_request: models::GetTransactionWithCompressionInfoPostRequest,
1785) -> Result<
1786 models::GetTransactionWithCompressionInfoPost200Response,
1787 Error<GetTransactionWithCompressionInfoPostError>,
1788> {
1789 let local_var_configuration = configuration;
1790
1791 let local_var_client = &local_var_configuration.client;
1792
1793 let local_var_uri_str = format!(
1794 "{}/getTransactionWithCompressionInfo",
1795 local_var_configuration.base_path
1796 );
1797 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1798 let mut local_var_req_builder =
1799 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1800
1801 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1802 local_var_req_builder =
1803 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1804 }
1805 local_var_req_builder =
1806 local_var_req_builder.json(&get_transaction_with_compression_info_post_request);
1807
1808 let local_var_req = local_var_req_builder.build()?;
1809 let local_var_resp = local_var_client.execute(local_var_req).await?;
1810
1811 let local_var_status = local_var_resp.status();
1812 let local_var_content = local_var_resp.text().await?;
1813
1814 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1815 serde_json::from_str(&local_var_content).map_err(Error::from)
1816 } else {
1817 let local_var_entity: Option<GetTransactionWithCompressionInfoPostError> =
1818 serde_json::from_str(&local_var_content).ok();
1819 let local_var_error = ResponseContent {
1820 status: local_var_status,
1821 content: local_var_content,
1822 entity: local_var_entity,
1823 };
1824 Err(Error::ResponseError(local_var_error))
1825 }
1826}
1827
1828pub async fn get_transaction_with_compression_info_v2_post(
1829 configuration: &configuration::Configuration,
1830 get_transaction_with_compression_info_v2_post_request: models::GetTransactionWithCompressionInfoV2PostRequest,
1831) -> Result<
1832 models::GetTransactionWithCompressionInfoV2Post200Response,
1833 Error<GetTransactionWithCompressionInfoV2PostError>,
1834> {
1835 let local_var_configuration = configuration;
1836
1837 let local_var_client = &local_var_configuration.client;
1838
1839 let local_var_uri_str = format!(
1840 "{}/getTransactionWithCompressionInfoV2",
1841 local_var_configuration.base_path
1842 );
1843 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1844 let mut local_var_req_builder =
1845 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1846
1847 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1848 local_var_req_builder =
1849 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1850 }
1851 local_var_req_builder =
1852 local_var_req_builder.json(&get_transaction_with_compression_info_v2_post_request);
1853
1854 let local_var_req = local_var_req_builder.build()?;
1855 let local_var_resp = local_var_client.execute(local_var_req).await?;
1856
1857 let local_var_status = local_var_resp.status();
1858 let local_var_content = local_var_resp.text().await?;
1859
1860 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1861 serde_json::from_str(&local_var_content).map_err(Error::from)
1862 } else {
1863 let local_var_entity: Option<GetTransactionWithCompressionInfoV2PostError> =
1864 serde_json::from_str(&local_var_content).ok();
1865 let local_var_error = ResponseContent {
1866 status: local_var_status,
1867 content: local_var_content,
1868 entity: local_var_entity,
1869 };
1870 Err(Error::ResponseError(local_var_error))
1871 }
1872}
1873
1874pub async fn get_validity_proof_post(
1875 configuration: &configuration::Configuration,
1876 get_validity_proof_post_request: models::GetValidityProofPostRequest,
1877) -> Result<models::GetValidityProofPost200Response, Error<GetValidityProofPostError>> {
1878 let local_var_configuration = configuration;
1879
1880 let local_var_client = &local_var_configuration.client;
1881
1882 let local_var_uri_str = format!("{}/getValidityProof", local_var_configuration.base_path);
1883 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1884 let mut local_var_req_builder =
1885 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1886
1887 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1888 local_var_req_builder =
1889 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1890 }
1891 local_var_req_builder = local_var_req_builder.json(&get_validity_proof_post_request);
1892
1893 let local_var_req = local_var_req_builder.build()?;
1894 let local_var_resp = local_var_client.execute(local_var_req).await?;
1895
1896 let local_var_status = local_var_resp.status();
1897 let local_var_content = local_var_resp.text().await?;
1898
1899 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1900 serde_json::from_str(&local_var_content).map_err(Error::from)
1901 } else {
1902 let local_var_entity: Option<GetValidityProofPostError> =
1903 serde_json::from_str(&local_var_content).ok();
1904 let local_var_error = ResponseContent {
1905 status: local_var_status,
1906 content: local_var_content,
1907 entity: local_var_entity,
1908 };
1909 Err(Error::ResponseError(local_var_error))
1910 }
1911}
1912
1913pub async fn get_validity_proof_v2_post(
1914 configuration: &configuration::Configuration,
1915 get_validity_proof_v2_post_request: models::GetValidityProofV2PostRequest,
1916) -> Result<models::GetValidityProofV2Post200Response, Error<GetValidityProofV2PostError>> {
1917 let local_var_configuration = configuration;
1918
1919 let local_var_client = &local_var_configuration.client;
1920
1921 let local_var_uri_str = format!("{}/getValidityProofV2", local_var_configuration.base_path);
1922 let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1923 let mut local_var_req_builder =
1924 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1925
1926 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1927 local_var_req_builder =
1928 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1929 }
1930 local_var_req_builder = local_var_req_builder.json(&get_validity_proof_v2_post_request);
1931
1932 let local_var_req = local_var_req_builder.build()?;
1933 let local_var_resp = local_var_client.execute(local_var_req).await?;
1934
1935 let local_var_status = local_var_resp.status();
1936 let local_var_content = local_var_resp.text().await?;
1937
1938 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1939 serde_json::from_str(&local_var_content).map_err(Error::from)
1940 } else {
1941 let local_var_entity: Option<GetValidityProofV2PostError> =
1942 serde_json::from_str(&local_var_content).ok();
1943 let local_var_error = ResponseContent {
1944 status: local_var_status,
1945 content: local_var_content,
1946 entity: local_var_entity,
1947 };
1948 Err(Error::ResponseError(local_var_error))
1949 }
1950}
1951
1952fn append_api_key(configuration: &Configuration, uri_str: &str) -> String {
1953 let mut uri_str = uri_str.to_string();
1954 if let Some(ref api_key) = configuration.api_key {
1955 let prefix = api_key.prefix.clone().unwrap_or("api-key".to_string());
1956 uri_str = format!("{}?{}={}", uri_str, prefix, api_key.key);
1957 }
1958 uri_str
1959}