refactor: remove bincode and serde (#14)

crates/identity/Cargo.toml

@@ -19,7 +19,3 @@ path = "../utils"
 
 [dependencies.secp256k1]
 version = "~0.27.0"
-
-[dependencies.serde]
-version = "~1.0.188"
-features = ["derive"]

crates/identity/src/account/account.rs

@@ -1,13 +1,12 @@
 use secp256k1::{PublicKey, Secp256k1, SecretKey};
-use serde::{Deserialize, Serialize};
 
 use super::AccountError;
 use utils::{
   crypto::sha3::keccak256,
   hex::{add0x, assert_is_valid_hex_address, encode},
 };
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct Account<T> {
   pub address: String,
   pub public_key: Vec<u8>,

crates/keychain/Cargo.toml

@@ -28,7 +28,3 @@ path = "../utils"
 [dependencies.vault]
 package = "walleth-vault"
 path = "../vault"
-
-[dependencies.serde]
-version = "~1.0.188"
-features = ["derive"]

crates/keychain/hdkey/Cargo.toml

@@ -20,7 +20,3 @@ features = ["std"]
 
 [dependencies.secp256k1]
 version = "~0.27.0"
-
-[dependencies.serde]
-version = "~1.0.188"
-features = ["derive"]

crates/keychain/hdkey/src/hdkey.rs

@@ -1,6 +1,5 @@
 use bip32::XPrv;
 use secp256k1::{PublicKey, Secp256k1, SecretKey};
-use serde::{Deserialize, Serialize};
 
 use crate::{
   utils::{generate_seed_bytes, get_derivation_path, parse_mnemonic},
@@ -11,7 +10,7 @@ use identity::{
   Account, AccountDeriver, GenericIdentity, IdentityError, Initializable, MultiKeyPair,
 };
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug)]
 pub struct HDKey {
   seed: Vec<u8>,
 }

crates/keychain/src/keychain.rs

@@ -1,7 +1,5 @@
-use hdkey::HDKey;
-use serde::{Deserialize, Serialize};
-
 use super::KeychainError;
+use hdkey::HDKey;
 use identity::{Account, IdentityError, Initializable, MultiKeyPair};
 use utils::{Controller, Observable};
 use vault::{Vault, VaultError};
@@ -14,7 +12,7 @@ where
   MultiKeyPair(Vault<M>),
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug)]
 pub struct KeychainState {
   /// The accounts in the keychain
   /// This is a list of public accounts

crates/utils/Cargo.toml

@@ -19,6 +19,5 @@ version = "~0.4.3"
 [dependencies.sha3]
 version = "~0.10.8"
 
-[dependencies.serde]
-version = "~1.0.188"
-features = ["derive"]
+[dependencies.secp256k1]
+version = "~0.27.0"

crates/vault/Cargo.toml

@@ -17,7 +17,3 @@ package = "walleth-vault-safe"
 
 [dependencies.secp256k1]
 version = "~0.27.0"
-
-[dependencies.serde]
-version = "~1.0.188"
-features = ["derive"]

crates/vault/safe/Cargo.toml

@@ -13,9 +13,6 @@ keywords = [
 	"signing",
 ]
 
-[dependencies.bincode]
-version = "~1.3.3"
-
 [dependencies.chacha20poly1305]
 version = "~0.9.0"
 
@@ -28,9 +25,5 @@ version = "~0.12.2"
 [dependencies.rand_core]
 version = "~0.6.4"
 
-[dependencies.serde]
-version = "~1.0.188"
-features = ["derive"]
-
 [dependencies.sha3]
 version = "~0.10.8"

crates/vault/safe/src/errors.rs

@@ -1,15 +1,15 @@
 use std::fmt::{Display, Formatter, Result};
 
 pub enum SafeError {
-  Serialization,
-  Deserialization,
+  Serialization(String),
+  Deserialization(String),
 }
 
 impl Display for SafeError {
   fn fmt(&self, f: &mut Formatter) -> Result {
     match self {
-      SafeError::Serialization => write!(f, "Unable to serialize safe"),
-      SafeError::Deserialization => write!(f, "Unable to deserialize safe"),
+      SafeError::Serialization(message) => write!(f, "Unable to serialize safe > {}", message),
+      SafeError::Deserialization(message) => write!(f, "Unable to deserialize safe > {}", message),
     }
   }
 }

crates/vault/safe/src/safe.rs

@@ -1,5 +1,3 @@
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
-
 use crate::{ChaCha20Poly1305Cipher, CipherKey, SafeError};
 
 /// A safe is a container for encrypted data.
@@ -10,7 +8,7 @@ use crate::{ChaCha20Poly1305Cipher, CipherKey, SafeError};
 ///
 /// The encrypted bytes are encrypted and can be used
 /// to store sensitive information.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone)]
 pub struct Safe<T> {
   pub metadata: T,
   encrypted_bytes: Box<[u8]>,
@@ -40,31 +38,52 @@ impl<T> Safe<T> {
   }
 }
 
-impl<T> Safe<T>
+impl<T> From<Safe<T>> for Vec<u8>
 where
-  T: Serialize,
+  T: TryFrom<Vec<u8>> + Into<Vec<u8>>,
 {
   /// Serialize `Safe` to bytes
-  pub fn to_bytes(&self) -> Result<Vec<u8>, SafeError> {
-    bincode::serialize(&self).or(Err(SafeError::Serialization))
+  fn from(safe: Safe<T>) -> Vec<u8> {
+    let mut bytes: Vec<u8> = vec![];
+    let metadata_bytes = safe.metadata.into();
+
+    bytes.append(&mut vec![u8::try_from(metadata_bytes.len()).unwrap()]);
+    bytes.append(&mut metadata_bytes.into());
+    bytes.append(&mut safe.encrypted_bytes.into());
+    bytes.append(&mut safe.nonce.to_vec());
+
+    bytes
   }
 }
 
 impl<T> TryFrom<Vec<u8>> for Safe<T>
 where
-  T: DeserializeOwned,
+  T: TryFrom<Vec<u8>> + Into<Vec<u8>>,
 {
   type Error = SafeError;
 
   /// Deserialize `Safe` from bytes
   fn try_from(bytes: Vec<u8>) -> Result<Self, SafeError> {
-    bincode::deserialize(&bytes).or(Err(SafeError::Deserialization))
+    let metadata_len = bytes[0];
+    let metadata = T::try_from(bytes[1..metadata_len as usize + 1].to_vec()).or(Err(
+      SafeError::Deserialization("error deserializing metadata".to_string()),
+    ))?;
+    let encrypted_bytes = bytes[metadata_len as usize + 1..bytes.len() - 24].to_vec();
+    let nonce = bytes[bytes.len() - 24..bytes.len()].to_vec();
+
+    Ok(Safe {
+      metadata,
+      encrypted_bytes: encrypted_bytes.into_boxed_slice(),
+      nonce: nonce.try_into().or(Err(SafeError::Deserialization(
+        "unexpected bytes length".to_string(),
+      )))?,
+    })
   }
 }
 
 impl<T> PartialEq for Safe<T>
 where
-  T: PartialEq,
+  T: PartialEq + TryFrom<Vec<u8>> + Into<Vec<u8>>,
 {
   fn eq(&self, other: &Self) -> bool {
     self.metadata == other.metadata

crates/vault/src/errors.rs

@@ -17,8 +17,8 @@ pub enum VaultError {
   VaultRestoreFromBytes(String),
   SafeCreation,
   SafeDecrypt,
-  SafeExport,
-  SafeRestore,
+  SafeExport(String),
+  SafeRestore(String),
 }
 
 impl Display for VaultError {
@@ -37,8 +37,8 @@ impl Display for VaultError {
       }
       Self::SafeCreation => write!(f, "Safe creation error"),
       Self::SafeDecrypt => write!(f, "Safe decryption error"),
-      Self::SafeExport => write!(f, "Safe export error"),
-      Self::SafeRestore => write!(f, "Safe restore error"),
+      Self::SafeExport(message) => write!(f, "Safe export error > {}", message),
+      Self::SafeRestore(message) => write!(f, "Safe restore error > {}", message),
       Self::IdentityError(error) => write!(f, "{}", error),
     }
   }
@@ -59,8 +59,8 @@ impl From<SignerError> for VaultError {
 impl From<SafeError> for VaultError {
   fn from(error: SafeError) -> Self {
     match error {
-      SafeError::Serialization => Self::SafeExport,
-      SafeError::Deserialization => Self::SafeRestore,
+      SafeError::Serialization(message) => Self::SafeExport(message),
+      SafeError::Deserialization(message) => Self::SafeRestore(message),
     }
   }
 }