refactor: keychain module (#10)

* refactor: keychain module

* fix: run rustfmt

* refactor: better organize errors modules

src/account/keychain/account.rs → src/keychain/account/account.rs

@@ -18,7 +18,7 @@ impl Account {
     let extended_address = encode(&keccak256(&extended_public_key.to_bytes()));
     let address = extended_address[extended_address.len() - 40..].to_string();
 
-    assert_is_valid_hex_address(&address).or(Err(AccountError::InvalidPublicKey))?;
+    assert_is_valid_hex_address(&address)?;
 
     Ok(Account {
       address: add0x(&address).to_owned(),

src/keychain/account/errors.rs

@@ -0,0 +1,28 @@
+use crate::hex::HexError;
+
+#[derive(Debug)]
+pub enum AccountError {
+  InvalidHexAddress,
+  InvalidKeyLength,
+}
+
+impl std::fmt::Display for AccountError {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::InvalidHexAddress => write!(f, "Invalid hex address"),
+      Self::InvalidKeyLength => write!(f, "Invalid key length"),
+    }
+  }
+}
+
+impl From<HexError> for AccountError {
+  fn from(error: HexError) -> Self {
+    match error {
+      HexError::InvalidHex => Self::InvalidHexAddress,
+      HexError::InvalidHexLength => Self::InvalidHexAddress,
+      HexError::InvalidHexAddress => Self::InvalidHexAddress,
+    }
+  }
+}
+
+impl std::error::Error for AccountError {}

src/keychain/account/mod.rs

@@ -0,0 +1,5 @@
+pub mod account;
+pub mod errors;
+
+pub use account::Account;
+pub use errors::AccountError;

src/account/keychain/errors.rs → src/keychain/errors.rs

@@ -11,8 +11,3 @@ impl From<VaultError> for KeychainError {
     Self::VaultError(error)
   }
 }
-
-#[derive(Debug)]
-pub enum AccountError {
-  InvalidPublicKey,
-}

src/account/keychain/keychain.rs → src/keychain/keychain.rs

@@ -1,4 +1,7 @@
-use crate::{Account, Controller, KeychainError, Observable, Signer, Vault};
+use crate::{
+  keychain::{Account, KeychainError, Signer, Vault},
+  utils::{Controller, Observable},
+};
 
 #[derive(Clone, Debug)]
 pub struct KeychainState {

src/account/keychain/mod.rs → src/keychain/mod.rs

@@ -1,7 +1,11 @@
 pub mod account;
 pub mod errors;
 pub mod keychain;
+pub mod signer;
+pub mod vault;
 
 pub use account::*;
 pub use errors::*;
 pub use keychain::*;
+pub use signer::*;
+pub use vault::*;

src/keychain/signer/errors.rs

@@ -0,0 +1,14 @@
+#[derive(Debug)]
+pub enum SignerError {
+  InvalidPrivateKey,
+}
+
+impl std::fmt::Display for SignerError {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::InvalidPrivateKey => write!(f, "Invalid private key"),
+    }
+  }
+}
+
+impl std::error::Error for SignerError {}

src/keychain/vault/errors.rs

@@ -0,0 +1,46 @@
+use std::{error::Error, fmt::Display};
+
+use crate::{AccountError, SignerError};
+
+#[derive(Debug)]
+pub enum VaultError {
+  ForbiddenWhileLocked,
+  AccountCreation,
+  InvalidPassword,
+  InvalidMnemonic,
+  SignerCreation,
+  KeyDerivation,
+  AlreadyUnlocked,
+  SafeCreation,
+  SafeDecrypt,
+}
+
+impl Display for VaultError {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Self::ForbiddenWhileLocked => write!(f, "Forbidden while locked"),
+      Self::AccountCreation => write!(f, "Account creation error"),
+      Self::InvalidPassword => write!(f, "Invalid password"),
+      Self::InvalidMnemonic => write!(f, "Invalid mnemonic"),
+      Self::SignerCreation => write!(f, "Signer creation error"),
+      Self::KeyDerivation => write!(f, "Key derivation error"),
+      Self::AlreadyUnlocked => write!(f, "Already unlocked"),
+      Self::SafeCreation => write!(f, "Safe creation error"),
+      Self::SafeDecrypt => write!(f, "Safe decryption error"),
+    }
+  }
+}
+
+impl From<AccountError> for VaultError {
+  fn from(_: AccountError) -> Self {
+    Self::AccountCreation
+  }
+}
+
+impl From<SignerError> for VaultError {
+  fn from(_: SignerError) -> Self {
+    Self::SignerCreation
+  }
+}
+
+impl Error for VaultError {}

src/lib.rs

@@ -1,5 +1,5 @@
-pub mod account;
+pub mod keychain;
 pub mod utils;
 
-pub use account::*;
+pub use keychain::*;
 pub use utils::*;