Removing unnecessary to_hex function

Author: dr-orlovsky

src/key.rs

@@ -203,8 +203,7 @@ impl SecretKey {
 impl ::serde::Serialize for SecretKey {
     fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
         if s.is_human_readable() {
-            let mut buf = [0u8; constants::SECRET_KEY_SIZE*2];
-            s.serialize_str(::to_hex(&self.0[..], &mut buf).expect("Should never fail, the buffer is big enough."))
+            s.serialize_str(&self.display_secret().to_string())
         } else {
             s.serialize_bytes(&self[..])
         }
@@ -687,11 +686,10 @@ mod test {
         let pk = PublicKey::from_secret_key(&s, &sk);
         #[cfg(fuzzing)]
         let pk = PublicKey::from_slice(&[0x02, 0x18, 0x84, 0x57, 0x81, 0xf6, 0x31, 0xc4, 0x8f, 0x1c, 0x97, 0x09, 0xe2, 0x30, 0x92, 0x06, 0x7d, 0x06, 0x83, 0x7f, 0x30, 0xaa, 0x0c, 0xd0, 0x54, 0x4a, 0xc8, 0x87, 0xfe, 0x91, 0xdd, 0xd1, 0x66]).expect("pk");
-        let mut buf = [0u8; constants::SECRET_KEY_SIZE * 2];
 
         #[allow(deprecated)] {
         assert_eq!(
-            to_hex(&sk[..], &mut buf).unwrap(),
+            sk.display_secret().to_string(),
             "01010101010101010001020304050607ffff0000ffff00006363636363636363"
         ) };
         assert_eq!(

src/lib.rs

@@ -852,29 +852,6 @@ fn from_hex(hex: &str, target: &mut [u8]) -> Result<usize, ()> {
     Ok(idx / 2)
 }
 
-/// Utility function used to encode hex into a target u8 buffer. Returns
-/// a reference to the target buffer as an str.
-// it returns an error if the target buffer isn't big enough
-#[inline]
-fn to_hex<'a>(src: &[u8], target: &'a mut [u8]) -> Result<&'a str, ()> {
-    let hex_len = src.len() * 2;
-    if target.len() < hex_len {
-        return Err(());
-    }
-    const HEX_TABLE: [u8; 16] = *b"0123456789abcdef";
-
-    let mut i = 0;
-    for &b in src {
-        target[i] = HEX_TABLE[usize::from(b >> 4)];
-        target[i+1] = HEX_TABLE[usize::from(b & 0b00001111)];
-        i +=2 ;
-    }
-    let result = &target[..hex_len];
-    debug_assert!(str::from_utf8(result).is_ok());
-    return unsafe { Ok(str::from_utf8_unchecked(result)) };
-}
-
-
 #[cfg(test)]
 mod tests {
     use rand::{RngCore, thread_rng};

src/secret.rs

@@ -58,8 +58,14 @@ macro_rules! impl_display_secret {
 /// ```
 /// use secp256k1::key::ONE_KEY;
 /// let key = ONE_KEY;
-/// println!("{}", key.display_secret());
-/// println!("{:?}", key.display_secret());
+/// assert_eq!(
+///     "0000000000000000000000000000000000000000000000000000000000000001",
+///     format!("{}", key.display_secret())
+/// );
+/// assert_eq!(
+///     "[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, 1]",
+///     format!("{:?}", key.display_secret())
+/// );
 /// ```
 ///
 /// [`Display`]: fmt::Display