Move shared response processing code to ohttp.rs

The `process_res` methods across send and receive have a lot of shared
code that can be extracted into reusable functions. `process_get_res`
and `process_post_res` essentially do the same thing, and could
conceivably be combined into one function. They were kept separate
because "202 Accepted" is not a valid response for POST requests.

Author: spacebear21

payjoin/src/ohttp.rs

@@ -52,6 +52,47 @@ pub fn ohttp_encapsulate(
     Ok((buffer, ohttp_ctx))
 }
 
+pub enum DirectoryResponseError {
+    InvalidSize(usize),
+    OhttpDecapsulation(OhttpEncapsulationError),
+    UnexpectedStatusCode(http::StatusCode),
+}
+
+pub fn process_get_res(
+    res: &[u8],
+    ohttp_context: ohttp::ClientResponse,
+) -> Result<Option<Vec<u8>>, DirectoryResponseError> {
+    let response = process_ohttp_res(res, ohttp_context)?;
+    match response.status() {
+        http::StatusCode::OK => Ok(Some(response.body().to_vec())),
+        http::StatusCode::ACCEPTED => Ok(None),
+        status_code => Err(DirectoryResponseError::UnexpectedStatusCode(status_code)),
+    }
+}
+
+pub fn process_post_res(
+    res: &[u8],
+    ohttp_context: ohttp::ClientResponse,
+) -> Result<(), DirectoryResponseError> {
+    let response = process_ohttp_res(res, ohttp_context)?;
+    match response.status() {
+        http::StatusCode::OK => Ok(()),
+        status_code => Err(DirectoryResponseError::UnexpectedStatusCode(status_code)),
+    }
+}
+
+fn process_ohttp_res(
+    res: &[u8],
+    ohttp_context: ohttp::ClientResponse,
+) -> Result<http::Response<Vec<u8>>, DirectoryResponseError> {
+    let response_array: &[u8; crate::directory::ENCAPSULATED_MESSAGE_BYTES] =
+        res.try_into().map_err(|_| DirectoryResponseError::InvalidSize(res.len()))?;
+    log::trace!("decapsulating directory response");
+    let res = ohttp_decapsulate(ohttp_context, response_array)
+        .map_err(DirectoryResponseError::OhttpDecapsulation)?;
+    Ok(res)
+}
+
 /// decapsulate ohttp, bhttp response and return http response body and status code
 pub fn ohttp_decapsulate(
     res_ctx: ohttp::ClientResponse,

payjoin/src/receive/v2/error.rs

@@ -3,7 +3,7 @@ use std::error;
 
 use super::Error::V2;
 use crate::hpke::HpkeError;
-use crate::ohttp::OhttpEncapsulationError;
+use crate::ohttp::{DirectoryResponseError, OhttpEncapsulationError};
 use crate::receive::error::Error;
 
 /// Error that may occur during a v2 session typestate change
@@ -21,6 +21,24 @@ impl From<InternalSessionError> for Error {
     fn from(e: InternalSessionError) -> Self { V2(e.into()) }
 }
 
+impl From<DirectoryResponseError> for SessionError {
+    fn from(value: DirectoryResponseError) -> Self {
+        match value {
+            DirectoryResponseError::InvalidSize(e) =>
+                InternalSessionError::UnexpectedResponseSize(e),
+            DirectoryResponseError::OhttpDecapsulation(e) =>
+                InternalSessionError::OhttpEncapsulation(e),
+            DirectoryResponseError::UnexpectedStatusCode(e) =>
+                InternalSessionError::UnexpectedStatusCode(e),
+        }
+        .into()
+    }
+}
+
+impl From<DirectoryResponseError> for Error {
+    fn from(value: DirectoryResponseError) -> Self { V2(value.into()) }
+}
+
 #[derive(Debug)]
 pub(crate) enum InternalSessionError {
     /// Url parsing failed

payjoin/src/receive/v2/mod.rs

@@ -17,7 +17,9 @@ use super::{
     v1, InternalPayloadError, JsonReply, OutputSubstitutionError, ReplyableError, SelectionError,
 };
 use crate::hpke::{decrypt_message_a, encrypt_message_b, HpkeKeyPair, HpkePublicKey};
-use crate::ohttp::{ohttp_decapsulate, ohttp_encapsulate, OhttpEncapsulationError, OhttpKeys};
+use crate::ohttp::{
+    ohttp_encapsulate, process_get_res, process_post_res, OhttpEncapsulationError, OhttpKeys,
+};
 use crate::output_substitution::OutputSubstitution;
 use crate::persist::Persister;
 use crate::receive::{parse_payload, InputPair};
@@ -180,23 +182,15 @@ impl Receiver<WithContext> {
         body: &[u8],
         context: ohttp::ClientResponse,
     ) -> Result<Option<Receiver<UncheckedProposal>>, Error> {
-        let response_array: &[u8; crate::directory::ENCAPSULATED_MESSAGE_BYTES] =
-            body.try_into()
-                .map_err(|_| InternalSessionError::UnexpectedResponseSize(body.len()))?;
-        log::trace!("decapsulating directory response");
-        let response = ohttp_decapsulate(context, response_array)
-            .map_err(InternalSessionError::OhttpEncapsulation)?;
-        if response.body().is_empty() {
-            log::debug!("response is empty");
-            return Ok(None);
-        }
-        match String::from_utf8(response.body().to_vec()) {
+        let body = match process_get_res(body, context)? {
+            Some(body) => body,
+            None => return Ok(None),
+        };
+        match String::from_utf8(body.clone()) {
             // V1 response bodies are utf8 plaintext
             Ok(response) => Ok(Some(Receiver { state: self.extract_proposal_from_v1(response)? })),
             // V2 response bodies are encrypted binary
-            Err(_) => Ok(Some(Receiver {
-                state: self.extract_proposal_from_v2(response.body().to_vec())?,
-            })),
+            Err(_) => Ok(Some(Receiver { state: self.extract_proposal_from_v2(body)? })),
         }
     }
 
@@ -350,16 +344,7 @@ impl Receiver<UncheckedProposal> {
         body: &[u8],
         context: ohttp::ClientResponse,
     ) -> Result<(), SessionError> {
-        let response_array: &[u8; crate::directory::ENCAPSULATED_MESSAGE_BYTES] =
-            body.try_into()
-                .map_err(|_| InternalSessionError::UnexpectedResponseSize(body.len()))?;
-        let response = ohttp_decapsulate(context, response_array)
-            .map_err(InternalSessionError::OhttpEncapsulation)?;
-
-        match response.status() {
-            http::StatusCode::OK => Ok(()),
-            _ => Err(InternalSessionError::UnexpectedStatusCode(response.status()).into()),
-        }
+        process_post_res(body, context).map_err(Into::into)
     }
 }
 
@@ -648,15 +633,7 @@ impl Receiver<PayjoinProposal> {
         res: &[u8],
         ohttp_context: ohttp::ClientResponse,
     ) -> Result<(), Error> {
-        let response_array: &[u8; crate::directory::ENCAPSULATED_MESSAGE_BYTES] =
-            res.try_into().map_err(|_| InternalSessionError::UnexpectedResponseSize(res.len()))?;
-        let res = ohttp_decapsulate(ohttp_context, response_array)
-            .map_err(InternalSessionError::OhttpEncapsulation)?;
-        if res.status().is_success() {
-            Ok(())
-        } else {
-            Err(InternalSessionError::UnexpectedStatusCode(res.status()).into())
-        }
+        process_post_res(res, ohttp_context).map_err(Into::into)
     }
 }
 

payjoin/src/send/v2/error.rs

@@ -1,5 +1,7 @@
 use core::fmt;
 
+use super::ResponseError;
+use crate::ohttp::DirectoryResponseError;
 use crate::uri::url_ext::ParseReceiverPubkeyParamError;
 
 /// Error returned when request could not be created.
@@ -120,3 +122,23 @@ impl From<InternalEncapsulationError> for super::ResponseError {
         )
     }
 }
+
+impl From<DirectoryResponseError> for EncapsulationError {
+    fn from(value: DirectoryResponseError) -> Self {
+        match value {
+            DirectoryResponseError::InvalidSize(e) => InternalEncapsulationError::InvalidSize(e),
+            DirectoryResponseError::OhttpDecapsulation(e) => InternalEncapsulationError::Ohttp(e),
+            DirectoryResponseError::UnexpectedStatusCode(e) =>
+                InternalEncapsulationError::UnexpectedStatusCode(e),
+        }
+        .into()
+    }
+}
+
+impl From<DirectoryResponseError> for ResponseError {
+    fn from(value: DirectoryResponseError) -> Self {
+        ResponseError::Validation(
+            super::InternalValidationError::V2Encapsulation(value.into()).into(),
+        )
+    }
+}

payjoin/src/send/v2/mod.rs

@@ -32,7 +32,7 @@ use url::Url;
 use super::error::BuildSenderError;
 use super::*;
 use crate::hpke::{decrypt_message_b, encrypt_message_a, HpkeSecretKey};
-use crate::ohttp::{ohttp_decapsulate, ohttp_encapsulate};
+use crate::ohttp::{ohttp_encapsulate, process_get_res, process_post_res};
 use crate::persist::Persister;
 use crate::send::v1;
 use crate::uri::{ShortId, UrlExt};
@@ -325,24 +325,14 @@ impl Sender<V2PostContext> {
         self,
         response: &[u8],
     ) -> Result<Sender<V2GetContext>, EncapsulationError> {
-        let response_array: &[u8; crate::directory::ENCAPSULATED_MESSAGE_BYTES] = response
-            .try_into()
-            .map_err(|_| InternalEncapsulationError::InvalidSize(response.len()))?;
-        let response = ohttp_decapsulate(self.state.ohttp_ctx, response_array)
-            .map_err(InternalEncapsulationError::Ohttp)?;
-        match response.status() {
-            http::StatusCode::OK => {
-                // return OK with new Typestate
-                Ok(Sender {
-                    state: V2GetContext {
-                        endpoint: self.state.endpoint,
-                        psbt_ctx: self.state.psbt_ctx,
-                        hpke_ctx: self.state.hpke_ctx,
-                    },
-                })
-            }
-            _ => Err(InternalEncapsulationError::UnexpectedStatusCode(response.status()))?,
-        }
+        process_post_res(response, self.state.ohttp_ctx)?;
+        Ok(Sender {
+            state: V2GetContext {
+                endpoint: self.state.endpoint,
+                psbt_ctx: self.state.psbt_ctx,
+                hpke_ctx: self.state.hpke_ctx,
+            },
+        })
     }
 }
 
@@ -404,16 +394,9 @@ impl Sender<V2GetContext> {
         response: &[u8],
         ohttp_ctx: ohttp::ClientResponse,
     ) -> Result<Option<Psbt>, ResponseError> {
-        let response_array: &[u8; crate::directory::ENCAPSULATED_MESSAGE_BYTES] = response
-            .try_into()
-            .map_err(|_| InternalEncapsulationError::InvalidSize(response.len()))?;
-
-        let response = ohttp_decapsulate(ohttp_ctx, response_array)
-            .map_err(InternalEncapsulationError::Ohttp)?;
-        let body = match response.status() {
-            http::StatusCode::OK => response.body().to_vec(),
-            http::StatusCode::ACCEPTED => return Ok(None),
-            _ => return Err(InternalEncapsulationError::UnexpectedStatusCode(response.status()))?,
+        let body = match process_get_res(response, ohttp_ctx)? {
+            Some(body) => body,
+            None => return Ok(None),
         };
         let psbt = decrypt_message_b(
             &body,