casper_rust_wasm_sdk/sdk/rpcs/
get_chainspec.rs

1use 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/// A struct representing the result of the `get_chainspec` function.
15#[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/// Implementations for the `GetChainspecResult` struct.
35#[cfg(target_arch = "wasm32")]
36#[wasm_bindgen]
37impl GetChainspecResult {
38    /// Gets the API version as a JsValue.
39    #[wasm_bindgen(getter)]
40    pub fn api_version(&self) -> JsValue {
41        JsValue::from_serde(&self.0.api_version).unwrap()
42    }
43
44    /// Gets the chainspec bytes as a JsValue.
45    #[wasm_bindgen(getter)]
46    pub fn chainspec_bytes(&self) -> JsValue {
47        JsValue::from_serde(&self.0.chainspec_bytes).unwrap()
48    }
49
50    /// Converts the `GetChainspecResult` to a JsValue.
51    #[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/// Implementations for the `SDK` struct.
58#[cfg(target_arch = "wasm32")]
59#[wasm_bindgen]
60impl SDK {
61    /// Asynchronously retrieves the chainspec.
62    ///
63    /// # Arguments
64    ///
65    /// * `verbosity` - An optional `Verbosity` parameter.
66    /// * `rpc_address` - An optional rpc address as a string.
67    ///
68    /// # Returns
69    ///
70    /// A `Result` containing either a `GetChainspecResult` or a `JsError` in case of an error.
71    #[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    // JavaScript alias for `get_chainspec`.
88    #[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
99/// Implementations for the `SDK` struct.
100impl SDK {
101    /// Asynchronously retrieves the chainspec.
102    ///
103    /// # Arguments
104    ///
105    /// * `verbosity` - An optional `Verbosity` parameter.
106    /// * `rpc_address` - An optional rpc address as a string.
107    ///
108    /// # Returns
109    ///
110    /// A `Result` containing either a `_GetChainspecResult` or a `SdkError` in case of an error.
111    pub async fn get_chainspec(
112        &self,
113        verbosity: Option<Verbosity>,
114        rpc_address: Option<String>,
115    ) -> Result<SuccessResponse<_GetChainspecResult>, Error> {
116        //log("get_chainspec!");
117        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        // Arrange
134        let sdk = SDK::new(None, None, None);
135        let error_message = "failed to parse node address as valid URL";
136
137        // Act
138        let result = sdk.get_chainspec(None, None).await;
139
140        // Assert
141        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        // Arrange
149        let sdk = SDK::new(None, None, None);
150        let verbosity = Some(Verbosity::High);
151        let (rpc_address, _, _, _, _) = get_network_constants();
152
153        // Act
154        let result = sdk.get_chainspec(verbosity, Some(rpc_address)).await;
155
156        // Assert
157        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        // Act
167        let result = sdk.get_chainspec(None, None).await;
168
169        // Assert
170        assert!(result.is_err());
171        let err_string = result.err().unwrap().to_string();
172        assert!(err_string.contains(error_message));
173    }
174}