casper_rust_wasm_sdk/sdk/contract/
call_entrypoint_deploy.rs

1#![allow(deprecated)]
2
3#[cfg(all(feature = "js", target_arch = "wasm32"))]
4use crate::deploy::deploy::PutDeployResult;
5use crate::types::deploy_params::{
6    deploy_str_params::{deploy_str_params_to_casper_client, DeployStrParams},
7    payment_str_params::{payment_str_params_to_casper_client, PaymentStrParams},
8    session_str_params::{session_str_params_to_casper_client, SessionStrParams},
9};
10use crate::{types::sdk_error::SdkError, SDK};
11use casper_client::{
12    cli::deploy::make_deploy, rpcs::results::PutDeployResult as _PutDeployResult, SuccessResponse,
13};
14#[cfg(all(feature = "js", target_arch = "wasm32"))]
15use wasm_bindgen::prelude::*;
16
17/// A set of functions for working with smart contract entry points.
18#[cfg(all(feature = "js", target_arch = "wasm32"))]
19#[cfg_attr(feature = "js", wasm_bindgen)]
20impl SDK {
21    /// Calls a smart contract entry point with the specified parameters and returns the result.
22    ///
23    /// # Arguments
24    ///
25    /// * `deploy_params` - The deploy parameters.
26    /// * `session_params` - The session parameters.
27    /// * `payment_amount` - The payment amount as a string.
28    /// * `rpc_address` - An optional rpc address to send the request to.
29    ///
30    /// # Returns
31    ///
32    /// A `Result` containing either a `PutDeployResult` or a `JsError` in case of an error.
33    ///
34    /// # Errors
35    ///
36    /// Returns a `JsError` if there is an error during the call.
37    #[cfg_attr(feature = "js", wasm_bindgen(js_name = "call_entrypoint_deploy"))]
38    #[deprecated(note = "prefer 'call_entrypoint' with transaction")]
39    #[allow(deprecated)]
40    #[cfg(feature = "js")]
41    pub async fn call_entrypoint_deploy_js_alias(
42        &self,
43        deploy_params: DeployStrParams,
44        session_params: SessionStrParams,
45        payment_amount: &str,
46        rpc_address: Option<String>,
47    ) -> Result<PutDeployResult, JsError> {
48        let payment_params = PaymentStrParams::default();
49        payment_params.set_payment_amount(payment_amount);
50
51        let result = self
52            .call_entrypoint_deploy(deploy_params, session_params, payment_params, rpc_address)
53            .await;
54        match result {
55            Ok(data) => Ok(data.result.into()),
56            Err(err) => {
57                let err = &format!("Error occurred with {err:?}");
58                Err(JsError::new(err))
59            }
60        }
61    }
62}
63
64/// A set of functions for working with smart contract entry points.
65/// Alias of sdk.deploy
66impl SDK {
67    /// Calls a smart contract entry point with the specified parameters and returns the result.
68    ///
69    /// # Arguments
70    ///
71    /// * `deploy_params` - The deploy parameters.
72    /// * `session_params` - The session parameters.
73    /// * `payment_params` - The payment parameters.
74    /// * `rpc_address` - An optional rpc address to send the request to.
75    ///
76    /// # Returns
77    ///
78    /// A `Result` containing either a `_PutDeployResult` or a `SdkError` in case of an error.
79    ///
80    /// # Errors
81    ///
82    /// Returns a `SdkError` if there is an error during the call.
83    #[deprecated(note = "prefer 'call_entrypoint' with transaction")]
84    #[allow(deprecated)]
85    pub async fn call_entrypoint_deploy(
86        &self,
87        deploy_params: DeployStrParams,
88        session_params: SessionStrParams,
89        payment_params: PaymentStrParams,
90        rpc_address: Option<String>,
91    ) -> Result<SuccessResponse<_PutDeployResult>, SdkError> {
92        //log("call_entrypoint_deploy!");
93        let deploy = make_deploy(
94            "",
95            deploy_str_params_to_casper_client(&deploy_params),
96            session_str_params_to_casper_client(&session_params),
97            payment_str_params_to_casper_client(&payment_params),
98            false,
99        )?;
100
101        self.put_deploy(deploy.into(), None, rpc_address).await
102    }
103}
104
105#[cfg(test)]
106#[allow(deprecated)]
107mod tests {
108    use super::*;
109    use crate::{helpers::public_key_from_secret_key, install_cep78};
110    use sdk_tests::{
111        config::{ARGS_SIMPLE, ENTRYPOINT_MINT, PAYMENT_AMOUNT, TTL},
112        tests::helpers::{get_network_constants, get_user_secret_key},
113    };
114    use tokio;
115
116    async fn get_contract_hash() -> String {
117        install_cep78().await
118    }
119
120    #[tokio::test]
121    async fn test_call_entrypoint_deploy_with_none_values() {
122        // Arrange
123        let sdk = SDK::new(None, None, None);
124        let deploy_params = DeployStrParams::new("", "", None, None, None, None);
125        let session_params = SessionStrParams::default();
126        let payment_params = PaymentStrParams::default();
127
128        let error_message =
129            "Invalid argument 'is_session_transfer': requires --session-arg to be present";
130
131        // Act
132        let result = sdk
133            .call_entrypoint_deploy(deploy_params, session_params, payment_params, None)
134            .await;
135
136        // Assert
137        assert!(result.is_err());
138        let err_string = result.err().unwrap().to_string();
139        assert!(err_string.contains(error_message));
140    }
141
142    #[tokio::test]
143    async fn test_call_entrypoint_deploy_with_valid_input() {
144        // Arrange
145        let sdk = SDK::new(None, None, None);
146        let (rpc_address, _, _, _, chain_name) = get_network_constants();
147        let secret_key = get_user_secret_key(None).unwrap();
148        let account = public_key_from_secret_key(&secret_key).unwrap();
149
150        let deploy_params =
151            DeployStrParams::new(&chain_name, &account, Some(secret_key), None, None, None);
152
153        let payment_params = PaymentStrParams::default();
154        payment_params.set_payment_amount(PAYMENT_AMOUNT);
155
156        let mut session_params = SessionStrParams::default();
157        session_params.set_session_hash(&crate::helpers::contract_hash_key_for_global_state(
158            &get_contract_hash().await,
159        ));
160        session_params.set_session_entry_point(ENTRYPOINT_MINT);
161        let args_simple: Vec<String> = ARGS_SIMPLE.iter().map(|s| s.to_string()).collect();
162        session_params.set_session_args_simple(args_simple);
163
164        // Act
165        let result = sdk
166            .call_entrypoint_deploy(
167                deploy_params,
168                session_params,
169                payment_params,
170                Some(rpc_address),
171            )
172            .await;
173
174        // Assert
175        assert!(result.is_ok());
176        let deploy_hash = result.unwrap().result.deploy_hash;
177        assert!(!deploy_hash.to_string().is_empty());
178    }
179
180    #[tokio::test]
181    async fn test_call_entrypoint_deploy_with_invalid_input() {
182        // Arrange
183        let sdk = SDK::new(None, None, None);
184        let (rpc_address, _, _, _, chain_name) = get_network_constants();
185        let secret_key = get_user_secret_key(None).unwrap();
186        let account = public_key_from_secret_key(&secret_key).unwrap();
187
188        let error_message =
189            "Missing a required arg - exactly one of the following must be provided";
190
191        let deploy_params = DeployStrParams::new(
192            &chain_name,
193            &account,
194            Some(secret_key.clone()),
195            None,
196            Some(TTL.to_string()),
197            None,
198        );
199
200        let payment_params = PaymentStrParams::default();
201        payment_params.set_payment_amount(""); // This is not valid payment amount
202
203        let mut session_params = SessionStrParams::default();
204        session_params.set_session_hash(
205            "hash-cfa781f5eb69c3eee952c2944ce9670a049f88c5e46b83fb5881ebe13fb98e6d",
206        );
207        session_params.set_session_entry_point(ENTRYPOINT_MINT);
208        let args_simple: Vec<String> = ARGS_SIMPLE.iter().map(|s| s.to_string()).collect();
209        session_params.set_session_args_simple(args_simple);
210
211        // Act
212        let result = sdk
213            .call_entrypoint_deploy(
214                deploy_params,
215                session_params,
216                payment_params,
217                Some(rpc_address),
218            )
219            .await;
220
221        // Assert
222        assert!(result.is_err());
223        let err_string = result.err().unwrap().to_string();
224        assert!(err_string.contains(error_message));
225    }
226
227    #[tokio::test]
228    async fn test_call_entrypoint_deploy_without_secret_key() {
229        // Arrange
230        let sdk = SDK::new(None, None, None);
231        let (rpc_address, _, _, _, chain_name) = get_network_constants();
232        let secret_key = get_user_secret_key(None).unwrap();
233        let account = public_key_from_secret_key(&secret_key).unwrap();
234
235        let error_message = "the deploy was invalid: invalid associated keys";
236
237        let deploy_params = DeployStrParams::new(
238            &chain_name,
239            &account,
240            None,
241            None,
242            Some(TTL.to_string()),
243            None,
244        );
245        let payment_params = PaymentStrParams::default();
246        payment_params.set_payment_amount(PAYMENT_AMOUNT);
247
248        let mut session_params = SessionStrParams::default();
249        session_params.set_session_hash(
250            "hash-cfa781f5eb69c3eee952c2944ce9670a049f88c5e46b83fb5881ebe13fb98e6d",
251        );
252        session_params.set_session_entry_point(ENTRYPOINT_MINT);
253        let args_simple: Vec<String> = ARGS_SIMPLE.iter().map(|s| s.to_string()).collect();
254        session_params.set_session_args_simple(args_simple);
255
256        // Act
257        let result = sdk
258            .call_entrypoint_deploy(
259                deploy_params,
260                session_params,
261                payment_params,
262                Some(rpc_address),
263            )
264            .await;
265
266        // Assert
267        assert!(result.is_err());
268        let err_string = result.err().unwrap().to_string();
269        assert!(err_string.contains(error_message));
270    }
271
272    #[tokio::test]
273    async fn test_call_entrypoint_deploy_with_error() {
274        // Arrange
275        let sdk = SDK::new(Some("http://localhost".to_string()), None, None);
276        let (_, _, _, _, chain_name) = get_network_constants();
277        let secret_key = get_user_secret_key(None).unwrap();
278        let account = public_key_from_secret_key(&secret_key).unwrap();
279
280        let deploy_params = DeployStrParams::new(
281            &chain_name,
282            &account,
283            Some(secret_key.clone()),
284            None,
285            None,
286            None,
287        );
288
289        let error_message = "error sending request";
290
291        let payment_params = PaymentStrParams::default();
292        payment_params.set_payment_amount(PAYMENT_AMOUNT);
293
294        let mut session_params = SessionStrParams::default();
295        session_params.set_session_hash(
296            "hash-cfa781f5eb69c3eee952c2944ce9670a049f88c5e46b83fb5881ebe13fb98e6d",
297        );
298        session_params.set_session_entry_point(ENTRYPOINT_MINT);
299        let args_simple: Vec<String> = ARGS_SIMPLE.iter().map(|s| s.to_string()).collect();
300        session_params.set_session_args_simple(args_simple);
301
302        // Act
303        let result = sdk
304            .call_entrypoint_deploy(deploy_params, session_params, payment_params, None)
305            .await;
306
307        // Assert
308        assert!(result.is_err());
309        let err_string = result.err().unwrap().to_string();
310        assert!(err_string.contains(error_message));
311    }
312}
casper_rust_wasm_sdk/sdk/contract/call_entrypoint_deploy.rs

casper_rust_wasm_sdk/sdk/contract/
call_entrypoint_deploy.rs
