diff --git a/src/bases/b58.rs b/src/bases/b58.rs
index fea202ca5ebea468c46cefecea6866d2f52edcfc..1f8b08ded8c6671347bffa9dbab7ce55eb53abc6 100644
--- a/src/bases/b58.rs
+++ b/src/bases/b58.rs
@@ -25,7 +25,12 @@ pub trait ToBase58 {
 
 /// Create an array of 32 bytes from a Base58 string.
 pub fn str_base58_to_32bytes(base58_data: &str) -> Result<([u8; 32], usize), BaseConvertionError> {
-    match bs58::decode(base58_data).into_vec() {
+    let mut source = base58_data;
+    while !source.is_empty() && &source[0..1] == "1" {
+        source = &source[1..];
+    }
+
+    match bs58::decode(source).into_vec() {
         Ok(result) => {
             let len = result.len();
             if len <= 32 {
diff --git a/src/keys/ed25519.rs b/src/keys/ed25519.rs
index 92f22dd9317aa3fe505c82c243632a5abbe3da01..0a7d84cec0b22d897a30a871f5b38ca1dfa50062 100644
--- a/src/keys/ed25519.rs
+++ b/src/keys/ed25519.rs
@@ -43,11 +43,9 @@ use unwrap::unwrap;
 use zeroize::Zeroize;
 
 /// Maximal size of a public key in bytes
-pub static PUBKEY_SIZE_IN_BYTES: &usize = &32;
-/// Minimal size of a public key in bytes
-pub static PUBKEY_MIN_SIZE_IN_BYTES: &usize = &31;
-/// Size of a signature in bytes
-pub static SIG_SIZE_IN_BYTES: &usize = &64;
+pub const PUBKEY_SIZE_IN_BYTES: usize = 32;
+/// constf a signature in bytes
+pub const SIG_SIZE_IN_BYTES: usize = 64;
 
 /// Store a ed25519 signature.
 #[derive(Clone, Copy)]
@@ -167,7 +165,7 @@ impl Default for PublicKey {
     fn default() -> Self {
         PublicKey {
             datas: [0u8; 32],
-            len: 32,
+            len: 0,
         }
     }
 }
@@ -182,9 +180,9 @@ impl TryFrom<&[u8]> for PublicKey {
     type Error = PubkeyFromBytesError;
 
     fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
-        if bytes.len() > *PUBKEY_SIZE_IN_BYTES || bytes.len() < *PUBKEY_MIN_SIZE_IN_BYTES {
+        if bytes.len() > PUBKEY_SIZE_IN_BYTES {
             Err(PubkeyFromBytesError::InvalidBytesLen {
-                expected: *PUBKEY_SIZE_IN_BYTES,
+                expected: PUBKEY_SIZE_IN_BYTES,
                 found: bytes.len(),
             })
         } else {
@@ -223,14 +221,7 @@ impl super::PublicKey for PublicKey {
     #[inline]
     fn from_base58(base58_data: &str) -> Result<Self, BaseConvertionError> {
         let (datas, len) = b58::str_base58_to_32bytes(base58_data)?;
-        if len < *PUBKEY_MIN_SIZE_IN_BYTES {
-            Err(BaseConvertionError::InvalidLength {
-                expected: *PUBKEY_SIZE_IN_BYTES,
-                found: len,
-            })
-        } else {
-            Ok(PublicKey { datas, len })
-        }
+        Ok(PublicKey { datas, len })
     }
 
     fn to_bytes_vector(&self) -> Vec<u8> {
@@ -489,6 +480,12 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_pubkey_111_from_base58() {
+        let public58 = "11111111111111111111111111111111111111111111";
+        let _ = unwrap!(super::PublicKey::from_base58(public58));
+    }
+
     #[test]
     fn base58_public_key() {
         let public58 = "DNann1Lh55eZMEDXeYt59bzHbA3NJR46DeQYCS2qQdLV";
@@ -578,7 +575,7 @@ mod tests {
 
         // Test signature serialization/deserialization
         let mut bin_sig = bincode::serialize(&signature).expect("Fail to serialize signature !");
-        assert_eq!(*SIG_SIZE_IN_BYTES, bin_sig.len());
+        assert_eq!(SIG_SIZE_IN_BYTES, bin_sig.len());
         assert_eq!(signature.to_bytes_vector(), bin_sig);
         assert_eq!(
             signature,
diff --git a/src/keys/mod.rs b/src/keys/mod.rs
index a69823d2a20aff1fb95a1c824de3c686f79c0d95..3f31d9f374a5b3695b3293043c93026347a798f0 100644
--- a/src/keys/mod.rs
+++ b/src/keys/mod.rs
@@ -162,7 +162,7 @@ impl Sig {
     /// Get Sig size in bytes
     pub fn size_in_bytes(&self) -> usize {
         match *self {
-            Sig::Ed25519(_) => *ed25519::SIG_SIZE_IN_BYTES + 2,
+            Sig::Ed25519(_) => ed25519::SIG_SIZE_IN_BYTES + 2,
             Sig::Schnorr() => panic!("Schnorr algo not yet supported !"),
         }
     }
@@ -494,7 +494,7 @@ mod tests {
         let sig_str_b64 = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==".to_owned();
         let sig = Sig::Ed25519(ed25519::Signature(sig_bytes));
 
-        assert_eq!(sig.size_in_bytes(), *ed25519::SIG_SIZE_IN_BYTES + 2);
+        assert_eq!(sig.size_in_bytes(), ed25519::SIG_SIZE_IN_BYTES + 2);
         assert_eq!(sig_str_b64, format!("{}", sig));
 
         assert_eq!(KeysAlgo::Ed25519, sig.algo());
@@ -508,10 +508,7 @@ mod tests {
     #[test]
     fn pubkey() {
         let pubkey_default = PubKey::default();
-        let pubkey_bytes = [
-            0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0,
-        ];
+        let pubkey_bytes = [];
         let pubkey = PubKey::Ed25519(unwrap!(ed25519::PublicKey::try_from(&pubkey_bytes[..])));
         assert_eq!(pubkey_default, pubkey);
 
@@ -521,15 +518,15 @@ mod tests {
             PubKey::from_str(&pubkey_str_b58).expect("Fail to parse pubkey !")
         );
 
-        assert_eq!(pubkey.size_in_bytes(), *ed25519::PUBKEY_SIZE_IN_BYTES + 3);
-        assert_eq!(pubkey_str_b58, format!("{}", pubkey));
+        assert_eq!(pubkey.size_in_bytes(), ed25519::PUBKEY_SIZE_IN_BYTES + 3);
+        assert_eq!("", &format!("{}", pubkey));
 
         assert_eq!(KeysAlgo::Ed25519, pubkey.algo());
         assert_eq!(KeysAlgo::Schnorr, PubKey::Schnorr().algo());
 
         assert_eq!(pubkey_bytes.to_vec(), pubkey.to_bytes_vector());
 
-        assert_eq!(pubkey_str_b58, pubkey.to_base58());
+        assert_eq!("", &pubkey.to_base58());
 
         assert_eq!(
             Err(SigError::InvalidSig),
@@ -721,14 +718,7 @@ mod tests {
     fn pubkey_from_bytes() {
         assert_eq!(
             Err(PubkeyFromBytesError::InvalidBytesLen {
-                expected: *ed25519::PUBKEY_SIZE_IN_BYTES,
-                found: 2,
-            }),
-            PubKey::from_bytes(&[0u8, 1]),
-        );
-        assert_eq!(
-            Err(PubkeyFromBytesError::InvalidBytesLen {
-                expected: *ed25519::PUBKEY_SIZE_IN_BYTES,
+                expected: ed25519::PUBKEY_SIZE_IN_BYTES,
                 found: 33,
             }),
             PubKey::from_bytes(&[
@@ -738,7 +728,7 @@ mod tests {
         );
         assert_eq!(
             Ok(PubKey::Ed25519(ed25519::PublicKey::default())),
-            PubKey::from_bytes(&[0u8; 32]),
+            PubKey::from_bytes(&[]),
         );
     }
 }