casper_rust_wasm_sdk/sdk/rpcs/
get_chainspec.rs1use crate::{types::verbosity::Verbosity, SDK};
2use casper_client::{
3 get_chainspec, rpcs::results::GetChainspecResult as _GetChainspecResult, Error, JsonRpcId,
4 SuccessResponse,
5};
6#[cfg(target_arch = "wasm32")]
7use gloo_utils::format::JsValueSerdeExt;
8use rand::Rng;
9#[cfg(target_arch = "wasm32")]
10use serde::{Deserialize, Serialize};
11#[cfg(target_arch = "wasm32")]
12use wasm_bindgen::prelude::*;
13
14#[cfg(target_arch = "wasm32")]
16#[derive(Debug, Deserialize, Clone, Serialize)]
17#[wasm_bindgen]
18pub struct GetChainspecResult(_GetChainspecResult);
19
20#[cfg(target_arch = "wasm32")]
21impl From<GetChainspecResult> for _GetChainspecResult {
22 fn from(result: GetChainspecResult) -> Self {
23 result.0
24 }
25}
26
27#[cfg(target_arch = "wasm32")]
28impl From<_GetChainspecResult> for GetChainspecResult {
29 fn from(result: _GetChainspecResult) -> Self {
30 GetChainspecResult(result)
31 }
32}
33
34#[cfg(target_arch = "wasm32")]
36#[wasm_bindgen]
37impl GetChainspecResult {
38 #[wasm_bindgen(getter)]
40 pub fn api_version(&self) -> JsValue {
41 JsValue::from_serde(&self.0.api_version).unwrap()
42 }
43
44 #[wasm_bindgen(getter)]
46 pub fn chainspec_bytes(&self) -> JsValue {
47 JsValue::from_serde(&self.0.chainspec_bytes).unwrap()
48 }
49
50 #[wasm_bindgen(js_name = "toJson")]
52 pub fn to_json(&self) -> JsValue {
53 JsValue::from_serde(&self.0).unwrap_or(JsValue::null())
54 }
55}
56
57#[cfg(target_arch = "wasm32")]
59#[wasm_bindgen]
60impl SDK {
61 #[wasm_bindgen(js_name = "get_chainspec")]
72 pub async fn get_chainspec_js_alias(
73 &self,
74 verbosity: Option<Verbosity>,
75 rpc_address: Option<String>,
76 ) -> Result<GetChainspecResult, JsError> {
77 let result = self.get_chainspec(verbosity, rpc_address).await;
78 match result {
79 Ok(data) => Ok(data.result.into()),
80 Err(err) => {
81 let err = &format!("Error occurred with {:?}", err);
82 Err(JsError::new(err))
83 }
84 }
85 }
86
87 #[deprecated(note = "This function is an alias. Please use `get_chainspec` instead.")]
89 #[allow(deprecated)]
90 pub async fn info_get_chainspec(
91 &self,
92 verbosity: Option<Verbosity>,
93 rpc_address: Option<String>,
94 ) -> Result<GetChainspecResult, JsError> {
95 self.get_chainspec_js_alias(verbosity, rpc_address).await
96 }
97}
98
99impl SDK {
101 pub async fn get_chainspec(
112 &self,
113 verbosity: Option<Verbosity>,
114 rpc_address: Option<String>,
115 ) -> Result<SuccessResponse<_GetChainspecResult>, Error> {
116 get_chainspec(
118 JsonRpcId::from(rand::thread_rng().gen::<u64>().to_string()),
119 &self.get_rpc_address(rpc_address),
120 self.get_verbosity(verbosity).into(),
121 )
122 .await
123 }
124}
125
126#[cfg(test)]
127mod tests {
128 use super::*;
129 use sdk_tests::tests::helpers::get_network_constants;
130
131 #[tokio::test]
132 async fn test_get_chainspec_with_none_values() {
133 let sdk = SDK::new(None, None, None);
135 let error_message = "failed to parse node address as valid URL";
136
137 let result = sdk.get_chainspec(None, None).await;
139
140 assert!(result.is_err());
142 let err_string = result.err().unwrap().to_string();
143 assert!(err_string.contains(error_message));
144 }
145
146 #[tokio::test]
147 async fn test_get_chainspec_with_specific_arguments() {
148 let sdk = SDK::new(None, None, None);
150 let verbosity = Some(Verbosity::High);
151 let (rpc_address, _, _, _, _) = get_network_constants();
152
153 let result = sdk.get_chainspec(verbosity, Some(rpc_address)).await;
155
156 assert!(result.is_ok());
158 }
159
160 #[tokio::test]
161 async fn test_get_chainspec_with_error() {
162 let sdk = SDK::new(Some("http://localhost".to_string()), None, None);
163
164 let error_message = "error sending request for url (http://localhost/rpc)";
165
166 let result = sdk.get_chainspec(None, None).await;
168
169 assert!(result.is_err());
171 let err_string = result.err().unwrap().to_string();
172 assert!(err_string.contains(error_message));
173 }
174}