lsdk 0.0.0

Rust SDK for hardware wallets speaking the BOLOS APDU protocol: HID/WebHID transport, device info, genuine check, app management, firmware updates and app signers
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

//! Native websocket backend (tokio-tungstenite). Requires a tokio runtime.

use futures_util::{SinkExt, StreamExt};
use tokio::net::TcpStream;
use tokio_tungstenite::tungstenite::Message;
use tokio_tungstenite::{MaybeTlsStream, WebSocketStream, connect_async};

use crate::error::{Error, Result};

pub(crate) struct WsConn {
    ws: Option<WebSocketStream<MaybeTlsStream<TcpStream>>>,
}

fn ws_err(e: impl core::fmt::Display) -> Error {
    Error::WebSocket(e.to_string())
}

impl WsConn {
    pub async fn connect(url: &str) -> Result<Self> {
        let (ws, _) = connect_async(url).await.map_err(ws_err)?;
        Ok(Self { ws: Some(ws) })
    }

    /// Next text message, `None` when the connection is closed.
    pub async fn recv(&mut self) -> Result<Option<String>> {
        let Some(ws) = self.ws.as_mut() else {
            return Ok(None);
        };
        while let Some(msg) = ws.next().await {
            match msg {
                Ok(Message::Text(t)) => return Ok(Some(t.to_string())),
                Ok(Message::Binary(b)) => return Ok(Some(String::from_utf8_lossy(&b).into_owned())),
                Ok(Message::Close(_)) => return Ok(None),
                Ok(_) => continue,
                Err(
                    tokio_tungstenite::tungstenite::Error::ConnectionClosed
                    | tokio_tungstenite::tungstenite::Error::AlreadyClosed
                    | tokio_tungstenite::tungstenite::Error::Protocol(
                        tokio_tungstenite::tungstenite::error::ProtocolError::ResetWithoutClosingHandshake,
                    ),
                ) => return Ok(None),
                Err(e) => return Err(ws_err(e)),
            }
        }
        Ok(None)
    }

    pub async fn send(&mut self, text: String) -> Result<()> {
        let ws = self
            .ws
            .as_mut()
            .ok_or_else(|| Error::WebSocket("closed".into()))?;
        ws.send(Message::text(text)).await.map_err(ws_err)
    }

    pub async fn close(&mut self) {
        if let Some(mut ws) = self.ws.take() {
            let _ = ws.close(None).await;
        }
    }
}