align charge error classification with mpp status semantics

Author: betterclever

crates/tempo-common/src/error.rs

@@ -242,10 +242,10 @@ pub enum PaymentError {
     },
     #[error("Payment rejected by server: {reason}")]
     PaymentRejected { reason: String, status_code: u16 },
-    #[error("Paid request failed with upstream application error: {reason}")]
-    UpstreamApplicationError { reason: String, status_code: u16 },
-    #[error("Paid request failed with upstream server error: {reason}")]
-    UpstreamServerError { reason: String, status_code: u16 },
+    #[error("Payment response failed at application layer: {reason}")]
+    PaymentResponseApplicationError { reason: String, status_code: u16 },
+    #[error("Payment response failed at server layer: {reason}")]
+    PaymentResponseServerError { reason: String, status_code: u16 },
     #[error("Transaction reverted: {0}")]
     TransactionReverted(String),
     #[error("Channel {channel_id} not found on {network}")]
@@ -415,26 +415,26 @@ mod tests {
     }
 
     #[test]
-    fn test_upstream_application_error_display() {
-        let err = PaymentError::UpstreamApplicationError {
+    fn test_payment_response_application_error_display() {
+        let err = PaymentError::PaymentResponseApplicationError {
             reason: "missing query parameter".to_string(),
             status_code: 400,
         };
         assert_eq!(
             err.to_string(),
-            "Paid request failed with upstream application error: missing query parameter"
+            "Payment response failed at application layer: missing query parameter"
         );
     }
 
     #[test]
-    fn test_upstream_server_error_display() {
-        let err = PaymentError::UpstreamServerError {
+    fn test_payment_response_server_error_display() {
+        let err = PaymentError::PaymentResponseServerError {
             reason: "gateway timeout".to_string(),
             status_code: 502,
         };
         assert_eq!(
             err.to_string(),
-            "Paid request failed with upstream server error: gateway timeout"
+            "Payment response failed at server layer: gateway timeout"
         );
     }
 

crates/tempo-request/src/payment/charge.rs

@@ -274,7 +274,7 @@ async fn submit_credential(
 /// Maximum characters to include in a payment rejection reason.
 const MAX_REJECTION_REASON_CHARS: usize = 500;
 
-/// Parse a non-200 response after payment submission into a descriptive error.
+/// Parse an error response after credential submission into a descriptive error.
 fn parse_payment_rejection(response: &HttpResponse) -> PaymentError {
     let raw_reason = match response.body_string() {
         Ok(body) if !body.trim().is_empty() => {
@@ -285,17 +285,19 @@ fn parse_payment_rejection(response: &HttpResponse) -> PaymentError {
     let reason = sanitize_for_terminal(&raw_reason);
 
     match response.status_code {
-        500..=599 => PaymentError::UpstreamServerError {
+        402 => PaymentError::PaymentRejected {
             reason,
             status_code: response.status_code,
         },
-        400..=499 if !is_retriable_payment_rejection(response) => {
-            PaymentError::UpstreamApplicationError {
-                reason,
-                status_code: response.status_code,
-            }
-        }
-        _ => PaymentError::PaymentRejected {
+        500..=599 => PaymentError::PaymentResponseServerError {
+            reason,
+            status_code: response.status_code,
+        },
+        400..=499 => PaymentError::PaymentResponseApplicationError {
+            reason,
+            status_code: response.status_code,
+        },
+        _ => PaymentError::PaymentResponseServerError {
             reason,
             status_code: response.status_code,
         },
@@ -325,49 +327,75 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_payment_rejection_classifies_upstream_application_error() {
+    fn test_parse_payment_rejection_classifies_application_response_error() {
         let body = br#"{"error":"invalid_request","message":"missing input"}"#;
         let resp = HttpResponse::for_test(400, body);
         let err = parse_payment_rejection(&resp);
         match err {
-            PaymentError::UpstreamApplicationError {
+            PaymentError::PaymentResponseApplicationError {
                 reason,
                 status_code,
             } => {
                 assert!(reason.contains("invalid_request"));
                 assert_eq!(status_code, 400);
             }
-            _ => panic!("expected UpstreamApplicationError"),
+            _ => panic!("expected PaymentResponseApplicationError"),
         }
     }
 
     #[test]
-    fn test_parse_payment_rejection_classifies_upstream_server_error() {
+    fn test_parse_payment_rejection_classifies_server_response_error() {
         let body = b"Transaction reverted";
         let resp = HttpResponse::for_test(500, body);
         let err = parse_payment_rejection(&resp);
         match err {
-            PaymentError::UpstreamServerError {
+            PaymentError::PaymentResponseServerError {
                 reason,
                 status_code,
             } => {
                 assert_eq!(reason, "Transaction reverted");
                 assert_eq!(status_code, 500);
             }
-            _ => panic!("expected UpstreamServerError"),
+            _ => panic!("expected PaymentResponseServerError"),
         }
     }
 
+    #[test]
+    fn test_parse_payment_rejection_classifies_401_as_application_response_error() {
+        let resp = HttpResponse::for_test(401, b"login required");
+        let err = parse_payment_rejection(&resp);
+        assert!(matches!(
+            err,
+            PaymentError::PaymentResponseApplicationError {
+                status_code: 401,
+                ..
+            }
+        ));
+    }
+
+    #[test]
+    fn test_parse_payment_rejection_classifies_403_as_application_response_error() {
+        let resp = HttpResponse::for_test(403, b"policy denied");
+        let err = parse_payment_rejection(&resp);
+        assert!(matches!(
+            err,
+            PaymentError::PaymentResponseApplicationError {
+                status_code: 403,
+                ..
+            }
+        ));
+    }
+
     #[test]
     fn test_parse_payment_rejection_truncated() {
         let body = "a".repeat(600);
         let resp = HttpResponse::for_test(500, body.as_bytes());
         let err = parse_payment_rejection(&resp);
         match err {
-            PaymentError::UpstreamServerError { reason, .. } => {
+            PaymentError::PaymentResponseServerError { reason, .. } => {
                 assert_eq!(reason.len(), MAX_REJECTION_REASON_CHARS);
             }
-            _ => panic!("expected UpstreamServerError"),
+            _ => panic!("expected PaymentResponseServerError"),
         }
     }
 
@@ -376,10 +404,10 @@ mod tests {
         let resp = HttpResponse::for_test(500, b"");
         let err = parse_payment_rejection(&resp);
         match err {
-            PaymentError::UpstreamServerError { reason, .. } => {
+            PaymentError::PaymentResponseServerError { reason, .. } => {
                 assert_eq!(reason, "HTTP 500");
             }
-            _ => panic!("expected UpstreamServerError"),
+            _ => panic!("expected PaymentResponseServerError"),
         }
     }
 
@@ -388,10 +416,10 @@ mod tests {
         let resp = HttpResponse::for_test(503, b"   \n\t  ");
         let err = parse_payment_rejection(&resp);
         match err {
-            PaymentError::UpstreamServerError { reason, .. } => {
+            PaymentError::PaymentResponseServerError { reason, .. } => {
                 assert_eq!(reason, "HTTP 503");
             }
-            _ => panic!("expected UpstreamServerError"),
+            _ => panic!("expected PaymentResponseServerError"),
         }
     }
 
@@ -400,10 +428,10 @@ mod tests {
         let resp = HttpResponse::for_test(500, &[0xff, 0xfe, 0xfd]);
         let err = parse_payment_rejection(&resp);
         match err {
-            PaymentError::UpstreamServerError { reason, .. } => {
+            PaymentError::PaymentResponseServerError { reason, .. } => {
                 assert_eq!(reason, "HTTP 500");
             }
-            _ => panic!("expected UpstreamServerError"),
+            _ => panic!("expected PaymentResponseServerError"),
         }
     }
 
@@ -416,13 +444,19 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_payment_rejection_keeps_payment_proof_invalid_as_payment_rejected() {
+    fn test_parse_payment_rejection_classifies_non_402_payment_wrapper_as_application_error() {
         let resp = HttpResponse::for_test(
             400,
             br#"{"error":"payment_proof_invalid","message":"invalid payment proof"}"#,
         );
         let err = parse_payment_rejection(&resp);
-        assert!(matches!(err, PaymentError::PaymentRejected { .. }));
+        assert!(matches!(
+            err,
+            PaymentError::PaymentResponseApplicationError {
+                status_code: 400,
+                ..
+            }
+        ));
     }
 
     #[test]