1  
 2  use serde::{Deserialize, Deserializer, Serialize, Serializer};
 3  
 4  pub mod network_kind {
 5  	use super::*;
 6      use bitcoin::NetworkKind;
 7  
 8  	pub fn serialize<S: ::serde::Serializer>(network: &NetworkKind, s: S) -> Result<S::Ok, S::Error> {
 9  		match network {
10  			NetworkKind::Main => s.serialize_str("main"),
11  			NetworkKind::Test => s.serialize_str("test"),
12  		}
13  	}
14  
15  	pub fn deserialize<'de, D: ::serde::Deserializer<'de>>(d: D) -> Result<NetworkKind, D::Error> {
16  		use serde::de::Error;
17  
18  		match <&str>::deserialize(d)? {
19  			"main" => Ok(NetworkKind::Main),
20  			"test" => Ok(NetworkKind::Test),
21  			k => Err(D::Error::custom(format!("unknown network kind: {}", k))),
22  		}
23  	}
24  }
25  
26  /// Utility struct to serialize byte strings as hex.
27  #[derive(Clone, PartialEq, Eq, Debug, Hash)]
28  pub struct HexBytes(pub Vec<u8>);
29  
30  impl HexBytes {
31  	pub fn hex(&self) -> String {
32  		hex::encode(&self.0)
33  	}
34  
35  	pub fn bytes(&self) -> &[u8] {
36  		&self.0
37  	}
38  
39  	pub fn take_bytes(self) -> Vec<u8> {
40  		self.0
41  	}
42  }
43  
44  impl From<Vec<u8>> for HexBytes {
45  	fn from(vec: Vec<u8>) -> HexBytes {
46  		HexBytes(vec)
47  	}
48  }
49  
50  impl<'a> From<&'a [u8]> for HexBytes {
51  	fn from(slice: &'a [u8]) -> HexBytes {
52  		HexBytes(slice.to_vec())
53  	}
54  }
55  
56  impl Serialize for HexBytes {
57  	fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
58  		s.serialize_str(&hex::encode(&self.0))
59  	}
60  }
61  
62  impl<'de> Deserialize<'de> for HexBytes {
63  	fn deserialize<D: Deserializer<'de>>(d: D) -> Result<HexBytes, D::Error> {
64  		use serde::de::Error;
65  
66  		let hex_str = <&str>::deserialize(d)?;
67  		Ok(HexBytes(hex::decode(hex_str).map_err(D::Error::custom)?))
68  	}
69  }