1#[cfg(target_arch = "wasm32")]
2use crate::{
3 types::{
4 digest::Digest,
5 era_id::EraId,
6 hash::{block_hash::BlockHash, transaction_hash::TransactionHash},
7 key::Key,
8 public_key::PublicKey,
9 record_id::RecordId,
10 sdk_error::SdkError,
11 transaction::Transaction,
12 },
13 SDK,
14};
15#[cfg(target_arch = "wasm32")]
16use gloo_utils::format::JsValueSerdeExt;
17#[cfg(target_arch = "wasm32")]
18use wasm_bindgen::prelude::*;
19
20#[cfg(target_arch = "wasm32")]
21#[wasm_bindgen]
22impl SDK {
23 #[wasm_bindgen(js_name = "get_binary_latest_switch_block_header")]
24 pub async fn get_binary_latest_switch_block_header_js_alias(
25 &self,
26 node_address: Option<String>,
27 ) -> Result<JsValue, JsError> {
28 let result = self
29 .get_binary_latest_switch_block_header(node_address)
30 .await;
31
32 result
33 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
34 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
35 }
36
37 #[wasm_bindgen(js_name = "get_binary_latest_block_header")]
38 pub async fn get_binary_latest_block_header_js_alias(
39 &self,
40 node_address: Option<String>,
41 ) -> Result<JsValue, JsError> {
42 let result = self.get_binary_latest_block_header(node_address).await;
43 result
44 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
45 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
46 }
47
48 #[wasm_bindgen(js_name = "get_binary_block_header_by_height")]
49 pub async fn get_binary_block_header_by_height_js_alias(
50 &self,
51 height: u64,
52 node_address: Option<String>,
53 ) -> Result<JsValue, JsError> {
54 let result = self
55 .get_binary_block_header_by_height(node_address, height)
56 .await;
57 result
58 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
59 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
60 }
61
62 #[wasm_bindgen(js_name = "get_binary_block_header_by_hash")]
63 pub async fn get_binary_block_header_by_hash_js_alias(
64 &self,
65 block_hash: BlockHash,
66 node_address: Option<String>,
67 ) -> Result<JsValue, JsError> {
68 let result = self
69 .get_binary_block_header_by_hash(node_address, block_hash.into())
70 .await;
71 result
72 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
73 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
74 }
75
76 #[wasm_bindgen(js_name = "get_binary_latest_block_with_signatures")]
77 pub async fn get_binary_latest_block_with_signatures_js_alias(
78 &self,
79 node_address: Option<String>,
80 ) -> Result<JsValue, JsError> {
81 let result = self
82 .get_binary_latest_block_with_signatures(node_address)
83 .await;
84 result
85 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
86 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
87 }
88
89 #[wasm_bindgen(js_name = "get_binary_block_with_signatures_by_height")]
90 pub async fn get_binary_block_with_signatures_by_height_js_alias(
91 &self,
92 height: u64,
93 node_address: Option<String>,
94 ) -> Result<JsValue, JsError> {
95 let result = self
96 .get_binary_block_with_signatures_by_height(node_address, height)
97 .await;
98 result
99 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
100 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
101 }
102
103 #[wasm_bindgen(js_name = "get_binary_block_with_signatures_by_hash")]
104 pub async fn get_binary_block_with_signatures_by_hash_js_alias(
105 &self,
106 block_hash: BlockHash,
107 node_address: Option<String>,
108 ) -> Result<JsValue, JsError> {
109 let result = self
110 .get_binary_block_with_signatures_by_hash(node_address, block_hash.into())
111 .await;
112 result
113 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
114 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
115 }
116
117 #[wasm_bindgen(js_name = "get_binary_transaction_by_hash")]
118 pub async fn get_binary_transaction_by_hash_js_alias(
119 &self,
120 hash: TransactionHash,
121 with_finalized_approvals: bool,
122 node_address: Option<String>,
123 ) -> Result<JsValue, JsError> {
124 let result = self
125 .get_binary_transaction_by_hash(node_address, hash.into(), with_finalized_approvals)
126 .await;
127 result
128 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
129 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
130 }
131
132 #[wasm_bindgen(js_name = "get_binary_peers")]
133 pub async fn get_binary_peers_js_alias(
134 &self,
135 node_address: Option<String>,
136 ) -> Result<JsValue, JsError> {
137 let result = self.get_binary_peers(node_address).await;
138 result
139 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
140 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
141 }
142
143 #[wasm_bindgen(js_name = "get_binary_uptime")]
144 pub async fn get_binary_uptime_js_alias(
145 &self,
146 node_address: Option<String>,
147 ) -> Result<JsValue, JsError> {
148 let result = self.get_binary_uptime(node_address).await;
149 result
150 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
151 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
152 }
153
154 #[wasm_bindgen(js_name = "get_binary_last_progress")]
155 pub async fn get_binary_last_progress_js_alias(
156 &self,
157 node_address: Option<String>,
158 ) -> Result<JsValue, JsError> {
159 let result = self.get_binary_last_progress(node_address).await;
160 result
161 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
162 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
163 }
164
165 #[wasm_bindgen(js_name = "get_binary_reactor_state")]
166 pub async fn get_binary_reactor_state_js_alias(
167 &self,
168 node_address: Option<String>,
169 ) -> Result<JsValue, JsError> {
170 let result = self.get_binary_reactor_state(node_address).await;
171 result
172 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
173 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
174 }
175
176 #[wasm_bindgen(js_name = "get_binary_network_name")]
177 pub async fn get_binary_network_name_js_alias(
178 &self,
179 node_address: Option<String>,
180 ) -> Result<JsValue, JsError> {
181 let result = self.get_binary_network_name(node_address).await;
182 result
183 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
184 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
185 }
186
187 #[wasm_bindgen(js_name = "get_binary_consensus_validator_changes")]
188 pub async fn get_binary_consensus_validator_changes_js_alias(
189 &self,
190 node_address: Option<String>,
191 ) -> Result<JsValue, JsError> {
192 let result = self
193 .get_binary_consensus_validator_changes(node_address)
194 .await;
195 result
196 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
197 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
198 }
199
200 #[wasm_bindgen(js_name = "get_binary_block_synchronizer_status")]
201 pub async fn get_binary_block_synchronizer_status_js_alias(
202 &self,
203 node_address: Option<String>,
204 ) -> Result<JsValue, JsError> {
205 let result = self
206 .get_binary_block_synchronizer_status(node_address)
207 .await;
208 result
209 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
210 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
211 }
212
213 #[wasm_bindgen(js_name = "get_binary_available_block_range")]
214 pub async fn get_binary_available_block_range_js_alias(
215 &self,
216 node_address: Option<String>,
217 ) -> Result<JsValue, JsError> {
218 let result = self.get_binary_available_block_range(node_address).await;
219 result
220 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
221 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
222 }
223
224 #[wasm_bindgen(js_name = "get_binary_next_upgrade")]
225 pub async fn get_binary_next_upgrade_js_alias(
226 &self,
227 node_address: Option<String>,
228 ) -> Result<JsValue, JsError> {
229 let result = self.get_binary_next_upgrade(node_address).await;
230 result
231 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
232 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
233 }
234
235 #[wasm_bindgen(js_name = "get_binary_consensus_status")]
236 pub async fn get_binary_consensus_status_js_alias(
237 &self,
238 node_address: Option<String>,
239 ) -> Result<JsValue, JsError> {
240 let result = self.get_binary_consensus_status(node_address).await;
241 result
242 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
243 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
244 }
245
246 #[wasm_bindgen(js_name = "get_binary_chainspec_raw_bytes")]
247 pub async fn get_binary_chainspec_raw_bytes_js_alias(
248 &self,
249 node_address: Option<String>,
250 ) -> Result<JsValue, JsError> {
251 let result = self.get_binary_chainspec_raw_bytes(node_address).await;
252 result
253 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
254 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
255 }
256
257 #[wasm_bindgen(js_name = "get_binary_node_status")]
258 pub async fn get_binary_node_status_js_alias(
259 &self,
260 node_address: Option<String>,
261 ) -> Result<JsValue, JsError> {
262 let result = self.get_binary_node_status(node_address).await;
263 result
264 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
265 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
266 }
267
268 #[wasm_bindgen(js_name = "get_binary_validator_reward_by_era")]
269 pub async fn get_binary_validator_reward_by_era_js_alias(
270 &self,
271 validator_key: PublicKey,
272 era: EraId,
273 node_address: Option<String>,
274 ) -> Result<JsValue, JsError> {
275 let result = self
276 .get_binary_validator_reward_by_era(node_address, validator_key.into(), era.into())
277 .await;
278 result
279 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
280 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
281 }
282
283 #[wasm_bindgen(js_name = "get_binary_validator_reward_by_block_height")]
284 pub async fn get_binary_validator_reward_by_block_height_js_alias(
285 &self,
286 validator_key: PublicKey,
287 block_height: u64,
288 node_address: Option<String>,
289 ) -> Result<JsValue, JsError> {
290 let result = self
291 .get_binary_validator_reward_by_block_height(
292 node_address,
293 validator_key.into(),
294 block_height,
295 )
296 .await;
297 result
298 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
299 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
300 }
301
302 #[wasm_bindgen(js_name = "get_binary_validator_reward_by_block_hash")]
303 pub async fn get_binary_validator_reward_by_block_hash_js_alias(
304 &self,
305 validator_key: PublicKey,
306 block_hash: BlockHash,
307 node_address: Option<String>,
308 ) -> Result<JsValue, JsError> {
309 let result = self
310 .get_binary_validator_reward_by_block_hash(
311 node_address,
312 validator_key.into(),
313 block_hash.into(),
314 )
315 .await;
316 result
317 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
318 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
319 }
320
321 #[wasm_bindgen(js_name = "get_binary_delegator_reward_by_era")]
322 pub async fn get_binary_delegator_reward_by_era_js_alias(
323 &self,
324 validator_key: PublicKey,
325 delegator_key: PublicKey,
326 era: EraId,
327 node_address: Option<String>,
328 ) -> Result<JsValue, JsError> {
329 let result = self
330 .get_binary_delegator_reward_by_era(
331 node_address,
332 validator_key.into(),
333 delegator_key.into(),
334 era.into(),
335 )
336 .await;
337 result
338 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
339 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
340 }
341
342 #[wasm_bindgen(js_name = "get_binary_delegator_reward_by_block_height")]
343 pub async fn get_binary_delegator_reward_by_block_height_js_alias(
344 &self,
345 validator_key: PublicKey,
346 delegator_key: PublicKey,
347 block_height: u64,
348 node_address: Option<String>,
349 ) -> Result<JsValue, JsError> {
350 let result = self
351 .get_binary_delegator_reward_by_block_height(
352 node_address,
353 validator_key.into(),
354 delegator_key.into(),
355 block_height,
356 )
357 .await;
358 result
359 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
360 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
361 }
362
363 #[wasm_bindgen(js_name = "get_binary_delegator_reward_by_block_hash")]
364 pub async fn get_binary_delegator_reward_by_block_hash_js_alias(
365 &self,
366 validator_key: PublicKey,
367 delegator_key: PublicKey,
368 block_hash: BlockHash,
369 node_address: Option<String>,
370 ) -> Result<JsValue, JsError> {
371 let result = self
372 .get_binary_delegator_reward_by_block_hash(
373 node_address,
374 validator_key.into(),
375 delegator_key.into(),
376 block_hash.into(),
377 )
378 .await;
379 result
380 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
381 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
382 }
383
384 #[wasm_bindgen(js_name = "get_binary_read_record")]
385 pub async fn get_binary_read_record_js_alias(
386 &self,
387 record_id: RecordId,
388 key: Vec<u8>,
389 node_address: Option<String>,
390 ) -> Result<JsValue, JsError> {
391 let result = self
392 .get_binary_read_record(node_address, record_id.into(), &key)
393 .await;
394 result
395 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
396 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
397 }
398
399 #[wasm_bindgen(js_name = "get_binary_global_state_item")]
400 pub async fn get_binary_global_state_item_js_alias(
401 &self,
402 key: Key,
403 path: Vec<String>,
404 node_address: Option<String>,
405 ) -> Result<JsValue, JsError> {
406 let result = self
407 .get_binary_global_state_item(node_address, key.into(), path)
408 .await;
409 result
410 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
411 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
412 }
413
414 #[wasm_bindgen(js_name = "get_binary_global_state_item_by_state_root_hash")]
415 pub async fn get_binary_global_state_item_by_state_root_hash_js_alias(
416 &self,
417 state_root_hash: Digest,
418 key: Key,
419 path: Vec<String>,
420 node_address: Option<String>,
421 ) -> Result<JsValue, JsError> {
422 let result = self
423 .get_binary_global_state_item_by_state_root_hash(
424 node_address,
425 state_root_hash.into(),
426 key.into(),
427 path,
428 )
429 .await;
430 result
431 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
432 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
433 }
434
435 #[wasm_bindgen(js_name = "get_binary_global_state_item_by_block_hash")]
436 pub async fn get_binary_global_state_item_by_block_hash_js_alias(
437 &self,
438 block_hash: BlockHash,
439 key: Key,
440 path: Vec<String>,
441 node_address: Option<String>,
442 ) -> Result<JsValue, JsError> {
443 let result = self
444 .get_binary_global_state_item_by_block_hash(
445 node_address,
446 block_hash.into(),
447 key.into(),
448 path,
449 )
450 .await;
451 result
452 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
453 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
454 }
455
456 #[wasm_bindgen(js_name = "get_binary_global_state_item_by_block_height")]
457 pub async fn get_binary_global_state_item_by_block_height_js_alias(
458 &self,
459 block_height: u64,
460 key: Key,
461 path: Vec<String>,
462 node_address: Option<String>,
463 ) -> Result<JsValue, JsError> {
464 let result = self
465 .get_binary_global_state_item_by_block_height(
466 node_address,
467 block_height,
468 key.into(),
469 path,
470 )
471 .await;
472 result
473 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
474 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
475 }
476
477 #[wasm_bindgen(js_name = "get_binary_try_accept_transaction")]
478 pub async fn get_binary_try_accept_transaction_js_alias(
479 &self,
480 transaction: Transaction,
481 node_address: Option<String>,
482 ) -> Result<JsValue, JsError> {
483 let result = self
484 .get_binary_try_accept_transaction(node_address, transaction.into())
485 .await;
486
487 match result {
488 Ok(_) => Ok(JsValue::undefined()), Err(err) => Err(JsError::new(&format!("Error occurred: {:?}", err))),
490 }
491 }
492
493 #[wasm_bindgen(js_name = "get_binary_try_speculative_execution")]
494 pub async fn get_binary_try_speculative_execution_js_alias(
495 &self,
496 transaction: Transaction,
497 node_address: Option<String>,
498 ) -> Result<JsValue, JsError> {
499 let result = self
500 .get_binary_try_speculative_execution(node_address, transaction.into())
501 .await;
502 result
503 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
504 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
505 }
506
507 #[wasm_bindgen(js_name = "get_binary_protocol_version")]
508 pub async fn get_binary_protocol_version_js_alias(
509 &self,
510 node_address: Option<String>,
511 ) -> Result<JsValue, JsError> {
512 let result = self.get_binary_protocol_version(node_address).await;
513 result
514 .and_then(|data| JsValue::from_serde(&data).map_err(SdkError::SerializationError))
515 .map_err(|err| JsError::new(&format!("Error occurred: {:?}", err)))
516 }
517}