Make constants publicly available

common-api/src/crypto/ed25519.rs

 //! Used Dalek cryptography, and implemented [`Borsh`](https://borsh.io/) serialization for them
 
 use borsh::{BorshDeserialize, BorshSerialize};
-use ed25519_dalek::{
-    ExpandedSecretKey, PublicKey, SecretKey, Signature, Verifier, PUBLIC_KEY_LENGTH,
-    SECRET_KEY_LENGTH, SIGNATURE_LENGTH,
-};
+use ed25519_dalek::{ExpandedSecretKey, PublicKey, SecretKey, Signature, Verifier};
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 use std::{
 
 use super::{split_encoded_str, Error, Key, Result, ED25519};
 
+pub use ed25519_dalek::{
+    PUBLIC_KEY_LENGTH as ED25519_PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH as ED25519_SECRET_KEY_LENGTH,
+    SIGNATURE_LENGTH as ED25519_SIGNATURE_LENGTH,
+};
+
 #[derive(Copy, Clone, Default, Eq, PartialEq)]
 pub struct Ed25519PublicKey(PublicKey);
 
     }
 
     #[inline]
-    pub fn as_bytes(&self) -> &[u8; PUBLIC_KEY_LENGTH] {
+    pub fn as_bytes(&self) -> &[u8; ED25519_PUBLIC_KEY_LENGTH] {
         self.0.as_bytes()
     }
 }
 
-impl Key<PUBLIC_KEY_LENGTH> for Ed25519PublicKey {
+impl Key<ED25519_PUBLIC_KEY_LENGTH> for Ed25519PublicKey {
     const KEY_TYPE: &'static str = ED25519;
 
     #[inline]
-    fn to_bytes(&self) -> [u8; PUBLIC_KEY_LENGTH] {
+    fn to_bytes(&self) -> [u8; ED25519_PUBLIC_KEY_LENGTH] {
         self.0.to_bytes()
     }
 
                 Error::from_string::<Ed25519SecretKey>(bs58_encoded.to_owned(), err.to_string())
             })?
             .into_iter()
-            .take(SECRET_KEY_LENGTH)
+            .take(ED25519_SECRET_KEY_LENGTH)
             .collect_vec();
         Self::try_from_bytes(&expanded_key_bytes)
     }
 
     #[inline]
-    pub fn as_bytes(&self) -> &[u8; PUBLIC_KEY_LENGTH] {
+    pub fn as_bytes(&self) -> &[u8; ED25519_PUBLIC_KEY_LENGTH] {
         self.0.as_bytes()
     }
 }
 
-impl Key<SECRET_KEY_LENGTH> for Ed25519SecretKey {
+impl Key<ED25519_SECRET_KEY_LENGTH> for Ed25519SecretKey {
     const KEY_TYPE: &'static str = ED25519;
 
     #[inline]
-    fn to_bytes(&self) -> [u8; SECRET_KEY_LENGTH] {
+    fn to_bytes(&self) -> [u8; ED25519_SECRET_KEY_LENGTH] {
         self.0.to_bytes()
     }
 
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct Ed25519Signature(Signature);
 
-impl Key<SIGNATURE_LENGTH> for Ed25519Signature {
+impl Key<ED25519_SIGNATURE_LENGTH> for Ed25519Signature {
     const KEY_TYPE: &'static str = ED25519;
 
     #[inline]
-    fn to_bytes(&self) -> [u8; SIGNATURE_LENGTH] {
+    fn to_bytes(&self) -> [u8; ED25519_SIGNATURE_LENGTH] {
         self.0.to_bytes()
     }
 

common-api/src/crypto/key_exchange.rs

 
 use super::{Error, Key, Result, X25519};
 
-const PUBLIC_LENGTH: usize = 32_usize;
-const SECRET_LENGTH: usize = 32_usize;
+pub const PUBLIC_KEY_LENGTH: usize = 32_usize;
+pub const SECRET_KEY_LENGTH: usize = 32_usize;
 
 pub struct Secret(StaticSecret);
 
     }
 }
 
-impl Key<SECRET_LENGTH> for Secret {
+impl Key<SECRET_KEY_LENGTH> for Secret {
     const KEY_TYPE: &'static str = X25519;
 
     #[inline]
-    fn to_bytes(&self) -> [u8; SECRET_LENGTH] {
+    fn to_bytes(&self) -> [u8; SECRET_KEY_LENGTH] {
         self.0.to_bytes()
     }
 
     fn try_from_bytes(buf: &[u8]) -> Result<Self> {
-        if buf.len() != SECRET_LENGTH {
+        if buf.len() != SECRET_KEY_LENGTH {
             return Err(Error::from_bytes::<Public>(
                 buf,
                 format!(
-                    "input buffer size \"{}\" not equal to secret key size \"{SECRET_LENGTH}\"",
+                    "input buffer size \"{}\" not equal to secret key size \"{SECRET_KEY_LENGTH}\"",
                     buf.len()
                 ),
             ));
         }
 
-        let mut temp_buf = [0_u8; SECRET_LENGTH];
+        let mut temp_buf = [0_u8; SECRET_KEY_LENGTH];
         temp_buf.copy_from_slice(buf);
 
         Ok(Self(StaticSecret::from(temp_buf)))
     }
 }
 
-impl Key<PUBLIC_LENGTH> for Public {
+impl Key<PUBLIC_KEY_LENGTH> for Public {
     const KEY_TYPE: &'static str = X25519;
 
     #[inline]
-    fn to_bytes(&self) -> [u8; PUBLIC_LENGTH] {
+    fn to_bytes(&self) -> [u8; PUBLIC_KEY_LENGTH] {
         self.0.to_bytes()
     }
 
     fn try_from_bytes(buf: &[u8]) -> Result<Self> {
-        if buf.len() != PUBLIC_LENGTH {
+        if buf.len() != PUBLIC_KEY_LENGTH {
             return Err(Error::from_bytes::<Public>(
                 buf,
                 format!(
-                    "input buffer size \"{}\" not equal to public key size \"{PUBLIC_LENGTH}\"",
+                    "input buffer size \"{}\" not equal to public key size \"{PUBLIC_KEY_LENGTH}\"",
                     buf.len()
                 ),
             ));
         }
 
-        let mut temp_buf = [0_u8; PUBLIC_LENGTH];
+        let mut temp_buf = [0_u8; PUBLIC_KEY_LENGTH];
         temp_buf.copy_from_slice(buf);
 
         Ok(Self(PublicKey::from(temp_buf)))
     /// ## Returns
     /// Byte array with a shared secret key
     ///
-    pub fn exchange(&self, other_public: &Public) -> [u8; SECRET_LENGTH] {
+    pub fn exchange(&self, other_public: &Public) -> [u8; SECRET_KEY_LENGTH] {
         self.0.diffie_hellman(&other_public.0).to_bytes()
     }
 }

common-api/src/crypto/mod.rs

 pub mod key_exchange;
 pub mod prelude {
     pub use super::{
-        ed25519::{Ed25519PublicKey, Ed25519SecretKey, Ed25519Signature, Keypair},
-        key_exchange::{Public, Secret},
+        ed25519::{
+            Ed25519PublicKey, Ed25519SecretKey, Ed25519Signature, Keypair,
+            ED25519_PUBLIC_KEY_LENGTH, ED25519_SECRET_KEY_LENGTH, ED25519_SIGNATURE_LENGTH,
+        },
+        key_exchange::{Public, Secret, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH},
         Error, Key,
     };
 }