fireblocks_sdk/client/
whitelist.rs

1use {
2    super::Client,
3    crate::{
4        WalletContainer,
5        WalletType,
6        apis::{
7            Api,
8            whitelisted_contracts_api::{
9                AddContractAssetParams,
10                CreateContractParams,
11                DeleteContractParams,
12                GetContractParams,
13            },
14            whitelisted_external_wallets_api::{
15                AddAssetToExternalWalletParams,
16                CreateExternalWalletParams,
17                DeleteExternalWalletParams,
18                GetExternalWalletParams,
19            },
20            whitelisted_internal_wallets_api::{
21                CreateInternalWalletAssetParams,
22                CreateInternalWalletParams,
23                DeleteInternalWalletParams,
24                GetInternalWalletParams,
25            },
26        },
27        error::FireblocksError,
28        models::{
29            AddAssetToExternalWalletRequest,
30            BasicAddressRequest,
31            CreateContractRequest,
32            CreateInternalWalletAssetRequest,
33            CreateWalletRequest,
34        },
35    },
36};
37
38impl Client {
39    /// Create asset in a wallet
40    /// # Panics
41    /// this will panic if id returned is None, which shouldn't happen
42    pub async fn wallet_create_asset(
43        &self,
44        wallet_type: WalletType,
45        id: &str,
46        asset_id: impl Into<String>,
47        address: &str,
48    ) -> crate::Result<String> {
49        let asset_id = asset_id.into();
50        let id: String = match wallet_type {
51            WalletType::External => {
52                let api = self.api_client.whitelisted_external_wallets_api();
53                let params = AddAssetToExternalWalletParams::builder()
54                    .asset_id(asset_id)
55                    .wallet_id(String::from(id))
56                    .add_asset_to_external_wallet_request(
57                        AddAssetToExternalWalletRequest::BasicAddressRequest(BasicAddressRequest {
58                            address: String::from(address),
59                            tag: None,
60                        }),
61                    )
62                    .build();
63                api.add_asset_to_external_wallet(params)
64                    .await
65                    .map_err(|e| FireblocksError::FetchWalletCreateError(e.to_string()))?
66                    .id
67                    .unwrap_or_default()
68            }
69            WalletType::Internal => {
70                let api = self.api_client.whitelisted_internal_wallets_api();
71                let a = CreateInternalWalletAssetRequest::new(String::from(address));
72                let params = CreateInternalWalletAssetParams::builder()
73                    .asset_id(asset_id)
74                    .wallet_id(String::from(id))
75                    .create_internal_wallet_asset_request(a)
76                    .build();
77                api.create_internal_wallet_asset(params)
78                    .await
79                    .map_err(|e| FireblocksError::FetchWalletCreateError(e.to_string()))?
80                    .id
81                    .expect("id to be defined")
82            }
83            WalletType::Contract => {
84                let api = self.api_client.whitelisted_contracts_api();
85                let params = AddContractAssetParams::builder()
86                    .asset_id(asset_id)
87                    .contract_id(String::from(address))
88                    .build();
89                api.add_contract_asset(params)
90                    .await
91                    .map_err(|e| FireblocksError::FetchWalletCreateError(e.to_string()))?
92                    .id
93                    .unwrap_or_default()
94            }
95        };
96        Ok(id)
97    }
98
99    pub async fn wallet_delete(&self, wallet_type: WalletType, id: &str) -> crate::Result<()> {
100        match wallet_type {
101            WalletType::External => {
102                let api = self.api_client.whitelisted_external_wallets_api();
103                let params = DeleteExternalWalletParams::builder()
104                    .wallet_id(String::from(id))
105                    .build();
106                api.delete_external_wallet(params)
107                    .await
108                    .map_err(|e| FireblocksError::FetchWalletCreateError(e.to_string()))?;
109            }
110            WalletType::Internal => {
111                let api = self.api_client.whitelisted_internal_wallets_api();
112                let params = DeleteInternalWalletParams::builder()
113                    .wallet_id(String::from(id))
114                    .build();
115                api.delete_internal_wallet(params)
116                    .await
117                    .map_err(|e| FireblocksError::FetchWalletCreateError(e.to_string()))?;
118            }
119            WalletType::Contract => {
120                let api = self.api_client.whitelisted_contracts_api();
121                let params = DeleteContractParams::builder()
122                    .contract_id(String::from(id))
123                    .build();
124                api.delete_contract(params)
125                    .await
126                    .map_err(|e| FireblocksError::FetchWalletCreateError(e.to_string()))?;
127            }
128        }
129        Ok(())
130    }
131
132    pub async fn wallet_create(
133        &self,
134        wallet_type: WalletType,
135        name: &str,
136    ) -> crate::Result<String> {
137        let id: String = match wallet_type {
138            // TransferPeerPathType::Contract => String::new(),
139            WalletType::External => {
140                let api = self.api_client.whitelisted_external_wallets_api();
141                let params = CreateExternalWalletParams::builder()
142                    .create_wallet_request(CreateWalletRequest {
143                        name: Some(String::from(name)),
144                        customer_ref_id: None,
145                    })
146                    .build();
147                api.create_external_wallet(params)
148                    .await
149                    .map_err(|e| FireblocksError::FetchWalletCreateError(e.to_string()))?
150                    .id
151            }
152            WalletType::Internal => {
153                let api = self.api_client.whitelisted_internal_wallets_api();
154                let params = CreateInternalWalletParams::builder()
155                    .create_wallet_request(CreateWalletRequest {
156                        name: Some(String::from(name)),
157                        customer_ref_id: None,
158                    })
159                    .build();
160                api.create_internal_wallet(params)
161                    .await
162                    .map_err(|e| FireblocksError::FetchWalletCreateError(e.to_string()))?
163                    .id
164            }
165            WalletType::Contract => {
166                let api = self.api_client.whitelisted_contracts_api();
167                let params = CreateContractParams::builder()
168                    .create_contract_request(CreateContractRequest {
169                        name: Some(String::from(name)),
170                    })
171                    .build();
172                api.create_contract(params)
173                    .await
174                    .map_err(|e| FireblocksError::FetchWalletCreateError(e.to_string()))?
175                    .id
176            }
177        };
178        Ok(id)
179    }
180
181    pub async fn wallet_by_name(
182        &self,
183        wallet_type: WalletType,
184        name: &str,
185    ) -> crate::Result<Option<WalletContainer>> {
186        Ok(self
187            .wallets(wallet_type)
188            .await?
189            .into_iter()
190            .find(|w| w.name == name))
191    }
192
193    pub async fn wallet_by_id(
194        &self,
195        wallet_type: WalletType,
196        id: &str,
197    ) -> crate::Result<WalletContainer> {
198        let w: WalletContainer = match wallet_type {
199            WalletType::External => {
200                let w = self
201                    .wallet_external_api()
202                    .get_external_wallet(GetExternalWalletParams {
203                        wallet_id: String::from(id),
204                    })
205                    .await
206                    .map_err(|e| FireblocksError::FetchWalletError(e.to_string()))?;
207                WalletContainer::from(w)
208            }
209            WalletType::Internal => {
210                let w = self
211                    .wallet_internal_api()
212                    .get_internal_wallet(GetInternalWalletParams {
213                        wallet_id: String::from(id),
214                    })
215                    .await
216                    .map_err(|e| FireblocksError::FetchWalletError(e.to_string()))?;
217                WalletContainer::from(w)
218            }
219            WalletType::Contract => {
220                let w = self
221                    .wallet_contract_api()
222                    .get_contract(GetContractParams {
223                        contract_id: String::from(id),
224                    })
225                    .await
226                    .map_err(|e| FireblocksError::FetchWalletError(e.to_string()))?;
227                WalletContainer::from(w)
228            }
229        };
230        Ok(w)
231    }
232
233    pub async fn wallets(&self, wallet_type: WalletType) -> crate::Result<Vec<WalletContainer>> {
234        let wallets: Vec<WalletContainer> = match wallet_type {
235            WalletType::Internal => {
236                let api = self.api_client.whitelisted_internal_wallets_api();
237                let wallets = api
238                    .get_internal_wallets()
239                    .await
240                    .map_err(|e| FireblocksError::FetchWalletInternalError(e.to_string()))?;
241                wallets.into_iter().map(WalletContainer::from).collect()
242            }
243            WalletType::External => {
244                let api = self.api_client.whitelisted_external_wallets_api();
245                let wallets = api
246                    .get_external_wallets()
247                    .await
248                    .map_err(|e| FireblocksError::FetchWalletExternalError(e.to_string()))?;
249                wallets.into_iter().map(WalletContainer::from).collect()
250            }
251            WalletType::Contract => {
252                let api = self.api_client.whitelisted_contracts_api();
253                let wallets = api
254                    .get_contracts()
255                    .await
256                    .map_err(|e| FireblocksError::FetchWalletContractError(e.to_string()))?;
257                wallets.into_iter().map(WalletContainer::from).collect()
258            }
259        };
260        Ok(wallets)
261    }
262}
fireblocks_sdk/client/whitelist.rs

fireblocks_sdk/client/
whitelist.rs
