walletconnect 0.1.0

WalletConnect client implementation in Rust.
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

use super::session::Session;
use crate::crypto::Key;
use crate::protocol::{Metadata, Topic};
use crate::uri::Uri;
use lazy_static::lazy_static;
use std::path::PathBuf;
use url::Url;

lazy_static! {
    pub static ref DEFAULT_BRIDGE_URL: Url =
        Url::parse("https://bridge.walletconnect.org").unwrap();
}

#[derive(Clone, Debug)]
pub enum Connection {
    Bridge(Url),
    Uri(Uri),
}

impl Default for Connection {
    fn default() -> Self {
        Connection::Bridge(DEFAULT_BRIDGE_URL.clone())
    }
}

#[derive(Clone, Debug)]
pub struct Options {
    pub profile: PathBuf,
    pub meta: Metadata,
    pub connection: Connection,
    pub chain_id: Option<u64>,
}

impl Options {
    pub fn new(profile: impl Into<PathBuf>, meta: Metadata) -> Self {
        Options {
            profile: profile.into(),
            meta,
            connection: Connection::default(),
            chain_id: None,
        }
    }

    pub fn with_uri(profile: impl Into<PathBuf>, meta: Metadata, uri: Uri) -> Self {
        Options {
            profile: profile.into(),
            meta,
            connection: Connection::Uri(uri),
            chain_id: None,
        }
    }

    pub fn create_session(self) -> Session {
        let client_meta = self.meta;
        let (handshake_topic, bridge, key) = match self.connection {
            Connection::Bridge(bridge) => (Topic::new(), bridge, Key::random()),
            Connection::Uri(uri) => uri.into_parts(),
        };
        let chain_id = self.chain_id;

        Session {
            connected: false,
            accounts: Vec::new(),
            chain_id,
            bridge,
            key,
            client_id: Topic::new(),
            client_meta,
            peer_id: None,
            peer_meta: None,
            handshake_id: 0,
            handshake_topic,
        }
    }

    pub fn matches(&self, session: &Session) -> bool {
        self.meta == session.client_meta
            && match &self.connection {
                Connection::Bridge(bridge) => *bridge == session.bridge,
                Connection::Uri(uri) => *uri == session.uri(),
            }
    }
}