Separate send::{v1,v2} modules

This reduces the number of feature gates and works toward a crate
where the features are additive and potentially both available
at the same time.

Right now they're still mutually exclusive (v1 is enabled by not(v2))

Author: DanGould

payjoin-cli/src/app/mod.rs

@@ -8,7 +8,6 @@ use bitcoincore_rpc::bitcoin::Amount;
 use bitcoincore_rpc::RpcApi;
 use payjoin::bitcoin::psbt::Psbt;
 use payjoin::receive::InputPair;
-use payjoin::send::Sender;
 use payjoin::{bitcoin, PjUri};
 
 pub mod config;
@@ -31,7 +30,7 @@ pub trait App {
     async fn send_payjoin(&self, bip21: &str, fee_rate: &f32) -> Result<()>;
     async fn receive_payjoin(self, amount_arg: &str) -> Result<()>;
 
-    fn create_pj_request(&self, uri: &PjUri, fee_rate: &f32) -> Result<Sender> {
+    fn create_original_psbt(&self, uri: &PjUri, fee_rate: &f32) -> Result<Psbt> {
         let amount = uri.amount.ok_or_else(|| anyhow!("please specify the amount in the Uri"))?;
 
         // wallet_create_funded_psbt requires a HashMap<address: String, Amount>
@@ -67,11 +66,7 @@ pub trait App {
             .psbt;
         let psbt = Psbt::from_str(&psbt).with_context(|| "Failed to load PSBT from base64")?;
         log::debug!("Original psbt: {:#?}", psbt);
-        let req_ctx = payjoin::send::SenderBuilder::new(psbt, uri.clone())
-            .build_recommended(fee_rate)
-            .with_context(|| "Failed to build payjoin request")?;
-
-        Ok(req_ctx)
+        Ok(psbt)
     }
 
     fn process_pj_response(&self, psbt: Psbt) -> Result<bitcoin::Txid> {

payjoin-cli/src/app/v1.rs

@@ -16,6 +16,7 @@ use hyper_util::rt::TokioIo;
 use payjoin::bitcoin::psbt::Psbt;
 use payjoin::bitcoin::{self, FeeRate};
 use payjoin::receive::{PayjoinProposal, UncheckedProposal};
+use payjoin::send::v1::SenderBuilder;
 use payjoin::{Error, PjUriBuilder, Uri, UriExt};
 use tokio::net::TcpListener;
 
@@ -72,7 +73,13 @@ impl AppTrait for App {
             Uri::try_from(bip21).map_err(|e| anyhow!("Failed to create URI from BIP21: {}", e))?;
         let uri = uri.assume_checked();
         let uri = uri.check_pj_supported().map_err(|_| anyhow!("URI does not support Payjoin"))?;
-        let (req, ctx) = self.create_pj_request(&uri, fee_rate)?.extract_v1()?;
+        let psbt = self.create_original_psbt(&uri, fee_rate)?;
+        let fee_rate_sat_per_kwu = fee_rate * 250.0_f32;
+        let fee_rate = FeeRate::from_sat_per_kwu(fee_rate_sat_per_kwu.ceil() as u64);
+        let (req, ctx) = SenderBuilder::new(psbt, uri.clone())
+            .build_recommended(fee_rate)
+            .with_context(|| "Failed to build payjoin request")?
+            .extract_v1()?;
         let http = http_agent()?;
         let body = String::from_utf8(req.body.clone()).unwrap();
         println!("Sending fallback request to {}", &req.url);

payjoin-cli/src/app/v2.rs

@@ -7,7 +7,7 @@ use payjoin::bitcoin::consensus::encode::serialize_hex;
 use payjoin::bitcoin::psbt::Psbt;
 use payjoin::bitcoin::{Amount, FeeRate};
 use payjoin::receive::v2::Receiver;
-use payjoin::send::Sender;
+use payjoin::send::v2::{Sender, SenderBuilder};
 use payjoin::{bitcoin, Error, Uri};
 use tokio::signal;
 use tokio::sync::watch;
@@ -65,7 +65,12 @@ impl AppTrait for App {
         let req_ctx = match self.db.get_send_session(url)? {
             Some(send_session) => send_session,
             None => {
-                let mut req_ctx = self.create_pj_request(&uri, fee_rate)?;
+                let psbt = self.create_original_psbt(&uri, fee_rate)?;
+                let fee_rate_sat_per_kwu = fee_rate * 250.0_f32;
+                let fee_rate = FeeRate::from_sat_per_kwu(fee_rate_sat_per_kwu.ceil() as u64);
+                let mut req_ctx = SenderBuilder::new(psbt, uri.clone())
+                    .build_recommended(fee_rate)
+                    .with_context(|| "Failed to build payjoin request")?;
                 self.db.insert_send_session(&mut req_ctx, url)?;
                 req_ctx
             }
@@ -192,7 +197,7 @@ impl App {
         Ok(())
     }
 
-    async fn long_poll_post(&self, req_ctx: &mut payjoin::send::Sender) -> Result<Psbt> {
+    async fn long_poll_post(&self, req_ctx: &mut Sender) -> Result<Psbt> {
         match req_ctx.extract_v2(self.config.ohttp_relay.clone()) {
             Ok((req, ctx)) => {
                 println!("Posting Original PSBT Payload request...");

payjoin-cli/src/db/v2.rs

@@ -1,6 +1,6 @@
 use bitcoincore_rpc::jsonrpc::serde_json;
 use payjoin::receive::v2::Receiver;
-use payjoin::send::Sender;
+use payjoin::send::v2::Sender;
 use sled::{IVec, Tree};
 use url::Url;
 

payjoin/src/send/error.rs

@@ -4,9 +4,6 @@ use bitcoin::locktime::absolute::LockTime;
 use bitcoin::transaction::Version;
 use bitcoin::{AddressType, Sequence};
 
-#[cfg(feature = "v2")]
-use crate::uri::url_ext::ParseReceiverPubkeyParamError;
-
 /// Error building a Sender from a SenderBuilder.
 ///
 /// This error is unrecoverable.
@@ -84,71 +81,6 @@ impl std::error::Error for BuildSenderError {
     }
 }
 
-/// Error returned when request could not be created.
-///
-/// This error can currently only happen due to programmer mistake.
-/// `unwrap()`ing it is thus considered OK in Rust but you may achieve nicer message by displaying
-/// it.
-#[derive(Debug)]
-#[cfg(feature = "v2")]
-pub struct CreateRequestError(InternalCreateRequestError);
-
-#[derive(Debug)]
-#[cfg(feature = "v2")]
-pub(crate) enum InternalCreateRequestError {
-    Url(url::ParseError),
-    Hpke(crate::hpke::HpkeError),
-    OhttpEncapsulation(crate::ohttp::OhttpEncapsulationError),
-    ParseReceiverPubkey(ParseReceiverPubkeyParamError),
-    MissingOhttpConfig,
-    Expired(std::time::SystemTime),
-}
-
-#[cfg(feature = "v2")]
-impl fmt::Display for CreateRequestError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use InternalCreateRequestError::*;
-
-        match &self.0 {
-            Url(e) => write!(f, "cannot parse url: {:#?}", e),
-            Hpke(e) => write!(f, "v2 error: {}", e),
-            OhttpEncapsulation(e) => write!(f, "v2 error: {}", e),
-            ParseReceiverPubkey(e) => write!(f, "cannot parse receiver public key: {}", e),
-            MissingOhttpConfig =>
-                write!(f, "no ohttp configuration with which to make a v2 request available"),
-            Expired(expiry) => write!(f, "session expired at {:?}", expiry),
-        }
-    }
-}
-
-#[cfg(feature = "v2")]
-impl std::error::Error for CreateRequestError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use InternalCreateRequestError::*;
-
-        match &self.0 {
-            Url(error) => Some(error),
-            Hpke(error) => Some(error),
-            OhttpEncapsulation(error) => Some(error),
-            ParseReceiverPubkey(error) => Some(error),
-            MissingOhttpConfig => None,
-            Expired(_) => None,
-        }
-    }
-}
-
-#[cfg(feature = "v2")]
-impl From<InternalCreateRequestError> for CreateRequestError {
-    fn from(value: InternalCreateRequestError) -> Self { CreateRequestError(value) }
-}
-
-#[cfg(feature = "v2")]
-impl From<ParseReceiverPubkeyParamError> for CreateRequestError {
-    fn from(value: ParseReceiverPubkeyParamError) -> Self {
-        CreateRequestError(InternalCreateRequestError::ParseReceiverPubkey(value))
-    }
-}
-
 /// Error that may occur when the response from receiver is malformed.
 ///
 /// This is currently opaque type because we aren't sure which variants will stay.