casper_rust_wasm_sdk/sdk/contract/
call_entrypoint_deploy.rs

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

casper_rust_wasm_sdk/sdk/contract/
call_entrypoint_deploy.rs
