14668081009

Committed 25 Apr 2025 03:27PM UTC coverage: 81.936% (+0.1%) from 81.835%

Build # 14668081009

Build Type

push

github

Committed by

web-flow

Commit Message

Fix uninline format rust 1.88.0 clippy violations (#667)

Run Details

50 of 145 new or added lines in 30 files covered. (34.48%)

3 existing lines in 2 files now uncovered.

5325 of 6499 relevant lines covered (81.94%)

711.53 hits per line

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

77.78

/payjoin/src/receive/optional_parameters.rs

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

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

use crate::output_substitution::OutputSubstitution;

#[derive(Debug, Clone)]
pub(crate) struct Params {
    // version
    pub v: usize,
    // disableoutputsubstitution
    pub output_substitution: OutputSubstitution,
    // maxadditionalfeecontribution, additionalfeeoutputindex
    pub additional_fee_contribution: Option<(bitcoin::Amount, usize)>,
    // minfeerate
    pub min_fee_rate: FeeRate,
    #[cfg(feature = "_multiparty")]
    /// Opt in to optimistic psbt merge
    pub optimistic_merge: bool,
}

impl Default for Params {
    fn default() -> Self {
        Params {
            v: 1,
            output_substitution: OutputSubstitution::Enabled,
            additional_fee_contribution: None,
            min_fee_rate: FeeRate::BROADCAST_MIN,
            #[cfg(feature = "_multiparty")]
            optimistic_merge: false,
        }
    }
}

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", fee_rate) =>
                    params.min_fee_rate = match fee_rate.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 minimum, 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.output_substitution = if v == "true" {
                        OutputSubstitution::Disabled
                    } else {
                        OutputSubstitution::Enabled
                    },
                #[cfg(feature = "_multiparty")]
                ("optimisticmerge", v) => params.optimistic_merge = 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 }
}

#[cfg(test)]
pub(crate) mod test {
    use bitcoin::Amount;

    use super::*;

    #[test]
    fn test_parse_params() {
        use bitcoin::FeeRate;

        let pairs = url::form_urlencoded::parse(b"maxadditionalfeecontribution=182&additionalfeeoutputindex=0&minfeerate=1&disableoutputsubstitution=true&optimisticmerge=true");
        let params =
            Params::from_query_pairs(pairs, &[1]).expect("Could not parse params from query pairs");
        assert_eq!(params.v, 1);
        assert_eq!(params.output_substitution, OutputSubstitution::Disabled);
        assert_eq!(params.additional_fee_contribution, Some((Amount::from_sat(182), 0)));
        assert_eq!(params.min_fee_rate, FeeRate::BROADCAST_MIN);
        #[cfg(feature = "_multiparty")]
        assert!(params.optimistic_merge)
    }
}

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

payjoin / rust-payjoin / 14668081009

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