Remove deprecated flags

Author: vorot93

accounts/ethstore/cli/src/main.rs

@@ -166,8 +166,6 @@ fn main() {
 
 fn key_dir(location: &str, password: Option<Password>) -> Result<Box<dyn KeyDirectory>, Error> {
     let dir: RootDiskDirectory = match location {
-        "geth" => RootDiskDirectory::create(dir::geth(false))?,
-        "geth-test" => RootDiskDirectory::create(dir::geth(true))?,
         path if path.starts_with("parity") => {
             let chain = path.split('-').nth(1).unwrap_or("ethereum");
             let path = dir::parity(chain);

accounts/ethstore/src/ethstore.rs

@@ -27,7 +27,6 @@ use accounts_dir::{KeyDirectory, SetKeyError, VaultKey, VaultKeyDirectory};
 use ethkey::{
     self, Address, ExtendedKeyPair, KeyPair, Message, Password, Public, Secret, Signature,
 };
-use import;
 use json::{self, OpaqueKeyFile, Uuid};
 use presale::PresaleWallet;
 use random::Random;
@@ -330,38 +329,6 @@ impl SecretStore for EthStore {
     fn local_path(&self) -> PathBuf {
         self.store.dir.path().cloned().unwrap_or_else(PathBuf::new)
     }
-
-    fn list_geth_accounts(&self, testnet: bool) -> Vec<Address> {
-        import::read_geth_accounts(testnet)
-    }
-
-    fn import_geth_accounts(
-        &self,
-        vault: SecretVaultRef,
-        desired: Vec<Address>,
-        testnet: bool,
-    ) -> Result<Vec<StoreAccountRef>, Error> {
-        let imported_addresses = match vault {
-            SecretVaultRef::Root => import::import_geth_accounts(
-                &*self.store.dir,
-                desired.into_iter().collect(),
-                testnet,
-            ),
-            SecretVaultRef::Vault(vault_name) => {
-                if let Some(vault) = self.store.vaults.lock().get(&vault_name) {
-                    import::import_geth_accounts(
-                        vault.as_key_directory(),
-                        desired.into_iter().collect(),
-                        testnet,
-                    )
-                } else {
-                    Err(Error::VaultNotFound)
-                }
-            }
-        };
-
-        imported_addresses.map(|a| a.into_iter().map(|a| StoreAccountRef::root(a)).collect())
-    }
 }
 
 /// Similar to `EthStore` but may store many accounts (with different passwords) for the same `Address`

accounts/ethstore/src/import.rs

@@ -16,8 +16,7 @@
 
 use std::{collections::HashSet, fs, path::Path};
 
-use accounts_dir::{DiskKeyFileManager, KeyDirectory, KeyFileManager, RootDiskDirectory};
-use dir;
+use accounts_dir::{DiskKeyFileManager, KeyDirectory, KeyFileManager};
 use ethkey::Address;
 use Error;
 
@@ -66,37 +65,3 @@ pub fn import_accounts(
         })
         .collect()
 }
-
-/// Provide a `HashSet` of all accounts available for import from the Geth keystore.
-pub fn read_geth_accounts(testnet: bool) -> Vec<Address> {
-    RootDiskDirectory::at(dir::geth(testnet))
-        .load()
-        .map(|d| d.into_iter().map(|a| a.address).collect())
-        .unwrap_or_else(|_| Vec::new())
-}
-
-/// Import specific `desired` accounts from the Geth keystore into `dst`.
-pub fn import_geth_accounts(
-    dst: &dyn KeyDirectory,
-    desired: HashSet<Address>,
-    testnet: bool,
-) -> Result<Vec<Address>, Error> {
-    let src = RootDiskDirectory::at(dir::geth(testnet));
-    let accounts = src.load()?;
-    let existing_accounts = dst
-        .load()?
-        .into_iter()
-        .map(|a| a.address)
-        .collect::<HashSet<_>>();
-
-    accounts
-        .into_iter()
-        .filter(|a| !existing_accounts.contains(&a.address))
-        .filter(|a| desired.contains(&a.address))
-        .map(|a| {
-            let address = a.address.clone();
-            dst.insert(a)?;
-            Ok(address)
-        })
-        .collect()
-}

accounts/ethstore/src/lib.rs

@@ -64,7 +64,7 @@ pub use self::{
     account::{Crypto, SafeAccount},
     error::Error,
     ethstore::{EthMultiStore, EthStore},
-    import::{import_account, import_accounts, read_geth_accounts},
+    import::{import_account, import_accounts},
     json::OpaqueKeyFile as KeyFile,
     parity_wordlist::random_phrase,
     presale::PresaleWallet,

accounts/ethstore/src/secret_store.rs

@@ -221,15 +221,6 @@ pub trait SecretStore: SimpleSecretStore {
 
     /// Returns local path of the store.
     fn local_path(&self) -> PathBuf;
-    /// Lists all found geth accounts.
-    fn list_geth_accounts(&self, testnet: bool) -> Vec<Address>;
-    /// Imports geth accounts to the store/vault.
-    fn import_geth_accounts(
-        &self,
-        vault: SecretVaultRef,
-        desired: Vec<Address>,
-        testnet: bool,
-    ) -> Result<Vec<StoreAccountRef>, Error>;
 }
 
 impl StoreAccountRef {

accounts/src/lib.rs

@@ -572,27 +572,6 @@ impl AccountProvider {
         Ok(self.sstore.agree(&account, &password, other_public)?)
     }
 
-    /// Returns the underlying `SecretStore` reference if one exists.
-    pub fn list_geth_accounts(&self, testnet: bool) -> Vec<Address> {
-        self.sstore
-            .list_geth_accounts(testnet)
-            .into_iter()
-            .map(|a| Address::from(a).into())
-            .collect()
-    }
-
-    /// Returns the underlying `SecretStore` reference if one exists.
-    pub fn import_geth_accounts(
-        &self,
-        desired: Vec<Address>,
-        testnet: bool,
-    ) -> Result<Vec<Address>, Error> {
-        self.sstore
-            .import_geth_accounts(SecretVaultRef::Root, desired, testnet)
-            .map(|a| a.into_iter().map(|a| a.address).collect())
-            .map_err(Into::into)
-    }
-
     /// Create new vault.
     pub fn create_vault(&self, name: &str, password: &Password) -> Result<(), Error> {
         self.sstore.create_vault(name, password).map_err(Into::into)

parity/account.rs

@@ -22,7 +22,6 @@ pub enum AccountCmd {
     New(NewAccount),
     List(ListAccounts),
     Import(ImportAccounts),
-    ImportFromGeth(ImportFromGethAccounts),
 }
 
 #[derive(Debug, PartialEq)]
@@ -46,16 +45,6 @@ pub struct ImportAccounts {
     pub spec: SpecType,
 }
 
-/// Parameters for geth accounts' import
-#[derive(Debug, PartialEq)]
-pub struct ImportFromGethAccounts {
-    /// import mainnet (false) or testnet (true) accounts
-    pub testnet: bool,
-    /// directory to import accounts to
-    pub to: String,
-    pub spec: SpecType,
-}
-
 #[cfg(not(feature = "accounts"))]
 pub fn execute(_cmd: AccountCmd) -> Result<String, String> {
     Err("Account management is deprecated. Please see #9997 for alternatives:\nhttps://github.com/paritytech/parity-ethereum/issues/9997".into())
@@ -65,10 +54,7 @@ pub fn execute(_cmd: AccountCmd) -> Result<String, String> {
 mod command {
     use super::*;
     use accounts::{AccountProvider, AccountProviderSettings};
-    use ethstore::{
-        accounts_dir::RootDiskDirectory, import_account, import_accounts, read_geth_accounts,
-        EthStore, SecretStore, SecretVaultRef,
-    };
+    use ethstore::{accounts_dir::RootDiskDirectory, import_account, import_accounts, EthStore};
     use helpers::{password_from_file, password_prompt};
     use std::path::PathBuf;
 
@@ -77,7 +63,6 @@ mod command {
             AccountCmd::New(new_cmd) => new(new_cmd),
             AccountCmd::List(list_cmd) => list(list_cmd),
             AccountCmd::Import(import_cmd) => import(import_cmd),
-            AccountCmd::ImportFromGeth(import_geth_cmd) => import_geth(import_geth_cmd),
         }
     }
 
@@ -148,25 +133,6 @@ mod command {
 
         Ok(format!("{} account(s) imported", imported))
     }
-
-    fn import_geth(i: ImportFromGethAccounts) -> Result<String, String> {
-        use ethstore::Error;
-        use std::io::ErrorKind;
-
-        let dir = Box::new(keys_dir(i.to, i.spec)?);
-        let secret_store = Box::new(secret_store(dir, None)?);
-        let geth_accounts = read_geth_accounts(i.testnet);
-        match secret_store.import_geth_accounts(SecretVaultRef::Root, geth_accounts, i.testnet) {
-            Ok(v) => Ok(format!(
-                "Successfully imported {} account(s) from geth.",
-                v.len()
-            )),
-            Err(Error::Io(ref io_err)) if io_err.kind() == ErrorKind::NotFound => {
-                Err("Failed to find geth keys folder.".into())
-            }
-            Err(err) => Err(format!("Import geth accounts failed. {}", err)),
-        }
-    }
 }
 
 #[cfg(feature = "accounts")]