Take JsonReply in extract_err_req

This simple type can more easily cross foreign language boundaries.

Fix payjoin#605

Author: DanGould

payjoin-cli/src/app/v2.rs

@@ -287,7 +287,8 @@ async fn handle_recoverable_error(
     mut receiver: UncheckedProposal,
     ohttp_relay: &payjoin::Url,
 ) -> anyhow::Error {
-    let (err_req, err_ctx) = match receiver.extract_err_req(&e, ohttp_relay) {
+    let to_return = anyhow!("Replied with error: {}", e);
+    let (err_req, err_ctx) = match receiver.extract_err_req(&e.into(), ohttp_relay) {
         Ok(req_ctx) => req_ctx,
         Err(e) => return anyhow!("Failed to extract error request: {}", e),
     };
@@ -306,7 +307,7 @@ async fn handle_recoverable_error(
         return anyhow!("Failed to process error response: {}", e);
     }
 
-    e.into()
+    to_return
 }
 
 fn try_contributing_inputs(

payjoin/src/receive/error.rs

@@ -104,13 +104,14 @@ impl JsonReply {
     }
 }
 
-impl From<&ReplyableError> for JsonReply {
-    fn from(e: &ReplyableError) -> Self {
+impl From<ReplyableError> for JsonReply {
+    fn from(e: ReplyableError) -> Self {
+        use ReplyableError::*;
         match e {
-            ReplyableError::Payload(e) => e.into(),
+            Payload(e) => e.into(),
             #[cfg(feature = "v1")]
-            ReplyableError::V1(e) => e.into(),
-            ReplyableError::Implementation(_) => JsonReply::new(Unavailable, "Receiver error"),
+            V1(e) => e.into(),
+            Implementation(_) => JsonReply::new(Unavailable, "Receiver error"),
         }
     }
 }
@@ -196,8 +197,8 @@ pub(crate) enum InternalPayloadError {
     FeeTooHigh(bitcoin::FeeRate, bitcoin::FeeRate),
 }
 
-impl From<&PayloadError> for JsonReply {
-    fn from(e: &PayloadError) -> Self {
+impl From<PayloadError> for JsonReply {
+    fn from(e: PayloadError) -> Self {
         use InternalPayloadError::*;
 
         match &e.0 {

payjoin/src/receive/v1/exclusive/error.rs

@@ -38,8 +38,8 @@ impl From<InternalRequestError> for super::ReplyableError {
     fn from(e: InternalRequestError) -> Self { super::ReplyableError::V1(e.into()) }
 }
 
-impl From<&RequestError> for JsonReply {
-    fn from(e: &RequestError) -> Self {
+impl From<RequestError> for JsonReply {
+    fn from(e: RequestError) -> Self {
         use InternalRequestError::*;
 
         match &e.0 {

payjoin/src/receive/v2/mod.rs

@@ -278,15 +278,15 @@ impl UncheckedProposal {
     /// a Receiver Error Response
     pub fn extract_err_req(
         &mut self,
-        err: &ReplyableError,
+        err: &JsonReply,
         ohttp_relay: impl IntoUrl,
     ) -> Result<(Request, ohttp::ClientResponse), SessionError> {
         let subdir = subdir(&self.context.directory, &id(&self.context.s));
         let (body, ohttp_ctx) = ohttp_encapsulate(
             &mut self.context.ohttp_keys,
             "POST",
             subdir.as_str(),
-            Some(JsonReply::from(err).to_json().to_string().as_bytes()),
+            Some(err.to_json().to_string().as_bytes()),
         )
         .map_err(InternalSessionError::OhttpEncapsulation)?;
         let req = Request::new_v2(&self.context.full_relay_url(ohttp_relay)?, &body);
@@ -620,21 +620,26 @@ mod test {
             context: SHARED_CONTEXT.clone(),
         };
 
-        let server_error = proposal
-            .clone()
-            .check_broadcast_suitability(None, |_| Err("mock error".into()))
-            .err()
-            .ok_or("expected error but got success")?;
+        let server_error = || {
+            proposal
+                .clone()
+                .check_broadcast_suitability(None, |_| Err("mock error".into()))
+                .expect_err("expected broadcast suitability check to fail")
+        };
+
         let expected_json = serde_json::json!({
             "errorCode": "unavailable",
             "message": "Receiver error"
         });
-        let actual_json = JsonReply::from(&server_error).to_json();
+
+        let actual_json = JsonReply::from(server_error()).to_json().clone();
         assert_eq!(actual_json, expected_json);
-        let (_req, _ctx) = proposal.clone().extract_err_req(&server_error, &*EXAMPLE_URL)?;
 
-        let internal_error = InternalPayloadError::MissingPayment.into();
-        let (_req, _ctx) = proposal.extract_err_req(&internal_error, &*EXAMPLE_URL)?;
+        let (_req, _ctx) =
+            proposal.clone().extract_err_req(&server_error().into(), &*EXAMPLE_URL)?;
+
+        let internal_error: ReplyableError = InternalPayloadError::MissingPayment.into();
+        let (_req, _ctx) = proposal.extract_err_req(&internal_error.into(), &*EXAMPLE_URL)?;
         Ok(())
     }