wallet_standard 0.5.1

An implementation of the solana wallet standard 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
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use std::fmt::Display;

use serde::Deserialize;
use serde::Serialize;

#[derive(Debug, Clone, thiserror::Error, Eq, PartialEq, Serialize, Deserialize)]
pub enum WalletError {
	#[error("the arguments provided are not valid")]
	InvalidArguments,
	#[error("icon is not valid")]
	InvalidIcon,
	#[error("The identifier could not be parsed: {0}")]
	InvalidIdentifier(String),
	#[error("The signature is not valid")]
	InvalidSignature,
	#[error("Signer: {0}")]
	Signer(String),
	#[error("{0}")]
	Js(String),
	#[error("Parsing string failed: {0}")]
	ParseString(String),
	#[error(transparent)]
	#[cfg(feature = "solana")]
	Program(#[from] solana_program_error::ProgramError),
	#[error("an error occured during deserialization: {0}")]
	Serde(String),
	#[cfg(feature = "solana")]
	#[error(transparent)]
	Transaction(#[from] solana_transaction_error::TransactionError),
	#[error("the requested feature: `{feature}` is not supported for this wallet: `{wallet}`")]
	UnsupportedFeature { feature: String, wallet: String },
	#[error("icon type is not supported")]
	UnsupportedIconType,
	#[error("The transaction version is not supported by this wallet")]
	UnsupportedTransactionVersion,
	#[error("Wallet account not connected")]
	WalletAccount,
	#[error("The wallet configuration is invalid")]
	WalletConfig,
	#[error("An error occurred while connecting to the wallet")]
	WalletConnection,
	#[error("Could not decrypt the provided data")]
	WalletDecrypt,
	#[error("Action can't be performed because the wallet is disconnected")]
	WalletDisconnected,
	#[error("Error while disconnecting wallet")]
	WalletDisconnection,
	#[error("Could not encrypt the provided data")]
	WalletEncrypt,
	#[error("Wallet keypair")]
	WalletKeypair,
	#[error("Error loading the wallet")]
	WalletLoad,
	#[error("Wallet not connected")]
	WalletNotConnected,
	#[error("The wallet is not yet ready")]
	WalletNotReady,
	#[error("Invalid wallet public key")]
	WalletPublicKey,
	#[error("Wallet send transaction")]
	WalletSendTransaction,
	#[error("Wallet sign in")]
	WalletSignIn,
	#[error("Wallet sign in fields: {0}")]
	WalletSignInFields(String),
	#[error("Wallet sign message")]
	WalletSignMessage,
	#[error("Wallet sign transaction")]
	WalletSignTransaction,
	#[error("Wallet timeout")]
	WalletTimeout,
	#[error("Wallet window blocked")]
	WalletWindowBlocked,
	#[error("Wallet window closed")]
	WalletWindowClosed,
	/// An error from an external source. Implement `IntoWalletError` for your
	/// error to support this functionality.
	#[error("{0}")]
	External(String),
}

impl From<core::fmt::Error> for WalletError {
	fn from(value: core::fmt::Error) -> Self {
		WalletError::ParseString(value.to_string())
	}
}

#[cfg(feature = "browser")]
#[allow(unused_qualifications)]
impl From<wasm_bindgen::JsValue> for WalletError {
	#[allow(deprecated)]
	fn from(source: wasm_bindgen::JsValue) -> Self {
		WalletError::Js(
			source
				.as_string()
				.unwrap_or("An error occurred in the JavaScript.".to_string()),
		)
	}
}
#[cfg(feature = "solana")]
impl From<solana_signer::SignerError> for WalletError {
	fn from(error: solana_signer::SignerError) -> Self {
		WalletError::Signer(error.to_string())
	}
}

#[cfg(feature = "browser")]
impl From<serde_wasm_bindgen::Error> for WalletError {
	fn from(source: serde_wasm_bindgen::Error) -> Self {
		WalletError::Serde(source.to_string())
	}
}

pub type WalletResult<T> = Result<T, WalletError>;

pub trait IntoWalletError: Display {}

impl<E: IntoWalletError> From<E> for WalletError {
	fn from(value: E) -> Self {
		WalletError::External(value.to_string())
	}
}