Supply & parse receiver response errors

payjoin-cli/src/app.rs

@@ -107,9 +107,12 @@ impl App {
             .header("Content-Type", "text/plain")
             .send()
             .with_context(|| "HTTP request failed")?;
-        // TODO display well-known errors and log::debug the rest
-        let psbt =
-            ctx.process_response(&mut response).with_context(|| "Failed to process response")?;
+        let psbt = ctx.process_response(&mut response).or_else(|e| {
+            // It is imperative to carefully display pre-defined messages to end users and the details in debug, otherwise receiver could craft a message to phish the sender.
+            log::error!("Response contains error: {}", e);
+            log::debug!("Response contains error: {:?}", e);
+            Err(e)
+        })?;
         log::debug!("Proposed psbt: {:#?}", psbt);
         let psbt = self
             .bitcoind

payjoin/Cargo.toml

@@ -22,6 +22,7 @@ bitcoin = { version = "0.30.0", features = ["base64"] }
 bip21 = "0.3.1"
 log = { version = "0.4.14"}
 rand = { version = "0.8.4", optional = true }
+tinyjson = "2"
 url = "2.2.2"
 
 [dev-dependencies]

payjoin/src/receive/error.rs

@@ -13,7 +13,10 @@ impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match &self {
             Self::BadRequest(e) => e.fmt(f),
-            Self::Server(e) => write!(f, "Internal Server Error: {}", e),
+            Self::Server(_) => write!(
+                f,
+                r#"{{ "errorCode": "unavailable", "message": "The payjoin endpoint is not available for now." }}"#
+            ),
         }
     }
 }

payjoin/src/send/error.rs

@@ -16,7 +16,7 @@ pub struct ValidationError {
 
 #[derive(Debug)]
 pub(crate) enum InternalValidationError {
-    Psbt(bitcoin::psbt::PsbtParseError),
+    Parse,
     Io(std::io::Error),
     InvalidInputType(InputTypeError),
     InvalidProposedInput(crate::psbt::PrevTxOutError),
@@ -58,7 +58,6 @@ impl fmt::Display for ValidationError {
         use InternalValidationError::*;
 
         match &self.internal {
-            Psbt(e) => write!(f, "couldn't decode PSBT: {}", e),
             Io(e) => write!(f, "couldn't read PSBT: {}", e),
             InvalidInputType(e) => write!(f, "invalid transaction input type: {}", e),
             InvalidProposedInput(e) => write!(f, "invalid proposed transaction input: {}", e),
@@ -86,6 +85,7 @@ impl fmt::Display for ValidationError {
             PayeeTookContributedFee => write!(f, "payee tried to take fee contribution for himself"),
             FeeContributionPaysOutputSizeIncrease => write!(f, "fee contribution pays for additional outputs"),
             FeeRateBelowMinimum =>  write!(f, "the fee rate of proposed transaction is below minimum"),
+            Parse => write!(f, "couldn't decode as PSBT or JSON",),
         }
     }
 }
@@ -95,7 +95,6 @@ impl std::error::Error for ValidationError {
         use InternalValidationError::*;
 
         match &self.internal {
-            Psbt(error) => Some(error),
             Io(error) => Some(error),
             InvalidInputType(error) => Some(error),
             InvalidProposedInput(error) => Some(error),
@@ -123,6 +122,7 @@ impl std::error::Error for ValidationError {
             PayeeTookContributedFee => None,
             FeeContributionPaysOutputSizeIncrease => None,
             FeeRateBelowMinimum => None,
+            Parse => None,
         }
     }
 }
@@ -210,3 +210,102 @@ impl std::error::Error for CreateRequestError {
 impl From<InternalCreateRequestError> for CreateRequestError {
     fn from(value: InternalCreateRequestError) -> Self { CreateRequestError(value) }
 }
+
+pub enum ResponseError {
+    // Well known errors with internal message for logs as String
+    WellKnown(WellKnownError, String),
+    // Don't display unknowns to end users, only debug logs
+    Unrecognized(String, String),
+
+    Validation(ValidationError),
+}
+
+impl ResponseError {
+    pub fn from_json(json: &str) -> Self {
+        use std::convert::TryInto;
+
+        use tinyjson::{JsonParser, JsonValue};
+
+        let parsed: JsonValue = json.parse().unwrap();
+        //.unwrap_or_else( |_| ResponseError::Validation(InternalValidationError::Parse.into()));
+        let maybe_code = parsed["errorCode"].get();
+        let maybe_message = parsed["message"].get();
+        if let (Some(error_code), Some(message)) = (maybe_code, maybe_message) {
+            let well_known_error = WellKnownError::from_str(&error_code);
+
+            if let Some(wk_error) = well_known_error {
+                ResponseError::WellKnown(wk_error, message.to_string())
+            } else {
+                ResponseError::Unrecognized(error_code.to_string(), message.to_string())
+            }
+        } else {
+            ResponseError::Validation(InternalValidationError::Parse.into())
+        }
+    }
+}
+
+impl From<InternalValidationError> for ResponseError {
+    fn from(value: InternalValidationError) -> Self {
+        Self::Validation(ValidationError { internal: value })
+    }
+}
+
+// It is imperative to carefully display pre-defined messages to end users and the details in debug.
+impl fmt::Display for ResponseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::WellKnown(e, _) => e.fmt(f),
+            // Don't display unknowns to end users, only debug logs
+            Self::Unrecognized(_, _) => write!(f, "The receiver sent an unrecognized error."),
+            Self::Validation(e) => write!(f, "The receiver sent an invalid response: {}", e),
+        }
+    }
+}
+
+impl fmt::Debug for ResponseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::WellKnown(e, msg) =>
+                write!(f, r#"Well known error: {{ "errorCode": "{}", "message": "{}" }}"#, e, msg),
+            Self::Unrecognized(code, msg) => write!(
+                f,
+                r#"Unrecognized error: {{ "errorCode": "{}", "message": "{}" }}"#,
+                code, msg
+            ),
+            Self::Validation(e) => write!(f, "Validation({:?})", e),
+        }
+    }
+}
+
+impl std::error::Error for ResponseError {}
+
+#[derive(Debug)]
+pub enum WellKnownError {
+    Unavailable,
+    NotEnoughMoney,
+    VersionUnsupported,
+    OriginalPsbtRejected,
+}
+
+impl WellKnownError {
+    pub fn from_str(s: &str) -> Option<Self> {
+        match s {
+            "unavailable" => Some(WellKnownError::Unavailable),
+            "not-enough-money" => Some(WellKnownError::NotEnoughMoney),
+            "version-unsupported" => Some(WellKnownError::VersionUnsupported),
+            "original-psbt-rejected" => Some(WellKnownError::OriginalPsbtRejected),
+            _ => None,
+        }
+    }
+}
+
+impl fmt::Display for WellKnownError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Unavailable => write!(f, "The payjoin endpoint is not available for now."),
+            Self::NotEnoughMoney => write!(f, "The receiver added some inputs but could not bump the fee of the payjoin proposal."),
+            Self::VersionUnsupported => write!(f, "This version of payjoin is not supported."),
+            Self::OriginalPsbtRejected => write!(f, "The receiver rejected the original PSBT."),
+        }
+    }
+}