Merge pull request #79 from Relayz-io/silvestr/impl-try-from-for-ed25519

Implemented TryFrom for PublicKey and SecretKey in dhx

common-api/Cargo.toml

 [dependencies]
 bs58 = "0.4"
 borsh = "0.9"
+curve25519-dalek = "3"
 ed25519-dalek = "1"
 itertools = "0.10"
 near-account-id = { version = "0.15", optional = true }
 serde = { version = "1", default-features = false, features = ["derive"] }
-serde_json = "1"
 thiserror = "1"
 uuid = { version = "1", optional = true }
 x25519-dalek = { version = "1", features = ["serde"] }

common-api/src/crypto/key_exchange.rs

 //! ---
 //! Used Dalek cryptography, and implemented [`Borsh`](https://borsh.io/) serialization for it
 
-use borsh::{BorshDeserialize, BorshSerialize};
+use super::{
+    ed25519::{Ed25519PublicKey, Ed25519SecretKey},
+    Error, Key, Result, X25519,
+};
 use std::{
     fmt::Display,
     io::{Error as IoError, ErrorKind},
 };
-use x25519_dalek::{PublicKey as DalekPublicKey, StaticSecret};
 
-use super::{Error, Key, Result, X25519};
+use borsh::{BorshDeserialize, BorshSerialize};
+use curve25519_dalek::edwards::CompressedEdwardsY;
+use x25519_dalek::{PublicKey as DalekPublicKey, StaticSecret};
 
 pub const PUBLIC_KEY_LENGTH: usize = 32_usize;
 pub const SECRET_KEY_LENGTH: usize = 32_usize;
     }
 }
 
+impl TryFrom<Ed25519PublicKey> for PublicKey {
+    type Error = Error;
+
+    fn try_from(key: Ed25519PublicKey) -> Result<Self> {
+        let edwards_point = CompressedEdwardsY::from_slice(key.as_bytes())
+            .decompress()
+            .ok_or_else(|| {
+                Error::from_bytes::<Ed25519PublicKey>(
+                    key.as_bytes(),
+                    "Couldn't decompress an Edwards point".to_owned(),
+                )
+            })?;
+
+        PublicKey::try_from_bytes(edwards_point.to_montgomery().as_bytes())
+    }
+}
+
+impl TryFrom<Ed25519SecretKey> for SecretKey {
+    type Error = Error;
+
+    fn try_from(key: Ed25519SecretKey) -> Result<Self> {
+        use ed25519_dalek::{ExpandedSecretKey, SecretKey as S};
+
+        let expanded_key =
+            ExpandedSecretKey::from(&S::from_bytes(key.as_bytes()).map_err(|err| {
+                Error::from_bytes::<Ed25519SecretKey>(key.as_bytes(), err.to_string())
+            })?);
+
+        Self::try_from_bytes(&expanded_key.to_bytes()[..32])
+    }
+}
+
 serde_impl!(SecretKey);
 serde_impl!(PublicKey);

common-api/tests/crypto.rs

     assert_eq!(keypair_bs58, keypair.to_string());
 }
 
+#[test]
+fn convert_from_edwards_to_montgomery() {
+    let alice_sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
+    let bob_sk = Ed25519SecretKey::try_from_bytes(&random_bits()).unwrap();
+
+    let alice_pk = Ed25519PublicKey::from(&alice_sk);
+    let bob_pk = Ed25519PublicKey::from(&bob_sk);
+
+    let alice_sk_dhx = SecretKey::try_from(alice_sk).unwrap();
+    let bob_sk_dhx = SecretKey::try_from(bob_sk).unwrap();
+
+    let alice_pk_dhx = PublicKey::try_from(alice_pk).unwrap();
+    let bob_pk_dhx = PublicKey::try_from(bob_pk).unwrap();
+
+    assert_eq!(
+        alice_sk_dhx.exchange(&bob_pk_dhx),
+        bob_sk_dhx.exchange(&alice_pk_dhx)
+    );
+}
+
 fn random_bits() -> [u8; ED25519_SECRET_KEY_LENGTH] {
     let mut chacha = ChaChaRng::from_entropy();
     let mut secret_bytes = [0_u8; ED25519_SECRET_KEY_LENGTH];