26896827188

Committed 03 Jun 2026 03:58PM UTC coverage: 85.37% (+0.01%) from 85.358%

Build # 26896827188

Build Type

Pull #1399

github

Committed by

web-flow

Commit Message

Merge 36e1f6b9a into fec44af10

Pull Request Pull Request #1399: Split resume session relays

Coverage Stats

51 of 68 new or added lines in 3 files covered. (75.0%)

1 existing line in 1 file now uncovered.

11846 of 13876 relevant lines covered (85.37%)

391.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.27

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

//! OHTTP relay selection and key bootstrapping for the payjoin-cli.
//!
//! [`RelayManager`] tracks the currently selected relay and any relays that
//! have failed, excluding them from future selections for the lifetime of
//! the [`RelayManager`].
//!
//! `fetch_ohttp_keys` selects a relay at random from the configured list,
//! excluding relays that [`RelayManager`] has marked as failed,
//! to avoid a fixed contact pattern at the network layer.

use anyhow::{anyhow, Result};
use payjoin::Url;

use super::Config;

#[derive(Debug, Clone)]
pub struct RelayManager {
    selected_relay: Option<Url>,
    failed_relays: Vec<Url>,
}

impl RelayManager {
    pub fn new() -> Self { RelayManager { selected_relay: None, failed_relays: Vec::new() } }

    pub fn set_selected_relay(&mut self, relay: Url) { self.selected_relay = Some(relay); }

    pub fn get_selected_relay(&self) -> Option<Url> { self.selected_relay.clone() }

    pub fn add_failed_relay(&mut self, relay: Url) { self.failed_relays.push(relay); }

    pub fn get_failed_relays(&self) -> Vec<Url> { self.failed_relays.clone() }
}

pub(crate) struct ValidatedOhttpKeys {
    pub(crate) ohttp_keys: payjoin::OhttpKeys,
    pub(crate) relay_url: Url,
}

pub(crate) async fn unwrap_ohttp_keys_or_else_fetch(
    config: &Config,
    directory: Option<Url>,
    relay_manager: &mut RelayManager,
) -> Result<ValidatedOhttpKeys> {
    if let Some(ohttp_keys) = config.v2()?.ohttp_keys.clone() {
        println!("Using OHTTP Keys from config");
        let validated = fetch_ohttp_keys(config, directory, relay_manager).await?;
        Ok(ValidatedOhttpKeys { ohttp_keys, relay_url: validated.relay_url })
    } else {
        println!("Bootstrapping private network transport over Oblivious HTTP");
        let fetched_keys = fetch_ohttp_keys(config, directory, relay_manager).await?;

        Ok(fetched_keys)
    }
}

async fn fetch_ohttp_keys(
    config: &Config,
    directory: Option<Url>,
    relay_manager: &mut RelayManager,
) -> Result<ValidatedOhttpKeys> {
    use payjoin::bitcoin::secp256k1::rand::prelude::SliceRandom;
    let payjoin_directory = directory.unwrap_or(config.v2()?.pj_directory.clone());
    let relays = config.v2()?.ohttp_relays.clone();

    loop {
        let failed_relays = relay_manager.get_failed_relays();

        let remaining_relays: Vec<_> =
            relays.iter().filter(|r| !failed_relays.contains(r)).cloned().collect();

        if remaining_relays.is_empty() {
            return Err(anyhow!("No valid relays available"));
        }

        let selected_relay =
            match remaining_relays.choose(&mut payjoin::bitcoin::key::rand::thread_rng()) {
                Some(relay) => relay.clone(),
                None => return Err(anyhow!("Failed to select from remaining relays")),
            };

        relay_manager.set_selected_relay(selected_relay.clone());

        let ohttp_keys = {
            #[cfg(feature = "_manual-tls")]
            {
                if let Some(cert_path) = config.root_certificate.as_ref() {
                    let cert_der = std::fs::read(cert_path)?;
                    payjoin::io::fetch_ohttp_keys_with_cert(
                        selected_relay.as_str(),
                        payjoin_directory.as_str(),
                        &cert_der,
                    )
                    .await
                } else {
                    payjoin::io::fetch_ohttp_keys(
                        selected_relay.as_str(),
                        payjoin_directory.as_str(),
                    )
                    .await
                }
            }
            #[cfg(not(feature = "_manual-tls"))]
            payjoin::io::fetch_ohttp_keys(selected_relay.as_str(), payjoin_directory.as_str()).await
        };

        match ohttp_keys {
            Ok(keys) =>
                return Ok(ValidatedOhttpKeys { ohttp_keys: keys, relay_url: selected_relay }),
            Err(payjoin::io::Error::UnexpectedStatusCode(e)) => {
                return Err(payjoin::io::Error::UnexpectedStatusCode(e).into());
            }
            Err(e) => {
                tracing::debug!("Failed to connect to relay: {selected_relay}, {e:?}");
                relay_manager.add_failed_relay(selected_relay);
            }
        }
    }
}

1	//! OHTTP relay selection and key bootstrapping for the payjoin-cli.
2	//!
3	//! [`RelayManager`] tracks the currently selected relay and any relays that
4	//! have failed, excluding them from future selections for the lifetime of
5	//! the [`RelayManager`].
6	//!
7	//! `fetch_ohttp_keys` selects a relay at random from the configured list,
8	//! excluding relays that [`RelayManager`] has marked as failed,
9	//! to avoid a fixed contact pattern at the network layer.
10
11	use anyhow::{anyhow, Result};
12	use payjoin::Url;
13
14	use super::Config;
15
16	#[derive(Debug, Clone)]
17	pub struct RelayManager {
18	selected_relay: Option<Url>,
19	failed_relays: Vec<Url>,
20	}
21
22	impl RelayManager {
23	pub fn new() -> Self { RelayManager { selected_relay: None, failed_relays: Vec::new() } }	10✔
24
25	pub fn set_selected_relay(&mut self, relay: Url) { self.selected_relay = Some(relay); }	8✔
26
27	pub fn get_selected_relay(&self) -> Option<Url> { self.selected_relay.clone() }	9✔
28
29	pub fn add_failed_relay(&mut self, relay: Url) { self.failed_relays.push(relay); }	×
30
31	pub fn get_failed_relays(&self) -> Vec<Url> { self.failed_relays.clone() }	8✔
32	}
33
34	pub(crate) struct ValidatedOhttpKeys {
35	pub(crate) ohttp_keys: payjoin::OhttpKeys,
36	pub(crate) relay_url: Url,
37	}
38
39	pub(crate) async fn unwrap_ohttp_keys_or_else_fetch(	8✔
40	config: &Config,	8✔
41	directory: Option<Url>,	8✔
42	relay_manager: &mut RelayManager,	8✔
43	) -> Result<ValidatedOhttpKeys> {	8✔
44	if let Some(ohttp_keys) = config.v2()?.ohttp_keys.clone() {	8✔
45	println!("Using OHTTP Keys from config");	4✔
46	let validated = fetch_ohttp_keys(config, directory, relay_manager).await?;	4✔
47	Ok(ValidatedOhttpKeys { ohttp_keys, relay_url: validated.relay_url })	2✔
48	} else {
49	println!("Bootstrapping private network transport over Oblivious HTTP");	4✔
50	let fetched_keys = fetch_ohttp_keys(config, directory, relay_manager).await?;	4✔
51
52	Ok(fetched_keys)	4✔
53	}
54	}	6✔
55
56	async fn fetch_ohttp_keys(	8✔
57	config: &Config,	8✔
58	directory: Option<Url>,	8✔
59	relay_manager: &mut RelayManager,	8✔
60	) -> Result<ValidatedOhttpKeys> {	8✔
61	use payjoin::bitcoin::secp256k1::rand::prelude::SliceRandom;
62	let payjoin_directory = directory.unwrap_or(config.v2()?.pj_directory.clone());	8✔
63	let relays = config.v2()?.ohttp_relays.clone();	8✔
64
65	loop {
66	let failed_relays = relay_manager.get_failed_relays();	8✔
67
68	let remaining_relays: Vec<_> =	8✔
69	relays.iter().filter(\|r\| !failed_relays.contains(r)).cloned().collect();	8✔
70
71	if remaining_relays.is_empty() {	8✔
72	return Err(anyhow!("No valid relays available"));	×
73	}	8✔
74
75	let selected_relay =	8✔
76	match remaining_relays.choose(&mut payjoin::bitcoin::key::rand::thread_rng()) {	8✔
77	Some(relay) => relay.clone(),	8✔
78	None => return Err(anyhow!("Failed to select from remaining relays")),	×
79	};
80
81	relay_manager.set_selected_relay(selected_relay.clone());	8✔
82
83	let ohttp_keys = {	6✔
84	#[cfg(feature = "_manual-tls")]
85	{
86	if let Some(cert_path) = config.root_certificate.as_ref() {	8✔
87	let cert_der = std::fs::read(cert_path)?;	8✔
88	payjoin::io::fetch_ohttp_keys_with_cert(	8✔
89	selected_relay.as_str(),	8✔
90	payjoin_directory.as_str(),	8✔
91	&cert_der,	8✔
92	)	8✔
93	.await	8✔
94	} else {
95	payjoin::io::fetch_ohttp_keys(	×
96	selected_relay.as_str(),	×
97	payjoin_directory.as_str(),	×
98	)	×
99	.await	×
100	}
101	}
102	#[cfg(not(feature = "_manual-tls"))]
103	payjoin::io::fetch_ohttp_keys(selected_relay.as_str(), payjoin_directory.as_str()).await
104	};
105
106	match ohttp_keys {	×
107	Ok(keys) =>	6✔
108	return Ok(ValidatedOhttpKeys { ohttp_keys: keys, relay_url: selected_relay }),	6✔
109	Err(payjoin::io::Error::UnexpectedStatusCode(e)) => {	×
110	return Err(payjoin::io::Error::UnexpectedStatusCode(e).into());	×
111	}
112	Err(e) => {	×
113	tracing::debug!("Failed to connect to relay: {selected_relay}, {e:?}");	×
NEW 114	relay_manager.add_failed_relay(selected_relay);	×
115	}
116	}
117	}
118	}	6✔

payjoin / rust-payjoin / 26896827188

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous