payjoin 0.25.0

Payjoin Library implementing BIP 78 and BIP 77 batching protocols.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use url::{ParseError, Url};

#[derive(Debug, PartialEq, Eq)]
pub enum Error {
    BadScheme,
    ParseError(ParseError),
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        use Error::*;

        match self {
            BadScheme => write!(f, "URL scheme is not allowed"),
            ParseError(e) => write!(f, "{e}"),
        }
    }
}

impl std::error::Error for Error {}

impl From<ParseError> for Error {
    fn from(err: ParseError) -> Error { Error::ParseError(err) }
}

type Result<T> = core::result::Result<T, Error>;

/// Try to convert some type into a [`Url`].
///
/// This trait is "sealed", such that only types within payjoin can
/// implement it.
///
/// This design is inspired by the `reqwest` crate's design:
/// see <https://docs.rs/reqwest/latest/reqwest/trait.IntoUrl.html>
pub trait IntoUrl: IntoUrlSealed {}

impl IntoUrl for &str {}
impl IntoUrl for &String {}
impl IntoUrl for String {}

pub trait IntoUrlSealed {
    /// Besides parsing as a valid `Url`, the `Url` must be a valid
    /// `http::Uri`, in that it makes sense to use in a network request.
    fn into_url(self) -> Result<Url>;

    fn as_str(&self) -> &str;
}

impl IntoUrlSealed for &Url {
    fn into_url(self) -> Result<Url> { self.clone().into_url() }

    fn as_str(&self) -> &str { self.as_ref() }
}

impl IntoUrlSealed for Url {
    fn into_url(self) -> Result<Url> {
        if self.has_host() {
            Ok(self)
        } else {
            Err(Error::BadScheme)
        }
    }

    fn as_str(&self) -> &str { self.as_ref() }
}

impl IntoUrlSealed for &str {
    fn into_url(self) -> Result<Url> { Url::parse(self)?.into_url() }

    fn as_str(&self) -> &str { self }
}

impl IntoUrlSealed for &String {
    fn into_url(self) -> Result<Url> { (&**self).into_url() }

    fn as_str(&self) -> &str { self.as_ref() }
}

impl IntoUrlSealed for String {
    fn into_url(self) -> Result<Url> { (&*self).into_url() }

    fn as_str(&self) -> &str { self.as_ref() }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn http_uri_scheme_is_allowed() {
        let url = "http://localhost".into_url().unwrap();
        assert_eq!(url.scheme(), "http");
    }

    #[test]
    fn https_uri_scheme_is_allowed() {
        let url = "https://localhost".into_url().unwrap();
        assert_eq!(url.scheme(), "https");
    }

    #[test]
    fn into_url_file_scheme() {
        let err = "file:///etc/hosts".into_url().unwrap_err();
        assert_eq!(err.to_string(), "URL scheme is not allowed");
    }

    #[test]
    fn into_url_blob_scheme() {
        let err = "blob:https://example.com".into_url().unwrap_err();
        assert_eq!(err.to_string(), "URL scheme is not allowed");
    }

    #[test]
    fn into_url_conversions() {
        let input = "http://localhost/";
        let url = Url::parse(input).unwrap();

        let url_ref = &url;
        assert_eq!(url_ref.as_str(), url.as_ref());
        assert_eq!(IntoUrlSealed::as_str(url_ref), url.as_ref());
        assert_eq!(IntoUrlSealed::as_str(&url_ref), url.as_ref());

        let url_str: &str = input;
        assert_eq!(url_str, url.as_ref());
        assert_eq!(IntoUrlSealed::as_str(&url_str), url.as_ref());

        let url_string: String = input.to_string();
        assert_eq!(url_string, url.as_ref());
        assert_eq!(IntoUrlSealed::as_str(&url_string), url.as_ref());

        let url_string_ref: &String = &input.to_string();
        assert_eq!(url_string_ref, url.as_ref());
        assert_eq!(IntoUrlSealed::as_str(&url_string_ref), url.as_ref());
    }
}