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

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

#[cfg(feature = "storage")]
mod storage_stub {

    use async_trait::async_trait;

    use crate::{
        client::{
            secret::{mnemonic::MnemonicSecretManager, SecretManagerConfig},
            storage::StorageAdapter,
        },
        wallet::{
            core::builder::dto::WalletBuilderDto,
            storage::constants::{SECRET_MANAGER_KEY, WALLET_INDEXATION_KEY},
            WalletBuilder,
        },
    };

    #[async_trait]
    pub trait SaveLoadWallet {
        async fn save(&self, storage: &impl StorageAdapter<Error = crate::wallet::Error>) -> crate::wallet::Result<()>;

        async fn load(
            storage: &impl StorageAdapter<Error = crate::wallet::Error>,
        ) -> crate::wallet::Result<Option<Self>>
        where
            Self: Sized;
    }

    #[async_trait]
    impl<S: 'static + SecretManagerConfig> SaveLoadWallet for WalletBuilder<S>
    where
        crate::wallet::Error: From<S::Error>,
    {
        async fn save(&self, storage: &impl StorageAdapter<Error = crate::wallet::Error>) -> crate::wallet::Result<()> {
            log::debug!("save_wallet_data");
            storage.set(WALLET_INDEXATION_KEY, self).await?;

            if let Some(secret_manager) = &self.secret_manager {
                let secret_manager = secret_manager.read().await;
                if let Some(config) = secret_manager.to_config() {
                    log::debug!("save_secret_manager: {config:?}");
                    storage.set(SECRET_MANAGER_KEY, &config).await?;
                }
            }
            Ok(())
        }

        async fn load(
            storage: &impl StorageAdapter<Error = crate::wallet::Error>,
        ) -> crate::wallet::Result<Option<Self>> {
            log::debug!("get_wallet_data");
            if let Some(data) = storage.get::<WalletBuilderDto>(WALLET_INDEXATION_KEY).await? {
                log::debug!("get_wallet_data {data:?}");

                let secret_manager_dto = storage.get(SECRET_MANAGER_KEY).await?;
                log::debug!("get_secret_manager {secret_manager_dto:?}");

                Ok(Some(Self::from(data).with_secret_manager(
                    secret_manager_dto.map(|dto| S::from_config(&dto)).transpose()?,
                )))
            } else {
                Ok(None)
            }
        }
    }

    #[async_trait]
    impl SaveLoadWallet for WalletBuilder<MnemonicSecretManager> {
        async fn save(&self, storage: &impl StorageAdapter<Error = crate::wallet::Error>) -> crate::wallet::Result<()> {
            log::debug!("save_wallet_data");
            storage.set(WALLET_INDEXATION_KEY, self).await?;
            Ok(())
        }

        async fn load(
            storage: &impl StorageAdapter<Error = crate::wallet::Error>,
        ) -> crate::wallet::Result<Option<Self>> {
            log::debug!("get_wallet_data");
            let res = storage.get::<WalletBuilderDto>(WALLET_INDEXATION_KEY).await?;
            log::debug!("get_wallet_data {res:?}");
            Ok(res.map(Into::into))
        }
    }
}
#[cfg(not(feature = "storage"))]
mod storage_stub {
    pub trait SaveLoadWallet {}
    impl<T> SaveLoadWallet for T {}
}
pub(crate) use storage_stub::*;