refactoring to AccountService

util/src/keys/store.rs

@@ -80,16 +80,57 @@ struct AccountUnlock {
 
 /// Basic account management trait
 pub trait AccountProvider : Send + Sync {
+	/// Lists all accounts
+	fn accounts(&self) -> Result<Vec<Address>, ::std::io::Error>;
 	/// Unlocks account with the password provided
 	fn unlock_account(&self, account: &Address, pass: &str) -> Result<(), EncryptedHashMapError>;
 	/// Creates account
-	fn new_account(&mut self, pass: &str) -> Result<Address, ::std::io::Error>;
+	fn new_account(&self, pass: &str) -> Result<Address, ::std::io::Error>;
 	/// Returns secret for unlocked account
 	fn account_secret(&self, account: &Address) -> Result<crypto::Secret, SigningError>;
 	/// Returns secret for unlocked account
 	fn sign(&self, account: &Address, message: &H256) -> Result<crypto::Signature, SigningError>;
 }
 
+/// Thread-safe accounts management
+pub struct AccountService {
+	secret_store: RwLock<SecretStore>,
+}
+
+impl AccountProvider for AccountService {
+	/// Lists all accounts
+	fn accounts(&self) -> Result<Vec<Address>, ::std::io::Error> {
+		Ok(try!(self.secret_store.read().unwrap().accounts()).iter().map(|&(addr, _)| addr).collect::<Vec<Address>>())
+	}
+	/// Unlocks account with the password provided
+	fn unlock_account(&self, account: &Address, pass: &str) -> Result<(), EncryptedHashMapError> {
+		self.secret_store.read().unwrap().unlock_account(account, pass)
+	}
+	/// Creates account
+	fn new_account(&self, pass: &str) -> Result<Address, ::std::io::Error> {
+		self.secret_store.write().unwrap().new_account(pass)
+	}
+	/// Returns secret for unlocked account
+	fn account_secret(&self, account: &Address) -> Result<crypto::Secret, SigningError> {
+		self.secret_store.read().unwrap().account_secret(account)
+	}
+	/// Returns secret for unlocked account
+	fn sign(&self, account: &Address, message: &H256) -> Result<crypto::Signature, SigningError> {
+		self.secret_store.read().unwrap().sign(account, message)
+	}
+}
+
+impl AccountService {
+	/// New account service with the default location
+	pub fn new() -> AccountService {
+		let secret_store = RwLock::new(SecretStore::new());
+		secret_store.write().unwrap().try_import_existing();
+		AccountService {
+			secret_store: secret_store
+		}
+	}
+}
+
 impl SecretStore {
 	/// new instance of Secret Store in default home directory
 	pub fn new() -> SecretStore {
@@ -156,11 +197,9 @@ impl SecretStore {
 			unlocks: RwLock::new(HashMap::new()),
 		}
 	}
-}
 
-impl AccountProvider for SecretStore {
 	/// Unlocks account for use
-	fn unlock_account(&self, account: &Address, pass: &str) -> Result<(), EncryptedHashMapError> {
+	pub fn unlock_account(&self, account: &Address, pass: &str) -> Result<(), EncryptedHashMapError> {
 		let secret_id = try!(self.account(&account).ok_or(EncryptedHashMapError::UnknownIdentifier));
 		let secret = try!(self.get(&secret_id, pass));
 		{
@@ -174,7 +213,7 @@ impl AccountProvider for SecretStore {
 	}
 
 	/// Creates new account
-	fn new_account(&mut self, pass: &str) -> Result<Address, ::std::io::Error> {
+	pub fn new_account(&mut self, pass: &str) -> Result<Address, ::std::io::Error> {
 		let secret = H256::random();
 		let key_id = H128::random();
 		self.insert(key_id.clone(), secret, pass);
@@ -187,7 +226,7 @@ impl AccountProvider for SecretStore {
 	}
 
 	/// Signs message with unlocked account
-	fn sign(&self, account: &Address, message: &H256) -> Result<crypto::Signature, SigningError> {
+	pub fn sign(&self, account: &Address, message: &H256) -> Result<crypto::Signature, SigningError> {
 		let read_lock = self.unlocks.read().unwrap();
 		let unlock = try!(read_lock.get(account).ok_or(SigningError::AccountNotUnlocked));
 		match crypto::KeyPair::from_secret(unlock.secret) {
@@ -200,7 +239,7 @@ impl AccountProvider for SecretStore {
 	}
 
 	/// Returns secret for unlocked account
-	fn account_secret(&self, account: &Address) -> Result<crypto::Secret, SigningError> {
+	pub fn account_secret(&self, account: &Address) -> Result<crypto::Secret, SigningError> {
 		let read_lock = self.unlocks.read().unwrap();
 		let unlock = try!(read_lock.get(account).ok_or(SigningError::AccountNotUnlocked));
 		Ok(unlock.secret as crypto::Secret)