Use session enpoint url for directory when available

when merging the ohttp-key fetching and validation functions I found
that there was some logic that was skipping the correct directory
selection.

By ensuring that the directory is chosen per session we can ensure that
the correct directory is used no matter the initial config at
intialization.

Author: benalleng

payjoin-cli/src/app/v2/mod.rs

@@ -77,9 +77,10 @@ impl AppTrait for App {
 
     async fn receive_payjoin(&self, amount: Amount) -> Result<()> {
         let address = self.wallet().get_new_address()?;
-        let ohttp_keys = unwrap_ohttp_keys_or_else_fetch(&self.config, self.relay_manager.clone())
-            .await?
-            .ohttp_keys;
+        let ohttp_keys =
+            unwrap_ohttp_keys_or_else_fetch(&self.config, None, self.relay_manager.clone())
+                .await?
+                .ohttp_keys;
         let mut persister = ReceiverPersister::new(self.db.clone());
         let new_receiver = NewReceiver::new(
             address,
@@ -161,7 +162,9 @@ impl App {
         println!("Receive session established");
         let mut pj_uri = session.pj_uri();
         pj_uri.amount = amount;
-        let ohttp_relay = self.unwrap_relay_or_else_fetch().await?;
+        let ohttp_relay = self
+            .unwrap_relay_or_else_fetch(Some(session.pj_uri().extras.endpoint().clone()))
+            .await?;
 
         println!("Request Payjoin by sharing this Payjoin Uri:");
         println!("{pj_uri}");
@@ -202,7 +205,7 @@ impl App {
     }
 
     async fn long_poll_post(&self, req_ctx: &mut Sender<WithReplyKey>) -> Result<Psbt> {
-        let ohttp_relay = self.unwrap_relay_or_else_fetch().await?;
+        let ohttp_relay = self.unwrap_relay_or_else_fetch(Some(req_ctx.endpoint().clone())).await?;
 
         match req_ctx.extract_v2(ohttp_relay.clone()) {
             Ok((req, ctx)) => {
@@ -247,7 +250,9 @@ impl App {
         &self,
         session: &mut Receiver<WithContext>,
     ) -> Result<Receiver<UncheckedProposal>> {
-        let ohttp_relay = self.unwrap_relay_or_else_fetch().await?;
+        let ohttp_relay = self
+            .unwrap_relay_or_else_fetch(Some(session.pj_uri().extras.endpoint().clone()))
+            .await?;
 
         loop {
             let (req, context) = session.extract_req(&ohttp_relay)?;
@@ -303,13 +308,16 @@ impl App {
         Ok(payjoin_proposal)
     }
 
-    async fn unwrap_relay_or_else_fetch(&self) -> Result<payjoin::Url> {
+    async fn unwrap_relay_or_else_fetch(
+        &self,
+        directory: Option<payjoin::Url>,
+    ) -> Result<payjoin::Url> {
         let selected_relay =
             self.relay_manager.lock().expect("Lock should not be poisoned").get_selected_relay();
         let ohttp_relay = match selected_relay {
             Some(relay) => relay,
             None =>
-                unwrap_ohttp_keys_or_else_fetch(&self.config, self.relay_manager.clone())
+                unwrap_ohttp_keys_or_else_fetch(&self.config, directory, self.relay_manager.clone())
                     .await?
                     .relay_url,
         };

payjoin-cli/src/app/v2/ohttp.rs

@@ -29,24 +29,30 @@ pub(crate) struct ValidatedOhttpKeys {
 
 pub(crate) async fn unwrap_ohttp_keys_or_else_fetch(
     config: &Config,
+    directory: Option<payjoin::Url>,
     relay_manager: Arc<Mutex<RelayManager>>,
 ) -> Result<ValidatedOhttpKeys> {
-    let config_keys = config.v2()?.ohttp_keys.clone();
-    let mut fetched_keys = fetch_ohttp_keys(config, relay_manager).await?;
-
-    if let Some(keys) = config_keys {
-        fetched_keys.ohttp_keys = keys;
+    if let Some(ohttp_keys) = config.v2()?.ohttp_keys.clone() {
+        println!("Using OHTTP Keys from config");
+        return Ok(ValidatedOhttpKeys {
+            ohttp_keys,
+            relay_url: config.v2()?.ohttp_relays[0].clone(),
+        });
+    } else {
+        println!("Bootstrapping private network transport over Oblivious HTTP");
+        let fetched_keys = fetch_ohttp_keys(config, directory, relay_manager).await?;
+
+        Ok(fetched_keys)
     }
-
-    Ok(fetched_keys)
 }
 
 async fn fetch_ohttp_keys(
     config: &Config,
+    directory: Option<payjoin::Url>,
     relay_manager: Arc<Mutex<RelayManager>>,
 ) -> Result<ValidatedOhttpKeys> {
     use payjoin::bitcoin::secp256k1::rand::prelude::SliceRandom;
-    let payjoin_directory = config.v2()?.pj_directory.clone();
+    let payjoin_directory = directory.unwrap_or(config.v2()?.pj_directory.clone());
     let relays = config.v2()?.ohttp_relays.clone();
 
     loop {