casper_rust_wasm_sdk/sdk/deploy/
transfer.rs

1#[cfg(target_arch = "wasm32")]
2use crate::deploy::deploy::PutDeployResult;
3use crate::{
4    types::{
5        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        },
9        sdk_error::SdkError,
10        verbosity::Verbosity,
11    },
12    SDK,
13};
14use casper_client::{
15    cli::deploy::make_transfer, rpcs::results::PutDeployResult as _PutDeployResult, SuccessResponse,
16};
17use rand::Rng;
18#[cfg(target_arch = "wasm32")]
19use wasm_bindgen::prelude::*;
20
21#[cfg(target_arch = "wasm32")]
22#[wasm_bindgen]
23impl SDK {
24    /// JS function for transferring funds.
25    ///
26    /// # Arguments
27    ///
28    /// * `amount` - The amount to transfer.
29    /// * `target_account` - The target account.
30    /// * `transfer_id` - An optional transfer ID (defaults to a random number).
31    /// * `deploy_params` - The deployment parameters.
32    /// * `payment_params` - The payment parameters.
33    /// * `verbosity` - The verbosity level for logging (optional).
34    /// * `rpc_address` - The address of the node to connect to (optional).
35    ///
36    /// # Returns
37    ///
38    /// A `Result` containing the result of the transfer or a `JsError` in case of an error.
39    #[wasm_bindgen(js_name = "transfer")]
40    #[deprecated(note = "prefer transfer_transaction")]
41    #[allow(clippy::too_many_arguments, deprecated)]
42    pub async fn transfer_js_alias(
43        &self,
44        amount: &str,
45        target_account: &str,
46        transfer_id: Option<String>,
47        deploy_params: DeployStrParams,
48        payment_params: PaymentStrParams,
49        verbosity: Option<Verbosity>,
50        rpc_address: Option<String>,
51    ) -> Result<PutDeployResult, JsError> {
52        let result = self
53            .transfer(
54                amount,
55                target_account,
56                transfer_id,
57                deploy_params,
58                payment_params,
59                verbosity,
60                rpc_address,
61            )
62            .await;
63        match result {
64            Ok(data) => Ok(data.result.into()),
65            Err(err) => {
66                let err = &format!("Error occurred with {:?}", err);
67                Err(JsError::new(err))
68            }
69        }
70    }
71}
72
73impl SDK {
74    /// Perform a transfer of funds.
75    ///
76    /// # Arguments
77    ///
78    /// * `amount` - The amount to transfer.
79    /// * `target_account` - The target account.
80    /// * `transfer_id` - An optional transfer ID (defaults to a random number).
81    /// * `deploy_params` - The deployment parameters.
82    /// * `payment_params` - The payment parameters.
83    /// * `verbosity` - The verbosity level for logging (optional).
84    /// * `rpc_address` - The address of the node to connect to (optional).
85    ///
86    /// # Returns
87    ///
88    /// A `Result` containing the result a `SuccessResponse<_PutDeployResult>` of the transfer or a `SdkError` in case of an error.
89    #[deprecated(note = "prefer transfer_transaction")]
90    #[allow(clippy::too_many_arguments, deprecated)]
91    pub async fn transfer(
92        &self,
93        amount: &str,
94        target_account: &str,
95        transfer_id: Option<String>,
96        deploy_params: DeployStrParams,
97        payment_params: PaymentStrParams,
98        verbosity: Option<Verbosity>,
99        rpc_address: Option<String>,
100    ) -> Result<SuccessResponse<_PutDeployResult>, SdkError> {
101        //log("transfer!");
102        let transfer_id = if let Some(transfer_id) = transfer_id {
103            transfer_id
104        } else {
105            rand::thread_rng().gen::<u64>().to_string()
106        };
107        let deploy = make_transfer(
108            "",
109            amount,
110            target_account,
111            &transfer_id,
112            deploy_str_params_to_casper_client(&deploy_params),
113            payment_str_params_to_casper_client(&payment_params),
114            false,
115        );
116
117        if let Err(err) = deploy {
118            return Err(SdkError::from(err));
119        }
120
121        self.put_deploy(deploy.unwrap().into(), verbosity, rpc_address)
122            .await
123            .map_err(SdkError::from)
124    }
125}
126
127#[cfg(test)]
128#[allow(deprecated)]
129mod tests {
130
131    use super::*;
132    use crate::helpers::public_key_from_secret_key;
133    use sdk_tests::{
134        config::{PAYMENT_TRANSFER_AMOUNT, TRANSFER_AMOUNT},
135        tests::helpers::{get_network_constants, get_user_secret_key},
136    };
137
138    #[tokio::test]
139    async fn test_transfer_with_valid_transfer_params() {
140        // Arrange
141        let sdk = SDK::new(None, None, None);
142        let verbosity = Some(Verbosity::High);
143        let (rpc_address, _, _, _, chain_name) = get_network_constants();
144
145        let secret_key = get_user_secret_key(None).unwrap();
146        let account = public_key_from_secret_key(&secret_key).unwrap();
147
148        let deploy_params =
149            DeployStrParams::new(&chain_name, &account, Some(secret_key), None, None, None);
150        let payment_params = PaymentStrParams::default();
151        payment_params.set_payment_amount(PAYMENT_TRANSFER_AMOUNT);
152
153        // Act
154        let result = sdk
155            .transfer(
156                TRANSFER_AMOUNT,
157                &account,
158                None,
159                deploy_params,
160                payment_params,
161                verbosity,
162                Some(rpc_address),
163            )
164            .await;
165
166        // Assert
167        assert!(result.is_ok());
168    }
169
170    #[tokio::test]
171    async fn test_transfer_with_valid_transfer_params_without_secret_key() {
172        // Arrange
173        let sdk = SDK::new(None, None, None);
174        let verbosity = Some(Verbosity::High);
175        let (rpc_address, _, _, _, chain_name) = get_network_constants();
176
177        let error_message = "Invalid Deploy";
178
179        let secret_key = get_user_secret_key(None).unwrap();
180        let account = public_key_from_secret_key(&secret_key).unwrap();
181
182        let deploy_params = DeployStrParams::new(&chain_name, &account, None, None, None, None);
183        let payment_params = PaymentStrParams::default();
184        payment_params.set_payment_amount(PAYMENT_TRANSFER_AMOUNT);
185
186        // Act
187        let result = sdk
188            .transfer(
189                TRANSFER_AMOUNT,
190                &account,
191                None,
192                deploy_params,
193                payment_params,
194                verbosity,
195                Some(rpc_address),
196            )
197            .await;
198
199        // Assert
200        assert!(result.is_err());
201        let err_string = result.err().unwrap().to_string();
202        assert!(err_string.contains(error_message));
203    }
204
205    #[tokio::test]
206    async fn test_transfer_with_invalid_transfer_params() {
207        // Arrange
208        let sdk = SDK::new(None, None, None);
209        let verbosity = Some(Verbosity::High);
210        let (rpc_address, _, _, _, chain_name) = get_network_constants();
211
212        let error_message = "Missing a required arg - exactly one of the following must be provided: [\"payment_amount\", \"payment_hash\", \"payment_name\", \"payment_package_hash\", \"payment_package_name\", \"payment_path\", \"has_payment_bytes\"]";
213        let secret_key = get_user_secret_key(None).unwrap();
214        let account = public_key_from_secret_key(&secret_key).unwrap();
215
216        let deploy_params =
217            DeployStrParams::new(&chain_name, &account, Some(secret_key), None, None, None);
218        let payment_params = PaymentStrParams::default();
219        payment_params.set_payment_amount(""); // This is not valid payment amount
220
221        // Act
222        let result = sdk
223            .transfer(
224                TRANSFER_AMOUNT,
225                &account,
226                None,
227                deploy_params,
228                payment_params,
229                verbosity,
230                Some(rpc_address),
231            )
232            .await;
233        // Assert
234        assert!(result.is_err());
235
236        let err_string = result.err().unwrap().to_string();
237        assert!(err_string.contains(error_message));
238    }
239}