iota-sdk 1.0.1

The IOTA SDK provides developers with a seamless experience to develop on IOTA by providing account abstractions and clients to interact with node APIs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

// Copyright 2022 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

//! IOTA node core API

pub mod routes;

#[cfg(not(target_family = "wasm"))]
use crate::client::constants::MAX_PARALLEL_API_REQUESTS;
use crate::{
    client::{Client, Result},
    types::block::output::{OutputId, OutputMetadata, OutputWithMetadata},
};

impl Client {
    /// Request outputs by their output ID in parallel
    pub async fn get_outputs(&self, output_ids: &[OutputId]) -> Result<Vec<OutputWithMetadata>> {
        #[cfg(target_family = "wasm")]
        let outputs = futures::future::try_join_all(output_ids.iter().map(|id| self.get_output(id))).await?;

        #[cfg(not(target_family = "wasm"))]
        let outputs =
            futures::future::try_join_all(output_ids.chunks(MAX_PARALLEL_API_REQUESTS).map(|output_ids_chunk| {
                let client = self.clone();
                let output_ids_chunk = output_ids_chunk.to_vec();
                async move {
                    tokio::spawn(async move {
                        futures::future::try_join_all(output_ids_chunk.iter().map(|id| client.get_output(id))).await
                    })
                    .await?
                }
            }))
            .await?
            .into_iter()
            .flatten()
            .collect();

        Ok(outputs)
    }

    /// Request outputs by their output ID in parallel, ignoring failed requests
    /// Useful to get data about spent outputs, that might not be pruned yet
    pub async fn get_outputs_ignore_errors(&self, output_ids: &[OutputId]) -> Result<Vec<OutputWithMetadata>> {
        #[cfg(target_family = "wasm")]
        let outputs = futures::future::join_all(output_ids.iter().map(|id| self.get_output(id)))
            .await
            .into_iter()
            .filter_map(Result::ok)
            .collect();

        #[cfg(not(target_family = "wasm"))]
        let outputs =
            futures::future::try_join_all(output_ids.chunks(MAX_PARALLEL_API_REQUESTS).map(|output_ids_chunk| {
                let client = self.clone();
                let output_ids_chunk = output_ids_chunk.to_vec();
                tokio::spawn(async move {
                    futures::future::join_all(output_ids_chunk.iter().map(|id| client.get_output(id)))
                        .await
                        .into_iter()
                        .filter_map(Result::ok)
                        .collect::<Vec<_>>()
                })
            }))
            .await?
            .into_iter()
            .flatten()
            .collect();

        Ok(outputs)
    }

    /// Requests metadata for outputs by their output ID in parallel, ignoring failed requests
    pub async fn get_outputs_metadata_ignore_errors(&self, output_ids: &[OutputId]) -> Result<Vec<OutputMetadata>> {
        #[cfg(target_family = "wasm")]
        let metadata = futures::future::join_all(output_ids.iter().map(|id| self.get_output_metadata(id)))
            .await
            .into_iter()
            .filter_map(Result::ok)
            .collect();

        #[cfg(not(target_family = "wasm"))]
        let metadata =
            futures::future::try_join_all(output_ids.chunks(MAX_PARALLEL_API_REQUESTS).map(|output_ids_chunk| {
                let client = self.clone();
                let output_ids_chunk = output_ids_chunk.to_vec();
                tokio::spawn(async move {
                    futures::future::join_all(output_ids_chunk.iter().map(|id| client.get_output_metadata(id)))
                        .await
                        .into_iter()
                        .filter_map(Result::ok)
                        .collect::<Vec<_>>()
                })
            }))
            .await?
            .into_iter()
            .flatten()
            .collect();

        Ok(metadata)
    }
}