12920446392

Committed 23 Jan 2025 01:33AM UTC coverage: 66.558% (-5.6%) from 72.12%

Build # 12920446392

Build Type

Pull #502

github

Committed by

web-flow

Commit Message

Merge b976a09a9 into 7d8116e03

Pull Request Pull Request #502: Introduce `directory` feature module

Run Details

123 of 153 new or added lines in 11 files covered. (80.39%)

269 existing lines in 14 files now uncovered.

3268 of 4910 relevant lines covered (66.56%)

930.53 hits per line

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

68.66

/payjoin/src/receive/optional_parameters.rs

use std::borrow::Borrow;
use std::fmt;

use bitcoin::FeeRate;
use log::warn;

#[derive(Debug, Clone)]
pub(crate) struct Params {
    // version
    pub v: usize,
    // disableoutputsubstitution
    pub disable_output_substitution: bool,
    // maxadditionalfeecontribution, additionalfeeoutputindex
    pub additional_fee_contribution: Option<(bitcoin::Amount, usize)>,
    // minfeerate
    pub min_feerate: FeeRate,
}

impl Default for Params {
    fn default() -> Self {
        Params {
            v: 1,
            disable_output_substitution: false,
            additional_fee_contribution: None,
            min_feerate: FeeRate::BROADCAST_MIN,
        }
    }
}

impl Params {
    pub fn from_query_pairs<K, V, I>(
        pairs: I,
        supported_versions: &'static [usize],
    ) -> Result<Self, Error>
    where
        I: Iterator<Item = (K, V)>,
        K: Borrow<str> + Into<String>,
        V: Borrow<str> + Into<String>,
    {
        let mut params = Params::default();

        let mut additional_fee_output_index = None;
        let mut max_additional_fee_contribution = None;

        for (key, v) in pairs {
            match (key.borrow(), v.borrow()) {
                ("v", version) =>
                    params.v = match version.parse::<usize>() {
                        Ok(version) if supported_versions.contains(&version) => version,
                        _ => return Err(Error::UnknownVersion { supported_versions }),
                    },
                ("additionalfeeoutputindex", index) =>
                    additional_fee_output_index = match index.parse::<usize>() {
                        Ok(index) => Some(index),
                        Err(_error) => {
                            warn!(
                                "bad `additionalfeeoutputindex` query value '{}': {}",
                                index, _error
                            );
                            None
                        }
                    },
                ("maxadditionalfeecontribution", fee) =>
                    max_additional_fee_contribution =
                        match bitcoin::Amount::from_str_in(fee, bitcoin::Denomination::Satoshi) {
                            Ok(contribution) => Some(contribution),
                            Err(_error) => {
                                warn!(
                                    "bad `maxadditionalfeecontribution` query value '{}': {}",
                                    fee, _error
                                );
                                None
                            }
                        },
                ("minfeerate", feerate) =>
                    params.min_feerate = match feerate.parse::<f32>() {
                        Ok(fee_rate_sat_per_vb) => {
                            // TODO Parse with serde when rust-bitcoin supports it
                            let fee_rate_sat_per_kwu = fee_rate_sat_per_vb * 250.0_f32;
                            // since it's a minnimum, we want to round up
                            FeeRate::from_sat_per_kwu(fee_rate_sat_per_kwu.ceil() as u64)
                        }
                        Err(_) => return Err(Error::FeeRate),
                    },
                ("disableoutputsubstitution", v) =>
                    params.disable_output_substitution = v == "true",
                _ => (),
            }
        }

        match (max_additional_fee_contribution, additional_fee_output_index) {
            (Some(amount), Some(index)) =>
                params.additional_fee_contribution = Some((amount, index)),
            (Some(_), None) | (None, Some(_)) => {
                warn!("only one additional-fee parameter specified: {:?}", params);
            }
            _ => (),
        }

        log::debug!("parsed optional parameters: {:?}", params);
        Ok(params)
    }
}

#[derive(Debug)]
pub(crate) enum Error {
    UnknownVersion { supported_versions: &'static [usize] },
    FeeRate,
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Error::UnknownVersion { .. } => write!(f, "unknown version"),
            Error::FeeRate => write!(f, "could not parse feerate"),
        }
    }
}

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
}

1	use std::borrow::Borrow;
2	use std::fmt;
3
4	use bitcoin::FeeRate;
5	use log::warn;
6
7	#[derive(Debug, Clone)]
8	pub(crate) struct Params {
9	// version
10	pub v: usize,
11	// disableoutputsubstitution
12	pub disable_output_substitution: bool,
13	// maxadditionalfeecontribution, additionalfeeoutputindex
14	pub additional_fee_contribution: Option<(bitcoin::Amount, usize)>,
15	// minfeerate
16	pub min_feerate: FeeRate,
17	}
18
19	impl Default for Params {
20	fn default() -> Self {	17✔
21	Params {	17✔
22	v: 1,	17✔
23	disable_output_substitution: false,	17✔
24	additional_fee_contribution: None,	17✔
25	min_feerate: FeeRate::BROADCAST_MIN,	17✔
26	}	17✔
27	}	17✔
28	}
29
30	impl Params {
31	pub fn from_query_pairs<K, V, I>(	9✔
32	pairs: I,	9✔
33	supported_versions: &'static [usize],	9✔
34	) -> Result<Self, Error>	9✔
35	where	9✔
36	I: Iterator<Item = (K, V)>,	9✔
37	K: Borrow<str> + Into<String>,	9✔
38	V: Borrow<str> + Into<String>,	9✔
39	{	9✔
40	let mut params = Params::default();	9✔
41		9✔
42	let mut additional_fee_output_index = None;	9✔
43	let mut max_additional_fee_contribution = None;	9✔
44
45	for (key, v) in pairs {	29✔
46	match (key.borrow(), v.borrow()) {	20✔
47	("v", version) =>	20✔
48	params.v = match version.parse::<usize>() {	1✔
49	Ok(version) if supported_versions.contains(&version) => version,	1✔
50	_ => return Err(Error::UnknownVersion { supported_versions }),	×
51	},
52	("additionalfeeoutputindex", index) =>	19✔
53	additional_fee_output_index = match index.parse::<usize>() {	9✔
54	Ok(index) => Some(index),	9✔
55	Err(_error) => {	×
56	warn!(	×
57	"bad `additionalfeeoutputindex` query value '{}': {}",	×
58	index, _error
59	);
60	None	×
61	}
62	},
63	("maxadditionalfeecontribution", fee) =>	10✔
64	max_additional_fee_contribution =	9✔
65	match bitcoin::Amount::from_str_in(fee, bitcoin::Denomination::Satoshi) {	9✔
66	Ok(contribution) => Some(contribution),	9✔
67	Err(_error) => {	×
68	warn!(	×
69	"bad `maxadditionalfeecontribution` query value '{}': {}",	×
70	fee, _error
71	);
72	None	×
73	}
74	},
75	("minfeerate", feerate) =>	1✔
76	params.min_feerate = match feerate.parse::<f32>() {	1✔
77	Ok(fee_rate_sat_per_vb) => {	1✔
78	// TODO Parse with serde when rust-bitcoin supports it	1✔
79	let fee_rate_sat_per_kwu = fee_rate_sat_per_vb * 250.0_f32;	1✔
80	// since it's a minnimum, we want to round up	1✔
81	FeeRate::from_sat_per_kwu(fee_rate_sat_per_kwu.ceil() as u64)	1✔
82	}
83	Err(_) => return Err(Error::FeeRate),	×
84	},
85	("disableoutputsubstitution", v) =>	×
86	params.disable_output_substitution = v == "true",	×
87	_ => (),	×
88	}
89	}
90
91	match (max_additional_fee_contribution, additional_fee_output_index) {	9✔
92	(Some(amount), Some(index)) =>	9✔
93	params.additional_fee_contribution = Some((amount, index)),	9✔
94	(Some(_), None) \| (None, Some(_)) => {
95	warn!("only one additional-fee parameter specified: {:?}", params);	×
96	}
UNCOV 97	_ => (),	×
98	}
99
100	log::debug!("parsed optional parameters: {:?}", params);	9✔
101	Ok(params)	9✔
102	}	9✔
103	}
104
105	#[derive(Debug)]
106	pub(crate) enum Error {
107	UnknownVersion { supported_versions: &'static [usize] },
108	FeeRate,
109	}
110
111	impl fmt::Display for Error {
112	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {	×
113	match self {	×
114	Error::UnknownVersion { .. } => write!(f, "unknown version"),	×
115	Error::FeeRate => write!(f, "could not parse feerate"),	×
116	}
117	}	×
118	}
119
120	impl std::error::Error for Error {
121	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }	×
122	}

payjoin / rust-payjoin / 12920446392

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