wallet-adapter 1.4.2

Solana Wallet Adapter for Rust clients written in pure 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
84
85
86
87
88
89
90
91
92
93
94
95
96

use wallet_adapter_common::{
    feature_support::FeatureSupport,
    standardized_events::{
        SOLANA_SIGN_AND_SEND_TRANSACTION_IDENTIFIER, SOLANA_SIGN_IN_IDENTIFIER,
        SOLANA_SIGN_MESSAGE_IDENTIFIER, SOLANA_SIGN_TRANSACTION_IDENTIFIER,
        STANDARD_CONNECT_IDENTIFIER, STANDARD_DISCONNECT_IDENTIFIER, STANDARD_EVENTS_IDENTIFIER,
    },
};

use crate::{
    Connect, Disconnect, Reflection, SemverVersion, SignIn, SignMessage, SignTransaction,
    StandardEvents, WalletError, WalletResult,
};

/// All the features of `standard` and `solana` events as specified
/// in the wallet standard. These features are contained within a
/// [crate::Wallet] struct allowing to check if a wallet supports a certain
/// feature and also calling the callback functions to make requests to a browser wallet.
#[derive(Debug, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Features {
    /// standard:connect
    pub(crate) connect: Connect,
    /// standard:disconnect
    pub(crate) disconnect: Disconnect,
    /// standard:events
    pub(crate) events: StandardEvents,
    /// solana:signAndSendTransaction
    pub(crate) sign_and_send_tx: SignTransaction,
    /// solana:signTransaction
    pub(crate) sign_tx: SignTransaction,
    /// solana:signMessage
    pub(crate) sign_message: SignMessage,
    /// solana:signIn
    pub(crate) sign_in: Option<SignIn>,
    /// Non-standard features
    extensions: Vec<String>,
}

impl Features {
    /// Parse all the features from a wallet described as a [web_sys::wasm_bindgen::JsValue]
    pub(crate) fn parse(reflection: &Reflection) -> WalletResult<(Self, FeatureSupport)> {
        let features_keys = reflection.object_to_vec_string("features")?;
        let features_object = Reflection::new_from_str(reflection.get_inner(), "features")?;

        let mut features = Features::default();
        let mut supported_features = FeatureSupport::default();

        features_keys.into_iter().try_for_each(|feature| {
            let inner_object = features_object.reflect_inner(&feature)?;
            let inner_object = Reflection::new(inner_object)?;

            if feature.starts_with("standard:") || feature.starts_with("solana:") {
                let version = SemverVersion::from_jsvalue(&inner_object)?;

                if feature == STANDARD_CONNECT_IDENTIFIER {
                    features.connect = Connect::new(&inner_object, version)?;
                    supported_features.connect = true;
                } else if feature == STANDARD_DISCONNECT_IDENTIFIER {
                    features.disconnect = Disconnect::new(&inner_object, version)?;
                    supported_features.disconnect = true;
                } else if feature == STANDARD_EVENTS_IDENTIFIER {
                    features.events = StandardEvents::new(&inner_object, version)?;
                    supported_features.events = true;
                } else if feature == SOLANA_SIGN_AND_SEND_TRANSACTION_IDENTIFIER {
                    features.sign_and_send_tx =
                        SignTransaction::new_sign_and_send_tx(&inner_object, version)?;
                    supported_features.sign_and_send_tx = true;
                } else if feature == SOLANA_SIGN_TRANSACTION_IDENTIFIER {
                    features.sign_tx = SignTransaction::new_sign_tx(&inner_object, version)?;
                    supported_features.sign_tx = true;
                } else if feature == SOLANA_SIGN_MESSAGE_IDENTIFIER {
                    features.sign_message = SignMessage::new(&inner_object, version)?;
                    supported_features.sign_message = true;
                } else if feature == SOLANA_SIGN_IN_IDENTIFIER {
                    features
                        .sign_in
                        .replace(SignIn::new(&inner_object, version)?);
                    supported_features.sign_in = true;
                } else {
                    return Err(WalletError::UnsupportedWalletFeature(feature));
                }
            } else {
                features.extensions.push(feature);
            }

            Ok(())
        })?;

        Ok((features, supported_features))
    }

    /// Get all extensions on the wallet
    pub fn extensions(&self) -> &[String] {
        &self.extensions
    }
}