gl-client 0.4.0

Client library for Greenlight, and basis for language bindings.
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

use super::models::WithdrawRequestResponse;
use anyhow::{anyhow, Result};
use log::debug;
use reqwest::Url;
use serde_json::{to_value, Map, Value};

pub fn build_withdraw_request_callback_url(
    lnurl_pay_request_response: &WithdrawRequestResponse,
    invoice: String,
) -> Result<String> {
    let mut url = Url::parse(&lnurl_pay_request_response.callback)?;
    url.query_pairs_mut()
        .append_pair("k1", &lnurl_pay_request_response.k1)
        .append_pair("pr", &invoice);

    Ok(url.to_string())
}

fn convert_value_field_from_str_to_u64(
    value: &mut Map<String, Value>,
    field_name: &str,
) -> Result<()> {
    match value.get(field_name) {
        Some(field_value) => match field_value.as_str() {
            Some(field_value_str) => {
                let converted_field_value = field_value_str.parse::<u64>()?;

                //overwrites old type value
                value.insert(
                    String::from(field_name),
                    to_value(converted_field_value).unwrap(),
                );
                return Ok(());
            }
            None => return Err(anyhow!("Failed to convert {} into a str", field_name)),
        },
        None => return Err(anyhow!("Failed to find {} in map", field_name)),
    }
}

pub fn parse_withdraw_request_response_from_url(url: &str) -> Option<WithdrawRequestResponse> {
    let url = Url::parse(url).unwrap();
    let query_params: Value = url.query_pairs().clone().collect();

    if let Some(mut query_params) = query_params.as_object().cloned() {
        if convert_value_field_from_str_to_u64(&mut query_params, "minWithdrawable").is_err() {
            debug!("minWithdrawable could not be parsed into a number");
            return None;
        };

        if convert_value_field_from_str_to_u64(&mut query_params, "maxWithdrawable").is_err() {
            debug!("maxWithdrawable could not be parsed into a number");
            return None;
        };

        match serde_json::from_value(Value::Object(query_params)) {
            Ok(w) => {
                return w;
            },
            Err(e) => {
                debug!("{:?}", e);
                return None;
            }
        }
    }

    None
}

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

    #[test]
    fn test_build_withdraw_request_callback_url() -> Result<()> {

        let k1 =  String::from("unique");
        let invoice = String::from("invoice");

        let built_withdraw_request_callback_url = build_withdraw_request_callback_url(&WithdrawRequestResponse { 
            tag: String::from("withdraw"), 
            callback: String::from("https://cipherpunk.com/"), 
            k1: k1.clone(), 
            default_description: String::from(""), 
            min_withdrawable: 2, 
            max_withdrawable: 300, 
        }, invoice.clone());

        let url = Url::parse(&built_withdraw_request_callback_url.unwrap())?;
        let query_pairs = url.query_pairs().collect::<Value>();
        let query_params: &Map<String, Value> = query_pairs.as_object().unwrap();
        
       assert_eq!(query_params.get("k1").unwrap().as_str().unwrap(), k1);
       assert_eq!(query_params.get("pr").unwrap().as_str().unwrap(), invoice);

        Ok(())
    }

    #[test]
    fn test_parse_withdraw_request_response_from_url() {
        let withdraw_request = parse_withdraw_request_response_from_url("https://cipherpunk.com?tag=withdraw&callback=cipherpunk.com&k1=42&minWithdrawable=1&maxWithdrawable=100&defaultDescription=");
        assert!(withdraw_request.is_some());
    }

    #[test]
    fn test_parse_withdraw_request_response_from_url_fails_when_field_is_missing() {
        let withdraw_request = parse_withdraw_request_response_from_url("https://cipherpunk.com?tag=withdraw&callback=cipherpunk.com&k1=42&minWithdrawable=1&maxWithdrawable=100");
        assert!(withdraw_request.is_none());
    }

    #[test]
    fn test_parse_withdraw_request_response_from_url_fails_when_min_withdrawable_is_wrong_type() {
        let withdraw_request = parse_withdraw_request_response_from_url("https://cipherpunk.com?tag=withdraw&callback=cipherpunk.com&k1=42&minWithdrawable=one&maxWithdrawable=100&defaultDescription=");
        assert!(withdraw_request.is_none());
    }
}