iota-sdk 0.3.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

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

//! The `StorageProvider` implementation for `StrongholdAdapter`.

use std::ops::Deref;

use async_trait::async_trait;
use crypto::ciphers::chacha;

use super::{common::PRIVATE_DATA_CLIENT_PATH, StrongholdAdapter};
use crate::client::{storage::StorageProvider, stronghold::Error};

#[async_trait]
impl StorageProvider for StrongholdAdapter {
    type Error = Error;

    #[allow(clippy::significant_drop_tightening)]
    async fn get(&mut self, k: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
        let data = match self
            .stronghold
            .lock()
            .await
            .get_client(PRIVATE_DATA_CLIENT_PATH)?
            .store()
            .get(k)?
        {
            Some(data) => data,
            None => return Ok(None),
        };

        let locked_key_provider = self.key_provider.lock().await;
        let key_provider = if let Some(key_provider) = &*locked_key_provider {
            key_provider
        } else {
            return Err(Error::KeyCleared);
        };
        let buffer = key_provider.try_unlock()?;
        let buffer_ref = buffer.borrow();

        Ok(Some(chacha::aead_decrypt(buffer_ref.deref(), &data)?))
    }

    async fn insert(&mut self, k: &[u8], v: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
        let encrypted_value = {
            let locked_key_provider = self.key_provider.lock().await;
            let key_provider = if let Some(key_provider) = &*locked_key_provider {
                key_provider
            } else {
                return Err(Error::KeyCleared);
            };
            let buffer = key_provider.try_unlock()?;
            let buffer_ref = buffer.borrow();

            chacha::aead_encrypt(buffer_ref.deref(), v)?
        };

        Ok(self
            .stronghold
            .lock()
            .await
            .get_client(PRIVATE_DATA_CLIENT_PATH)?
            .store()
            .insert(k.to_vec(), encrypted_value, None)?)
    }

    async fn delete(&mut self, k: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
        Ok(self
            .stronghold
            .lock()
            .await
            .get_client(PRIVATE_DATA_CLIENT_PATH)?
            .store()
            .delete(k)?)
    }
}

mod tests {
    #[tokio::test]
    async fn test_stronghold_db() {
        use std::fs;

        use super::StrongholdAdapter;
        use crate::client::storage::StorageProvider;

        let snapshot_path = "test_stronghold_db.stronghold";
        let mut stronghold = StrongholdAdapter::builder()
            .password("drowssap")
            .build(snapshot_path)
            .unwrap();

        assert!(matches!(stronghold.get(b"test-0").await, Ok(None)));
        assert!(matches!(stronghold.get(b"test-1").await, Ok(None)));
        assert!(matches!(stronghold.get(b"test-2").await, Ok(None)));

        assert!(matches!(stronghold.insert(b"test-0", b"test-0").await, Ok(None)));
        assert!(matches!(stronghold.insert(b"test-1", b"test-1").await, Ok(None)));
        assert!(matches!(stronghold.insert(b"test-2", b"test-2").await, Ok(None)));

        assert!(matches!(stronghold.get(b"test-0").await, Ok(Some(_))));
        assert!(matches!(stronghold.get(b"test-1").await, Ok(Some(_))));
        assert!(matches!(stronghold.get(b"test-2").await, Ok(Some(_))));

        assert!(matches!(stronghold.insert(b"test-0", b"0-tset").await, Ok(Some(_))));
        assert!(matches!(stronghold.insert(b"test-1", b"1-tset").await, Ok(Some(_))));
        assert!(matches!(stronghold.insert(b"test-2", b"2-tset").await, Ok(Some(_))));

        assert!(matches!(stronghold.delete(b"test-0").await, Ok(Some(_))));
        assert!(matches!(stronghold.delete(b"test-1").await, Ok(Some(_))));
        assert!(matches!(stronghold.delete(b"test-2").await, Ok(Some(_))));

        assert!(matches!(stronghold.get(b"test-0").await, Ok(None)));
        assert!(matches!(stronghold.get(b"test-1").await, Ok(None)));
        assert!(matches!(stronghold.get(b"test-2").await, Ok(None)));

        fs::remove_file(snapshot_path).unwrap();
    }
}