feat: deserlialize secret key

crates/cashu/src/nuts/nut01.rs

@@ -56,7 +56,7 @@ impl std::fmt::Display for PublicKey {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(transparent)]
 pub struct SecretKey(#[serde(with = "crate::serde_utils::serde_secret_key")] k256::SecretKey);
 
@@ -98,6 +98,11 @@ impl SecretKey {
 
         Self(private_key.into())
     }
+
+    pub fn random() -> Self {
+        let mut rng = rand::thread_rng();
+        SecretKey(k256::SecretKey::random(&mut rng))
+    }
 }
 
 /// Mint Keys [NUT-01]
@@ -193,15 +198,15 @@ impl<'de> serde::de::Deserialize<'de> for KeysResponse {
 pub mod mint {
     use std::collections::BTreeMap;
 
-    use serde::Serialize;
+    use serde::{Deserialize, Serialize};
 
     use super::{PublicKey, SecretKey};
     use crate::Amount;
 
-    #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+    #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
     pub struct Keys(pub BTreeMap<Amount, KeyPair>);
 
-    #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+    #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
     pub struct KeyPair {
         pub public_key: PublicKey,
         pub secret_key: SecretKey,
@@ -238,4 +243,15 @@ mod tests {
 
         assert_eq!(&serde_json::to_string(&response).unwrap(), &res)
     }
+
+    #[test]
+    fn test_ser_der_secret() {
+        let secret = SecretKey::random();
+
+        let json = serde_json::to_string(&secret).unwrap();
+
+        let sec: SecretKey = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(sec, secret);
+    }
 }

crates/cashu/src/nuts/nut02.rs

@@ -214,14 +214,14 @@ pub mod mint {
     use bitcoin::hashes::sha256::Hash as Sha256;
     use bitcoin::hashes::{Hash, HashEngine};
     use k256::SecretKey;
-    use serde::Serialize;
+    use serde::{Deserialize, Serialize};
 
     use super::Id;
     use crate::nuts::nut01::mint::{KeyPair, Keys};
     use crate::nuts::CurrencyUnit;
     use crate::Amount;
 
-    #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+    #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
     pub struct KeySet {
         pub id: Id,
         pub unit: CurrencyUnit,

crates/cashu/src/serde_utils.rs

@@ -103,7 +103,9 @@ pub mod serde_public_key {
 }
 
 pub mod serde_secret_key {
+    use k256::elliptic_curve::generic_array::GenericArray;
     use k256::SecretKey;
+    use serde::Deserialize;
 
     pub fn serialize<S>(seckey: &SecretKey, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -112,14 +114,15 @@ pub mod serde_secret_key {
         let encoded = hex::encode(seckey.to_bytes());
         serializer.serialize_str(&encoded)
     }
-    /*
-        pub fn deserialize<'de, D>(deserializer: D) -> Result<SecretKey, D::Error>
-        where
-            D: serde::Deserializer<'de>,
-        {
-            let encoded = String::deserialize(deserializer)?;
-            let decoded = hex::decode(encoded).map_err(serde::de::Error::custom)?;
-            SecretKey::from_slice(&decoded).map_err(serde::de::Error::custom)
-        }
-    */
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<SecretKey, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let encoded = String::deserialize(deserializer)?;
+        Ok(
+            k256::SecretKey::from_bytes(GenericArray::from_slice(&hex::decode(encoded).unwrap()))
+                .unwrap(),
+        )
+    }
 }