serde_utils.rs 3.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125
  1. //! Utilities for serde
  2. pub mod serde_url {
  3. use serde::Deserialize;
  4. use url::Url;
  5. pub fn serialize<S>(url: &Url, serializer: S) -> Result<S::Ok, S::Error>
  6. where
  7. S: serde::Serializer,
  8. {
  9. serializer.serialize_str(url.to_string().trim_end_matches('/'))
  10. }
  11. pub fn deserialize<'de, D>(deserializer: D) -> Result<Url, D::Error>
  12. where
  13. D: serde::Deserializer<'de>,
  14. {
  15. let url_string = String::deserialize(deserializer)?;
  16. Url::parse(&url_string).map_err(serde::de::Error::custom)
  17. }
  18. }
  19. pub mod bytes_base64 {
  20. use base64::engine::general_purpose;
  21. use base64::Engine as _;
  22. use serde::Deserialize;
  23. pub fn serialize<S>(my_bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
  24. where
  25. S: serde::Serializer,
  26. {
  27. let encoded = general_purpose::STANDARD.encode(my_bytes);
  28. serializer.serialize_str(&encoded)
  29. }
  30. pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
  31. where
  32. D: serde::Deserializer<'de>,
  33. {
  34. let encoded = String::deserialize(deserializer)?;
  35. let decoded = general_purpose::STANDARD
  36. .decode(encoded)
  37. .map_err(serde::de::Error::custom)?;
  38. Ok(decoded)
  39. }
  40. }
  41. pub mod serde_public_key {
  42. use k256::PublicKey;
  43. use serde::Deserialize;
  44. pub fn serialize<S>(pubkey: &PublicKey, serializer: S) -> Result<S::Ok, S::Error>
  45. where
  46. S: serde::Serializer,
  47. {
  48. let encoded = hex::encode(pubkey.to_sec1_bytes());
  49. serializer.serialize_str(&encoded)
  50. }
  51. pub fn deserialize<'de, D>(deserializer: D) -> Result<PublicKey, D::Error>
  52. where
  53. D: serde::Deserializer<'de>,
  54. {
  55. let encoded = String::deserialize(deserializer)?;
  56. let decoded = hex::decode(encoded).map_err(serde::de::Error::custom)?;
  57. PublicKey::from_sec1_bytes(&decoded).map_err(serde::de::Error::custom)
  58. }
  59. pub mod opt {
  60. use k256::PublicKey;
  61. use serde::{Deserialize, Deserializer};
  62. pub fn serialize<S>(pubkey: &Option<PublicKey>, serializer: S) -> Result<S::Ok, S::Error>
  63. where
  64. S: serde::Serializer,
  65. {
  66. match pubkey {
  67. Some(pubkey) => {
  68. let encoded = hex::encode(pubkey.to_sec1_bytes());
  69. serializer.serialize_str(&encoded)
  70. }
  71. None => serializer.serialize_none(),
  72. }
  73. }
  74. pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<PublicKey>, D::Error>
  75. where
  76. D: Deserializer<'de>,
  77. {
  78. let option_str: Option<String> = Option::deserialize(deserializer)?;
  79. match option_str {
  80. Some(encoded) => {
  81. let bytes = hex::decode(encoded).map_err(serde::de::Error::custom)?;
  82. let pubkey =
  83. PublicKey::from_sec1_bytes(&bytes).map_err(serde::de::Error::custom)?;
  84. Ok(Some(pubkey))
  85. }
  86. None => Ok(None),
  87. }
  88. }
  89. }
  90. }
  91. pub mod serde_secret_key {
  92. use k256::SecretKey;
  93. pub fn serialize<S>(seckey: &SecretKey, serializer: S) -> Result<S::Ok, S::Error>
  94. where
  95. S: serde::Serializer,
  96. {
  97. let encoded = hex::encode(seckey.to_bytes());
  98. serializer.serialize_str(&encoded)
  99. }
  100. /*
  101. pub fn deserialize<'de, D>(deserializer: D) -> Result<SecretKey, D::Error>
  102. where
  103. D: serde::Deserializer<'de>,
  104. {
  105. let encoded = String::deserialize(deserializer)?;
  106. let decoded = hex::decode(encoded).map_err(serde::de::Error::custom)?;
  107. SecretKey::from_slice(&decoded).map_err(serde::de::Error::custom)
  108. }
  109. */
  110. }