_ Git - ldk-sample/blob - src/hex_utils.rs

   1 use bitcoin::secp256k1::PublicKey;
   2 use std::fmt::Write;
   3
   4 pub fn to_vec(hex: &str) -> Option<Vec<u8>> {
   5         let mut out = Vec::with_capacity(hex.len() / 2);
   6
   7         let mut b = 0;
   8         for (idx, c) in hex.as_bytes().iter().enumerate() {
   9                 b <<= 4;
  10                 match *c {
  11                         b'A'..=b'F' => b |= c - b'A' + 10,
  12                         b'a'..=b'f' => b |= c - b'a' + 10,
  13                         b'0'..=b'9' => b |= c - b'0',
  14                         _ => return None,
  15                 }
  16                 if (idx & 1) == 1 {
  17                         out.push(b);
  18                         b = 0;
  19                 }
  20         }
  21
  22         Some(out)
  23 }
  24
  25 #[inline]
  26 pub fn hex_str(value: &[u8]) -> String {
  27         let mut res = String::with_capacity(2 * value.len());
  28         for v in value {
  29                 write!(&mut res, "{:02x}", v).expect("Unable to write");
  30         }
  31         res
  32 }
  33
  34 pub fn to_compressed_pubkey(hex: &str) -> Option<PublicKey> {
  35         if hex.len() != 33 * 2 {
  36                 return None;
  37         }
  38         let data = match to_vec(&hex[0..33 * 2]) {
  39                 Some(bytes) => bytes,
  40                 None => return None,
  41         };
  42         match PublicKey::from_slice(&data) {
  43                 Ok(pk) => Some(pk),
  44                 Err(_) => None,
  45         }
  46 }