Use strong json Value types with serde_json

Hand rolling strings is simple, but serde_json is already a dependency
and is more robust.

Author: DanGould

payjoin/src/receive/error.rs

@@ -77,28 +77,30 @@ pub struct JsonReply {
     error_code: ErrorCode,
     /// The error message to be displayed only in debug logs
     message: String,
-    /// Additional fields to be added to the JSON
-    additional_fields: Vec<String>,
+    /// Additional fields to be included in the JSON response
+    extra: serde_json::Map<String, serde_json::Value>,
 }
 
 impl JsonReply {
     /// Create a new Reply
     pub fn new(error_code: ErrorCode, message: impl fmt::Display) -> Self {
-        Self { error_code, message: message.to_string(), additional_fields: vec![] }
+        Self { error_code, message: message.to_string(), extra: serde_json::Map::new() }
+    }
+
+    /// Add an additional field to the JSON response
+    pub fn with_extra(mut self, key: &str, value: impl Into<serde_json::Value>) -> Self {
+        self.extra.insert(key.to_string(), value.into());
+        self
     }
 
     /// Serialize the Reply to a JSON string
-    pub fn to_json(&self) -> String {
-        if self.additional_fields.is_empty() {
-            format!(r#"{{ "errorCode": "{}", "message": "{}" }}"#, self.error_code, self.message)
-        } else {
-            format!(
-                r#"{{ "errorCode": "{}", "message": "{}", {} }}"#,
-                self.error_code,
-                self.message,
-                self.additional_fields.join(", ")
-            )
-        }
+    pub fn to_json(&self) -> serde_json::Value {
+        let mut map = serde_json::Map::new();
+        map.insert("errorCode".to_string(), self.error_code.to_string().into());
+        map.insert("message".to_string(), self.message.clone().into());
+        map.extend(self.extra.clone());
+
+        serde_json::Value::Object(map)
     }
 }
 
@@ -205,14 +207,8 @@ impl From<&PayloadError> for JsonReply {
                 super::optional_parameters::Error::UnknownVersion { supported_versions } => {
                     let supported_versions_json =
                         serde_json::to_string(supported_versions).unwrap_or_default();
-                    JsonReply {
-                        error_code: VersionUnsupported,
-                        message: "This version of payjoin is not supported.".to_string(),
-                        additional_fields: vec![format!(
-                            r#""supported": {}"#,
-                            supported_versions_json
-                        )],
-                    }
+                    JsonReply::new(VersionUnsupported, "This version of payjoin is not supported.")
+                        .with_extra("supported", supported_versions_json)
                 }
                 _ => JsonReply::new(OriginalPsbtRejected, e),
             },

payjoin/src/receive/v2/mod.rs

@@ -286,7 +286,7 @@ impl UncheckedProposal {
             &mut self.context.ohttp_keys,
             "POST",
             subdir.as_str(),
-            Some(JsonReply::from(err).to_json().as_bytes()),
+            Some(JsonReply::from(err).to_json().to_string().as_bytes()),
         )
         .map_err(InternalSessionError::OhttpEncapsulation)?;
         let req = Request::new_v2(&self.context.full_relay_url(ohttp_relay)?, &body);
@@ -625,10 +625,12 @@ mod test {
             .check_broadcast_suitability(None, |_| Err("mock error".into()))
             .err()
             .ok_or("expected error but got success")?;
-        assert_eq!(
-            JsonReply::from(&server_error).to_json(),
-            r#"{ "errorCode": "unavailable", "message": "Receiver error" }"#
-        );
+        let expected_json = serde_json::json!({
+            "errorCode": "unavailable",
+            "message": "Receiver error"
+        });
+        let actual_json = JsonReply::from(&server_error).to_json();
+        assert_eq!(actual_json, expected_json);
         let (_req, _ctx) = proposal.clone().extract_err_req(&server_error, &*EXAMPLE_URL)?;
 
         let internal_error = InternalPayloadError::MissingPayment.into();

payjoin/src/send/error.rs

@@ -344,20 +344,22 @@ impl Display for ResponseError {
 impl fmt::Debug for ResponseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Self::WellKnown(e) => write!(
-                f,
-                r#"Well known error: {{ "errorCode": "{}",
-                "message": "{}" }}"#,
-                e.error_code(),
-                e.message()
-            ),
+            Self::WellKnown(e) => {
+                let json = serde_json::json!({
+                    "errorCode": e.error_code().to_string(),
+                    "message": e.message()
+                });
+                write!(f, "Well known error: {}", json)
+            }
             Self::Validation(e) => write!(f, "Validation({:?})", e),
 
-            Self::Unrecognized { error_code, message } => write!(
-                f,
-                r#"Unrecognized error: {{ "errorCode": "{}", "message": "{}" }}"#,
-                error_code, message
-            ),
+            Self::Unrecognized { error_code, message } => {
+                let json = serde_json::json!({
+                    "errorCode": error_code,
+                    "message": message
+                });
+                write!(f, "Unrecognized error: {}", json)
+            }
         }
     }
 }
@@ -403,7 +405,7 @@ impl Display for WellKnownError {
 
 #[cfg(test)]
 mod tests {
-    use bitcoind::bitcoincore_rpc::jsonrpc::serde_json::json;
+    use serde_json::json;
 
     use super::*;