gl-sdk 0.2.0

High-level SDK for Greenlight with UniFFI 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

use crate::{
    credentials::{Credentials, DeveloperCert},
    signer::Signer,
    util::exec,
    Error,
};

#[derive(uniffi::Object, Clone)]
pub struct Scheduler {
    credentials: Option<Credentials>,
    network: gl_client::bitcoin::Network,
    developer_cert: Option<gl_client::credentials::Nobody>,
}

impl Scheduler {
    /// Resolve the credentials to use for unauthenticated scheduler
    /// calls (register, recover). Uses the developer certificate if
    /// one was provided via `with_developer_cert()`, otherwise falls
    /// back to the compiled-in default.
    fn nobody(&self) -> gl_client::credentials::Nobody {
        self.developer_cert
            .clone()
            .unwrap_or_else(gl_client::credentials::Nobody::new)
    }
}

#[uniffi::export]
impl Scheduler {
    /// Create a `Scheduler` instance configured with the Greenlight
    /// production service pre-configured.
    #[uniffi::constructor()]
    pub fn new(network: crate::Network) -> Result<Scheduler, Error> {
        let network: gl_client::bitcoin::Network = network.into();

        Ok(Scheduler {
            credentials: None,
            network,
            developer_cert: None,
        })
    }

    /// Configure a developer certificate obtained from the Greenlight
    /// Developer Console. Nodes registered through this scheduler
    /// will be associated with the developer's account.
    ///
    /// Returns a new `Scheduler` instance with the developer
    /// certificate configured.
    pub fn with_developer_cert(&self, cert: &DeveloperCert) -> Scheduler {
        Scheduler {
            developer_cert: Some(cert.inner.clone()),
            ..self.clone()
        }
    }

    pub fn register(&self, signer: &Signer, code: Option<String>) -> Result<Credentials, Error> {
        let nobody = self.nobody();
        exec(async move {
            let inner = gl_client::scheduler::Scheduler::new(self.network, nobody)
                .await
                .map_err(|e| Error::Other(e.to_string()))?;

            let res = inner
                .register(&signer.inner, code)
                .await
                .map_err(|e| Error::Other(e.to_string().clone()))?;

            Credentials::load(res.creds).map_err(|_e| Error::UnparseableCreds())
        })
    }

    pub fn recover(&self, signer: &Signer) -> Result<Credentials, Error> {
        let nobody = self.nobody();
        exec(async move {
            let inner = gl_client::scheduler::Scheduler::new(self.network, nobody)
                .await
                .map_err(|e| Error::Other(e.to_string()))?;

            let res = inner
                .recover(&signer.inner)
                .await
                .map_err(|e| Error::Other(e.to_string()))?;

            Credentials::load(res.creds).map_err(|_e| Error::UnparseableCreds())
        })
    }
}