Merge branch 'master' into lightrpc

rpc/src/v1/impls/parity_accounts.rs

@@ -201,6 +201,53 @@ impl ParityAccounts for ParityAccountsClient {
 
 		Ok(into_vec(store.list_geth_accounts(false)))
 	}
+
+	fn create_vault(&self, name: String, password: String) -> Result<bool, Error> {
+		take_weak!(self.accounts)
+			.create_vault(&name, &password)
+			.map_err(|e| errors::account("Could not create vault.", e))
+			.map(|_| true)
+	}
+
+	fn open_vault(&self, name: String, password: String) -> Result<bool, Error> {
+		take_weak!(self.accounts)
+			.open_vault(&name, &password)
+			.map_err(|e| errors::account("Could not open vault.", e))
+			.map(|_| true)
+	}
+
+	fn close_vault(&self, name: String) -> Result<bool, Error> {
+		take_weak!(self.accounts)
+			.close_vault(&name)
+			.map_err(|e| errors::account("Could not close vault.", e))
+			.map(|_| true)
+	}
+
+	fn list_vaults(&self) -> Result<Vec<String>, Error> {
+		take_weak!(self.accounts)
+			.list_vaults()
+			.map_err(|e| errors::account("Could not list vaults.", e))
+	}
+
+	fn list_opened_vaults(&self) -> Result<Vec<String>, Error> {
+		take_weak!(self.accounts)
+			.list_opened_vaults()
+			.map_err(|e| errors::account("Could not list vaults.", e))
+	}
+
+	fn change_vault_password(&self, name: String, new_password: String) -> Result<bool, Error> {
+		take_weak!(self.accounts)
+			.change_vault_password(&name, &new_password)
+			.map_err(|e| errors::account("Could not change vault password.", e))
+			.map(|_| true)
+	}
+
+	fn change_vault(&self, address: RpcH160, new_vault: String) -> Result<bool, Error> {
+		take_weak!(self.accounts)
+			.change_vault(address.into(), &new_vault)
+			.map_err(|e| errors::account("Could not change vault.", e))
+			.map(|_| true)
+	}
 }
 
 fn into_vec<A, B>(a: Vec<A>) -> Vec<B> where

rpc/src/v1/tests/mocked/parity_accounts.rs

@@ -17,6 +17,9 @@
 use std::sync::Arc;
 
 use ethcore::account_provider::AccountProvider;
+use ethstore::EthStore;
+use ethstore::dir::RootDiskDirectory;
+use devtools::RandomTempPath;
 
 use jsonrpc_core::IoHandler;
 use v1::{ParityAccounts, ParityAccountsClient};
@@ -30,21 +33,33 @@ fn accounts_provider() -> Arc<AccountProvider> {
 	Arc::new(AccountProvider::transient_provider())
 }
 
-fn setup() -> ParityAccountsTester {
-	let accounts = accounts_provider();
-	let parity_accounts = ParityAccountsClient::new(&accounts);
+fn accounts_provider_with_vaults_support(temp_path: &str) -> Arc<AccountProvider> {
+	let root_keys_dir = RootDiskDirectory::create(temp_path).unwrap();
+	let secret_store = EthStore::open(Box::new(root_keys_dir)).unwrap();
+	Arc::new(AccountProvider::new(Box::new(secret_store)))
+}
 
+fn setup_with_accounts_provider(accounts_provider: Arc<AccountProvider>) -> ParityAccountsTester {
+	let parity_accounts = ParityAccountsClient::new(&accounts_provider);
 	let mut io = IoHandler::default();
 	io.extend_with(parity_accounts.to_delegate());
 
 	let tester = ParityAccountsTester {
-		accounts: accounts,
+		accounts: accounts_provider,
 		io: io,
 	};
 
 	tester
 }
 
+fn setup() -> ParityAccountsTester {
+	setup_with_accounts_provider(accounts_provider())
+}
+
+fn setup_with_vaults_support(temp_path: &str) -> ParityAccountsTester {
+	setup_with_accounts_provider(accounts_provider_with_vaults_support(temp_path))
+}
+
 #[test]
 fn should_be_able_to_get_account_info() {
 	let tester = setup();
@@ -217,3 +232,122 @@ fn should_be_able_to_remove_address() {
 	let response = r#"{"jsonrpc":"2.0","result":{},"id":4}"#;
 	assert_eq!(res, Some(response.into()));
 }
+
+#[test]
+fn rpc_parity_new_vault() {
+	let temp_path = RandomTempPath::new();
+	let tester = setup_with_vaults_support(temp_path.as_str());
+
+	let request = r#"{"jsonrpc": "2.0", "method": "parity_newVault", "params":["vault1", "password1"], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":true,"id":1}"#;
+
+	assert_eq!(tester.io.handle_request_sync(request), Some(response.to_owned()));
+	assert!(tester.accounts.close_vault("vault1").is_ok());
+	assert!(tester.accounts.open_vault("vault1", "password1").is_ok());
+}
+
+#[test]
+fn rpc_parity_open_vault() {
+	let temp_path = RandomTempPath::new();
+	let tester = setup_with_vaults_support(temp_path.as_str());
+
+	assert!(tester.accounts.create_vault("vault1", "password1").is_ok());
+	assert!(tester.accounts.close_vault("vault1").is_ok());
+
+	let request = r#"{"jsonrpc": "2.0", "method": "parity_openVault", "params":["vault1", "password1"], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":true,"id":1}"#;
+
+	assert_eq!(tester.io.handle_request_sync(request), Some(response.to_owned()));
+}
+
+#[test]
+fn rpc_parity_close_vault() {
+	let temp_path = RandomTempPath::new();
+	let tester = setup_with_vaults_support(temp_path.as_str());
+
+	assert!(tester.accounts.create_vault("vault1", "password1").is_ok());
+
+	let request = r#"{"jsonrpc": "2.0", "method": "parity_closeVault", "params":["vault1"], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":true,"id":1}"#;
+
+	assert_eq!(tester.io.handle_request_sync(request), Some(response.to_owned()));
+}
+
+#[test]
+fn rpc_parity_change_vault_password() {
+	let temp_path = RandomTempPath::new();
+	let tester = setup_with_vaults_support(temp_path.as_str());
+
+	assert!(tester.accounts.create_vault("vault1", "password1").is_ok());
+
+	let request = r#"{"jsonrpc": "2.0", "method": "parity_changeVaultPassword", "params":["vault1", "password2"], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":true,"id":1}"#;
+
+	assert_eq!(tester.io.handle_request_sync(request), Some(response.to_owned()));
+}
+
+#[test]
+fn rpc_parity_change_vault() {
+	let temp_path = RandomTempPath::new();
+	let tester = setup_with_vaults_support(temp_path.as_str());
+
+	let (address, _) = tester.accounts.new_account_and_public("root_password").unwrap();
+	assert!(tester.accounts.create_vault("vault1", "password1").is_ok());
+
+	let request = format!(r#"{{"jsonrpc": "2.0", "method": "parity_changeVault", "params":["0x{}", "vault1"], "id": 1}}"#, address.hex());
+	let response = r#"{"jsonrpc":"2.0","result":true,"id":1}"#;
+
+	assert_eq!(tester.io.handle_request_sync(&request), Some(response.to_owned()));
+}
+
+#[test]
+fn rpc_parity_vault_adds_vault_field_to_acount_meta() {
+	let temp_path = RandomTempPath::new();
+	let tester = setup_with_vaults_support(temp_path.as_str());
+
+	let (address1, _) = tester.accounts.new_account_and_public("root_password1").unwrap();
+	let uuid1 = tester.accounts.account_meta(address1.clone()).unwrap().uuid.unwrap();
+	assert!(tester.accounts.create_vault("vault1", "password1").is_ok());
+	assert!(tester.accounts.change_vault(address1, "vault1").is_ok());
+
+	let request = r#"{"jsonrpc": "2.0", "method": "parity_allAccountsInfo", "params":[], "id": 1}"#;
+	let response = format!(r#"{{"jsonrpc":"2.0","result":{{"0x{}":{{"meta":"{{\"vault\":\"vault1\"}}","name":"","uuid":"{}"}}}},"id":1}}"#, address1.hex(), uuid1);
+
+	assert_eq!(tester.io.handle_request_sync(request), Some(response.to_owned()));
+}
+
+#[test]
+fn rpc_parity_list_vaults() {
+	let temp_path = RandomTempPath::new();
+	let tester = setup_with_vaults_support(temp_path.as_str());
+
+	assert!(tester.accounts.create_vault("vault1", "password1").is_ok());
+	assert!(tester.accounts.create_vault("vault2", "password2").is_ok());
+
+	let request = r#"{"jsonrpc": "2.0", "method": "parity_listVaults", "params":[], "id": 1}"#;
+	let response1 = r#"{"jsonrpc":"2.0","result":["vault1","vault2"],"id":1}"#;
+	let response2 = r#"{"jsonrpc":"2.0","result":["vault2","vault1"],"id":1}"#;
+
+	let actual_response = tester.io.handle_request_sync(request);
+	assert!(actual_response == Some(response1.to_owned())
+		|| actual_response == Some(response2.to_owned()));
+}
+
+#[test]
+fn rpc_parity_list_opened_vaults() {
+	let temp_path = RandomTempPath::new();
+	let tester = setup_with_vaults_support(temp_path.as_str());
+
+	assert!(tester.accounts.create_vault("vault1", "password1").is_ok());
+	assert!(tester.accounts.create_vault("vault2", "password2").is_ok());
+	assert!(tester.accounts.create_vault("vault3", "password3").is_ok());
+	assert!(tester.accounts.close_vault("vault2").is_ok());
+
+	let request = r#"{"jsonrpc": "2.0", "method": "parity_listOpenedVaults", "params":[], "id": 1}"#;
+	let response1 = r#"{"jsonrpc":"2.0","result":["vault1","vault3"],"id":1}"#;
+	let response2 = r#"{"jsonrpc":"2.0","result":["vault3","vault1"],"id":1}"#;
+
+	let actual_response = tester.io.handle_request_sync(request);
+	assert!(actual_response == Some(response1.to_owned())
+		|| actual_response == Some(response2.to_owned()));
+}

rpc/src/v1/traits/parity_accounts.rs

@@ -105,5 +105,33 @@ build_rpc_trait! {
 		/// Returns the accounts available for importing from Geth.
 		#[rpc(name = "parity_listGethAccounts")]
 		fn geth_accounts(&self) -> Result<Vec<H160>, Error>;
+
+		/// Create new vault.
+		#[rpc(name = "parity_newVault")]
+		fn create_vault(&self, String, String) -> Result<bool, Error>;
+
+		/// Open existing vault.
+		#[rpc(name = "parity_openVault")]
+		fn open_vault(&self, String, String) -> Result<bool, Error>;
+
+		/// Close previously opened vault.
+		#[rpc(name = "parity_closeVault")]
+		fn close_vault(&self, String) -> Result<bool, Error>;
+
+		/// List all vaults.
+		#[rpc(name = "parity_listVaults")]
+		fn list_vaults(&self) -> Result<Vec<String>, Error>;
+
+		/// List all currently opened vaults.
+		#[rpc(name = "parity_listOpenedVaults")]
+		fn list_opened_vaults(&self) -> Result<Vec<String>, Error>;
+
+		/// Change vault password.
+		#[rpc(name = "parity_changeVaultPassword")]
+		fn change_vault_password(&self, String, String) -> Result<bool, Error>;
+
+		/// Change vault of the given address.
+		#[rpc(name = "parity_changeVault")]
+		fn change_vault(&self, H160, String) -> Result<bool, Error>;
 	}
 }