2113901785

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/iotaledger/wallet.rs/commit/<a class=hub.com/iotaledger/wallet.rs/commit/<a class="double-link" href="https://git"><a class=hub.com/iotaledger/wallet.rs/commit/<a class="double-link" href="https://git"><a class=hub.com/iotaledger/wallet.rs/commit/45f2cdb90d78856d180860299bb3b0f89c2ca0fa">45f2cdb90<a href="https://github.com/iotaledger/wallet.rs/commit/45f2cdb90d78856d180860299bb3b0f89c2ca0fa">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/iotaledger/wallet.rs/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/iotaledger/wallet.rs/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/iotaledger/wallet.rs/commit/45f2cdb90d78856d180860299bb3b0f89c2ca0fa&quot;&gt;45f2cdb90&lt;/a&gt;&lt;a href=&quot;https://github.com/iotaledger/wallet.rs/commit/45f2cdb90d78856d180860299bb3b0f89c2ca0fa&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/iotaledger/wallet.rs/commit/45f2cdb90d78856d180860299bb3b0f8&lt;/a&gt;9c2ca0fa">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/iotaledger/wallet.rs/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/iotaledger/wallet.rs/commit/<a class="double-link" href="https://github.com/iotaledger/wallet.rs/commit/ef64d93a8b1f61d9c489c0e3d8cf9ea4d7d8db33">ef64d93a8</a><a href="https://github.com/iotaledger/wallet.rs/commit/45f2cdb90d78856d180860299bb3b0f89c2ca0fa">&amp;quot;&amp;gt;ef64d93a8&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;ef64d93a8&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/iotaledger/wallet.rs/commit/45f2cdb90d78856d180860299bb3b0f89c2ca&lt;/a&gt;0fa&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/iotaledger/wallet.rs/commit/<a class="double-link" href="https://github.com/iotaledger/wallet.rs/commit/b7db45051">b7db45051">b7db45051</a>

Pull Request Pull Request #978: Sync foundry outputs

Run Details

25 of 25 new or added lines in 2 files covered. (100.0%)

714 of 3504 relevant lines covered (20.38%)

8579.46 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.39

/src/storage/manager.rs

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

use crate::{
    account::Account,
    account_manager::builder::AccountManagerBuilder,
    storage::{constants::*, decrypt_record, Storage, StorageAdapter},
};

use serde::{Deserialize, Serialize};
use tokio::sync::Mutex;

use std::sync::Arc;

/// The storage used by the manager.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub(crate) enum ManagerStorage {
    #[cfg(feature = "stronghold")]
    /// Stronghold storage.
    Stronghold,
    /// RocksDB storage.
    Rocksdb,
}

pub(crate) type StorageManagerHandle = Arc<Mutex<StorageManager>>;

/// Sets the storage adapter.
pub(crate) async fn new_storage_manager(
    encryption_key: Option<[u8; 32]>,
    storage: Box<dyn StorageAdapter + Send + Sync + 'static>,
) -> crate::Result<StorageManagerHandle> {
    let storage = Storage {
        inner: storage,
        encryption_key,
    };
    let account_indexes = match storage.get(ACCOUNTS_INDEXATION_KEY).await {
        Ok(account_indexes) => serde_json::from_str(&account_indexes)?,
        Err(_) => Vec::new(),
    };
    let storage_manager = StorageManager {
        storage,
        account_indexes,
    };

    Ok(Arc::new(Mutex::new(storage_manager)))
}

#[derive(Debug)]
/// Storage manager
pub struct StorageManager {
    storage: Storage,
    // account indexes for accounts in the database
    account_indexes: Vec<u32>,
}

impl StorageManager {
    pub fn id(&self) -> &'static str {
        self.storage.id()
    }

    #[cfg(test)]
    pub fn is_encrypted(&self) -> bool {
        self.storage.encryption_key.is_some()
    }

    pub async fn get(&self, key: &str) -> crate::Result<String> {
        self.storage.get(key).await
    }

    pub async fn save_account_manager_data(
        &mut self,
        account_manager_builder: &AccountManagerBuilder,
    ) -> crate::Result<()> {
        log::debug!("save_account_manager_data");
        self.storage
            .set(ACCOUNT_MANAGER_INDEXATION_KEY, account_manager_builder)
            .await
    }

    pub async fn get_account_manager_data(&self) -> crate::Result<AccountManagerBuilder> {
        log::debug!("get_account_manager_data");
        let data = self.storage.get(ACCOUNT_MANAGER_INDEXATION_KEY).await?;
        log::debug!("get_account_manager_data {}", data);
        let builder: AccountManagerBuilder = serde_json::from_str(&data)?;
        Ok(builder)
    }

    pub async fn get_accounts(&mut self) -> crate::Result<Vec<Account>> {
        if self.account_indexes.is_empty() {
            if let Ok(record) = self.storage.get(ACCOUNTS_INDEXATION_KEY).await {
                self.account_indexes = serde_json::from_str(&record)?;
            }
        }

        let mut accounts = Vec::new();
        for account_index in self.account_indexes.clone() {
            accounts.push(
                self.get(&format!("{}{}", ACCOUNT_INDEXATION_KEY, account_index))
                    .await?,
            );
        }
        parse_accounts(&accounts, &self.storage.encryption_key)
    }

    pub async fn save_account(&mut self, account: &Account) -> crate::Result<()> {
        self.account_indexes.push(*account.index());
        self.storage
            .set(ACCOUNTS_INDEXATION_KEY, self.account_indexes.clone())
            .await?;
        self.storage
            .set(&format!("{}{}", ACCOUNT_INDEXATION_KEY, account.index()), account)
            .await
    }

    pub async fn remove_account(&mut self, account_index: u32) -> crate::Result<()> {
        self.storage
            .remove(&format!("{}{}", ACCOUNT_INDEXATION_KEY, account_index))
            .await?;
        self.account_indexes.retain(|a| a == &account_index);
        self.storage
            .set(ACCOUNTS_INDEXATION_KEY, self.account_indexes.clone())
            .await
    }

    #[cfg(feature = "ledger-nano")]
    // used for ledger accounts to verify that the same menmonic is used for all accounts
    pub async fn save_first_ledger_address(
        &mut self,
        address: &iota_client::bee_message::address::Address,
    ) -> crate::Result<()> {
        self.storage.set(FIRST_LEDGER_ADDRESS_KEY, address).await?;
        Ok(())
    }

    #[cfg(feature = "ledger-nano")]
    pub async fn get_first_ledger_address(&self) -> crate::Result<iota_client::bee_message::address::Address> {
        let address: iota_client::bee_message::address::Address =
            serde_json::from_str(&self.storage.get(FIRST_LEDGER_ADDRESS_KEY).await?)?;
        Ok(address)
    }
}

// Parse accounts from strings and decrypt them first if necessary
fn parse_accounts(accounts: &[String], encryption_key: &Option<[u8; 32]>) -> crate::Result<Vec<Account>> {
    let mut parsed_accounts: Vec<Account> = Vec::new();
    for account in accounts {
        let account_json = if account.starts_with('{') {
            Some(account.to_string())
        } else if let Some(key) = encryption_key {
            Some(decrypt_record(account, key)?)
        } else {
            None
        };
        if let Some(json) = account_json {
            let acc = serde_json::from_str::<Account>(&json)?;
            parsed_accounts.push(acc);
        } else {
            return Err(crate::Error::StorageIsEncrypted);
        }
    }
    Ok(parsed_accounts)
}

1	// Copyright 2021 IOTA Stiftung
2	// SPDX-License-Identifier: Apache-2.0
3
4	use crate::{
5	account::Account,
6	account_manager::builder::AccountManagerBuilder,
7	storage::{constants::*, decrypt_record, Storage, StorageAdapter},
8	};
9
10	use serde::{Deserialize, Serialize};
11	use tokio::sync::Mutex;
12
13	use std::sync::Arc;
14
15	/// The storage used by the manager.
16	#[derive(Debug, Clone, Serialize, Deserialize)]	10✔
17	pub(crate) enum ManagerStorage {
18	#[cfg(feature = "stronghold")]
19	/// Stronghold storage.
20	Stronghold,
21	/// RocksDB storage.
22	Rocksdb,
23	}
24
25	pub(crate) type StorageManagerHandle = Arc<Mutex<StorageManager>>;
26
27	/// Sets the storage adapter.
28	pub(crate) async fn new_storage_manager(	10✔
29	encryption_key: Option<[u8; 32]>,	10✔
30	storage: Box<dyn StorageAdapter + Send + Sync + 'static>,	10✔
31	) -> crate::Result<StorageManagerHandle> {	10✔
32	let storage = Storage {	10✔
33	inner: storage,	10✔
34	encryption_key,	10✔
35	};	10✔
36	let account_indexes = match storage.get(ACCOUNTS_INDEXATION_KEY).await {	10✔
37	Ok(account_indexes) => serde_json::from_str(&account_indexes)?,	1✔
38	Err(_) => Vec::new(),	9✔
39	};
40	let storage_manager = StorageManager {	10✔
41	storage,	10✔
42	account_indexes,	10✔
43	};	10✔
44		10✔
45	Ok(Arc::new(Mutex::new(storage_manager)))	10✔
46	}	10✔
47
48	#[derive(Debug)]	×
49	/// Storage manager
50	pub struct StorageManager {
51	storage: Storage,
52	// account indexes for accounts in the database
53	account_indexes: Vec<u32>,
54	}
55
56	impl StorageManager {
57	pub fn id(&self) -> &'static str {	×
58	self.storage.id()	×
59	}	×
60
61	#[cfg(test)]
62	pub fn is_encrypted(&self) -> bool {	×
63	self.storage.encryption_key.is_some()	×
64	}	×
65
66	pub async fn get(&self, key: &str) -> crate::Result<String> {	1✔
67	self.storage.get(key).await	1✔
68	}	1✔
69
70	pub async fn save_account_manager_data(	8✔
71	&mut self,	8✔
72	account_manager_builder: &AccountManagerBuilder,	8✔
73	) -> crate::Result<()> {	8✔
74	log::debug!("save_account_manager_data");	×
75	self.storage	8✔
76	.set(ACCOUNT_MANAGER_INDEXATION_KEY, account_manager_builder)	8✔
77	.await	×
78	}	8✔
79
80	pub async fn get_account_manager_data(&self) -> crate::Result<AccountManagerBuilder> {	10✔
81	log::debug!("get_account_manager_data");	×
82	let data = self.storage.get(ACCOUNT_MANAGER_INDEXATION_KEY).await?;	10✔
83	log::debug!("get_account_manager_data {}", data);	×
84	let builder: AccountManagerBuilder = serde_json::from_str(&data)?;	2✔
85	Ok(builder)	2✔
86	}	10✔
87
88	pub async fn get_accounts(&mut self) -> crate::Result<Vec<Account>> {	10✔
89	if self.account_indexes.is_empty() {	10✔
90	if let Ok(record) = self.storage.get(ACCOUNTS_INDEXATION_KEY).await {	9✔
91	self.account_indexes = serde_json::from_str(&record)?;	×
92	}	9✔
93	}	1✔
94
95	let mut accounts = Vec::new();	10✔
96	for account_index in self.account_indexes.clone() {	10✔
97	accounts.push(
98	self.get(&format!("{}{}", ACCOUNT_INDEXATION_KEY, account_index))	1✔
99	.await?,	×
100	);
101	}
102	parse_accounts(&accounts, &self.storage.encryption_key)	10✔
103	}	10✔
104
105	pub async fn save_account(&mut self, account: &Account) -> crate::Result<()> {	108✔
106	self.account_indexes.push(*account.index());	108✔
107	self.storage	108✔
108	.set(ACCOUNTS_INDEXATION_KEY, self.account_indexes.clone())	108✔
109	.await?;	×
110	self.storage	108✔
111	.set(&format!("{}{}", ACCOUNT_INDEXATION_KEY, account.index()), account)	108✔
112	.await	1✔
113	}	108✔
114
115	pub async fn remove_account(&mut self, account_index: u32) -> crate::Result<()> {	×
116	self.storage	×
117	.remove(&format!("{}{}", ACCOUNT_INDEXATION_KEY, account_index))	×
118	.await?;	×
119	self.account_indexes.retain(\|a\| a == &account_index);	×
120	self.storage	×
121	.set(ACCOUNTS_INDEXATION_KEY, self.account_indexes.clone())	×
122	.await	×
123	}	×
124
125	#[cfg(feature = "ledger-nano")]
126	// used for ledger accounts to verify that the same menmonic is used for all accounts
127	pub async fn save_first_ledger_address(	×
128	&mut self,	×
129	address: &iota_client::bee_message::address::Address,	×
130	) -> crate::Result<()> {	×
131	self.storage.set(FIRST_LEDGER_ADDRESS_KEY, address).await?;	×
132	Ok(())	×
133	}	×
134
135	#[cfg(feature = "ledger-nano")]
136	pub async fn get_first_ledger_address(&self) -> crate::Result<iota_client::bee_message::address::Address> {	×
137	let address: iota_client::bee_message::address::Address =	×
138	serde_json::from_str(&self.storage.get(FIRST_LEDGER_ADDRESS_KEY).await?)?;	×
139	Ok(address)	×
140	}	×
141	}
142
143	// Parse accounts from strings and decrypt them first if necessary
144	fn parse_accounts(accounts: &[String], encryption_key: &Option<[u8; 32]>) -> crate::Result<Vec<Account>> {	10✔
145	let mut parsed_accounts: Vec<Account> = Vec::new();	10✔
146	for account in accounts {	11✔
147	let account_json = if account.starts_with('{') {	1✔
148	Some(account.to_string())	1✔
149	} else if let Some(key) = encryption_key {	×
150	Some(decrypt_record(account, key)?)	×
151	} else {
152	None	×
153	};
154	if let Some(json) = account_json {	1✔
155	let acc = serde_json::from_str::<Account>(&json)?;	1✔
156	parsed_accounts.push(acc);	1✔
157	} else {
158	return Err(crate::Error::StorageIsEncrypted);	×
159	}
160	}
161	Ok(parsed_accounts)	10✔
162	}	10✔

iotaledger / wallet.rs / 2113901785

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous