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        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        // Arrange
135        let sdk = SDK::new(None, None, None);
136        let error_message = "failed to parse node address as valid URL";
137
138        // Act
139        let result = sdk.get_chainspec(None, None).await;
140
141        // Assert
142        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        // Arrange
150        let sdk = SDK::new(None, None, None);
151        let verbosity = Some(Verbosity::High);
152        let (rpc_address, _, _, _, _) = get_network_constants();
153
154        // Act
155        let result = sdk.get_chainspec(verbosity, Some(rpc_address)).await;
156
157        // Assert
158        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        // Act
168        let result = sdk.get_chainspec(None, None).await;
169
170        // Assert
171        assert!(result.is_err());
172        let err_string = result.err().unwrap().to_string();
173        assert!(err_string.contains(error_message));
174    }
175}