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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use crate::{Credentials, Error};
use bip39::Mnemonic;
use std::str::FromStr;
use tracing;

#[derive(uniffi::Object, Clone)]
pub struct Signer {
    seed: Vec<u8>,
    pub(crate) inner: gl_client::signer::Signer,
    credentials: Option<Credentials>,
}

#[uniffi::export]
impl Signer {
    #[uniffi::constructor()]
    pub fn new(phrase: String) -> Result<Signer, Error> {
        let phrase = Mnemonic::from_str(phrase.as_str()).map_err(|_e| Error::PhraseCorrupted())?;
        let seed = phrase.to_seed_normalized(&"").to_vec();
        Self::new_from_seed(seed)
    }

    #[uniffi::constructor()]
    pub fn new_from_seed(seed: Vec<u8>) -> Result<Signer, Error> {
        let credentials = gl_client::credentials::Nobody::new();

        let inner = gl_client::signer::Signer::new(
            seed.clone(),
            gl_client::bitcoin::Network::Bitcoin,
            credentials,
        )
        .map_err(|e| Error::Other(e.to_string()))?;
        let credentials = None;
        Ok(Signer {
            seed,
            inner,
            credentials,
        })
    }

    pub fn authenticate(&self, creds: &Credentials) -> Result<Signer, Error> {
        let credentials = Some(creds.clone());

        let inner = gl_client::signer::Signer::new(
            self.seed.clone(),
            gl_client::bitcoin::Network::Bitcoin,
            creds.inner.clone(),
        )
        .map_err(|e| Error::Other(e.to_string()))?;

        Ok(Signer {
            inner,
            credentials,
            ..self.clone()
        })
    }

    pub fn start(&self) -> Result<Handle, Error> {
        Ok(Handle::spawn(self.inner.clone()))
    }

    pub fn node_id(&self) -> Vec<u8> {
        self.inner.node_id()
    }
}

// Not exported through uniffi, internal logic only.
impl Signer {
    async fn run(&self, signal: tokio::sync::mpsc::Receiver<()>) {
        self.inner
            .run_forever(signal)
            .await
            .expect("Error running signer loop");
    }
}

/// A handle to interact with a signer loop running and processing
/// requests in the background. Used primarily to stop the loop and
/// exiting the signer.
#[derive(uniffi::Object, Clone)]
pub struct Handle {
    chan: tokio::sync::mpsc::Sender<()>,
}

#[uniffi::export]
impl Handle {
    pub fn stop(&self) {
        self.chan.try_send(()).expect("sending shutdown signal");
    }
}

impl Handle {
    /// Spawns the signer on the shared signer runtime and returns a handle to stop it.
    pub(crate) fn spawn(signer: gl_client::signer::Signer) -> Self {
        let (tx, rx) = tokio::sync::mpsc::channel(1);
        crate::util::get_signer_runtime().spawn(async move {
            if let Err(e) = signer.run_forever(rx).await {
                tracing::error!("Error running signer: {e}");
            }
        });
        Self { chan: tx }
    }

    /// Sends the shutdown signal, returning true if the signal was
    /// delivered and false if the signer has already stopped.
    pub(crate) fn try_stop(&self) -> bool {
        self.chan.try_send(()).is_ok()
    }
}