Accept owned variant keys for Decoded<Strkey> (#125)

Author: leighmcculloch

Cargo.toml

@@ -28,6 +28,7 @@ crate-git-revision = "0.0.9"
 [dev-dependencies]
 proptest ="1.0.0"
 serde_test = "1.0.177"
+serde_json = "1"
 
 [dependencies]
 data-encoding = { version = "2.6.0", default-features = false }

src/strkey.rs

@@ -193,11 +193,16 @@ mod strkey_decoded_serde_impl {
                 }
 
                 fn visit_map<M: MapAccess<'de>>(self, mut map: M) -> Result<Self::Value, M::Error> {
-                    let key: &str = map
+                    // Read the variant key as an owned `String`, not a borrowed
+                    // `&str`. Deserializers that don't borrow from a contiguous
+                    // input buffer — e.g. `serde_json::from_value` /
+                    // `from_reader`, and most non-JSON formats — yield owned
+                    // keys that cannot be borrowed as `&str` and would fail here.
+                    let key: alloc::string::String = map
                         .next_key()?
                         .ok_or_else(|| de::Error::custom("expected a variant key"))?;
 
-                    let strkey = match key {
+                    let strkey = match key.as_str() {
                         "public_key_ed25519" => {
                             let Decoded(inner) = map.next_value()?;
                             Strkey::PublicKeyEd25519(inner)
@@ -232,7 +237,7 @@ mod strkey_decoded_serde_impl {
                         }
                         _ => {
                             return Err(de::Error::unknown_variant(
-                                key,
+                                &key,
                                 &[
                                     "public_key_ed25519",
                                     "pre_auth_tx",

tests/cli_json.rs tests/serde_decoded.rstests/cli_json.rs renamed to tests/serde_decoded.rs

@@ -1,4 +1,4 @@
-#![cfg(feature = "cli")]
+#![cfg(feature = "serde-decoded")]
 
 use stellar_strkey::{ed25519, *};
 
@@ -123,6 +123,52 @@ fn test_ed25519_signed_payload() {
     );
 }
 
+// Regression tests for deserializing `Decoded<Strkey>` from deserializers that
+// yield owned (rather than borrowed) string keys. `serde_json::from_str`
+// borrows the variant key directly from the input buffer, but `from_value` and
+// `from_reader` cannot, so the map visitor must accept an owned key. The
+// `encode` CLI is one consumer that hits this, via `from_value`. See issue
+// #124.
+
+#[test]
+fn test_decode_strkey_from_value() {
+    let value = serde_json::json!({
+        "public_key_ed25519": "3330317ec241d79943bb9aa7c8ea5f8b89f9c6ea351fe03f8ec3d1127137d484",
+    });
+    let Decoded(strkey): Decoded<Strkey> = serde_json::from_value(value).unwrap();
+    assert!(matches!(strkey, Strkey::PublicKeyEd25519(_)));
+}
+
+#[test]
+fn test_decode_strkey_from_reader() {
+    // `from_reader` consumes a stream and cannot borrow keys from the input.
+    let json = r#"{"public_key_ed25519":"3330317ec241d79943bb9aa7c8ea5f8b89f9c6ea351fe03f8ec3d1127137d484"}"#;
+    let Decoded(strkey): Decoded<Strkey> = serde_json::from_reader(json.as_bytes()).unwrap();
+    assert!(matches!(strkey, Strkey::PublicKeyEd25519(_)));
+}
+
+#[test]
+fn test_decode_strkey_from_value_nested_variant() {
+    // A compound variant (nested object) exercised through the owned-key path.
+    let value = serde_json::json!({
+        "signed_payload_ed25519": {
+            "ed25519": "0000000000000000000000000000000000000000000000000000000000000000",
+            "payload": "01020304",
+        }
+    });
+    let Decoded(strkey): Decoded<Strkey> = serde_json::from_value(value).unwrap();
+    assert!(matches!(strkey, Strkey::SignedPayloadEd25519(_)));
+}
+
+#[test]
+fn test_roundtrip_public_key_via_value() {
+    // Serialize to a `serde_json::Value`, then deserialize back via `from_value`.
+    let original = Strkey::PublicKeyEd25519(ed25519::PublicKey([7u8; 32]));
+    let value = serde_json::to_value(Decoded(&original)).unwrap();
+    let Decoded(deserialized): Decoded<Strkey> = serde_json::from_value(value).unwrap();
+    assert_eq!(original, deserialized);
+}
+
 #[test]
 fn test_roundtrip_muxed_account() {
     let original = Strkey::MuxedAccountEd25519(ed25519::MuxedAccount {