Basic Authority (#991)

* Firt commit.

* First non-functional but correct implementation of BasicAuthority.

Still needs:
- Sealing infrastructure.

* Punch a hole to give miner access to key store.

* Fix test built.

* Basic version of synchronous mining.

This will seal a block whenever a new transaction comes through.
To be made better we need a timer which will wait for one second after the
last block before sealing a new one - better still would be to cooperatively
interleave blocks with other sealing nodes.

* Add tests.

* Fix minor issues from repotting.

* Address grumbles.

util/src/common.rs

@@ -24,6 +24,20 @@ pub use vector::*;
 pub use numbers::*;
 pub use sha3::*;
 
+#[macro_export]
+macro_rules! hash_map {
+	( $( $x:expr => $y:expr ),* ) => {
+		vec![ $( ($x, $y) ),* ].into_iter().collect::<HashMap<_, _>>()
+	}
+}
+
+#[macro_export]
+macro_rules! hash_mapx {
+	( $( $x:expr => $y:expr ),* ) => {
+		vec![ $( ( From::from($x), From::from($y) ) ),* ].into_iter().collect::<HashMap<_, _>>()
+	}
+}
+
 #[macro_export]
 macro_rules! map {
 	( $( $x:expr => $y:expr ),* ) => {

util/src/keys/mod.rs

@@ -19,3 +19,6 @@
 pub mod directory;
 pub mod store;
 mod geth_import;
+mod test_account_provider;
+
+pub use self::test_account_provider::{TestAccount, TestAccountProvider};

util/src/keys/store.rs

@@ -31,6 +31,8 @@ const KEY_LENGTH_AES: u32 = KEY_LENGTH/2;
 const KEY_LENGTH_USIZE: usize = KEY_LENGTH as usize;
 const KEY_LENGTH_AES_USIZE: usize = KEY_LENGTH_AES as usize;
 
+// TODO: this file needs repotting into several separate files.
+
 /// Encrypted hash-map, each request should contain password
 pub trait EncryptedHashMap<Key: Hash + Eq> {
 	/// Returns existing value for the key, if any
@@ -87,10 +89,12 @@ pub trait AccountProvider : Send + Sync {
 	fn unlock_account(&self, account: &Address, pass: &str) -> Result<(), EncryptedHashMapError>;
 	/// Creates account
 	fn new_account(&self, pass: &str) -> Result<Address, ::std::io::Error>;
-	/// Returns secret for unlocked account
+	/// 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>;
+	/// Returns signature when unlocked `account` signs `message`.
+	fn sign(&self, account: &Address, message: &H256) -> Result<crypto::Signature, SigningError> {
+		self.account_secret(account).and_then(|s| crypto::ec::sign(&s, message).map_err(|_| SigningError::InvalidSecret))
+	}
 }
 
 /// Thread-safe accounts management

util/src/keys/test_account_provider.rs

@@ -0,0 +1,102 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Test implementation of account provider.
+
+use std::sync::RwLock;
+use std::collections::HashMap;
+use std::io;
+use hash::{Address, FixedHash};
+use crypto::{Secret, KeyPair};
+use super::store::{AccountProvider, SigningError, EncryptedHashMapError};
+
+/// Account mock.
+#[derive(Clone)]
+pub struct TestAccount {
+	/// True if account is unlocked.
+	pub unlocked: bool,
+	/// Account's password.
+	pub password: String,
+	/// Account's secret.
+	pub secret: Secret,
+}
+
+impl TestAccount {
+	/// Creates new test account.
+	pub fn new(password: &str) -> Self {
+		let pair = KeyPair::create().unwrap();
+		TestAccount {
+			unlocked: false,
+			password: password.to_owned(),
+			secret: pair.secret().clone()
+		}
+	}
+
+	/// Returns account address.
+	pub fn address(&self) -> Address {
+		KeyPair::from_secret(self.secret.clone()).unwrap().address()
+	}
+}
+
+/// Test account provider.
+pub struct TestAccountProvider {
+	/// Test provider accounts.
+	pub accounts: RwLock<HashMap<Address, TestAccount>>,
+}
+
+impl TestAccountProvider {
+	/// Basic constructor.
+	pub fn new(accounts: HashMap<Address, TestAccount>) -> Self {
+		TestAccountProvider {
+			accounts: RwLock::new(accounts),
+		}
+	}
+}
+
+impl AccountProvider for TestAccountProvider {
+	fn accounts(&self) -> Result<Vec<Address>, io::Error> {
+		Ok(self.accounts.read().unwrap().keys().cloned().collect())
+	}
+
+	fn unlock_account(&self, account: &Address, pass: &str) -> Result<(), EncryptedHashMapError> {
+		match self.accounts.write().unwrap().get_mut(account) {
+			Some(ref mut acc) if acc.password == pass => {
+				acc.unlocked = true;
+				Ok(())
+			},
+			Some(_) => Err(EncryptedHashMapError::InvalidPassword),
+			None => Err(EncryptedHashMapError::UnknownIdentifier),
+		}
+	}
+
+	fn new_account(&self, pass: &str) -> Result<Address, io::Error> {
+		let account = TestAccount::new(pass);
+		let address = KeyPair::from_secret(account.secret.clone()).unwrap().address();
+		self.accounts.write().unwrap().insert(address.clone(), account);
+		Ok(address)
+	}
+
+	fn account_secret(&self, address: &Address) -> Result<Secret, SigningError> {
+		// todo: consider checking if account is unlock. some test may need alteration then.
+		self.accounts
+			.read()
+			.unwrap()
+			.get(address)
+			.ok_or(SigningError::NoAccount)
+			.map(|acc| acc.secret.clone())
+	}
+}
+