Abstract creating v2 POST requests to common pub(crate) fns

Extracting the POST request to read from the pj directory is duplicated
in both the v2 sender and multiparty (ns1r) sender. This work introduces
a common utility method `create_request` used in both mods.

Author: arminsabouri

payjoin/src/send/multiparty/error.rs

@@ -6,7 +6,7 @@ use crate::hpke::HpkeError;
 use crate::ohttp::OhttpEncapsulationError;
 use crate::receive::ImplementationError;
 use crate::send::InternalProposalError;
-use crate::uri::url_ext::{ParseOhttpKeysParamError, ParseReceiverPubkeyParamError};
+use crate::uri::url_ext::ParseReceiverPubkeyParamError;
 
 #[derive(Debug)]
 pub struct CreateRequestError(InternalCreateRequestError);
@@ -16,10 +16,9 @@ pub(crate) enum InternalCreateRequestError {
     #[allow(dead_code)]
     Expired(std::time::SystemTime),
     MissingOhttpConfig,
-    OhttpEncapsulation(OhttpEncapsulationError),
-    Hpke(HpkeError),
     ParseReceiverPubkeyParam(ParseReceiverPubkeyParamError),
     Url(url::ParseError),
+    V2CreateRequest(crate::send::v2::CreateRequestError),
 }
 
 impl From<InternalCreateRequestError> for CreateRequestError {
@@ -35,10 +34,9 @@ impl std::error::Error for CreateRequestError {
         match &self.0 {
             InternalCreateRequestError::Expired(_) => None,
             InternalCreateRequestError::MissingOhttpConfig => None,
-            InternalCreateRequestError::OhttpEncapsulation(e) => Some(e),
-            InternalCreateRequestError::Hpke(e) => Some(e),
             InternalCreateRequestError::ParseReceiverPubkeyParam(e) => Some(e),
             InternalCreateRequestError::Url(e) => Some(e),
+            InternalCreateRequestError::V2CreateRequest(e) => Some(e),
         }
     }
 }
@@ -48,10 +46,7 @@ pub struct FinalizedError(InternalFinalizedError);
 
 #[derive(Debug)]
 pub(crate) enum InternalFinalizedError {
-    CreateRequest(CreateRequestError),
-    Encapsulation(OhttpEncapsulationError),
     Hpke(HpkeError),
-    ParseOhttp(ParseOhttpKeysParamError),
     InvalidSize,
     #[allow(dead_code)]
     FinalizePsbt(ImplementationError),
@@ -60,6 +55,7 @@ pub(crate) enum InternalFinalizedError {
     #[allow(dead_code)]
     UnexpectedStatusCode(http::StatusCode),
     Proposal(InternalProposalError),
+    Ohttp(OhttpEncapsulationError),
 }
 
 impl From<InternalFinalizedError> for FinalizedError {
@@ -73,16 +69,14 @@ impl Display for FinalizedError {
 impl std::error::Error for FinalizedError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match &self.0 {
-            InternalFinalizedError::CreateRequest(e) => Some(e),
-            InternalFinalizedError::Encapsulation(e) => Some(e),
             InternalFinalizedError::Hpke(e) => Some(e),
-            InternalFinalizedError::ParseOhttp(_e) => None,
             InternalFinalizedError::InvalidSize => None,
             InternalFinalizedError::FinalizePsbt(_) => None,
             InternalFinalizedError::MissingResponse => None,
             InternalFinalizedError::Psbt(e) => Some(e),
             InternalFinalizedError::UnexpectedStatusCode(_) => None,
             InternalFinalizedError::Proposal(e) => Some(e),
+            InternalFinalizedError::Ohttp(e) => Some(e),
         }
     }
 }

payjoin/src/send/multiparty/mod.rs

@@ -6,12 +6,13 @@ use error::{
 use serde::{Deserialize, Serialize};
 use url::Url;
 
-use super::v2::{self, EncapsulationError, HpkeContext};
+use super::v2::{self, extract_request, EncapsulationError, HpkeContext};
 use super::{serialize_url, AdditionalFeeContribution, BuildSenderError, InternalResult};
 use crate::hpke::decrypt_message_b;
 use crate::ohttp::ohttp_decapsulate;
 use crate::receive::ImplementationError;
 use crate::send::v2::V2PostContext;
+use crate::uri::UrlExt;
 use crate::{PjUri, Request};
 
 mod error;
@@ -36,55 +37,43 @@ impl Sender {
         &self,
         ohttp_relay: Url,
     ) -> Result<(Request, PostContext), CreateRequestError> {
-        use crate::hpke::encrypt_message_a;
-        use crate::ohttp::ohttp_encapsulate;
-        use crate::send::PsbtContext;
-        use crate::uri::UrlExt;
-        let url = self.0.endpoint().clone();
-        if let Ok(expiry) = url.exp() {
-            if std::time::SystemTime::now() > expiry {
-                return Err(InternalCreateRequestError::Expired(expiry).into());
-            }
-        }
         let rs = self
             .0
             .extract_rs_pubkey()
             .map_err(InternalCreateRequestError::ParseReceiverPubkeyParam)?;
+        let mut ohttp_keys = self
+            .0
+            .endpoint()
+            .ohttp()
+            .map_err(|_| InternalCreateRequestError::MissingOhttpConfig)?;
         let body = serialize_v2_body(
             &self.0.v1.psbt,
             self.0.v1.disable_output_substitution,
             self.0.v1.fee_contribution,
             self.0.v1.min_fee_rate,
         )?;
-        let hpke_ctx = HpkeContext::new(rs, &self.0.reply_key);
-        let body = encrypt_message_a(
+        let (request, ohttp_ctx) = extract_request(
+            ohttp_relay,
+            self.0.reply_key.clone(),
             body,
-            &hpke_ctx.reply_pair.public_key().clone(),
-            &hpke_ctx.receiver.clone(),
+            self.0.endpoint().clone(),
+            rs.clone(),
+            &mut ohttp_keys,
         )
-        .map_err(InternalCreateRequestError::Hpke)?;
-        let mut ohttp = self
-            .0
-            .v1
-            .endpoint
-            .ohttp()
-            .map_err(|_| InternalCreateRequestError::MissingOhttpConfig)?;
-        let (body, ohttp_ctx) = ohttp_encapsulate(&mut ohttp, "POST", url.as_str(), Some(&body))
-            .map_err(InternalCreateRequestError::OhttpEncapsulation)?;
-
+        .map_err(InternalCreateRequestError::V2CreateRequest)?;
         let v2_post_ctx = V2PostContext {
             endpoint: self.0.endpoint().clone(),
-            psbt_ctx: PsbtContext {
+            psbt_ctx: crate::send::PsbtContext {
                 original_psbt: self.0.v1.psbt.clone(),
                 disable_output_substitution: self.0.v1.disable_output_substitution,
                 fee_contribution: self.0.v1.fee_contribution,
                 payee: self.0.v1.payee.clone(),
                 min_fee_rate: self.0.v1.min_fee_rate,
             },
-            hpke_ctx,
+            hpke_ctx: HpkeContext::new(rs, &self.0.reply_key),
             ohttp_ctx,
         };
-        Ok((Request::new_v2(&ohttp_relay, &body), PostContext(v2_post_ctx)))
+        Ok((request, PostContext(v2_post_ctx)))
     }
 }
 
@@ -143,8 +132,8 @@ impl GetContext {
         let response_array: &[u8; crate::directory::ENCAPSULATED_MESSAGE_BYTES] =
             response.try_into().map_err(|_| InternalFinalizedError::InvalidSize)?;
 
-        let response = ohttp_decapsulate(ohttp_ctx, response_array)
-            .map_err(InternalFinalizedError::Encapsulation)?;
+        let response =
+            ohttp_decapsulate(ohttp_ctx, response_array).map_err(InternalFinalizedError::Ohttp)?;
         let body = match response.status() {
             http::StatusCode::OK => Some(response.body().to_vec()),
             http::StatusCode::ACCEPTED => None,
@@ -185,35 +174,22 @@ impl FinalizeContext {
     pub fn extract_req(
         &self,
         ohttp_relay: Url,
-    ) -> Result<(Request, ohttp::ClientResponse), FinalizedError> {
-        use crate::hpke::encrypt_message_a;
-        use crate::ohttp::ohttp_encapsulate;
-        use crate::uri::UrlExt;
-
-        let hpke_ctx = self.hpke_ctx.clone();
-        let directory_url = self.directory_url.clone();
-        // TODO: check if request is expired off the directory url
-
-        // The query params are not needed for the final request
-        // The reciever will ignore them. PSBT is all that is needed.
-        let body = serialize_v2_body(
-            &self.psbt,
-            false, // disable output substitution
-            None,  // fee contribution
-            FeeRate::BROADCAST_MIN,
-        )
-        .map_err(InternalFinalizedError::CreateRequest)?;
-        let body = encrypt_message_a(
+    ) -> Result<(Request, ohttp::ClientResponse), CreateRequestError> {
+        let reply_key = self.hpke_ctx.reply_pair.secret_key();
+        let body = serialize_v2_body(&self.psbt, false, None, FeeRate::BROADCAST_MIN)?;
+        let mut ohttp_keys = self
+            .directory_url
+            .ohttp()
+            .map_err(|_| InternalCreateRequestError::MissingOhttpConfig)?;
+        let (request, ohttp_ctx) = extract_request(
+            ohttp_relay,
+            reply_key.clone(),
             body,
-            &hpke_ctx.reply_pair.public_key().clone(),
-            &hpke_ctx.receiver.clone(),
+            self.directory_url.clone(),
+            self.hpke_ctx.receiver.clone(),
+            &mut ohttp_keys,
         )
-        .map_err(InternalFinalizedError::Hpke)?;
-        let mut ohttp = directory_url.ohttp().map_err(InternalFinalizedError::ParseOhttp)?;
-        let (body, ohttp_ctx) =
-            ohttp_encapsulate(&mut ohttp, "POST", directory_url.as_str(), Some(&body))
-                .map_err(InternalFinalizedError::Encapsulation)?;
-        let request = Request::new_v2(&ohttp_relay, &body);
+        .map_err(InternalCreateRequestError::V2CreateRequest)?;
         Ok((request, ohttp_ctx))
     }
 

payjoin/src/send/v2/mod.rs

@@ -24,6 +24,7 @@
 use bitcoin::hashes::{sha256, Hash};
 pub use error::{CreateRequestError, EncapsulationError};
 use error::{InternalCreateRequestError, InternalEncapsulationError};
+use ohttp::ClientResponse;
 use serde::{Deserialize, Serialize};
 use url::Url;
 
@@ -33,7 +34,7 @@ use crate::hpke::{decrypt_message_b, encrypt_message_a, HpkeSecretKey};
 use crate::ohttp::{ohttp_decapsulate, ohttp_encapsulate};
 use crate::send::v1;
 use crate::uri::{ShortId, UrlExt};
-use crate::{HpkeKeyPair, HpkePublicKey, IntoUrl, PjUri, Request};
+use crate::{HpkeKeyPair, HpkePublicKey, IntoUrl, OhttpKeys, PjUri, Request};
 
 mod error;
 
@@ -138,37 +139,34 @@ impl Sender {
         &self,
         ohttp_relay: Url,
     ) -> Result<(Request, V2PostContext), CreateRequestError> {
-        use crate::hpke::encrypt_message_a;
-        use crate::ohttp::ohttp_encapsulate;
-        use crate::send::PsbtContext;
-        use crate::uri::UrlExt;
         if let Ok(expiry) = self.v1.endpoint.exp() {
             if std::time::SystemTime::now() > expiry {
                 return Err(InternalCreateRequestError::Expired(expiry).into());
             }
         }
-        let rs = self.extract_rs_pubkey()?;
-        let url = self.v1.endpoint.clone();
+
+        let mut ohttp_keys = self
+            .v1
+            .endpoint()
+            .ohttp()
+            .map_err(|_| InternalCreateRequestError::MissingOhttpConfig)?;
         let body = serialize_v2_body(
             &self.v1.psbt,
             self.v1.disable_output_substitution,
             self.v1.fee_contribution,
             self.v1.min_fee_rate,
         )?;
-        let hpke_ctx = HpkeContext::new(rs, &self.reply_key);
-        let body = encrypt_message_a(
+        let (request, ohttp_ctx) = extract_request(
+            ohttp_relay,
+            self.reply_key.clone(),
             body,
-            &hpke_ctx.reply_pair.public_key().clone(),
-            &hpke_ctx.receiver.clone(),
-        )
-        .map_err(InternalCreateRequestError::Hpke)?;
-        let mut ohttp =
-            self.v1.endpoint.ohttp().map_err(|_| InternalCreateRequestError::MissingOhttpConfig)?;
-        let (body, ohttp_ctx) = ohttp_encapsulate(&mut ohttp, "POST", url.as_str(), Some(&body))
-            .map_err(InternalCreateRequestError::OhttpEncapsulation)?;
-        log::debug!("ohttp_relay_url: {:?}", ohttp_relay);
+            self.v1.endpoint.clone(),
+            self.extract_rs_pubkey()?,
+            &mut ohttp_keys,
+        )?;
+        let rs = self.extract_rs_pubkey()?;
         Ok((
-            Request::new_v2(&ohttp_relay, &body),
+            request,
             V2PostContext {
                 endpoint: self.v1.endpoint.clone(),
                 psbt_ctx: PsbtContext {
@@ -178,7 +176,7 @@ impl Sender {
                     payee: self.v1.payee.clone(),
                     min_fee_rate: self.v1.min_fee_rate,
                 },
-                hpke_ctx,
+                hpke_ctx: HpkeContext::new(rs, &self.reply_key),
                 ohttp_ctx,
             },
         ))
@@ -193,6 +191,31 @@ impl Sender {
     pub fn endpoint(&self) -> &Url { self.v1.endpoint() }
 }
 
+pub(crate) fn extract_request(
+    ohttp_relay: Url,
+    reply_key: HpkeSecretKey,
+    body: Vec<u8>,
+    url: Url,
+    receiver_pubkey: HpkePublicKey,
+    ohttp_keys: &mut OhttpKeys,
+) -> Result<(Request, ClientResponse), CreateRequestError> {
+    use crate::hpke::encrypt_message_a;
+    use crate::ohttp::ohttp_encapsulate;
+    let hpke_ctx = HpkeContext::new(receiver_pubkey, &reply_key);
+    let body = encrypt_message_a(
+        body,
+        &hpke_ctx.reply_pair.public_key().clone(),
+        &hpke_ctx.receiver.clone(),
+    )
+    .map_err(InternalCreateRequestError::Hpke)?;
+
+    let (body, ohttp_ctx) = ohttp_encapsulate(ohttp_keys, "POST", url.as_str(), Some(&body))
+        .map_err(InternalCreateRequestError::OhttpEncapsulation)?;
+    log::debug!("ohttp_relay_url: {:?}", ohttp_relay);
+    let request = Request::new_v2(&ohttp_relay, &body);
+    Ok((request, ohttp_ctx))
+}
+
 pub(crate) fn serialize_v2_body(
     psbt: &Psbt,
     disable_output_substitution: bool,