casper_rust_wasm_sdk/sdk/deploy_utils/
make_transfer.rs

1use crate::types::deploy::Deploy;
2use crate::{
3    types::{
4        deploy_params::{
5            deploy_str_params::{deploy_str_params_to_casper_client, DeployStrParams},
6            payment_str_params::{payment_str_params_to_casper_client, PaymentStrParams},
7        },
8        sdk_error::SdkError,
9    },
10    SDK,
11};
12use casper_client::cli::deploy::make_transfer as client_make_transfer;
13use rand::Rng;
14#[cfg(target_arch = "wasm32")]
15use wasm_bindgen::prelude::*;
16
17/// Exposes the `make_transfer` function to JavaScript with an alias.
18#[cfg(target_arch = "wasm32")]
19#[wasm_bindgen]
20impl SDK {
21    /// JS function for `make_transfer`.
22    ///
23    /// # Arguments
24    ///
25    /// * `amount` - The transfer amount.
26    /// * `target_account` - The target account.
27    /// * `transfer_id` - Optional transfer identifier.
28    /// * `deploy_params` - The deploy parameters.
29    /// * `payment_params` - The payment parameters.
30    ///
31    /// # Returns
32    ///
33    /// A `Result` containing the created `Deploy` or a `JsError` in case of an error.
34    #[wasm_bindgen(js_name = "make_transfer")]
35    #[deprecated(note = "prefer 'make_transfer_transaction'")]
36    #[allow(deprecated)]
37    pub fn make_transfer_js_alias(
38        &self,
39        amount: &str,
40        target_account: &str,
41        transfer_id: Option<String>,
42        deploy_params: DeployStrParams,
43        payment_params: PaymentStrParams,
44    ) -> Result<Deploy, JsError> {
45        // log("make_transfer");
46        let result = self.make_transfer(
47            amount,
48            target_account,
49            transfer_id,
50            deploy_params,
51            payment_params,
52        );
53        match result {
54            Ok(data) => Ok(data),
55            Err(err) => {
56                let err = &format!("Error occurred with {:?}", err);
57                Err(JsError::new(err))
58            }
59        }
60    }
61}
62
63impl SDK {
64    /// Creates a transfer deploy with the provided parameters.
65    ///
66    /// # Arguments
67    ///
68    /// * `amount` - The transfer amount.
69    /// * `target_account` - The target account.
70    /// * `transfer_id` - Optional transfer identifier.
71    /// * `deploy_params` - The deploy parameters.
72    /// * `payment_params` - The payment parameters.
73    ///
74    /// # Returns
75    ///
76    /// A `Result` containing the created `Deploy` or a `SdkError` in case of an error.
77    #[deprecated(note = "prefer 'make_transfer_transaction'")]
78    #[allow(deprecated)]
79    pub fn make_transfer(
80        &self,
81        amount: &str,
82        target_account: &str,
83        transfer_id: Option<String>,
84        deploy_params: DeployStrParams,
85        payment_params: PaymentStrParams,
86    ) -> Result<Deploy, SdkError> {
87        // log("make_transfer");
88        make_transfer(
89            amount,
90            target_account,
91            transfer_id,
92            deploy_params,
93            payment_params,
94        )
95    }
96}
97
98/// Internal function to create a transfer deploy.
99#[deprecated(note = "prefer 'make_transfer_transaction'")]
100#[allow(deprecated)]
101pub(crate) fn make_transfer(
102    amount: &str,
103    target_account: &str,
104    transfer_id: Option<String>,
105    deploy_params: DeployStrParams,
106    payment_params: PaymentStrParams,
107) -> Result<Deploy, SdkError> {
108    let transfer_id = if let Some(transfer_id) = transfer_id {
109        transfer_id
110    } else {
111        rand::thread_rng().gen::<u64>().to_string()
112    };
113    client_make_transfer(
114        "",
115        amount,
116        target_account,
117        &transfer_id,
118        deploy_str_params_to_casper_client(&deploy_params),
119        payment_str_params_to_casper_client(&payment_params),
120        false,
121    )
122    .map(Into::into)
123    .map_err(SdkError::from)
124}
125
126#[cfg(test)]
127#[allow(deprecated)]
128mod tests {
129    use super::*;
130    use crate::helpers::public_key_from_secret_key;
131    use sdk_tests::{
132        config::{PAYMENT_TRANSFER_AMOUNT, TRANSFER_AMOUNT},
133        tests::helpers::{get_network_constants, get_user_secret_key},
134    };
135
136    #[tokio::test]
137    async fn test_make_transfer_with_valid_transfer_params() {
138        // Arrange
139        let sdk = SDK::new(None, None, None);
140        let (_, _, _, _, chain_name) = get_network_constants();
141        let secret_key = get_user_secret_key(None).unwrap();
142        let account = public_key_from_secret_key(&secret_key).unwrap();
143
144        let deploy_params =
145            DeployStrParams::new(&chain_name, &account, Some(secret_key), None, None, None);
146        let payment_params = PaymentStrParams::default();
147        payment_params.set_payment_amount(PAYMENT_TRANSFER_AMOUNT);
148
149        // Act
150        let result = sdk.make_transfer(
151            TRANSFER_AMOUNT,
152            &account,
153            None,
154            deploy_params,
155            payment_params,
156        );
157
158        // Assert
159        assert!(result.is_ok());
160    }
161
162    #[tokio::test]
163    async fn test_make_transfer_with_valid_transfer_params_without_secret_key() {
164        // Arrange
165        let sdk = SDK::new(None, None, None);
166        let (_, _, _, _, chain_name) = get_network_constants();
167        let secret_key = get_user_secret_key(None).unwrap();
168        let account = public_key_from_secret_key(&secret_key).unwrap();
169
170        let deploy_params = DeployStrParams::new(&chain_name, &account, None, None, None, None);
171        let payment_params = PaymentStrParams::default();
172        payment_params.set_payment_amount(PAYMENT_TRANSFER_AMOUNT);
173
174        // Act
175        let result = sdk.make_transfer(
176            TRANSFER_AMOUNT,
177            &account,
178            None,
179            deploy_params,
180            payment_params,
181        );
182
183        // Assert
184        assert!(result.is_ok());
185    }
186
187    #[tokio::test]
188    async fn test_make_transfer_with_invalid_transfer_params() {
189        // Arrange
190        let sdk = SDK::new(None, None, None);
191        let (_, _, _, _, chain_name) = get_network_constants();
192        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\"]";
193        let secret_key = get_user_secret_key(None).unwrap();
194        let account = public_key_from_secret_key(&secret_key).unwrap();
195
196        let deploy_params =
197            DeployStrParams::new(&chain_name, &account, Some(secret_key), None, None, None);
198        let payment_params = PaymentStrParams::default();
199        payment_params.set_payment_amount(""); // This is not valid payment amount
200
201        // Act
202        let result = sdk.make_transfer(
203            TRANSFER_AMOUNT,
204            &account,
205            None,
206            deploy_params,
207            payment_params,
208        );
209        // Assert
210
211        assert!(result.is_err());
212
213        let err_string = result.err().unwrap().to_string();
214        assert!(err_string.contains(error_message));
215    }
216}