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 let random_id = JsonRpcId::from(rand::thread_rng().gen::<u64>().to_string());
118 get_chainspec(
119 random_id,
120 &self.get_rpc_address(rpc_address),
121 self.get_verbosity(verbosity).into(),
122 )
123 .await
124 }
125}
126
127#[cfg(test)]
128mod tests {
129 use super::*;
130 use sdk_tests::tests::helpers::get_network_constants;
131
132 #[tokio::test]
133 async fn test_get_chainspec_with_none_values() {
134 let sdk = SDK::new(None, None, None);
136 let error_message = "failed to parse node address as valid URL";
137
138 let result = sdk.get_chainspec(None, None).await;
140
141 assert!(result.is_err());
143 let err_string = result.err().unwrap().to_string();
144 assert!(err_string.contains(error_message));
145 }
146
147 #[tokio::test]
148 async fn test_get_chainspec_with_specific_arguments() {
149 let sdk = SDK::new(None, None, None);
151 let verbosity = Some(Verbosity::High);
152 let (rpc_address, _, _, _, _) = get_network_constants();
153
154 let result = sdk.get_chainspec(verbosity, Some(rpc_address)).await;
156
157 assert!(result.is_ok());
159 }
160
161 #[tokio::test]
162 async fn test_get_chainspec_with_error() {
163 let sdk = SDK::new(Some("http://localhost".to_string()), None, None);
164
165 let error_message = "error sending request";
166
167 let result = sdk.get_chainspec(None, None).await;
169
170 assert!(result.is_err());
172 let err_string = result.err().unwrap().to_string();
173 assert!(err_string.contains(error_message));
174 }
175}