iota-sdk 0.2.0

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

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

use std::collections::HashMap;

use crate::{
    client::{node_manager::node::Node, Client},
    types::api::plugins::participation::types::{
        ParticipationEventId, ParticipationEventStatus, ParticipationEventType,
    },
    wallet::account::{
        operations::participation::ParticipationEventWithNodes,
        types::participation::ParticipationEventRegistrationOptions, AccountHandle,
    },
};

impl AccountHandle {
    /// Stores participation information for the given events locally and returns them all.
    ///
    /// This will NOT store the node url and auth inside the client options.
    pub async fn register_participation_events(
        &self,
        options: &ParticipationEventRegistrationOptions,
    ) -> crate::wallet::Result<HashMap<ParticipationEventId, ParticipationEventWithNodes>> {
        let client = Client::builder()
            .with_ignore_node_health()
            .with_node_auth(options.node.url.as_str(), options.node.auth.clone())?
            .finish()?;

        let events_to_register = match &options.events_to_register {
            Some(events_to_register_) => {
                if events_to_register_.is_empty() {
                    self.get_participation_event_ids(&options.node, Some(ParticipationEventType::Voting))
                        .await?
                } else {
                    events_to_register_.clone()
                }
            }
            None => {
                self.get_participation_event_ids(&options.node, Some(ParticipationEventType::Voting))
                    .await?
            }
        };

        let mut registered_participation_events = HashMap::new();
        for event_id in events_to_register {
            if let Some(events_to_ignore) = &options.events_to_ignore {
                if events_to_ignore.contains(&event_id) {
                    continue;
                }
            }

            let event_data = client.event(&event_id).await?;
            let event_with_node = ParticipationEventWithNodes {
                id: event_id,
                data: event_data,
                nodes: vec![options.node.clone()],
            };
            let account_index = self.read().await.index;
            self.storage_manager
                .lock()
                .await
                .insert_participation_event(account_index, event_with_node.clone())
                .await?;
            registered_participation_events.insert(event_id, event_with_node.clone());
        }

        Ok(registered_participation_events)
    }

    /// Removes a previously registered participation event from local storage.
    pub async fn deregister_participation_event(&self, id: &ParticipationEventId) -> crate::wallet::Result<()> {
        let account_index = self.read().await.index;
        self.storage_manager
            .lock()
            .await
            .remove_participation_event(account_index, id)
            .await?;
        Ok(())
    }

    /// Retrieves corresponding information for a participation event from local storage.
    pub async fn get_participation_event(
        &self,
        id: ParticipationEventId,
    ) -> crate::wallet::Result<Option<ParticipationEventWithNodes>> {
        let account_index = self.read().await.index;
        Ok(self
            .storage_manager
            .lock()
            .await
            .get_participation_events(account_index)
            .await?
            .get(&id)
            .cloned())
    }

    /// Retrieves information for all registered participation events.
    pub async fn get_participation_events(
        &self,
    ) -> crate::wallet::Result<HashMap<ParticipationEventId, ParticipationEventWithNodes>> {
        let account_index = self.read().await.index;
        self.storage_manager
            .lock()
            .await
            .get_participation_events(account_index)
            .await
    }

    /// Retrieves IDs of all events tracked by the client options node.
    pub async fn get_participation_event_ids(
        &self,
        node: &Node,
        event_type: Option<ParticipationEventType>,
    ) -> crate::wallet::Result<Vec<ParticipationEventId>> {
        let client = Client::builder()
            .with_ignore_node_health()
            .with_node_auth(node.url.as_str(), node.auth.clone())?
            .finish()?;
        Ok(client.events(event_type).await?.event_ids)
    }

    /// Retrieves the latest status of a given participation event.
    pub async fn get_participation_event_status(
        &self,
        id: &ParticipationEventId,
    ) -> crate::wallet::Result<ParticipationEventStatus> {
        Ok(self.get_client_for_event(id).await?.event_status(id, None).await?)
    }
}